text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Сервлеты и Reflection
Совсем недавно, в статье [Сервлеты — маленький трюк с Reflection](http://habrahabr.ru/blogs/java/119648/), разбирался прием, с помощью которого можно получить url вида:
`host/servletName/methodName.`
Если пойти дальше, то с помощью Reflection можно реализовать конструкцию следующего вида:
Где, у нас в проекте есть несколько классов контроллеров, и у каждого из них свои действия. А самое главное, в методы контроллеров мы можем передавать параметры из URI. Например:
`host/servletName/projects/add?title=hello`
#### Контроллеры
Сначала разберёмся с сервлетом. У нас есть все тот же класс BaseServlet, наследуемый от HttpServlet.
```
package projectManagment;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import projectManagment.controllers.Controller;
public class BaseServlet extends HttpServlet {
private ControllerFactory factory;
public BaseServlet () {
super();
factory = new ControllerFactory();
}
@Override
protected void service(HttpServletRequest request, HttpServletResponse response) {
try {
String name = getControllerName(request);
if (name == null)
name = "index";
Controller controller = factory.create(name);
Controller.setHttp(request, response, getServletContext());
String method = getMethodName(request);
if (method == null)
method = "index";
callMethod(controller, method, request, response);
} catch (Exception e) {
System.out.println("Error: " + e.getMessage());
e.printStackTrace();
}
}
public String getControllerName (HttpServletRequest request) {
String path = request.getRequestURI().substring(request.getContextPath().length());
if (path == null || "".equals(path) || "/".equals(path))
return null;
String controller = path.substring(1, path.lastIndexOf("/"));
if (controller != null && !"".equals(controller))
return controller;
return null;
}
private String getMethodName (HttpServletRequest request) {
String method = request.getRequestURI().substring(request.getContextPath().length());
if (method != null && !"".equals(method) && !"/".equals(method))
return method.substring(method.lastIndexOf("/") + 1, method.length() );
return null;
}
private void callMethod (Controller controller, String methodName,
HttpServletRequest request, HttpServletResponse response) throws
IllegalArgumentException, SecurityException,
IllegalAccessException, InvocationTargetException,
NoSuchMethodException {
for (Method method : controller.getClass().getMethods()) {
if (method.getName().equalsIgnoreCase(methodName)) {
controller.getClass().getMethod(methodName, method.getParameterTypes()).invoke(controller);
}
}
}
}
```
Самое интересное происходит в методе service. Сначала мы получаем имя контроллера с помощью вспомогательного метода getControllerName, где парсится URI. После мы используем ControllerFactory – фабрику контроллеров, которая создает объект нужного нам класса контроллера. Код ControllerFactory очень прост:
```
package projectManagment;
import java.util.HashMap;
import java.util.Map;
import projectManagment.controllers.*;
public class ControllerFactory {
public ControllerFactory() {
map = defaultMap();
}
public Controller create (String controllerName) {
Class ControllerClass = (Class) map.get(controllerName);
if (ControllerClass == null)
throw new RuntimeException(getClass() + " was unable to find an controller named '" + controllerName + "'.");
Controller controllerInstance = null;
try {
controllerInstance = (Controller) ControllerClass.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return controllerInstance;
}
protected Map> defaultMap() {
Map> map = new HashMap>();
map.put("index", Index.class);
return map;
}
protected Map> map;
}
```
Остается разобраться с вызовом метода. Для начала получаем его имя с помощью getMethodName, а дальше передаем необходимые параметры в callMethod. Тут происходит поиск подходящего метода в контроллере, а после его вызов.
Все контроллеры, которые мы хотим использовать должны быть прописаны в методе defaultMap у ControllerFactory.
Перейдем к базовому классу контроллера.
```
package projectManagment.controllers;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class Controller {
static protected HttpServletResponse response;
static protected HttpServletRequest request;
static protected ServletContext context;
public Controller () {
request = null;
response = null;
context = null;
}
static public void setHttp (HttpServletRequest req, HttpServletResponse res, ServletContext con) {
request = req;
response = res;
context = con;
}
}
```
Метод setHttp позволяет нам научить разговаривать наш контроллер. Сюда же можно добавить методы для авторизации, редиректа и т.д.
Теперь сделаем тестовый контроллер под именем Index. В нем будут два метода index и show.
```
package projectManagment.controllers;
public class Index extends Controller {
public static void index () {
System.out.println("Index method");
}
public static void show () {
String value = request.getParameter("name");
System.out.println("Hello " + value);
}
}
```
Не забываем настроить mapping в web.xml следующим образом:
```
xml version="1.0" encoding="UTF-8"?
Demo
projectManagment.BaseServlet
Demo
/
```
Протестируем наш сервлет. По запросу /host/demo/ мы увидим в консоли строку “Index method”, а по запросу /host/demo/index/show?name=Anton — “Hello Anton”.
#### Передача параметров в метод
Для парсинга параметров из URI в методах приходится использовать конструкцию вида:
```
String strValue = request.getParametr("intParamName");
Integer value = Intger.parseInt(strValue);
```
Совершать такие простые действия по многу раз довольно нудно, да и красота кода страдает. Проблему парсинга параметров можно решить, передовая их как параметры к методу. Для этого нужно использовать аннотации.
```
package projectManagment.controllers;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
@Retention(RetentionPolicy.RUNTIME)
public @interface Param {
String name();
}
```
Метод show теперь выглядит следующим образом:
```
public static void show (@Param(name = "name") String name, @Param(name = "age") Integer age) {
System.out.println("Hello " + name + ", you are " + age + " years old");
}
```
Это еще не все, необходимо в методе callMethod передавать параметры из URI в вызываемый метод.
```
private void callMethod(Controller controller, String methodName,
HttpServletRequest request, HttpServletResponse response) throws
NoSuchMethodException, RuntimeException,
SecurityException, IllegalAccessException,
InvocationTargetException {
for (Method method : controller.getClass().getMethods()) {
if (method.getName().equalsIgnoreCase(methodName)) {
Object[] params = new Object[method.getParameterTypes().length];
Annotation[][] parameterAnnotations = method.getParameterAnnotations();
Class[] parameterTypes = method.getParameterTypes();
int i = 0;
for(Annotation[] annotations : parameterAnnotations){
Class parameterType = parameterTypes[i];
for(Annotation annotation : annotations){
if(annotation instanceof Param){
Param myAnnotation = (Param) annotation;
Object value = null;
if (parameterType.getSimpleName().equals("Integer")) {
try {
value = Integer.parseInt(request.getParameter(myAnnotation.name()));
} catch (NumberFormatException e) {
value = null;
}
}
else {
value = request.getParameter(myAnnotation.name());
}
params[i++] = value;
System.out.println("param: " + parameterType.getSimpleName());
System.out.println("name : " + myAnnotation.name());
System.out.println("value: " + value);
}
}
}
controller.getClass().getMethod(method.getName(), method.getParameterTypes()).invoke(controller, params);
}
}
}
```
Теперь на запрос /host/demo/index/show?name=Anton&age=20, консоль выводит “Hello Anton, you are 20 years old”. | https://habr.com/ru/post/120715/ | null | ru | null |
# Обучение с подкреплением для самых маленьких
*В данной статье разобран принцип работы метода машинного обучения[«Обучение с подкреплением»](https://ru.wikipedia.org/wiki/Обучение_с_подкреплением) на примере физической системы. Алгоритм поиска оптимальной стратегии реализован в коде на Python с помощью метода [«Q-Learning»](https://ru.wikipedia.org/wiki/Q-обучение).*
Обучение с подкреплением — это метод машинного обучения, при котором происходит обучение модели, которая не имеет сведений о системе, но имеет возможность производить какие-либо действия в ней. Действия переводят систему в новое состояние и модель получает от системы некоторое вознаграждение. Рассмотрим работу метода на [примере](https://www.youtube.com/watch?v=f2nIKFMyfSg), показанном в видео. В описании к видео находится код для [Arduino](https://drive.google.com/file/d/0Bwyt-Hm2ItvRc0laTFhFNWFQdTg/view?pli=1), который реализуем на [Python](https://github.com/MichaelSwanRu/Reinforcement-Learning/blob/master/Q-Learning/Example-and-Tutorial/Q-LEARNING.py).
### Задача
С помощью метода «обучение с подкреплением» необходимо научить тележку отъезжать от стены на максимальное расстояние. Награда представлена в виде значения изменения расстояния от стены до тележки при движении. Измерение расстояния D от стены производится дальномером. Движение в данном примере возможно только при определенном смещении «привода», состоящего из двух стрел S1 и S2. Стрелы представляют собой два сервопривода с направляющими, соединенными в виде «колена». Каждый сервопривод в данном примере может поворачиваться на 6 одинаковых углов. Модель имеет возможность совершить 4 действия, которые представляют собой управление двумя сервоприводами, действие 0 и 1 поворачивают первый сервопривод на определенный угол по часовой и против часовой стрелке, действие 2 и 3 поворачивают второй сервопривод на определенный угол по часовой и против часовой стрелке. На рисунке 1 показан рабочий прототип тележки.
*Рис. 1. Прототип тележки для экспериментов с машинным обучением*
На рисунке 2 красным цветом выделена стрела S2, синим цветом – стрела S1, черным цветом – 2 сервопривода.
*Рис. 2. Двигатель системы*
Схема системы показана на рисунке 3. Расстояние до стены обозначено D, желтым показан дальномер, красным и черным выделен привод системы.
*Рис. 3. Схема системы*
Диапазон возможных положений для S1 и S2 показан на рисунке 4:
*Рис. 4.а. Диапазон положений стрелы S1*
*Рис. 4.б. Диапазон положений стрелы S2*
Пограничные положения привода показаны на рисунке 5:
При S1 = S2 = 5 максимальная дальность от земли.
При S1 = S2 = 0 минимальная дальность до земли.
*Рис. 5. Пограничные положения стрел S1 и S2*
У «привода» 4 степени свободы. Действие (action) изменяет положение стрел S1 и S2 в пространстве по определённому принципу. Виды действий показаны на рисунке 6.
*Рис. 6. Виды действий (Action) в системе*
Действие 0 увеличивает значение S1. Действие 1 уменьшает значение S1.
Действие 2 увеличивает значение S2. Действие 3 уменьшает значение S2.
### Движение
В нашей задаче тележка приводится в движение всего в 2х случаях:
В положении S1 =0, S2 = 1 действие 3 приводит в движение тележку от стены, система получает положительное вознаграждение, равное изменению расстояния до стены. В нашем примере вознаграждение равно 1.
*Рис. 7. Движение системы с положительным вознаграждением*
В положении S1 = 0, S2 = 0 действие 2 приводит в движение тележку к стене, система получает отрицательное вознаграждение, равное изменению расстояния до стены. В нашем примере вознаграждение равно -1.
*Рис. 8. Движение системы с отрицательным вознаграждением*
При остальных состояниях и любых действиях «привода» система будет стоять на месте и вознаграждение будет равно 0.
Хочется отметить, что стабильным динамическим состоянием системы будет последовательность действий 0-2-1-3 из состояния S1=S2=0, в котором тележка будет двигаться в положительном направлении при минимальном количестве затраченных действий. Подняли колено – разогнули колено – опустили колено – согнули колено = тележка сдвинулась вперед, повтор. Таким образом, с помощью метода машинного обучения необходимо найти такое состояние системы, такую определенную последовательность действий, награда за которые будет получена не сразу (действия 0-2-1 – награда за которые равна 0, но которые необходимы для получения 1 за последующее действие 3).
### Метод Q-Learning
Основой метода Q-Learning является матрица весов состояния системы. Матрица Q представляет собой совокупность всевозможных состояний системы и весов реакции системы на различные действия.
В данной задаче возможных комбинаций параметров системы 36 = 6^2. В каждом из 36 состояний системы возможно произвести 4 различных действия (Action = 0,1,2,3).
На рисунке 9 показано первоначальное состояние матрицы Q. Нулевая колонка содержит индекс строки, первая строка – значение S1, вторая – значение S2, последние 4 колонки равны весам при действиях равных 0, 1, 2 и 3. Каждая строка представляет собой уникальное состояние системы.
При инициализации таблицы все значения весов приравняем 10.
*Рис. 9. Инициализация матрицы Q*
После обучения модели (~15000 итераций) матрица Q имеет вид, показанный на рисунке 10.
*Рис. 10. Матрица Q после 15000 итераций обучения*
Обратите внимание, действия с весами, равными 10, невозможны в системе, поэтому значение весов не изменилось. Например, в крайнем положении при S1=S2=0 нельзя выполнить действие 1 и 3, так как это ограничение физической среды. Эти пограничные действия запрещены в нашей модели, поэтому 10тки алгоритм не использует.
Рассмотрим результат работы алгоритма:
…
Iteration: 14991, was: S1=0 S2=0, action= 0, now: S1=1 S2=0, prize: 0
Iteration: 14992, was: S1=1 S2=0, action= 2, now: S1=1 S2=1, prize: 0
Iteration: 14993, was: S1=1 S2=1, action= 1, now: S1=0 S2=1, prize: 0
Iteration: 14994, was: S1=0 S2=1, action= 3, now: S1=0 S2=0, prize: 1
Iteration: 14995, was: S1=0 S2=0, action= 0, now: S1=1 S2=0, prize: 0
Iteration: 14996, was: S1=1 S2=0, action= 2, now: S1=1 S2=1, prize: 0
Iteration: 14997, was: S1=1 S2=1, action= 1, now: S1=0 S2=1, prize: 0
Iteration: 14998, was: S1=0 S2=1, action= 3, now: S1=0 S2=0, prize: 1
Iteration: 14999, was: S1=0 S2=0, action= 0, now: S1=1 S2=0, prize: 0
Рассмотрим подробнее:
Возьмем итерацию 14991 в качестве текущего состояния.
1. Текущее состояние системы S1=S2=0, этому состоянию соответствует строка с индексом 0. Наибольшим значением является 0.617 (значения равные 10 игнорируем, описано выше), оно соответствует Action = 0. Значит, согласно матрице Q при состоянии системы S1=S2=0 мы производим действие 0. Действие 0 увеличивает значение угла поворота сервопривода S1 (S1 = 1).
2. Следующему состоянию S1=1, S2=0 соответствует строка с индексом 6. Максимальное значение веса соответствует Action = 2. Производим действие 2 – увеличение S2 (S2 = 1).
3. Следующему состоянию S1=1, S2=1 соответствует строка с индексом 7. Максимальное значение веса соответствует Action = 1. Производим действие 1 – уменьшение S1 (S1 = 0).
4. Следующему состоянию S1=0, S2=1 соответствует строка с индексом 1. Максимальное значение веса соответствует Action = 3. Производим действие 3 – уменьшение S2 (S2 = 0).
5. В итоге вернулись в состояние S1=S2=0 и заработали 1 очко вознаграждения.
На рисунке 11 показан принцип выбор оптимального действия.
*Рис. 11.а. Матрица Q*
*Рис. 11.б. Матрица Q*
**Рассмотрим подробнее процесс обучения.**
**Алгоритм Q-learning**
```
minus = 0;
plus = 0;
initializeQ();
for t in range(1,15000):
epsilon = math.exp(-float(t)/explorationConst);
s01 = s1; s02 = s2
current_action = getAction();
setSPrime(current_action);
setPhysicalState(current_action);
r = getDeltaDistanceRolled();
lookAheadValue = getLookAhead();
sample = r + gamma*lookAheadValue;
if t > 14900:
print 'Time: %(0)d, was: %(1)d %(2)d, action: %(3)d, now: %(4)d %(5)d, prize: %(6)d ' % \
{"0": t, "1": s01, "2": s02, "3": current_action, "4": s1, "5": s2, "6": r}
Q.iloc[s, current_action] = Q.iloc[s, current_action] + alpha*(sample - Q.iloc[s, current_action] ) ;
s = sPrime;
if deltaDistance == 1:
plus += 1;
if deltaDistance == -1:
minus += 1;
print( minus, plus )
```
Полный код на [GitHub](https://github.com/MichaelSwanRu/Reinforcement-Learning/blob/master/Q-Learning/Example-and-Tutorial/Q-LEARNING.py).
Установим начальное положение колена в крайнее верхнее положение:
```
s1=s2=5.
```
Инициализируем матрицу Q, заполнив начальным значением:
```
initializeQ();
```
Вычислим параметр *epsilon*. Это вес «случайности» действия алгоритма в нашем расчёте. Чем больше итераций обучения прошло, тем меньше случайных значений действий будут выбраны:
```
epsilon = math.exp(-float(t)/explorationConst)
```
Для первой итерации:
```
epsilon = 0.996672
```
Сохраним текущее состояние:
```
s01 = s1; s02 = s2
```
Получим «лучшее» значение действия:
```
current_action = getAction();
```
Рассмотрим функцию поподробнее.
Функция getAction() выдает значение действия, которому соответствует максимальный вес при текущем состоянии системы. Берется текущее состояние системы в матрице Q и выбирается действие, которому соответствует максимальный вес. Обратим внимание, что в этой функции реализован механизм выбора случайного действия. С увеличением числа итераций случайный выбор действия уменьшается. Это сделано, для того, чтобы алгоритм не зацикливался на первых найденных вариантах и мог пойти по другому пути, который может оказаться лучше.
В исходном начальном положении стрел возможны только два действия 1 и 3. Алгоритм выбрал действие 1.
Далее определим номер строки в матрице Q для следующего состояние системы, в которое система перейдет после выполнения действия, которое мы получили в предыдущем шаге.
```
setSPrime(current_action);
```
В реальной физической среде после выполнения действия мы получили бы вознаграждение, если последовало движение, но так как движение тележки моделируется, необходимо ввести вспомогательные функции эмуляции реакции физической среды на действия. (setPhysicalState и getDeltaDistanceRolled() )
Выполним функции:
```
setPhysicalState(current_action);
```
— моделируем реакцию среды на выбранное нами действие. Изменяем положение сервоприводов, смещаем тележку.
```
r = getDeltaDistanceRolled();
```
— Вычисляем вознаграждение – расстояние, пройденное тележкой.
После выполнения действия нам необходимо обновить коэффициент этого действия в матрице Q для соответствующего состояния системы. Логично, что, если действие привело к положительной награде, то коэффициент, в нашем алгоритме, должен уменьшиться на меньшее значение, чем при отрицательном вознаграждении.
Теперь самое интересное – для расчета веса текущего шага заглянем в будущее.
При определении оптимального действия, которое нужно совершить в текущем состоянии, мы выбираем наибольший вес в матрице Q. Так как мы знаем новое состояние системы, в которое мы перешли, то можем найти максимальное значение веса из таблицы Q для этого состояния:
```
lookAheadValue = getLookAhead();
```
В самом начале оно равно 10. И используем значение веса, еще не выполненного действия, для подсчета текущего веса.
```
sample = r + gamma*lookAheadValue;
sample = 7.5
Q.iloc[s, current_action] = Q.iloc[s, current_action] + alpha*(sample - Q.iloc[s, current_action] ) ;
Q.iloc[s, current_action] = 9.75
```
Т.е. мы использовали значение веса следующего шага, для расчета веса шага текущего. Чем больше вес следующего шага, тем меньше мы уменьшим вес текущего (согласно формуле), и тем текущий шаг будет предпочтительнее в следующий раз.
Этот простой трюк дает хорошие результаты сходимости алгоритма.
### Масштабирование алгоритма
Данный алгоритм можно расширить на большее количество степеней свободы системы (s\_features), и большее количество значений, которые принимает степень свободы (s\_states), но в небольших пределах. Достаточно быстро матрица Q займет всю оперативную память. Ниже пример кода построения сводной матрицы состояний и весов модели. При количестве «стрел» s\_features = 5 и количестве различных положений стрелы s\_states = 10 матрица Q имеет размеры (100000, 9).
**Увеличение степеней свободы системы**
```
import numpy as np
s_features = 5
s_states = 10
numActions = 4
data = np.empty((s_states**s_features, s_features + numActions), dtype='int')
for h in range(0, s_features):
k = 0
N = s_states**(s_features-1-1*h)
for q in range(0, s_states**h):
for i in range(0, s_states):
for j in range(0, N):
data[k, h] = i
k += 1
for i in range(s_states**s_features):
for j in range(numActions):
data[i,j+s_features] = 10.0;
data.shape
# (100000L, 9L)
```
### Вывод
Этот простой метод показывает «чудеса» машинного обучения, когда модель ничего не зная об окружающей среде обучается и находит оптимальное состояние, при котором награда за действия максимальна, причем награда присуждается не сразу, за какое либо действие, а за последовательность действий.
Спасибо за внимание! | https://habr.com/ru/post/308094/ | null | ru | null |
# Кастомизация radiobutton без JS
Однажды, у меня возникла задача, сделать на форме сайта выбор одного из нескольких цветов. Казалось бы, нет ничего проще. Элемент `radiobutton`, как нельзя лучше, подходит для этой задачи, нужно только чуть-чуть его кастомизировать. Тут-то и начинаются проблемы. Дело в том, что отрисовкой элементов `radiobutton` и `checkbutton` управляет не браузер, а ОС. Соответственно, большинство свойств CSS (например, `background-color`) на них не действует.
В интернете я нашел множество способов кастомизации `radiobutton`, но все они показались мне слишком сложными, поэтому я решил придумать свой.
Моя идея основана на том факте, что когда пользователь кликает по подписи `label`, `radiobutton` переключается. Значит можно кастомизировать не `radiobutton`, а `label`.
Рассмотрим пример кода HTML:
```
```
Здесь нет ничего необычного. Обычные `radiobutton` и подписи к ним.
Теперь CSS:
```
// скрываем radiobutton
input[type="radio"]{display: none;}
// кастомизируем label
label{
width: 20px;
height: 20px;
}
label.blue{background-color: blue;}
label.cyan{background-color: #00ffff;}
// Для выбранного объекта
input[type="radio"]:checked+label{
border: black solid 2px;
}
```
Здесь мы скрываем `radiobutton` и рисуем, как нам хочется `label`. Рисуем `label` для отмеченного состояния `input[type="radio"]:checked+label`. Всё просто и элегантно.
На этом можно было бы закончить пост, если бы не одно «но».
###### Пара гнилых помидоров в сторону Apple
Мир был бы хорош и прекрасен, если бы в нём не было одной корпорации у которой особый путь развития. Это корпорация Apple, которая отказывает своим пользователям в праве тыкать по `label`. В следствии чего, мой способ не работает на iPhone и iPad. Самое интересное, что Safari на Windows пережевывает всё правильно. К сожалению не было под рукой ни одного iMac, чтобы проверить.
Специально для хипстеров пришлось таки применить JS (код рассчитан на использование в связке с jQuery):
```
var deviceAgent = navigator.userAgent.toLowerCase();
var iOS = deviceAgent.match(/(iphone|ipod|ipad)/);
if (iOS) {
$('label').click(function (event) {
$('#' + $(event.target).attr('for')).attr('checked', true).change();
});
}
```
###### Пример использования
[Long Twit](http://lngtw.com) — простой сервис, который рендерит текст в картинку и отправляет в Twitter. Можно выбрать цвет текста и фона. | https://habr.com/ru/post/150760/ | null | ru | null |
# Строим отчеты и анализируем групповые политики с помощью PowerShell
Тема использования PowerShell для администрирования крайне актуальна, и на Хабре появляется все больше и больше статей на эту тему. Предыдущий [перевод статьи](http://habrahabr.ru/company/netwrix/blog/160837/) Джеффри Хикса, который мы опубликовали в прошлую пятницу, вызвал волну интереса. И как тут не вспомнить замечательное выступление того же автора на TechEd North America 2012. Доклад, который Джеффри Хикс проводил вместе с Джереми Московицем (Jeremy Moskowitz), был посвящен анализу объектов групповых политик и формированию отчетов. Оригинальный материал (видео) [здесь](http://channel9.msdn.com/Events/TechEd/NorthAmerica/2012/WSV415), мы же приводим крактко содержание + скрипты. В любом случае рекомендуем посмотреть само видео.
В фокусе доклада было два вопроса:
1. Строит отчеты по групповым политикам
2. Проводим анализ групповых политик
Подробности – под катом.
#### Используем PowerShell в связке с групповыми политиками: что для этого нужно?
Чтобы использовать PowerShell при работе с групповыми политиками, нам необходимы:
* Windows 7 (для запуска PowerShell)
* [RSAT для Windows 7](http://www.microsoft.com/ru-ru/download/details.aspx?id=7887)
* Собственно сам PowerShell v2.0 или выше
* Опционально: рекомендуется [Microsoft Active Directory Provider](http://msdn.microsoft.com/ru-ru/library/windows/desktop/aa384753(v=vs.85).aspx)
Последовательность наших действий:
* Импортируем модуль групповых политик (Import-module GroupPolicy)
* Получаем объект групповых политик с помощью PowerShell (Get a GPO PowerShell Object)
* Строим отчет на основе этого объекта
* Строим HTML/XML-отчеты по объектам групповых политик
* Парсим и осуществляем поиск в XML для целей анализа
* Осуществляем поиск с помощью Select-XML и Xpath
#### Строим отчеты по групповым политикам
**Проблема №1. Необходимо получить информацию о том, что в настоящий момент происходит в групповых политиках**
```
PS C:\> Import-Module GroupPolicy
PS C:\> Get-GPO JeremyGPO
```
В данном случае вместо JeremyGPO выступает отображаемое имя (DisplayName) объекта групповых политик. Выводится такая табличка
```
DisplayName : JeremyGPO
DomainName : GLOBOMANTICS.local
Owner : GLOBOMANTICS\Domain Admins
Id : cd73c562-5bfe-40e2-b81e-28da10da425c
GpoStatus : ComputerSettingsDisabled
Description :
CreationTime : 12/28/2011 2:52:37 PM
ModificationTime : 5/21/2012 11:08:26 AM
UserVersion : AD Version: 4, SysVol Version: 4
ComputerVersion : AD Version: 1, SysVol Version: 1
WmiFilter :
```
**Решение проблемы: создаем отчеты.**
Например, перед нами стоит задача получить список всех объектов групповых, которые были изменены за последние 30 дней, отсортированные по убыванию (последние наверху) с тремя значениями (отображаемое имя, время изменения, описание). Полученную информацию необходимо экспортировать в .csv файл (GPOModReport.csv в данном примере). Как это выглядит в PowerShell:
```
PS C:\> get-gpo -all | Where {$_.ModificationTime -gt (Get-Date).AddDays(-30)}
... | Sort ModificationTime -Descending | Where {$_.ModificationTime -ge (Get-Date).AddDays(-30)} | Select Displayname,ModificationTime,Description
... | Export-CSV R:\GPOModReport.csv
```
**Примеры дополнительных команд**
```
#Созданные и измененные объекты групповых политик
PS C:\>get-gpo -all | Sort CreationTime,Modificationtime | Select Displayname,*Time
```
```
#Находим все объекты групповых политик, измененные за последние 30 дней
PS C:\>get-gpo -all | Where {$_.ModificationTime -ge (Get-Date).AddDays(-30)}
```
```
#Создаем отчет по отдельному объекту групповых политик (Defaul Domain Policy)
PS C:\>Get-GPOReport -name "Default Domain Policy" -ReportType HTML -Path "c:\work\ddp.htm"
invoke-item "c:\work\ddp.htm"
```
```
#Создаем отчеты по всем объектам групповых политик
PS C:\>Get-GPOReport -All -ReportType HTML -Path "c:\work\allgpo.htm"
invoke-item "c:\work\allgpo.htm"
```
```
#Создаем для каждого объекта групповых политик свой отчет
#заменяем пробелы на _ в имени GPO
PS C:\>Get-GPO -all | foreach {
$f="{0}.htm" -f ($_.Displayname).Replace(" ","_")
$htmfile=Join-Path -Path "C:\work" -ChildPath $f
Get-GPOReport -Name $_.Displayname -ReportType HTML -Path $htmfile
Get-Item $htmfile
}
```
**Проблема №2. Слишком много GPO, которые не используются.**
**Задача: найти пустые GPOs**
* Определить объекты групповых политик без настроек
* Ищем XML ExtensionData
```
PS C:\> Import-Module GroupPolicy
PS C:\> [xml]$r = Get-GPOReport -Name MyGPO
-ReportType XML
PS C:\> if ((-Not $r.gpo.user.extensiondata) -AND (-not $r.gpo.computer.extensiondata)) {
"GPO is empty"
}
```
**Дополнительные команды**
```
#requires -version 2.0
#find empty gpos in the domain
Function Get-EmptyGPO {
Param (
[Parameter(Position=0,ValueFromPipeline=$True,
ValueFromPipelinebyPropertyName=$True)]
[string]$DisplayName
)
Begin {
#import the GroupPolicy Module
Import-Module GroupPolicy
}
Process {
#create an XML report
[xml]$report=Get-GPOReport -Name $displayname -ReportType XML
#totally empty
if ((-Not $report.gpo.user.extensiondata) -AND (-not $report.gpo.computer.extensiondata)) {
#no extension data so write
Get-GPO -Name $Displayname
}
} #process
End {}
} #function
Function Test-EmptyGPO {
Param (
[Parameter(Position=0,ValueFromPipeline=$True,
ValueFromPipelinebyPropertyName=$True)]
[string]$DisplayName
)
Begin {
#import the GroupPolicy Module
Import-Module GroupPolicy
}
Process {
#set default values
$User=$False
$Computer=$False
#create an XML report
[xml]$report=Get-GPOReport -Name $displayname -ReportType XML
if ($report.gpo.user.extensiondata) {
$User=$True
}
If ( $report.gpo.computer.extensiondata) {
$Computer=$True
}
#write a custom object to the pipeline
New-Object -TypeName PSObject -Property @{
Displayname=$report.gpo.name
UserData=$User
ComputerData=$Computer
}
} #Process
End {}
} #function
#Get-GPO -All | Get-EmptyGPO
#Get-GPO -All | Test-EmptyGPO
```
**Проблема №3.**Кто обращался к объекту групповой политики?
Имеются ли GPO, в которых половина политики деактивирована (“Are there any GPOs with ‘half’ the policy disabled?”)
Имеются ли GPO, в которых все политики деактивированы (“Are there any GPOs with ‘all’ the policy disabled?”)
Применяем фильтр по статусу GPO (GPOStatus). Каждому из трех вопросов выше соответствуют три команды:
```
PS C:\> get-gpo -all | Sort GPOStatus | format-table -GroupBy GPOStatus Displayname,*Time
PS C:\> get-gpo -all | where {$_.GPOStatus -match "disabled"} | Select GPOStatus,Displayname
PS C:\> get-gpo -all | where {$_.GPOStatus -match "AllSettingsDisabled"}
```
#### Анализируем объекты групповых политик
**Проблема №4. Обнаруживаем GPO без связей**
```
PS C:\> Import-Module ActiveDirectory
Get-ADOrganizationalUnit -filter * | select-object
-ExpandProperty DistinguishedName | get-adobject
-prop gplink | where {$_.gplink} | Select-object
-expand gplink | foreach-object {
foreach ($item in ($_.Split("]["))) {
$links+=$regex.match($item).Value
}
}
Get-GPO -All | Where {$links -notcontains $_.id}
```
**Дополнительные команды**
```
#requires -version 2.0
<#
Find unlinked GPOs. This requires the Active Directory Module
This version does not query for site links
#>
Import-Module ActiveDirectory,GroupPolicy
#GUID regular expression pattern
[Regex]$RegEx = "(([0-9a-fA-F]){8}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){12})"
#create an array of distinguishednames
$dn=@()
$dn+=Get-ADDomain | select -ExpandProperty DistinguishedName
$dn+=Get-ADOrganizationalUnit -filter * | select -ExpandProperty DistinguishedName
$links=@()
#get domain and OU links
foreach ($container in $dn) {
#pull the GUID and add it to the array of links
get-adobject -identity $container -prop gplink |
where {$_.gplink} | Select -expand gplink | foreach {
#there might be multiple GPO links so split
foreach ($item in ($_.Split("]["))) {
$links+=$regex.match($item).Value
} #foreach item
} #foreach
} #foreach container
#$links
<#
get all gpos where the ID doesn't belong to the array
write the GPO to the pipeline
#>
Get-GPO -All | Where {$links -notcontains $_.id}
```
**Проблема 5. Объекты групповых политик с излишними настройками в реестре (“Extra Registry Settings”)**
Находим излишние настройки в реестре
```
#Use Xpath with the XML report data
PS C:\> [xml]$report = Get-GPOReport -Name MyGPO
-ReportType XML
PS C:\> $ns = @{q3 = "http://www.microsoft.com/GroupPolicy/Settings/Registry"}
PS C:\> $nodes = Select-Xml -Xml $report -Namespace $ns -XPath "//q3:RegistrySetting" | select -expand Node | Where {$_.AdmSetting -eq 'false'}
```
**Дополнительные команды**
```
#requires -version 2.0
#find GPOs with extra registry, ie non-ADM settings
Function Test-GPOExtraRegistry {
Param (
[Parameter(Position=0,ValueFromPipeline=$True,
ValueFromPipelinebyPropertyName=$True)]
[string]$DisplayName
)
Begin {
#import the GroupPolicy Module
Import-Module GroupPolicy
}
Process {
#create an XML report
[xml]$report=Get-GPOReport -Name $displayname -ReportType XML
#define the XML namespace
$ns=@{q3="http://www.microsoft.com/GroupPolicy/Settings/Registry"}
$nodes=Select-Xml -Xml $report -Namespace $ns -XPath "//q3:RegistrySetting" |
select -expand Node | Where {$_.AdmSetting -eq 'false'}
if ($nodes) {
#extra settings were found so get the GPO and write it to the pipeline
Get-GPO -Name $Displayname
}
}
End {}
} #function
#Import-Module GroupPolicy
#Get-GPO -all | Test-GPOExtraRegistry
```
Еще раз обозначим, что мы привели в посте лишь сухой остаток того, что было продемонстрировано в докладе. Сам доклад можно посмотреть [здесь](http://channel9.msdn.com/Events/TechEd/NorthAmerica/2012/WSV415).
Бонусы:
* [Ссылка на скрипты](http://jdhitsolutions.com/blog/wp-content/uploads/2012/06/TechEd2012-GPOAnalysis-PowerShellDemo.zip)
* [Слайды](http://jdhitsolutions.com/blog/wp-content/uploads/2012/06/GroupPolicy_Reporting_Analysis_with_PowerShell.pdf)
* [Бесплатная книга по Group Policy + PowerShell от одного из авторов доклада [ENG]](https://moskowitzinc.infusionsoft.com/app/form/2fb14a6883b8b10595a174b65169af71) (необходимо заполнить форму)
Также для построения отчетов по групповым политикам вы можете воспользоваться нашей программой [NetWrix Group Policy Change Reporter](http://www.netwrix.com/ru/group_policy_auditing_change_reporting_freeware.html). | https://habr.com/ru/post/161533/ | null | ru | null |
# Заметка ленивого верстальщика о SCSS и Compass Framework
Я изготавливаю сайты «под ключ». Начиная от дизайна, кончая заливкой на хостинг. И самая нелюбимая мною часть этого увлекательного процесса — верстка дизайна в HTML. Вроде бы ничего сложного, но многие рутинные вещи очень утомляют. Поэтому я постоянно нахожусь в поисках интересных решений в этой области.
Не так давно я начал изучать Ruby on Rails 3 и нашел очень интересный плагин для него: [Compass](http://compass-style.org). По сути, этот CSS-фреймворк независим от Rails, им можно пользоваться и в других типах проектов.
Расскажу-ка я вам, как Compass облегчил мою жизнь.
#### SCSS
Первое, на что падает глаз — фреймворк использует языки SASS и SCSS. Почитать о них можно на [домашней странице](http://sass-lang.com) этого проекта. Если коротко, то это альтернативные языки для написания таблиц стилей. Конечно, на выходе после компиляции все равно выходит самый обычный CSS, но главное преимущество в том, что эти языки значительно ускоряют написание стилей.
Для себя я выбрал SCSS, ибо он привычен (его синтаксис схож с синтаксисом обычного CSS). Этот язык дает верстальщику 4 сверхспособности:
##### 1. Переменные
Потрясающая вещь! Только ради нее уже можно переходить на SCSS. Представим ситуацию: вы верстаете страничку, на которой цвет рамки блоков и цвет ссылок должен быть одинаковый. И вдруг заказчик говорит, что нужно бы сделать этот цвет посветлее.
```
.megablock {
border-color: #A88;
}
.megablock a {
text-decoration: none;
color: #A88;
}
```
И вы ищете и меняете этот цвет во всем stylesheet'е. А при использовании переменных SCSS, этот код можно облегчить и сделать более гибким:
```
$block-color: #A88;
.megablock {
border-color: $block-color;
}
.megablock a {
text-decoration: none;
color: $block-color;
}
```
Теперь, чтобы поменять цвета, вам достаточно лишь поменять одну единственную переменную в тексте. Более того, к переменным можно применять математические операции. Например:
```
$border-color - #111
```
##### 2. Вложение
Очередная рюшечка, ускоряющая написание стилей. Как часто вам приходилось писать длинные селекторы, вроде `table.cart div span a`? В SCSS вы можете вкладывать селекторы друг в друга:
```
table.cart {
width: 700px;
div {
float:left;
span {
font-size: 14px;
a {
color: $cart-link-color;
}
}
}
}
```
Зачастую это даже элементарно упрощает чтение кода.
##### 3. Mixins (Примеси)
А еще ведь наверняка приходится писать частенько в разных селекторах одни и те же правила, да? Например, скругление углов для всех браузеров. SCSS позволит вам и тут сэкономить время:
```
#promo {
background-color: $promo-bg-color;
@border-radius(10px);
}
```
В этом примере я впервые демонстрирую вам некоторые возможности фреймворка Compass, так как «примесь» `border-radius` уже включена в стандартный набор его возможностей.
##### 4. Наследование селекторов
Еще одна приятность, которую нельзя обойти стороной. По своей сути она похожа на предыдущую:
```
.notification {
border: 1px solid;
margin: 0 auto;
}
.errorNotification {
@extend .notification;
background-color: #f11;
color: #fff;
}
```
Нетрудно догадаться, что при компиляции селектора `.errorNotification` в него будут включены все правила из `.notification`
#### Compass Framework
Ну а теперь, собственно, о самом фреймворке. Достаточно взглянуть на его [документацию](http://compass-style.org/docs/), чтобы понять, насколько он может упростить жизнь веб-разработчику. Огромное количество готовых mixin'ов, классов, тесная интеграция с CSS-фреймворком Blueprint.
Чтобы описать все, конечно, у меня не хватит терпения, но пройдусь по основным фишкам фреймворка.
##### Кроссбраузерный CSS3
Для того, чтобы не писать правила для каждого браузера (WebKit, Mozilla и т.д.), разработчики включили множество инструментов для быстрого написания CSS3-примочек. Градиенты, скругленные углы, тени и многое другое теперь можно создавать одной строчкой.
##### Хелперы
В Compass также включено много инструментов-хелперов. Например, если вы хотите всем заголовкам задать одинаковый шрифт, в качестве селектора можно воспользоваться `headings(all)`. Есть также готовый инструмент для приклеивания футера к низу страницы.
##### Хаки и утилиты
Да, особую ценность представляют различные хаки, призванные справляться с кроссбраузерными проблемами. Float'ы, Clearfix'ы, минимумы и т.п.
А как пример жутко полезной утилиты: примесь `link-colors()`, которая позволяет задать 4 цвета для всех четырех состояний ссылки одной строкой!
##### Blueprint
Отдельно стоит упомянуть то, что Compass поддерживает все классы CSS-фреймворка [Blueprint](http://www.blueprintcss.org/) сразу из коробки. Сетки, типографика, формы, кнопки и все остальное. Лично для меня это было огромнейшим плюсом, так как Blueprint уже давно облегчает мне верстку сайтов благодаря готовым классам, а в комплекте с Compass становится мощнейшим инструментом.
#### Итого
Но, пожалуй, главное преимущество SCSS и Compass — они очень просты и прозрачны. Чтобы начать пользоваться вышеперечисленными преимуществами мне понадобилось не больше часа времени.
Для Rails-проектов я просто не вижу никакой альтернативы. Хотя, если вам интересно, можете попробовать использовать его и в других средах.
Если подключить еще и HAML, то время верстки страницы в среднем уменьшается в 2-3 раза! Думаю, что больше аргументов не требуется. | https://habr.com/ru/post/111523/ | null | ru | null |
# Дорога к С++20
Сегодня завершилась летняя встреча комитета ISO WG21 C++, проходившая в Торонто с 10 по 15 июля. Вскоре нас наверняка ждёт [подробный отчёт от РГ21](https://stdcpp.ru/blog/20-iyulya-vstrecha-rg21-s-v-sankt-peterburge), а сегодня уважаемой публике предлагается пост-«разогрев» с обсуждением самого интересного.
Итоги встречи следующие: стандарт С++17 завершен и будет опубликован на следующем собрании в ноябре этого года; стандарт С++20 уже обзавелся первыми серьезными фичами — *концептами* (*concepts*), *явными обобщёнными лямбда-функциями* (*explicit generic lambdas*) — и это только начало.
Возможности нового стандарта С++17 обсуждались уже не раз, про нововведения [писали на Хабре](https://habrahabr.ru/company/yandex/blog/323972/), проводили [доклады на конференциях](https://www.youtube.com/watch?v=pEzV32yRu4U), поэтому снова их приводить здесь я не буду. Не секрет, что ключевой особенностью этого выпуска С++ стал [перенос самых «вкусных» возможностей](https://habrahabr.ru/company/infopulse/blog/279927/) в неопределенное будущее. Что ж, теперь можно с уверенностью сказать, что многие долгожданные «фичи» переехали именно в С++20. Взятый курс на расширение stdlib никуда не делся, поэтому от C++20 можно ожидать гораздо большего и богатого набора функций.
### Черновик стандарта С++20
#### Концепты
Многострадальные *Concepts*, когда-то не вошедшие в C++11, потом переделанные в виде нового предложения *Concepts-Lite*, наконец-то становятся частью стандарта.
По поводу краткого синтаксиса для концептов (terse syntax) комитету договориться пока не удалось; однако, обсуждение будет продолжаться в рамках С++20.
#### ＿VA\_OPT＿
```
#define LOG(msg, ...) printf(msg __VA_OPT__(,) __VA_ARGS__)
LOG("hello world") // => printf("hello world")
LOG("hello world", ) // => printf("hello world")
LOG("hello %d", n) // => printf("hello %d", n)
```
#### Явные обобщённые лямбда-функции (Explicit generic lambdas) [[pdf]](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0428r1.pdf)
```
[] (T t) { /\* ... \*/ }
```
Лямбда-функции были добавлены в язык в стандарте C++11, требовавшие указания конкретного типа; стандарт C++14 в свою очередь позволил объявлять параметры лямбда-функций со спецификатором типа auto:
```
[](auto x) { /* ... */ }
```
Теперь взаимодействовать с типами параметра (или параметров) станет проще — при определении лямбда-функций можно будет использовать привычный синтаксис шаблона функций:
```
[](T x) { /\* ... \*/ }
[](T\* p) { /\* ... \*/ }
[](T (&a)[N]) { /\* ... \*/ }
```
#### shared\_ptr для массивов [[pdf]](https://wg21.link/p0674r0)
```
shared_ptr p = make\_shared(1024);
```
Тема поднималась неоднократно — например, здесь[1](https://rsdn.org/forum/cpp/4790880.all).
#### Определение порядка байтов
Больше нет нужды прибегать [к хитрым приёмам](https://stackoverflow.com/questions/1001307/detecting-endianness-programmatically-in-a-c-program) — на самом деле, компилятор и так всегда знал ответ, просто теперь он им сможет поделиться:
```
enum class endian
{
little = __ORDER_LITTLE_ENDIAN__,
big = __ORDER_BIG_ENDIAN__,
native = __BYTE_ORDER__
};
```
#### Назначенный инициализатор (designated initializer) [[pdf]](https://wg21.link/p0329)
```
struct A { int x; int y; int z; }; A b{.x = 1, .z = 2};
```
#### Инициализаторы битовых полей по умолчанию (default bit-field initializers)
```
struct S {int x : 8 = 42;};
```
Нововведение, которое ожидали еще со времен появления «in-class initialization» в C++11: теперь declarator для членов битового поля поддерживает инициализацию.
#### Исправлены const-qualified указатели на члены
```
struct X { void foo() const&; };
X{}.foo(); // this is okay
(X{}.*&X::foo)(); // ill-formed in C++17, well-formed in C++2a
```
#### Улучшенная дедукция аргумента шаблона
```
vector v{vector{1, 2}};
// Выведет vector вместо vector>
```
### TS (Technical Specifications)
Перечисленные ниже TS отныне являются частью С++17 (уже обсуждались в прошлые разы):
* **Filesystem v1 [[pdf]](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4100.pdf)** — порт boost::filesystem,
* **Parallelism v1 [[pdf]](https://wg21.link/n4507)** — благодаря этому TS, большая часть библиотеки *algorithm* отныне будет доступна в «параллельной» версии,
* **Library Fundamentals v1 [[pdf]](https://wg21.link/n4480)** — расширение стандартной библиотеки: std::string\_view, std::optional, std::any, system\_error.
Помимо этого, комитет опубликовал следующие технические спецификации, для которых компиляторы уже могут делать экспериментальные реализации (и они наверняка здесь обсуждались ранее):
* [**Coroutines v1**](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/n4663.pdf) — вокруг сопрограмм было много [обсуждений](https://habrahabr.ru/post/278267/)
* [**Ranges v1**](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/n4671.pdf) — проскочили вслед за концептами, и, будем надеяться, попадут в С++20
* [**Networking v1**](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/n4656.pdf) — имеет все шансы попасть в C++20; библиотека для работы с сокетами, в основе которой лежит boost::asio.
Далее рассматриваются TS, работа над которыми все ещё продолжается.
Некоторые из них — но, определенно, не все — войдут в состав С++20.
#### Модули (Modules) [[pdf]](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/n4667.pdf)
Модули по-прежнему находятся в разработке, однако, в их жизни случилось серьезное событие — стал доступен ранний черновик [TS Модулей](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/n4667.pdf). В его публичной версии за прошедшее время ничего не изменилось (не считая пары мелких деталей) — т.е. модули по-прежнему основываются на дизайне Microsoft и не экспортируют макросы. По этому вопросу хотелось бы услышать мнение членов комитета, поскольку есть подозрения, что это не окончательное решение.
#### Concurrency v1 [[pdf]](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4399.html)
Опубликован, собирались принимать на этой встрече, однако фичи на разной стадии готовности — так что уже на следующей встрече данный TS будет частично принят в С++20. Содержит улучшения, которые сделают futures неблокирующими (в отличие от std::async), а также latches, барьеры и atomic smart pointers *atomic\_shared\_ptr*. Не вошел в С++17 по причине того, что был поздно опубликован и не получилось собрать достаточно практического опыта.
Непосредственно имплементация была вдохновлена MS Visual Studio, HPX и just::thread. Перед встречей были опасения, что новые предложения [P0676](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0676r0.pdf) и [P0701](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0701r0.html) могут отодвинуть принятие TS на неопределенный срок.
#### Transactional Memory v1 [[pdf](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4514.pdf)]
Опубликован, однако по этому TS еще совсем недавно у его же авторов оставались вопросы по части того, насколько быстрыми могут быть атомики и shared\_ptr вне транзакций, если они должны с транзакцией взаимодействовать. Остается ждать разъяснений по поводу того, изменилось ли что-либо с прошлого раза.
#### Library Fundamentals v2
Опубликован. Нечто вспомогательное, потребуется для С++20.
#### Executors v1 [[pdf]](https://wg21.link/p0443r1)
В разработке. Должен войти в С++20, т.к. на него завязаны несколько других TS библиотек, связанных с гетерогенными вычислениями.
#### Reflection v1 [[pdf](https://wg21.link/p0194r4)]
В разработке. Есть все шансы попадания в С++20, ибо ему будет посвящена одна из грядущих встреч.
В основе TS лежат интроспекция кода и (с недавних пор) материализация (reification). По мнению комитета, TS пригодится в метапрограммировании, ставшему популярным благодаря Boost::Hana и аналогичных библиотек — а также для [гетерогенных контейнеров](https://habrahabr.ru/post/332084/).
#### Concurrency v2
В разработке на ранней стадии. Библиотека concurrent data structures, сoncurrent queues, lock-free алгоритмов и структур данных; включает в себя Hazard pointers (указатели опасности), RCU (безопасное освобождение памяти для lock-free контейнеров), atomic views. Вероятность попадания в С++20 крайне мала, т.к. находится еще на ранней стадии — при этом комитет осознает востребованность этого функционала и он, по словам автора, в самой активной разработке.
#### Parallelism v2
В разработке. Оказывается, за время разработки Parallelism v1 сделали не только Parallel STL для CPU, но и для GPU. Parallelism v2 —
#### Library Fundamentals v3
В разработке.
#### Contracts v1
В разработке. Будет либо TS, либо включение в стандарт С++20. Вкратце: улучшенная версия assert, которая позволяет проводить проверку пре- и пост- условий (т.е. инварианты). По мнению комитета, библиотека поможет С++ стать более безопасным языком, чтобы разработчики ПО для медицины, автомобилей, авиации и кибер-безопасности спали спокойней.
#### Numerics [[pdf](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0101r0.html)]
В разработке на ранней стадии. Кое-что из продвинутой арифметики наверняка войдет в С++20: decimal floating point, bounded types (например, fixed point types), unbounded types, multiprecision arithmetic. Должно пригодиться в работе в работе игровым разработчикам (которые, впрочем, привыкли сами писать то, что им требуется).
#### 2D Graphics v1
На ранней стадии.
#### По мелочи
Идёт работа над добавлением новых функций к std::string — *starts\_with*, *ends\_with*.
Стоит заметить, что причиной появления сразу нескольких будущих TS стали распределенные и гетерогенные вычисления. Участники комитета понимают, что вот уже долгое время CUDA/OpenMP/OpenCL обгоняет нативный C++. В данный момент, все функции вроде std::invoke, std::async, параллельные алгоритмы и пр. предполагают, что std::thread используется исключительно на CPU; и даже несмотря на то, что черновик Executors TS содержит подвижки на этом фронте в виде включения в него новых фич, этого будет недостаточно, и работы предстоит еще очень много.
Уже продолжительное время эксперты из Google, NVidia, Codeplay и NASDAQ принимают участие в работе над черновиками грядущих TS, чтобы определить направление развития С++, и приоритеты будущего языка вам известны: Concurrency, Parallelism, Transactional Memory, и Networking.
Время покажет, что из обещанного действительно войдет в C++20, и насколько оправдаются наши надежды.
### Литература
Как обычно, прошу прощения за любые допущенные неточности.
[Michael Wong — What's in C++20 and the C++17 final score card](https://www.codeplay.com/portal/10-06-17-whats-in-cpp-20-and-cpp17-final-score-card)
[Обсуждение](https://www.reddit.com/r/cpp/comments/6n9t5v/codeplay_whats_in_c20_and_the_c17_final_score/)
[2017 Toronto ISO C++ Committee Discussion Thread (Concepts in C++20; Coroutines, Ranges and Networking TSes published)](https://www.reddit.com/r/cpp/comments/6ngkgc/2017_toronto_iso_c_committee_discussion_thread/)
[C++17: The Language Features — Nicolai Josuttis](https://www.youtube.com/watch?v=pEzV32yRu4U)
[Trip report: Summer ISO C++ standards meeting (Toronto)](https://herbsutter.com/2017/07/15/trip-report-summer-iso-c-standards-meeting-toronto/) | https://habr.com/ru/post/333414/ | null | ru | null |
# Учебник по языку программирования D. Часть 3
Третья часть перевода [D Programming Language Tutorial](http://ddili.org/ders/d.en/index.html) от [Ali Çehreli](http://ddili.org/AliCehreli_resume.html). Содержание главы расчитано для начинающих и, как мне кажется, даже не раскрывает темы. Но это перевод одной из глав.
Предыдущие части:
1. [Часть 1](http://habrahabr.ru/post/226071/)
2. [Часть 2](http://habrahabr.ru/post/226565/)
Присвоение и порядок выполнения операций
========================================
Первые две сложности, что большинство студентов встречают при изучении программирования — это операция присвоения и порядок выполнения операций.
Операция присвоения
-------------------
Вы будете видеть строки похожие на следующие почти в каждой программе, почти в каждом языке программирования.
```
a = 10;
```
Смысл этой строки следующий «сделай значение а равным 10». Аналогично, смысл следующей строки следующий «сделай значение b равным 20».
```
b = 20;
```
Руководствуясь этой информацией, что было бы сказано о следующей строке?
```
a = b;
```
К сожалению, эта строчка не про математическое равенство, о котором, я думаю, все мы знаем. Это вышеуказанное выражение не подразумевает «a равно b»! Если следовать той же логике с предыдущих двух строк, то это выражение должно означать «сделай значение a равным b». Присвоение значению a значение b также означает «сделай значение a таким же как значение b».
Хорошо известный математический символ "=" имеет полностью другое значение в программировании: сделать значение левой части таким же как значение правой части.
Порядок выполнения операций
---------------------------
Эти операции программы выполняются шаг за шагом в особом порядке. Мы можем видеть эти предыдущие 3 выражения в программе в следующем порядке:
```
a = 10;
b = 20;
a = b;
```
Смысл этих трех строчек вместе такой: «сделай значение а равным 10, затем сделай значение b равным 20, затем сделай значение a таким же как значение b». Соответсвенно, после этих трех операций, a и b будут равны 20.
Упражнение
----------
Проследите, что следующие три операции сменят значения a и b. Если в начале их значения 1 и 2 соответсвенно, после этих операций значения станут 2 и 1.
```
c = a;
a = b;
b = c;
``` | https://habr.com/ru/post/243595/ | null | ru | null |
# Concurrency: 6 способов жить с shared state
В многопоточном программировании много сложностей, основными из которых являются работа c разделяемым состоянием и эффективное использование предоставляемых ядер. Об использовании ядер пойдет речь в следующей статье.
С разделяемым состоянием в многопоточной среде существуют два момента, из-за которых возникают все сложности: [состояние гонки](https://en.wikipedia.org/wiki/Race_condition) и видимость изменений. В состоянии гонки, потоки одновременно изменяют состояние, что ведет к недетерменированному поведению. А проблема с видимостью заключаются в том, что результат изменения данных в одном потоке, может быть невидим другому. В статье будут рассказаны шесть способов как бороться с данными проблемами.
Все примеры приведены на Java, но содержат комментарии и я надеюсь будут понятны программистам не знакомым c Java. Данная статья носит обзорный характер и не претендует на полноту. В то же время она наполнена ссылками, которые дают более подробное объяснение терминам и утверждениям.
#### Shared State
Работу с разделяемым состоянием я покажу на примере вычисления чисел фибоначчи.
Формула для вычисления выглядит так:
```
f(0) = 0
f(1) = 1
f(n) = f(n - 1) + f(n - 2) , n >= 2
```
В первую очередь определим интерфейс:
```
public interface FibonacciGenerator {
/\*\*
\* Следующее сгенерированное значение
\*/
T next();
/\*\*
\* Текущее значение в генераторе
\*/
public T val();
}
```
Наши классы будут реализовывать интерфейс `FibonacciGenerator`. Из формулы видно, что для предоставления следующего числа, надо хранить два предыдущих — это и будет разделяемое состояние, за которое будет проходить конкуренция. Наша реализация должна быть [потоко-безопасной](https://en.wikipedia.org/wiki/Thread_safety). То есть независимо от одновременного количества потребителей, она будет сохранять свои инварианты и придерживаться контракта. И так, приступим.
#### Locking
Первый способ сделать класс корректно работающим в многопоточной среде — это использовать [блокировки](https://en.wikipedia.org/wiki/Lock_(computer_science)) и объявить все методы synchronized. Примером может служить класс [Vector](http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/tip/src/share/classes/java/util/Vector.java).
```
public class IntrinsicLock implements FibonacciGenerator {
private BigInteger curr = BigInteger.ONE;
private BigInteger next = BigInteger.ONE;
@Override
public synchronized BigInteger next() {
BigInteger result = curr;
curr = next;
next = result.add(next);
return result;
}
@Override
public synchronized BigInteger val() {
return curr;
}
}
```
Мы получили класс, который корректно работает в многопоточной среде, затратив при этом минимум усилий. В первую очередь, мы жертвуем производительностью. Производительность класса такая же, как если бы он запускался в однопоточной среде. К тому же, использование локов приносит проблемы, такие как: [deadlock](https://en.wikipedia.org/wiki/Deadlock), [livelock](https://stackoverflow.com/questions/1036364/good-example-of-livelock) и т.п.
#### Fine-Grained locking
Следующий способ — разбить наши структуры на части и оградить локами только те секции, в которых происходит работа с разделяемым состоянием. Примером такого подхода является [СoncurrentHashMap](http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/tip/src/share/classes/java/util/concurrent/ConcurrentHashMap.java). В нем все данные разбиваются на несколько частей. При доступе блокируется только та часть, изменение которой происходит в текущий момент. Также есть вариант использовать более функциональные локи, такие как: [StampedLock (java 8)](http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/tip/src/share/classes/java/util/concurrent/locks/StampedLock.java), [ReadWriteLock](http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/tip/src/share/classes/java/util/concurrent/locks/ReadWriteLock.java). При корректных алгоритме и реализации мы получаем более высокий уровень параллелизма. Пример с использованием ReadWriteLock:
```
public class FineGrainedLock implements FibonacciGenerator {
private final ReadWriteLock lock = new ReentrantReadWriteLock();
private BigInteger curr = BigInteger.ONE;
private BigInteger next = BigInteger.ONE;
@Override
public BigInteger next() {
BigInteger result;
lock.writeLock().lock();
try {
// Вход другим потокам запрещен
result = curr;
curr = next;
next = result.add(next);
return result;
} finally {
lock.writeLock().unlock();
}
}
@Override
public BigInteger val() {
lock.readLock().lock();
try {
// При отпущенном write lock
// Допуст`им вход множества потоков
return curr;
} finally {
lock.readLock().unlock();
}
}
}
```
Мы усовершенствовали класс и добились более высокой пропускной способности на чтение. У такой реализации есть все минусы локов. К тому же, из минусов добавилось то, что алгоритм усложнился (добавилось шума, не связанного с логикой работы) и вероятность некорректной реализации возросла.
#### Lock-free algorithms
Использование локов влечет массу проблем с производительностью и корректностью. Существует альтернатива в виде [неблокирующих алгоритмов](https://en.wikipedia.org/wiki/Non-blocking_algorithm). Такие алгоритмы построены на [атомарных операциях](https://en.wikipedia.org/wiki/Compare-and-swap), предоставляемых процессорами. Примером служит метод [get](http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/tip/src/share/classes/java/util/concurrent/ConcurrentHashMap.java#l934) в ConcurrentHashMap. Чтобы писать неблокирующие алгоритмы, имеет смысл воспользоваться существующими неблокирующими классами: [ConcurrentLinkedQueue](http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/tip/src/share/classes/java/util/concurrent/ConcurrentLinkedQueue.java), ConcurrentHashMap и т.п. Напишем неблокирующую реализацию нашего класса.
```
public class LockFree implements FibonacciGenerator {
// Инкапсулируем состояние генератора в класс
private static class State {
final BigInteger next;
final BigInteger curr;
public State(BigInteger curr, BigInteger next) {
this.next = next;
this.curr = curr;
}
}
// Сделаем состояние класса атомарным
private final AtomicReference atomicState = new AtomicReference<>(
new State(BigInteger.ONE, BigInteger.ONE));
public BigInteger next() {
BigInteger value = null;
while (true) {
// сохраняем состояние класса
State state = atomicState.get();
// то что возвращаем если удалось изменить состояние класса
value = state.curr;
// конструируем новое состояние
State newState = new State(state.next, state.curr.add(state.next));
// если за время пока мы конструировали новое состояние
// оно осталось прежним, то заменяем состояние на новое,
// иначе пробуем сконструировать еще раз
if (atomicState.compareAndSet(state, newState)) {break;}
}
return value;
}
@Override
public BigInteger val() {
return atomicState.get().curr;
}
}
```
Из плюсов такого подхода следует отметить увеличение производительности, по сравнению с блокирующими алгоритмами. А также, что не менее важно, избавление от [недостатков локов](https://en.wikipedia.org/wiki/Lock_(computer_science)#Disadvantages). Минус в том, что неблокирующий алгоритм придумать гораздо сложнее.
#### Software Transactional Memory
Альтернативой неблокирующим алгоритмам является применение [программной транзакционной памяти](https://en.wikipedia.org/wiki/Software_transactional_memory). Её использование похоже на использование транзакций при работе с базами данных. Концепция довольно таки новая (1995) и среди популярных языков, нативная поддержка есть только в Clojure. Поддержка STM на уровне библиотек есть во многих языках, в том числе и Java. Я буду использовать STM, реализованный в рамках проекта [Akka](https://en.wikipedia.org/wiki/Akka_(toolkit)).
```
public class STM implements FibonacciGenerator {
// Оборачиваем переменные в транзакционные ссылки
// система будет отслеживать изменения этих переменных внутри транзакции
private final Ref curr = new Ref<>(BigInteger.ONE);
private final Ref next = new Ref<>(BigInteger.ONE);
@Override
public BigInteger next() {
// Создаем транзакцию
return new Atomic() {
// Изменения внутри метода
// будут обладают АСI (https://en.wikipedia.org/wiki/ACID)
@Override
public BigInteger atomically() {
// Все значения отслеживаемых переменных согласованы
BigInteger result = curr.get();
// Изменения не видны другим потокам
curr.set(next.get());
next.set(result.add(next.get()));
// Проверяется были ли изменения над отслеживаемыми
// переменными. Если да, то нас опередили, но мы
// оптимистичны и повторяем транзакцию еще раз.
// Если мы первые, то атомарно записываем новые значения.
return result;
}
// и выполняем ее
}.execute();
}
@Override
public BigInteger val() {
// Транзакция создается неявно
return curr.get();
}
}
```
Код легко понимается и нет шума, создаваемого неблокирующими алгоритмами и использованием локов. Но за это мы платим более низкой производительностью и ограниченной применимостью, поскольку STM хорошо себя показывает когда читателей гораздо больше, чем писателей.
#### Immutability
Проблемы с общим доступом к состоянию от того, что оно изменяемое. То есть спроектировав класс [неизменяемым](https://en.wikipedia.org/wiki/Immutable_object), можно без ограничений работать с ним в многопоточной среде, так как он также будет потоко-безопасным. Но неизменяемые структуры данных зачастую требуют [функциональных подходов](https://en.wikipedia.org/wiki/Functional_programming) и [специальных структур данных](https://en.wikipedia.org/wiki/Persistent_data_structure), так как расходы на память могут быть очень велики.
```
public class Immutable {
private final BigInteger next;
// Текущее значение
public final BigInteger val;
private Immutable(BigInteger next, BigInteger val) {
this.next = next;
this.val = val;
}
public Immutable next() {
return new Immutable(val.add(next), next);
}
public static Immutable first() {
return new Immutable(BigInteger.ONE, BigInteger.ONE);
}
}
```
Как вы заметили, интерфейс класса изменился и это потребует других способов работы с ним.
#### Isolated mutability
Идея изолированной изменяемости объектов состоит в том, что доступ к ним ограничен всегда одним потоком. Следовательно у нас не возникнет проблем, характерных для многопоточных программ. Такой подход использует [модель акторов](https://en.wikipedia.org/wiki/Actor_model). Акторы — это сущности похожие на объекты, у которых есть изменяемое состояние и поведение. Взаимодействие акторов происходит через асинхронную [передачу сообщений](https://en.wikipedia.org/wiki/Message_passing). Сообщения неизменяемы и актор обрабатывает одно сообщение за раз. Результатом обработки сообщения является изменение поведения, состояния и выполнение других действий. Пример использования акторов будет приведен в следующей статье.
#### Итог
У каждого подхода есть свои минусы и плюсы и нельзя дать универсального совета.
Комбинация fine-grained локов и неблокирующих алгоритмов, наиболее часто используемый подход в Java. В Clojure же напротив — транзакционная память и неизменяемые структуры данных. Транзакционная память, на мой взгляд, многообещающий инструмент (предлагаю читателю самостоятельно провести аналогию со сборкой мусора). Надеюсь, что при следующем проектировании системы, модуля или класса, вы вспомните подходы, описанные в данной статье, и выберите подходящий именно вам.
Спасибо за внимание. Жду ваших замечаний и предложений. | https://habr.com/ru/post/216049/ | null | ru | null |
# Использование бесплатных утилит для кастомизации «Неизменяемых» компонентов Windows 8
Многие, если не сказать – большинство из вас уже, как я уверен, успели установить и оценить новые возможности в последней клиентской операционной системе от Microsoft – Windows 8. В принципе, некоторым понравился новый «Metro»-интерфейс, а кто-то сразу кинулся искать возможности вернуть «на родину» кнопку **«Пуск»**. Кто-то активно использует новые упакованные приложения, а кто-то изменяет значения системного реестра, чтобы сразу отображался рабочий стол вместо начального экрана. Кто-то успел оценить возможности графического пароля, а кому-то не понравились изменения, связанные с ленточным интерфейсом в большинстве стандартных приложений, включая проводник. Иначе говоря, можно либо смириться со всеми новациями, привыкать к новым возможностям и работать, как ни в чем не бывало, либо постоянно видоизменять ту или иную функциональную возможность (насколько это может позволить Microsoft, естественно) исключительно под свои нужды.
Однако, в этой операционной системе есть несколько таких интересных возможностей, которые попросту не изменяют интерфейс и не добавляют/удаляют новые возможности системы, а просто не подлежат кастомизации. Так вот именно о таких возможностях и пойдет далее в текущей статье речь. Другими словами, в этой статье я не буду говорить о групповых политиках, об Active Directory и о Windows Server в частности. Речь пойдет исключительно о кастомизации клиентской операционной системы, причем о кастомизации таких компонентов системы, в которые можно вносить изменения только при использовании сторонних утилит. Ну что же…
Изменение пунктов меню Power User Tasks Menu
--------------------------------------------
Как бы ни было странно, но большинство людей, использующих операционную систему Windows 8, не знают о существовании такого интересного меню, которое называется Power User Tasks Menu. Итак, что это такое и зачем оно нужно?
В большинстве случаев у пользователей операционных систем практически не бывает таких ситуаций, когда у них красуется рабочий стол со всеми требуемыми ярлыками. Да и вообще, если честно, то я за все время видел не более пяти пользователей Windows, у которых на рабочем столе были бы такие утилиты как, скажем, редактор системного реестра, Process Monitor, планировщик задач и прочие необходимые для настройки и обслуживания системы приложения. Даже если таковые там и фигурируют, чтобы добраться к таким приложениям, пользователям нужно будет свернуть все открытые приложения, а затем запустить уже свой ярлык. Естественно, для этого нужно всего лишь выполнить комбинацию клавиш Win+D, дождаться, пока все свернется и, грубо говоря, все. Но все равно это требует какого-то времени.
Можно открыть диалоговое окно **«Выполнить»** и уже оттуда указать приложение или утилиту, которая должна запускаться. Это тоже время, да еще и нужно что-то набирать руками. В конце концов, вы можете закрепить требуемое приложение на панели задач, но она, естественно, не резиновая, и, закрепив на ней 6-7 программ, люди уже начинают задумываться над тем, стоит ли закреплять очередное приложение, а затем искать требуемый элемент на панели.
Специально для того, чтобы существенно сократить время доступа к необходимым приложениям, предназначенным в основном для обслуживания систем, было создано меню **Power User Tasks Menu** или же, проще говоря, **Win+X** меню. Из его «сокращенного» названия становится очевидно, какая комбинация клавиш требуется для его открытия. Альтернативным вариантом открытия такого меню является нажатие правой кнопкой мыши в нижней левой части экрана. Открывается такое меню очень быстро, по умолчанию из него можно вызвать окно управления электропитанием, оснастку просмотра событий, командную строку, диспетчер задач и много прочих полезных утилит. Но тут есть одно «но»… Это меню просто невозможно редактировать штатными средствами, что, безо всякого сомнения, очень неприятно. А ведь было бы удобно, если бы была возможность добавления в это меню дополнительных пунктов (мониторы-то с расширениями экрана, благо, сейчас у большинства позволяют «отъесть» немного места).
Мой товарищ, **[Сергей Ткаченко](http://www.facebook.com/HappyBulldozer)**, относительно недавно написал очень удобную и простую утилиту, предназначенную для управления этим меню. Эта утилита называется «[**Win+X Menu Editor for Windows 8**](http://winaero.com/comment.php?comment.news.30)», которую вы можете загрузить по указанной в названии утилиты ссылке. Прежде всего, хотелось бы отметить, что утилита абсолютно бесплатная и практически не занимает места на диске. Так что же собой представляет эта утилита?
Интерфейс данной утилиты настолько прост, что с ним способны справиться даже пользователи, которые очень далеки от того, чтобы их называли опытными. Сразу после открытия этой утилиты в отобразившемся окне вы увидите содержимое своего Win+X меню, включающее в себя группы и требуемые утилиты. При помощи текущей утилиты вы можете добавить как общеизвестные административные элементы (например, Windows PowerShell, Брандмауэр Windows в режиме повышенной безопасности, планировщик заданий и прочее), элементы панели управления, к которым можно отнести диалоговое окно компонентов Windows, окно персонализации, параметров шрифта и прочее, а также, в том случае, если требуемого приложения или утилиты не было в предоставленных списках, вы можете при помощи опции **«Add a program»** и стандартного системного диалогового окна открытия приложения выбрать последнее из своего «родного» расположения. Окно текущей утилиты с раскрывающимся списком «**Add a program**» вы можете увидеть на следующей иллюстрации:
**Рис. 1. Утилита Win+X Menu Editor for Windows 8**
Например, я таким образом на своей клиентской машине в это меню добавил себе в третью группу утилиту от Марка Руссиновича Process Monitor, редактор реестра и планировщик заданий, а также создал новую группу для таких приложений как Snipping Tool, редактор Snagit, Windows Live Writer, при помощи которого я публикую посты на своем блоге, текстовый редактор Notepad++, One Note и Outlook. Теперь, грубо говоря, все приложения, которые у меня запускаются чаще всего и которым не было выделено своего места на панели задач, у меня всегда под рукой.
**Рис. 2. Меню Win+X после всех внесённых изменений**
Добавление команд в контекстные меню
------------------------------------
Контекстные меню для многих можно назвать отправной точкой для выполнения нестандартных операций с файлами. То есть, если вы хотите, чтобы в контекстном меню какого-то конкретного типа файла фигурировала дополнительная команда, вам нужно прибегать к редактированию системного реестра или написанию объемных reg-файлов (в которых легко можно допустить ошибки), с чем, естественно, бОльшая часть пользователей попросту неспособна справиться.
Специально для решения такой проблемы одним добрым самаритянином была написана бесплатная утилита, которая называется [Default Programs Editor](http://defaultprogramseditor.com/). Используя функциональные возможности такой утилиты, вы можете редактировать контекстное меню для любого файла, вплоть до опции **«Открыть с помощью»**.
Так как эта статья позиционируется как небольшая, сразу перейду к примеру использования этой утилиты. Предположим, что нам нужно в контекстное меню MKV-файлов добавить опцию **«Проигрывать в K-Lite»**. Как же это делается:
1. В отобразившемся окне утилиты следует выбрать самую верхнюю опцию, опцию «**Context Menu**», как видно ниже:
**Рис. 3. Начальная страница данной утилиты**
2. После этого на странице «**Select an extension to change**» выбираем из предоставленного списка требуемое расширение. В нашем случае это расширение **.mkv**. Для большего удобства вы можете воспользоваться эвристическим поиском, как показано на следующей иллюстрации:
**Рис. 4. Поиск требуемого типа файла**
3. И вот уже на странице «**Select and change context menu items for .mkv files**» вы можете добавлять свои пункты меню для выбранного вами на предыдущей странице утилиты типа файла. Здесь вы можете как отредактировать существующие пункты меню, так и добавить новый, уникальный пункт. Попробуем добавить что-то новое. Для этого достаточно нажать на кнопку **«Add»**, а затем на отобразившейся странице следует ввести имя нового пункта меню и, естественно, путь для исполняемого файла. При желании можно добавить даже значок для такого пункта. В данном случае в текстовом поле «**Command name**» указывается текст «**Проигрывать в K-Lite**», в поле **«Program Path»** — **«"C:\Program Files (x86)\K-Lite Codec Pack\Media Player Classic\mpc-hc.exe" "%1"»** (путь вместе с параметром указывается при выборе соответствующего файла), а в качестве значка можно установить тот значок, который будет предложен по нажатию на кнопку обзора около опции «**Item icon**». Помимо этого вы также можете определить некоторые дополнительные параметры. Пример такого добавляемого элемента можно посмотреть ниже:
**Рис. 5. Добавление нового пункта меню**
4. Между прочим, по нажатию на кнопку **«Edit selected command»**, как я уже отметил ранее, вы можете отредактировать как добавленный вами пункт меню, так и тот пункт, который был создан самой операционной системой или встраиваемым приложением. Как можно заметить, все внесенные изменения вы можете сохранить как непосредственно в реестр, так и отдельно в reg-файл для создания одного уникального файла со всеми настройками либо для централизованного развертывания таких параметров. Данная страница утилиты с раскрывающимся списком сохранения изменений фигурирует на следующей иллюстрации:
**Рис. 6. Сохранение внесенных изменений**
В конечном счете у вас должен получиться следующий reg-файл, который вы уже можете использовать так, как посчитаете нужным:
***`[HKEY_CURRENT_USER\Software\Classes\KLCP.WMP.mkv\shell\KLite]
@="Проигрывать в K-Lite"
[HKEY_CURRENT_USER\Software\Classes\KLCP.WMP.mkv\shell\KLite\command]
@="\"C:\\Program Files (x86)\\K-Lite Codec Pack\\Media Player Classic\\mpc-hc.exe\" \"%1\""
[HKEY_CURRENT_USER\Software\Classes\KLCP.WMP.mkv\shell\KLite]
"Icon"="C:\\Program Files (x86)\\K-Lite Codec Pack\\Media Player Classic\\mpc-hc.exe,0"`***
Само собой, после внесения всех изменений вам даже не обязательно перезапускать процесс explorer.exe. Все будет работать просто после повторного открытия проводника Windows. Сам результат выполнения таких действий можно увидеть ниже:
**Рис. 7. Результат выполненных в системе изменений**
Между прочим, при желании вы даже можете редактировать значки и описания любых типов файлов, а также предопределять программы, установленные по умолчанию для этих же типов.
Итоги
-----
В принципе, эти две бесплатные утилиты являются лишь небольшим примером того, как можно изменять компоненты системы, которые, как казалось бы, неподвластны изменениям средствами пользовательского интерфейса. В этой статье специально не были рассмотрены какие-либо твиккеры и чистилки реестра, так как, откровенно говоря, от них порою может быть лишь больше вреда для операционной системы, чем пользы, как казалось бы обычному пользователю. Если эта тема для вас была интересной, в следующем посте могу рассмотреть методы автоматизации очистки операционной системы и системного реестра Windows 8 от различного мусора штатными средствами операционной системы.
А изменяете ли вы в своей системе возможности каких-либо компонентов и добавляете ли в них свои опции? | https://habr.com/ru/post/178359/ | null | ru | null |
# Неочевидная особенность в синтаксисе определения переменных
Предлагается совершенно невинный на вид кусок кода на C++. Здесь нет ни шаблонов, ни виртуальных функций, ни наследования, но создатели этого чудесного языка спрятали грабли посреди чистa поля.
> `struct A {
>
> A (int i) {}
>
> };
>
>
>
> struct B {
>
> B (A a) {}
>
> };
>
>
>
> int main () {
>
> int i = 1;
>
> B b(A(i)); // (1)
>
> return 0;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Вопрос: какой тип у переменной b? Совсем не тот, который можно было бы предположить на первый взгляд.
#### Анализ
Конечно же, тип переменной b не B, иначе бы не было этой статьи :) Я не буду сразу приводить ответ, а вместо этого расскажу, как до него можно дойти, не копаясь в тысячестраничном стандарте.
Для начала добавим немного отладочной печати:
> `#include
>
> struct A {
>
> A (int i) { std::cout << 'A';}
>
> };
>
>
>
> struct B {
>
> B (A a) { std::cout << 'B';}
>
> };
>
>
>
> int main () {
>
> int i = 1;
>
> B b(A(i)); // (1)
>
> return 0;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Если попробовать запустить этот код, окажется, что **вообще ничего** не выводится. Но если заменить строку (1) на
> `B b(A(1));`
внезапно всё начинает работать.
А теперь посмотрим внимательно на вывод компилятора при максимально включенных предупреждениях
> `$ g++ -W -Wall test.cpp
>
> x.cpp:2: warning: unused parameter ‘i’
>
> x.cpp:6: warning: unused parameter ‘a’
>
> x.cpp: In function ‘int main()’:
>
> x.cpp:10: warning: unused variable ‘i’`
С первыми двумя строками всё понятно, действительно параметры конструкторов не используются. А вот последняя строка выглядит очень странно. Как переменная i оказалась неиспользуемой, если она используется в следующей строке?
В принципе, этой информации достаточно, чтобы, немного подумав, ответить на поставленный вопрос. Но если умные мысли в голову не приходят, и хочется ещё немного поприключаться, почему бы просто не спросить компилятор? На помощь приходит RTTI.
> `#include
>
> #include
>
>
>
> struct A {
>
> A (int i) {}
>
> };
>
>
>
> struct B {
>
> B (A a) {}
>
> };
>
>
>
> int main () {
>
> int i = 1;
>
> B b(A(i)); // (1)
>
> std::cout << typeid(b).name() << std::endl;
>
> return 0;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
При компиляции GCC 4.3 результатом выполнения этой программы является строка
> `F1B1AE`
в которой зашифрована нужная нам информация о типе переменной (конечно, другой компилятор выдаст другую строку, формат вывода [type\_info::name()](http://www.cplusplus.com/reference/std/typeinfo/type_info/) в стандарте не описан и оставлен на усмотрение разработчика). Узнать же, что означают эти буквы и цифры, нам поможет c++filt.
> `$ c++filt -t F1B1AE
>
> B ()(A)`
Вот и ответ: это функция, принимающая на вход параметр типа A и возвращающая значение типа B.
#### Причина
Осталось понять, почему наша строка проинтерпретировалась таким неожиданным способом. Всё дело в том, что в объявлении типа переменной лишние скобки вокруг имени игнорируются. Например, мы можем написать
> `int (v);`
и это будет означать в точности тоже самое, что
> `int v;`
Поэтому многострадальную строку (1) можно без изменения смысла переписать, убрав лишнюю пару скобок:
> `B b(A i);`
Теперь невооружённым взглядом видно, что b это объявление функции с одним аргументом типа A, которая возвращает значение типа B.
Заодно мы объяснили странный ворнинг о неиспользованной переменной i — действительно, она не имеет никакого отношения к формальному параметру i.
#### Workarounds
Нам осталось только объяснить компилятору, что же на самом деле мы от него хотим — то есть, получить переменную типа B, проинициализированную переменной типа A. Самый простой способ — добавить лишних скобок, вот так:
> `B b((A(i)));`
или так:
> `B b((A)(i));`
Этого достаточно, чтобы убедить парсер, что это не объявление функции.
Как альтернативу, можно использовать форму вызова конструктора с помощью присваивания, если только конструктор не объявлен explicit:
> `B b = A(i);`
Несмотря на наличие знака '=', никакого лишнего копирования здесь не происходит, в чём можно легко убедиться, заведя в классе B приватный конструктор копирования.
А можно просто ввести дополнительную переменную:
> `A a(i);
>
> B b(a);`
Правда, при этом потребуется лишнее копирование переменной a, но во многих случаях это приемлемо.
Выберите тот способ, который кажется вам более понятным :)
Навеяно [постом в StackOverflow](http://stackoverflow.com/questions/1379932/trick-question-regarding-declaration-syntax-in-c)
P.S. Спасибо [sse](https://habrahabr.ru/users/sse/) за уточнения. | https://habr.com/ru/post/68796/ | null | ru | null |
# Именованные аргументы функции в C
В некоторых языках существует возможность вызова функции с именованными параметрами. Такой способ позволяет указать аргумент для определённого параметра, связав его с именем параметра, а не с позицией. Это возможно, например, в C# или Python.
Рассмотрим «игрушечный» пример на Python с использованием именованных аргументов:
```
#вычислим объем параллелепипеда
#если значение стороны не указано, то считаем что оно равно единице
def volume(length=1, width=1, height=1):
return length * width * height;
print(volume()) # V = 1
print(volume(length=2)) # V = 2
print(volume(length=2, width=3)) # V = 6
print(volume(length=2, width=3, height=4)) # V = 24
```
Здесь в примере одна и та же функция вызывается с разными аргументами. И видно, какой параметр каким значением проинициализирован. Если у функции есть параметры, значения которых можно оставить по умолчанию, то очень удобно проинициализировать только необходимые параметры с помощью именованных аргументов. Но в языке C аргументы функции связаны с позицией, поэтому разработчику нужно помнить порядок следования параметров, что может быть неудобно, если их достаточно много.
Ниже я покажу, как можно сымитировать использование именованных аргументов в C.
### Меньше слов — больше кода
Самое очевидное решение – передавать в функцию не разрозненный набор параметров, а структуру. Инициализировать ее удобно списком в фигурных скобках. Например:
```
#include
typedef struct {
int length, width, height;
} params\_s;
int volume\_f(params\_s in) {
return in. length \* in. width \* in.height ;
}
int main() {
params\_s p = {.length=8, .width=4, .height=2};
/\* Volume1 = 64 \*/
printf("Volume1 = %i\n", volume\_f(p));
/\* Volume2 = 0 \*/
printf("Volume2 = %i\n", volume\_f( (params\_s){.width=4, .height=2}) );
return 0;
}
```
Стало немного лучше, но все равно осталась проблема с параметрами по умолчанию, если они отличны от нуля. Так в примере выше Volume2 = 0, т.к. поле length по умолчанию проинициализировалось нулем. Еще за именованные аргументы мы платим тем, что должны создавать структуру или помнить ее название, если делаем приведение типов. Да и делать постоянно приведение типов неудобно. Но на помощь приходят…
### Вариативные макросы
Макросы, которые принимают переменное число аргументов, появились в C99. Объявляются они также как и функция, которая принимает переменное число аргументов: нужно добавить многоточие в качестве последнего аргумента. Идентификатор \_\_VA\_ARGS\_\_ заменяется аргументами, переданными в многоточии, включая запятые (точки с запятой) между ними. Сферический пример ниже.
```
#include
#define printArray(str, ...) { \
double d[] = {\_\_VA\_ARGS\_\_, 0} ; \
puts(str); \
for(int i = 0; d[i] !=0; i++) \
printf("%g ", d[i]); \
puts(""); \
}
#define DO(...){ \_\_VA\_ARGS\_\_ }
int main() {
printArray("cool array: ", 1, 2, 3, 4, 5);
/\* обратите внимание, что функции перечислены через точку с запятой \*/
DO(puts("hello"); puts("world"); return 0);
return 0;
}
```
После работы препроцессора макросы развернутся в такой код:
```
int main() {
{ double d[] = {1, 2, 3, 4, 5, 0} ; /*...*/};
{ puts("hello"); puts("world"); return 0;};
return 0;
}
```
Используя вариативный макрос, мы можем просто заранее проинициализировать структуру, а потом добавить то, что было передано в него.
### Итог
Теперь, соединив все воедино, можно притвориться, что в C тоже есть возможность вызвать функцию, передав ей именованные аргументы.
В итоге получился такой код:
```
#include
typedef struct {
int length, width, height;
} params\_s;
int volume\_f(params\_s in) {
return in. length \* in.width \* in.height ;
}
#define volume(...) \
volume\_f((params\_s){.length=1, .width=1, .height=1 , \_\_VA\_ARGS\_\_})
int main() {
printf("volume(): %i\n", volume());
printf("volume(.length = 2): %i\n", volume(.length =2 ));
printf("volume(.length = 2, .width = 3): %i\n",
volume(.length = 2, .width = 3));
printf("volume(.length = 2, .width = 3, .height =4): %i\n",
volume(.length =2, .width =3, .height =4));
}
```
Все примеры компилируется с флагом -std=c99 или -std=gnu99
Т.к. при вызове функции происходит переприсвоение значений полям структуры, то компиляторы выдают варнинг.
GCC выдаст:
```
warning: initialized field overwritten [-Woverride-init]
clang:
warning: initializer overrides prior initialization of this subobject [-Winitializer-overrides].
```
Если надо его отключить, используем соответственно флаги: -Wno-initializer-overrides для clang или -Wno-override-init для gcc.
Подробней про вариативный макрос написано, например, [в Википедии](https://ru.wikipedia.org/wiki/%D0%92%D0%B0%D1%80%D0%B8%D0%B0%D1%82%D0%B8%D0%B2%D0%BD%D1%8B%D0%B9_%D0%BC%D0%B0%D0%BA%D1%80%D0%BE%D1%81)
Идея взята из книги [Бена Клеменса](http://shop.oreilly.com/product/0636920033677.do) | https://habr.com/ru/post/248385/ | null | ru | null |
# Решение проблемы кодировки в GSP-страницах (без Grails)
В какой-то момент проявилась одна заметная проблема, мешающая мне осуществить абсолютно 100% замену PHP на Groovy для веба без использования относительно тяжеловесного MVC-фреймворка Grails.
Это касается \*.gsp страниц (Groovy Server Pages), представляющих собой html-страницы со вставками вида <%… %> с произвольным кодом на Groovy или Java, или на языке оригинала: "*GSP means GroovyServer Pages, which is similar to JSP (JavaServer Pages).*"
Точно такая же функциональность в PHP реализуется вставками … ? (причем для PHP наличие такого блока является обязательным, даже если он реализует классы или бизнес-логику; если после такого блока будет находиться обычно невидимый пробел или перенос строки, то он попадет в вывод, что может привести к проблемам).
На сайте груви написано: "*GSP are not maintained as a standalone module. But it has been forked and reintegrated in Grails*." Но, тем не менее, как и груви-сервлеты, gsp-страницы работают и без Grails, достаточно просто подключить груви к приложению.
Проблема заключалась в том, что в этих gsp-страницах русский текст превращался в «кракозябры». В груви-сервлетах, как в «настоящих», так и скриптового вида, такого не наблюдалось.
Методом научного тыка выяснилось, что если исходник gsp перевести в кодировку по-умолчанию на системе (например, cp1251 для Windows), то проблема решается (притом вывод страницы идет уже в UTF-8).
А это чистой воды подсказка: идем в исходники сервлета groovy.servlet.TemplateServlet.java, который отвечает за разбор таких страниц, и находим там строку:
```
private static final String GROOVY_SOURCE_ENCODING = "groovy.source.encoding";
```
Там же видно, как этот параметр влияет на создание экземпляра Reader-а.
Прописываем в web.xml приложения параметр сервлету со значением «UTF-8», и вуаля, — проблема решена.
Полный текст web.xml приложения, в котором все произвольные \*.groovy и \*.gsp файлы будут компилироваться в сервлеты и корректно выводить кириллицу:
```
xml version="1.0" encoding="UTF-8"?
GroovyServlet
groovy.servlet.GroovyServlet
GroovyServlet
\*.groovy
\*.grv
GSP
groovy.servlet.TemplateServlet
groovy.source.encoding
UTF-8
GSP
\*.gsp
```
Здесь так же показано, как длинное расширение .groovy, которое будет «светиться» в url-адресах можно заменить произвольным коротким, например .grv (или .php — just 4 fun).
Теперь можно быстро и просто писать сайты, веб-приложения, фреймворки на Groovy, для чего понадобятся только установленные Java и Tomcat на сервере. | https://habr.com/ru/post/129285/ | null | ru | null |
# (in)Finite War
We have a problem. The problem with testing. The problem with testing React components, and it is quite fundamental. It’s about the difference between `unit testing` and `integration testing`. It’s about the difference between what we call unit testing and what we call integration testing, the size and the scope.
It's not about testing itself, but about Component Architecture. About the difference between testing **components**, standalone libraries, and final **applications**.
Everyone knows how to test simple components(they are simple), probably know how to test Applications(E2E). How to test *Finite* and *Infinite* things…
Define the Problem
------------------
There is 2 different ways to test React Component — `shallow` and everything else, including `mount`, `react-testing-library`, `webdriver` and so on. Only `shallow` is special — the rest behave in the same manner.
And this difference is about *the size, and the scope* — about WHAT would be tested, and just partially *how*.
In short — `shallow` will only record calls to React.createElement, but not running any side effects, including rendering DOM elements — it's a side(algebraic) effect of React.createElement.
Any other command will run the code you provided with each and every side effect also being executed. As it would be in real, and that's the goal.
And **the problem** is following: `you can NOT run each and every side effect`.
### Why not?
Function purity? Purity and Immutability — the holy cows of today. And you are slaughtering one of them. The axioms of unit testing — no side effects, isolation, mocking, everything under control.
* But that's is *not a problem* for… `dumb components`. They are dumb, contains only the presentation layer, but not "side effects".
* But that's *a problem* for `Containers`. As long they are not dumb, contains whatever they want, and fully about side effects. They are the problem!
Probably, if we define the rules of "The Right Component" we could easily test — it will guide us, and help us.
> TRDL: The Finite Component
Smart and Dumb components
-------------------------
According to [Dan Abramov Article](https://medium.com/@dan_abramov/smart-and-dumb-components-7ca2f9a7c7d0) Presentation Components are:
* Are concerned with how things look.
* May contain both presentational and container components`**` inside, and usually have some DOM markup and styles of their own.
* Often allow containment via this.props.children.
* Have no dependencies on the rest of the app, such as Flux actions or stores.
* Don’t specify how the data is loaded or mutated.
* Receive data and callbacks exclusively via props.
* Rarely have their own state (when they do, it’s UI state rather than data).
* Are written as functional components unless they need state, lifecycle hooks, or performance optimizations.
* Examples: Page, Sidebar, Story, UserInfo, List.
* ....
* And Containers are just data/props providers for these components.
According to the origins: **In the ideal Application…
Containers are the Tree. Components are Tree Leafs.**
#### Find the black cat in the dark room
The secret sauce here, one change we have to amend in this definition, is hidden inside *“May contain both presentational and container components`**`”*, let me cite original article:
> In an earlier version of this article I claimed that presentational components should only contain other presentational components. I no longer think this is the case. Whether a component is a presentational component or a container is its implementation detail. You should be able to replace a presentational component with a container without modifying any of the call sites. Therefore, both presentational and container components can contain other presentational or container components just fine.
Ok, but what about the rule, which makes presentation components unit testable – *“Have no dependencies on the rest of the app”*?
Unfortunately, by including containers into the presentation components you are making second ones **infinite**, and injecting dependency to the rest of the app.
Probably that's not something you were intended to do. So, I don't have any other choice, but to make dumb component finite:
**PRESENTATION COMPONENTS SHOULD ONLY CONTAIN OTHER PRESENTATION COMPONENTS**
And the only question, you should ask (looking into your current code base): *How?* :tableflip:?!
Today Presentation Components and Containers are not just entangled, but sometimes just not extracted as "pure" entities (hello GraphQL).
#### Solution 1 — DI
Solution 1 is simple — don't contain nested containers in the dumb component — contain `slots`. Just accept "content"(children), as props, and that would solve the problem:
* you are able to test dumb component without "the rest of your app"
* you are able to test integration with smoke/integration/e2e test, not tests.
```
// Test me with mount, with "slots emty".
const PageChrome = ({children, aside}) => (
{aside}
{children}
);
// test me with shallow, or real integration test
const PageChromeContainer = () => (
}>
);
```
Approved by Dan himself:
{% twitter 1021850499618955272 %}
DI(both Dependecy Injection and Dependency Inversion), probably, is a most reusable technique here, able to make your life much, much easier.
> Point here — Dumb components are dumb!
#### Solution 2 — Boundaries
This is a quite declarative solution, and could extend `Solution 1` — just declare all *extension* points. Just wrap them with… `Boundary`
```
const Boundary = ({children}) => (
process.env.NODE_ENV === 'test' ? null : children
// or `jest.mock`
);
const PageChrome = () => (
);
```
Then — you are able to disable, just zero, `Boundary` to reduce Component scope, and make it *finite*.
> Point here — Boundary is on Dumb component level. Dumb component is controlling how Dumb it is.
### Solution 3 — Tier
Is the same as Solution 2, but with more smart Boundary, able to mock *layer*, or *tier*, or whatever you say:
```
const checkTier = tier => tier === currentTier;
const withTier = tier => WrapperComponent => (props) => (
(process.env.NODE_ENV !== ‘test’ || checkTier(tier))
&&
);
const PageChrome = () => (
);
const ASideContainer = withTier('UI')(...)
const Page = withTier('Page')(...)
const PageChromeContainer = withTier('UI')(PageChrome);
```
> Even if this is almost similar to Boundary example — Dumb component is Dumb, and Containers controlling visibility of other Containers.
#### Solution 4 — Separate Concerns
Another solution is just to Separate Concerns! I mean — you already did it, and probably it's time to utilize it.
> By `connect`ing component to Redux or GQL you are producing *well known* Containers. I mean — with *well-known* names — `Container(WrapperComponent)`. You may mock them by their names
```
const PageChrome = () => (
);
// remove all components matching react-redux pattern
reactRemock.mock(/Connect\(\w\)/)
// all any other container
reactRemock.mock(/Container/)
```
This approach is a bit rude — it will wipe *everything*, making harder to test Contaiers themselves, and you may use a bit more complex mocking to keep the "first one":
```
import {createElement, remock} from 'react-remock';
// initially "open"
const ContainerCondition = React.createContext(true);
reactRemock.mock(/Connect\(\w\)/, (type, props, children) => (
{ opened => (
opened
? (
// "close" and render real component
{createElement(type, props, ...children)}
)
// it's "closed"
: null
)}
)
```
> Point here: there is no logic inside nor Presentation, not Container — all logic is outside.
#### Bonus Solution — Separate Concerns
You may keep *tight coupling* using `defaultProps`, and nullify these props in tests...
```
const PageChrome = ({Content = Page, Aside = ASideContainer}) => (
);
```
So?
---
So I've just posted a few ways to reduce the scope of any component, and make them much more testable. The simple way to get one `gear` out of the `gearbox`. A simple pattern to make your life easier.
E2E tests are great, but it's hard to simulate some conditions, which could occur inside a deeply nested feature and be ready for them. You have to have unit tests to be able to simulate different scenarios. You have to have integration tests to ensure that everything is wired properly.
You know, as Dan wrote in [his another article](https://overreacted.io/the-elements-of-ui-engineering/):
> For example, if a button can be in one of 5 different states (normal, active, hover, danger, disabled), the code updating the button must be correct for 5×4=20 possible transitions — or forbid some of them. How do we tame the combinatorial explosion of possible states and make visual output predictable?
While the right solution here is state machines, being able to cherry-pick a single atom or molecule and play with it — is the base requirement.
### The main points of this article
1. Presentational components should only contain other presentational components.
2. Containers are the Tree. Components are Tree Leafs.
3. You don't have to *always* NOT contain Containers inside Presentational ones, but *not contain them* only in tests.
> You may dive deeper into the problem by reading the [medium article](https://hackernoon.com/testing-the-finite-react-components-d08ca74eb8c1), but here let's skip all the sugar.
PS: This is a translation of *ru-habr* article [habr version](https://habr.com/post/434830/). | https://habr.com/ru/post/436692/ | null | en | null |
# Kogito + Knime = new instance of match made in heaven?
Very often we've heard that some frameworks fit together so good, that they are considered as "match made in heaven". In this article I would like to share our experience regarding integration of those frameworks.
Introduction
------------
Recently we were investigating possibility to introduce some kind of business automation framework in our quarkus-based set of microservices[. Quarkus](https://quarkus.io/) has acquired rather big amount of libraries and is steeply evolving from the niche solution to the set of libraries, which can solve problems of different nature. For business automation quarkus framework suggests usage of [kogito](https://kogito.kie.org/) framework. This is a collection of well established frameworks like drools, jbpmn, optaplanner with ability to be executed as cloud-native services. [Knime](https://www.knime.com/) is well known data analytics platform and while analytics platform is available as open source solution, knime servers are available only by subscription. Therefore we've got an idea to create a prototype, where we have trained a model using knime data analytics platform and then embed it into kogito on quarkus, compile it in native mode using [GraalVM](https://www.graalvm.org/22.0/reference-manual/native-image/Options/) and host on kubernetes platform.
Oversimplified use case
-----------------------
For our prototype we have taken following use case: based on location we would like to retrieve recommendations regarding outerwear.
Oversimplified use case for kogito prototypeSurely, this use case could be implemented in kogito using simple gateway, as shown on the picture, but our idea was to incorporate decision tree model resulting from Knime data mining into kogito model.
Technical implementation, 9000 feet view
----------------------------------------
Technical implementation of the prototype includes rest-based service, which accepts location as input parameter, then connects to [openweather api](https://openweathermap.org/) to get current weather in the location provided and provides this information to the decision model. It uses embedded decision tree model, exported from knime, for making decisions. Result of decision (generally T-Shirt or Winter Jacket or Magenta T-Shirt or Magenta Winter Jacket for Bonn location) is returned to the service consumer.
Technical implementation, closer look
-------------------------------------
As it described in many quarkus kogito tutorials, creation of a project with dmn inside is a pretty simple task (see for example <https://quarkus.io/guides/kogito>). Generally we create the new quarkus project with enabled kogito extensions, then create model classes and then design dmn. In our case we were using openapi generator (api first approach) to automatically generate interface classes out of rest interfaces (for out prototype and for openweather service). Doing so we could skip writing them manully.
Auxiliary classes
-----------------
To provide mapping between internal dmn classes and to create rest-client for consumption of openweather api, we have created additional classes.
with following content:
WeatherRestClient.java:
```
@Path("/weather")
@RegisterRestClient(configKey="weather")
public interface WeatherRestClient {
@GET
@Produces("application/json")
Model200 get(@QueryParam("q") String location, @QueryParam("appId") String applicationId,
@QueryParam("units") String units);
}
```
ClothesResponse is just a simple dto for internal model represenation with fields:
```
private Main main;
private Clothes clothes;
private String location;
```
WeatherMapper is just a simple mapper from internal representation to external representation using [mapstruct](https://mapstruct.org/) library:
```
@ApplicationScoped
@Mapper(componentModel = "cdi")
public interface WeatherMapper {
default Clothes mapResponseToClothes(ClothesSelectorResponse response) {
return response.getClothes();
}
}
```
WeatherService contains some logic to invoke rest client and provide default answer:
```
@ApplicationScoped
public class WeatherService {
@Inject
@RestClient
WeatherRestClient weatherRestClient;
@ConfigProperty(name="weather.appId")
String applicationId;
@Fallback(fallbackMethod = "defaultWeather")
public Main get(String location) {
Model200 weatherModel = weatherRestClient.get(location, applicationId,"metric");
return weatherModel.getMain();
}
public Main defaultWeather(String location) {
Main main = new Main();
main.setTemp(new BigDecimal(0.0));
return main;
}
}
```
Main.class for openweather structure is not an intention to introduce bad practices it is named so in original openweather api specification, so for prototyping purposes it is left as is.
BPMN and DMN
------------
Having all the stuff prepared, it's time to create BPMN and DMN in it. We skip here detailed description, how to create such kind of model, just concentrate on some basic stuff.
The "Get weather by location" and "Map internal representation to external" custom tasks are just invocations of WeatherService.get and WeatherMapperImpl.mapResponseToClothes.
The "REST" rectangle is rather interesting here, namely this is an REST endpoint to invoke embedded DMN with following definition:
```
[
[
"name" : "Rest",
"parameters" : [
"Url" : new StringDataType(),
"ContentData" : new ObjectDataType(),
"Method": new StringDataType,
"Host" : new StringDataType(),
"Port" : new IntegerDataType(),
"Username" : new StringDataType(),
"Password" : new StringDataType()
],
"results" : [
"Result" : new ObjectDataType(),
],
"displayName" : "REST",
"icon" : "defaultservicenodeicon.png"
]
]
```
with following settings:
Clothes Selector is in this case the name of the embedded DMN.
So, there are 2 input structures (main with weather information and location with location information). The stuff on the right hand side represents Function based on embedded pmml and it's invocation.
Finally in clothes decision DMN we use dmn context to put result of function invocation to the right field inside of tClothes structure.
PMML model
To get trained model for providing decisions, which outerwear to take based on location an temperature we will use Knime data analytics platform.
The input data are delivered as csv file with following information:
So we are building decision tree model using location and temp as input data and outerwear as decision data. Underwear column is skipped in framework of this prototype.
Input data are split into data, which are used for model training and data (80%), which are used for test execution (20%)
Result of Decision Tree Learner is saved as model in pmml format.
So, after successful learning of the model it is exported to the pmml file, which later on should be imported to the dmn model.
Putting all together
--------------------
Having all preparations, described above, done, we can write unit tests (we do so by sending some requests to external rest interfaces of the application) and execute it in jvm development mode. There are some error messages in the logs, if the kogito data index url is missing (i.e. endpoint for kogito indexing), so for development profile you might suppress them using following settings:
```
%dev.kogito.data-index.url=http://localhost:8080
```
When you execute application in the development mode, you can easily access not only external interface of the application, but also internal model interfaces (also they are listed in swagger-ui).
The final step is to provide correct compilator configuration for successful native compilation. Generally you should list all the resources, which you need inside of application, mark all classes, where reflection is used and specify classes, which shouldn't be initialized in compile time. In our case all the models (dmn, bpmn, pmml) should be listed as resources for native compilation.
Over last 2 years GraalVM error messages have been significantly improved, so that they give you now rather clear instruction which exactly classes should be initialized in the runtime. In complicated cases you still have possibility to use [tracing agent](https://www.graalvm.org/22.0/reference-manual/native-image/Agent/).
Running application in the native mode you have following benefits:
* significantly less resource consumption
* much shorter start times
* smaller size of docker image
There are following drawbacks:
* models are fixed during native compilation, so there is no chance to change them in runtime
* correct configuration of compiler options might be tricky in cases when libraries of different nature are used inside of application
Conclusion
----------
As the result of this prototyping activity we have created a way to create native quarkus rest-based services, which include as a decision tree any externally trained models. In our case most suitable mean to train such kind of models was Knime analytics platform.
In the follow-up article I want to describe more complicated scenario, when you need to embed more than one pmml model into dmn. Surprisingly, during configuration we have faced with some difficulties, so it might be interesting for the audience to have a look at our approach for solving them. | https://habr.com/ru/post/660721/ | null | en | null |
# Аппаратный ЭЛТ-фильтр для картинок
[](https://habr.com/ru/company/ruvds/blog/695058/)
Всю мою жизнь мне нравятся средства отображения информации — в виде электронно-лучевых трубок. В них есть определённый романтизм и шарм. Недаром их часто используют в иллюстрациях к фильмам антиутопиям.
В конце 2000-х набирали популярности социальные сети с фотографиями. И мне очень не хватало в те годы настоящего живого фильтра, который делает эффект телевизора. В один из прекрасных дней мне встретился проект, где из видоискателя от видеокамеры и фотоаппарата, сделали аппаратный фильтр для фотографий. Проект, когда я его встретил, уже не работал, а значит поле было не занято. Понял, вот это оно! И с тех пор идея поселилась в моей голове.
Как вы понимаете, этот проект — самый эпичный долгострой в моей жизни, раз я задумал его ещё в конце 2000-х. Где-то примерно в году 2015 он работал для друзей, и даже в 2016 году он ездил на Chaos Construction. Но это всё было не то, интерфейсы не те. И вот, наконец проект завершён, и может быть показан широкому зрителю.
А прежде, чем вы залезете под кат, можно сразу попробовать отфильтровать картинку — достаточно просто зайти в [мой телеграмм бот](https://t.me/hipcrt_bot).
Поехали, ниже много аппаратной жести.
Концепция
---------
Идея достаточно проста, родилась она в то время, когда автоматическая обработка фотографий только набирала обороты, и всякие аппаратные решения могли бы быть достаточно забавными.
На чёрно-белый ЭЛТ-монитор выводится картинка, затем фотографируется камерой, а дальше уже сводятся цвета.
Вообще, те, кто давно следят за моим творчеством, могут сопоставить несколько статей по данной теме. Например, когда я искал монитор, то в качестве него хотел использовать видоискатель от старой видеокамеры. Так получилась статья «[Мини ЭЛТ монитор](https://habr.com/ru/post/223357/)». Но, к сожалению, экран от видеокамеры оказался слишком мал для таких целей. Поэтому, в дальнейшем, я приобрёл небольшой чёрно-белый охранный монитор, который был больше по размерам и оказался намного более удобным для моей задачи.
*Охранный монитор «Topica TP-098»*
В процессе экспериментов я подбирал различные камеры. Вообще, хотел использовать зеркальный фотоаппарат и даже пробовал его подключать. Это вы читали в статье «[Старый фотик + bash = таймлапс](https://habr.com/ru/company/ruvds/blog/582660/)». К сожалению, из-за малого ресурса, а также всяких аппаратных косяков — решил отказаться от этого варианта. Остановился на Raspberry Pi и малиновой камере.
От идеи до готового прототипа
-----------------------------
*Внешний вид первого работающего прототипа (2016 г.)*
Сразу стало понятно, что для реализации всей задумки, мне понадобится готовый стенд. Он должен удовлетворять следующим параметрам:
1. Быть закрытым, чтобы не было бликов на мониторе.
2. Быть носимым, чтобы можно было перемещать по квартире.
3. В нём должна обеспечиваться достаточная вентиляция, чтобы монитор не перегревался.
4. Необходимо иметь возможность в широких пределах менять месторасположение камеры и жёстко её фиксировать.
### ▍ Фанерный ящик
Первое, что было изготовлено — это фанерный ящик. Тут никаких хитростей нет, разве что съёмная боковая и верхняя крышка. Для уменьшения бликов изнутри был окрашен чёрной тушью. Это было сделано по неопытности, идеальная краска, с хорошим светопоглащением, доступная в любом магазине — это акриловая газовая сажа.
Ящик не так прост, как кажется на первый взгляд. Как я уже сказал, необходимо обеспечить охлаждение, поэтому ящик располагается на ножках, которые просто вырезаны из той же фанеры, с набойкой из войлока. Это нужно, чтобы снизу было пространство для движения воздуха. В месте установки монитора — сделаны отверстия воздухозабора (там же, где они у самого монитора) и отверстия под его ножки. Для удобства подключения — сзади установлена обычная розетка, куда подключается монитор и блок питания одноплатника.
*Отверстия воздухозабора и под ножки*
*Дополнительная розетка питания сзади*
Для того чтобы камеру точно можно было позиционировать внутри, и она не сдвигалась в процессе эксплуатации, внутри решено было сделать деревянные рельсы. Изначально попробовал посмотреть, как это будет выглядеть из бросового материала — утеплителя.
Рельсу изготовил из соснового щита. Не самый лучший материал для таких целей, слишком мягкий. Но для разовой установки подойдёт.
*Готовые рельсы из соснового щита*
Когда стало понятно, что это крепление наиболее оптимально, я выпилил все необходимые детали на лобзиковом станке для установки болтов. Они нужны для регулировки высоты и наклона камеры. Прорезь нужна, чтобы можно было смещать камеру поперёк оси. Не знаю, как корректно именовать этот элемент, назову суппортом.
*Готовый суппорт*
В результате всех примерок и перестановок получился следующий готовый прототип.
На фотографии не видно, но суппорт прижимается к рельсам с помощью барашка. Это оказалось не очень удобно, и дальше я решил сделать фанерный диск с запрессованной гайкой.
### ▍ Окончательная сборка
Поскольку проект растянулся на много лет, и описать все события с ним, в рамках одной статьи, невозможно, основной акцент я дам только на последних изменениях. Аппаратные решения минувшего прошлого я просто не помню, всё это было утрачено в веках.
Мозгами всего устройства выступает Raspberry Pi 4, для камеры взял устаревший модуль V2. Поскольку всё работает в закрытом корпусе, для лучшего охлаждения одноплатника приобрёл дополнительный корпус-радиатор с вентиляторами.
*Исходники в коробочках*
После чего всё примеряю по месту и думаю об оптимальном расположении элементов.
*Примерка*
Самое сложное было сделать крепление камеры. Необходимо было обеспечить жёсткость крепления так, чтобы камера не болталась и не дрожала. Перепробовал несколько вариантов, самым оптимальным оказалось крепление на винтах М2, между гаек.
*Крепление камеры*
После всех манипуляций мне показалось, что слишком уж больно весело и светло всё выглядит, и я решил дополнительно окрасить всё газовой сажей. На фотографии ниже — видна фанерная прижимная гайка.
*Окраска*
После всех манипуляций эмпирическим путём было установлено, что совсем без света в ящике нельзя. Потому что не будет видно стильную рамку самого монитора. А самое главное, камера будет постоянно настраивать отдельную яркость под каждую картинку и картинка будет получаться неодинаковой освещённости. Поэтому внутрь установил световое кольцо, и на заднюю стенку поставил лист обычной бумаги. Между кольцом и суппортом проложил лист бумаги, покрашенный чёрной краской, чтобы не было засветов снизу, и не сияли металлические болты в кадре.
*Дополнительный свет*
Недостаток лампы в том, что на некоторых картинках можно видеть отсвет силуэта крепления камеры. Но пусть это будет не бага, а фича, которая показывает что установка реальная, аппаратная.
Всё укомплектовано, засветов лишних практически нет. Теперь всё готово к настройке и разработке софта.
*Готовый ящик*
*Ящик с закрытой крышкой*
Настройка и разработка софта
----------------------------
Самая сложная часть — это не собрать ящик, хоть эта часть выглядит круто и понятна каждому. Самая сложная и скрытная часть — это настроить всё, и разработать ПО.
### ▍ Корректная установка камеры
Для меня это самая муторная задача, потому что надо в течение нескольких часов двигать суппорт и крутить винты. И да, я до сих пор недоволен идеальностью выставленной камеры.
В первый раз я выставлял камеру достаточно хитрым способом: скачал на DVD-диск специальные настроечные таблицы и выводил с помощью проигрывателя эти таблицы на монитор, а на телевизор выводил результат того, что снимает камера.
*Настройка положения камеры в далёком 2016 году*
Сейчас такими глупостями заниматься я не стал, потому что ни телевизора, ни плеера у меня уже нет. Поступил сильно проще, я открыл [документацию на камеру для малины](https://www.raspberrypi.com/documentation/accessories/camera.html#libcamera-and-libcamera-apps). И просто сделал трансляцию того, что она выводит в VLC. Главное поставить разрешение поменьше, а с помощью fbi (Linux framebuffer imageviewer) выводил на экран обычную настроечную таблицу для чёрно-белых телевизоров и старался, чтобы она хоть как-то совпадала с тем, что я должен увидеть.
*Настроечная таблица чёрно-белых телевизоров*
Можно использовать и цветную. По ней сначала визуально настраиваю яркость-контраст монитора, а потом в течение нескольких часов двигаю суппорт туда-сюда, вдоль и поперёк рельсы, поднимаю-опускаю камеру, изменяю угол наклона так, чтобы квадраты были более-менее одинаковыми, и горизонт был не очень сильно завален.
В общем, после многочасовой изнуряющей настройки положения камеры, яркости монитора и всевозможных крутилок, можно убедиться, что результат получился нормальным. Далее предстоит кропотливый труд разработки ПО.
*Успешный вывод настроечной таблицы*
### ▍ Позвольте, а откуда цвет?
Внимательный читатель заметил, что в своём проекте я использую чёрно-белый монитор. Можно даже потрудиться, найти на него документацию и убедиться, что цвет он выводить не умеет. Но как же можно получить цветное изображение?
Всё просто, берётся цветная картинка, например:
И разделяется на три канала по цветам (делается это программно).
*Три отдельных картинки с каждым цветом*
Далее, каждый цвет отдельно выводится на монитор и фотографируется:
*Реальные фотографии с монитора*
После чего, все три кадра снова сводятся единую фотографию и получается снова цветное изображение.
*Изображение, полученное с монитора*
Виден засвет тёмной области, это именно та проблема, которая возникает в абсолютно тёмном ящике. Поэтому и нужен контр-свет.
### ▍ Разработка софта. Серверная часть
В первоначальном прототипе у меня был вебсайт, где всё работало через CGI. Но это было не самый удобный вариант и по многим параметрам он мне не нравится. Поэтому было принято волевое решение шагать в ногу со временем и сделать telegram-бота. Сам бот — это для меня запредельная магия (шучу), я потыкал в него палочкой и не смог реализовать. Поэтому слёзно просил помочь мне его сделать [man\_of\_letters](https://habr.com/ru/users/man_of_letters/). О подобном боте у нас есть отличная статья «[Проект — электрический помощник для редакции](https://habr.com/ru/company/ruvds/blog/677482/)». С небольшими изменениями из него получился бот для получения и отдачи фотографий пользователю. Более подробно рассказать не смогу, потому что сильно код бота не ковырял.
API работы устроено достаточно просто:
1. Бот принимает картинку от пользователя, шинкует её на три канала цвета RGB и сохраняет картинки в png с соответствующими именами.
2. После успешной шинковки создаёт просто пустой файл, с именем трёх файлов. Создание этого файла и имя файла является ключём для того, чтобы начать обработку.
3. После того как моё устройство заберёт эти файлы, перемелет их, а далее складывает обратно — все три обработанных файла в другую папку. Бот их сводит и отдаёт клиенту.
Итого, у меня три папки, которые и являются API для взаимодействия с ботом. Для работы с ними решили использовать протокол ssh, потому что это удобно, надёжно и просто. Как же я ошибался…
### ▍ Клиентская часть
Основная проблема работы по ssh — это держать постоянное подключение. И оказалось, что при длительном соединении постоянно «лопалась труба» (ошибка broken pipe).
Лопнувшие трубы ssh соединения сильно портили малину, и порой даже бились данные. Решила эти проблемы [следующая статья](https://dampi.ru/oshibka-client_loop-send-disconnect-broken-pipe). Но, изначальный сервер у нас был на Debian, любезно предоставленный компанией [RuVDS](https://ruvds.com/ru-rub), а там этот фокус вообще чуть не погасил весь ssh. Поэтому в срочном порядке пришлось переехать на сервер с Ubuntu 20.04. Для наших задач хватит самой простецкой конфигурации.
Далее там создаём файл:
```
sudo vim /etc/ssh/sshd_config.d/alive.conf
```
И добавляем туда следующие строки:
```
ClientAliveInterval 30
ClientAliveCountMax 30
TCPKeepAlive no
```
И не забываем перезапустить sshd-демон:
```
sudo systemctl restart ssh
```
Теперь возникает другой вопрос: как на стороне клиента aka Raspberry Pi мониторить создание файла на удалённом сервере?
Изначально для этих целей я использовал приложение inotifywait и отслеживал создание новых файлов, вот такой совершенно страшной конструкцией и далее в теле while уже делал все свои грязные дела:
```
ssh teleuser@$server inotifywait -e create /****/workaround --format "%f" -q -m| while read file; do
...
```
Но длительные тесты показали, что такой подход неэффективен: теряется часть файлов, и в случае потери соединения, мы уже не будем знать, что там произошло. Поэтому сделал на обычном ls, сортируя по дате добавления в обратном порядке, и по очереди пробегаясь по каждому файлу. И всё это запихал в большой цикл while. Не элегантно, но работает.
```
ssh teleuser@$server ls -1tr /*****/workaround | while read file; do
```
Вывод на экран делаю в консольном режиме, используя стандартную программу вывода во фреймбуффер:
```
sudo fbi -T 2 --nocomments --noverbose -a /***/hipcrt/${file%.*}$num.png
```
Самое сложное было разобраться с тем, как это фотографировать. Когда-то, давным-давно, я использовал приложение raspistill, но с тех пор много воды утекло и появилось другое приложение.
Необходимо было подобрать оптимальное разрешение, чтобы было всё чётко видно, и не занимало много места, и настроить выдержку с таким параметром, чтобы картинка успела отрисоваться вся, и при этом не было пересвета и баланс белого.
*Пример неудачно подобранной выдержки, когда идут разноцветные полосы из-за того, что кадр не успел отрисоваться весь.*
В результате после небольшого НИР получилась следующая команда:
```
libcamera-still -n --width 800 --height 600 -o /****/hipcrt/result/${file%.*}$num.jpg -e jpg --shutter 125000 -t 500 --awb fluorescent
```
Итоговый скрипт получился простым и лаконичным. В этом скрипте происходит удаление всех временных файлов, то есть пользовательские файлы на сервере не хранятся, для экономии места, и мы их увидеть, увы, не можем.
```
#!/bin/bash
server=***.***.***.***
while true
do
sleep 0.1
ssh teleuser@$server ls -1tr /*****/workaround | while read file; do
scp teleuser@$server:/*****/pic_from_user_split/${file%.*}* /*****/hipcrt/
ssh teleuser@$server rm -f /*****/workaround/$file
ssh teleuser@$server rm -f /*****/pic_from_user/${file%.*}*
ssh teleuser@$server rm -f /*****/pic_from_user_split/${file%.*}*
for num in "_r" "_b" "_g"
do
sudo fbi -T 2 --nocomments --noverbose -a /*****/hipcrt/${file%.*}$num.png
sleep 0.5
sudo libcamera-still -n --width 800 --height 600 -o /*****/hipcrt/result/${file%.*}$num.jpg -e jpg --shutter 125000 -t 500 --awb fluorescent
done
sudo killall fbi
scp /*****/hipcrt/result/${file%.*}* teleuser@$server:/*****/pic_from_crt/
rm -f /*****/hipcrt/*.png /*****/hipcrt/result/*
done
done
exit 0
```
На самом деле, я как-то так легко и просто всё расписал, но в реальности — вся эта куча экспериментов и опытов вылилась в недели работы, потому что было неясно, где и что отваливается.
Так, и где же я могу всё это попробовать?
-----------------------------------------
*Рекурсивная фотография аппаратного ЭЛТ-фильтра, обработанная на аппаратном ЭЛТ-фильтре*
Хочется уже попробовать, правда? Такая краткая инструкция для начинающих:
* Бот обитает [по следующему адресу](https://t.me/hipcrt_bot).
* Заходим в него и жмём «запустить».
* После этого у вас появится меню.
* Выбираем «Обработать новое изображение» и скармливаем любой графический файл со сжатием.
После этого ваше изображение добавляется в очередь. Обработка каждого изображения занимает 15 секунд, поэтому из-за хабраэффекта, пожалуйста, соблюдайте терпение, все получат свои картинки рано или поздно. С телефона всё выглядит вот так.
Чтобы канал не забил один крепкий кликер фоток — там стоит антиспам, ограничивающий количество фотографий от одного человека. Так что выбирайте фотографии лучше.
Заключение
----------
В моей жизни — этот проект самый эпичный долгострой, который всё же был реализован и доведён до конца. Проект меня многому научил. Когда я делал сайт, то впервые вообще столкнулся с js, php и вообще web-программированием, CGI вообще был для меня пустым звуком, а ещё разработка своих скриптов… Всё это стало для меня замечательным опытом и дало весьма неплохой навык, который пригодился в моей дальнейшей работе.
Да, сам проект может быть глупым и абсурдным, но лично меня он научил очень многому, и я благодарен, что он состоялся.
Главное я благодарен всем моим друзьям, которые мне помогали с этим проектом. Не буду перечислять всех по именам, вы все молодцы. Громадное спасибо [man\_of\_letters](https://habr.com/ru/users/man_of_letters/) за помощь с сайтом в начале пути, и за помощь с ботом в завершении проекта. Компании RuVDS за помощь в подготовке этого проекта.
А главное, вам мои дорогие читатели, за то, что будете его использовать и понимать что это просто прикольно!
**[HIPCRT\_BOT](https://t.me/hipcrt_bot)**
И напоследок, вот видео, которое изготовлено на этом аппарате. Понадобился день, чтобы обработать все кадры этого короткого видеоролика.
З.Ы. Если всё будет хорошо, постараюсь чтобы аппаратная часть проработала не меньше месяца!
> **[Telegram-канал с полезностями](https://inlnk.ru/dn6PzK) и [уютный чат](https://inlnk.ru/ZZMz0Y)**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=dlinyj&utm_content=apparatnyj_elt-filtr_dlya_kartinok) | https://habr.com/ru/post/695058/ | null | ru | null |
# Проблема с безопасностью при использовании аутентификации формами в ASP.NET
Сообщает [Peter Vogel](http://visualstudiomagazine.com/forms/emailtoauthor.aspx?AuthorItem=%7BDD0073EE-E182-4F32-B5FB-3F183FCFA220%7D&ArticleItem=%7BD74E8DAD-34EF-460E-AF36-56058B6D51C0%7D)
Два исследователя безопасности, Тай Донг (Thai Duong) и Джулиано Риццо( Juliano Rizzo), обнаружили баг в используемом по умолчанию механизме шифрования, который задействован в защите куки, обычно применяемых для реализации аутентификации формами (Forms Authentication) в ASP.NET. С помощью разработанного исследователями инструмента ([Padding Oracle Exploit Tool](http://netifera.com/research/) или POET), можно многократно модифицировать куки, зашифрованные с помощью механизма шифрования AES и, исследуя возвращаемые ошибки, вычислить машинный ключ (Machine Key), используемый для шифрования куки. По утверждениям исследователей, процесс надёжен на 100% и занимает от 30 до 50 минут для любого сайта.
Как только машинный ключ был определён, атакующий может создавать фиктивные аутентификационные куки. И если разработчики сайта выбрали вариант встраивания информации о роли данного пользователя в куки, то атакующий может присвоить себе роль администратора. Эта дыра в безопасности может оказать влияние и на другие функции провайдера членства в ролях, защиту от спуфинга ViewState, других зашифрованных данных, которые могут храниться в куки или каким-то другим образом могут быть доступны на стороне клиента.
Плохая новость в том, что проблема обширна и требует немедленного решения. Хорошая же в том, что решение её достаточно просто. Данный хак эксплуатирует баг в .NET-реализации шифрования с использованием AES. Выход прост – необходимо переключиться на использование другого механизма шифрования – например, 3DES. А поскольку шифрование членства и провайдеров ролей обрабатывается ASP.NET, то никакой модификации существующего кода, использующего аутентификацию формами, не понадобится.
Метод шифрования можно изменить в файле web.config для сайта, в IIS 7 для веб-сервера или в конфигурационном файле .NET на сервере в каталоге %SYSTEMROOT%\Microsoft.NET\Framework\version\CONFIG\. На 64-битных системах так же необходимо изменить конфигурационный файл в каталоге %SYSTEMROOT%\Microsoft.NET\Framework64\version\CONFIG\. Типичная запись будет выглядеть таким образом:
`validation="3DES"
decryptionKey="AutoGenerate,IsolateApps"
decryption="3DES" />`
На веб-ферме этот параметр должен быть изменен на всех серверах фермы.
Эти параметры также используются для предотвращения спуфинга ViewState (данные ViewState кодируются, но не шифруются). Поэтому если вы внесёте эти изменения, это также приведёт к шифрованию ViewState с использованием 3DES.
Разработчики, которые используют AES для шифрования информации, доступной на клиенте, должны рассмотреть возможность изменения кода, с целью использования другого механизма шифрования.
Донг и Риццо намерены предоставить более подробную информацию об этой проблеме [на конференции по безопасности](http://ekoparty.org/index.php), которая пройдёт в пятницу, 17 сентября в Буэнос-Айресе. | https://habr.com/ru/post/104258/ | null | ru | null |
# Криптография в Java. Класс KeyPair
Привет, Хабр! Представляю вашему вниманию перевод 6, 7 и 8 статей автора Jakob Jenkov из [серии статей для начинающих](http://tutorials.jenkov.com/java-cryptography/index.html), желающих освоить основы криптографии в Java.
Оглавление:
-----------
1. [Java Cryptography](https://habr.com/ru/post/444764/)
2. [Java Cipher](https://habr.com/ru/post/444814/)
3. [MessageDigest](https://habr.com/ru/post/444974/)
4. [Mac](https://habr.com/ru/post/445228/)
5. [Signature](https://habr.com/ru/post/445330/)
6. KeyPair
7. KeyGenerator
8. KeyPairGenerator
9. [KeyStore](https://habr.com/ru/post/445786/)
10. [Keytool](https://habr.com/ru/post/446322/)
11. [Certificate](https://habr.com/ru/post/446888/)
12. [CertificateFactory](https://habr.com/ru/post/446888/)
13. [CertPath](https://habr.com/ru/post/446888/)
Ключевая пара
-------------
Класс KeyPair (**java.security.KeyPair**) представляет собой пару асимметричных ключей (открытый ключ + закрытый ключ). Экземпляр KeyPair обычно используется в асимметричной криптографии(шифрование или подпись данных). Обычно экземпляр KeyPair получают из хранилища ключей Java или KeyPairGenerator который будет рассмотрен далее в этой статье.
### Доступ к открытому ключу
Вы можете получить доступ к открытому ключу экземпляра KeyPair, вызвав его метод *getPublic()*. Пример получения открытого ключа:
```
PublicKey publicKey = keyPair.getPublic();
```
### Доступ к закрытому ключу
Так же можно получить доступ к закрытому ключу экземпляра KeyPair, вызвав его метод *getPrivate()*. Вот пример получения закрытого ключа:
```
PrivateKey privateKey = keyPair.getPrivate();
```
Генератор ключей
----------------
Класс KeyGenerator (**javax.crypto.KeyGenerator**) используется для генерации симметричных ключей шифрования. Симметричный ключ шифрования — это ключ, который используется для шифрования и дешифрования данных алгоритмом симметричного шифрования.
### Создание экземпляра KeyGenerator
Прежде чем вы сможете использовать класс KeyGenerator, вы должны создать экземпляр KeyGenerator. Экземпляр KeyGenerator создается вызывом статического метода *getInstance()*, в качестве параметра принимающего имя алгоритма шифрования, для которого создается ключ. Вот пример создания экземпляра KeyGenerator:
```
KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
```
В этом примере создается экземпляр KeyGenerator, который может генерировать ключи для алгоритма шифрования AES.
### Инициализация KeyGenerator
После создания экземпляра KeyGenerator его необходимо инициализировать. Инициализация экземпляра выполняется путем вызова метода *init()*. Пример инициализации экземпляра KeyGenerator:
```
SecureRandom secureRandom = new SecureRandom();
int keyBitSize = 256;
keyGenerator.init(keyBitSize, secureRandom);
```
Метод *init()* принимает два параметра: длина ключа и [SecureRandom](https://docs.oracle.com/javase/8/docs/api/java/security/SecureRandom.html), который используется во время генерации ключа.
### Генерация ключа
После инициализации экземпляра KeyGenerator вы можете использовать его для генерации ключей. Генерация ключа выполняется путем вызова метода *generateKey()*. Вот пример генерации симметричного ключа:
```
SecretKey secretKey = keyGenerator.generateKey();
```
Генератор ключевой пары
-----------------------
Класс KeyPairGenerator (**java.security.KeyPairGenerator**) используется для генерации асимметричных ключевых пар. Пара асимметричных ключей состоит из двух ключей: первый ключ обычно используется для шифрования данных, а второй ключ используется для расшифровки данных, зашифрованных с помощью первого ключа.
### Открытые и закрытые ключи
Наиболее известным типом пары асимметричных ключей является тип пары ключей вида: открытый ключ + закрытый ключ. Закрытый ключ используется для шифрования данных, а открытый ключ — для расшифровки данных. На самом деле, вы также можете зашифровать данные с помощью открытого ключа и расшифровать его с помощью закрытого ключа. Закрытый ключ обычно хранится в секрете, а открытый ключ может быть известен всем. Таким образом, если Джек зашифровывает некоторые данные своим закрытым ключом, каждый, кто владеет открытым ключом Джека, может расшифровать его.
### Создание экземпляра KeyPairGenerator
Чтобы использовать KeyPairGenerator, вы должны сначала создать экземпляр класса KeyPairGenerator. Создание экземпляра KeyPairGenerator выполняется путем вызова метода *getInstance()*. Вот пример создания экземпляра:
```
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
```
Метод *getInstance()* принимает имя алгоритма шифрования, который будет использоваться. В этом примере мы используем алгоритм RSA.
### Инициализация KeyPairGenerator
В зависимости от алгоритма, вам может потребоваться инициализация экземпляра KeyPairGenerator. Инициализация KeyPairGenerator выполняется путем вызова его метода *initialize()*. Пример инициализации экземпляра KeyPairGenerator:
```
keyPairGenerator.initialize(2048);
```
В этом примере инициализируется KeyPairGenerator для генерации ключей размером 2048 бит.
### Генерация ключевой пары
Чтобы сгенерировать ключевую пару с помощью KeyPairGenerator вызывается метод *generateKeyPair()*. Вот пример генерации ключевой пары:
```
KeyPair keyPair = keyPairGenerator.generateKeyPair();
``` | https://habr.com/ru/post/445560/ | null | ru | null |
# Встроенная поддержка FTP будет удалена в Firefox 90
Mozilla [объявила](https://blog.mozilla.org/addons/2020/04/13/what-to-expect-for-the-upcoming-deprecation-of-ftp-in-firefox/) о планах удалить встроенную поддержку FTP из браузера с релизом Firefox 90.
Поддержка в настоящее время уже отключена на каналах Nightly и Beta, а в стабильной версии будет отключена 19 апреля 2021 года с выходом Firefox 88. Полностью поддержка будет удалена в Firefox 90. После отключения FTP Firefox будет делегировать открытие ссылок `ftp://`на внешние приложения так же, как это происходит с другими протоколами.
После прекращения поддержки настройка `browserSettings.ftpProtocolEnabled`перейдет в режим «только чтения».
Расширения и дальше смогут без ошибок передавать запросы «ftp» при использовании фильтров для proxy или webRequest, но эти API больше не будут обрабатывать запросы таких типов.
Чтобы компенсировать удаление поддержки `ftp` он был добавлен в список поддерживаемых обработчиков протоколов для расширений браузера. Это означает, что расширения смогут предлагать пользователям запустить приложение FTP для обработки определенных ссылок.
Код, отвечающий за поддержку FTP, еще полностью не удален в Firefox 88, и поддержку можно временно вернуть до выхода Firefox 90, когда она будет полностью удалена из браузера.
* Откройте about:config
* Установите `network.ftp.enabled` на `true` | https://habr.com/ru/post/552910/ | null | ru | null |
# Настройка WPA2 Enterprise c RADIUS
*В статье пойдёт речь о вопросах расширенной аутентификации в беспроводной сети через WPA2 Enterprise. Для данной системы используется RADIUS сервер, поэтому рассмотрим краткий пример упрощённой установки и настройки.*
О методах аутентификации
------------------------
В предыдущих статьях, в частности: [Особенности защиты беспроводных и проводных сетей. Часть 1 — Прямые меры защиты](https://habr.com/ru/company/zyxel/blog/516508), — мы рассказывали о различных методах аутентификации.
Более или менее надёжным можно считать алгоритм защиты начиная с WPA2, а самый современный протокол аутентификации — WPA3, входящий в состав новшеств от WiFi 6. Но так как не все ещё перешли на WiFi 6, то WPA2 пока остаётся актуальным.
В свою очередь технология WPA2 подразделяется на два направления: **WPA2 Personal** и **WPA2 Enterprise**.
Вариант **WPA2 Personal** с PSK (Pre-Shared Key), проще говоря, «один-ключ-на все-устройства» используется в небольших (обычно в домашних сетях). При этом единственный ключ (длинная символьная строка не менее 8 символов) хранится на самой точке доступа и на каждом устройстве, подключаемом к беспроводной сети. Когда просят дать «пароль от WiFi», это тот самый ключ и есть.
При увеличении числа клиентов обслуживание такой беспроводной сети превращается в кошмар для сисадмина.
Если кто-то из пользователей со скандалом уволился, умудрился потерять ноутбук или случайно переслал ключ по почте (выложил общем чате, на форуме и так далее) ...
В общем, при малейшем подозрении на компрометацию ключа выход может быть только один — сгенерировать новый ключ и заменить его везде: на всех точках доступа и у всех пользователей на всех устройствах. При этом нужно обязательно проверить работает ли доступ у всех пользователей на всех корпоративных (а иногда и личных) девайсах, а ещё ответить на 1000 и 1 вопрос из разряда: «А зачем?», «А почему так произошло?», «А что, теперь постоянно менять придётся?» и так далее и тому подобное.
Поэтому для беспроводных сетей корпоративного уровня используется гораздо более совершенный вариант **WPA2 Enterprise**. Наиболее очевидной альтернативой общему ключу является индивидуальный ключ для каждого. Разумеется, в этом случае при подключении к сети запрашивается не только ключ, но и имя пользователя. Фактически это возврат к аутентификации на основе логин + длинный пароль. (Спасибо Капитану Очевидность за точные формулировки).
Вопрос в том, где хранить базу пользователей и паролей. Размер встроенной аппаратной флеш-памяти не «резиновый», а если точек доступа несколько, то нужно подумать, как выполнять синхронизацию учётных данных между ними.
Гораздо проще использовать внешний сервер для аутентификации. **WPA2 Enterprise** использует для этих целей RADIUS.
**RADIUS** (*Remote Authentication in Dial-In User Service*) — сервис AAA (Authentication, Authorization, Accounting), основанный на использовании отдельного сервера, взаимодействующего с клиентами (оборудованием) по специальным протоколам.
На сегодняшний момент наиболее популярны следующие реализации:
* **Microsoft Network Policy Server (NPS), бывший IAS** — для конфигурации используется встроенный инструментарий Microsoft. Соответственно, нужно купить необходимые лицензии.
* **Cisco Secure Access Control Server (ACS) 4.2, 5.3** — для администрирования использует веб-интерфейс, имеет широкий набор полезных функций. Это также платный продукт.
* **FreeRADIUS** — распространяется бесплатно, может использоваться как в «чистом виде», так и вкупе с различными СУБД (MySQL и другие), имеются веб-интерфейсы (DaloRADIUS, Dual-In), в общем, довольно известное решение.
Существуют и другие реализации данного сервиса. Для настройки главное понять принцип взаимодействия с сервером аутентификации, всё остальное можно найти в документации.
> **Интересный факт.** Аппаратные шлюзы и контроллеры точек доступа Zyxel уже имеют встроенный сервис RADIUS «на борту». А облачная среда Zyxel Nebula может похвастаться собственной системой аутентификации, отличной от RADIUS, но выполняющей те же функции. Поэтому самостоятельная установка внешнего сервера аутентификации — процесс интересный, но отнюдь не всегда обязательный. Есть и более простые варианты.
Взаимодействие точки доступа с сервером RADIUS
----------------------------------------------
Для обмена данными с сервером RADIUS используется протокол UDP (User Datagram Protocol) по принципу «клиент-сервер». В роли клиента выступает точка доступа (или другое устройство, нуждающиеся в службе аутентификации), которая обращается к серверу RADIUS с запросами о проверке учётных записей.
В зависимости от настройки и схемы использования сервер RADIUS может сообщать клиенту не только информацию об успешной аутентификации, но и другие параметры: VLAN клиентского устройства, IP адрес, QoS профиль и так далее.
Для создания безопасного соединения клиент и сервер RADIUS обладают общим ключом.
В отказоустойчивой production схеме используется более одного сервера RADIUS. Например, точка доступа NWA210AX может использовать для проверки два сервера: основной и резервный.
**Кратко рассмотрим порядок взаимодействия**
Пользователь подключает устройство (корпоративный ноутбук или любое другое). Для этого он вызывает соответствующий интерфейс для настройки. Появляется окно подключения, где он вводит логин и пароль.
Точка доступа принимает эти данные и для проверки аутентификации передаёт на сервер RADIUS.
Сервер RADIUS по своим записям проверяет данного пользователя и его пароль, и, в зависимости от результата, возвращает одно из значений: «Accepted» (Принято) или «Rejected» (Отклонено).
При получении «Accepted» (Принято) между клиентом и точкой доступа происходит обмен индивидуальными ключами шифрования, действующими только на время, установленное для данной сессии.
Рисунок 1. Использование сервера RADIUS для аутентификации.
Вообще на тему установки RADIUS написано очень много How-to, в том числе интеграцией с различными СУБД, использованию веб-интерфейса и так далее.
Однако невозможно объять необъятное, поэтому сейчас остановимся на самой простой реализации: сервер FreeRADIUS без сторонних продуктов, который настраивается путём изменения конфигурационных файлов.
> **ВНИМАНИЕ!** Ниже приводится именно простейший пример для иллюстрации, а не готовая шпаргалка для копирования и размножения у себя в рабочей среде.
Описание примера настройки и взаимодействия точки доступа с сервером RADIUS
---------------------------------------------------------------------------
### Конфигурация сервера FreeRADIUS
Это виртуальная машина со следующими характеристиками: RAM 1GB, 1xCPU, виртуальный диск 20GB (можно меньше, лишь бы разместилась операционная система и необходимые пакеты).
В роли гипервизора — Oracle Virtual Box 6.1.18
В качестве гостевой операционной системы для экспериментов использовался дистрибутив Oracle Linux 6.3. В принципе, можно выбрать любой другой дистрибутив, если нет специальных ограничений.
FreeRADIUS — из стандартного репозитория.
### Точка доступа
В качестве клиента (точки доступа) — используется модель Zyxel [NWA210AX](https://www.zyxel.com/ru/ru/products_services/802-11ax--WiFi-6--Dual-Radio-PoE-Access-Point-NWA210AX). Это современное устройство, поддерживающее интеграцию в облачной системе Zyxel Nebula и обладающее массой других достоинств.
Несмотря на то, что NWA210AX поддерживает новые протоколы безопасности WiFi 6 и может использовать сервис аутентификации Nebula, в нашем случае она прекрасно выступит в качестве устройства доступа в сети WPA 2 Enterprise.
*Рисунок 2. Точка доступа NWA210AX.*
### Клиент для проверки подключения
В качестве платформы для проверки клиентского подключения — наиболее наглядно данный процесс отображается на последних версиях Mac OS X.
### Установка и настройка сервера RADIUS
Перед установкой рекомендуется настроить файервольные правила, в частности, разрешить порты 1812, 1813, а также, если понадобиться, выполнить настройку SELinux. Нашей целью было показать взаимодействие с RADIUS, поэтому такие нюансы, как настройка сети, файервола, других средств безопасности выходят за рамки статьи и остаются за кадром. И мы сразу переходим к установке FreeRADIUS.
`sudo install freeradius freeradius-utils -y`
Обратите внимание, мы устанавливаем не только пакет *freeradius*, но и дополнительные инструменты *freeradius-utils*.
Из этого пакета нам понадобится утилита *radclient* для проверки пользователей.
После окончания установки настроим запуск сервиса при старте системы:
`sudo systemctl enable radiusd`
Для проверки запустим FreeRADIUS:
`sudo systemctl start radiusd`
Проверим его состояние:
`sudo systemctl status radiusd`
Пример ответа системы:
```
radiusd.service - FreeRADIUS high performance RADIUS server.
Loaded: loaded (/usr/lib/systemd/system/radiusd.service; enabled; vendor preset: disabled)
Active: active (running) since Thu 2021-02-04 13:36:11 EST; 7min ago
Process: 953 ExecStart=/usr/sbin/radiusd -d /etc/raddb (code=exited, status=0/SUCCESS)
Process: 872 ExecStartPre=/usr/sbin/radiusd -C (code=exited, status=0/SUCCESS)
Process: 821 ExecStartPre=/bin/sh /etc/raddb/certs/bootstrap (code=exited, status=0/SUCCESS)
Process: 810 ExecStartPre=/bin/chown -R radiusd.radiusd /var/run/radiusd (code=exited, status=0/SUCCESS)
Main PID: 970 (radiusd)
Tasks: 6 (limit: 12425)
Memory: 82.9M
CGroup: /system.slice/radiusd.service
└─970 /usr/sbin/radiusd -d /etc/raddb
Feb 04 13:36:10 localhost.localdomain systemd[1]: Starting FreeRADIUS high performance RADIUS server....
Feb 04 13:36:10 localhost.localdomain sh[821]: server.pem: OK
Feb 04 13:36:11 localhost.localdomain systemd[1]: Started FreeRADIUS high performance RADIUS server..
```
Дополнительно проверить можно командой:
`sudo ps aux | grep radiusd`
Ответ системы должен быть примерно таким:
```
root 7586 0.0 0.2 112716 2200 pts/1 R+ 01:28 0:00 grep --color=auto radiusd
radiusd 13320 0.0 1.5 513536 15420 ? Ssl Dec23 0:00 /usr/sbin/radiusd -d /etc/raddb
```
Для настройки нам понадобится только два конфигурационных файла из каталога */etc/raddb*:
*clients* и *users*.
> ***ВНИМАНИЕ!** Ещё раз повторяем — это всего лишь пример, помогающий понять механизм работы. Такой примитивный вариант, например, когда записи пользователей и ключи хранятся открытым текстом — в production лучше не использовать. Но именно для иллюстрации работы самого RADIUS — чем меньше и проще настраивать, тем лучше.*
В файле */etc/raddb/clients* настраивается доступ из конкретной сети и задаётся общий ключ для сервера RADIUS и клиентов, в нашем случае — точек доступа.
`sudo vi /etc/raddb/clients`
Находим подходящий пример записи:
```
#client private-network-2 {
# ipaddr = 198.51.100.0/24
# secret = testing123-2
#}
```
и на его основе создаём свою запись:
```
client private-network-rpcm {
ipaddr = 192.168.0.0/24
secret = testing123-3
}
```
Для примера используется самый простейший вариант «из коробки», и по умолчанию информация о пользователях хранится в файле */etc/raddb/users*. Создадим двух пользователей: ivan и rodeon.
`sudo vi /etc/raddb/users`
Обратите внимание на следующее предупреждение в самом конце файла:
```
#########################################################
# You should add test accounts to the TOP of this file! #
# See the example user "bob" above. #
#########################################################
```
Самый простой способ правильной вставки информации о пользователях — найти пользователя bob и добавить прямо под ним следующие строки:
```
ivan Cleartext-Password := "Pass1van"
Reply-Message := "Hello, %{User-Name}"
rodeon Cleartext-Password := "PassR0deon"
Reply-Message := "Hello, %{User-Name}"
```
Перезапустим сервис radiusd, чтобы тот перечитал конфигурационные файлы:
`sudo systemctl restart radiusd`
Предварительная проверка заключается в том, чтобы сервис *radiusd* повторно в штатном режиме стартовал без сообщений об ошибках. Выше мы уже выполняли такую проверку (после установки FreeRADIUS) командой:
`sudo systemctl status radiusd`
После того, как убедились в стабильной работе сервиса, выполним проверку через команду *radclient* с передачей имени пользователя.
`sudo echo "User-Name=ivan,User-Password=Pass1van" | radclient 192.168.0.104:1812 auth testing123-3`
Где:
* команда echo "User-Name= ivan,User-Password= Pass1van" передаёт имя пользователя и пароль;
* 192.168.0.104:1812 — адрес сервера с портом UDP;
* auth testing123-3 — указывается общий ключ ***testing123-3***.
Если всё в порядке, ответ должен быть примерно таким:
```
Sent Access-Request Id 54 from 0.0.0.0:57939 to 192.168.0.104:1812 length 44
Received Access-Accept Id 54 from 192.168.0.104:1812 to 192.168.0.104:57939 length 33
```
Последняя и самая главная проверка: настроить на точке доступа *NWA210AX* подключение к данному серверу RADIUS и подключить выбранное клиентское устройство к WiFi сети.
Настройка подключения к RADIUS на точке доступа
-----------------------------------------------
Чтобы выполнить настройку, необходимо узнать адрес устройства. Для сетевого оборудования Zyxel это можно легко сделать при помощи сетевой утилиты ZON (Zyxel One Networking Utility). О ней можно подробнее узнать и бесплатно скачать на сайте [Zyxel](https://www.zyxel.com/ru/ru/products_services/Zyxel-ONE-Network-Utility-ZON-Utility).
*Рисунок 3. Утилита ZON (Zyxel One Networking Utility).*
После того, как мы узнали IP, подключаемся через Интернет браузер.
Появляется первое окно с предложением сразу перейти к управлению через облачную среду Zyxel Nebula. Как уже было сказано выше, использовать «облако» проще, в отличие от автономной работы, в Nebula уже реализован аналог сервера аутентификации (и много чего другого, мониторинг, например). Но в данном случае используется автономная схема, поэтому выбираем режим — Standalone Mode.
*Рисунок 4. Окно с предложением сразу перейти в облачную среду Nebula.*
Далее идёт окно ввода имени пользователя и пароля. Пользователь по умолчанию — *admin*, пароль по умолчанию — *1234*.
*Рисунок 5. Окно ввода пользователя и пароля на NWA210AX.*
Далее переходим в раздел Configuration —> AP Management. Нам необходимо настроить SSID профили.
В данном случае у нас два профиля: *Wiz\_SSID\_1* и *Wiz\_SSID\_2.*
Для их настройки на соединение с RADIUS нужно задействовать элементы вызова окна редактирования (отмечено красным контуром на рисунке 6).
*Рисунок 6. Раздел Configuration —> AP Management. Вызов окна редактирования SSID профиля.*
Появится окно *Edit SSID Profile Wiz\_SSID\_1.*
В нём нас интересует переход к настройкам Security Profile (отмечено красным контуром на рисунке 7).
*Рисунок 7. Окно Edit SSID Profile Wiz\_SSID\_1.*
В появившемся окне *Edit Security Profile Wiz\_SEC\_Profile\_1* включаем опцию Primary Radius Server Activate и заполняем поля в соответствии с записями в файле */etc/raddb/clients* нашего FreeRADIUS (отмечено красным контуром):
* Radius Server IP Address,
* Radius Server Port,
* Radius Server Secret.
Если есть резервный сервер RADIUS, то необходимо включить Secondary Radius Server Activate и заполнить для него значения (отмечено синим подчёркиванием). У нас тестовая среда, но в production наличие резервного сервера аутентификации обязательно.
*Рисунок 8. Окно Edit Security Profile Wiz\_SEC\_Profile\_1.*
Среди прочего присутствует вкладка Advance, в которой можно задать дополнительные значения. В данном случае у нас довольно простой пример, поэтому лучше оставить всё по умолчанию.
*Рисунок 9. Окно Edit Security Profile Wiz\_SEC\_Profile\_11 с раскрытой вкладкой* Advance*.*
Проверка подключения
--------------------
Как уже было сказано выше, более или менее точно процесс установки беспроводной связи иллюстрирует интерфейс Mac OS Х.
После того, как в списке подключений нашли соответствующий пункт (по умолчанию он называется Zyxel), операционная система показывает окно ввода имени пользователя и пароля/ключа, хранящегося в системе RADIUS.
*Рисунок 10. Запрос имени пользователя и пароля для входа в беспроводную сеть.*
Далее происходит передача сертификата. В OS X об этом свидетельствует окно для подтверждения использования сертификата.
*Рисунок 11. Окно проверки сертификата. Дополнительно нажата кнопка «Показать сертификат».*
После этого можно работать, например, зайти по адресам, указанным в разделе Полезные ссылки (в конце статьи).
Заключение
----------
Как видим, даже для такого простого примера нам потребовалось довольно много действий. Теперь представьте, что точек в сети довольно много. Позже мы рассмотрим, как можно обеспечить подобную систему аутентификации с меньшими усилиями благодаря облачной систем управления Zyxel Nebula или встроенным аппаратным решениям Zyxel.
Полезные ссылки
---------------
1. [Telegram chat Zyxel](https://t.me/zyxelru)
2. [Форум по оборудованию Zyxel](https://www.zyxel.com/ru/ru/ci_general_20191031_520516.shtml)
3. [Много полезного видео на канале](https://www.youtube.com/channel/UCcNN2UCEz1e49PEaAisN5ow) Youtube
4. [Особенности защиты беспроводных и проводных сетей. Часть 1 — Прямые меры защиты](https://habr.com/ru/company/zyxel/blog/516508)
5. [Двухдиапазонная точка доступа 802.11ax (WiFi 6) NWA210AX](https://www.zyxel.com/ru/ru/products_services/802-11ax--WiFi-6--Dual-Radio-PoE-Access-Point-NWA210AX)
6. [Zyxel ONE Network Utility (ZON)](https://www.zyxel.com/ru/ru/products_services/Zyxel-ONE-Network-Utility-ZON-Utility/)
7. [Домашняя страничка проекта FreeRADIUS](https://freeradius.org)
8. [Zyxel Nebula](https://nebula.zyxel.com) | https://habr.com/ru/post/541474/ | null | ru | null |
# Локальный (offline) npm репозиторий
### Предыстория
Решив продаться задорого, я оказался у работодателя, где интернета нет не только в пром-контуре, но и в деве (ситуация на самом деле нередкая во многих, так сказать, "энтерпрайзах"). Есть IE в консоли, где ты, мой дорогой читатель, можешь конечно посмотреть на Хабр или stackoverflow, но не более. В целом, повторюсь, ситуация не исключительная, с ней можно жить — вот он, мой личный ноут, на котором я это пишу, стоит на столе… wifi ли, поднимаемый многими сотрудниками, сотовый ли как модем, в целом, если это не оборонка/всякие службы из трех букв (тут я советую идти официальными-дорогими путями, о чем будет пара слов ниже) и нет службы радиоконтроля, то вы вольны со своим личным ноутом делать все что угодно (в рамках допустимого :) ), ну по-крайней мере, так это выглядит у нас. Возможность перетащить файлики в dev-среду худо-бедно есть, но мне очень не понравилось решение держать node\_modules в кодовой базе и я засучил рукава (рукава я засучивал много раз и по поводу переезда с TFS на git, и по поводу локального nuget-репо, но это отдельные истории, тоже не лишенные драматизьму, но о них как-нибудь в следующий раз). Есть несколько довольно дорогих решений вопроса, вполне возможно, что я смог бы протолкнуть даже какой-нибудь Artifactory, но когда я представил сколько этой займет сил и самое главное, как долго это будет решаться, согласовываться и внедряться, было решено поступить дешево и сердито.
*Дисклеймер: поскольку у меня была windows-среда, то и описываю я детально именно работу в виндовой консоли, однако по сути отличия будут только в конце, когда вы захотите окончательный результат поднять в виде сервиса/демона.*
### Не томи, задушевенник, как?
В действе участвуют:
* Компьютер с доступом к интернету — зовем его *исходник*
* Компьютер без доступа, в корпоративной сети — зовем его *целевой машиной*
На исходнике и на целевой машине должны быть node.js (проще всего, если одной или близких версий).
Создаем на исходнике папочку, где нибудь и зовем ее, например, verdaccio:
```
mkdir verdaccio
cd verdaccio
```
После локально ставим Verdaccio, это очень полезная штука, основанная на старом проекте sinopia. Подробнее прочитать можно тут: <https://verdaccio.org/>.
Если же коротко, то это прокси для npm, которая умеет кешировать. Для очень многих пользователей этого пакета, ключевой возможностью является способность приватно публиковаться, мой же случай несколько отличается я хотел закешировать все что мне нужно для работы и чуть больше, а потом перекинуть это вот все на целевую машину. Забегая вперед скажу, что все прошло довольно безболезненно, кроме переноса node-sass. Именно корежа ее тарболы я провел полтора дня (там есть нативная часть, которая подгружается с гитхаба в процессе установки или собирается gyp'ом, если вдруг не вышло подгрузить — вдумайтесь, собирается на каждой локальной разработческой машине, что совершенно некомильфо), но это пожалуй тоже другая история.
Тут все просто:
```
npm i verdaccio
```
Вообще в руководстве рекомендуют ставить глобально, но на самом деле это вовсе необязательно, более того, мы хотим локализовать все это безобразие в одной папке, чтобы потом ее с удобством копировать. Потому так...
Запустим пакет, он создаст хранилище и конфигурацию по-умолчанию:
```
.\node_modules\.bin\verdaccio.cmd
```
Тут как раз нам все и рассказали, где конфиг, на каком порту висим.
В принципе можно уже сходить по указанному адресу и увидеть, что-то вроде этого:
Теперь нам нужно сделать несколько вещей:
* Очистить npm-cache ( [подробнее тут](https://docs.npmjs.com/files/folders), если коротко то убить содержимое *%AppData%/npm-cache* )
* Выполнить
```
npm set registry http://localhost:4873/
```
* Скопировать config.yaml в нашу уютную папку verdaccio
* Убедиться, что раздел uplinks этого файла выглядит так:
```
uplinks:
npmjs:
url: https://registry.npmjs.org/
cache: true
```
* В конце конфига добавить :
```
listen:
- 0.0.0.0:4873
```
Если этого не сделать, то вы не сможете достучаться позже на целевой машине к локальному адресу.
* Собственно мы готовы, теперь все пакеты, что мы возьмем через npm install осядут в ./storage, что нам и нужно. Восстанавливаем целевой проект, ставим дополнительно:
```
npm i node-windows
```
Все, после этого берем папку и любым доступным вам способом отправляем на целевую машину (там нужны **админские** права, да). Можно уже там, можно сразу создать файлик в руте папки же installservice.js:
```
var Service = require('node-windows').Service;
var svc = new Service({
name: 'VerdaccioSvc',
description: 'Verdaccio - npm local repository',
script: ' <тут путь до папки>\\node_modules\\verdaccio\\bin\\verdaccio',
nodeOptions: []
});
svc.on('install', function() {svc.start();});
svc.install();
```
Запускаем :
```
node installservice.js
```
**Наслаждаемся!**
В целом довольно малой кровью удалось получить локальный репозиторий, билды билдятся, разработчики разрабатывают и все в этом мире на своих местах. И да, последующая синхронизация сводится к копированию содержимого *./storage*.
Вот это все было записано отчасти в качестве памятки, отчасти, ради того, чтобы сберечь тебе хабраюзер время (задача вряд ли слишком часто решаемая), потому если каменный цветок не будет выходить — смело пиши, есть шанс, что я забыл описать какую-то деталь, а если и не забыл, вдруг, чем помогу... | https://habr.com/ru/post/453614/ | null | ru | null |
# Книга «Вероятностное программирование на Python: байесовский вывод и алгоритмы»
[](https://habr.com/ru/company/piter/blog/456562/) Привет, Хаброжители! Байесовские методы пугают формулами многих айтишников, но без анализа статистики и вероятностей сейчас не обойтись. Кэмерон Дэвидсон-Пайлон рассказывает о байесовском методе с точки зрения программиста-практика, работающего с многофункциональным языком PyMC и библиотеками NumPy, SciPy и Matplotlib. Раскрывая роль байесовских выводов при А/В-тестировании, выявлении мошенничества и в других насущных задачах, вы не только легко разберетесь в этой нетривиальной теме, но и начнете применять полученные знания для достижения своих целей.
### Отрывок: 4.3.3. Пример: сортировка комментариев на Reddit
Возможно, вы не согласны, что закон больших чисел применяется всеми, хотя и только неявно, при подсознательном принятии решений. Рассмотрим пример онлайн-рейтингов товаров. Часто ли вы доверяете среднему рейтингу в пять баллов на основе одного отзыва? Двух отзывов? Трех отзывов? Вы подсознательно понимаете, что при таком малом количестве отзывов средний рейтинг плохо отражает то, насколько товар на самом деле хорош/плох.
Вследствие этого возникают упущения при сортировке товаров и вообще при их сравнении. Для многих покупателей понятно, что сортировка результатов интерактивного поиска по рейтингу не слишком объективна, неважно, идет ли речь о книгах, видео или комментариях в Интернете. Зачастую находящиеся на первых местах фильмы или комментарии получают высокие оценки только за счет небольшого числа восторженных поклонников, а действительно хорошие фильмы или комментарии скрыты на последующих страницах с якобы неидеальными рейтингами около 4,8. Что же с этим делать?
Рассмотрим популярный сайт Reddit (я осознанно не привожу на него ссылки, ведь Reddit печально знаменит тем, что затягивает пользователей, и я боюсь, что вы никогда не вернетесь к моей книге). На этом сайте есть множество ссылок на разные истории и картинки, причем комментарии к этим ссылкам тоже очень популярны. Пользователи сайта (которых обычно называют словом redditor1) могут голосовать за каждый комментарий или против него (так называемые голоса «за» (upvotes) и голоса «против» (downvotes)). Reddit по умолчанию сортирует комментарии по убыванию. Как же определить, какие комментарии лучшие? Обычно ориентируются на следующие несколько показателей.
1. *Популярность*. Комментарий считается хорошим, если за него подано много голосов. Проблемы при использовании этой модели начинаются в случае комментария с сотнями голосов «за» и тысячами «против». Хотя и очень популярный, этот комментарий, похоже, слишком неоднозначен, чтобы считаться «лучшим».
2. *Разница*. Можно воспользоваться разницей между количеством голосов «за» и «против». Это решает проблему, возникающую при использовании метрики «популярность», но не учитывает временную природу комментариев. Комментарии могут быть отправлены через многие часы после публикации первоначальной ссылки. При этом возникает смещение, из-за которого самый высокий рейтинг получают вовсе не лучшие комментарии, а самые старые, успевшие накопить больше голосов «за», чем более новые.
3. *Поправка на время*. Рассмотрим метод, при котором разница голосов «за» и «против» делится на возраст комментария и получается частота (rate), например величина разницы в секунду или в минуту. Сразу же на ум приходит контрпример: при использовании варианта «в секунду» комментарий, оставленный секунду назад с одним голосом «за» окажется лучше, чем оставленный 100 секунд назад с 99 голосами «за». Избежать этой проблемы можно, если учитывать только комментарии, оставленные как минимум t секунд назад. Но как выбрать хорошее значение t? Значит ли это, что все комментарии, оставленные позднее, чем t секунд назад, плохи? Дело закончится сравнением неустойчивых величин с устойчивыми (новых и старых комментариев).
4. *Соотношение*. Ранжирование комментариев по соотношению числа голосов «за» к суммарному числу голосов «за» и «против». Такой подход устраняет проблему с временно'й природой комментариев, так что недавно оставленные комментарии с хорошими оценками получат высокий рейтинг с той же вероятностью, что и оставленные давно, при условии, что у них относительно высокое отношение голосов «за» к общему числу голосов. Проблема с этим методом состоит в том, что комментарий с одним голосом «за» (отношение = 1,0) окажется лучше, чем комментарий с 999 голосами «за» и одним «против» (отношение = 0,999), хотя очевидно, что второй из этих комментариев скорее окажется лучшим.
Я неспроста написал *«скорее»*. Может оказаться и так, что первый комментарий с одним-единственным голосом «за» действительно лучше, чем второй, с 999 голосами «за». С этим утверждением трудно согласиться, ведь мы не знаем, какими могли бы быть 999 потенциальных следующих голосов для первого комментария. Скажем, он мог получить в результате еще 999 голосов «за» и ни одного голоса «против» и оказаться лучше, чем второй, хотя такой сценарий и не слишком вероятен.
На самом деле нам нужно оценить фактическое соотношение голосов «за». Отмечу, что это вовсе не то же, что наблюдаемое соотношение голосов «за»; фактическое соотношение голосов «за» скрыто, наблюдаем мы только число голосов «за» по сравнению с голосами «против» (фактическое соотношение голосов «за» можно рассматривать как вероятность получения данным комментарием голоса «за», а не «против»). Благодаря закону больших чисел можно с уверенностью утверждать, что у комментария с 999 голосами «за» и одним «против» фактическое соотношение голосов «за», вероятно, будет близко к 1. С другой стороны, мы гораздо менее уверены в том, каким окажется фактическое соотношение голосов «за» для комментария с одним голосом «за». Похоже, что это байесовская задача.
Один из способов определить априорное распределение соотношения голосов «за» — изучить историю распределения соотношений голосов «за». Это можно сделать с помощью скрапинга комментариев Reddit и последующего определения распределения. Впрочем, у этого метода есть несколько недостатков.
1. *Асимметричные данные*. Число голосов у абсолютного большинства комментариев очень невелико, вследствие чего соотношения у многих комментариев будут близки к экстремальным (см. «треугольный» график в примере с набором данных Kaggle на рис. 4.4) и распределение окажется сильно «перекошено». Можно попробовать учитывать лишь комментарии, число голосов у которых превышает определенное пороговое значение. Но и здесь возникают сложности. Приходится искать баланс между числом доступных комментариев, с одной стороны, и более высоким пороговым значением с соответствующей точностью соотношения — с другой.
2. *Смещенные (содержащие систематическую погрешность) данные*. Reddit состоит из множества подфорумов (subreddits). Два примера: r/aww с фотографиями забавных животных и r/politics. Более чем вероятно, что поведение пользователей при комментировании этих двух подфорумов Reddit будет кардинально различаться: в первом из них посетители, скорее всего, будут умиляться и вести себя дружелюбно, что приведет к большему числу голосов «за», по сравнению со вторым, где мнения в комментариях, вероятно, будут расходиться.
В свете вышеизложенного мне кажется, что имеет смысл воспользоваться равномерным априорным распределением.
Теперь мы можем вычислить апостериорное распределение фактического соотношения голосов «за». Сценарий comments\_for\_top\_reddit\_pic.py служит для скрапинга комментариев из текущей наиболее популярной картинки Reddit. В следующем коде мы произвели скрапинг комментариев Reddit, относящихся к картинке [3]: [http://i.imgur.com/OYsHKlH.jpg.](http://i.imgur.com/OYsHKlH.jpg)
```
from IPython.core.display import Image
# С помощью добавления числа к вызову %run
# можно получить i-ю по рейтингу фотографию.
%run top_pic_comments.py 2
```
>
> ```
> [Output]:
> Title of submission:
> Frozen mining truck
> http://i.imgur.com/OYsHKlH.jpg
> ```
>
```
"""
Contents: массив текстов всех комментариев к картинке Votes: двумерный
массив NumPy голосов "за" и "против" для каждого комментария
"""
n_comments = len(contents)
comments = np.random.randint(n_comments, size=4)
print "Несколько комментариев (из общего числа в %d) \n
-----------"%n_comments
for i in comments:
print '"' + contents[i] + '"'
print "голоса "за"/"против": ",votes[i,:]
print
```
>
> ```
> [Output]:
>
> Несколько комментариев (из общего числа 77)
> -----------
> "Do these trucks remind anyone else of Sly Cooper?"
> голоса "за"/"против": [2 0]
>
> "Dammit Elsa I told you not to drink and drive."
> голоса "за"/"против": [7 0]
>
> "I've seen this picture before in a Duratray (the dump box supplier) brochure..."
> голоса "за"/"против": [2 0]
>
> "Actually it does not look frozen just covered in a layer of wind packed snow."
> голоса "за"/"против": [120 18]
> ```
>
При N голосах и заданном фактическом соотношении голосов «за» p число голосов «за» напоминает биномиальную случайную переменную с параметрами p и N (дело в том, что фактическое соотношение голосов «за» эквивалентно вероятности подачи голоса «за» по сравнению с голосом «против» при N возможных голосах/испытаниях). Создадим функцию для байесовского вывода по p в отношении набора голосов «за»/«против» конкретного комментария.
```
import pymc as pm
def posterior_upvote_ratio(upvotes, downvotes, samples=20000):
"""
Эта функция принимает в качестве параметров количество
голосов "за" и "против", полученных конкретным комментарием,
а также количество выборок, которое нужно вернуть пользователю.
Предполагается, что априорное распределение равномерно.
"""
N = upvotes + downvotes
upvote_ratio = pm.Uniform("upvote_ratio", 0, 1)
observations = pm.Binomial("obs", N, upvote_ratio,
value=upvotes, observed=True)
# Обучение; сначала выполняем метод MAP, поскольку он не требует
# больших вычислительных затрат и приносит определенную пользу.
map_ = pm.MAP([upvote_ratio, observations]).fit()
mcmc = pm.MCMC([upvote_ratio, observations])
mcmc.sample(samples, samples/4)
return mcmc.trace("upvote_ratio")[:]
```
Далее приведены получившиеся в результате апостериорные распределения.
```
figsize(11., 8)
posteriors = []
colors = ["#348ABD", "#A60628", "#7A68A6", "#467821", "#CF4457"]
for i in range(len(comments)):
j = comments[i]
label = u'(%d за:%d против)\n%s...'%(votes[j, 0], votes[j,1],
contents[j][:50])
posteriors.append(posterior_upvote_ratio(votes[j, 0], votes[j,1]))
plt.hist(posteriors[i], bins=18, normed=True, alpha=.9,
histtype="step", color=colors[i%5], lw=3, label=label)
plt.hist(posteriors[i], bins=18, normed=True, alpha=.2,
histtype="stepfilled", color=colors[i], lw=3)
plt.legend(loc="upper left")
plt.xlim(0, 1)
plt.ylabel(u"Плотность")
plt.xlabel(u"Вероятность голоса 'за'")
plt.title(u"Апостериорные распределения соотношений голосов 'за' \
для различных комментариев");
```
>
> ```
> [Output]:
> [****************100%******************] 20000 of 20000 complete
> ```
>
Как видно из рис. 4.5, некоторые распределения сильно «сжаты», у других же — сравнительно длинные «хвосты», выражающие то, что мы точно не знаем, чему равно фактическое соотношение голосов «за».
### 4.3.4. Сортировка
До сих пор мы игнорировали основную цель нашего примера: сортировку комментариев от лучшего к худшему. Конечно, невозможно сортировать распределения; сортировать нужно скалярные значения. Предусмотрено множество способов извлечь сущность распределения в виде скаляра; например, можно выразить суть распределения через его математическое ожидание, или среднее значение. Впрочем, среднее значение для этого подходит плохо, поскольку этот показатель не учитывает неопределенность распределений.
Я рекомендовал бы воспользоваться 95%-ным наименее правдоподобным значением (least plausible value), которое определяется как значение с лишь 5%-ной вероятностью того, что фактическое значение параметра ниже его (ср. с нижней границей байесовского доверительного интервала). Далее мы строим графики апостериорных распределений с указанным 95%-ным наименее правдоподобным значением (рис. 4.6).
```
N = posteriors[0].shape[0]
lower_limits = []
for i in range(len(comments)):
j = comments[i]
label = '(%d за:%d против)\n%s…'%(votes[j, 0], votes[j,1],
contents[j][:50])
plt.hist(posteriors[i], bins=20, normed=True, alpha=.9,
histtype="step", color=colors[i], lw=3, label=label)
plt.hist(posteriors[i], bins=20, normed=True, alpha=.2,
histtype="stepfilled", color=colors[i], lw=3)
v = np.sort(posteriors[i])[int(0.05*N)]
plt.vlines(v, 0, 10 , color=colors[i], linestyles="—",
linewidths=3)
lower_limits.append(v)
plt.legend(loc="upper left")
plt.ylabel(u"Плотность")
plt.xlabel(u"Вероятность голоса 'за'")
plt.title(u"Апостериорные распределения соотношений голосов 'за' \
для различных комментариев");
order = np.argsort(-np.array(lower_limits))
print order, lower_limits
```
>
> ```
> [Output]:
>
> [3 1 2 0] [0.36980613417267094, 0.68407203257290061,
> 0.37551825562169117, 0.8177566237850703]
> ```
>
Лучшими, согласно нашей процедуре, окажутся те комментарии, для которых наиболее высока вероятность получения высокого процента голосов «за». Визуально это комментарии с ближайшим к единице 95%-ным наименее правдоподобным значением. На рис. 4.6 95%-ное наименее правдоподобное значение изображено с помощью вертикальных линий.
Почему же сортировка на основе этого показателя — такая хорошая идея? Упорядочение в соответствии с 95%-ным наименее правдоподобным значением означает максимальную осторожность в объявлении комментариев лучшими. То есть даже при наихудшем сценарии, если мы сильно переоценили соотношение голосов «за», гарантируется, что лучшие комментарии окажутся сверху. При таком упорядочении обеспечиваются следующие весьма естественные свойства.
1. Из двух комментариев с одинаковым наблюдаемым соотношением голосов «за» лучшим будет признан комментарий с бо'льшим числом голосов (поскольку выше уверенность в более высоком соотношении для него).
2. Из двух комментариев с одинаковым количеством голосов лучшим считается комментарий с бо'льшим числом голосов «за».
» Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/new/product/veroyatnostnoe-programmirovanie-na-python-bayesovskiy-vyvod-i-algoritmy)
» [Оглавление](https://storage.piter.com/upload/contents/978544611058/978544611058_X.pdf)
» [Отрывок](https://storage.piter.com/upload/contents/978544611058/978544611058_p.pdf)
Для Хаброжителей скидка 25% по купону — **JavaScript**
По факту оплаты бумажной версии книги на e-mail высылается электронная книга. | https://habr.com/ru/post/456562/ | null | ru | null |
# Ящик пива за лучшую сисадминскую байку и наш личный топ историй
Мы в [RUVDS](https://ruvds.com/) очень любим три вещи: сисадминов, байки и пиво.
В этот раз мы решили объединить эти любимые вещи и сделать конкурс лучших сисадминских баек: про работу, клиентов и забавные случаи из практики.
*Ммммм, сисадмин-техпод-байка-пиво*
Каждому, кто расскажет забавную историю в комментариях, мы подарим по баночке нашего фирменного [темного эля DukeNukem](http://dukenukembeer.ru/), а победителю, чей рассказ наберет больше всего плюсов — **вышлем целый ящик пива**.
Для вдохновения и правильного настроя, делимся нашими любимыми сисадминскими байками: тут почти нет новых историй, зато много ностальгии, доброго юмора и даже пара нерешенных до сих пор загадок. Поехали?
Раньше я работал в IT-отделе компании Samsung. Одному из сотрудников нужно было сбросить пароль, я сменил пароль на «Samsung1» и сказал ему об этом. Мне перезвонили через две минуты и сказали, что пароль не подходит. Я снова сбросил его, но он снова не сработал. Я подумал, что проблемы со стороны пользователя и решил зайти к нему.
Каково было мое удивление, когда я увидел, что он неправильно набирает пароль! Он печатал «Semsung1».
«Подсказываю! Это компания, в которой вы работаете, и ее название написано на мониторах, перед которыми вы сидите»
*Питер Дж.*
Это было в начале 2007 года. В нашем колледже строили Центр обработки данных в переоборудованном классе, практически не обращая внимания на климат-контроль, а тогда там стоял обычный сплит-кондиционер. Наш колледж находился в юго-западной части пустыни Мохаве, в Южной Калифорнии. В нем «экономили деньги» каждые выходные отключая все кондиционеры по всему кампусу, в том числе и **в центре обработки данных**, так что наши серверы пыхтели при 50-60 градусной жаре до утра понедельника. В марте 2007 года мы обратились к поставщику резервных копий, так как у нас был ленточный накопитель Quantum LTO1 (только с одним отделением для кассеты), и он глючил из-за жары в нашем [EMC Clarion CX400 SAN](https://ru.wikipedia.org/wiki/%D0%A1%D0%B5%D1%82%D1%8C_%D1%85%D1%80%D0%B0%D0%BD%D0%B5%D0%BD%D0%B8%D1%8F_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85). Нам нужен был надежный накопитель, который бы выживал в наших условиях. Но существующее решение не могло делать копии открытых файлов, потому нам нужна была неделя на то, чтобы собрать полный набор данных (из-за медленного накопителя). Мы попросили денег на резервный узел SAN для подстраховки в случае падения, но нам отказали.
Вместо этого нам выделили деньги на работу сторонней компании, выполняющей резервное копирование в сжатые сроки. Выезд их специалистов запланировали 17 июля 2007 года в 8:45, чтобы они делали нам полный бекап. В точности по Закону Мерфи наша SAN вышла из строя ночью, прямо перед запланированным приездом специалистов по бекапу, а один из [LUN](https://ru.wikipedia.org/wiki/LUN) на 900 ГБ был потерян навсегда.
Да здравствует планирование!
*Джастин Дж.*
У нас в компании было совещание руководителей отделов для обсуждения работы с компьютерной системой службы 911. Инструкции разослали утром в пятницу, чтобы начать тренинг по работе в ней уже в понедельник.
Два пользователя, не особо вникая текст письма, активировали систему по инструкции сразу, как только получили письмо, наведя шухер среди офицеров полиции работающих в 911.
*Зак Д.*
Как и большинство системных администраторов я начал с работы в службе поддержки.
Однажды мне потребовалось более 20 минут, чтобы объяснить новой работнице, как нажать CTRL-ALT-DEL для входа в компьютер. Она просто не могла понять концепцию одновременного нажатия 3 клавиш сразу
*Конрад Дж*.
Как-то рабочий, обслуживающий коммуникации в фальш-потолке, где были проложены наши сетевые кабели, случайно их перерезал. Когда наши инженеры прибыли на место для устранения обрыва, рабочий сказал, что все в порядке, и он сам все исправил.
Он соединил обрывки витых пар колпачками для скрутки проводов.
*Уоллес Ф.*
Однажды я чуть не сошел с ума, пытаясь понять, где сбой в питании, проведенном через фальш-пол. Вдруг мы услышали голос из соседней комнаты: “О-ля-ля! Ты вылила всю мою бутылку воды на розетку!”.
Мы побежали туда и увидели розетку, залитую лужей воды…
*Хорхе Б.*
Лет 10-25 назад я работал в поддержке у провайдера, в какой-то момент мне позвонила женщина, которая сразу призналась, что не умеет обращаться с компьютером, но ей очень надо запустить одну программу. Она жила всего в паре минут от меня, и я решил просто зайти к ней домой.
Придя на место, я сказал, что сначала ей надо открыть меню “Пуск”. Она спросила меня: “Что такое Меню Пуск?”… Постепенно я ей все объяснил и нашел приложение, которое ей было нужно. Когда я собрался уходить, она сказала, что знает еще одного человека, которому я могу помочь. Оказалось, что у нее есть маленькая дочь, и та слышала, что можно превратить курсор мыши в динозавра. Это было просто, я всего лишь поменял тему курсора Windows XP, но девочка была счастлива.
Вернувшись в офис я заполнил тикет: “Помог пользователю найти приложение ‘Х’ и превратил курсор мыши в динозавра”.
*Энди С.*
Помню, у меня на работе жила саламандра в аквариуме, которая все время умудрялась вылезать из него, хотя крышка была закрыта. Однажды, она вылезла, когда никого не было, и пропала.
Через некоторое время мой компьютер отказался запускаться из-за проблем с блоком питания. Когда я открыл корпус, то увидел палочку, застрявшую в вентиляторе.
Только это была не палочка!..
*Роб Х.*
У нас был клиент, который прислал нам фотографию своего треснувшего экрана…
… сделанную с помощью Print Screen.
*Лим Р.*
Когда я работал в техподдержке, я, было, удаленно помогал одному пожилому человеку. Когда мы со всем разобрались, я попросил его закрыть все окна, чтобы мы могли повторить все сначала. Он сказал «Хорошо, скоро вернусь». Через десять минут он снова подошел к телефону и сказал: «Ну, я закрыл все окна, и что теперь?»
Райан Г.
Однажды я отошел от рабочего компьютера, оставив его включенным и не заблокировав заставкой с паролем. Никогда этого не требовалось, потому что коллектив был меньше десяти человек, все работали вместе несколько лет и довольно хорошо друг друга знали. Вернувшись, я увидел, что в моей аське мигает почти весь контакт лист, все мне что-то пишут, включая тех, с кем мы общались очень редко и даже не каждый месяц.
Оказалось, почему-то именно в тот день одному коллеге ударило в голову неизвестное вещество, и он решил пошутить, сев за мой комп и написав в мою аську: “Я тряс башкой и мой хаер застрял в клавиатуре”, а потом одной кнопкой разослав это по всем моим контактам (спасибо Аське, тогда это можно было сделать буквально в один клик).
Я пережил несколько неприятных минут, объясняя, что это глупая шутка коллеги. Но с ним больше не здоровался… А компьютер блокировал.
*Константин В.*
Был случай, когда к нам в офис устроился сотрудник, который, как бы сказать поделикатнее, пренебрегал личной гигиеной. Всех достало его амбрэ, но сказать прямо стеснялись. В итоге, решили проблему довольно замороченным способом, но зато “по-админски”.
На компьютере Макинтош можно сбросить пароль root-пользователя с помощью специальной опции на установочном диске. Мы загрузили его Мак с этого диска, сбросили пароль root, завели еще одного пользователя и задали ему известный нам пароль. Потом зашли под root, открыли файл с хешем пароля того сотрудника, скопировали его в отдельный файл, а на его место вставили хеш пароля нового пользователя. Это позволило нам зайти в учетную запись пахучего сотрудника, использовав пароль временного пользователя. Мы поменяли на десктопе фон, поставив картинку с младенцем и большой надписью: “Даже малые дети знают, что надо принимать душ каждое утро и пользоваться дезодорантом!”.
После этого снова зашли под root, скопировали обратно хеш его пароля из сохраненного файла и вставили его обратно, а временного пользователя удалили.
На следующее утро мы с предвкушением ждали его реакции и были вознаграждены громким возгласом изумления, раздавшимся тогда, когда он загрузил свой компьютер. Наши старания были не напрасны, парень стал принимать душ и пользоваться антиперспирантом!
*Константин В.*
Несколько лет назад, работая в Лаборатории искусственного интеллекта МТИ (на самом деле очень много, потому что описывается компьютер из 60-х годов), я рылся в шкафах, где находился мейнфрейм PDP-10, и заметил маленький переключатель, приделанный к раме одного шкафа. Очевидно, это был прикол, который добавил один из местных “хакеров”.
На самом деле, есть правило: “Не трогать переключатель, если вы не знаете, что он делает, потому что это может привести к сбою компьютера. Но этот был маркирован совершенно дурацким образом, у него было два положения, и на металлическом корпусе карандашом были нацарапаны слова «магия» и «больше магии». Тогда тумблер был в «более волшебном» положении.
Я позвал другого сотрудника, чтобы он посмотрел на это чудо. Но он тоже никогда раньше не замечал его. При более внимательном изучении выяснилось, что к выключателю подведен только один провод, который скрывался в лабиринте внутри компьютера. Логично, что выключатель не может ничего делать, если к нему не подключены провода с двух сторон, но у этого переключателя был только один провод.
Понятно, что этот переключатель мог быть только чьей-то глупой шуткой. Убедившись в том, что он не должен работать, мы щелкнули им. Компьютер моментально сломался…
Представьте себе наше крайнее изумление! Мы списали это на совпадение, но тем не менее вернули переключатель в «более волшебное» положение перед тем, как запустить компьютер снова, и больше его не трогали.
Год спустя я рассказал эту историю еще одному хакеру, Дэвиду Муну. Он посмеялся надо мной и выразил сомнения в моем здравом уме, обвинив меня, в вере в сверхъестественную силу этого переключателя. В доказательство своих слов я показал ему этот “волшебный выключатель”, все еще привинченный к корпусу шкафа с подключенным к нему только одним проводом, оставленный в положении «больше магии». Мы внимательно изучили переключатель и обнаружили, что другой конец провода был подключен к контакту заземления. Это явно выглядело вдвойне бесполезным, он не только не работал электрически, но и был подключен к контакту, который, в любом случае, ни на что не мог повлиять. Итак, мы щелкнули выключателем.
Компьютер снова сломался…
На этот раз мы побежали за Ричардом Гринблаттом, бывалым хакером из Массачусетского технологического института, который работал неподалеку. Он никогда раньше не замечал этого выключателя, но когда осмотрел его, тоже пришел к выводу, что он бесполезен, и решительно откусил провод. Затем мы перезапустили компьютер, и с тех пор он работал без проблем…
Мы до сих пор не знаем, как выключатель ломал машину. Существует теория, что цепь рядом с выводом заземления была на пределе, и щелчок переключателя изменял электрическую емкость достаточно для того, чтобы нарушить цепь, когда через нее проходили импульсы с длиной в миллионные доли секунды.
Этот выключатель все еще валяется у меня в подвале. Возможно это глупо, но я держу его в положении «большей магии”.
Добавлено в 1994 году.
С тех пор было предложено еще одно объяснение этой истории.
Корпус переключателя был металлическим, а неподключенная сторона переключателя была привинчена к корпусу компьютерного шкафа (обычно корпус подключается к отдельной клемме заземления, но бывают исключения). Таким образом корпус выключателя был соединен с корпусом компьютера, который, предположительно, тоже заземлен. Заземление цепи внутри машины не обязательно имеет тот же потенциал, что и заземление корпуса, поэтому щелчок переключателя соединяет заземление цепей компьютера с землей корпуса, вызывая падение/скачок напряжения, которое перезагружает машину. Вероятно, это было обнаружено кем-то, кто на собственном горьком опыте, выяснил, что между ними существует разность потенциалов, а затем приделал переключатель в качестве шутки.
*Хакерский фольклор МТИ*
В одной конторе, где я в свое время работал, был один товарищ.
Трубку домофона в той конторе повесили у двери, к двери он сидел ближе всех, но бегать на каждый звонок ему было лениво.
Как он решил эту проблему? Он подключил контакты кнопки домофона, открывающей дверь, через реле к флоппи-дисководу, расшарил доступ к диску A:, вывел всем ярлычки «Открыть дверь».
После этого любой работник мог открыть дверь по локальной сети.
*Фольклор*
В одном закрытом военном НИИ проводили инвентаризацию и наткнулись на описание оборудования, которое никто не мог опознать. В “Книге учета” оно было записано как “соком 50 хэ”. Раз оборудование стоит на учете, его надо найти и проверить, тем более, что оценено оно было в заметную сумму “условных единиц”. Народ долго ломал голову, пока одному научному сотруднику не пришло в голову простое решение этого ребуса. Учетом занималась весьма пожилая женщина, без высшего образования, не знающая никаких языков, кроме русского. Потому, привод для CD-ROM, 50-скоростной, она записала “как поняла”, то есть “соком 50 хэ”.
*Константин В.*
Однажды, когда я работал в одной небольшой фирме в нашем кабинете стали проводить инвентаризацию и всех попросили выйти, потому что нужно было наклеить инвентарные номера на всю мебель и оборудование, а мы им мешали. Мы решили совместить приятное с полезным и пошли обедать.
Вернувшись с обеда, мы обнаружили, что ни одна мышка не работает. Причина стала очевидна, когда я перевернул свою кверху брюшком. Ну куда еще можно наклеить инвентарный номер на мышь? Конечно же поперек отверстия с шариком!
*Константин В.*
В одной компании был МФУ Xerox, и у данного устройства существовала полезная особенность — умение отсылать отсканированные документы на емейл. Для этого ему, как ни странно, нужна учетная запись на почтовом сервере, ибо отсылает он по SMTP. Меняли почтовый сервер, часть учетных записей мигрировали, а часть решили просто пересоздать. В процессе создания новой учетки для МФУ полезли на старый сервер уточнить login и обратили внимание на папку с входящими письмами. С сервера адский агрегат почту не забирал, так что скопилось ее порядка пятидесяти мегабайт.
Оказалось, что народ ведет активную переписку с МФУ, пишет ему «Спасибо!» и «Благодарю за документы!». Особенно запомнилось сообщение одной сотрудницы: «Спасибо, скан договора получила, жду от Вас приложение 2»
*Фольклор*
Был случай, когда студентам, изучающим искусственный интеллект, дали задание написать самообучающегося бота для 3д-шутера. Студенты справились с заданием и запустили ботов в локалку, чтобы они за ночь наловчились убивать друг друга. Утром зашли в сетку и стали тестировать своих ботов. Выяснилось, что живых игроков выносят в первые же секунды, и выжить нет ни единого шанса. Когда стали смотреть логи, оказалось, что уровни в игре были сделаны небрежно, между текстурами были зазоры, которые не бросались в глаза игрокам, но были обнаружены ботами, и позволяли им прятаться внутри стен, проходя в любое помещение и убивать игроков, не давая им обнаружить себя.
*Фольклор*
Друг работает на складе комплектующих для компьютера.
Им пришёл заказ из СНБ на 100 модулей оперативной памяти. Вы представляете себе сто оперативок? Упаковали их компактно в коробочку 60 на 40 сантиметров. Приезжает представитель СНБ, у них с менеджером происходит диалог, после которого менеджер вползает в конвульсиях в кабинет шефа, вручает ему коробку с памятью и просит выйти самого.
Шеф выходит на крыльцо. Там стоит вышеупомянутый представитель, который показывает на КАМАЗ… С ПРИЦЕПОМ!.. и выдаёт: «Я тут машину подогнал, если этого не хватит, то мы ДВЕ ХОДКИ СДЕЛАЕМ!..»
Шеф не растерялся, протягивает представителю коробочку и просит подержать. Сам подписывает документы, стоит и улыбается. Представитель начинает нервничать: «Где же товар, у меня люди ждут, ЗАГРУЖАТЬ НАДО!».
Шеф: «Он у вас в руке».
*Фольклор*
Мой брат живет в соседнем штате и уже достал просьбами помочь ему с компьютером по принципу “тыжпрограммист”. Некоторые из звонков в семейную службу техподдержки были болезненные как лечение у стоматолога. Ему казалось, что в его компьютер попадают вирусы и трояны, после чего он звонил мне. Он мог часами держать меня на телефоне, заставляя чинить ему компьютер.
Однажды я решил эту проблему раз и навсегда.
— Тебе надо зайти в Гугл
— Как мне это сделать?
— Откройте свой браузер, введите Google и нажмите Enter.
— Что за браузер? Как я могу это сделать?
— Это, с чего ты смотришь что-либо в Интернете…
— О… Он только что открыл Word? Так и надо было?
И в таком духе разговор продолжается больше часа. Внезапно мне в голову приходит дикая идея. Последовательно я подвожу его к тому, чтобы загрузить и установить VNC. Затем заставляю его посетить несколько сайтов по компьютерной безопасности, чтобы напугать его последствиями беспечного поведения в интернете, все время читая лекции на эту тему.
Я: Интернет действительно опасное место. Ты должен быть осторожен. Очень осторожен. Есть хакеры, которые хотят взломать твой компьютер. Если они заразят твой компьютер, то загрузят на него хакерские программы, которые будут делать всякие неприятные вещи. Они могут украсть твои пароли или получить доступ к банку и кредитным картам!
Одновременно с этим я через VNC «случайно» открываю и закрываю окна, захожу на разные сайты.
Я: Они даже могут захватить твой компьютер, превратив его в бота, которым ОНИ будут управлять. Я слышал рассказы о людях, к которым приходили из ФБР, потому что их компьютер был захвачен хакерами, и использовался для атак на Белый дом или Пентагон. Бедные люди даже не был в курсе, что их взломали…
При этом я открываю и закрываю все больше окон.
Он: Эй! Я не уверен, что происходит, но мой компьютер ведет себя странно. Он пытается самостоятельно выйти в Интернет!
Я: Ой-ой. Это плохо! Ты уверен, что печатаешь не слишком быстро? На всякий случай запусти антивирус. Если ты не сможешь этого сделать, то это очень плохо.
Он пытается, но я мешаю движению его мыши. Наконец я позволил ему запустить программу, и как только она открылась, то я сразу закрыл ее.
Он: Я начинаю волноваться. Я не знаю, что происходит! Я ничего не могу сделать на своем компьютере!!!
А я открываю командную строку и запускаю команды: IPCONFIG, netstat, tracert whitehouse.gov и тд.
Я: Вау — что ты сделал?! Выглядит очень серьезно. Похоже, твой компьютер был атакован… Может быть, хакер пытается проникнуть в него. Возможно, тебе придется отключить его. Похоже, они пытаются добраться до твоего банка или того хуже…
При этом начинаю набирать:
`Access: Pentagon Classification TS5
PASSWORD REQUIRED: ******
FAILURE 1 NOTED: Alert sequence
Delta Alpha Charlie initiated : IP TRACKING LEVEL 1 PRIORITY INITIATED
WARNING - PASSWORD FAILURE 2
ALERT TEAM NOTIFIED: FINAL PASSWORD FAILURE
Security Breach detected. Tracking completed. IP ADDRESS confirmed. Response Team dispatched. Address Confirmed: Illegal security breach confirmed. Trace complete. Team dispatched - 2123 Main street: Perpetrator confirmation - John Smith.`
Естественно, я использовал его реальный домашний адрес.
Я продолжал пугать его, набирая вышеуказанное, но он начал меня перебивать
— Ой, чувак, это действительно очень плохо… Они взламывают Пентагон. Что мне делать. Что делать?!
Я намереваясь действовать слишком медленно для его удобства.
— Ой, ты должен запустить антивирус.
— ПОМОГИТЕ! Они знают, кто я. Что мне делать?!
— Ну, я бы посоветовал выключить компьютер, положить его в коробку и вернуть в магазин!
Наконец я уже не смог сдерживать смех и спалился, а потом объяснил ему, что я делал. Почему-то это не показалось ему настолько смешным, как мне. Но с тех пор мне не звонили как “тыжпрограммисту”!
*Комментарий к статье*
Наверное, худшая история, которую я могу вспомнить, помимо обычной головной боли от пользователей, была о том, как мне пришлось провести исследования активности одного пользователя в сети. Было показано, что этот человек генерирует очень большой трафик во второй половине дня и замедляет работу всего отдела. После нескольких минут изучения логов я обратил внимание на название одного из его часто посещаемых сайтов. Уже не помню конкретный адрес, но то был сайт, посвященный КРУПНЫМ женщинам. Я передал эту информацию своему руководителю, который передал ее дальше, и скоро я получил ответ от начальника моего босса, что им нужны конкретные примеры того, на какие типы сайтов он заходит, со скриншотами.
Остаток дня я никогда не забуду… Если бы у меня под руками был отбеливатель, я бы залил его в свои глаза сразу, как только он зашел на тот сайт. Очевидно, этот «джентльмен» проводил 80% своего времени, просматривая очень сомнительные материалы в офисе.
После сбора снимков экрана в течение двух часов я связался с начальником моего босса, чтобы показать ему свое расследование…
Позже он сказал мне, что они поговорили с тем сотрудником, и он уволился.
**110 != 220**
Это был мой первый год в ИТ, и мне пришлось менять компьютер, который управлял огромной сушилкой для древесины. Мне не очень много лет, но тогда многие компьютеры работали под DOS.
Я позвонил в Германию, в компанию по производству печей, нашел человека, который владел английским, получил спецификации, собрал снаряжение и уехал к заказчику, который находился за 200 миль. После резервного копирования предыдущей системы (на дискеты!) я вытащил огромную сетевую карту из старого компьютера, вставил в новый, подключил питание к ИБП и нажал кнопку включения.
БУМ
Голубой дымок из перегоревшего блока питания… С побелевшим лицом я позвонил начальнику, рассказал ему обо всем, что я сделал, и к чему это привело.
«Не переживай, щит хепенс, просто зайди в компьютерный магазин в получасе езды, купи новый блок питания и попробуй еще раз. Да, и удали эту чудовищную сетевую карту, прежде чем снова включишь питание!».
Быстро съездив до магазина и обратно, я возвращаюсь с новым блоком питания, заменяю его, снимаю сетевую карту и снова нажимаю кнопку питания.
БУМ
Еще больше голубого дыма, и мое лицо побелело еще сильнее. Я перезваниваю своему боссу: «Опять что-то не так с вашей установкой». Через несколько минут, обсудив с ним все по телефону, мы пришли к выводу, что компьютер собран правильно, а проблема в чем-то другом.
— Куда ты подключил шнур питания?
— К ИБП
— Хммм… А чьего он производства? Ты не знаешь? Написано по-немецки?
— Да
— Тогда вернись в магазин, купи новый блок питания и поставь красный переключатель на задней панели на 220В. Перезвоните мне, когда печь снова заработает.
Вот так выяснилось, что в Германии техника работает на 220В. Думаю, 19-летний парень из Канады, которым я тогда был, мог этого не знать.
*Из комментариев к статье*
Когда я только начинал свою карьеру в сфере IT, и мне сказали, что один VIP-пользователь никак не может подключиться к VPN, попросили помочь. На его рабочем компьютере все было в порядке, поэтому я попросил пользователя лично показать мне, что он делает. Он достал свой токен RSA, ввел код с него и вошел в систему.
Однако этот пользователь не первый раз жаловался эту проблему, и я был не первым, кто пытался ему помочь. Я попросил его рассказать по шагам, что он делает перед тем, как у него не получается зайти в сеть.
«Сначала, я достаю свой ноутбук, подключаю сетевой кабель, подключаюсь к Интернету из дома. Потом запускаю VPN-клиент, вытаскиваю этот листок с кодом и набираю его…»
Оказалось, что он записывал код с токена RSA перед тем, как уйти домой, а сам токен оставлял на работе, потому что эта штука была довольно дорогой, и он не хотел ее терять. Я объяснил, что номер все время меняется, и ему нужно всегда носить его с собой. Проблема с VPN была решена.
*Комментарий к статье*
Одна из компаний, поддержкой которых мы занимались на моей прошлой работе, была университетская полиция. И вот однажды моему коллеге позвонил начальник полиции и сообщил, что что-то не так с подключением к сети Ethernet на его новеньком ноутбуке. Мы быстро подъехали, чтобы взглянуть на его ноутбук. Проблема была очевидна!
Каким-то образом (я до сих пор не знаю, как у него хватило силы) начальник полиции вставил кабель Ethernet в разъем модема RJ-11. И вставил его так сильно, что треснул корпус вокруг разъема.
*Комментарий к статье*
Несколько лет назад мне позвонил один пользователь и пожаловался, что у него проблемы с печатью на принтере в его кабинете. Я зашел в настройку «Принтеры» WindowsXP и увидел, что принтера там нет.
Я подошел к его столу, чтобы проверить соединение, но обнаружил, что его рабочая станция не подключена к принтеру.
«Зачем мне это нужно?», — он спросил, — «Это же ЛАЗЕРНЫЙ принтер!"
*Комментарий к статье*
Это было в середине 90-х, в старые добрые времена DOS. Я работал в очень большом банке и оказывал поддержку пользователям по всему штату. Обучение сотрудников там не одобрялось, и в бюджете не было предусмотрено, поэтому у нас были здания, заполненные людьми, пытающимися понять, как заставить работать их компьютеры. Одна дама работала в налоговом отделе, лет ей было 190, и она использовала компьютер только потому, что была вынуждена (опять же без обучения!). Я настроил для нее систему и сделал ее максимально удобной для пользователя, насколько это вообще было возможно в DOS. У нее было простое меню с тремя вариантами, один из которых запускал налоговую программу.
Однажды она позвонила мне очень сильно раздраженная: «На моем экране ничего нет!». Не имея в своем распоряжении никаких диагностических инструментов, кроме своего воображения, я начал использовать ее как свои глаза.
— Посмотрите на монитор, ту штуку, которая похожа на телевизор, горит ли зеленый светодиод?
— НЕ ЗНАЮ
— Посмотрите справа от телевизора, 2 дюйма вниз и 1 дюйм направо.
— Есть зеленая лампочка.
Я еле удержался от комментариев, и мы повторили этот процесс для компьютера, с аналогичными сложностями в переводе с «айтишного» языка на понятный ей. После выяснения того, что все действительно было включено и работало правильно, я снова обратил внимание на монитор. Мог ли он сгореть?
— Хорошо, я хочу, чтобы вы посмотрели в телевизор. Вы видите что-нибудь похожее на светящиеся оранжево-желтые буквы где-нибудь на стеклянной части телевизора?
— О да, там написано 'C: ->'
Я подумал объяснить ей, что она смотрела на приглашение DOS, но решил пропустить такие подробности.
— Наберите MENU, нажмите Enter и расскажите мне, что происходит
— Ничего.
— Есть новые яркие символы?
— Да: “Bad command or filename C:->”.
Несколько попыток запустить приложение “Menu” не увенчались успехом, поэтому я подумал, что, возможно, приложение было повреждено. После внутренних стенаний о том, что будет дальше, я сказал:
— Давайте попробуем запустить приложение Tax без меню. Я хочу, чтобы вы набрали: “CD (space) TAX”, нажмите Enter и расскажите мне, что произошло.
— Ничего! На экране ничего нет!
С растущим возбуждением я прошу:
— ПОСМОТРИТЕ НА 1/2 дюйма от того места, где остановились ваши глаза и прочтите чертовы светящиеся символы!
— “Bad command or file name".
Я был в недоумении… Потом еще подумал несколько минут, и мне в голову пришла идея.
— Прочитайте по буквам то, что вы только что набрали
— “S E E D E E S P A C E T A X"
Именно в тот момент своей карьеры я понял, для чего на самом деле нужна кнопка отключения звука. Когда я отключил свой телефон, то с криком ударился головой об стол!
*Комментарий к статье*
У меня было давно такого, чего я уже не вспомню, но есть один случай, когда одна девушка сообщила: “На мониторе моего компьютера утка”.
Служба поддержки 1-го уровня удаленно проверила ее машину и не нашла вредоносных программ или приложений, которые могли бы вызывать такое поведение. Они уже собирались прислать мне компьютер, чтобы я физически проверил, но, прежде чем отдать мне свою машину, она заявила, что со всем разобралась.
Мне было очень любопытно, что же вызвало такую проблему, поэтому я спросил, что произошло
Она ответила, что поклонник наклеил на ее монитор стикер с уткой, и она просто не заметила этого.
*Комментарий к статье*
Однажды вечером нам позвонили из небольшой фирмы примерно в 70 милях от нас. Перед этим мы продали им новый принтер, все, что им нужно было сделать — установить драйверы и подключить устройство. Ничего особенного.
Но они позвонили мне и сказали, что компакт-диск не помещается в дисковод. Читая наклейку на диске, они сказали, что поняли проблему. На диске было написано, что он предназначен для MAC, а мне нужно было отправить им диск для Windows, так как компакт-диск от MAC не влезет в привод. Дело было срочное и я поехал к ним в офис.
Я понял проблему сразу, как только вошел в офис, потому что на верхней части компьютера были маленькие резиновые ножки. Решение? Переверните компьютер и теперь CD отлично подходит!
*Комментарий к статье*
Было дело, в техподдержку позвонила женщина позвонила и сказала, что каждый день она сохраняет свою базу данных на дискете, а на следующий день дискета всегда пуста.
После того, как несколько дней мы просили ее проверять целостность данных в резервной копии, и все было в порядке, но на следующий день снова все исчезало, мы отправили к ней технического специалиста.
Что он увидел?
После сохранения данных на диск 5 1/2 она прикрепляла его к своему металлическому шкафу с помощью промышленного магнита.
*Комментарий к статье*
В один момент мне было необходимо срочно проложить четыре десятка проводов витой пары на расстояние в сто метров. Большая часть дистанции проходила над навесным потолком на трёхметровой высоте. Поняв, что для моих единственных в конторе админских плеч решение задачи в приемлемые сроки является непосильным, я принялся терзать шефа на предмет привлечения сторонних монтажников, и тот, скрепя сердце, согласился. Я разработал техзадание, разослал по разным конторам и стал ждать.
Одно из предложений сильно выделялось из общей массы. Ребята утверждали, что работу они выполнят всего за один день, причём втрое дешевле, чем любой из конкурентов! На всякий случай перезвонил и уточнил, правильно ли они поняли задание. Ответили, что поняли прекрасно, а скорость и дешевизна объясняется тем, что в работе используется кабелеукладчик. Я был заинтригован. С кабелеукладчиками имел дело в армии и решительно не представлял, каким образом данный девайс можно приспособить к прокладке витой пары под фальшпотолком.
В назначенный день прибыли всего два монтажника со стремянками и инструментами. Наблюдая за процессом разгрузки, я с нетерпением ждал чудо-агрегата, способного автоматизировать процесс. Агрегата так не дождался, зато последней из микроавтобуса была выгружена некрупная такса. Не успел я удивиться по поводу появления животного, как мне объяснили, что это и есть таинственный кабелеукладчик.
В комплекте к таксе шел специальный костюмчик с ручкой вдоль спины для переноски, сбруя на голову со светодиодным фонариком и шлейка. Прокладка кабеля осуществлялась путём прикрепления его к шлейке и запуска таксы в труднодоступное место. Надрессированное животное шустро мчалось на звук голоса или свет фонаря, волоча за собой провод. Потолок собаку выдерживал, мощности же хватало метров на пятьдесят.
Скорость прокладки в длинных и труднодоступных участках была просто фантастической. Такса резво носилась в одну сторону по верху, а обратно по коридору, пугая женскую часть персонала. Даже ЧП в виде выпавшей панельки потолка не повлияло на её настроение: протягиваемый провод сыграл роль страховочного троса, и собачка плавно опустилась на пол. Ребята сказали, что к таким ситуациям кабелеукладчик приучен.
Смех смехом, но такса на полном серьёзе стояла у ребят на балансе фирм. Мне были продемонстрированы документы. Работу дружный коллектив действительно выполнил менее, чем за день, причем без предварительного разматывания кабеля и, соответственно, без обрезков. Правда, работа нашей конторы полностью встала: всё население сбежалось посмотреть за работой кабелеукладчика.
*Фольклор*
Мы поставили пиво в холодильник и ждем ваших историй
----------------------------------------------------
Победителя определим через неделю, 10 марта.
**UPD**
> Горшочек, не вари.
>
> Прием новых комментариев приостанавливается, но можно голосовать за текущие — чтобы помочь выиграть сразу ящик пива
Напоминаем правила:
* Ваша любимая история, личная, рассказанная другом за бутылочкой пива, прочитанная когда-то
* Баночка [Duke Nukem](http://dukenukembeer.ru/) за каждую историю
* Ящик эля [Duke Nukem](http://dukenukembeer.ru/) за самую заплюсованную историю в комментариях
UDP А вот и победитель!
-----------------------
Ящик пива выигрывает [denis-19](https://habr.com/ru/users/denis-19/). Поздравляем!
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=vconst&utm_content=sysadmin-bayki-konkurs#order) | https://habr.com/ru/post/545258/ | null | ru | null |
# Интеграция в проект LVGL графической библиотеки для микроконтроллеров
[LVGL](https://lvgl.io/) — Light and Versatile Graphics Library также известная как LittleVGL.
Библиотека поддерживает большое количество микроконтроллеров, таких как STM32, ESP32 и другие. Мне пока удалось запустить полноценную демо программу на ESP32 и STM32f429 Discovery. Библиотека открытая, поддерживает большое количество графических элементов с Dark and Light темами. Распространяется под MIT license. Можно свободно использовать даже в коммерческих продуктах. Можно посмотреть интерактивное [Online Demo](https://lvgl.io/demos) без установки на устройство
Библиотека поддерживает подключение двух типов дисплея
1. Напрямую через интерфейс RGB где буфер будет находится на стороне MCU во внутренней RAM или внешней SDRAM
2. Через внешний контроллер дисплея. В этом случае MCU может связываться с контроллером дисплея через SPI или I2C шину. Для улучшения производительности, промежуточные буферы отрисовки внутри MCU также могут быть использованы в этом случае
**Two typical hardware set-ups**
MCU with TFT/LCD driver If your MCU has a TFT/LCD driver periphery then you can connect a display directly via RGB interface. In this case, the frame buffer can be in the internal RAM (if the MCU has enough RAM) or in the external RAM (if the MCU has a memory interface).
External display controller If the MCU doesn't have TFT/LCD driver interface then an external display controller (E.g. SSD1963, SSD1306, ILI9341) has to be used. In this case, the MCU can communicate with the display controller via Parallel port, SPI or sometimes I2C. The frame buffer is usually located in the display controller which saves a lot of RAM for the MCU.
Все очень гибко в этом плане. Если у вас есть драйвер, но в библиотеке еще нет порта под этот драйвер, то вы можете сами легко интегрировать библиотеку в свой проект
Самый простой способ, но и самый медленный это переписать callback отрисовки — my\_flush\_cb
```
void my_flush_cb(lv_disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p)
{
/*The most simple case (but also the slowest) to put all pixels to the screen one-by-one*/
int32_t x, y;
for(y = area->y1; y <= area->y2; y++) {
for(x = area->x1; x <= area->x2; x++) {
put_px(x, y, *color_p)
color_p++;
}
}
/* IMPORTANT!!!
* Inform the graphics library that you are ready with the flushing*/
lv_disp_flush_ready(disp);
}
```
put\_px — Это отрисовка пикселя вашего драйвера. Из за того что отрисовка идет попиксельно это и происходит медленно. В документации библиотеки подробно описаны другие более эффективные способы интеграции
Интегрируем LVGL в проект. Первое это делаем инициализацию библиотеки, дисплея и системы ввода
```
lv_init();
tft_init();
touchpad_init();
lv_demo_widgets(); // Используется для примера из демо
```
Поскольку библиотека внутри себя имеет диспетчер задач. Да это мультипотоковая система, поправьте меня если это не так, то нам потребуется увеличивать внутренний счетчик диспетчера посредством вызова lv\_tick\_inc
```
void * tick_thread (void *args)
{
while(1) {
usleep(5*1000); /*Sleep for 5 millisecond*/
lv_tick_inc(5); /*Tell LVGL that 5 milliseconds were elapsed*/
}
}
```
Причем передавать в функцию надо миллисекунды которые прошли с момента ее последнего вызова или другими словами время с момента предыдущей итерации.
Чтобы не тратить ресурсы на лишний поток можно вызывать эту функцию по прерыванию от таймера. Как раз в STM32 есть SysTick таймер для таких целей:
```
void systickInit (uint16_t frequency)
{
RCC_ClocksTypeDef RCC_Clocks;
RCC_GetClocksFreq (&RCC_Clocks);
(void) SysTick_Config (RCC_Clocks.HCLK_Frequency / frequency);
}
extern "C" void SysTick_Handler (void)
{
lv_tick_inc(1); // 1 ms
}
```
**SysTick timer**
This timer is dedicated to real-time operating systems, but could also be used as a standard
downcounter. It features:
* A 24-bit downcounter
* Autoreload capability
* Maskable system interrupt generation when the counter reaches 0
* Programmable clock source.
Так же надо вызывать в цикле lv\_task\_handler. Рекомендуется дергать его каждые 5 ms для обеспечения хорошего отклика. Я пробовал увеличивать до 20 ms и система все еще оставалась довольно отзывчивой и плавной. Можно оставить как вечный цикл или использовать Thread
```
while(1) {
lv_task_handler();
my_delay_ms(5);
}
```
Циклы должны быть в разных местах. Я сделал ошибку и запихнул lv\_tick\_inc и lv\_task\_handler в один цикл. Вот что из этого получилось — [Тормоза](https://youtu.be/KRr4xy87Pr4)
Когда оба метода были разнесены в разные потоки с правильными интервалами все заработало корректно и быстро:
Библиотека имеет возможность настраивать количество внутренних буферов:
1. Один буфер, когда LVGL рисует содержимое экрана в буфер и отправляет его на дисплей
2. Два буфера с неполным размером экрана, пока идет отрисовка в одном буфере, содержимое другого буфера отправляется для отображения в фоновом режиме
3. Два буфера размером с целый экран
На сайте есть [конвертер для шрифтов](https://lvgl.io/tools/fontconverter) и [картинок](https://lvgl.io/tools/imageconverter). Можно спокойно добавить свой шрифт в проект или свою иконку в меню. Причем опционально можно грузить картинки с внешнего хранилища например CD-CARD или из массива байт расположенного во внутренней Flash памяти.
**How to use the generated file in LittlevGL?**
For C arrays
Copy the result C file into your LittlevGL project
In a C file of your application declare the image as: LV\_IMG\_DECLARE(my\_image\_name);
Set the image for an lv\_img object: lv\_img\_set\_src(img1, &my\_image\_name);
For external binary files (e.g. SD card)
Set up a new driver. To learn more read the Tutorial.
Set the image for an lv\_img object: lv\_img\_set\_src(img1, «S:/path/to/image»);
Еще одна важная и приятная плюшка этой библиотеки, что для ее отладки можно использовать Eclipse IDE в среде Linux и Windows.
Приятно что, для OpenSource библиотеки она хорошо документирована. Имеется множество примеров и портов. Библиотека обросла довольно большим [комьюнити](https://forum.lvgl.io/)
Я запускал порт для ESP32. Даже при использовании mapping для выводов SPI т.е. не дефолтных, на которых получается лучшая скорость передачи, все работало без замедлений:
[ESP32 ST7789 LVGL](https://youtu.be/15qrV2CNSoQ)
[ESP32 ILI9341 LVGL](https://youtu.be/yOIVdAknToc)
**Материалы по теме**
[docs.lvgl.io/latest/en/html/porting/sys.html](https://docs.lvgl.io/latest/en/html/porting/sys.html)
[Basic systick configuration on the STM32](http://www.micromouseonline.com/2016/02/02/systick-configuration-made-easy-on-the-stm32/) | https://habr.com/ru/post/510626/ | null | ru | null |
# Плавающая контентная область сайта.
Приветствую Хабр.
По мотивам cайта, сделанного сами знаете кем :)
В свое время увидел, такой эффект – слева сайта находятся ссылки, при клике на которые контентная область сайта плавно перемещается к указанному идентификатору. Эффект запомнился — решил повторить.
Для реализации плавного перемещения взял JQuery.
**Немного теории:**
Данный эффект достигается путем размещения «окошка» (если честно не знаю, как оно называется у других — как подсказал [j4ck](https://habrahabr.ru/users/j4ck/) — **viewport**), над областью контента, которую мы будем позиционировать.
Область «окошка» можно сделать произвольной.
**Картинкой**
**Практика**
Создаем сетку:
> `<div id="small">
>
> <div id="big">
>
>
>
> <div class="workplace" id="wp\_01">
>
> <p>Первая областьp>
>
>
>
> div>
>
> <div class="workplace" id="wp\_02">
>
> <p>Вторая областьp>
>
> div>
>
> <div class="workplace" id="wp\_03">
>
> <p>Первая областьp>
>
> div>
>
> <div class="workplace" id="wp\_04">
>
> <p>Первая областьp>
>
> div>
>
>
>
> div>
>
> <ul id="links"">
>
> <li><a href="#" id="go" onclick="return moveTo('wp\_01', 'big');">Тест 1a>li>
>
> <li><a href="#" id="go2" onclick="return moveTo('wp\_02', 'big');">Тест 2a>li>
>
> <li><a href="#" id="go3" onclick="return moveTo('wp\_03', 'big');">Тест 3a>li>
>
> <li><a href="#" id="go4" onclick="return moveTo('wp\_04', 'big');">Тест 4a>li>
>
> ul>
>
> div>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Накладываем таблицу стилей для позиционирования:**
> `<style>
>
> html {
>
> height: 100%;
>
> }
>
> body {
>
> padding:0; margin:0;
>
> height: 100%;
>
> }
>
> #big{
>
> width: 30000px;
>
> position: absolute;
>
> top: -1000px;
>
> left: -100px;
>
> cursor: move;
>
> }
>
>
>
> #small {
>
> width: 100%;
>
> height: 100%;
>
> overflow: hidden;
>
> position: relative;
>
> background: url(img/bg.jpg);
>
> }
>
>
>
> #links {
>
> top:10px;
>
> left: 10px;
>
> position: absolute;
>
> width: 75px;
>
> background-color: white;
>
> padding: 5px;
>
> opacity:0.5;
>
> }
>
>
>
> div.workplace {
>
> width: 400px;
>
> position: absolute;
>
> cursor:default;
>
> }
>
>
>
> #wp\_04 {
>
> top:1800px;;
>
> left: 1800px;
>
> }
>
>
>
> #wp\_03 {
>
> top:1000px;;
>
> left: 1500px;
>
> }
>
>
>
> #wp\_02 {
>
> top: 200px;;
>
> left: 400px;
>
> }
>
>
>
> #wp\_01 {
>
> top: 1650px;
>
> left: 800px; }
>
>
>
> div.workplace {
>
> font: normal 90% "Trebuschet MS";
>
> color:white;
>
> }
>
>
>
> a.act {
>
> font-weight: bold;
>
> text-decoration:none;
>
> }
>
>
>
> style>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**javascript**
> `jQuery.noConflict(); /\*мало ли другой framework есть\*/
>
> <br/>
> <font color="#0000ff">function</font> moveTo(divId, mainId) {<br/>
> jQuery(<font color="#A31515">"#"</font>+mainId).stop(); <font color="#008000">/\*Останавливаем текущую анимацию\*/</font><br/>
> <font color="#0000ff">var</font> topIn = jQuery(<font color="#A31515">"#"</font>+divId).css(<font color="#A31515">"top"</font>);<br/>
> <font color="#0000ff">var</font> leftIn = jQuery(<font color="#A31515">"#"</font>+divId).css(<font color="#A31515">"left"</font>);<br/>
> leftIn = leftIn.replace(/px/, <font color="#A31515">""</font>);<br/>
> leftIn = leftIn - 400;<br/>
> jQuery(<font color="#A31515">"#"</font>+mainId).animate({<br/>
> top: <font color="#A31515">"-"</font>+topIn,<br/>
> left: <font color="#A31515">"-"</font>+leftIn<br/>
> }, 1500 );<br/>
> <font color="#0000ff">return</font> <font color="#0000ff">false</font>;<br/>
> }<br/>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Описание**
Передаем функции:
divId – идентификатор области на которую надо встать
mainId – идентификатор контента
c помошью animate плавно перемещаем контентную область к указанному элементу.
Собственно все.
Пример: [http://htmllancer.tu2.ru/workarea.html](http://htmllancer.tu2.ru/workarea.html "Посмотреть пример")
Статья первая – так что ногами не пинать :)
**UPD:** переделал под высоту экрана.
**UPD2:** сделал остановку анимации, теперь при 10 кликах область 10 раз не ездит | https://habr.com/ru/post/46873/ | null | ru | null |
# Обзор маршрутизатора Draytek серии 2912. Часть первая
Сегодня на рынке широко представлены различные модели многофункциональных устройств, которые призваны максимально обеспечить малый или среднего размера офис сетевыми сервисами на базе одного устройства. Но среди них особняком, как и несколько лет назад, стоит продукция [Draytek](http://draytek-russia.ru), это связано с тем, что продукция именно этого вендора задала планку простых в настройке, надёжных и функциональных сетевых «комбайнов» для офиса. Серия маршрутизаторов Draytek 2912, о которых пойдёт речь — это золотая середина, которая находится там, где уровень функционала и производительности маршрутизаторов операторского уровня требуется, но обычного домашнего или домашнего+ маршрутизатора, для решения сетевых задач офиса, недостаточно. К тому же, использование одного устройства экономически целесообразнее, чем держать несколько устройство под разные задачи, если они в среднем, являются типовыми, например, маршрутизация, межсетевой экран, VPN-сервер и прочее. Другая ключевая особенность маршрутизаторов Dryatek, которая сделала их популярным во всём мире, это качество и надёжность, которые компания вложила в устройства, начиная с качества материалов корпуса, микросхем и комплектующих и заканчивая качеством встроенного программного обеспечения. Ещё одна особенность маршрутизаторов Draytek– простота настройки и понятный интерфейс, поэтому многим администратором и инженерам нравится работать с Dryatek. Кстати, что касается документации, здесь тоже порядок, кроме официальных руководств, в Интернете и на сайтах Draytek есть множество примеров настройки маршрутизаторов и интеграции их с оборудованием других производителей.
[](https://geektimes.ru/company/digitalangel/blog/276476/)
Данный обзор поможет подробно познакомиться с серией маршрутизаторов Draytek 2912 на примере модели 2912n и включает две части.
В первой части мы познакомимся со схемами использования маршрутизатора в целом и его отдельными функциями, далее, подробно рассмотрим его характеристики, посмотрим внешний вид и комплектацию, интерфейсы и разъёмы, затем протестируем пропускную способность устройства.
Вторая часть будет посвящена обзору веб-интерфейса, его особенностям и примеру настройки таких функции и интерфейсов как WAN и LAN, Load-balancing, беспроводная сеть, VPN, межсетевой экран, NAT управление пропускной способностью, а также функции USB, диагностики и мониторинга маршрутизатора.
Серия маршрутизаторов Draytek 2912 представлена на данный момент двумя моделями 2912 и 2912n. Модели различаются наличием поддержки беспроводной сети стандарта 802.11n(скорость до 300Мбит\c @ 2.4Ггц) в модели Draytek 2912n, в остальном обе модели одинаковы. Далее, я буду рассматривать модель Draytek 2912n.
Ключевые особенности устройства
-------------------------------
* Серия Draytek 2912 идеально подходит для SOHO сегмента
* Сетевой комбайн формата «всё-в-одном»
* Мощный офисный маршрутизатор с высокой пропускной способностью
* Сетевой фильтр с широкими возможностями
* Система управления безопасностью содержимого CSM (Content Security Management)
* WAN-интерфейс с резервированием и балансировкой трафика между несколькими WAN интерфейсами
* Беспроводная сеть стандарта 802.11n до 300 Мбит\сек (только для модели 2912n) с возможностью создания нескольких беспроводных сетей на одном устройстве
* Поддержка VLAN по портам и на основе тегов.
* Поддержка до 16 VPN туннелей (по протоколам PPTP/ L2TP/ IPsec) с аппаратным шифрованием и возможностью резервирования VPN-соединений (оборудование, официально ввозимое на территорию РФ, поддерживает только протокол PPTP без шифрования)
* Многофункциональный USB-порт для подключения принтера или организации общего доступа к файлам
* Возможность подключения 3G/4G USB модемов как WAN 3 через USB порт
* Управление пропускной способностью с интеллектуальный режимом VoIP QoS
* Поддержка IPv4 и IPv6
* Широкие возможности по управлению через веб-интерфейс или командную строку CLI
* Возможность использования с сервером для централизованного управления и мониторинга VigorACS SI
* Поддержка протокола управления TR-69
* Возможность подключения к анализатору трафика Smart Monitor и мониторинга до 30 хостов.
Схема использования Draytek 2912
--------------------------------
Модель 2912 является прежде всего офисным маршрутизатором с максимальным набором функций, который может потребоваться для создания прозрачной и эффективной сетевой инфраструктуры небольшого офиса. В данном примере демонстрируется комбинированная схема использования маршрутизатора.
Рис. 2
Итак, первое расположение — головной офис, в нём установлен мощный маршрутизатор Draytek 3900, тут же находится единая система управления и мониторинга для всех маршрутизаторов Draytek, используемых компанией, под названием VigorACS SI, при помощи которой можно легко настраивать, обновлять и мониторить все маршрутизаторы в сети, из одного места, причём устройств в сети могут быть сотни. При помощи VPN-туннелей, все офисы объединены друг с другом, в нашем примере это головной офис, офисы А и Б, в них мы установили Draytek 2912 и 2912n, офисы небольшие и производительности данных маршрутизаторов достаточно. В офисе А, маршрутизатор подключён к двум интернет провайдерам, через два WAN порта по Ethernet. Настроена балансировка трафика между интерфейсами WAN, поэтому если у одного из операторов случится авария, доступ в Интернет будет сохранён. Все рабочие места сотрудников подключены по Wi-Fi, причём настроены несколько независимых беспроводных сетей со своими SSID, в примере это сеть Wireless для сотрудников офиса, и гостевая сеть Guest, с ограниченным доступом и лимитами по числу одновременных сессий с устройства и максимальной полосе пропускания, чтобы гости не мешали работе сотрудников. При помощи системы безопасности контента CSM, сотрудникам заблокирован доступ к социальным сетям, при помощи онлайн фильтра веб-контента, на маршрутизаторе проверяется тематика сайтов, к которым сотрудники хотят получить доступ, и блокируется нежелательные. Через USB-порт маршрутизатора подключён принтер, ПК сотрудников «видят» его как принт-сервер. Удалённые сотрудники могут подключаться к локальной сети компании через VPN-клиенты на своих домашних компьютерах, используя PPTP или IPSec. В офисе Б основной провайдер подключён через Ethernet к WAN 1 порту Dryatek 2912, а через USB-порт подключен 3G модем, который настроен как WAN 3 и в случае аварии на канале WAN 1, трафик пойдет через 3G модем. ПК сотрудников, IP-телефоны и серверы находятся в разных VLAN, настроен QoS, так как в офисе используются IP-телефоны. Для мониторинга и анализа сетевой активности пользователей, используется решение Draytek Smart Monitor, при помощи которого, легко понять какой объём трафика потребляют сотрудники и какие веб-ресурсы посещают.
Теперь подробнее рассмотрим ключевые функции маршрутизатора.
**Мощный офисный маршрутизатор с резервированием подключения к Интернет, балансировкой трафика**
Рис. 3
Маршрутизаторы серии 2912 имеют два WAN Fast Ethernet интерфейса – основной порт WAN (W1 на рисунке), 1 порт LAN (W2/P1 на рисунке) может быть настроен как второй порт WAN2. Между интерфейсами настраивается балансировка трафика и резервирование, при использовании сразу двух Интернет-провайдеров в случае аварии на канале одного из них, в офисе будет работать Интернет. Кроме резервирования Ethernet провайдеров, можно подключить резервирования Интернет-канала через 3G/4G модем, который вставляется в USB-порт маршрутизатора и становится портом WAN3.
В дополнение, можно создавать правила маршрутизации (или адресной трансляции NAT) в конкретные интерфейсы WAN/LAN/VPN, для трафика от источников и для адресатов таких как хост или подсеть с опциональным указанием протокола и диапазона портов. В правиле, дополнительно указывается резервный интерфейс, на который следует отправить трафик в случае отказа основного.
Каждое правило имеет приоритет в списке, поэтому если первое правило не сработало, будет применяться следующее правило ниже приоритетом, если оно есть в списке.
**Построение безопасной VPN-сети между офисами или подключение удалённых рабочих мест**
Рис. 4
Маршрутизатор поддерживает до 16 VPN\* туннелей типа LAN-to-LAN для безопасного объединения сетей организации через Интернет или создания VPN-подключений с удалённых рабочих мест надомных сотрудников, используя протоколы PPTP/IPSec/L2P/L2TPover IPSec. Шифрование AES/DES/3DES и возможность IKE аутентификации обеспечивают повышенную надёжность. Использование сдвоенного WAN соединения позволяет использовать не только схему балансировки нагрузки, но и резервирования. Поэтому, если основной канал VPN-канал станет недоступным, его заменит резервный VPN-канал.
Кстати, функции VPN в Draytek настраиваются очень просто. Буквально за пару кликов можно настроить как соединения типа LAN-to-LAN, так и доступ с удалённых рабочих мест. У Dryatek есть свой VPN-клиент для упрощения подключения с рабочих мест, он называется Draytek Smart VPN Сlient. Приложение доступно для свободного скачивания на сайте draytek.com
*\*В официальных поставках маршрутизаторов на территорию РФ удалены все программные средства шифрования, не поддерживающие ГОСТы, поэтому в такой прошивке можно найти только поддержку PPTP без шифрования. Это можно обойти путём установки штатного ПО, которое можно скачать с сайта draytek.com.*
**Организация безопасных сетей для офиса**
Рис. 5
Маршрутизатор поддерживает беспроводную сеть стандарта 802.11n и имеет две всенаправленные антенны. Настроек функций беспроводной сети в маршрутизаторе большое количество.
Устройство поддерживает до 4х независимых беспроводных сети со своими настройками, причём каждой из сетей можно ограничить максимальную полосу для исходящего и входящего трафика, а также включить расписание, в соответствии с которым, будут работать эти ограничения. Для каждой из 4х беспроводных сетей настраиваются свои параметры безопасности, включая фильтры MAC адресов. Для каждой сети можно включить квоту времени использования Wi-Fi на основании MAC-адреса и таймаут на повторное предоставление квоты.
Рис. 6
Также можно включить функцию веб-портала для перенаправления на нужную веб-страницу подключающегося к интернету пользователя, в качестве рекламы компании.
Рис. 7
Ещё одно важно преимущество: любую из четырех беспроводных сетей и подсеть LAN можно объединить и изолировать от других сетей, что повышает безопасность. На маршрутизаторе Draytek 2912 может быть 2 подсети LAN.
Рис. 8
**Мощный межсетевой фильтр с возможностью фильтрации контента на прикладном уровне**
Рис. 9
Маршрутизаторы серии 2912 поддерживают межсетевой экран с невидимой проверкой пакетов SPI (Stateful Packet Inspection), базирующийся на объектах (Object-based), таких как пользователь (при авторизации он получает определенный IP), IP-адрес или группы IP-адресов, протокол и диапазон портов и их группы, ключевые слова и группы ключевых слов, профили расширений файлов. Эти объекты могут быть использованы для создания правил межсетевого экрана, которые можно включать и отключать по расписанию.
Система безопасности содержимого CSM (Content Security Management) — это подсистема межсетевого экрана работающая на прикладном уровне, позволяется блокировать UR- ссылки по ключевым словам и по типу содержимого, например, Java Applet, Cookies, Active X, также можно блокировать различные сетевые приложения, например, IM/P2P или по протоколам прикладного уровня, например, MySQL, SMB, SSH, UltraVPN, список сервисов и протоколов довольно внушительный. Также имеется возможность блокировки DNS по ключевым словам.
Ещё один мощный инструмент, который содержит CSM — система GlobalView Web Content Filter. Предназначена для фильтрации нежелательного контента на тематическом уровне, то есть, например, сайты с тематикой порно, криминал, азартные игры и прочее. Администратор создаёт профили, где указывает тематику сайтов и назначает их в правила межсетевого экрана, затем указывает что делать при совпадении правила, например, заблокировать. Web Content Filter лицензируется, но пробную лицензию для тестирования можно получить бесплатно.
В маршрутизаторе реализованы детектирование и автоматическая защита от DoS-атак, причём метрики порога интенсивности трафика, после которого событие считается атакой, могут настраиваться вручную. Также предусмотрено отправка уведомлений об атаке. Вообще межсетевой экран может работать в одном из двух глобальных режимов:
» Rule-Based, то есть базирующийся на правилах, где объекты, например, IP-адреса станций пользователей, администратор устанавливает правила на основании различных IP-адресов.
» User-Based, то есть управление на основании профилей пользователей, администратор устанавливает правила на различны профили пользователей. Перед этим пользователи должны авторизоваться.
**Управление пропускной способностью и обеспечение качества обслуживания QoS**
Маршрутизатор обладает широкими возможностями настройки качества обслуживания QoS, для решения типичной ситуации – правильной приоритезации критичного к задержкам трафика над трафиком сервисов, которые требуют таких приоритетов. Причём маршрутизатор, по умолчанию, автоматически определяет трафик реального времени, и даёт ему приоритет над другими типами трафика. Например, VoIP-вызовы. В дополнении к настройкам QoS имеются широкие возможности по контролю ширины полосы пропускания и установками лимита расходования трафика как для отдельных IP-адресов, так и для групп IP-адресов. Можно указать какой объём трафика и за какое время будет предоставлен тому или иному пользователю на полной скорости, по исчерпании лимита, скорость будет понижена до определенного порога. Имеется возможность ограничения числа одновременных сессий на конкретные IP или диапазоны IP, а также максимального числа одновременных сессий по умолчанию.
Для включения и отключения правил, есть возможность создать семидневное расписание, до 15 интервалов.
Рис. 10
**Возможность многоцелевого использования USB порта в режимах принт-сервера, хранилища файлов, подключения 3G/4G модемов**
На маршрутизаторе есть USB-порт, который может быть использован в одном из трёх режимов. Во-первых, подключения USB модема 3G/4G для резервирования Интернет-соединения или как основное Интернет-соединение, если других способов подключение к Интернет не имеется.
Во-вторых, подключения USB-принтера к маршрутизатору, который становится принт-сервером и им смогут воспользоваться пользователи, настроив к нему доступ по сети.
В-третьих, подключить USB-накопитель и предоставить общий доступ к файлам диска по FTP или NetBios/SMB.
Рис. 11
**Система анализа трафика Smart Monitor**
Рис. 12
Smart Monitor создан, прежде всего, для решения сетевых проблем путём мониторинга и анализа сетевого трафика, приложение помогает администраторам находить и решать проблемы с сетевыми приложениями. Например, мониторить трафик различного типа, создавать детальные отчёты по использованию трафика пользователями экспортировать их и даже отправлять по электронной почте, есть ранжирование TOP10 по максимальному использованию сетевых ресурсов, например, TOP10 по использованию IM-мессенджеров или загрузкам файлов, также можно ранжировать использование различных сетевых протоколов и учитывать эту информацию при настройке маршрутизатора так, чтобы пользователям было комфортно работать. Для иллюстрации ниже представлены несколько снимков экранов.
Рис. 13
Приложение помогает решать проблемы нецелевого использования рабочего времени и нежелательной утечки конфиденциальной информации. Например, монитрорить злоупотребление IM-мессенджерами и передачу конфиденциальной информацию за пределы компании, время, потраченное на социальные сети, находить пользователей, которые загружают каналы загрузкой больших файлов или потоковым видео и т.д. С помощью SmartMonitor можно следить за активностью пользователей: прочитать электронную почту, переписку в IM-мессенджерах, просматривать загруженные ими файлы.
Для иллюстрации ниже представлены несколько снимков экрана.
Рис. 14
Функция перехвата полезна для восстановления данных в случае их утери пользователем или решения спорных ситуации. Например, прослушивание VoIP-разговоров или восстановление случайно удалённых писем. Естественно, можно просматривать адреса сайтов, которые посещали конкретные пользователи. Что касается разделения прав: в приложении можно создать учётные записи с привилегиями на просмотр информации только для определенных пользователей, например, только сотрудников отдела продаж.
Приложение Smart Monitor захватывает и анализирует трафик который зеркалируется с указанных портов LAN маршрутизатора на Mirror port. К Mirror порту подключается порт сервера, на котором установлено приложение Smart Monitor, трафик с этого порта сохраняется, а затем «разбирается» приложением. Поэтому на сервере может быть два порта: один для зеркалирования трафика второй для управления. Важный момент – с маршрутизатора зеркалируется только трафик потов LAN, беспроводной трафик не зеркалируется, следовательно, не обрабатывается.
Приложение состоит из нескольких компонентов, таких как веб сервер Apahe с PHP, WinPcap, устанавливается на компьютер в несколько кликов. Интерфейс Smart Monitor работает через веб-браузер. Для этого нужно открыть в браузере IP сервера, затем ввести логин и пароль для доступа к системе. Минимальные аппаратные требования для системы на 30 хостов скромные: Intel P4 1.4GHz /AMD CPU, 20 GB на HDD и 1GB ОЗУ. Поддерживаемые ОС Windows XP/7, Linux.
Кстати приложение является бесплатным программным обеспечением. Для более подробного ознакомления рекомендую воспользоваться онлайн демо по адресу <http://eu.draytek.com:50000/Logon.php>
```
Login:guest
Pass:guest
```
Рис. 15
**Система централизованного управления и мониторинга VigorACS SI**
Централизованная система Draytek VigorACS SI предназначена для управления, настройки и мониторинга парка устройств Draytek для больших предприятий, операторов и сервис-провайдеров, которым необходимо максимально упростить и автоматизировать процесс инсталляции и обслуживания оборудования. Использование системы VigorACS SI существенно уменьшает затраты на обслуживание оборудования со стороны сервис-провайдера (оператора) или системного интегратора. Вообще, система заслуживает отдельного обзора так как очень функциональна.
Можно выделить следующий преимущества использования системы Draytek VigorACS SI:
Централизованное управление. Архитектура VigorACS SI позволяет централизовано управлять различными типами устройств Draytek, например, маршрутизаторами, даже если устройства находятся за NAT. Управление любыми устройствами производится из единого интерфейса. Управление может быть, как группами устройств, так и отдельным устройством.
Сокращение расходов на поддержку. Одной из главных задач системы VigorACS SI является сокращение количества обращений в службу технической поддержки и времени необходимого для устранения возникающих проблем. Система позволяет администраторам легко находить и устранять проблемы благодаря простому интуитивно понятному интерфейсу, возможности разграничения прав доступа и аудит настроек, выполненных другими пользователями. Система предоставляет подробную статистику работы всех устройств, оповещение о событиях, и уведомления об авариях, возможность удалённого управления устройствами.
Автоматизация всего цикла настройки и эксплуатации оборудования. Система может быть полезна как сервис провайдерам, так и системным интеграторам, которые хотят максимально упростить и автоматизировать процесс инсталляции и обслуживания оборудования.
Экономия времени. Автоматическая настройка позволяет существенно уменьшить временные затраты на инсталляцию новых устройств и перенастройку уже имеющихся, и как следствие — экономить деньги.
Мониторинг и анализ. Система позволяет отслеживать и анализировать состояния всех устройств в сети и уведомлять о событиях, например, авариях или недоступности устройства, перегрузке или ошибках. Это позволяет принять меры или предотвратить аварию до момента, когда её обнаружит клиент и обратится в службу технической поддержки.
Рис. 16
Ключевые особенности системы:
* Поддержка протокола TR-69
* Совместимость с устройствами Draytek поддерживающих TR-69
* Удалённая автонастройка и мониторинг состояния устройств
* Динамический и настраиваемый по расписанию настройка сервисов
* Мастер настройки VPN позволяющий легко создавать безопасные соединения
* Ежедневные отчёты и обзор производительности
* Уведомления об авариях в режиме реального времени
* Управление топологией с отрисовкой связности устройств.
* Управление встроенным ПО устройств
* Многопользовательский режим с разделением прав
Для управления устройствами система VigorACS SI использует стандартный протокол TR-069
Рис. 17
Система лицензируется и является коммерческим продуктом. Доступ к системе осуществляется через веб-браузер Internet Explorer/Firefox/Safari/Opera, который должен поддерживать Adobe Flash Player 9.0.
Требования к ОС сервера:
* MicroSoft Windows 2003/XP/Vista/7
* Рекмендуется 32/64-bit openSUSE или другие дистрибутивы Linux c Java v1.5/ Mariadb(MySQL) v5.5, для больших инсталляций более 5000 узлов, не рекомендуется пользоваться WindowsMicroSoft Windows 2003/XP/Vista
Минимальные аппаратные требования:
* Intel Pentium 4 CPU 1.0 GHz и выше
* 2 GB DDR2 ОЗУ
* Жесткий диск: 80Гбайт и больше
Демо-интерфейс системы можно посмотреть по ссылке <http://acstest.draytek.com:8001/web/ACS.html> используя учётную запись
```
sername:guest
password:guest
```
Подробная функциональная спецификация Draytek 2912/2912n
--------------------------------------------------------
Ниже приведены подробные технические характеристики Draytek серии 2912
**WAN интерфейс для подключения к Интернет**
* IPv4- DHCP Клиент, Статический IP, PPPoE, PPTP, L2TP, 802.1p/q Multi-VLAN Теггирование
* IPv6- Туннельный режим: PPP, TSPC, AICCU, 6in4, 6rd
* Двойной стек: DHCPv6 Client, Static IPv6, DSLite
* USB WAN через 3G/4G модем
* PPP
* Балансировка исходящей нагрузки на основе политик
* Резервирование WAN-интерфейса
* Поддержка до 30000 NAT-сессий
**Межсетевой экран**
* Мульти-NAT, DMZ Хост, Перенаправление портов
* Базирующийся на объектах межсетевой экран (Object-based Firewall)
* Фильтрация MAC-адресов
* Невидимая проверка пакетов SPI (Stateful Packet Inspection) (Flow Track)
* Предотвращение DoS/DDoS
* Anti-spoofing IP-адресов
* E-mail уведомления и журналирование через Syslog
* Привязка IP-адреса к MAC-адресу
* Управление по расписанию
* IPv6 Сетевой экран
* Управление пользователями
**Функции VPN**
Здесь есть небольшая ремарка: в соответствии с законодательством РФ программно-аппаратные средства, поддерживающие средства шифрования, ввозимые в РФ, должны соответствовать нормативам устанавливаемым контрольно-надзорными органами, поэтому в случае с данным маршрутизатором в ПО убраны все функции шифрования. Это можно обойти путём установки штатного ПО которое можно скачать с сайта draytek.com.
* До 16 VPN-туннелей
* Протоколы: PPTP, IPSec, L2TP, L2TP over IPSec
* Шифрование: MPPE и аппаратное AES/DES/3DES
* Аутентификация: MD5, SHA-1
* IKE аутентификация: Pre-shared ключ и цифровая подпись (X.509)
* Работа и контроль в режимах LAN-to-LAN, Host-to-LAN
* IPsec NAT-traversal (NAT-T)
* Детектирование отключенных пиров Dead Peer Detection (DPD)
* Режим резервирования VPN Backup Mode
* DHCP поверх IPSec
* Сквозное прохождение VPN Pass-through
* Мастер настройки VPN Wizard
* mOTP
**Функции USB**
* Общий доступ к принтеру
* Общий доступ к файлам:
— Поддержка FAT32
— Поддержка общего доступа через FTP
— Поддержка общего доступа через Samba
* Подключения модемов 3.5G (HSDPA)/4G (LTE) как интерфейс WAN3
**Подробный список технических характеристик Draytek серии 2912**
Управление пропускной способностью:
* Функции обеспечений QoS:
— Гарантированная полоса для VoIP-трафика
— Базирующая на классах гарантированная полоса для категорий трафика определяемая пользователем
— Поддержка маркировки DSCP
— 4 уровня приоритезации для каждого вида трафика
* Резервирование полосы
* Переназначение меток QoS для L3 протоколов TOS/DSCP
* Интеллектуальное ограничение пропускной способности
**Сетевое управление**
* Управление через веб-интерфейс
* Мастер быстрой настройки маршрутизатора
* Консольный CLI-интерфейс управления через telnet/ssh
* Административный контроль доступа
* Резервирование и восстановление конфигурации
* Встроенные функции диагностики
* Обновление встроенного ПО через протоколы TFTP/FTP/HTTP/TR-069
* Журналирование через Syslog
* Поддержка SNMP V2/V3
* Установка таймаута сессии управления
* Двухуровневое ограничение прав на управление: администратор и пользователь
* Поддержка протокола TR069
* Поддержка Smart Monitor до 30 терминалов
**Управление безопасностью содержимого**
* Приложения IM/P2P
* Фильтр по содержимому URL:
— Фильтр по ключевым словам в (Белые и чёрные списки)
— Блокировка содержимого по типам(расширениям):Java апплеты, Кукки, Active X, Сжатые, Исполняемые, Мультимедиа
— Возможность указания сетей для которых правила не применяются
* Глобальный фильтр контента GlobalView (используя технологию CYREN)
**Сетевые характеристики**
* DHCP Клиент/Релей/Сервер
* RADVD для IPv6
* DHCPv6 Сервер
* Статическая адресация IPv6
* IGMP Прокси V2/V3
* IGMP Snooping
* Динамический DNS
* NTP Клиент
* RADIUS Клиент
* DNS Кэширование/Проксирование
* UPnP 30 Сессий
* Протоколы маршрутизации:
— Статическая маршрутизация
— RIP V2
* Теггированные VLAN (802.1q) в LAN
**Беспроводная сеть (только для модели Draytek 2912n)**
* Стандарт IEEE802.11n (2.4GHz) до 300 Мегабит\сек
* Просмотр списка беспроводных клиентов
* Изоляция беспроводных сетей
* Безопасность беспроводной сети
— WEP 64/128 бит
— WPA-TKIP/WPA2-AES/Смешанный режим(WPA+WPA2)
— Аутентификация 802.1x
* Сокрытие беспроводной SSID
* Конфигурация нескольких SSID
* Фильтр MAC-адресов
* Обнаружение точек доступа
* Объединение точек доступа при помощи WDS (Wireless Distribution System)
* SSID VLAN группировка с LAN портом
* Контроль пропускной способности сети
* WMM
* WPS
**Комплект поставки, внешний вид и упаковка**
Устройство поставляется в коробке с маркетинговыми элементами, такими как изображения маршрутизатора, информация о его ключевых функциях, также подробное описание возможностей. Вид упаковки говорит о том, что устройство, в том числе, продаётся в магазинах, где потенциального покупателя сперва должна привлечь красивая и качественная упаковка.
Рис. 18
На одной из боковых сторон коробки изображена схема использования VPN-туннелей на WAN интерфейсах устройства и это не случайно, так как устройство обладает широким VPN функционалом, это и демонстрирует производитель. Вторая картинка показывает отличие моделей серии – поддержка беспроводной сети.
Рис. 19
Достаточно взять в руки упаковку и прочитать то что на ней написано, чтобы достаточно полно понять, что может устройство, скрывающееся в упаковке. Списки функций, изображённые на упаковке, были подробно описаны выше.
Рис. 20
Рис. 21
Сбоку, на коробке, изображён символ EAC, свидетельствующий о том, что продукция, маркированная данным знаком, прошла все установленные в технических регламентах Таможенного союза процедуры оценки. Также информация о дистрибьютере оборудования – «ООО Цифровой Ангел». Как и раньше, всё оборудование Draytek изготавливается в Тайване.
На другой боковой части упаковки, информация о модели устройства – в нашем случае модель 2912n, серийном номере, версии встроенного ПО установленного на заводе, информация о регионе для использования – Россия.а
Рис 22
Рис 23
Когда впервые открываешь коробку, первое что бросается в глаза это качество упаковки. Всё хорошо и аккуратно упаковано. Кстати – примечательный факт, что зачастую устройство будет также хорошо или плохо работать, как было упаковано. По опыту, могу сказать, что так оно обычно и бывает. Причём это касается не только маршрутизаторов.
Рис 24
Рис 25
После извлечения содержимого каждый элемент оказывается в собственной упаковке. Комплектация стандартная для маршрутизатора. На изображении ниже Draytek 2912n, в комплектации Draytek 2912 отсутствуют антенны так как данная модификация не поддерживает беспроводную сеть.
Рис. 26
На изображении ниже комплект без упаковочных материалов.
Рис. 27
В комплект поставки входят следующие элементы:
Маршрутизатор Draytek 2912 – 1 шт.
Антенна(только для модели 2912n) – 2 шт.
Патч-корд RJ-45 – 1 шт.
Сетевой адаптер – 1 шт.
Набор для монтажа на стену – 1 шт.
Брошюры – 2 шт.
Техническое описание на русском языке – 1 шт.
Что касается сетевого адаптера, его входное напряжение от 100 до 240 вольт, входной ток 0,35А, мощность 12 Ватт. На выходе сетевой адаптер выдаёт 12 Вольт и 1 А постоянного тока. Адаптер очень компактный. Его изображение представлено ниже.
Рис 28
Сама «тушка» маршрутизатора имеет строгий прямоугольный дизайн и скрытые вентиляционные отверстия в верхней, боковой и нижних частях корпуса. В целом, корпус маршрутизатора умеренно греется. Вентиляция пассивная, поэтому устройство не шумит при работе.
Рис. 29
На верхней панели имеется ряд индикаторов состояния и контроля работы подсистем маршрутизатора
Рис. 30
Приведём описание этих индикаторов
**ACT (Activity)** – Если диод мерцает, маршрутизатор функционирует в штатном режиме, если выключен, маршрутизатор отключён.
**WCF** – если диод горит, функция фильтрации веб содержимого(Web Content Filter) активна
**QoS** – если диод горит, функция обеспечения QoS
**DoS** – если диод горит, функция защиты от DoS атак активна, если диод мерцает то детектирована и активна DoS атака.
**LAN (P4~P1)** – если диод горит, порт активен, если выключен, порт отключен, если мигает, через порт передаются данные.
**WAN(W2~W1)** – если диод горит, порт активен, если выключен, порт отключен, если мигает, через порт передаются данные.
**VPN** – если диод горит, VPN-туннель активен.
**USB** – если диод горит устройство к порту подключено и готово к работе, если диод мерцает, через порт передаются данные.
**WLAN (только для модели 2912n)** – если диод горит, беспроводная сеть готова, если диод мигает медленно, через беспроводную сеть передаётся трафик. Если диоды **ACT** и **WLAN** мигают одновременно и быстро, значит работает функция WPS (Wi-Fi Protected Setup), она автоматически перестанет работать по прошествии двух 2х минут.
Индикация достаточно простая, но полезна для первичной диагностики и оценки состояния маршрутизатора. На следующем изображении нижняя панель маршрутизатора.
Рис. 31
По всей площади имеются вентиляционные отверстия для теплоотвода, посередине наклейка с точным указанием модели устройства, потребляемая мощность – в нашем случае до 9 Ватт. Выходные потребляемые постоянные напряжение и ток 12-15 Вольт и 0.8-0.6 А соответственно. Примечательно, что на наклейке есть электронная почта технической поддержки Draytek, куда можно обратиться за помощью. Резьба для монтажа антенн закрыта силиконовыми колпачками. Для крепления маршрутизатора на стену или потолок в комплекте есть два самореза и два дюбеля. На нижней панели имеются два отверстия для фиксации корпуса на головках саморезов.
**Интерфейсы и разъемы роутера (фотографии с описанием)**
Теперь рассмотрим интерфейсы и кнопки маршрутизатора. Все они находятся в одном месте — на боковой панели маршрутизатора. Для модели 2912n, по краям, под силиконовыми колпачками находятся два коннектора беспроводных антенн с резьбой, куда привинчиваются всенаправленные антенны из комплекта маршрутизатора.
Рис. 32
Слева направо гнездо для подключения сетевого адаптера **PWR**. Рядом находится переключатель для включения или отключения электропитания маршрутизатора. Далее находится порт **USB** 2.0 для подключения накопителя, принтера или 3G/4G модема. Далее, блок портов Ethernet, порты **W1** и **W2/P1** служат для подключения устройства к интернет провайдерам, причём порт **W2/P1** может использоваться или как второй порт WAN или порт LAN. Порты **W2/P1 — P4** служат для подключения к локальной сети. Многофункциональная кнопка **Wireless LAN ON/OFF/WPS** (только для модели 2912n) служит для включения или отключения беспроводной сети на устройстве, для этого нужно нажать на кнопку, дважды если диод WLAN потухнет, беспроводная сеть отключена, если загорится – сеть включена. Если нажать кнопку один раз маршрутизатор будет в течении двух минут ожидать настройки при помощи функции WPS.
Кнопка **Factory Reset** сбрасывает устройство на заводские настройки, чтобы сбросить маршрутизатор, включите его и удерживайте кнопку нажатой более 5 секунд, когда вы увидите, что диод ACT начнёт быстро мигать, отпустите кнопку. Маршрутизатор перезагрузиться с заводскими настройками.
Следующие несколько фотографий демонстрируют вид маршрутизатора с установленными антеннами. Дизайн устройства строгий, очевидно он подчёркивает ориентацию устройства на бизнес пользователей, сетевых инженеров и системных администраторов, а не домашних пользователей. Устройство не бросается в глаза своим необычным видом и впишется в интерьер любого офиса. Относительно компактные размеры маршрутизатора позволяют поставить или повесить его практически где угодно, к тому же пассивное охлаждение, и как следствие отсутствие шума при работе, позволяют использовать его в любом месте.
Рис. 33
Рис. 34
Рис. 35
Ниже вид маршрутизатора с подключенными кабелями.
Рис. 36
Дополнительно, стоит отметить качество пластика и материалов, оно находится на хорошем уровне. Детали хорошо подогнаны друг к другу, при сжатии корпуса нет скрипа и люфта, кабели плотно садятся в разъёмы и не вываливаются, антенны можно зафиксировать под нужным углом, и они не «валяться» в стороны.
**Тестирование пропускной способности устройства**
Тестирование максимальной пропускной способности Draytek 2912n. Для тестирования было использовано программное обеспечение IxChariot 6.7 в качестве оконечных точек ноутбуки со старой доброй операционной системой WindowsXP 32 бита. Схема простая: на одном хосте находится сервер IxChariot, на втором endpoint IxChariot. Конечно, тесты нельзя назвать эталонными так как использовалось старое «железо» и старое ПО, но так как маршрутизатор имеет порты Ethernet 100 Мегабит, то такого оборудования для тестов достаточно. Для тестирования во всех случаях использовался стандартный скрипт High\_Performance\_Throughput.
Тест проводной сети, LAN-WAN c NAT, схема LAN → Draytek 2912n → WAN, продолжительность 00:01:26. Средняя скорость 93,622 Мбит/сек, что является очень неплохим показателем.
Рис. 37
Тест беспроводной сети, Wireless LAN-WAN, схема Wireless LAN → Draytek 2912n → WAN, беспроводной сетевой адаптер на ноутбуке работал в режиме 802.11n, безопасность WPA2/PSK.
Я использовал обычный ноутбук с беспроводным контроллером Intel Wireless WiFi Link 4965AGN, ведь в реальности, среднестатистический пользователь будет использовать подобное оборудование. Продолжительность теста около 3х минут, средняя реальная скорость 40,731 Мбит/сек, при скорости подключения адаптера ноутбука к беспроводной сети около 104 Мбит\сек.
Скорость подключения беспроводного адаптера может составлять 300Мбит\сек, при такой скорости тест Wireless LAN -> WAN покажет скорость около 90Мбит\сек, так как проводной интерфейс WAN имеет предельную скорость подключения 100 Мбит\сек.
Рис. 38
А вот такой же тест беспроводной сети, но без шифрования, разница по пропускной способности не значительна, не смотря на отсутствие шифрования.
Рис. 39
Тестирование VPN, схема VPN Клиент PPTP (без шифрования) → Draytek 2912n → WAN.
Рис. 40
Средняя скорость оказалась 87,986 Мбит\сек.
Теперь шифрование, схема VPN Клиент IPSec(с шифрованием DES) → Draytek 2912 → WAN
Средняя скорость 82,978 Мбит\сек, результат очень неплохой.
Рис. 41
Итак, в данной части обзора мы подробно рассмотрели маршрутизатор Draytek серии 2912/2912n с таких сторон как позиционирование устройства на рынке, схему использования маршрутизатора, его ключевые функции и примеры их использования, ознакомились с подробной технической спецификацией устройства, посмотрели комплектацию и внешний вид маршрутизатора, подробно разобрали функции индикаторов и интерфейсов устройства. Всё увиденное нами, однозначно демонстрирует то, что устройство обладает очень широким возможностями, которые могут понадобиться предприятию уровня SMB/SOHO или небольшому филиалу крупной компании и поэтому устройство имеет огромный потенциал для использования в корпоративных сетях. Нагрузочное тестирование показало неплохие результаты, других результатов я не ожидал, ведь устройство далеко не начального уровня, поэтому обязано быть производительным.
В следующей части обзора мы рассмотрим веб-интерфейс устройства. | https://habr.com/ru/post/394687/ | null | ru | null |
# Универсальный NMEA 0183 Parser/Formatter на C# (+ порт на JAVA)
#### Префикс
Как бы банально это не звучало, но поискав готовое решение, которое могло бы (по моему разумению) полностью поддерживать работу с [NMEA](http://ru.wikipedia.org/wiki/NMEA) — сообщениями, я его не обнаружил.
Проштудировав [официальный документ](http://www.tronico.fi/OH6NT/docs/NMEA0183.pdf), я всецело пропитался идеей непременно это реализовать и недолго думая сам взял себя на понт.
#### Фабула
Да простят меня люди сведущие, но для прочей ясности я все же кратко опишу физику явления.
Итак, сообщение стандарта NMEA, в самом стандарте называются «sentence», тот, кто эти «предложения» «говорит» — «Talker». Так например, GPS-применик в рамках NMEA имеет идентификатор «GP», а наш [ответ чемберлену](http://ru.wikipedia.org/wiki/GLONASS) — «GL».
Существующие решения работали либо только с этими двумя типами устройств, а в лучшем случае понимали различные специфические для конкретных производителей (Germin, UBLox, и пр.) приемников команды.
Да и кто знает, вдруг срочно нужно будет интерпритировать данные поступающие с атомных часов (Talker: ZA), или спозиционироваться по системе Loran-C (Talker: LC), ну а возможность поболтать с автопилотом (Talker: AG) вообще нельзя исключать!
По сути, стандарт описывает 34 типа устройств, выступающих в качестве talker-ов, около 74-х типов сообщений (sentence), возможность применения проприетарного кода (Talker: P) — своего набора команд на усмотрение производителя устройства. И было бы просто обидно взять и не охватить всю эту кухню под единый namespace!
Вообщем, я отталкивался от необходимого результата. В итоге, задача встала так, чтобы работал вот такой код:
```
NMEASentence parsedSentence = NMEAParser.Parse(sourceString);
```
и ещё:
```
string NMEASentenceString = NMEAParser.Build(parsedSentence);
```
И чтобы NMEASentence изнутри выглядел как-нибудь так:
```
public sealed class NMEASentence
{
public TalkerIdentifiers TalkerID;
public SentenceIdentifiers SentenceID;
public object[] parameters;
}
```
К слову сказать, общий вид NMEA sentence имеет такой:
**$[parameter 1],[parameter 2],...[<\*checksum>]**
Это ASCII-строка не длиннее 82 символов, со знаком "$" в начале и в конце. Разобрать такую строку на части сложности нет — все делается простым string.Split();, проблема состоит в том, как проверять и парсить конкретные выражения.
Стандарт описывает несколько основных типов данных, в документации по стандарту они обозначаются следующим образом:
«x» — целый
«x.x» — вещественный
«c--c» — строка
«hh» — шестнадцатеричный
«llll.ll» — широта
«yyyyy.yy» — долгота
«hhmmss.ss» — время
«ddmmyy» — дата
«a» — символ
ещё есть магическая строка "...", означающая, что все последующие параметры сообщения имеют такой же тип, как и предыдующий.
Для реализации парсинга продумывались различные варианты начиная от того, чтобы пронаследовать каждую команду от чего-то базового и реализовать логику каждой команды отдельно, до того, чтобы эвристически запарсить каждый параметр.
Решение же оказалось на поверхности: применим антипаттерн [Magic strings](http://en.wikipedia.org/wiki/Magic_string_%28programming%29#Magic_strings_in_code)!
Раз уж во всех документах описывают формат сообщений в таком виде:
**$GPRMA,A,llll.ll,a,yyyyy.yy,a,x.x,x.x,x.x,x.x,x.x,a**
так пусть они в коде так и хранятся — заодно добавление поддержки новых сообщений черезвычайно просто:
1) копируем описание из мануала
2) вставляем в код
3) ???
4) PROFIT
Под тремя вопросами следующая идея.
Все описания сообщений хранятся в словаре, где ключ — идентификатор сообщения, enum:
```
public enum SentencesIdentifiers
{
AAM,
ALM,
APA,
...
}
```
а значение, искомая «магическая строчка» из мануала. Выглядит это вот так:
```
public static Dictionary SentencesFormats =
new Dictionary() { { SentenceIdentifiers.AAM, "A,A,x.x,N,c--c" },
{ SentenceIdentifiers.ALM, "x.x,x.x,xx,x.x,hh,hhhh,hh,hhhh,hhhhhh,hhhhhh,hhhhhh,hhhhhh,hhh,hhh" },
{ SentenceIdentifiers.APB, "A,A,x.x,a,N,A,A,x.x,a,c--c,x.x,a,x.x,a" },
...
```
Что теперь с этим делать?
Выход такой: выделив параметры сообщения и его идентификатор, определить его описание формата из словаря **SentencesFormats**, которое потом разбить на составляющие, а потом подавать на вход какого-нибудь метода:
```
private static object ParseToken(string token, string formatter)
{
???
}
```
Самая неуклюжая часть всей системы по всем законам и азбукам поселится под этими тремя вопросами, в виде какого-нибудь длинного switch:
```
switch (formatter)
{
case "x.x":
{
return double.Parse(token, CultureInfo.Invariant);
}
...
default:
return token; // просто вернуть исходную строку, если непонятно, что с ней делать
}
```
На этом bottleneck терялась бы вся гибкость системы, что не есть хорошо, поэтому лучше всего это сделать так:
```
return parsers[format](token);
```
Под именем **parsers** и скрывается как раз самый сахар:
```
private static Dictionary> parsers = new Dictionary>()
{
{ "x", x => int.Parse(x) },
...
{ "hh", x => Convert.ToByte(x, 16) },
...
{ "x.x", x => double.Parse(x, CultureInfo.InvariantCulture) },
{ "c--c", x => x },
{ "llll.ll", x => ParseLatitude(x) },
{ "yyyyy.yy", x => ParseLongitude(x) },
{ "hhmmss.ss", x => ParseCommonTime(x) },
{ "ddmmyy", x => ParseCommonDate(x) },
...
};
```
Как видно это словарь, где ключ — форматирующая строка, а значение — функция, делающая превращающая строку-параметр в объект.
Такой словарь может быть сериализован и легко расширен новыми записями, как и список поддерживаемых сообщений.
Похожим образом дела обстоят с проприетарными сообщениями, с небольшими отклонениями от приведенного выше сценария.
#### Постфикс
Идеи, описанные выше были реализованы в полном объеме в библиотеке NMEAParser.
Там же есть и полный список кодов производителей, список из 222 точек привязки (Datums, DOP).
Мне хотелось бы прикрепить к топику архив с исходниками библиотеки, но поскольку такой возможности нет простите мне ссылку на собственную [статью](http://www.codeproject.com/KB/cs/NMEAParser.aspx) на CodeProject, не для собственного пиара ради — а для людей старался, чтоб труд даром не пропал.
Буду рад выслушать критику, пожелания и предложения.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Обновление: в указанной ссылке на CodeProject появился порт на Java | https://habr.com/ru/post/132493/ | null | ru | null |
# Анимации на лямбдах в C++11
Компании-разработчики, как правило, не особо спешат переходить на новый Си++. Главным образом из-за поддержки его компиляторами, а точнее ее полного или частичного отсутствия. Недавно я решил узнать, что же есть новенького в плане поддержки C++11 компилятором GCC, [и понял, что пора начинать](http://gcc.gnu.org/projects/cxx0x.html). Благо, у нас в Ivideon лояльно относятся к новым технологиям и дают пробовать что-то новое.
Начал, конечно же, с самого вкусного — с лямбда-выражений! И с потоков.
Хочу представить читателю небольшую зарисовку на тему того, как лямбды могут помочь сделать код более читаемым и лаконичным. Такой код можно использовать всюду, где надо вызывать периодически какую-нибудь функцию, при этом передавая ей время, прошедшее с предыдущего вызова — например, в анимациях.
Заголовок:
```
#ifndef ANIMATION_ENGINE_H
#define ANIMATION_ENGINE_H
#include
namespace animation {
// Actor function has one parameter: time delta since previous frame
// It should return true if animation has finished,
// or false if it should go on
typedef std::function actor\_func;
// Handler is called after the animation is complete
typedef std::function handler\_func;
const handler\_func doNothing = [] {};
void start(unsigned intervalMs, actor\_func, handler\_func = doNothing);
} // end of namespace animation
#endif // ANIMATION\_ENGINE\_H
```
Интерфейс простой: в start() мы передаём интервал вызовов, функцию и необязательный обработчик завершения.
И реализация:
```
#include "animation_engine.h"
#include
namespace animation {
void start(unsigned intervalMs, actor\_func actor, handler\_func handler)
{
std::thread t([=]() {
auto timeStart = std::chrono::system\_clock::now();
float lastInterval = 0;
while(1) {
std::this\_thread::sleep\_for(std::chrono::milliseconds(intervalMs));
float timeDelta = std::chrono::duration\_cast
(std::chrono::system\_clock::now() - timeStart).count();
if (actor(timeDelta - lastInterval)) {
handler();
break;
}
lastInterval = timeDelta;
}
});
t.detach();
}
} // end of namespace animation
```
Вот здесь уже интереснее: на основе функций, которые передали аргументами, и интервала, строится новая функция (*замыкание*), куда переданные аргументы копируются ([=] означает захват по значению всех используемых в лямбде переменных из текущей области видимости). Дальше эта новая функция запускается в отдельном потоке, где она в бесконечном цикле гоняет нашу несчастную функцию actor, покуда она не вернет true. Ну, или приложение не закроется. Далее start() завершается, оставляя анимацию крутиться в своём потоке.
Ниже пример использования. Допустим, мы пишем игрушку наподобие пинг-понга или арканоида, и нам нужно привести в действие шарик. Вот как можно это реализовать:
```
animation::start (30,
[=] (float dt) {
this->adjustBallDirection(dt); // bouncing, maybe gravitation
this->updateBallPosition(dt);
return (this->ballMissed()) // if player missed the ball -> stop
},
[this] {
resetBall();
}
);
```
Компилировать это всё, как и водится, надо с ключом -std=c++11 или -std=c++0x. Кроме того, на этапе линковки нужно передать ключ -pthread. Если вы, как и я, работаете с QMake, просто добавьте эти две строчки в .pro-файл:
```
CONFIG += c++11
QMAKE_LFLAGS += -pthread
```
Возможное улучшение №1: для реальных задач неплохо бы улучшить расчет интервала между вызовами. Для этого следует учитывать время, пока отрабатывает функция-актор. А то сейчас выходит, что интервал становится чуть больше. Но я не стал заморачиваться на этот раз с этим: просто не об этом заметка.
Возможное улучшение №2: можно ввести дополнительный функционал, который бы позволил прерывать анимации. Сделать это несложно (да хотя бы введением флага, который бы все потоки с анимациями проверяли при работе), но, опять же, код примера распух бы от этого.
Вполне вероятно, что вы знаете более лаконичный способ решения подобной задачи — будет круто, если вы изложите его в комментариях. Или вы знаете более интересный кейс, где лямбды упростили бы жизнь… в общем, вы знаете, что делать.
Спасибо за внимание! | https://habr.com/ru/post/230501/ | null | ru | null |
# Создание пользовательских слоев в SwiftUI. LayoutValueKey
В последние несколько недель мы рассмотрели многие аспекты создания пользовательских слоев с использованием нового **Layout** протокола в Swift UI, однако нам еще многое предстоит обсудить. На этой неделе мы узнаем, как использовать протокол **Layout Value Key** для передачи параметров пользовательских слоев при создании представлений в пользовательском слое.
В предыдущих постах мы создали **FlowLayout** слой, используя новый **Layout** протокол в SwiftUI. Давайте продолжим наше работу над **FlowLayout**, добавив в него еще одну функцию. Допустим, мы хотим настроить точку привязки при размещении представлений в слое. В первом представлении может использоваться верхняя точка, а во втором — нижняя.
> **Если вы хотите узнать больше об основах протокола Layout, пожалуйста ознакомьтесь с** [отдельным постом на эту тему «Building custom layout in SwiftUI. Basics».](https://swiftwithmajid.com/2022/11/16/building-custom-layout-in-swiftui-basics/)
>
>
Swift UI предоставляет нам протокол **LayoutValueKey**, позволяющий нам заводить кастомные параметры для слоя. Мы можем использовать этот тип, чтобы закрепить любое нужное нам значение для вида внутри слоя, а также иметь возможность извлекать это значение в цикле слоя позже при необходимости.
Для начала, мы должны определить тип, соответствующий протоколу **LayoutValueKey**.
```
struct UnitPointKey: LayoutValueKey {
static var defaultValue: UnitPoint = .center
}
```
Создать пользовательский параметр слоя довольно просто. Единственное, что нам нужно сделать, это указать значение по умолчанию для параметра. Во‑вторых, мы должны создать расширение для **View**, чтобы упростить передачу пользовательских параметров слоя.
```
extension View {
func anchor(_ anchor: UnitPoint) -> some View {
layoutValue(key: UnitPointKey.self, value: anchor)
}
}
```
Как вы можете видеть в примере выше, мы используем модификатор представления **layoutValue**, чтобы закрепить конкретное значение к определенному типу, соответствующему протоколу **LayoutValueKey**. Мы можем использовать модификатор представления **layoutValue** без создания расширения для типа представления, но расширение предоставляет гораздо более приятный и чистый API.
```
Text("!!!")
.font(.title3)
.layoutValue(key: UnitPointKey.self, value: .top)
Text("!!!")
.font(.title3)
.anchor(.top)
```
Теперь мы можем определить FlowLayout с набором представлений и передать пользовательскую точку привязки для каждого представления внутри слоя. Если мы не определим ни какого значения в параметре пользовательского слоя, SwiftUI использует значение по умолчанию, которое мы предоставим.
```
struct ContentView: View {
var body: some View {
FlowLayout {
Text("Hello")
.font(.largeTitle)
.anchor(.bottom)
Text("World")
.font(.title)
.anchor(.top)
Text("!!!")
.font(.title3)
}
}
}
```
Последний шаг — использовать параметр пользовательского слоя при размещении или изменении размера слоя. Мы можем получить доступ к пользовательским параметрам слоя, используя **subscript** в прокси‑типе Subview.
```
struct FlowLayout: Layout {
// ....
func placeSubviews(
in bounds: CGRect,
proposal: ProposedViewSize,
subviews: Subviews,
cache: inout Cache
) {
var lineX = bounds.minX
var lineY = bounds.minY
var lineHeight: CGFloat = 0
for index in subviews.indices {
if lineX + cache.sizes[index].width > (proposal.width ?? 0) {
lineY += lineHeight
lineHeight = 0
lineX = bounds.minX
}
let anchor = subviews[index][UnitPointKey.self]
let position = CGPoint(
x: lineX + cache.sizes[index].width / 2,
y: lineY + cache.sizes[index].height / 2
)
lineHeight = max(lineHeight, cache.sizes[index].height)
lineX += cache.sizes[index].width
subviews[index].place(
at: position,
anchor: anchor,
proposal: ProposedViewSize(cache.sizes[index])
)
}
}
}
```
Как вы можете видеть в примере выше, мы используем **subscript** в прокси‑типе Subview для извлечения значения типа **UnitPointKey**. Наконец, мы используем это значение для обеспечения точки привязки при размещении представлений в слое.
Пользовательские параметры слоя позволяют нам очень легко создавать супернастраиваемые и повторно используемые слои в SwiftUI. Я надеюсь, вам понравился этот пост. Не стесняйтесь подписываться на меня в Twitter и задавать вопросы. Спасибо за чтение! | https://habr.com/ru/post/714778/ | null | ru | null |
# Установка Softether vpn-сервера в chroot окружение, под zte f-660 Iconbit 1003d
В предыдущем моем [материале](http://habrahabr.ru/post/211759/) я описывал процесс установки sip-proxy и базовых линукс утилит, в choot окружениие. Заметка вызвала достаточный интерес в хабра-сообществе. По этому я представляю вторую часть материала, в которой опишу процесс компиляции softether VPN-сервера под mips и mipsel архитектуру, для многострадального роутера zte f-660 и iconbit 1003d. Только в этот раз, весь код выложу в виде архива ([mipsel](http://yadi.sk/d/w00i8NFiHuBa5) и [mips](http://yadi.sk/d/BUjKfXdZHuBpZ)), а по тексту расставлю некоторые участки кода, для наглядности. Данный VPN сервер является относительно новым, но своими возможностями успел удивить многих. В частности о нем написано очень много вот [тут](http://habrahabr.ru/post/208782/) и [тут](http://habrahabr.ru/post/211136/).
Для компиляции из исходников нам потребуется изготовленный в предыдущем материале cross-toolchain. Если мы попытаемся vpn-сервер скомпилировать «в лоб»:
```
./configure
make
Install
```
То мы получим ошибку
По чему так произойдет? Все очень просто: дело в том, что так как проект новый, он не рассчитан на кросскомпиляцию, сценарий установки предполагает, что компиляция производится на той же машине, что и для установки. Для того, что бы скомпилировать проект, нам необходимо внести изменения в make-файл.
После небольшого изучения сгенерированного make-файла. Я понял что проблема заключается в некой утилите hamcorebuilder которая компилируется на ходу, и используется для архивации ресурсов, которые в свою очередь используются уже в самом бинарнике VPN сервера. Естественно так как мы используем кросскомпилятор, она не сможет выполниться на сборочной машине. Для того что бы обойти это ограничение, нам нужно всего лишь скомпилировать ее для x86 архитектуры используя системный компилятор /use/bin/gcc.
Я приведу ключевую разницу между сгенерерированным файлом, и исправленным:
`# hamcorebuilder Utility
tmp/hamcorebuilder: src/hamcorebuilder/hamcorebuilder.c $(HEADERS_MAYAQUA) $(HEADERS_CEDAR) $(OBJECTS_MAYAQUA_HOST) $(OBJECTS_CEDAR_HOST)
@mkdir -p tmp/
/usr/bin/gcc $(OPTIONS_COMPILE_HOST) $(OBJECTS_MAYAQUA_HOST) $(OBJECTS_CEDAR_HOST) src/hamcorebuilder/hamcorebuilder.c $(OPTIONS_LINK) -o tmp/hamcorebuilder`
Как мы видим ничего сложного все достаточно просто (добавили новые цели с окончанием \_host и правила для них)
Еще в одном месте, мы исправили часть отвечающая за инсталляцию
`$(INSTALL_BINDIR)vpnserver: bin/vpnserver/hamcore.se2 bin/vpnserver/vpnserver
@mkdir -p $(INSTALL_VPNSERVER_DIR)
cp bin/vpnserver/hamcore.se2 $(INSTALL_VPNSERVER_DIR)hamcore.se2
cp bin/vpnserver/vpnserver $(INSTALL_VPNSERVER_DIR)vpnserver
echo "#!/bin/bash" > $(INSTALL_BINDIR)vpnserver.sh
echo "/bin/vpnserver/vpnserver" '"$$@"' >> $(INSTALL_BINDIR)vpnserver.sh
echo 'exit $$?' >> $(INSTALL_BINDIR)vpnserver.sh
chmod 755 $(INSTALL_BINDIR)vpnserver.sh
.....`
С этого момента у нас есть директория, в которой подготовлена корневая файловая система с VPN-сервером пригодная для запуска в chroot-окружении.
Делаем все как предыдущей [заметке](http://habrahabr.ru/post/211759/) и проверяем работоспособность
* vpncmd.sh
* выбрать 3 вариант
* check
* vpnserver.sh start
Сервер запущен.
Тут не все гладко, для того, чтобы все это нормально работало, нужно очистить память для этого необходимо “поубивать” лишние процессы, вроде встроенного веб-сервера. Проблема в том что они после «убийства» восстанавливаются. Так что, к сожалению, мне не удалось убедится в полноценной работоспособности сервера. Так как роутер постоянно зависал от нехватки памяти. Для того, чтобы продемонстрировать, что методология все же работает, я выполнил всю компиляцию для немного другого девайса iconbit 1003d. И вот на нем, все совершенно четко заработало. (Кстати почитать как необходимо модифицировалось прошивку, чтобы не мучится с флешками, я рекомендую вот [тут](http://habrahabr.ru/post/146150/))
Скорость “обрезалась”, до 6 мегабит в секунду, что не так страшно по сравнению с потенциальными возможностями, которые дает нам VPN-сервер
Подведем итог: мы изучили как можно исправить готовый make-файл, сделав его пригодным для кроскомпиляции. Также удалось скомпилировать software VPN-server сразу под две разные архитектуры, не применив никаких громоздких патчей, фактически мы поменяли только префикс с mips на mipsel. Vpn-сервер Softether показал свою гибкость с точки зрения выбора целевой платформы. Вообще проект меня впечатлил своей гибкостью. Единственно, непонятно по чему, создатели vpn-сервера сделали GUI под windows. Очень хотелось бы видеть полноценный веб-интерфейс в будущих релизах.
[Архив](http://yadi.sk/d/udilY9uhHuHhU) уже скомпилированными программами | https://habr.com/ru/post/212679/ | null | ru | null |
# Вариант управления компьютером на Windows из-под консоли Linux
Бывают попадаются задачи, когда надо что-то сделать из-под Linux-а на машине, на которой установлен Windows, но не через RDP или VNC. Или например, как в моём случае, основная машина на Linux и необходимо управлять группой серверов. И для простых задач, например простого запроса типа `dsquery group -name "Группа" | dsget group -members | dsget user`, который выдаст полный список членов группы в Active Directory со всеми полями — не запускать же ради такого сеанс RDP.
Простого и удобного инструментария я, если честно, не нашёл. За исключением двух утилит: wmic и winexe, которые входят в комплекты Zenoss и OpenVAS. Вернее входили в Zenoss. Не суть, отдельно их я не нашёл, поэтому далее предлагаю свой вариант, большей частью для конкретного дистрибутива (Xubuntu 13.04), но при должной сноровке — всё можно сделать и в любом другом.
Итак, начнём:
```
wget http://www.openvas.org/download/wmi/wmi-1.3.14.tar.bz2
tar -xvf wmi-1.3.14.tar.bz2
cd wmi-1.3.14\Samba\source\wineexe\
```
Далее либо вручную либо с помощью `patch -p0 -i patchfile` применяем изменения из <https://gist.github.com/raw/843062/5bb87c4fa13688f65ca8b1e54fc42676aee42e5a/fix_winexe_service.diff>.
Потом:
```
sudo make
```
После чего можно уже делать:
```
winexe -U domain/user%password //server 'dsquery group -name "Группа"| dsget group -members | dsget user'
```
или
```
wmic -U domain/user%password //server 'select * from Win32_ComputerSystem'
```
Первая команда winexe позволяет запускать любые консольные команды через RPC на Windows-машине, вторая позволяет делать WMI-запросы, что вообщем-то даёт ещё больше возможностей (вот справочник по WQL, это вариант SQL for WMI — <http://msdn.microsoft.com/en-us/library/windows/desktop/aa394606%28v=vs.85%29.aspx>).
Однако есть проблема с выводом консоли winexe от удалённой машины, поскольку Microsoft любит и UTF-16, и CP1251, и CP866 разом. А местами и вовсе UCS-2. Точнее, в моём случае, вывод был в старой доброй CP866. Проблема решается очень просто:
```
luit -encoding cp866 winexe -U domain/user%password //server 'cmd'
```
И на выводе затем мы имеем:
```
Microsoft Windows [Version 6.1.7601]
(c) Корпорация Майкрософт (Microsoft Corporation), 2009. Все права защищены.
C:\Windows\system32>
```
Однако, опять таки в моём случае, luit 1.1 категорически не хотел видеть charmaps для cp866 и выдавал `Warning: couldn't find charset data for locale XXXX; using ISO 8859-1` (похоже на <https://bugs.launchpad.net/ubuntu/+source/x11-utils/+bug/280449>, фикс есть, пакета нет). Я решил для себя, что проще скачать исходники сильно свежего luit-а — <http://invisible-island.net/luit>. Увидеть его в составе x11-utils, где обычно он и бывает, вряд ли будет возможно. Далее:
```
./configure
```
Возможно не будет каких-то зависимостей, всё решаемо. У меня всё пролетело быстро.
```
sudo make
```
Свежескомпилированный luit 2.0 прекрасно переконвертирует на лету из 866 в UTF-8, т.е. в целом моя задача выполнена.
В целом руководствовался тем, что конкретная рабочая машина, настроенная один раз будет управлять любой дефолтной Windows-машиной, на которой запущен RPC и есть права.
Надеюсь на критику, комментарии и предложения.
**upd:** Спасибо [Slipeer](https://habrahabr.ru/users/slipeer/) за ссылку на заметно более свежий winexe — <http://sourceforge.net/projects/winexe/>!
**upd2:** Важный момент, на который стоит обратить, — при запуске cmd посредством winexe внутри не работают клавиши курсора и backspace. В написании скриптов на типовые операции мне это совсем не мешает :) | https://habr.com/ru/post/181103/ | null | ru | null |
# Установка и настройка hyper-v server для тех, кто впервые его видит
#### *Вступление*
Сегодня я расскажу о том, как установить и настроить гипервизор hyper-v server от компании Microsoft, а так же о некоторых подводных камнях и способах их избежать.
Поводом для написания этот статьи стал материал [данного поста](http://habrahabr.ru/post/79292). Этот пост подходит больше как шпаргалка, если вы уже работали с данным гипервизором. Новичку же придется столкнуться с кучей нюансов и перекопать немало форумов, в поисках ответов на нестандартные вопросы.
Эта писалась из расчета — как бы я сам хотел видеть подобный мануал по установке. Для новичков я постарался максимально подробно изложить все действия и их смысл, дабы у них была возможность начать экспериментировать и придумывать что-то свое. Для более подкованных — я разделил статью на логические блоки и подблоки, чтобы можно было быстро найти необходимую информацию.
Под катом много текста и скриншотов
#### *Описание*
MS hyper-v server представляет собой урезанную версию MS server 2008 R2 в режиме Core (т.е. фактически, графический интерфейс отсутствует) с установленной ролью hyper-v и ничего более. Согласно википедии hyper-v server распространяется бесплатно, что вкупе с удобным управлением и интеграцией с продуктами от MS, делает его очень привлекательным гипервизором. Кроме того он имеет достаточно высокие показатели по производительности, а значит ресурсы хостовой машины будут расходоваться на работу нужных нам сервисов.
#### *Установка*
Перед началом установки необходимо убедиться, что ваш процессор поддерживает технологии аппаратной виртуализации Intel VT-x или AMD-V.
Для начала необходимо скачать дистрибутив [hyper-v server 2008 R2](http://www.microsoft.com/ru-ru/download/details.aspx?id=3512) с сайта Microsoft (регистрироваться не нужно). Далее нарезать образ на DVD-диск или сделать [установочную флешку](http://habrahabr.ru/post/98954).
Вставляем диск/флешку и загружаемся с нее.
Hyper-v server — выбор языка мастера установки
Окно установки предлагает нам выбрать язык операционной системы. Выбираем английский, далее объясню, почему именно его.
Hyper-v server — выбор языка ОС и раскладки клавиатуры
Язык мы выбрали английский, а формат времени лучше выбрать русский, чтобы потом не мучиться с настройкой в командной строке.
Далее жмем кнопку «Install now». Читаем и принимаем с лицензионное соглашение.
Hyper-v server — выбор типа установки
Выбираем полную установку (Custom).
Hyper-v server — настройка параметров жесткого диска
На этом этапе мастер предлагает настроить параметры разделов жесткого диска. Лучше всего создать 2 логических диска. Первый — для установки самого гипервизора, ему хватит 15 Гб. Второй для хранения контейнеров виртуальных машин (ВМ). Таким образом, будет намного удобнее осуществлять управление, импорт и миграцию ВМ.
Жмем «Next» и уходим пить чай. В процессе установки компьютер несколько раз перезагрузится.
#### *Настройка*
##### *Базовая настройка и удаленный доступ*
После перезагрузки hyper-v server предложит нам установить пароль администратора. Так как по-умолчанию в групповой политике ms windows 2008 server r2 стоит требование к сложности пароля, придется придумать пароль длинной от 6 символов, обязательно содержащий заглавную букву и спецсимвол или цифру (например «Password1»).
Как вы можете заметить ниже на скриншотах консоль управления у меня на русском языке, хотя при установке был выбран английский язык, скорее всего это из того, что с официального сайта Microsoft я скачал русский дистрибутив. На работу и настройку сервера это негативным образом не повлияет. Если же у вас консоль на английском — можно делать по аналогии, все настройки будет легко понять.
Hyper-v server — интерфейс управления
После загрузки рабочего окружения, ОС предлагает нам 2 консоли управления. Стандартная командная консоль cmd и консоль с предустановленными опциями. Первым делом нам необходимо задать статический ip-адрес и настроить удаленное управление сервером. В консоли управления выбираем пункт 8.
Hyper-v server — сетевые адаптеры
В списке будут перечислены сетевые адаптеры. Выбираем нужный и вписываем его индекс. Далее выбираем «1 — установить ip-адрес сетевого адаптера». Вписываем «S» — что означает статический ip-адрес. Для примера зададим параметры:
ip-адрес — 192.168.1.100
маска подсети — 255.255.255.0
шлюз по-умолчанию 192.168.1.1
После применения параметров, мы вернемся в подменю, где будут перечисленные ранее внесенные настройки. Если все верно возвращаемся в главное меню.
Теперь настроим удаленный доступ. Выбираем пункт 7, далее включаем удаленный рабочий стол, вписав английскую «E». На вопрос об ограничении подключений от rdp-клиентов старых версий, выбираем «2» — подключаться от любых клиентов.
В главном меню выбираем пункт 9, и задаем актуальную дату и время на сервере.
##### *Сетевое имя сервера и рабочая группа*
Теперь настроим рабочую группу. Для работы hyper-v server, я не стал включать его в домен, что несколько усложняет настройку, но для экспериментов это идеальный вариант. Во время тестов и проверки различных конфигураций, лучше изолировать тестовые машины от целевой сети.
Выбираем пункт 1, затем «присоединиться к рабочей группе» вписав «W». Далее задаем название рабочей группы, например «test». Очень важно, чтобы имя рабочей группы на hyper-v server и ПК, с которого мы планируем им управлять, совпадали. После этого мы возвращаемся в главное меню.
Желательно задать сетевое имя сервера, выбираем пункт 2 и вписываем имя, например «hyper-srv». Для применения параметров необходимо перезагрузиться, соглашаемся с предложением ОС.
Далее все настройки (такие как имя компьютера, рабочей группы, пользователи, ip-адрес и т.д.) я буду приводить те, что описывал в процессе установки. Если вы задавали свои параметры, не забывайте использовать именно их.
После перезагрузки мы можем подключиться к серверу, используя клиент удаленного рабочего стола. Выбираем пуск -> выполнить, вписываем `mstsc`. В первом поле задаем ip-адрес (в моем случае 192.168.1.100), подключаемся. Сервер запросит данные авторизации, вводим имя пользователя «hyper-srv\Administrator» и пароль «Password1».
Итак, мы подключились, теперь необходимо настроить дополнительные параметры удаленного управления. Заходим в пункт 4. Теперь по порядку выбираем подпункты 1, 2 и дожидаемся окончания настройки. После завершения, ОС опять попросит перезагрузиться. По завершению этих настроек мы сможем подключаться к серверу с помощь консоли mmc и диспетчера сервера hyper-v из пакета Remote Server Administration Tools (RSAT). Подробнее об этом я опишу далее по тексту.
##### *Установка RSAT и диспетчера hyper-v*
Для комфортного удаленного управления сервером (создание/удаление/импорт/настройка ВМ, добавление/удаление оборудования, управления пользователями/групповыми политиками и т.п.) нам необходимо установить RSAT на наш ПК. Устанавливать будем на windows 7. Первым делом скачаем его [отсюда](http://www.microsoft.com/ru-ru/download/details.aspx?id=7887). В этом пакете нам нужен компонент “Диспетчер hyper-v” для консоли mmc — это собственно основной инструмент управления будущими ВМ.
Последующие настройки будет необходимо производить как на сервере (для краткости СРВ) так и на нашем управляющем ПК (УК).
##### *Настраиваем пользователей*
Первым делом нужно создать пользователя, от имени которого мы будем осуществлять управление. Имена пользователей и пароли должны совпадать для УК и СРВ!
На СРВ — в консоли управления выбираем пункт 3 (добавление локального администратора). Задаем имя «admin» и пароль для него «Qwerty1». Проверим, успешно ли добавился, в консоли cmd вводим `net user admin`. Эта команда покажет нам, что он состоит в группах «Administrators» и «Users».
На УК — запускаем консоль cmd от имени администратора и вводим команду `net user admin Qwerty1 /add`, добавим его в группу администраторов `net localgroup Администраторы admin /add` (для английской версии `net localgroup Administrators admin /add`). Снова проверим результаты с помощью `net user admin`.
Для настройки пользователей и групп безопасности есть замечательная утилита [“HVRemote”](http://archive.msdn.microsoft.com/HVRemote/Release/ProjectReleases.aspx?ReleaseId=3084), написанная одним из сотрудников Microsoft.
Скачиваем утилиту и копируем файл «HVremote.wsf» на сервер. Помните в самом начале, я писал, что нужно выбрать английский язык для ОС? Так вот для корректной работы скрипта «HVremote.wsf» необходимо, чтобы группы безопасности и пользователи именовались на английском языке.
Небольшое отступление: как я писал раньше — в hyper-v server отсутствует графический интерфейс. Это не совсем так, Microsoft просто вырезала по-максимому все, что связанно с Explorer, но это не мешает нам запускать приложения имеющие графические окна. Для примера можно скопировать на диск сервера программу «total commander» и запустить ее из консоли.
Hyper-v server — запуск приложений
Продолжим, на СРВ — открываем консоль cmd, переходим в папку с файлом скрипта (я сохранил в корень диска С: ). Выполняем команду `cscript hvremote.wsf /add:domain\account`, где domain — имя вашего сервера (домена), account — имя учетной записи для управления. В моем случае команда будет выглядеть так `cscript hvremote.wsf /add:hyper-srv\admin`.
Hyper-v server — выполнение скрипта
В результате у вас должно получиться как на скриншоте. Скрипт добавил пользователя в необходимые группы и назначил ему права.
На стороне УК необходимо выполнить следующую команду `cscript hvremote.wsf /anondcom:grant` и `cscript hvremote.wsf /mmc:enable`.
Для работы оснасток консоли удаленного управления компьютером, необходимо создать правила-исключения в брандмауэре сервера. Первым делом создадим правило, позволяющее управлять логическими дисками:
`Netsh advfirewall firewall set rule group="Remote Volume Management" new enable=yes`.
Если у вас выдает ошибку вида «Group cannot be specified with other identification conditions» — попробуйте перепечатать команду вручную, а не копировать/вставлять.
Результат успешного выполнения команды:
```
Updated 3 rule(s).
Ok.
```
Далее разрешим удаленное управление файерволом `Netsh advfirewall firewall set rule group="Windows Firewall Remote Management" new enable=yes`.
```
Updated 2 rule(s).
Ok.
```
Разрешим доступ для любых оснасток консоли mmc `netsh advfirewall firewall set rule group="Remote Administration" new enable=yes`.
```
Updated 3 rule(s).
Ok.
```
Разрешим использовать «Windows Management Instrumentation (WMI)» следующей командой
`netsh advfirewall firewall set rule group="windows management instrumentation (wmi)" new enable=yes`.
```
Updated 4 rule(s).
Ok.
```
Разрешим icmp-протокол — `netsh firewall set icmpsetting 8`.
Разрешим доступ к расшаренным файлам и папкам `netsh firewall set service type=fileandprint scope=subnet`.
Если вы по какой-то причине не можете подключиться к серверу, попробуйте отключить файервол командой `netsh firewall set opmode disable`. Возможно, вам придется создать дополнительные правила доступа.
Теперь мы можем использовать оснастки mmc для управления сервером (управление службами, пользователями, политиками и т.д.) и самое главное диспетчер hyper-v. Давайте откроем его: запускаем консоль mmc -> файл -> добавить или удалить оснастку -> диспетчер hyper-v. Выбираем меню Действие — > подключиться к серверу -> другой компьютер. В поле впишите сетевое имя вашего сервера (hyper-srv) и подключайтесь.
Hyper-v server — диспетчер управления ВМ
Вот собственно и все, мы успешно установили и настроили наш hyper-v server. Теперь можно смело разворачивать виртуальные машины и различные сервисы.
Это моя первая статья на хабре, поэтому жду советов и конструктивной критики
*Ссылки на информационные ресурсы:*
[Wikipedia — Hyper-v server](http://ru.wikipedia.org/wiki/Microsoft_Hyper-V_Server)
[Полезные консольные команды](http://www.curuit.com/managing-windows-2008-server-core-local-settings-2007100993) | https://habr.com/ru/post/146303/ | null | ru | null |
# Используем Webpack вместо Sprockets в Ruby on Rails
За работу frontend части приложения в Ruby on Rails отвечает библиотека [Sprockets](https://github.com/rails/sprockets), которая не дотягивает до потребностей современного frontend приложения. В чем именно не дотягивает можно почитать, например, [здесь](https://www.reinteractive.net/posts/213-rails-with-webpack-why-and-how) и [здесь](https://forum.shakacode.com/t/using-webpack-with-rails/199).
Хотя уже есть достаточно статей на тему связки webpack+rails и даже специальный [гем](https://github.com/mipearson/webpack-rails) есть, предлагаю посмотреть на еще один велосипед, умеющий также деплой делать.
Итак, все frontend приложение будет находиться в `#{Rails.root}/frontend`. В стандартной `assets` останутся только файлы изображений, которые подключаются через `image_tag`.
Для старта необходим Node JS, npm, сам webpack и плагины к нему. Также нужно добавить в `.gitignore` следующее:
```
/node_modules
/public/assets
/webpack-assets.json
/webpack-assets-deploy.json
```
Конфигурация webpack
====================
При использовании консольной утилиты webpack загружает файл `webpack.config.js`.
В нашем случае он будет использован для разделения различных окружений, определяемых в переменной `NODE_ENV`:
```
// frontend/webpack.config.js
const webpack = require('webpack');
const merge = require('webpack-merge');
const env = process.env.NODE_ENV || 'development';
module.exports = merge(
require('./base.config.js'),
require(`./${env}.config.js`)
);
```
В базовой конфигурации для всех окружений мы задаем общие настройки директорий, загрузчиков, плагинов. Также определяем [точки входа](https://webpack.github.io/docs/multiple-entry-points.html) для frontend приложения
```
// frontend/base.config.js
const path = require('path');
const webpack = require('webpack');
module.exports = {
context: __dirname,
output: {
// путь к сгенерированным файлам
path: path.join(__dirname, '..', 'public', 'assets', 'webpack'),
filename: 'bundle-[name].js'
},
// точки входа (entry point)
entry: {
// здесь должен быть массив: ['./app/base-entry'], чтобы можно было
// подключать одни точки входа в другие
// обещают исправить в версии 2.0
application: ['./app/base-entry'],
main_page: ['./app/pages/main'],
admin_panel: ['./app/pages/admin_panel']
},
resolve: {
// можно использовать require без указания расширения
extensions: ['', '.js', '.coffee'],
modulesDirectories: [ 'node_modules' ],
// еще одно улучшение для require: из любого файла можно вызвать
// require('libs/some.lib')
alias: {
libs: path.join(__dirname, 'libs')
}
},
module: {
loaders: [
// можно писать на ES6
{
test: /\.js$/,
include: [ path.resolve(__dirname + 'frontend/app') ],
loader: 'babel?presets[]=es2015'
},
// для CoffeeScript
{ test: /\.coffee$/, loader: 'coffee-loader' },
// для Vue JS компонентов
{ test: /\.vue$/, loader: 'vue' },
// автоматическая загрузка jquery при
// первом обращении к переменным $ или
{ test: require.resolve('jquery'), loader: 'expose?$!expose?jQuery' }
],
},
plugins: [
// можно использовать значение RAILS_ENV в js коде
new webpack.DefinePlugin({
__RAILS_ENV__: JSON.stringify(process.env.RAILS_ENV || 'development')
),
})
]
};
```
Окружение development
---------------------
Конфигурация для development окружения отличается включенным режимом отладки и source map. Я использую Vue JS, поэтому также добавил здесь [небольшой фикс](https://github.com/vuejs/vue-loader/issues/146) для правильного отображения исходного кода компонентов фреймворка.
Также здесь определяем загрузчики для стилей, изображений и шрифтов (для production окружения настройки этих загрузчиков будут другими с учетом особенностей кеширования).
```
// frontend/development.config.js
const webpack = require('webpack');
const AssetsPlugin = require('assets-webpack-plugin');
module.exports = {
debug: true,
displayErrorDetails: true,
outputPathinfo: true,
// включаем source map
devtool: 'eval-source-map',
output: {
// фикс для правильного отображения source map у Vue JS компонентов
devtoolModuleFilenameTemplate: info => {
if (info.resource.match(/\.vue$/)) {
$filename = info.allLoaders.match(/type=script/)
? info.resourcePath : 'generated';
} else {
$filename = info.resourcePath;
}
return $filename;
},
},
module: {
loaders: [
{ test: /\.css$/, loader: 'style!css?sourceMap' },
// нужно дополнительно применить плагин resolve-url,
// чтобы логично работали относительные пути к изображениям
// внутри *.scss файлов
{
test: /\.scss$/,
loader: 'style!css?sourceMap!resolve-url!sass?sourceMap'
},
// изображения
{
test: /\.(png|jpg|gif)$/,
loader: 'url?name=[path][name].[ext]&limit=8192'
},
// шрифты
{
test: /\.(ttf|eot|svg|woff(2)?)(\?.+)?$/,
loader: 'file?name=[path][name].[ext]'
}
]
},
plugins: [
// плагин нужен для генерация файла-манифеста, который будет использован
// фреймворком для подключения js и css
new AssetsPlugin({ prettyPrint: true })
]
};
```
Для разработки еще понадобится сервер, который будет отдавать статику, следить за изменениями в файлах и делать перегенерацию по необходимости. Приятный бонус — hot module replacement — изменения применяются без перезагрузки страницы. В моем случае для стилей это работает всегда, а Javascript — только для Vue JS компонентов
```
// frontend/server.js
const webpack = require('webpack');
const WebpackDevServer = require('webpack-dev-server');
const config = require('./webpack.config');
const hotRailsPort = process.env.HOT_RAILS_PORT || 3550;
config.output.publicPath = `http://localhost:${hotRailsPort}/assets/webpack`;
['application', 'main_page',
'inner_page', 'product_page', 'admin_panel'].forEach(entryName => {
config.entry[entryName].push(
'webpack-dev-server/client?http://localhost:' + hotRailsPort,
'webpack/hot/only-dev-server'
);
});
config.plugins.push(
new webpack.optimize.OccurenceOrderPlugin(),
new webpack.HotModuleReplacementPlugin(),
new webpack.NoErrorsPlugin()
);
new WebpackDevServer(webpack(config), {
publicPath: config.output.publicPath,
hot: true,
inline: true,
historyApiFallback: true,
quiet: false,
noInfo: false,
lazy: false,
stats: {
colors: true,
hash: false,
version: false,
chunks: false,
children: false,
}
}).listen(hotRailsPort, 'localhost', function (err, result) {
if (err) console.log(err)
console.log(
'=> Webpack development server is running on port ' + hotRailsPort
);
})
```
Окружение production
--------------------
Для production можно выделять CSS в отдельный файл, используя `extract-text-webpack-plugin`. Также применены различные оптимизации для генерируемого кода.
```
// frontend/production.config.js
const path = require('path')
const webpack = require('webpack');
const CleanPlugin = require('clean-webpack-plugin');
const ExtractTextPlugin = require("extract-text-webpack-plugin");
const CompressionPlugin = require("compression-webpack-plugin");
const AssetsPlugin = require('assets-webpack-plugin');
module.exports = {
output: {
// добавлем хеш в имя файла
filename: './bundle-[name]-[chunkhash].js',
chunkFilename: 'bundle-[name]-[chunkhash].js',
publicPath: '/assets/webpack/'
},
module: {
loaders: [
// используем плагин для выделения CSS в отдельный файл
{
test: /\.css$/,
loader: ExtractTextPlugin.extract("style-loader", "css?minimize")
},
// sourceMap пришлось оставить из-за бага
{
test: /\.scss$/,
loader: ExtractTextPlugin.extract(
"style-loader", "css?minimize!resolve-url!sass?sourceMap"
)
},
{ test: /\.(png|jpg|gif)$/, loader: 'url?limit=8192' },
{
test: /\.(ttf|eot|svg|woff(2)?)(\?.+)?$/,
loader: 'file'
},
]
},
plugins: [
// используем другое имя для манифеста, чтобы при релизе не перезаписывать
// developoment версию
new AssetsPlugin({
prettyPrint: true, filename: 'webpack-assets-deploy.json'
}),
// файл с общим js-кодом для всех точек входа
// Webpack самостоятельно его генерирует, если есть необходимость
new webpack.optimize.CommonsChunkPlugin(
'common', 'bundle-[name]-[hash].js'
),
// выделяем CSS в отдельный файл
new ExtractTextPlugin("bundle-[name]-[chunkhash].css", {
allChunks: true
}),
// оптимизация...
new webpack.optimize.DedupePlugin(),
new webpack.optimize.OccurenceOrderPlugin(),
new webpack.optimize.UglifyJsPlugin({
mangle: true,
compress: {
warnings: false
}
}),
// генерация gzip версий
new CompressionPlugin({ test: /\.js$|\.css$/ }),
// очистка перед очередной сборкой
new CleanPlugin(
path.join('public', 'assets', 'webpack'),
{ root: path.join(process.cwd()) }
)
]
};
```
Интеграция с Ruby on Rails
--------------------------
В конфигурацию приложения добавим новую опцию для включения/отключения вставки webpack статики на странице. Полезно, например, при запуске тестов, когда нет необходимости генерировать статику.
```
# config/application.rb
config.use_webpack = true
```
```
# config/environments/test.rb
config.use_webpack = false
```
Создаем инициализатор для парсинга манифеста при старте Rails-приложения
```
# config/initializers/webpack.rb
assets_manifest = Rails.root.join('webpack-assets.json')
if File.exist?(assets_manifest)
Rails.configuration.webpack = {}
manifest = JSON.parse(File.read assets_manifest).with_indifferent_access
manifest.each do |entry, assets|
assets.each do |kind, asset_path|
if asset_path =~ /(http[s]?):\/\//i
manifest[entry][kind] = asset_path
else
manifest[entry][kind] = Pathname.new(asset_path).cleanpath.to_s
end
end
end
Rails.configuration.webpack[:assets_manifest] = manifest
# я использую Sprockets генерацию статических версий страниц для серверных ошибок;
# поэтому webpack хелперы (см. ниже) нужно сделать доступными в контексте Sprockets
Rails.application.config.assets.configure do |env|
env.context_class.class_eval do
include Webpack::Helpers
end
end
else
raise "File #{assets_manifest} not found" if Rails.configuration.use_webpack
end
```
Также полезными будут webpack хелперы `webpack_bundle_js_tags` и `webpack_bundle_css_tags`, представляющие из себя обертки для `javascript_include_tag` и `stylesheet_link_tag`. Аргументом является название точки входа из конфига webpack
```
# lib/webpack/helpers.rb
module Webpack
module Helpers
COMMON_ENTRY = 'common'
def webpack_bundle_js_tags(entry)
webpack_tags :js, entry
end
def webpack_bundle_css_tags(entry)
webpack_tags :css, entry
end
def webpack_tags(kind, entry)
common_bundle = asset_tag(kind, COMMON_ENTRY)
page_bundle = asset_tag(kind, entry)
if common_bundle
common_bundle + page_bundle
else
page_bundle
end
end
def asset_tag(kind, entry)
if Rails.configuration.use_webpack
manifest = Rails.configuration.webpack[:assets_manifest]
if manifest.dig(entry, kind.to_s)
file_name = manifest[entry][kind]
case kind
when :js
javascript_include_tag file_name
when :css
stylesheet_link_tag file_name
else
throw "Unknown asset kind: #{kind}"
end
end
end
end
end
end
```
Добавим вспомогательный метод в базовый контроллер, для связи контроллера с точкой входа
```
# app/controllers/application_controller.rb
class ApplicationController < ActionController::Base
attr_accessor :webpack_entry_name
helper_method :webpack_entry_name
def self.webpack_entry_name(name)
before_action -> (c) { c.webpack_entry_name = name }
end
end
```
Теперь в контроллере можно делать так:
```
# app/controllers/main_controller.rb
class MainController < ApplicationController
webpack_entry_name 'main_page'
end
```
Использование во view:
```
<%= webpack\_bundle\_css\_tags(webpack\_entry\_name) %>
<%= webpack\_bundle\_js\_tags(webpack\_entry\_name) %>
```
Команда `npm`
=============
Теперь все frontend библиотеки должны устанавливаться так:
```
npm install --save
```
Крайне желательно "заморозить" точные версии всех пакетов в файле `npm-shrinkwrap.json` (аналог `Gemfile.lock`). Сделать это можно командой (хотя `npm` при установке/обновлении пакетов следит за актуальностью `npm-shrinkwrap.json`, лучше перестраховаться):
```
npm shrinkwrap --dev
```
Для удобства в `package.json` можно добавить в секцию `scripts` webpack-команды для быстрого запуска:
```
"scripts": {
"server": "node frontend/server.js",
"build:dev": "webpack -v --config frontend/webpack.config.js --display-chunks --debug",
"build:production": "NODE_ENV=production webpack -v --config frontend/webpack.config.js --display-chunks"
}
```
Например, запустить webpack сервер можно командой:
```
npm run server
```
Деплой: рецепт для capistrano
=============================
Я выбрал экономный вариант: не тащить весь JS-зоопарк на production сервер, а делать webpack сборку локально и загружать ее на сервер при помощи `rsync`.
Делается это командой `deploy:webpack:build`, реализация которой основана на геме [capistrano-faster-assets](https://github.com/capistrano-plugins/capistrano-faster-assets). Генерация происходит условно: если были изменения в frontend коде или были установлены/обновлены пакеты. При желании можно добавить свои условия (файлы, папки, по которым делается `diff`), установив переменную `:webpack_dependencies`. Также необходимо указать локальную папку для сгенерированной статики и файл-манифест:
```
# config/deploy.rb
set :webpack_dependencies, %w(frontend npm-shrinkwrap.json)
set :local_assets_dir, proc { File.expand_path("../../public/#{fetch(:assets_prefix)}/webpack", __FILE__) }
set :local_webpack_manifest, proc { File.expand_path("../../webpack-assets-deploy.json", __FILE__) }
```
Команда `deploy:webpack:build` запускается автоматически перед стандартной `deploy:compile_assets`.
Сам код рецепта для capistrano:
```
# lib/capistrano/tasks/webpack_build.rake
class WebpackBuildRequired < StandardError; end
namespace :deploy do
namespace :webpack do
desc "Webpack build assets"
task build: 'deploy:set_rails_env' do
on roles(:all) do
begin
latest_release = capture(:ls, '-xr', releases_path).split[1]
raise WebpackBuildRequired unless latest_release
latest_release_path = releases_path.join(latest_release)
dest_assets_path = shared_path.join('public', fetch(:assets_prefix))
fetch(:webpack_dependencies).each do |dep|
release = release_path.join(dep)
latest = latest_release_path.join(dep)
# skip if both directories/files do not exist
next if [release, latest].map{ |d| test "test -e #{d}" }.uniq == [false]
# execute raises if there is a diff
execute(:diff, '-Nqr', release, latest) rescue raise(WebpackBuildRequired)
end
info "Skipping webpack build, no diff found"
execute(
:cp,
latest_release_path.join('webpack-assets.json'),
release_path.join('webpack-assets.json')
)
rescue WebpackBuildRequired
invoke 'deploy:webpack:build_force'
end
end
end
before 'deploy:compile_assets', 'deploy:webpack:build'
task :build_force do
run_locally do
info 'Create webpack local build'
%x(RAILS_ENV=#{fetch(:rails_env)} npm run build:production)
invoke 'deploy:webpack:sync'
end
end
desc "Sync locally compiled assets with current release path"
task :sync do
on roles(:all) do
info 'Sync assets...'
upload!(
fetch(:local_webpack_manifest),
release_path.join('webpack-assets.json')
)
execute(:mkdir, '-p', shared_path.join('public', 'assets', 'webpack'))
end
roles(:all).each do |host|
run_locally do
`rsync -avzr --delete #{fetch(:local_assets_dir)} #{host.user}@#{host.hostname}:#{shared_path.join('public', 'assets')}`
end
end
end
end
end
```
Впечатления от использования в пользу webpack: модульность из коробки, четкий контроль версий библиотек и их легкое обновление, development сервер не занят обработкой статики, деплой происходит быстрее и не нагружает прекомпиляцией production сервер.
На этом все ;)
**Update!**. Если параллельно используется Sprockets (или что-то кроме webpack'a использует `public/assets`), то для генерации webpack ассетов лучше выделить отдельную директорию, например: `public/assets/webpack` (внес соответствующие правки в пост). Теперь при деплое можно запускать `rsync` с опцией `--delete`, чтобы не накапливать на продакшне неиспользуемые ассеты. Такое решение имеет недостаток: синхронизация с удалением делает невозможным откат ассетов к предыдущему релизу. Поэтому при деплое нужно делать бекап манифеста и восстанавливать по нему необходимую версию ассетов в случае отката.
**Update 2**. Оформил описанный выше процесс интеграции в виде гема <https://github.com/Darkside73/webpacked> | https://habr.com/ru/post/282584/ | null | ru | null |
# Подключаемся к СУБД CUBRID через PHP
Итак Вы, я уверен, уже знаете, как в PHP подключаться и работать с определенными реляционными системами баз данных. В этом блоге я расскажу, как начать работу в PHP с [СУБД CUBRID](http://habrahabr.ru/company/cubrid/blog/117687/ "Знакомство с CUBRID — СУБД оптимизированная для Веб приложений"), в чем ее отличие от других систем, а также приведу примеры для быстрого начала. Хорошая новость заключается в том, что последняя версия [CUBRID 8.4.0](http://habrahabr.ru/company/cubrid/blog/119342/ "Новый CUBRID 8.4.0: теперь вдвое быстрее") на 90% совместима с MySQL и с точки зрения SQL синтаксиса, и с точки зрения функций PHP.
Сразу оговорюсь, что речь будет идти о PHP версии 5.2 и выше, ибо это минимальное требование для работы с СУБД CUBRID в PHP.
#### Установка
Установка PHP драйвера для CUBRID типична. В ОС Windows Вы можете использовать автоматический исталлятор, либо можете вручную прописать все необходимое в конфигурационном файле *php.ini*. В ОС Linux инструкции почти такие же: можно использовать инсталлятор PECL, либо самому изменить php.ini.
##### Установка PHP Драйвера с помощью Установщика Windows
1. Скачайте последнюю версию **CUBRID PHP API Installer** с [оффициального сайта](http://www.cubrid.org/php_install_wizard) (< 870КБ). В этом установшике есть все версии PHP драйвера на всевозможные комбинации PHP и CUBRID.
2. Убедитесь, что сам движок PHP и СУБД CUBRID установлены.
3. Запустите установшик.
4. Все как в типичном Windows исталляторе:
* укажите путь для установки;
* подтвердите имя папки для главного меню *Старт*;
* нажмите на "**Установить**".
Готово! Не забудьте перезапустить свой Веб сервер. В результате этой установки, инсталлятор автоматически определит версию Вашего PHP движка, версию СУБД CUBRID, а также папку, в котором по-умолчанию PHP хранит свои драйвера (обычно это *C:\Program Files\PHP\ext*). Исходя из этого, установщик скопирует необходимый **php\_cubrid.dll** в эту папку со всеми остальными драйверами. Затем он добавит следующие две строчки в конфигурационный файл php.ini.
`[PHP_CUBRID]
extension=php_cubrid.dll`
Все стандартно, но все происходит автоматически без Вашего участия. Этот же способ, но уже на английском и со скриншотами можете посмотреть [здесь](http://www.cubrid.org/php_install_wizard "CUBRID PHP API Installer").
##### Ручная конфигурация php.ini в ОС Windows
То же самое, что делает CUBRID PHP API Installer, Вы можете сделать сами.
1. Скачайте необходимый для Вас драйвер с [оффициального сайта](http://www.cubrid.org/php_api_for_cubrid#for-windows) (< 40КБ). Доступны как и thread-safe, так и non-thread-safe версии для Apache и IIS.
2. Распакуйте архив.
3. Скопируйте **php\_cubrid.dll** в папку, где лежат Ваши остальные PHP драйвера.
4. Откройте конфигурационный файл **php.ini** и вставьте в конце файла вышеуказанные две строчки.
5. Сохраните измененния и перезапустите свой Веб сервер.
Все готово!
##### Установка PHP Драйвера в ОС Linux с помощью Исталлятора PECL
Здесь мы покажем как установить CUBRID PHP драйвер в ОС Linux, основанных на DEBIAN. Для RPM основанных Linux смотрите инструкцию ниже.
1. Устанавливаем phpize
`sudo apt-get install php5-dev`
2. Устанавливаем пакет PEAR, который предоставляет команды PECL
`sudo apt-get install php-pear`
3. Теперь устанавливаем сам CUBRID PHP драйвер с помощью команды PECL.
`sudo pecl install cubrid`
Это установит последнюю версию драйвера **cubrid.so**. Если Вам нужен один из предыдущих версий, то укажите версию при установке так:
`sudo pecl install cubrid-8.3.0.0005`
Если в этот момент отобразится запрос **"CUBRID base install dir [autodetect] :"**, введите полный путь директории, в который установлен CUBRID. Например, если CUBRID установлен в */home/cubridtest/CUBRID*, введите */home/cubridtest/CUBRID*.
4. В конце Вам необходимо изменить конфигурационный файл php.ini, добавив следующие две строчки в конце файла.
`[CUBRID]
extension=cubrid.so`
Установка CUBRID PHP драйвера в ОС Linux, основанных на RPM.
1. Устанавливаем phpize
`yum install php-devel`
2. Скачиваем пакет PEAR
`wget pear.php.net/go-pear.phar`
3. Запускаем пакет PEAR в PHP
`php go-pear.phar`
4. Теперь устанавливаем сам CUBRID PHP драйвер с помощью команды PECL.
`pecl install cubrid`
Это установит последнюю версию драйвера **cubrid.so**. Если Вам нужен один из предыдущих версий, то укажите версию при установке так:
`pecl install cubrid-8.3.0.0005`
Если в этот момент отобразится запрос **"CUBRID base install dir [autodetect] :"**, введите полный путь директории, в который установлен CUBRID. Например, если CUBRID установлен в */home/cubridtest/CUBRID*, введите */home/cubridtest/CUBRID*.
5. В конце Вам необходимо изменить конфигурационный файл php.ini, добавив следующие две строчки в конце файла.
`[CUBRID]
extension=cubrid.so`
Готово! Не забудьте перезапустить Веб сервер.
##### Ручная конфигурация php.ini в ОС Linux
Установить CUBRID PHP драйвер можно и без phpize и PEAR — вручную. Смотрим инструкции ниже.
1. Скачайте необходимый для Вас драйвер с [оффициального сайта](http://www.cubrid.org/php_api_for_cubrid#for-linux) (< 80КБ). Доступны версии как и для x64, так и для x86.
2. Распакуйте архив.
3. Скопируйте **cubrid.so** в директорию, где лежат Ваши остальные PHP драйвера (обычно это */usr/lib/php5/20090626* для PHP 5.3.3, где *20090626* название директории, которая может изменяться в зависимости от версии PHP).
4. Откройте конфигурационный файл **php.ini** (обычно находится в */etc/php5/apache2/php.ini*) и вставьте в конце файла следующие две строчки.
`[CUBRID]
extension=cubrid.so`
5. Сохраните измененния и перезапустите свой Веб сервер.
Готово! Если возникнут проблемы при установки драйвера, напишите в комментариях.
#### Работа с драйвером CUBRID PHP
Как Вы, должно быть, знаете, подключение и работа с базами Oracle и PostgreSQL похожи в каком-то роде. Работая с ними, Вы напрямую подключаетесь к определенной базе, нежели к хосту или серверу в целом, как Вы обычно делаете в MySQL и MSSQL. В случае MySQL и MSSQL вы создаете соединение с хостом, затем второй шаг — выбираете базу, к которой Вам необходимо подсоединиться.
Работа с СУБД CUBRID в этом смысле похожа на Oracle и PostgreSQL. Вы напрямую подключаетесь к базе данных, с которым Вы хотите работать. Поэтому в CUBRID PHP, как и в Oracle и PostgreSQL, нет функций, которые позволяют создавать, удалять или выбирать базы данных, за исключением тех функций, которые выдают информацию о рабочей базе. Вот в этом они отличаются от библиотек MySQL и MSSQL.
##### Синтаксис
`resource cubrid_connect(string $host, int $port, string $dbname [, string $userid [, string $passwd ]] )`
##### Пример
`$host_ip = "localhost";
$host_port = 33000;
$db_name = "demodb";
$conn = cubrid_connect($host_ip, $host_port, $db_name)
or die("Could not connect: " . cubrid_error());
print ("Connected successfully");
cubrid_close($conn);`
По-умолчанию параметр **auto\_commit** при подключении отключен, т.е. во всех следующих транзакциях Вы должны сами подтверждать транзакцию. Например:
`cubrid_commit($conn);`
Такая реализация очень удобна, если Вы хотите программно контролировать дальнейшие действия при ошибках в транзакциях (т.е. выдавать какие-то определенные сообщения и т.п.). Если предпочтете фиксировать все транзакции, можете включить **auto\_commit** либо сразу при подключении, либо уже во время работы. В первом случае подсоединяйтесь через [cubrid\_connect\_with\_url](http://www.php.net/manual/en/function.cubrid-connect-with-url.php).
`$conn_url = "cci:CUBRID:127.0.0.1:33088:demodb:dba:123456:?autocommit=off"
$conn = cubrid_connect_with_url($conn_url);`
Таким образом, все запросы будут фиксироваться автоматически. Во втором случае вызывайте функцию [cubrid\_set\_autocommit](http://www.php.net/manual/en/function.cubrid-set-autocommit.php) в необходимый момент, например:
`if (cubrid_set_autocommit($conn, true)){
echo "Теперь все автоматом коммитится";
}`
Точно также можно отключить *auto\_commit*. Чтобы узнать статус auto\_commit во время работы, Вы можете вызвать [cubrid\_get\_autocommit](http://www.php.net/manual/en/function.cubrid-get-autocommit.php).
Все остальные запросы в CUBRID очень похожи на синтаксис MySQL.
```
// Синтаксис запросов одинаков
$sql = "select sports, count(players) as players from event group by sports";
// Замените просто на просто приставку "mysql_" на "cubrid_"
$result = cubrid_query($conn, $sql);
if ($result){
// количество столбцов в запросе
$num_fields = cubrid_num_fields($result);
echo("|");
// имена столбцов в запросе по синтаксису MySQL
for ($i = 0; $i < $num\_fields; ++$i){
echo(" ");
echo(cubrid\_field\_name($result, $i));
echo(" |");
}
echo("
");
// то же самое можно сделать в стиле CUBRID, но только одним запросов
$columns = cubrid_column_names($result);
echo("|");
while (list($key, $colname) = each($columns)){
echo(" $colname |");
}
echo("
");
// Получаем численный и ассоциативный массив
while ($row = cubrid_fetch_array($result)){
// также можно использовать cubrid_fetch_assoc, cubrid_fetch_field,
// cubrid_fetch_lengths, cubrid_fetch_row и cubrid_fetch_object
// Все как в MySQL
echo("|");
for ($i = 0; $i < $num\_fields; ++$i){
echo(" ");
echo($row[$i]);
echo(" |");
}
echo("
");
}
}
cubrid_close($conn);
```
Для ввода нового или обновления старого значения, можно использовать те же функции, что и в MySQL, но уже с приставкой «cubrid\_».
```
$sql = "insert into olympic (host_year,host_nation,host_city,"
. "opening_date,closing_date) values (2008, 'China', 'Beijing',"
. "to_date('08-08-2008','mm-dd-yyyy'),to_date('08-24-2008','mm-dd-yyyy')) ;"
$result = cubrid_query($cubrid_con, $sql);
if ($result){
// Если auto_commit не включен по-умолчанию, то подтвердаем транзакцию
if (!cubrid_get_autocommit($cubrid_con)){
cubrid_commit($cubrid_con);
}
echo("Inserted successfully ");
}
else{
echo(cubrid_error());
cubrid_rollback($cubrid_con);
}
cubrid_disconnect($cubrid_con);
```
Чтобы получить **ID**, сгенерированного при последнем INSERT-запросе, учитывая, что в таблице есть столбец с AUTO\_INCREMENT ограничением, можно вызвать функцию [cubrid\_insert\_id](http://www.php.net/manual/en/function.cubrid-insert-id.php). Отличается эта функция от *mysql\_insert\_id* лишь тем, что в CUBRID функция возвращает строку, в то время как MySQL — число int. Удобство строки заключается в том, что эта функция может возвращать ID типа BIGINT, в то время как функцию MySQL нельзя использовать для больших чисел. Если в таблице нет AUTO\_INCREMENT столбцов, cubrid\_insert\_id возвратит 0.
После ввода новых значений или обновления уже имеющихся, как и в MySQL, можно вызвать [cubrid\_affected\_rows](http://www.php.net/manual/en/function.cubrid-affected-rows.php), чтобы узнать сколько строк были изменены в результате, указанного в качестве параметра. Если ресурс результата не указан, то будет подразумеваться результат последнего запроса.
`$affected_num = cubrid_affected_rows();
echo "Всего изменений: " . $affected_num;`
Полный список всех CUBRID PHP функций, сопоставленных с соответствующими функциями MySQL PHP, Вы можете посмотреть [здесь](http://www.cubrid.org/cubrid_mysql_php_function_comparison), где Вы заметите, что почти все функции идентичны с учетом замены префикса **mysql\_** на **cubrid\_**.
##### Постоянные соединения
В библиотеке CUBRID PHP постоянные соединения не реализованы по единственной причине того, что CUBRID сам поддерживает постоянные соединения. Т.е. Вы может задать в конфигурациях CUBRID Broker значение параметра [CCI\_PCONNECT](http://www.cubrid.org/manual/831/en/Parameter%20by%20Broker) [ссылка в мануал] как **ON** и перезапустить брокер, после чего все соединения между клиентским приложением и базой CUBRID буду постоянными, даже если Вы закроете их с помощью *cubrid\_close*.
Пул постоянных соединений может содержать максимум 256 соединений. Все остальные соединения будут открываться, как обычные, пока какой-либо из постоянных соединений не освободится. Также можно задать **KEEP\_CONNECTION**.
`[%BROKER1]
SERVICE = ON
BROKER_PORT = 33000
...
KEEP_CONNECTION = ON
CCI_PCONNECT = ON
STATEMENT_POOLING = ON`
##### Подготовленные запросы
В библиотеке CUBRID PHP также можно задавать подготовленные запросы (prepared statements). Они могут включать как и "?", так и именные заполнители. Например:
Применение ? в качестве заполнителя
`// ? в качестве заполнителя
$sql = "SELECT * FROM game WHERE host_year = ?;
$req = cubrid_prepare($conn, $sql);
// порядковое связывание значений, начиная с 1
cubrid_bind($req, 1, 2004);
cubrid_execute($req);`
Применение именного заполнителя
`// именной заполнитель
$sql2 = "SELECT * FROM game WHERE host_year = :host_year";
$req = cubrid_prepare($conn, $sql);
// также именное присвоение
cubrid_bind($req, ':host_year', 2004);
cubrid_execute($req);`
Все довольно просто. В конфигурациях CUBRID Broker есть еще один параметр **STATEMENT\_POOLING**, который отвечает за пулинг подготовленных запросов. Если включить этот параметр (ON, OFF, по-умолчанию **ON**), то все подготовленные запросы будут сохранятся в специальном пуле, что позволяет их переиспользовать. Если отключить, то подготовленные запросы будут закрываться сразу после завершения транзакций.
Итак, как Вы заметили, практически все, что работает с MySQL, будет работать и с CUBRID. А если у Вас что-то не сработает «из под коробки», пишите в комментариях. Разберемся. А может даже, благодаря Вам, в CUBRID PHP API будет что-то еще новенькое. | https://habr.com/ru/post/119514/ | null | ru | null |
# Type assertation without allocations
Всем привет. В дополнении к моей [предыдущей](https://habrahabr.ru/post/315566/) статье был интересный диалог с
[kirill\_danshin](https://habrahabr.ru/users/kirill_danshin/). В конце концов мы это сделали. Встречайте — [efaceconv](https://github.com/t0pep0/efaceconv), тулза для go generate, с помощью которой можно приводить типы из interface{} без аллокаций и в ~4 раза быстрее.
#### Как с этим работать?
Всё просто:
1. Устанавливаете: go get github.com/t0pep0/efaceconv
2. Добавляете в Ваши исходники вызов go generate //go:generate efaceconv
3. Описывайте типы, конвертация которых необходим (об этом ниже)
4. Запускаете go generate и наслаждаетесь (З.Ы. в качестве бонуса — тесты с 100% покрытием на сгенерированный код)
#### Как описать типы
Опять таки всё просто. Типы описываются в комментариях. Формат описания вот такой:
```
//ec:Имя пакета(Если нужно):Тип:Кастомное имя
```
Пример:
```
//ec:net/http:http.ResponseWriter:ResWriter
//ec::string:String
```
После того, как go generate отработает в директории пакета появится 2 новых файла:
efaceconv\_generated.go — сгенерированные методы
efaceconv\_generated\_test.go — тесты и бенчмарки для них
Пример demo.go:
```
//go:generate efaceconv
//ec::string:String
//ec::[]uint64:SUint64
package demo
```
efaceconv\_generated.go:
```
//generated by efaceconv DO NOT EDIT!
package demo
import (
"github.com/t0pep0/efaceconv/ecutils"
)
var (
_StringKind uintptr
_SUint64Kind uintptr
)
func init(){
var sString string
_StringKind = ecutils.GetKind(sString)
var sSUint64 []uint64
_SUint64Kind = ecutils.GetKind(sSUint64)
}
// Eface2String returns pointer to string and true if arg is a string
// or nil and false otherwise
func Eface2String(arg interface{}) (*string, bool) {
if ecutils.GetKind(arg) == _StringKind {
return (*string)(ecutils.GetDataPtr(arg)), true
}
return nil, false
}
// Eface2SUint64 returns pointer to []uint64 and true if arg is a string
// or nil and false otherwise
func Eface2SUint64(arg interface{}) (*[]uint64, bool) {
if ecutils.GetKind(arg) == _SUint64Kind {
return (*[]uint64)(ecutils.GetDataPtr(arg)), true
}
return nil, false
}
```
efaceconv\_generated\_test.go:
```
//generated by efaceconv DO NOT EDIT!
package demo
import (
"reflect"
"testing"
)
func TestEface2String(t *testing.T) {
var String string
res, ok := Eface2String(String)
if !ok {
t.Error("Wrong type!")
}
if !reflect.DeepEqual(*res, String) {
t.Error("Not equal")
}
_, ok = Eface2String(ok)
if ok {
t.Error("Wrong type!")
}
}
func benchmarkEface2String(b *testing.B) {
var String string
var v *string
var ok bool
for n := 0; n < b.N; n++ {
v, ok = Eface2String(String)
}
b.Log(v, ok) //For don't use compiler optimization
}
func _StringClassic(arg interface{}) (v string, ok bool) {
v, ok = arg.(string)
return v, ok
}
func benchmarkStringClassic(b *testing.B) {
var String string
var v string
var ok bool
for n := 0; n < b.N; n++ {
v, ok = _StringClassic(String)
}
b.Log(v, ok) //For don't use compiler optimization
}
func TestEface2SUint64(t *testing.T) {
var SUint64 []uint64
res, ok := Eface2SUint64(SUint64)
if !ok {
t.Error("Wrong type!")
}
if !reflect.DeepEqual(*res, SUint64) {
t.Error("Not equal")
}
_, ok = Eface2SUint64(ok)
if ok {
t.Error("Wrong type!")
}
}
func benchmarkEface2SUint64(b *testing.B) {
var SUint64 []uint64
var v *[]uint64
var ok bool
for n := 0; n < b.N; n++ {
v, ok = Eface2SUint64(SUint64)
}
b.Log(v, ok) //For don't use compiler optimization
}
func _SUint64Classic(arg interface{}) (v []uint64, ok bool) {
v, ok = arg.([]uint64)
return v, ok
}
func benchmarkSUint64Classic(b *testing.B) {
var SUint64 []uint64
var v []uint64
var ok bool
for n := 0; n < b.N; n++ {
v, ok = _SUint64Classic(SUint64)
}
b.Log(v, ok) //For don't use compiler optimization
}
```
Как можно увидеть efaceconv генерирует методы вида
```
Eface2<Наше кастомное имя>(arg interface{}) (*<Наш тип>, bool)
```
Вместе с документацией к ним, тестами и бенчмарками, также бенчмарки генерируются и для классического типа приведения ( v, ok := arg.(type) ) что бы была возможность сравнить выигрыш в производительности.
#### Как это работает
Как мы знаем (из моей [предыдущей](https://habrahabr.ru/post/315260/) статьи) пустые интерфейсы это просто структура с двумя полями — \*TypeDescriptor и указатель на объект. TypeDescriptor генерируется в runtime, в единичном экземпляре для каждого типа, соответственно для всех пустых интерфейсов от одного типа \*TypeDescriptor будет равен и нет необходимости разбирать сам TypeDescriptor. Мы можем просто сравнивать числовое значение указателя, а уже при совпадении их можем вернуть указатель на объект будучи уверенными что он имеет нужный нам тип.
#### Почему это быстрее чем стандартный метод?
Стандартный метод приведения типа после сравнения TypeDescriptor'ов копирует данные по значению, мы же просто отдаем указатель на исходный объект
#### Тогда почему так не сделали авторы Go?
Это не безопасно. Точнее не так, это безопасно ровно до тех пор, пока вы используете иммутабельные типы данных (строки, слайсы, массивы). В случае использования не иммутабельных типов данных, при не аккуратном написании кода, возможны сайд эффекты.
#### Где-то уже используется?
[kirill\_danshin](https://habrahabr.ru/users/kirill_danshin/) внедрил первую версию у себя в продакшене, о результатах достоверно не знаю, но судя по [коммитам](https://github.com/t0pep0/efaceconv/commits/master?author=kirillDanshin) он доволен
#### А где цифры? Про производительность и аллокации
```
BenchmarkEface2SByte-4 100000000 11.8 ns/op 0 B/op 0 allocs/op
--- BENCH: BenchmarkEface2SByte-4
efaceconv_generated_test.go:33: &[] true
efaceconv_generated_test.go:33: &[] true
efaceconv_generated_test.go:33: &[] true
efaceconv_generated_test.go:33: &[] true
efaceconv_generated_test.go:33: &[] true
BenchmarkSByteClassic-4 30000000 50.4 ns/op 32 B/op 1 allocs/op
--- BENCH: BenchmarkSByteClassic-4
efaceconv_generated_test.go:48: [] true
efaceconv_generated_test.go:48: [] true
efaceconv_generated_test.go:48: [] true
efaceconv_generated_test.go:48: [] true
efaceconv_generated_test.go:48: [] true
BenchmarkEface2String-4 100000000 11.1 ns/op 0 B/op 0 allocs/op
--- BENCH: BenchmarkEface2String-4
efaceconv_generated_test.go:76: 0xc42003fee8 true
efaceconv_generated_test.go:76: 0xc420043ea8 true
efaceconv_generated_test.go:76: 0xc420043ea8 true
efaceconv_generated_test.go:76: 0xc420043ea8 true
efaceconv_generated_test.go:76: 0xc420043ea8 true
BenchmarkStringClassic-4 30000000 45.3 ns/op 16 B/op 1 allocs/op
--- BENCH: BenchmarkStringClassic-4
efaceconv_generated_test.go:91: true
efaceconv_generated_test.go:91: true
efaceconv_generated_test.go:91: true
efaceconv_generated_test.go:91: true
efaceconv_generated_test.go:91: true
BenchmarkEface2SInt-4 100000000 11.6 ns/op 0 B/op 0 allocs/op
--- BENCH: BenchmarkEface2SInt-4
efaceconv_generated_test.go:119: &[] true
efaceconv_generated_test.go:119: &[] true
efaceconv_generated_test.go:119: &[] true
efaceconv_generated_test.go:119: &[] true
efaceconv_generated_test.go:119: &[] true
BenchmarkSIntClassic-4 30000000 50.5 ns/op 32 B/op 1 allocs/op
--- BENCH: BenchmarkSIntClassic-4
efaceconv_generated_test.go:134: [] true
efaceconv_generated_test.go:134: [] true
efaceconv_generated_test.go:134: [] true
efaceconv_generated_test.go:134: [] true
efaceconv_generated_test.go:134: [] true
PASS
```
#### Злодеи! Я сделал всё как написано для мутабельного типа и у меня появилось странное поведение в коде!
ССЗБ
**UPD:** [Про возможные проблемы, если не подумать](https://gist.github.com/t0pep0/a14f56c8fde80a3b5e351c44c3584238). | https://habr.com/ru/post/315752/ | null | ru | null |
# Игрища с сервером jabber.ru
Среди активных ~~и пассивных~~ пользователей Линукс принято осуждать использование любых мессенджеров, кроме джаббера. Однако, мало кто знает, что сервер jabber.ru скрывает в себе множесто «веселых игр» вроде чтения приватной переписки в конференциях. Самые увлекательные развлечения, которые удалось отыскать описаны в этой статье.
### Игра первая: найди всех своих друзей
В отличие от нормальных серверов, тут все сделано для людей и их удобства. Например, простой, непривилигированный пользователь может выполнить такой запрос:
```
```
В ответе вам придет полный список зарегистрированных членов конференции. Вашей или не вашей. Приватность не нужна.
Да, это администраторский запрос, который сделан для редактирования списков пользователей. Но администрация jabber.ru крайне заботливо относится к своим клиентам и позволяет им найти всех своих друзей, даже если у вас нет администраторских полномочий.
Если вы не разбираетесь в программировании, то представляем вашему вниманию [gist.github.com/7316aec410cbecd4d97a.git](https://gist.github.com/7316aec410cbecd4d97a.git), простое и понятное консольное приложение, которое можно рассматривать как фронтенд к игровым сервисам, это приложение сделает вашу игру по-настоящему захватывающей, но одновременно с этим и простой. Найди всех своих друзей и врагов, докажи, что они в интернете не правы!
Позвольте, но ведь это всего-то список jid, разве можно выразить свою любовь через компьютерный интерфейс?
Да! Теперь это возможно!
Например, свою дружбу можно доказать, отправив около 500 запросов на дружбу через запрос авторизации. Современные xmpp-клиенты будут настолько рады, что зачастую будут вылетать от обилия счастья!
А вот и готовый инструментарий, все опенсорсно и свободно: [github.com/Kagami/kisa](https://github.com/Kagami/kisa)
Пусть ваша дружба будет вечной!
### Игра вторая: хочу все знать
Пожалуй, самой уникальной функцией jabber.ru является… чтение чужой лички! Вы не только сможете читать чужие сообщения, но и даже подменять их!
Как это работает:
В настройках конференции вы можете указать сервис (jid) для фильтрации сообщений, как правило, это какой-то бот, который должен быть в конференции. Само собой, если у вас нет такого бота, то вы запросто можете арендовать его в большом количестве конференций, ведь все сделано для людей. Ну или написать самому.
Боту не нужны админские права, бот просто должен присутствовать в конференции, пусть даже в статусе посетителя. Единственное, что ему нужно — это отвечать на специально сформированные IQ-запросы, разработанные на jabber.ru, что является настоящим эксклюзивом данного сервиса. Попробуйте — и вы не пожалеете! Вы уже хотите?
Официальная инструкция в бложике jabber.ru: [jabber-ru.ya.ru/replies.xml?item\_no=4659](http://jabber-ru.ya.ru/replies.xml?item_no=4659)
> У нас на jabber.ru, а точнее, на сервисе conference.jabber.ru появилась экспериментальная дырка, позволяющая фильтровать трафик конференции внешними сервисами, в народном обиходе называемыми ботами. Владельцы конференций смогут самостоятельно обеспечивать защиту своих территорий от употребления нецензурных слов, слишком длинных мессаг и прочего бессмысленного хлама!
>
> В конфиге конференции теперь есть опция, позволяющая указать jid бота, который будет через себя пропускать трафик, попадающий в конференцию. Станзы этого трафика выглядят как
>
> id='1' type='set' to='jid@bot'>
>
>
>
>
>
> В ответ бот должен прислать эту же станзу с type=result; В теле мессаги бот может производить различные операции над телом сообщения, которые сочтет необходимыми — например, замена мата на звездочки, заменить все сообщение на ссылку в пастбине или вообще заменить на ошибку пользователю.
>
> Разработчики ботов могут заглянуть в конференцию devel@conference.jabber.ru и обсудить это дело там.
>
>
>
> Удачи в борьбе с малолетками.
>
>
Конечно, если вы администратор конференции, то вы наверняка об этом знали и раньше и могли подсматривать в переписку, а что делать простым посетителям, у кого нет администраторских полномочий, а почитать чужую переписку ужас как охота?
### Игра третья: админ на час
Сервис jabber.ru постоянно борется за звание жаббера высокой культуры быта. И в погоне за высокой культурой останавливаться на только автоматических системах нельзя. Роботы не могут оценить сути происходящего, только настоящий живой человек сможет разобраться.
Сразу предупреждаю, что если у вас маленькая конференция, до 5 человек, то эта игра не для вас. Эта игра для топовых конференций: [jc.jabber.ru](http://jc.jabber.ru/)
Если вы в топе, то вас ожидает бесплатный сервис технической поддержки и расширенного обслуживания. Совершенно бесплатно к вам в конференцию зайдет высококвалифицированный специалист и поможет вам управлять вашим же сообществом. Он не только забанит ваших ботов, назначит новых администраторов, обеспечит доступ третьих лиц к приватной информации, но и поддержит беседу на высоком интеллектуальном уровне. Пример:
```
(22:09:49) karp: А вообщето пох[цензурировано]…
(22:55:30) karp: овнера?
(22:55:42) karp: ща
(22:55:54) karp: с норм клиента зайду
(23:00:11) karp: of
(23:00:13) karp: ща
(23:00:26) karp: [цензурировано]
(23:01:08) karp: zdrfv: все предложения на http://code.ustyugov.net...
(23:06:15) karp: да
(23:07:38) karp: крутой_пулемёт: круто?
(23:09:18) karp: крутой_пулемёт: нет, говорю
(23:09:46) karp: =)
(23:10:33) karp: крутой_пулемёт: бро, я же не могу настолько оху[цензурировано]...
(23:11:21) karp: zdrfv: нет. И мне пох[цензурировано]
(23:50:51) karp: Наташечка: так
(23:52:28) karp: Наташечка: речь не о том была, но пох[цензурировано]…
(23:55:12) karp: Он сейчас в админах?
(23:55:29) karp: нет. [цензурировано]ле истерить?
(23:56:20) karp: [цензурировано]уя он не делал за две минуты…
(23:56:51) karp: ггг
(23:57:07) karp: Да мне же по[цензурировано]
(23:57:32) karp: за вообще конфу закрою =)
(23:58:22) karp: Му[цензурировано], бл[цензурировано]
(23:58:57) karp: И [цензурировано]е?
(23:59:19) karp: [цензурировано]утая дура…
(23:59:25) karp: Ушол
```
Впрочем, если вы хотите воспользоваться этой услугой вне очереди, то напишите на igor@ustyugov.net и вам всегда придут на помощь! А если вас где-то обидели, несправедливо (по вашему мнению) забанили, то тут вас не только разбанят, но и дадут вам администраторские полномочия, и вы с легкостью сможете отвести душу.
### Игра четвертая: учим арабский
Это очень старая игра, которая со временем потеряла свой захватывающий геймплей, но не потеряла актуальности. Ранее, если в конференцию на jabber.ru написать что-то на арабском языке, то следовал немедленный кик. Так как администраторы плохо знали диапазоны юникода, то кик можно было огрести и за некоторые символы, которые не имеют к арабскому языку никакого отношения. Например, символы юникода, копируемые из комментариев сервиса YouTube.
Ранее игра была крайне захватывающей: можно было взять себе арабское имя и зайти в любую конференцию. Лучше всего работало в конференциях с ботами, где просто было достаточно написать ping и бОльшая часть конференции отваливалась. Было очень красиво и эффектно.
Со временем, геймплей изменился. Кик был удален, а текст сообщения заменялся на «I'm arabian pig». Данное признание можно было встретить от многих уважаемых участников совершенно разных конференций. К сожалению, новый геймплей не оценили и продержался он не очень долго, так как администрации грозили судами. Так как это уже не шутки, то вскоре сообщения начали заменяться на "\*\*\*", можете попробовать сами.
Но даже сейчас очень весело заходить в различные конференции с арабским ником и активно участвовать в дискуссиях. Попробуйте сами!
### Игра пятая: бонус
Зайти в support@conference.jabber.ru, сообщить о багах, о недоступности сервиса, задать технические вопросы и не получить бан. Конечно, разговаривать надо с официальными представителями, а не рядовыми пользователями.
Были и другие игры, которые могли бы скоротать ваш досуг. Например, кривой шейпер, который фактически блокировал работу конференции в случае, если один из участников оной отправлял длинную станзу. Были даже люди, которые сначала блокировали конфу, а потом просили выкуп за возвращение доступа. Впрочем, сообщения и сейчас очень часто не отправляются по причине limit rate, даже когда они исходят от легитимных пользователей и написаны живым человеком.
Генеральный спонсор игр: [zinid](https://habrahabr.ru/users/zinid/). | https://habr.com/ru/post/230735/ | null | ru | null |
# История борьбы за IOPS в самосборной SAN
Всем привет!
В одном из моих проектов используется нечто, немного похожее на частное облако. Это несколько серверов для хранения данных и несколько — бездисковых, отвечающих за виртуализацию. На днях я похоже что наконец поставил точку в вопросе выжимания максимальной производительности дисковой подсистемы данного решения. Это было довольно интересно и даже в некоторые моменты — довольно неожиданно. Поэтому и хочу поделиться своей историей с хабрасообществом, которая началась в далёком 2008м году, ещё до появления «Первого облачного провайдера России» и акции по рассылке бесплатных счётчиков воды.
##### Архитектура
Экспорт виртуальных жёстких дисков осуществляется через отдельную гигабитную сеть по протоколу [AoE](http://en.wikipedia.org/wiki/ATA_over_Ethernet). Если коротко — это детище компании Coraid, которая предложила реализовать передачу ATA-команд по сети, напрямую. Спецификация протокола занимает всего десяток страниц! Главная особенность — это отсутствие TCP/IP. При передаче данных получается минимальный оверхед, но как плата за простоту — невозможность роутинга.
Почему именно такой выбор? Если опустить перепечатывание официальных источников — в т.ч. и банальный lowcost.
Соответственно, в хранилищах мы использовали обычные SATA-диски с 7200 rpm. Их недостаток известен всем — низкий IOPS.
##### RAID10
Самый первый, популярный и очевидный способ решения проблемы скорости случайного доступа. Взяли mdadm в руки, вбили в консоль пару соответствующих команд, поверх подняли LVM (мы же в итоге собираемся раздавать блочные устройства для виртуальных машин) и запустили несколько наивных тестов.
```
root@storage:~# hdparm -tT /dev/md127
/dev/md127:
Timing cached reads: 9636 MB in 2.00 seconds = 4820.51 MB/sec
Timing buffered disk reads: 1544 MB in 3.03 seconds = 509.52 MB/sec
```
Если честно, проверять IOPS было страшно, вариантов решения проблемы кроме перехода на SCSI или написания собственных костылей всё-равно не было.
##### Сеть и MTU
Хотя сеть была и гигабитная, с бездисковых серверов скорость чтения немножко не дотягивала до ожидаемых ~100MiB/sec. Естественно, виноватыми оказались драйвера сетевых карт (привет, Debian). Использование свежих драйверов с сайта производителя проблему вроде бы частично устранила…
Во всех мануалах по оптимизации скорости AoE первым пунктом указывается выставление максимального MTU. В тот момент это было 4200. Сейчас это кажется смешным, но по сравнению со стандартными 1500, скорость линейного чтения действительно достигла ~120MiB/sec, круто! И даже при небольшо нагрузке на дисковую подсистему всеми виртуальными серверами, локальные кеши выправляли ситуацию и внутри каждой виртуалки скорость линейного чтения держалась на уровне не менее 50MiB/sec. На самом деле, довольно неплохо! Со временем, мы сменили сетевые карты, свитч — и подняли MTU до максимальных 9К.
##### Пока не пришёл MySQL
Да, какой-то из проектов 24/7 дёргал MySQL, причём и на запись, и на чтение. Выглядело это как-то так:
```
Total DISK READ: 506.61 K/s | Total DISK WRITE: 0.00 B/s
TID PRIO USER DISK READ DISK WRITE SWAPIN IO> COMMAND
30312 be/4 mysql 247.41 K/s 11.78 K/s 0.00 % 11.10 % mysqld
30308 be/4 mysql 113.89 K/s 19.64 K/s 0.00 % 7.30 % mysqld
30306 be/4 mysql 23.56 K/s 23.56 K/s 0.00 % 5.36 % mysqld
30420 be/4 mysql 62.83 K/s 11.78 K/s 0.00 % 5.03 % mysqld
30322 be/4 mysql 23.56 K/s 23.56 K/s 0.00 % 2.58 % mysqld
30445 be/4 mysql 19.64 K/s 19.64 K/s 0.00 % 1.75 % mysqld
30183 be/4 mysql 7.85 K/s 7.85 K/s 0.00 % 1.15 % mysqld
30417 be/4 mysql 7.85 K/s 3.93 K/s 0.00 % 0.36 % mysqld
```
Безобидно? Как бы не так. Огромный поток мелких запросов, 70% io wait на виртуальном сервере, 20%-я нагрузка на каждый из жёстких дисков (если верить atop) на хранилище и настолько унылая картина на остальных виртуалках:
```
root@mail:~# hdparm -tT /dev/xvda
/dev/xvda:
Timing cached reads: 10436 MB in 1.99 seconds = 5239.07 MB/sec
Timing buffered disk reads: 46 MB in 3.07 seconds = 14.99 MB/sec
```
И это ещё быстро! Зачастую скорость линейного чтения была не более 1-2 MiB/sec.
Думаю все уже догадались, на что мы напоролись. Низкие IOPS SATA-дисков, даже несмотря на RAID10.
##### Flashcache
Как же вовремя появились эти ребята! Это спасение, это то самое! Жизнь налаживается, мы будем спасены!
Срочная закупка SSD от Intel, включение модуля и утилит flashcache в live-образ серверов СХД, настройка write-back кеша и огонь в глазах. Ага, все счётчики по нулям. Ну, особенности LVM + Flashcache легко гуглятся, проблема быстро решилась.
На виртуальном сервере с MySQL loadavg упал с 20 до 10. Линейное чтение на остальных виртуалках возросло до стабильных 15-20 MiB/sec. Не обманули!
Спустя некоторое время я собрал такую статистику:
```
root@storage:~# dmsetup status cachedev
0 2930294784 flashcache stats:
reads(85485411), writes(379006540)
read hits(12699803), read hit percent(14)
write hits(11805678) write hit percent(3)
dirty write hits(4984319) dirty write hit percent(1)
replacement(144261), write replacement(111410)
write invalidates(2928039), read invalidates(8099007)
pending enqueues(2688311), pending inval(1374832)
metadata dirties(11227058), metadata cleans(11238715)
metadata batch(3317915) metadata ssd writes(19147858)
cleanings(11238715) fallow cleanings(6258765)
no room(27) front merge(1919923) back merge(1058070)
disk reads(72786438), disk writes(374046436) ssd reads(23938518) ssd writes(42752696)
uncached reads(65392976), uncached writes(362807723), uncached IO requeue(13388)
uncached sequential reads(0), uncached sequential writes(0)
pid_adds(0), pid_dels(0), pid_drops(0) pid_expiry(0)
```
read hit percent: 13, write hit percent: 3. Огромное количество uncached reads/writes. Выходит, flashcache работал, но далеко не в полную силу. Всего виртуальных машин было пара десятков, суммарный объём виртуальных дисков не превышал терабайта, дисковая активность была небольшая. Т.е. такой низкий процент попадания в кэш — не из-за активности соседей.
##### Прозрение!
В сотый раз глядя на вот такое:
```
root@storage:~# dmsetup table cachedev
0 2930294784 flashcache conf:
ssd dev (/dev/sda), disk dev (/dev/md2) cache mode(WRITE_BACK)
capacity(57018M), associativity(512), data block size(4K) metadata block size(4096b)
skip sequential thresh(0K)
total blocks(14596608), cached blocks(3642185), cache percent(24)
dirty blocks(36601), dirty percent(0)
nr_queued(0)
Size Hist: 512:117531108 1024:61124866 1536:83563623 2048:89738119 2560:43968876 3072:51713913 3584:83726471 4096:41667452
```
решил открыть любимый ~~Excel~~ LibreOffice Calc:
Диаграмма построена по последней строчке, гистрограмме распределения запросов по размерам блоков.
Все мы знаем, что
жёсткие диски обычно оперируют блоками по 512 байт. Ровно как и AoE. Ядро Linux — по 4096 байт. Data block size в flascache — тоже 4096.
Просуммировав количество запросов с размерами блоков отличными от 4096, то увидимо что полученное число подозрительно совпадает с количеством uncached reads + uncached writes из статистики flashcache. Кешируются только блоки размером 4К! Помните, что изначально MTU у нас был 4200? Если вычесть отсюда размер заголовка AoE-пакета, получаем размер дата-блока в 3584. Значит, любой запрос к дисковой подсистеме будет разбит минимум на 2 AoE-пакета: 3584 байт и 512 байт. Что как раз и было отчётливо видно на исходной диаграмме, которую я лицезрел. Даже на диаграмме из статьи заметно преобладание пакетов по 512 байт. И рекомендованый на каждом углу MTU в 9К тоже имеет схожую проблему: размер дата-блока составляет 8704 байта, это 2 блока по 4К и один на 512 байт (что как раз и наблюдается на диаграмме из статьи). Опаньки! Решение, думаю, очевидно всем.
##### MTU 8700
Диаграмма сделана спустя несколько суток после обновления конфигурации на одной из бездисковых нод. После обновления MTU на остальных — ситуация станет ещё лучше. А loadavg на виртуальном сервере с MySQL упал до 3!
##### Заключение
Не будучи системными администраторами с 20-ти летним стажем, мы решали проблемы используя «стандартные» и самые популярные подходы, известные в соответствующее время сообществу. Но в реальном мире всегда есть место несовершенствам, костылям и допущениям. На которые мы, собственно, и напоролись.
Вот такая вот история. | https://habr.com/ru/post/158159/ | null | ru | null |
# Интересное применение WordCloud
Всем привет! Хочу продемонстрировать вам, как я использовал библиотеку WordCloud для создания подарка для друга/подруги. Я решил составить облако слов по переписке с человеком, чтобы выделить основные темы, которые мы обсуждаем.
Выгружаем переписку
-------------------
Для начала нам нужно будет выгрузить переписку из ВК. Как это сделать? Очень просто! Я пользовался расширением для браузера "VkOpt". Скачиваем его и устанавливаем. Теперь заходим в диалог с человеком, переписку с которым хотим скачать.
Наводим на три точки и выбираем "сохранить переписку". Далее будет окно с выбором типа файла. Я предпочитаю json.
Обработка переписки
-------------------
Импортируем json и открываем наш файл с перепиской.
```
import json
vk = open('vk2.json', 'r', encoding='utf8')
vk = json.load(vk)
```
Теперь давайте выведем его и посмотрим как он выглядит.
Ну в общем всё ясно, массив таких вот сообщений. Каждый элемент соответствует одному облако-сообщению.
Давайте теперь вытащим из каждого сообщения его текст и разделим этот текст на слова.
```
mas = []
for i in range(len(vk)):
mas.append(vk[i]['body'].split())
data = []
for i in mas:
for j in range(len(i)):
data.append(i[j].lower())
```
Теперь у нас есть массив data, в котором каждый элемент - это одно слово. Далее создадим большую строку, в которую просто запишем через пробел все наши слова.
```
big_string=''
for i in range(len(data)):
big_string+=(data[i]+' ')
```
WordCloud
---------
Почти всё готово, теперь давайте воспользуемся библиотекой WordCloud и построим наше облако слов.
```
pip install wordcloud
import matplotlib.pyplot as plt
%matplotlib inline
from wordcloud import WordCloud, STOPWORDS
wordCloud = WordCloud(width = 10000, height = 10000, random_state=1, background_color='black', colormap='Set2', collocations=False).generate(big_string)
plt.figure(figsize=(5,5))
plt.imshow(wordCloud)
```
Убираем стоп-слова
------------------
Так, и что же это? Не очень похоже на оригинальный подарок. Естественно всё не так просто. Дело в том, что в нашей речи и сообщениях встречается куча стоп-слов. Собственно, эти слова вы и видите на картинке. Они встречались в диалоге чаще всего, поэтому алгоритм выделил их крупным шрифтом.
Теперь наша задача: почистить строку от ненужный слов. Для этого скачаем словарик стоп-слов русского языка(<https://snipp.ru/seo/stop-ru-words>). Он представлен как обычный txt-шник, а значит прочитаем его и разделим по переносу строки.
```
stop_words = open('stop-ru.txt', 'r', encoding='utf8')
stop_words = stop_words.read()
stop_words = stop_words.split('\n')
```
Далее создадим массив clear\_data, куда будем заносить слова из массива data, которые не содержатся в списке стоп-слов(т. е. нормальные слова).
```
clear_data=[]
for i in data:
if(i not in stop_words):
clear_data.append(i)
```
А теперь формируем нашу большую строку, только теперь из нового массива и заново строим WordCloud.
```
big_string=''
for i in range(len(clear_data)):
big_string+=(clear_data[i]+' ')
wordCloud = WordCloud(width = 10000, height = 10000, random_state=1, background_color='black', colormap='Set2', collocations=False).generate(big_string)
plt.figure(figsize=(5,5))
plt.imshow(wordCloud)
```
Результат на лицо. Начинает проявляться оттенок переписки с тем или иным человеком. Ну и, естественно, куда же мы русского могучего, он тоже начинает проявляться на изображении, приходится его замазывать :)
Переходим на ручное управление
------------------------------
Так, вроде стоп-слова убрали, но картинка всё равно не выглядит привлекательной. В выборке остались различные выражения, которые мы часто используем в переписке. Например, мои слова паразиты: "ок", "ща", "крч". Что делать? Все просто. Открываем наш текстовик с русскими стоп-слова и просто вписываем туда слова, которые не должны присутствовать в новом облаке слов(не забудьте сохранить текстовик, перед повторным чтением).
P.S. На самом деле есть и второй вариант удалить слова паразиты. Создадим массив, который заполним словами паразитами, и подадим его как параметр в WordCloud. Тоже хороший вариант, но мне больше нравится с текстовиком.
```
stopw = ['а', 'ок', 'крч'] #массив слов, которые хотим удалить
#подадим массив stopw в WordCloud как параметр stopwords
wordCloud = WordCloud(width = 1000, height = 1000, random_state=1,
background_color='black', colormap='Set2',
collocations=False, stopwords=stopw).generate(big_string)
```
Таким образом, мы всё глубже и глубже погружаемся в чертоги нашей переписки. Обычно появляются слова, соответствующие темам, которые вы и ваш друг часто обсуждаете.
Форма облака слов
-----------------
Теперь давайте воспользуемся одной фишкой WordCloud. Оформим наше облако слов в виде какой-то картинки. Я выберу банальное сердечко)
```
from PIL import Image
original_image = Image.open('путь до картинки')
image = original_image.resize([2000,2000], Image.ANTIALIAS)
image = np.array(image)
```
Подадим в функцию нашу картинку как параметр mask.
```
wordCloud = WordCloud(width = 1000, height = 1000, random_state=1,
background_color='black', colormap='Set2',
collocations=False, stopwords=stopw, mask=image).generate(big_string)
```
Вот такая штука у меня получилась.
По-хорошему, нужно удалить ещё около десятка слов, для более-менее приятной картины, но я уверен ту вы справитесь сами)
P.S. Выбирайте черно-белые изображения предметов. Лучше всего, если они выглядят как силуэты. С .png у меня не прошло, поэтому я сохранял в .jpg, может быть у вас получится.
Итог
----
Я нарисовал облако слов, которое отражает тональность переписки с тем или иным человеком. Дополнительно, в облаке содержатся слова, которые соответствуют тем темам, которые вы часто обсуждали в диалоге. Как вариант, можно сохранить эту картинку, распечатать, поставить в рамочку и вручить как подарок вашему собеседнику. Ему будет очень приятно, ведь всегда интересно посмотреть на то, как оценивает вашу переписку алгоритм) | https://habr.com/ru/post/580560/ | null | ru | null |
# OLPC, Афганистан. Первые прототипы педальных нетбуков
Как бы смешно не звучал заголовок, но это так.
Для использования нетбуков в деревнях и сельских районах.
Никаких дополнительных аккумуляторов, только физическая сила человека.
Разработчики утверждают, что использовать данное устройство подсилу даже детям третьих-четвертых классов.
источники:
[One Laptop Per Child News](http://www.olpcnews.com/countries/afghanistan/updates_from_olpc_afghanistan_1.html)
[One Laptop Per Child Afghanistan](http://www.olpc.af/)
p.s. ну да, ничего нового, но ведь применимо.
p.p.s я думаю многие из нас с такой конструкцией стали намного меньше сидеть за компьютером без дела ;)
---
**upd**: не ходите так много по второй ссылке, у них БД начинает оказывать
`Database Error: Unable to connect to the database:Could not connect to MySQL` | https://habr.com/ru/post/72261/ | null | ru | null |
# PostrgreSQL: ускоряемся через intarray
Лет так 6 назад, когда слоник был только в 8.0, а я плотно сидел на MySql, часто слышал призывы сменить DB. Я помню как это было болезненно начать. Но после того, как решился, ни разу не жалел и на мускул уже вряд ли вернусь. Уж очень много тут плюсов, но пост не об этом.
Пришла задача: написать магазин, большой в перспективе. А-ля Фотос, Хотлайн. Ну и стандартная задача для таких площадок — это фильтр.
Как это делаются в обычных «движках»? Верно: параметры = фильтры. Ну все понятно, что это просто, но не всегда красиво, особенно когда нужны фильтры с диапазонами (например: диагональ 10"-11"). Да и тогда приходится думать о том, что фильтры — это независимая от параметров сущность. В моей версии фильтры «вяжутся» к параметрам. Не знаю, как это сделано на том же хотлайне (есть подозрение, что там фильтры вяжутся непосредственно на товары), но такой вариант требует много человеческого внимания. Не буду вдаваться в детали архитектуры, это тема другого поста. Но рассматривать будем именно упрощенный вариант, дабы не потеряться.
Проблема в таких фильтрах — это их построение. Просчитать количество товаров при выбранных (или не выбранных ещё) фильтрах.
Итак…
Создаем таблицу для товаров:
```
CREATE TABLE public.products (
id SERIAL,
title VARCHAR NOT NULL,
CONSTRAINT products_pkey PRIMARY KEY(id)
);
```
Таблицу фильтров:
```
CREATE TABLE public.filters (
id SERIAL,
title VARCHAR NOT NULL,
CONSTRAINT filters_pkey PRIMARY KEY(id)
);
```
Таблицу для связей между filters и products:
```
CREATE TABLE public.products_ref_filters (
id_product INTEGER NOT NULL,
id_filter INTEGER NOT NULL,
CONSTRAINT products_ref_filters_pkey PRIMARY KEY(id_product, id_filter),
CONSTRAINT products_ref_filters_fk FOREIGN KEY (id_product)
REFERENCES public.products(id)
ON DELETE CASCADE
ON UPDATE CASCADE,
CONSTRAINT products_ref_filters_fk1 FOREIGN KEY (id_filter)
REFERENCES public.filters(id)
ON DELETE CASCADE
ON UPDATE CASCADE
);
```
И получается стандартный вариант. Тривиально.
Дальше…
В таблицу товаров добавляем поле filters:
```
ALTER TABLE public.products
ADD COLUMN filters INTEGER[] DEFAULT ARRAY[]::integer[] NOT NULL;
```
Как вы заметили, это массив чисел, тут будут дублироваться айдишки фильтров, да, это денормализация. Для целостности пишем процедуры и вешаем на триггера. Вставка:
```
CREATE OR REPLACE FUNCTION public.products_ref_filters__insert_tr ()
RETURNS trigger AS'
BEGIN
UPDATE products
SET filters = filters + NEW.id_filter --push element onto array
WHERE id = NEW.id_product;
RETURN NEW;
END;
'LANGUAGE 'plpgsql';
CREATE TRIGGER products_ref_filters__insert_tr
AFTER INSERT
ON public.products_ref_filters FOR EACH ROW
EXECUTE PROCEDURE public.products_ref_filters__insert_tr();
```
Удаление:
```
CREATE OR REPLACE FUNCTION public.products_ref_filters__delete_tr ()
RETURNS trigger AS'
BEGIN
UPDATE products
SET filters = filters - OLD.id_filter --remove entries matching right argument from array
WHERE id = OLD.id_product;
RETURN OLD;
END;
'LANGUAGE 'plpgsql';
```
Обновление:
```
CREATE OR REPLACE FUNCTION public.products_ref_filters__update_tr ()
RETURNS trigger AS'
BEGIN
UPDATE products
SET filters = filters - OLD.id_filter
WHERE id = OLD.id_product;
UPDATE products
SET filters = filters + NEW.id_filter
WHERE id = NEW.id_product;
RETURN NEW;
END;
'LANGUAGE 'plpgsql';
CREATE TRIGGER products_ref_filters__update_tr
AFTER UPDATE
ON public.products_ref_filters FOR EACH ROW
EXECUTE PROCEDURE public.products_ref_filters__update_tr();
```
Очистка:
```
CREATE OR REPLACE FUNCTION public.products_ref_filters__truncate_tr ()
RETURNS trigger AS'
BEGIN
UPDATE products SET filters = ARRAY[]::INTEGER[];
RETURN NULL;
END;
'LANGUAGE 'plpgsql';
CREATE TRIGGER products_ref_filters__truncate_tr
AFTER TRUNCATE
ON public.products_ref_filters FOR EACH STATEMENT
EXECUTE PROCEDURE public.products_ref_filters__truncate_tr();
```
Теперь, при вставке, обновлении, удалении, данных из таблицы связей будет записываться массив фильтров в таблицу товаров. И мы избавились от JOIN. Теперь не нужно клеить таблицы в запросе. Это дает много плюсов, легче строить запросы, они быстрее, меньше памяти и т.д. Но статья ведь о intarray? Да.
Устанавливаем расширение:
```
CREATE EXTENSION intarray;
```
После исполнения этой команды в базе появятся функции, индексы, операторы для работы с массивами типа INTEGER. Теперь работать будет намного быстрее и удобнее.
Наполняем нашу БД. Фильтров 10 000. Товаров 100 000. Каждому товару по 10 фильтров. Итого: промежуточная таблица 1 000 000 строк. Этот блок запросов у меня исполнялся 8 мин. Так что дождитесь.
```
INSERT INTO filters (title) SELECT 'filter_' || num FROM generate_series(1, 10000) as num;
INSERT INTO products (title) SELECT 'product_' || num FROM generate_series(1, 100000) as num;
DO $$
DECLARE
idp INTEGER;
BEGIN
FOR idp IN SELECT id FROM products
LOOP
INSERT INTO products_ref_filters
SELECT idp, f.id FROM filters f ORDER BY random() LIMIT 10;
END LOOP;
END$$;
```
Создаем индекс на массив чисел:
```
CREATE INDEX products_idx ON public.products
USING gin (filters public.gin__int_ops);
```
Итого, наша БД заполнена. Давайте посмотрим, что теперь с этим делать. Давайте найдем самые популярные фильтры и запомним их.
```
SELECT id_filter
FROM products_ref_filters
GROUP BY id_filter
ORDER BY count(*) DESC
LIMIT 10
```
Мой результат такой: 7267, 4889, 6364, 5376, 3556, 7292, 11188, 2643, 9005, 10235.
Найдем товары с определенным фильтром, пусть будет 7267:
```
-- обычный JOIN
SELECT t1.* FROM products t1, products_ref_filters t2
WHERE t1.id = t2.id_product
AND t2.id_filter = 7267
-- 140 rows returned (execution time: 125 ms; total time: 141 ms)
-- SUB SELECT
SELECT * FROM products
WHERE id IN ( SELECT id_product FROM products_ref_filters WHERE id_filter = 7267 )
-- 140 rows returned (execution time: 125 ms; total time: 141 ms)
-- поиск по массиву
SELECT * FROM products WHERE filters @> ARRAY[7267]
-- 140 rows returned (execution time: 0 ms; total time: 0 ms)
```
Один из фильтров
```
-- JOIN
SELECT DISTINCT t1.* FROM products t1, products_ref_filters t2
WHERE t1.id = t2.id_product
AND t2.id_filter IN (7267,4889,6364,5376,3556,7292,11188,2643,9005,10235)
-- 1347 rows returned (execution time: 297 ms; total time: 297 ms)
-- SUB SELECT
SELECT * FROM products
WHERE id IN ( SELECT id_product FROM products_ref_filters WHERE id_filter IN (7267,4889,6364,5376,3556,7292,11188,2643,9005,10235) )
-- 1347 rows returned (execution time: 234 ms; total time: 250 ms)
-- INTARRAY
SELECT * FROM products WHERE filters && ARRAY[7267,4889,6364,5376,3556,7292,11188,2643,9005,10235]
-- 1347 rows returned (execution time: 16 ms; total time: 16 ms)
```
Лень составлять другие запросы, уж простите. Но когда нужно найти товары с несколькими фильтрами, тут вообще этот подход оставляет джойны и сабселекты далеко позади.
```
-- JOIN
-- ЛЕНЬ, но тут отрыв ещё больше будет ;)
-- Товары содержащие оба фильтра
SELECT * FROM products WHERE filters @> ARRAY[9844,9957];
-- 1 rows returned (execution time: 0 ms; total time: 16 ms)
```
Оф. дока [тут](http://www.postgresql.org/docs/9.1/static/intarray.html).
Обратите внимание на операторы, это просто сказка! Где-то читал, что даже есть патч, установив который, можно внешние ключи строить на массив, и база сама будет следить за целостностью. Еще где-то читал, что разработчики даже планируют это сделать без всяких патчей. Да, здорово. В свое время, когда я нашел (для себя) это решение, радости было…
Посмотрев, что есть небольшой интерес к теме.
Решил немного добавить немного тестов на объемах.
Попробуем на 10 000 000 товарах.
Немного изменим запрос, по заполнению псевдотоваров.
```
-- фильтров как и было 1000
INSERT INTO filters (title) SELECT 'filter_' || num FROM generate_series(1, 10000) as num;
--Товаров 10 000 000
INSERT INTO products (title) SELECT 'product_' || num FROM generate_series(1, 10000000) as num;
-- т.к. целостность нас в тестах не интересует, заполним только ID-шки
DO $$
DECLARE
idp INTEGER;
BEGIN
FOR idp IN SELECT id FROM products
LOOP
UPDATE products
SET filters = (SELECT array_agg(id) FROM (SELECT id FROM filters OFFSET random()*1000 LIMIT 10) as foo)
WHERE id = idp;
END LOOP;
END$$;
-- этот запрос отрабатывает ~20мин
```
Размер БД ~2.9Гб
Индекс BTREE:
```
CREATE INDEX products_idx ON public.products USING btree (filters);
-- execution time: 00:02:36
-- DB size ~ 3.8Gb
SELECT * FROM products WHERE filters @> '{842}'::INTEGER[];
-- Seq Scan on public.products (cost=0.00..357908.00 rows=10000 width=80) ...
-- 99798 rows returned (execution time: 5,594 sec; total time: 5,594 sec)
SELECT * FROM products WHERE filters = '{842,843,844,845,846,847,848,849,850,851}'::INTEGER[];
-- Bitmap Heap Scan on public.products (cost=487.94..32940.13 rows=9726 width=80)
-- 9940 rows returned (execution time: 46 ms; total time: 62 ms)
SELECT * FROM products WHERE filters && '{842,843,844,845,846,847,848,849,850,851}'::INTEGER[]
-- Seq Scan on public.products (cost=0.00..357908.00 rows=10000 width=80)
-- 189853 rows returned (execution time: 6,281 sec; total time: 6,296 sec)
```
Индекс GIST:
```
CREATE INDEX products_idx ON public.products USING gist (filters public.gist__int_ops);
-- execution time: 00:26:55;
-- DB size ~ 4.5Gb
SELECT * FROM products WHERE filters @> '{842}'::INTEGER[];
-- Bitmap Heap Scan on public.products (cost=833.92..34097.44 rows=10000 width=80)
-- 99798 rows returned (execution time: 2,234 sec; total time: 2,234 sec)
SELECT * FROM products WHERE filters = '{842,843,844,845,846,847,848,849,850,851}'::INTEGER[];
-- Bitmap Heap Scan on public.products (cost=811.79..33263.99 rows=9726 width=80)
-- 9940 rows returned (execution time: 234 ms; total time: 234 ms)
SELECT * FROM products WHERE filters && '{842,843,844,845,846,847,848,849,850,851}'::INTEGER[];
-- Bitmap Heap Scan on public.products (cost=833.92..34097.44 rows=10000 width=80)
-- 189853 rows returned (execution time: 5,234 sec; total time: 5,234 sec)
```
Индекс GIN:
```
CREATE INDEX products_idx ON public.products USING gin (filters public.gin__int_ops);
-- execution time: 56,344 sec;
SELECT * FROM products WHERE filters @> '{842}'::INTEGER[];
-- Bitmap Heap Scan on public.products (cost=97.50..33361.02 rows=10000 width=80)
-- 99798 rows returned (execution time: 2,204 sec; total time: 2,219 sec)
SELECT * FROM products WHERE filters = '{842,843,844,845,846,847,848,849,850,851}'::INTEGER[];
-- Bitmap Heap Scan on public.products (cost=211.37..32663.57 rows=9726 width=80)
-- 9940 rows returned (execution time: 297 ms; total time: 312 ms)
SELECT * FROM products WHERE filters && '{842,843,844,845,846,847,848,849,850,851}'::INTEGER[];
-- Bitmap Heap Scan on public.products (cost=213.50..33477.02 rows=10000 width=80)
-- 189853 rows returned (execution time: 4,500 sec; total time: 4,515 sec)
```
Да, для мега больших баз, это особо не спасет. Но учитывая что такой поиск на практике не бывает, а всегда есть дополнительный фильтр, например по категории, то все же метод хорош. В любом случае это в 100 раз быстрее JOIN. | https://habr.com/ru/post/269823/ | null | ru | null |
# Telegram Site Helper 2.0 — чат помощник для сайта на основе Telegram
Здравствуйте. Меня зовут Андрей.
Летом прошлого года я опубликовал проект и статью "[Чат-помощник на сайт с помощью Telegram за 15 минут](https://habrahabr.ru/post/264035/)". Идея проекта заключалась в том, чтобы реализовать на сайте **всплывающий Чат-помощник**, бэкэндом для которого (для чата) был бы набирающий популярность **мессенджер Telegram**.
На удивление проект довольно быстро стал набирать звезды на **GitHub**, а я — получать письма благодарности и просьбы о помощи в настройке от людей со всего света. Люди не могли запустить скрипт на своих хостингах: то set\_time\_limit(0) не поддерживается, то 503 ошибка, то пути не правильно указаны.
**Вторая версия скрипта** устанавливается намного проще и работает на основе **WebHooks**.
**[>>>> Ссылка на репозиторий GitHub](https://github.com/Surzhikov/Telegram-Site-Helper-2.0)**.
В двух словах, что это такое
----------------------------
Для тех, кто не видел прошлую статью, повторюсь. **Telegram Site Helper** — это набор скриптов (PHP, JS), которые реализуют чат-помощник для Вашего сайта (для того, чтобы Ваши посетители/клиенты могли оперативно задать вопрос в чат Вашему менеджеру). Менеджер получит сообщение в мессендежере Telegram. И там же может ответить. Система подходит для сайтов, где не очень большой поток клиентов. По прежнему есть маленькое неудобство: все сообщения от всех посетителей приходят менеджеру в единый чат. Чтобы направить ответ посетителю, менеджер сперва должен выбрать «подчат», отправив команду */chat\_1234*, примерно вот так:
Что нового
----------
#### Теперь чат работает на основе WebHooks
Сервер Telegram сам будет присылать новые сообщения на Ваш сервер.
Вечно работающий в фоне скрипт-сервер для Long Poll запросов к серверу Telegram больше не нужен. Но зато теперь нужен HTTPS (это политика Telegram). Сертификат можно [купить](https://www.google.ru/webhp?sourceid=chrome-instant&ion=1&espv=2&ie=UTF-8#q=%D0%BA%D1%83%D0%BF%D0%B8%D1%82%D1%8C%20ssl%20%D1%81%D0%B5%D1%80%D1%82%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%82), сделать бесплатный на **[StartSSL](https://www.startssl.com)** или изготовить самоподписанный.
Для тех, кто не хочет искать, команды для терминала:
**Как создать csr-файл для StartSSL**`sudo openssl req -nodes -newkey rsa:2048 -keyout apache.key -out apache.csr`
**Как сделать самоподписанный сертификат**`sudo openssl req -x509 -nodes -days 3650 -newkey rsa:2048 -keyout apache.key -out apache.crt`
#### Для установки используется всего один файл.
В репозитории лежит всего один файл: **telegram-site-helper-install.php** — это инсталлятор. Он создаст нужные директории, распакует JS, CSS и два PHP файла.
Здесь же вы сможете сгенерировать JS код чата, который нужно будет вставить на странцу сайта.
**Внимание: cкрипты в инсталляторе закодированны в base64**Поскольку для многих владельцев сайтов на Wordpress/Joomla, base64 ассоциируется с вирусными инъекциям — заранее приглашаю всех ~~параноиков~~ опасающихся изучить содержимое скриптов, закодированных в base64 (например с помощью [этой утилиты](https://www.base64decode.org/)).
#### Всплывающий и встроенный чаты, стилизация
Чат можно стилизовать не залезая в CSS. Цвет рамки, фона, шрифт можно настроить прямо из инсталлятора.
Еще чат поддерживает два режима отображения. Его можно **встроить в любой другой HTML** элемент или "**приклеить**" к одному из углов экрана. Чат может открывать при нажатии на стандартный лейбл, а может при нажатии на произвольный HTML элемент
Вы также можете изменить все надписи («Начать чат», «Введите ваше имя», «Прикрепить файл» и другие).
#### Передача файлов
Теперь клиент и менеджер могут обмениваться файлами (фото и документами). Файлы хранятся на сервере Telegram и не занимают место на Вашем хостинге.
#### JQuery больше не обязательна
В прошлый раз меня ругали, мол надо тянуть JQuery для работы небольшого скрипта. Я все осознал и в этот раз написал все на чистом JavaScript.
#### Работает через Server Side Events либо LongPoll
Чат на сайте теперь может получать обновления от вашего сервера не только с помощью Long Poll запросов, но и с помощью Server Side Event трансляции (она будет работать только на хостингах, где поддерживается **set\_time\_limit(0)** и нет проблем с функцией **flush()**)
Как установить
--------------
1. Зайдите на свой сервер/VPS/хостинг по SSH или FTP
2. Создайте папку (удобнее в корне сайта) и назоваите ее например telegram-site-helper
3. Сделайте ей chmod (права доступа) хотя бы 0775 (скрипт-инсталлятор создаст там папки и файлы)
4. Залейте в эту папку telegram-site-helper-install.php
5. Запустите скрипт через https (например: `**https:**//mysite.ru/telegram-site-helper/telegram-site-helper-install.php`).
Вы должны увидеть следующее: 
6. Выберите Язык и нажмите «Начать установку»
7. Придумайте пароль для авторизации менеджеров и введите его в соответствующее поле (этот пароль менеджер введет одни раз для авторизации у Телеграм бота)
8. Получите токен для Бота у [**@BotFather**](https://telegram.me/botfather) и вставьте его (токен) в соответствующее поле:
9. Выберите, где хранить данные: в SQLite или в MySQL. Если в MySQL — настройте доступ.
10. Если вы используете самоподписанный сертификат — укажите полный путь до него (его нужно отправить на сервер Telegram)
11. Нажмите "**Проверить настройки и установить Telegram Site Helper**"
12. Если установка прошла успешно Вы должны увидеть следующее:
13. Откройте Telegram и напишите своему боту "**/login 1234**" (где 1234 — пароль менеджера). Если установка прошла успешно, бот авторизует Вас.
14. Переходим на вкладку "**Генератор виджета**"
15. Настраиваем виджет и копируем код на сайт. Все.
16. Если понравился проект — можно сделать **[Donate](https://money.yandex.ru/embed/donate.xml?account=4100168691358&quickpay=donate&payment-type-choice=on&mobile-payment-type-choice=on&default-sum=100&targets=%D0%9F%D0%BE%D0%B4%D0%B4%D0%B5%D1%80%D0%B6%D0%BA%D0%B0+%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B0&target-visibility=on&project-name=Telegram+Site+Helper+2%2F0&project-site=https%3A%2F%2Fgithub.com%2FSurzhikov%2FTelegram-Site-Helper-2.0&button-text=01&successURL=https%3A%2F%2Fraw.githubusercontent.com%2FSurzhikov%2FTelegram-Site-Helper-2.0%2Fmaster%2Fthank-you.txt)**.
Планы на будущее
----------------
* Все же реализовать поддержку LongPoll к серверу Telegram, чтоб обойтись без HTTPs
* Придумать и сделать: как разделять клиентов на «под-чаты»
* Доделать перевод на английский язык
* Голосовой чат
* Возможность изменить/отключить звук сообщения
* Умные мысли, которые хабра-пользователи напишут в комментариях
В конце статьи выражаю благодарность команде Telegram за платформу для Ботов. Крайне полезная вещь.
Спасибо.
UPD! Забыл добавить, что после установки, стоит удалить инсталлятор с сервера и настроить права доступа к папке.
**Большое спасибо за оперативные Pull Request`ы и критику кода.** Ищу силы и время на доработки. | https://habr.com/ru/post/302056/ | null | ru | null |
# За закрытой дверью фронтенда ЕФС
В этой статье мы расскажем о библиотеке компонентов Единой фронтальной системы (ЕФС) и как в целом устроен фронтенд платформы.
[](https://habrahabr.ru/company/efs/blog/325916/)
Одной из основных задач программы ЕФС является трансформация всех фронтальных систем к единому технологическому стеку. Фронтальная система в нашем контексте это интерфейс, через который любой пользователь взаимодействует с банком. Это может быть интернет-банк — многим известны приложения Сбербанк Онлайн и Сбербанк Онлайн для бизнеса, — банкоматы, терминалы, интерфейсы операторов в отделениях и call-центрах и другие системы, которыми пользуются многие тысячи клиентов и сотрудников банка в России.
Основная проблема, которую мы решаем, это замена устаревшего кода: фронтальных систем в банке много, у каждого своя архитектура, свой дизайн.
Очевидно, что это неудобно для всех: для клиентов, сотрудников и банка в целом.
Поэтому главная миссия фронтенда ЕФС – заменить существующую сборную солянку и привести все к единой кодовой базе, к единому технологическому стеку с удобным и понятным пользовательским сценарием.
Какие задачи стоят перед разработкой?
-------------------------------------
* Надежность и безопасность, ведь мы говорим о банковском ПО.
* Отказоустойчивость. Здесь фигурирует такая цифра, как 99,99%, это примерно 52 минуты в год, когда мы можем приостановить работу системы.
* Удобство для разных социально-демографических категорий пользователей. Интерфейс должен быть понятен как продвинутому пользователю, так и бабушке, как опытному сотруднику банка, так и новичку. Добавим, что единообразие и стандартизация позволяют нам сэкономить значительное время на обучении многих тысяч сотрудников по всей России.
* Быстрота работы и внедрения, так называемый time-to-market.
До эры ЕФС время вывода нового технического продукта на рынок могло составлять до 1 года. С ЕФС мы ставим себе задачу сократить time-to-market до 1 месяца.
И это только начало!
Как устроен фронтенд в ЕФС?
---------------------------
У нас есть команда разработчиков платформы ЕФС, а также прикладные разработчики, задача которых – реализовать бизнес-логику.
Команда платформы разрабатывает библиотеку UI-компонентов для внутреннего использования. Примеров подобной разработки довольно много — у таких компаний, как Google, Yandex, Avito, Mail.ru и др. также есть библиотеки компонентов. Команды же прикладных проектов используют эту библиотеку для реализации своих проектов, предоставляя фидбек в случае проблем.
В команде платформы сейчас 8 человек. Мы работаем двухнедельными спринтами, в конце каждого из них выпускаем новую версию библиотеки, в которой содержатся фиксы и, возможно, новые компоненты. У нас, разумеется, есть code review, свой code style – мы взяли лучшие практики программирования и адаптировали их под себя.
В качестве инструментария мы используем набор инструментов от компании Atlassian: JIRA для постановки задач, BitBucket для git-репозиториев и Confluence для документации.
Из чего состоит библиотека?
---------------------------
* Различные UI-элементы: всевозможные селекты, кнопки, большой набор полей с различными типами данных, чекбоксы, радиокнопки и другие элементы формы, с которыми взаимодействует пользователь.
* Способы вывода информации, например, таблицы или панели с кнопками и заголовками
* Сетка. Мы посмотрели, как ее реализовал Bootstrap, а затем создали подобное для своих целей. По нашей сетке компоненты строятся на формах.
* Компонент просмотра вложений. Служит для того чтобы оператор мог взаимодействовать с приложенным файлом, например, приблизить или повернуть квитанцию.
* Компонент загрузки файлов
* Компонент для асинхронной загрузки React-приложений: бизнес-процессов много, мы разбили их на отдельные React-приложения, которые подгружаются при переходах из одного процесса в другой.
Поддержка браузеров
-------------------
Целевыми браузерами являются IE8+. Сейчас IE8, если кто-то помнит, это как в свое время был IE6: ужасное API и ужасная отладка. Конечно, время, проведенное за дебагом в IE8, бесценно. Были случаи, когда разработчики проводили несколько дней в попытках найти, в каком месте возникала ошибка, потому что в IE8 очень скудный инструментарий для дебага и он показывает порой, что ошибка возникла совсем в другом месте.
Поддержка IE не случайна, нам приходится работать с железом из браузера: RFID-таблетки, различные принтеры, сканеры и т.д. В вебе нет единого стандарта по работе с железом: в далеком прошлом технологией для работы с ним был выбран ActiveX. Количество ПО, написанного с использованием ActiveX, колоссально, и это не дает нам в одночасье отказаться от поддержки IE и перейти в сторону современных браузеров. В планах — перевод устаревшего ActiveX на Java-апплеты и отказ от IE8.
Стек технологий
---------------
Мы своего рода стартап внутри крупной организации и наш стек технологий фронтенда не сильно отличается от большинства мировых стартапов: react, redux и PostCSS. Все эти технологии зарекомендовали себя с лучшей стороны, к тому же, они позволяют нам поддерживать IE8. Однако, мы не можем резко менять стек технологий, т.к. вокруг него завязана определенная архитектура приложений, например, именно React позволил нам разбить одно огромное приложение на сотни маленьких и подгружать их по требованию, используя SystemJS.
### React
Это первая технология, которую мы выбрали по следующим причинам:
1. Позволяет разбить приложение на компоненты, тем самым организовав компонентный подход к разработке.
2. Легок в изучении — мы не требуем от нового коллеги, чтобы он знал React, мы просто даем ему пару дней разобраться в проекте.
3. Поддержка IE8. С этого, на самом деле, можно было начинать, т.к., если посмотреть, какие фрэймворки и библиотеки поддерживают IE8, окажется, что таких крайне мало. Самые популярные — Angular, Ember, Vue.js — его не поддерживают, поэтому с React нам повезло.
Также в процессе разработки мы начали экспериментировать с React Native, что позволило нам выпустить кросс-платформенную библиотеку UI-компонентов. Прочитать об этом вы сможете в нашей [первой статье](https://habrahabr.ru/company/efs/blog/321828/).
### Как мы подружили React и IE8 ?
Во-первых, мы не обновляем версию React, потому что с какого-то момента они тоже отказались от поддержки IE8. Во-вторых, мы используем es3ify — это loader для webpack, который берет наш ES5 код и перегоняет в ES3. Он просто заменяет некоторые вещи, которые в IE8 не работают.
### TypeScript
Второй технологией, которую мы выбрали, был TypeScript, вот почему:
1. Строгая типизация
По нашим стандартам тип any запрещен, однако, бывают исключения из правил, т.к. далеко не всё можно покрыть generic’ами.
2. Защита от дурака
Все мы люди и иногда используем не те типы, передаем не те данные, и компилятор выводит простые и понятные ошибки.
3. Удобство работы с прикладными разработчиками
Как описано выше, мы передаем свою библиотеку прикладным разработчикам. Многие из них также используют TypeScript, и на этапе компиляции им понятно, как правильно работать с компонентами.
Сейчас в библиотеке порядка 70 компонентов. Когда мы только начинали разработку, у нас все компоненты были «умные», то есть содержали state и вся логика была внутри. Особых проблем мы не испытывали. Но, как только компоненты стали сложнее, они начали вкладываться друг в друга, их стало много, мы поняли, что все-таки у нас есть проблемы с производительностью, расскажем, как мы их решали.
### Производительность
Во-первых, мы сделали компоненты «глупыми», то есть избавились от state, вынося его на прикладной уровень. Теперь прикладные разработчики решают, как менять state, а в наши компоненты только пробрасываются нужные props.
Возьмем пример:
```
export default class Input extends React.Component {
static defaultProps: Props = {
value: ''
}
state: State = {
value: this.props.value
}
handleChange = event => {
const value = event.nativeEvent.target.value;
this.setState(prevState => ({value}))
this.props.onChange(value);
};
render() {
return ;
}
}
```
Есть библиотечный компонент Input, у него в state хранится value, в render он возвращает input и в onChange он меняет state. Не много ли кода для такого компонента? Однозначно много, давайте отрефакторим этот пример:
```
export default class Input extends React.Component {
static defaultProps: Props = {
value: ''
}
handleChange = event =>
this.props.onChange(event.nativeEvent.target.value);
render() {
return ;
}
}
```
Код компонента стал короче, а на уровне выше есть компонент Form, который сам решает, как управлять состоянием компонента: через redux или через простейший setState. Input стал проще, и, соответственно, производительнее.
Второе, мы придерживаемся архитектуры чистых компонентов (PureComponent), т.е. все внешние свойства, внутренний state и контекст проходят проверку соответствия предыдущему состояния. Если состояние не изменилось, то нет смысла вызывать render лишний раз. Эту проверку мы осуществляем в методе shouldComponentUpdate, который добавили во все наши компоненты.
И третье, мы избавились от утечек памяти в коллбеках.
```
export default class Button extends React.Component {
render() {
return (
this.props.onClick(event)}>
{this.props.children}
);
}
}
```
В данном примере у компонента есть коллбек onClick и в него передается стрелочная функция.
Если ее так задать, то здесь возникает утечка. В IE8 ее особенно видно, потому что при каждом повторном вызове render эта функция создается, она накапливается и возникают тормоза в компоненте. Немного изменим наш пример:
```
export default class Button extends React.Component {
handleClick = event => this.props.onClick(event);
render() {
return (
{this.props.children}
);
}
}
```
Сам код стал лаконичнее и к тому же, мы избавились от утечки, поскольку callback-функция больше не создается при каждом вызове render.
В планах на будущее — прекращение поддержки IЕ8, что позволит использовать более прогрессивные фронтенд-технологии. Кроме того, мы уже приступили к работе над масштабным проектом интеграции с мобильной платформой ЕФС, приступили к разработке гибридной библиотеки, позволяющая один и тот же код использовать и для web, и для мобильных устройств, используя React Native.
В следующий статье про фронтенд программы ЕФС мы расскажем про то, как мы используем Redux и как он стал сердцем нашей архитектуры, подписывайтесь на наш блог, чтобы не пропустить!
Идеи, предложения и пожелания – пишите, будем рады пообщаться с вами в комментариях к статье. | https://habr.com/ru/post/325916/ | null | ru | null |
# Используйте поиск по хешу, а не обыск массива
Довольно-таки часто встречается задача: проверить, совпадает ли строка с другими строками из набора. Например, вам нужно проверить каждое слово из сообщения на форуме на предмет того, не содержится ли оно в списке запрещённых. Распространённое решение: создать массив со списком запрещённых слов, а затем с помощью функции `in_array()` делать проверку. Есть способы повысить производительность такого алгоритма.
#### Обыск массива
Обычно проверка происходит так:
```
php
$words = get_all_words_in_text($text);
$badWords = ['$$$$', '@#$%', 'crud' /** ... */ ];
foreach ($words as $word) {
if (in_array(strtolower($word), $badWords)) {
echo 'Found bad word: ' . $word . "\n";
}
}
</code
```
Такой способ решает задачу, но он не самый эффективный. Проходим по массиву слов в сообщении и проверяем каждое на нахождение в списке запрещённых функцией `in_array()`. В PHP, алгоритм, по которому реализована работа функции `in_array()`, имеет линейную сложность — O(n). Это значит, что с увеличением списка плохих слов, время работы будет расти пропорционально. Мы можем придумать что-нибудь получше.
#### Поиск по хешу
Так как список плохих слов заранее известен, можно переработать способ сравнения так, что он будет иметь константную сложность, не зависящую от количества запрещённых слов в списке. Для этого можно использовать ассоциативные массивы. Как и в случае с хеш-таблицами, скорость поиска ключа в массиве равна O(1), за исключением [некоторых случаев](http://stackoverflow.com/a/2484455/2816475), которые в нашей ситуации не возникнут.
Если мы изменим структуру массива плохих слов таким образом, чтобы его значения стали ключами, а значения по этим ключам стали просто `true`, можно будет использовать функцию `isset()` и получить значительный прирост скорости.
```
php
$words = get_all_words_in_text($text);
$badWords = [
'$$$$' = true,
'@#$%' => true,
'crud' => true
// ...
];
foreach ($words as $word) {
if (isset($badWords[strtolower($word)])) {
echo 'Found bad word: ' . $word . "\n";
}
}
```
#### Тест производительности
Давайте попробуем протестировать новый способ. Я написал простой тест, который покажет затраченное время на одном и том же наборе данных для способов: «обыск массива» и «поиск по хешу».
```
php
$total = 10000;
$paragraph = 'this is a sentence. Crud! $$$$!';
$words = explode(' ', $paragraph);
$badWordList = ['$$$$', '@#$%', 'crud', 'fud', 'fudd', 'dud'];
$s = microtime(true);
for ($j = 0; $j < $total; $j++) {
foreach ($words as $word) {
in_array(strtolower($word), $badWordList);
}
}
echo "in_array: " . (microtime(true) - $s) . "\n";
$badWordHash = [
'$$$$' = true,
'@#$%' => true,
'crud' => true,
'fud' => true,
'fudd' => true,
'dud' => true
];
$s = microtime(true);
for ($j = 0; $j < $total; $j++) {
foreach ($words as $word) {
isset($badWordHash[strtolower($word)]);
}
}
echo "hash: " . (microtime(true) - $s) . "\n";
```
Как видно из листинга, в тесте используется 10 000 повторов. Результат получился таким:
```
in_array: 0.033491134643555
hash: 0.0069370269775391
```
Как видно, поиск по хешу дал прирост в 480% по сравнению с обыском массива.
Важно понимать, что с ростом количества запрещённых слов, увеличивается время, необходимое для обыска массива функцией `in_array()`. А вот `isset()` от количества элементов не зависит, и время его работы останется постоянным. Давайте, я покажу, что имел ввиду. В следующем примере список запрещённых слов будет состоять из 10 000 элементов.
```
php
$total = 10000;
$paragraph = 'this is a sentence. Crud! $$$$!';
$words = explode(' ', $paragraph);
// Заполняется список запрещённых слов
$sequence = [];
for ($j = 0; $j < 10000; $j++) {
$sequence[] = 'a' . $j;
}
$s = microtime(true);
for ($j = 0; $j < $total; $j++) {
foreach ($words as $word) {
in_array(strtolower($word), $sequence);
}
}
echo "in_array: " . (microtime(true) - $s) . "\n";
// Значения элементов становятся ключами
$hash = array_fill_keys($sequence, true);
$s = microtime(true);
for ($j = 0; $j < $total; $j++) {
foreach ($words as $word) {
isset($hash[strtolower($word)]);
}
}
echo "hash: " . (microtime(true) - $s) . "\n";
</code
```
Разница в скорости видна намного лучше. Поиск по хешу на 3 162 процента быстрее обыска массива.
```
in_array: 20.464313983917
hash: 0.0064699649810791
```
#### Вообще, тут ничего нового нет
Это не новая идея. Это довольно-таки распространённый подход во многих языках. Я недавно понял вдруг, что постоянно использую для подобных задач поиск по хэшу, пока читал книгу «[Программирование на Lua](http://www.lua.org/pil/11.5.html)».
В следующий раз, когда будете использовать `in_array()` для проверки, задумайтесь, а не ускорится ли работа, если вместо этого использовать функцию `isset()` на ключах ассоциативного массива. | https://habr.com/ru/post/216865/ | null | ru | null |
# Самурайские инструменты QA: Python (requests)
Постоянно в слезах и прострации
не знающий про автоматизацию
QA самурайРад приветствовать читателей Хабр. Меня зовут Азамат Акчурин, я QA инженер в Bimeister.
Часто при приемке разного рода фич нам, тестировщикам, не хватает сущностей/данных в тестируемой системе. Тестировать на пустых данных не “***comme il faut***”, поэтому, чтобы наполнить систему данными, мы можем обратиться к разработчикам, QA automation, добавить данные в БД и т. д. — способов очень много.
И сегодня я расскажу про один из таких способов, который "дешево и сердито" позволит тестировщику самостоятельно, не отвлекая других сотрудников, заполнить систему данными.
#### Все, что нам нужно
1. Установить Python.
2. Установить IDE для Python — лично пользуюсь PyCharm.
3. Дочитать эту статью, чтобы научиться применять такой способ в решении задач.
#### N.B.
В данной статье опущу пункты установки Python и IDE — будем считать, что они уже установлены. Перейдем, непосредственно, к практике.
Кейс #1
-------
Представим, что разработали новую таблицу, в которой содержатся объекты со свойством «Строка» — то есть мы можем создать объекты, в которых содержатся любые символы. Нам необходимо проверить фильтрацию объектов, поиск, пагинацию и т. д.
А если таких свойств будет 5/10/15 штук в одном объекте? Какая бы “*Самая быстрая рука на Диком Западе*” не была у тестировщика, заполнять систему данными он будет неприлично долго.
Пришло время научить машину делать рутинную работу за нас:
1. Открываем **devtools**→ **networks** и создаем один объект руками.
2. Ловим запрос, который ушел при создании объекта, и во вкладке **Networks**запоминаем следующие параметры:
- Request Url "[https://[что-то типа](https://sb18.bimeister.io/api/BimExemplars)[google.com](http://google.com/)]/api/BimExemplars".
- Request Method "post".
В этом примере я авторизован под учетной записью в системе, поэтому из Request Headears также фиксирую Bearer Token "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6….и еще куча символов".
3. Из вкладки **Payload** искомого запроса записываем данные для Request Payload.
Добавление объекта вручнуюДобавление объекта вручную. Смотрим PayloadВсе исходные данные мы собрали. Теперь перейдем к написанию скрипта:
```
import requests as r # Для импорта библиотеки requests, с помощью этой библиотеки будем отправлять запросы.
import random # Данная библиотека нужна для формирования рандомных значений.
url = 'https://[что-то типа google.com]/api/BimExemplars' # В переменную url сохранили значение Request Url (см. п2).
bearer = 'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJmYmMyMzRhZC01NjQ1LTQ3MTktODFmNC0zZDQyNzliMTMxYWEiLCJpc3...еще много символов' # В переменную bearer сохранили значение Bearer Token (см. п2).
for i in range(15): # Создаем цикл, в данном случае код — под этим циклом исполнится 15 раз. Почему 15? Да просто пример из головы. Если нам нужно 100 объектов, просто делаем цикл на 100 повторений.
payload = { # В переменную payload сохраняем значение из Requests Payload (см. п3). Но, если оставить в таком виде и запустить код, в системе будет 15 совершенно одинаковых объектов. Давайте подумаем, что можно изменить?
"projectId": "76dfd02a-9016-43f3-93f1-7744acd98f54", # ID проекта оставляем неизменным, так как именно в этом проекте мне необходимы созданные объекты.
"title": "Test obj", # Поле отвечающее за наименование объекта. Отличное поле для рандомных значений. Заменим значение "Test obj" на f"Test obj {random.randint(1, 1000)}". Что это нам даст? Будет создан Объект "Test obj {здесь будет случайное значение от 1 до 100}".
"bimClassId": "94e9f5ff-1afa-47ec-beb0-59109cc3d9dd", # bimClassId и ниже bimPropertyId отвечают за поля свойств у объекта, поэтому оставим их неизменными.
"bimExemplarProperties": [
{
"bimPropertyId": "8f2a6659-feb4-42d6-899d-8e7ebc99d5e4",
"value": "111" # Поле, отвечающее за значения в поле Свойства. Тоже отличное поле для рандомных значений. Идем по протоптанной дорожке и заменяем "123" на f"random.randint(1, 100)". Что здесь происходит? Думаю, уже понятно.
},
{
"bimPropertyId": "391fb437-8771-4d80-a22e-af86ce0fd6a8",
"value": "222" # Аналогично заменим здесь.
},
{
"bimPropertyId": "65f144fa-56d2-4bf1-88f3-452242f03a68",
"value": "333" # Здесь.
},
{
"bimPropertyId": "0d80ff51-5771-4d4d-9a1b-645faaac8c25",
"value": "444" # И здесь.
},
{
"bimPropertyId": "9d64cfc4-bcfc-44d2-88b0-8f8d511db06c",
"value": "555" # И здесь.
}
]
}
requests = r.post(url, headers={'authorization':bearer}, json=payload) # Что происходит: r.post(url, headers={'authorization':bearer}, json=payload) — говорим системе сделать Post запрос (см. п2 Requests Method "post"); url — запрос, который добавляет объекты; headers={'authorization':bearer} — хедеры, которые отправляются вместе с запросом, тут как бы говорим системе, что пользователь авторизован; json=payload — здесь передаем тело запроса.
print(requests.status_code) # После запуска кода выведет статус код каждого запроса. Сугубо личная вещь, сделано для удобства.
```
В таком виде мы создадим 15 одинаковых объектов, содержащих одинаковую информацию, соответствующую payload.
Добавим уникальности объектам через **random.randint(1, 100)**
```
import requests as r
import random
url = 'https://[что-то типа google.com]/api/BimExemplars'
bearer = 'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJmYmMyMzRhZC01NjQ1LTQ3MTktODFmNC0zZDQyNzliMTMxYWEiLCJpc3...еще много символов'
for i in range(15):
payload = {
"projectId": "76dfd02a-9016-43f3-93f1-7744acd98f54",
"title": f"Test obj {random.randint(1, 100)}", # {random.randint(1, 100)} Подставит любое целое число от 1 до 100
"bimClassId": "94e9f5ff-1afa-47ec-beb0-59109cc3d9dd",
"bimExemplarProperties": [
{
"bimPropertyId": "8f2a6659-feb4-42d6-899d-8e7ebc99d5e4",
"value": f"{random.randint(1, 100)}"
},
{
"bimPropertyId": "391fb437-8771-4d80-a22e-af86ce0fd6a8",
"value": f"{random.randint(1, 100)}"
},
{
"bimPropertyId": "65f144fa-56d2-4bf1-88f3-452242f03a68",
"value": f"{random.randint(1, 100)}"
},
{
"bimPropertyId": "0d80ff51-5771-4d4d-9a1b-645faaac8c25",
"value": f"{random.randint(1, 100)}"
},
{
"bimPropertyId": "9d64cfc4-bcfc-44d2-88b0-8f8d511db06c",
"value": f"{random.randint(1, 100)}"
}
]
}
requests = r.post(url, headers={'authorization':bearer}, json=payload)
print(requests.status_code)
```
Теперь запустим код и посмотрим, что произойдет в системе:
Запуск кода1. Запускаем код.
2. Смотрим, что все запросы вернулись с кодом 201.
3. Смотрим, что в системе создалось 15 объектов, и все они имеют рандомные наименования.
Кейс #2
-------
Чтобы закрепить материал, рассмотрим другой пример. Если открыть любой из созданных объектов и изменить какие-либо значения свойств, то можно сохранить новую версию объекта:
Изменение версии объектаЗатем, после сохранения "как новой версии" пользователю доступен список всех версий
Отображение версийВ практике столкнулся с тем, что необходимо было проверить открытие (до 1 сек.) и отображение дропдауна с 1000 версий. И тут снова пригодился Python. Повторим, знакомые нам, шаги:
1. Открываем **devtools**→ **networks**.
2. Создаем новую версию объектами руками.
3. Ловим запрос, который сохраняет версию и фиксируем параметры:
Request Url "[https://[что-то типа](https://sb18.bimeister.io/api/BimExemplarVersions)[google.com](http://google.com/)[]/api/BimExemplarVersions](https://sb18.bimeister.io/api/BimExemplarVersions)",
Request Method "Post".
Из Request Headears запоминаем Bearer Token "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6Ikp...и еще много символов".
Фиксируем параметры для составления скрипта4. Из вкладки Payload скопируем значение Request Payload:
```
{
"bimExemplarId": "92ea9b30-a097-4a7e-a472-48d020eecc13",
"title": "Test obj 893",
"bimExemplarProperties": [
{
"bimPropertyId": "57c5ae3d-3aa2-40c4-a77b-bc90b3cf84f7",
"value": "73"
},
{
"bimPropertyId": "4a23533f-1757-4a0c-931b-57e28a45c1bd",
"value": "162 значение изменено для сохранения новой версии"
},
{
"bimPropertyId": "588b3da1-73bc-4ea6-95d2-035f6082216d",
"value": "987 значение изменено для сохранения новой версии"
},
{
"bimPropertyId": "8740ae93-2a9e-4a17-8e56-5bede7405554",
"value": "51"
},
{
"bimPropertyId": "521ca3e8-64ef-4d3a-af2d-d8facdaf37df",
"value": "608"
},
{
"bimPropertyId": "fc4a6ce2-eb55-4543-9913-fc4238ce739e",
"value": "593"
},
{
"bimPropertyId": "d18c9d75-2298-45d7-9542-1644b900ed45",
"value": "535"
}
],
"bimExemplarVersionId": "f813654e-43b9-437b-930a-4882f1d71d73"
}
```
Нужные данные для скрипта мы записали. Перейдем к финальному скрипту. Рандомные значение проставили только для полей Объекта, так как, меняя только поля объекта, можно сохранить новую версию:
```
import requests as r
import random
url = 'https://[что-то типа google.com]/api/BimExemplarVersions'
bearer = 'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJiNmZjYThmYi1iYjgwLTQzZGItYmY4NC02MDk3NzM5ZGEzZ...и еще много символов'
for i in range(1000):
payload = {
"bimExemplarId": "92ea9b30-a097-4a7e-a472-48d020eecc13",
"title": "Test obj 893",
"bimExemplarProperties": [
{
"bimPropertyId": "57c5ae3d-3aa2-40c4-a77b-bc90b3cf84f7",
"value": f"{random.randint(1, 100)}" # Меняем значение свойства.
},
{
"bimPropertyId": "4a23533f-1757-4a0c-931b-57e28a45c1bd",
"value": f"{random.randint(1, 100)}" # Меняем значение свойства.
},
{
"bimPropertyId": "588b3da1-73bc-4ea6-95d2-035f6082216d",
"value": f"{random.randint(1, 100)}" # Меняем значение свойства.
},
{
"bimPropertyId": "8740ae93-2a9e-4a17-8e56-5bede7405554",
"value": f"{random.randint(1, 100)}" # Меняем значение свойства.
},
{
"bimPropertyId": "521ca3e8-64ef-4d3a-af2d-d8facdaf37df",
"value": f"{random.randint(1, 100)}" # Меняем значение свойства.
},
{
"bimPropertyId": "fc4a6ce2-eb55-4543-9913-fc4238ce739e",
"value": f"{random.randint(1, 100)}" # Меняем значение свойства.
},
{
"bimPropertyId": "d18c9d75-2298-45d7-9542-1644b900ed45",
"value": f"{random.randint(1, 100)}" # Меняем значение свойства.
}
],
"bimExemplarVersionId": "f813654e-43b9-437b-930a-4882f1d71d73"
}
requests = r.post(url, headers={'authorization':bearer}, json=payload)
print(requests.status_code)
```
В этом примере хватило 5 минут, чтобы создать 1000 версий для дальнейших тестов:
Проверка исполнения кодаВ заключение
------------
Мы разобрали два простых кейса из опыта, в которых буквально за 5-10 минут сгенерировали данные для тестирования. Этот способ, на мой взгляд, поможет тестировщику без каких-либо фундаментальных знаний программирования решать рутинные задач подобного рода. Если данная тема будет актуальна для читателей, то в следующей статье разберу более сложные примеры, в которых используются несколько запросов и параметры из одного запроса прокидываются в другой запрос.
Прошу подсказать читателей, интересна ли тема и каким инструментом пользуйтесь при решении таких задач?
### P.S.
Данная инструкция не является призывом к действию, эталоном и панацеей. Это всего лишь один из способов для решения вопросов "одному.здесь.сейчас", который возможно принесет пользу и вам. | https://habr.com/ru/post/669344/ | null | ru | null |
# Грокаем монады императивно
[Часть 1 Грокаем функторы](https://habr.com/ru/post/686768/)
[Часть 2 Грокаем монады](https://habr.com/ru/post/682340/)
Часть 3 Грокаем монады императивно
[Часть 4 Грокаем аппликативные функторы](https://habr.com/ru/post/707294/)
[Часть 5 Грокаем валидацию при помощи аппликативного функтора](https://habr.com/ru/post/709376/)
[Часть 6 Грокаем Traversable](https://habr.com/ru/post/714532/)
В предыдущем посте мы переизобрели Монаду на рабочем примере. У нас получился базовый механизм в виде функции `andThen` для типа `option`, но мы еще не достигли нашей конечной цели. Мы надеялись, что получится написать код, так же как если бы нам не нужно было обрабатывать значения `option`. Мы хотели писать в более "императивном" стиле. В этой части мы увидим как достичь этого при помощи технологии `computation expressions` языка F#, а также углубим наше понимание Монад.
Краткое повторение
------------------
Давайте быстро вспомним модель нашей предметной области:
```
type CreditCard =
{ Number: string
Expiry: string
Cvv: string }
type User =
{ Id: UserId
CreditCard: CreditCard option }
```
Мы хотели написать функцию `chargeUserCard` с сигнатурой:
```
UserId -> TransactionId option
```
Если бы не `option`, мы могли бы написать ее в "императивном стиле":
```
let chargeUserCardSafe (userId: UserId): TransactionId =
let user = lookupUser userId
let creditCard = u.CreditCard
chargeCard creditCard
```
Нашей целью было написать функцию, которая выглядела бы подобным образом, даже не смотря на то, что нам приходится иметь дело с типом `option` в ходе вычисления.
В процессе рефакторинга мы извлекли функцию:
```
let flatMap f x =
match x with
| Some y -> y |> f
| None -> None
```
используя которую, смогли улучшить функцию `chargeUserCard` до такой версии:
```
let chargeUserCard (amount: double) (userId: UserId): TransactionId option =
userId
|> lookupUser
|> andThen getCreditCard
|> andThen (chargeCard amount)
```
В чем же проблема?
------------------
У вас может возникнуть логичный вопрос, в чем же здесь проблема? Наша окончательная реализация `chargeUserCard` хорошо читается. Она довольно ясно описывает наши намерения и мы избежали дублирования кода. Неужели дело просто в эстетике?
Чтобы увидеть, почему возможность использовать "императивный стиль", не просто вопрос красоты, давайте введем еще одно требование. Так мы испытаем нашу текущую реализацию и раскроем ее слабые стороны.
Представим, что теперь пользователи должны устанавливать лимиты расходов в своем профиле. Для обратной совместимости поле `limit` представлено типом `option`. Если лимит задан, мы должны проверить, что расход не превышает его, если же пользователь еще не установил лимит, мы должны прервать вычисление и вернуть `None`.
Добавим лимит в нашу модель:
```
type User =
{ Id: UserId
CreditCard: CreditCard option
Limit: double option }
```
Начнем с реализации функции `getLimit` в том же порядке, как мы реализовали `getCreditCard`:
```
let getLimit (user: User): double option =
user.Limit
```
Итак, как нам обновить `chargeUserCard`, чтобы учесть лимит заданный для аккаунта? Необходимо выполнить следующие шаги:
1. Найти пользователя по его id;
2. Если пользователь существует, получить его кредитную карту;
3. Если пользователь существует, получить заданный лимит;
4. Если у нас есть и лимит и кредитная карта, списать средства, в размере не превышающем лимит.
Давайте опять напишем код, словно у нас нет значений `option`
```
let chargeUserCardSafe (amount: double) (userId: UserId) =
let user = lookupUser userId
let card = getCreditCard user
let limit = getLimit user
if amount <= limit then
chargeCard amount card
else
None
```
А теперь добавим `option` и используем оператор конвейера и функцию `andThen`
```
let chargeUserCard (amount: double) (userId: UserId): TransactionId option =
userId
|> lookupUser
|> andThen getCreditCard
|> andThen getLimit
|> andThen
(fun limit ->
if amount <= limit then
chargeCard amount ??
else
None)
```
Этот код не скомпилируется по двум причинам:
1. Мы не можем написать `andThen getLimit` после `getCreditCard`, потому что в этом месте у нас есть доступ только к объекту `CreditCard`, но мы должны передать объект `User` на вход функции `getLimit`.
2. У нас нет доступа к объекту `CreditCard` в месте вызова `chargeCard`.
Разрывая цепь
-------------
Похоже у нас больше нет последовательного потока данных. Это связано с тем, что нам нужно использовать пользователя для получения как кредитной карты, так и лимита, и нам нужны оба эти объекта, чтобы списать с карты деньги.
Немного пораскинув мозгами мы можем найти способ переписать код с использованием конвейера и функции `andThen`, но теперь он стал довольно размашистым.
```
let chargeUserCard (amount: double) (userId: UserId) : TransactionId option =
userId
|> lookupUser
|> andThen
(fun user ->
user
|> getCreditCard
|> andThen
(fun cc ->
user
|> getLimit
|> Option.map (fun limit -> {| Card = cc; Limit = limit |})))
|> andThen
(fun details ->
if amount <= details.Limit then
chargeCard amount details.Card
else
None)
```
Как быстро растет сложность этого кода!
Не волнуйтесь, если не до конца поняли, что здесь написано. В том-то и дело, что этот код потерял в читаемости и нам надо найти способ сократить его.
Новый сценарий сделал использование конвейера неудобным. Чтобы использовать оператор `|>`, мы вынуждены продолжать накапливать состояние, чтобы в конце цепочки вызовов мы могли использовать все объекты. Именно для этого мы создали анонимную запись в наиболее глубоко вложенной части выражения.
Тут можно начать сомневаться, настолько ли хорошо функциональное программирование. В старые добрые "императивные" времена, мы просто присваивали значения переменным, а затем ссылались на них, когда они были нужны.
Пытаемся усидеть на двух стульях
--------------------------------
К счастью, есть способ разобраться с этим беспорядком.
На этот раз мы собираемся изобрести новый синтаксис, чтобы заставить нашу желанную реализацию работать со значениями `option`. Мы собираемся определить оператор `let!`. Он очень похож на оператор `let`, но вместо того, чтобы просто привязать название к выражению, он привяжет название к значению внутри `option`, если оно существует. Если значение не существует, он немедленно прервет вычисления и вернет `None`.
С этим новым синтаксисом функция `chargeUserCard` упроститься до
```
let chargeUserCard (amount: double) (userId: UserId) =
let! user = lookupUser userId
let! card = getCreditCard user
let! limit = getLimit user
if amount <= limit then
chargeCard amount card
else
None
```
Практически никаких отличий от версии без `option`. Я слышу, как выговорите: "Это все конечно очень здорово, но ты не можешь просто взять и изобрести новый синтаксис!". К счастью для нас, мы и не должны. F# поддерживает оператор `let!` по умолчанию, как часть функционала под названием `Computation Expressions`.
Computation expressions != магия
--------------------------------
F# это не какое-то волшебство, мы должны объяснить ему, как оператор `let!` должен вести себя с конкретной монадой. Нам необходимо определить новый computation expression.
Я не буду подробно останавливаться на этом здесь, [документация F#](https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/computation-expressions#creating-a-new-type-of-computation-expression) - хорошее место, чтобы начать разбираться в технологии. Все, что для нас сейчас важно - F# требует создать тип с методом `Bind`. Мы уже знаем как написать этот метод, потому что мы открыли его в прошлой части и назвали `andThen`. Конструктор computation expression для `option` в конечном итоге выглядит следующим образом.
```
let andThen f x =
match x with
| Some y -> y |> f
| None -> None
type OptionBuilder() =
member _.Bind(x, f) = andThen f x
member _.Return(x) = Some x
member _.ReturnFrom(x) = x
```
Нам нужно также определить метод `Return`, который позволит нам создать из обычного значение объект `option`, и `ReturnFrom`, с помощью которого мы можем получить значение из объекта `option`.
Метод `ReturnFrom` может показаться излишним, потому что он слишком простой. Но в других computation expression нам может понадобиться более сложное поведение. Сделав его расширяемым создатели F# предоставили нам эту возможность за счет необходимости в некоторых случаях написать такой шаблонный код.
С использованием computation expression наша окончательная реализация `chargeUserCard` выглядит так
```
let chargeUserCard (amount: double) (userId: UserId) =
option {
let! user = lookupUser userId
let! card = getCreditCard user
let! limit = getLimit user
return!
if amount <= limit then
chargeCard amount card
else
None
}
```
Довольно аккуратно! Все что нам нужно - обернуть тело метода в блок `option` и таким образом указать, что мы хотим использовать только что определенный нами computation expression. Нам также придется использовать оператор `return!` в последней строке, чтобы выражение вернуло тип `option`. (*для тех кто хочет проделать все это самостоятельно: писать методы для* `OptionBuilder` *нет необходимости, они есть в* [*модуле Option*](https://fsharp.github.io/fsharp-core-docs/reference/fsharp-core-optionmodule.html)*. Автор пропустил одну важную строку, без которой наш computation expression не заработает -* `let option = OptionBuilder()` *прим. переводчика*)
Тестируем computation expression
--------------------------------
Чтобы лучше понять, как работает computation expression, который мы только что определили, и доказать, что все работает как ожидается, давайте запустим несколько тестов в F# repl. (*read-eval-print loop, интерактивный сеанс, где мы можем править код и сразу видеть результат наших правок. Это либо F# Interactive в консоли (dotnet fsi) или IDE, либо онлайн-сервис, которых сегодня очень много. Могу привести как пример один из самых популярных* [*https://replit.com*](https://replit.com) *или интересный вариант для .NET* [*https://sharplab.io*](https://sharplab.io) *прим. переводчика*)
```
> option {
- let! x = None
- let! y = None
- return x + y
- };;
val it : int option = None
```
Когда оба значения `x` и `y` содержат `None` результат будет `None`. Что если только одно из значений будет равно `None`?
```
> option {
- let! x = Some 1
- let! y = None
- return x + y
- };;
val it : int option = None
> option {
- let! x = None
- let! y = Some 2
- return x + y
- };;
val it : int option = None
```
3 из 3! Нам осталось убедиться, что выражение вернет сумму обернутую в `option` если `x` и `y` оба содержат значение.
```
> option {
- let! x = Some 1
- let! y = Some 2
- return x + y
- };;
val it : int option = Some 3
```
Полный комплект!
(*тесты в repl это конечно круто, но от себя хочу предложить вариант Unit-тестов с* [*xUnit*](https://xunit.net/) *и* [*Unquote*](https://github.com/SwensenSoftware/Unquote)
```
let sum x y =
option {
let! x' = x
let! y' = y
return x' + y'
}
let values : obj[] list =
[
[| None; None; None |]
[| 1; None; None |]
[| None; 2; None |]
[| 1; 2; 3 |]
]
[]
[]
let test\_option\_ce x y expected =
test <@ sum x y = expected @>
```
*прим. переводчика*)
Прокачиваем интуитивное понимание монад
---------------------------------------
Этот "императивный" стиль может показаться вам знакомым. Если бы это было асинхронное (async) выражение, мы бы просто использовали `await` вместо `let!`. Причина, по которой людям нравится `async/await`, особенно тем из нас, кто помнит ад глубоко вложенных обратных вызовов, в том, что этот прием позволяет писать асинхронный код, как если бы он был синхронным. Он позволяет нам избавится от всех этих подробностей, связанных с отложенным вычислением и возможностью ошибки в асинхронной функции.
Сomputation expressions в F# позволяют нам работать подобным образом с любыми монадами, не только с асинхронными. Преимущество этого подхода в том, что мы можем продолжать писать код в простом для понимания "императивном" стиле, но без изменяемого состояния и прочих побочных эффектов настоящего императивного программирования.
Должен ли я реализовать все самостоятельно?
-------------------------------------------
[Сборка FSharp.Core](https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/computation-expressions#built-in-computation-expressions) включает в себя несколько предопределенных computation expressions для последовательностей, асинхронных вычислений и LINQ. Много полезных computation expressions реализовано в библиотеках с открытым исходным кодом. Создатели [FSharpPlus](https://fsprojects.github.io/FSharpPlus//computation-expressions.html) пошли еще дальше создав единый computation expression для работы со многими монадическими типами.
Чему мы научились?
------------------
Мы узнали, что, хотя функция `andThen` является основным механизмом композиции монадических вычислений, использование ее напрямую в случае, когда последовательность операций не линейна, может легко привести к запутанному коду. При помощи computation expressions в F# мы можем скрыть эти сложные вычисления и писать код так, словно работаем с обычными функциями, а не монадами. Подобным образом работает `async/await` с той лишь разницей, что асинхронные вычисления ограничены типами `Task` или `Promise`. Так что, если вы грокнули `async/await` вы уже на пути к пониманию монад и computation expressions. | https://habr.com/ru/post/684820/ | null | ru | null |
# Screensaver на J2ME или Назад в прошлое. Часть первая
Доброго времени суток!
#### Введение
На дворе третье января, а душа то и дело требует написать какую-нибудь программку. Недолго думая, я вспомнил, что когда-то предложил [поправочку](http://habrahabr.ru/blogs/JavaMobile/132185/#comment_4429466) автору топика [Splash Screen на J2ME](http://habrahabr.ru/blogs/JavaMobile/132185/), после чего сомнения по поводу того, что писать, окончательно развеялись. Сегодня я предлагаю вам окунуться в мир «обычных звонилок» и написать для них приложение — это будет обычный скринсейвер.
#### Итак, приступим
Для начала вам следует установить себе необходимое для разработки ПО. Думаю, не надо расписывать, что необходимо ставить себе на ПК для компиляции и запуска нашего приложения, т.к. в интернете такую инструкцию можно найти за пять секунд. [Вот](http://annimon.com/library/index.php?id=124&start=0), например. Лично я компилирую все исходники приложений для J2ME на «рядовой звонилке». *Да, да, есть умельцы на земле русской, которые портировали компилятор с преверификатором на платформу J2ME.*
После того, как всё установлено, неплохо было бы вспомнить саму теорию, начиная устройством J2ME приложения и заканчивая директивами манифеста нашего приложения. Впрочем, если вы не знаете, что к чему, то не расстраивайтесь — немного теории по разработке приложений для J2ME будет разобрано в данном топике.
#### Анатомия J2ME приложения
Вообще, приложение в J2ME называется MIDlet-ом. Почему так, вы узнаете далее.
##### javax.microedition.midlet.MIDlet
Приложение для J2ME является ничем иным, как классом, наследованным от класса **MIDlet** из пакета **javax.microedition.midlet**. Данный класс является «сердцем» MIDlet'a. В нашем классе мы обязательно должны объявить три метода, необходимые для функционирования нашего приложения:
```
public void startApp() {
// данный метод вызывается при запуске нашего приложения
}
public void pauseApp() {
// данный метод вызывается, когда на наше устройство поступает звонок, SMS и т.д.
}
public void destroyApp(boolean unconditional) {
// данный метод вызывается тогда, когда он вызывается.
// сейчас объясню...
}
```
Дело в том, что данный метод указан, как необходимый к реализации в то время, как практической пользы он не несёт. Методы **startApp()** и **pauseApp()** используются самой AMS, а **destroyApp()** — нет. По сложившейся традиции, обычно блок данной функции выглядит следующим образом:
```
public void destroyApp(boolean unconditional) {
notifyDestroyed(); // данный метод закрывает наше приложение
}
```
Как вы можете видеть, прекращением цикла жизни приложений руководит функция **notifyDestroyed()**, а не **destroyApp()**. Ну да ладно, предназначение последней так и останется тайной. Не будем отвлекаться, а перейдём дальше.
##### javax.microedition.lcdui.Display
Следующим шагом в реализации нашего приложения является получение ссылки на объект **Display** пакета **javax.microedition.lcdui**. Как вы могли догадаться, делается это для получения возможности работы с экраном, формами (**javax.microedition.lcdui.Form**) или же холстом (**javax.microedition.lcdui.Canvas**) и переключения между ними. Получить ссылку мы можем следующим образом:
```
Display dsp = Display.getDisplay(this); // вот так...
```
Дело сделано, переходим к следующему шагу.
##### javax.microedition.lcdui.game.GameCanvas
Сразу же хочется отметить, что с появлением класса **GameCanvas** — он начал вытеснять обычный **Canvas** из-за невозможности двойной буфферизации «из коробки», как таковой последнего. Поэтому, в качестве холста, я предлагаю использовать именно **GameCanvas**. Сказано — сделано.
**GameCanvas** и **Canvas** отличаются всего-лишь по двум признакам: первый уже был указан (это двойная буфферизация), а вторым является необходимость объявления метода **paint** в последнем. Для наглядности приведу следующий код реализации холста с помощью **Canvas**:
```
import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Graphics;
public class OurCanvas extends Canvas { // наследуемся от Canvas
public void paint(Graphics g) {
int w = getWidth(); // получаем высоту экрана
int h = getHeight(); // и про ширину не забываем
g.setColor(0xffffff); // устанавливаем цвет кисти
g.fillRect(0,0,w,h); // заполняем выбранную область заданным цветом
}
}
```
В методе **paint()** мы выполняем всю отрисовку графических примитивов. Данный подход не особо эффективен по многим причинам, одной из которой является желание разделить логику.
**GameCanvas** позволяет вынести логику в другие методы, классы и т.д. Вот так:
```
import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Graphics;
public class OurCanvas extends GameCanvas implements Runnable { // наследуемся от GameCanvas и реализуем интерфейс Runnable, который используется классом Thread
public void run() {
Graphics g = getGraphics(); // получаем ссылку на объект Graphics
// с помощью которого мы и отрисовываем эти самые графические примитивы
int w = getWidth(); // получаем высоту экрана
int h = getHeight(); // и про ширину не забываем
g.setColor(0xffffff); // устанавливаем цвет кисти
g.fillRect(0,0,w,h); // заполняем выбранную область заданным цветом
}
}
```
Тут я совершил ошибку: не вынес объявления объекта **Graphics** куда-нибудь внутрь объявления самого класса в место объявления переменных, т.е. код должен выглядеть следующим образом:
```
import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Graphics;
public class OurCanvas extends GameCanvas implements Runnable {
Graphics g = getGraphics();
int w = getWidth();
int h = getHeight();
public void run() {
g.setColor(0xffffff);
g.fillRect(0,0,w,h);
isSomethingDone();
}
public void isSomethingDone() {
g.setColor(0xababab);
g.drawLine(25,25,125,125);
}
}
```
Как-то так. Вот и всё — необходимая база знаний для реализации задуманного у нас есть. Поехали!
#### Переходим к разработке
Наше приложение будет состоять из нескольких классов:
Встречайте! **midlet.java:**
```
import javax.microedition.midlet.MIDlet;
import javax.microedition.lcdui.*;
import java.util.Timer;
public class midlet extends MIDlet {
Timer timer;
midletTimerTask task;
midletCanvas canvas;
public midlet () {
canvas = new midletCanvas(this); // создаем канву
timer = new Timer ();
task = new midletTimerTask (canvas); // и задачу, которая будет выполняться
timer.scheduleAtFixedRate(task,10,10); // каждые 10 миллисекунд
// 10 мс - очень мало. Поэтому вызываемый метод repaint будет проверять,
// закончена ли перерисовка предыдущего экрана, с помощью флага in
}
protected void startApp() { // сразу передаем управление канве
Display.getDisplay(this).setCurrent (canvas);
}
protected void pauseApp() {}
protected void destroyApp(boolean unconditional) {}
public void exitMIDlet() {
notifyDestroyed();
}
}
```
Далее сам холст — **midletCanvas.java:**
```
import javax.microedition.lcdui.*;
class midletCanvas extends Canvas {
midlet midlet;
random Random;
static int [] PlasmaTab = { //таблица цветов плазмы - 256 элементов
32,32,33,34,35,35,36,37,38,39,39,40,41,42,42,43,
44,45,45,46,47,47,48,49,49,50,51,51,52,52,53,54,
54,55,55,56,56,57,57,58,58,59,59,59,60,60,60,61,
61,61,62,62,62,62,63,63,63,63,63,63,63,63,63,63,
63,63,63,63,63,63,63,63,63,63,62,62,62,62,62,61,
61,61,60,60,60,59,59,58,58,58,57,57,56,56,55,54,
54,53,53,52,52,51,50,50,49,48,48,47,46,46,45,44,
43,43,42,41,40,40,39,38,37,37,36,35,34,33,33,32,
31,30,30,29,28,27,26,26,25,24,23,23,22,21,20,20,
19,18,17,17,16,15,15,14,13,13,12,11,11,10,10, 9,
9, 8, 7, 7, 6, 6, 5, 5, 5, 4, 4, 3, 3, 3, 2, 2,
2, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2,
2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9,
9,10,11,11,12,12,13,14,14,15,16,16,17,18,18,19,
20,21,21,22,23,24,24,25,26,27,28,28,29,30,31,31
};
//Естественно, я не набивал вручную эту таблицу, а получил
//по закону 32* (1+ sin (x*(2*pi/255)), приведя все к целым числам
static int Delta = 6; //размер ячейки плазмы в пикселах
static int Yold_pos=0, Yold_asp=0, Xold_pos=0, Xold_asp=0;
int Ynew_pos, Ynew_asp, Xnew_pos, Xnew_asp, x, y, Color;
static int Width, Height; //Ширина и высота экрана
static boolean in = false; //состояние перерисовки
Graphics gbuffer; //а это для
Image screen; //двойной буферизации
public midletCanvas (midlet midlet) {
this.midlet = midlet;
Random = new random ();
setFullScreenMode (true); //Единственный оператор профиля MIDP 2.0
Width = getWidth ();
Height = getHeight ();
screen=Image.createImage(Width,Height);
gbuffer=screen.getGraphics(); //рисовать будем на gbuffer,
draw (gbuffer); //а потом одномоментно выводить его на канву!
}
void draw (Graphics g) { //рисуем в буфере очередное состояние плазмы
in = true;
Ynew_pos = Yold_pos;
Ynew_asp = Yold_asp;
for (y=0; y>1)));
g.fillRect (x,y,Delta,Delta);
Xnew\_pos += 1;
if (Xnew\_pos > 255) Xnew\_pos=0;
Xnew\_asp += 7;
if (Xnew\_asp > 255) Xnew\_asp=0;
}
Ynew\_pos += 2;
if (Ynew\_pos > 255) Ynew\_pos=0;
Ynew\_asp += 1;
if (Ynew\_asp > 255) Ynew\_asp=0;
}
Xold\_pos -= 2;
if (Xold\_pos<0) Xold\_pos=255;
Xold\_asp += Random.get(8);
if (Xold\_asp > 255) Xold\_asp=0;
Yold\_pos += 4;
if (Yold\_pos > 255) Yold\_pos=0;
Yold\_asp -= Random.get(6);
if (Yold\_asp<0) Yold\_asp=255;
in = false;
}
protected void paint (Graphics g) {
if (in == true) return; //Если мы еще в состоянии перерисовки
g.drawImage(screen,0,0,0);
draw (gbuffer);
}
public void keyPressed(int keyCode) {
switch (keyCode) { //Выход по клавише #
case Canvas.KEY\_POUND:
midlet.exitMIDlet();
break;
}
}
}
```
Следующим по счёту идёт таймер — **midletTimerTask.java:**
```
import java.util.TimerTask;
import javax.microedition.midlet.MIDlet;
class midletTimerTask extends TimerTask {
midletCanvas canvas;
public midletTimerTask (midletCanvas canvas) {
this.canvas = canvas;
}
public final void run() {
canvas.repaint();
}
}
```
И, наконец, реализация выбора случайных чисел — **random.java**
```
import java.util.Date;
import java.util.Random;
class random { //Класс-оболочка генератора случайных чисел
private Random r;
private Date d;
public random () {
d = new Date ();
r = new Random (d.getTime());
}
public int get (int max) { //случайное число из диапазона [0,max-1]
int n=r.nextInt()%max;
return (n<0 ? -n : n);
}
}
```
#### Скандалы, интриги, расследования
Мои исходники не хотят компилироваться. Вернее, они компилируются, но выполняется не то, что хочется мне. Поздняя ночь, поэтому вашему покорному слуге пришлось взять не свои исходники. Извиняюсь за форматирование кода — завтра поправлю.
#### Дальше дело техники
Компиляция и преверификация. Этот шаг я оставляю на вас.
#### MANIFEST.MF
Я предлагаю вам повозиться с этим файлом, а находится он в каталоге **META-INF**. Ведь, если мы делаем скринсейвер, то и вести он должен себя соответствующе. К сожалению, такое поведение доступно только телефонам от Sony Ericsson. Давайте добавим в него следующую строку:
```
SEMC-StandbyApplication: Y
```
#### Что мы сделали
Мы сделали возможной загрузку нашего скринсейвера, как фоновый рисунок. Для этого вам необходимо кинуть MIDlet в телефон. Далее заходим в «Приложения», находим наше. Следующим действием будет нажатие правой софт-клавиши и выбор пункта «Как фон. рисунок». Выбираем — кушать подано. Вы увидите следующее
#### Вот, что получилось
#### All you need
Исходники вы можете взять на Pastebin. вот они:
[midlet.java](http://pastebin.com/RyLuKcXV)
[midletCanvas.java](http://pastebin.com/xMrAPeZr)
[midletTimerTask.java](http://pastebin.com/uDYdaJMY)
[random.java](http://pastebin.com/riEGS5zs)
#### Заключение
Вот и всё. Всего-лишь за несколько шагов мы написали MIDlet. В наши дни J2ME постепенно уходит в никуда и, возможно, у вас уже не осталось подобной трубки, но пока Oracle занимается её поддержкой — кто знает, то ли ещё будет. Надеюсь вам было интересно.
До скорых встреч! | https://habr.com/ru/post/135672/ | null | ru | null |
# Байесовский анализ в Python
Этот пост является логическим продолжением моего первого поста о Байесовских методах, который можно найти [тут](http://habrahabr.ru/post/170545/).
Я бы хотел подробно рассказать о том, как проводить анализ на практике.
Как я уже упоминал, наиболее популярным средством, используемым для Байесовского анализа, является язык [R](http://www.r-project.org/) с пакетами [JAGS](http://mcmc-jags.sourceforge.net/) и/или [BUGS](http://www.openbugs.info/w/). Для рядового пользователя различие в пакетах состоит в кросс-платформенности JAGS (на собственном опыте убедился в наличии конфликта между Ubuntu и BUGS), а также в том, что в JAGS можно создавать свои функции и распределения (впрочем, необходимость в этом у рядового пользователя возникает нечасто, если вообще возникает). Кстати, отличным и удобным IDE для R является, например, [RStudio](http://www.rstudio.com/).
Но в этом посте я напишу об альтернативе R — Python с модулем [pymc](http://pymc-devs.github.com/pymc/).
В качестве удобного IDE для Python могу предложить [spyder](http://code.google.com/p/spyderlib/).
Я отдаю предпочтение Python потому, что, во-первых, не вижу смысла изучать такой не слишком распространенный язык, как R, только для того, чтобы посчитать какую-то задачку, касающуюся статистики. Во-вторых, Python с его модулями, с моей точки зрения, ничем не уступает R в простоте, понятности и функциональности.
Я предлагаю решить простую задачу нахождения коэффициентов линейной зависимости данных. Подобная задача оптимизации параметров довольно часто встречается в самых разных областях знаний, поэтому я бы сказал, что она весьма показательна. В конце мы сможем сравнить результат Байесовского анализа и метода наименьших квадратов
#### Установка ПО
Прежде всего нам надо установить [Python](http://www.python.org/download/) (для тех, кто этого еще не сделал). Я не пользовался Python 3.3, но с 2.7 все точно работает.
Затем нужно установить все необходимые модули для Python: [numpy](http://www.scipy.org/NumPy), [Matplotlib](http://matplotlib.org/).
При желании вы можете также установить дополнительные модули: [scipy](http://www.scipy.org/), [pyTables](http://www.pytables.org/moin), [pydot](http://code.google.com/p/pydot/), [IPython](http://ipython.org/) и [nose](https://nose.readthedocs.org/en/latest/).
Все эти установки (кроме самого Python) проще делать через [setuptools](https://pypi.python.org/pypi/setuptools).
А теперь можно установить собственно [pymc](https://github.com/pymc-devs/pymc) (его можно также поставить через setuptools).
Подробный гайд по pymc можно найти [тут](http://pymc-devs.github.com/pymc/).
#### Формулировка задачи
У нас есть данные, полученные в ходе гипотетического эксперимента, которые линейно зависят от некоторой величины x. Данные поступают с шумом, дисперсия которого неизвестна. Необходимо найти коэффициенты линейной зависимости.
#### Решение
Сперва мы импортируем модули, которые мы установили, и которые нам понадобятся:
```
import numpy
import pymc
```
Затем нам надо получить наши гипотетические линейные данные.
Для этого мы определяем, какое количество точек мы хотим иметь (в данном случае 20), они равномерно распределены на отрезке [0, 10], и задаем реальные коэффициенты линейной зависимости. Далее мы накладываем на данные гауссов шум:
```
#Generate data with noise
number_points = 20
true_coefficients = [10.4, 5.5]
x = numpy.linspace(0, 10, number_points)
noise = numpy.random.normal(size = number_points)
data = true_coefficients[0]*x + true_coefficients[1] + noise
```
Итак, у нас есть данные, и теперь нам надо подумать, как мы хотим проводить анализ.
Во-первых, мы знаем (или предполагаем), что наш шум гауссов, значит, функция правдоподобия у нас будет гауссова. У нее есть два параметра: среднее и дисперсия. Так как среднее шума равно нулю, то среднее для функции правдоподобия будет задаваться значением модели (а модель у нас линейная, поэтому там два параметра). Тогда как дисперсия нам неизвестна, следовательно, она будет еще одним параметром.
В результате у нас есть три параметра и гауссова функция правдоподобия.
Мы ничего не знаем о значениях параметров, поэтому a priori предположим их равномерно распределенными с произвольными границами (эти границы можно отодвигать сколь угодно далеко).
При задании априорного распределения, мы должны указать метку, по которой мы будем узнавать об апостериорных значениях параметров (первый аргумент), а также указать границы распределения (второй и третий аргументы). Все вышеперечисленные аргументы являются обязательными (еще есть дополнительные аргументы, описание которых можно найти в документации).
```
sigma = pymc.Uniform('sigma', 0., 100.)
a = pymc.Uniform('a', 0., 20.)
b = pymc.Uniform('b', 0., 20.)
```
Теперь надо задать нашу модель. В pymc сушествует два наиболее часто используемых класса: детерминистический и стохастический. Если при заданных входных данных можно однозначно определить значение(-я), которое(-ые) модель возвращает, значит, это детерминистическая модель. В нашем случае при заданных коэффициентах линейной зависимости для любой точки мы можем однозначно определить результат, соответственно это детерминистическая модель:
```
@pymc.deterministic(plot=False)
def linear_fit(a=a, b=b, x=x):
return a*x + b
```
И наконец задаем функцию правдоподобия, в которой среднее — это значение модели, sigma — параметр с заданным априорным распределением, а data — это наши экспериментальные данные:
```
y = pymc.Normal('y', mu=linear_fit, tau=1.0/sigma**2, value=data, observed=True)
```
Итак, весь файл model.py выглядит следующим образом:
```
import numpy
import pymc
#Generate data with noise
number_points = 20
true_coefficients = [10.4, 5.5]
x = numpy.linspace(0, 10, number_points)
noise = numpy.random.normal(size = number_points)
data = true_coefficients[0]*x + true_coefficients[1] + noise
#PRIORs:
#as sigma is unknown then we define it as a parameter:
sigma = pymc.Uniform('sigma', 0., 100.)
#fitting the line y = a*x+b, hence the coefficient are parameters:
a = pymc.Uniform('a', 0., 20.)
b = pymc.Uniform('b', 0., 20.)
#define the model: if a, b and x are given the return value is determined, hence the model is deterministic:
@pymc.deterministic(plot=False)
def linear_fit(a=a, b=b, x=x):
return a*x + b
#LIKELIHOOD
#normal likelihood with observed data (with noise), model value and sigma
y = pymc.Normal('y', mu=linear_fit, tau=1.0/sigma**2, value=data, observed=True)
```
Теперь я предлагаю сделать небольшое теоретическое отступление и обсудить, что же все-таки делает pymc.
С точки зрения матеметики, нам нужно решить следующую задачу:
p(a, b, sigma | Data) = p(Data | a, b, sigma)\*p(a, b, sigma) / p(Data)
Т.к. a, b и sigma независимы, то мы можем переписать уравнение в следующем виде:
p(a, b, sigma | Data) = p(Data | a, b, sigma)\*p(a)\*p( b)\*p(sigma) / p(Data)
На бумаге задача выглядит очень просто, но, когда мы ее решаем численно (при этом мы должны думать еще и о том, что мы хотим численно решить любую задачу такого класса, а не только с определенными типами вероятностей), то тут возникают трудности.
p(Data) — это, как обсуждалось в моем предыдущем [посте](http://habrahabr.ru/post/170545/), константа.
p(Data | a, b, sigma) нам определенно задана (то есть при известных a, b и sigma мы можем однозначно рассчитать вероятности для наших имеющихся данных)
a вот вместо p(a), p( b) и p(sigma) у нас, по сути, имеются только генераторы псевдослучайных величин, распределенных по заданному нами закону.
Как из всего этого получить апостериорное распределение? Правильно, генерировать (делать выборку) a, b и sigma, а потом считать p(Data | a, b, sigma). В результате у нас получится цепочка значений, которая является выборкой из апостериорного распределения. Но тут возникает вопрос, каким образом мы можем сделать эту выборку правильно. Если наше апостериорное распределение имеет несколько мод («холмов»), то как можно сгенерировать выборку, покрывающую все моды. То есть задача в том, как эффективно сделать выборку, которая бы «покрывала» все распределение за наименьшее количество итераций. Для этого есть несколько алгоритмов, наиболее используемый из которых [MCMC](http://en.wikipedia.org/wiki/Markov_chain_Monte_Carlo) (Markov chain Monte Carlo). [Цепь Маркова](http://ru.wikipedia.org/wiki/%D0%A6%D0%B5%D0%BF%D1%8C_%D0%9C%D0%B0%D1%80%D0%BA%D0%BE%D0%B2%D0%B0) — это такая последовательность случайных событий, в которой каждый элемент зависит от предыдущего, но не зависит от предпредыдущего. Я не стану описывать сам алгоритм (это может быть темой отдельного поста), но только отмечу, что pymc реализует этот алгоритм и в качестве результата дает цепь Маркова, являющуюся выборкой из апостериорного распределения. Вообще говоря, если мы не хотим, чтобы цепь была марковской, то нам просто надо ее «утоньшить», т.е. брать, например, каждый второй элемент.
Итак, мы создаем второй файл, назовем его run\_model.py, в котором будем генерировать цепь Маркова. Файлы model.py и run\_model.py должны быть в одной папке, иначе в файл run\_model.py нужно добавить код:
```
from sys import path
path.append("путь/к/папке/с/файлом/model.py/")
```
Вначале мы импортируем некоторые модули, которые нам пригодятся:
```
from numpy import polyfit
from matplotlib.pyplot import figure, plot, show, legend
import pymc
import model
```
polyfit реализует метод наименьших квадратов — с ним мы сравним результаты байесовского анализа.
figure, plot, show, legend нужны для того, чтобы построить итоговый график.
model — это, собственно, наша модель.
Затем мы создаем MCMC объект и запускаем выборку:
```
D = pymc.MCMC(model, db = 'pickle')
D.sample(iter = 10000, burn = 1000)
```
D.sample принимает два аргумента (на самом деле можно задать больше) — количество итераций и burn-in (назовем его «периодом разогрева»). Период разогрева — это количество первых итераций, которые обрезаются. Дело в том, что MCMC вначале зависит от стартовой точки (вот такое уж свойство), поэтому нам необходимо отрезать этот период зависимости.
На этом наш анализ закончен.
Теперь у нас есть объект D, в котором находится выборка, и который имеет различные методы (функции), позволяющие рассчитать параметры этой выборки (среднее, наиболее вероятное значение, дисперсию и пр.).
Для того, чтобы сравнить результаты, мы делаем анализ методом наименьших квадратов:
```
chisq_result = polyfit(model.x, model.data, 1)
```
Теперь печатаем все результаты:
```
print "\n\nResult of chi-square result: a= %f, b= %f" % (chisq_result[0], chisq_result[1])
print "\nResult of Bayesian analysis: a= %f, b= %f" % (D.a.value, D.b.value)
print "\nThe real coefficients are: a= %f, b= %f\n" %(model.true_coefficients[0], model.true_coefficients[1])
```
Строим стандартные для pymc графики:
```
pymc.Matplot.plot(D)
```
И, наконец, строим наш итоговый график:
```
figure()
plot(model.x, model.data, marker='+', linestyle='')
plot(model.x, D.a.value * model.x + D.b.value, color='g', label='Bayes')
plot(model.x, chisq_result[0] * model.x + chisq_result[1], color='r', label='Chi-squared')
plot(model.x, model.true_coefficients[0] * model.x + model.true_coefficients[1], color='k', label='Data')
legend()
show()
```
Вот полное содержание файла run\_model.py:
```
from numpy import polyfit
from matplotlib.pyplot import figure, plot, show, legend
import pymc
import model
#Define MCMC:
D = pymc.MCMC(model, db = 'pickle')
#Sample MCMC: 10000 iterations, burn-in period is 1000
D.sample(iter = 10000, burn = 1000)
#compute chi-squared fitting for comparison:
chisq_result = polyfit(model.x, model.data, 1)
#print the results:
print "\n\nResult of chi-square result: a= %f, b= %f" % (chisq_result[0], chisq_result[1])
print "\nResult of Bayesian analysis: a= %f, b= %f" % (D.a.value, D.b.value)
print "\nThe real coefficients are: a= %f, b= %f\n" %(model.true_coefficients[0], model.true_coefficients[1])
#plot graphs from MCMC:
pymc.Matplot.plot(D)
#plot noised data, true line and two fitted lines (bayes and chi-squared):
figure()
plot(model.x, model.data, marker='+', linestyle='')
plot(model.x, D.a.value * model.x + D.b.value, color='g', label='Bayes')
plot(model.x, chisq_result[0] * model.x + chisq_result[1], color='r', label='Chi-squared')
plot(model.x, model.true_coefficients[0] * model.x + model.true_coefficients[1], color='k', label='Data')
legend()
show()
```
В терминале мы видим следующий ответ:
Result of chi-square result: a= 10.321533, b= 6.307100
Result of Bayesian analysis: a= 10.366272, b= 6.068982
The real coefficients are: a= 10.400000, b= 5.500000
Замечу, что, так как мы имеет дело со случайным процессом, те значения, которые вы увидите у себя, могут отличаться от вышеприведенных (кроме последней строки).
А в папке с файлом run\_model.py мы увидим следующие графики.
Для параметра a:
Для параметра b:
Для параметра sigma:
Справа мы видим гистограмму апостериорного распределения, а две картинки слева относятся к цепи Маркова.
На них я сейчас заострять внимание не буду. Скажу лишь, что нижний график — это график автокорреляции (подробнее можно прочитать [тут](http://pymc-devs.github.com/pymc/modelchecking.html#convergence-diagnostics)). Он дает представление о сходимости MCMC.
А верхний график показывает след выборки. То есть он показывает, каким образом происходила выборка с течением времени. Среднее этого следа есть среднее выборки (сравните вертикальную ось на этом графике с горизонтальной осью на гистограмме справа).
В заключение я расскажу еще об одной интересной опции.
Если все же поставить модуль pydot и в файл run\_model.py включить следующую строку:
```
pymc.graph.dag(D).write_png('dag.png')
```
То он создаст в папке с файлом run\_model.py следующий рисунок:
Это прямой ацикличный граф, представляющий нашу модель. Белые эллипсы показывают стохастические узлы (это a, b и sigma), треугольники — детерминистические узлы, а затемненный эллипс включает наши псевдоэкспериментальные данные.
То есть мы видим, что значания a и b поступают в нашу модель (linear\_fit), которая сама по себе является детерминистским узлом, а потом поступают в функцию правдоподобия y. Sigma сначала задается стохастическим узлом, но так как параметром в функции правдоподобия является не sigma, а tau = 1/sigma^2, то стохастическое значение sigma сначала возводится в квадрат (верхний треугольник справа), и потом считается tau. И уже tau поступает в функцию правдоподобия, так же как и наши сгенерированные данные.
Я думаю, что этот граф весьма полезен как для объяснения модели, так и для самостоятельной проверки логики
модели. | https://habr.com/ru/post/170633/ | null | ru | null |
# Пишем свой Orm под Android с канастой и сеньоритами, Часть 3-я
#### Вступление
После некоторого перерыва в разработке моего приложения под **Android**, в течение которого в моей голове формировались все новые и новые идеи, как сделать его красивее и удобнее, в конце января я вновь уселся за разработку. За время размышлений подход к созданию приложения немного трансформировался, и посему до объектной модели я добрался только тройку недель назад. И почти сразу столкнулся с необходимостью доработки [UCAOrm](https://github.com/UCASoft/UcaOrm). Кому интересно узнать не только об уже внедренных нововведениях, но и о том, что еще только в процессе разработки —
#### Изменения и дополнения
Первое с чем я столкнулся: это необходимость в **ContentProvider**’е и в **Cursor**’е.
С **ContentProvider**’ом проблем особо не возникло — абстрактный **OrmContentProvider** наследуется от **ContentProvider**’а и реализует пока два метода: **query**, принимающий **OrmWhere** и возвращающий **OrmCursor**, и **update**, принимающий обновляемый экземпляр. **OrmCursor** же наследуется от **AbstractCursor** и, кроме реализации всех необходимых методов, реализует еще и метод **getEntities** — возвращающий **List** объектов. Самыми же интересными, с точки зрения реализации, являются функция **getColumnNames**, которая возвращает массив имен колонок (функцию **getOrmFields** уже переделал), и приватная функция **getObject**, возвращающая значение указанной колонки. Данные классы намного упростили разработку аккаунта синхронизации.
Вторым нововведением стала поддержка новых типов полей: **boolean** и **int array**. Если с **boolean** все более-менее понятно, то про **array** расскажу немного подробнее. Сначала появилась идея создавать дополнительную таблицу с именем “*имя класса\_имя поля*” и одном единственным столбцом типа компонента массива. Однако, порассуждав, пришел к выводу, что массив с классом, наследуемым от **OrmEntity**, рушит всю архитектуру, а любой другой не примитивный тип разработчику все равно придется сериализавать вручную. Отсюда и решил, что **orm** будет поддерживать только массивы примитивных типов, которые отлично сериализуются в строку и также отлично десериализуются обратно. Проблемы, разве что, могут возникнуть с **double**, формат которого в виде строки может содержать запятую, являющуюся разделителем элементов массива, но они легко решаются жесткой установкой локали в **English**.
Так же, наконец добрался до реализации метода **getDefaultValues** в наследнике **OrmHelper**’а. Теперь он выглядит так:
```
@Override
public void getDefaultValues(Class extends OrmEntity entityClass, List valueList) {
}
```
соответственно, добавление значений по умолчанию для нашей любимой модели из [второй](http://habrahabr.ru/post/187526/) части будет реализовано так:
```
public void getDefaultValues(Class extends OrmEntity entityClass, List valueList) {
if (entityClass.equals(CarType.class)) {
valueList.add(new CarType("Passenger"));
valueList.add(new CarType("Truck"));
}
}
```
Ну, а теперь мы подобрались к самой вкусной проблеме, о которой говорил [hardex](http://habrahabr.ru/users/hardex/) еще в [первой](http://habrahabr.ru/post/186078/#comment_6472516) статье — обновление схемы данных.
#### Обновление схемы данных
Опять же, вернемся к нашей модели и рассмотрим сущность **Car**:
```
@Table(rightJoinTo = {Truck.class})
public class Car extends BaseEntity {
@Column(name = "car_type")
private CarType type;
@Column
private List wheels;
@Column(name = "engine\_power")
private int enginePower;
@Column(name = "doors\_count")
private int doorsCount;
}
```
Предположим, что мы решили добавить еще одно поле:
```
@Column(name = "max_speed")
private int maxSpeed;
```
В этом случае нам надо изменить версию базы в manifest’е:
```
```
И написать код в методе **onUpdate helper**’а:
```
@Override
protected void onUpgrade(int oldVersion, int newVersion) {
if (newVersion == 2) {
OrmUtils.UpdateTable(Car.class).work();
}
}
```
“*А зачем еще нужен метод **work**?*” — спросит кто-то. А давайте рассмотрим возможные варианты изменения схемы данных:
1. В схему добавляется новое поле.
2. Из схемы удаляется поле.
3. Поле переименовывается.
4. У поля изменяется тип.
Скорее всего, многие уже догадались, что единственный пункт, не вызывающий сложностей — первый, но рассмотрим их по порядку.
##### Добавления поля
Тут все легко: **orm** выгребает поля из таблицы и сравнивает с полями из класса. Когда находится новое поле в объектной модели, для него дергается
```
ALTER TABLE … ADD COLUMN …
```
Если нужно будет значение по умолчанию, то его нужно будет указать в аннотации.
##### Удаление поля
Начало алгоритма схоже с предыдущим: сравниваем поля и находим те, которые надо удалить. Ну, а дальше, почти, как указано в [faq’е](http://www.sqlite.org/faq.html#q11). Единственно, не понимаю, зачем нужно второе копирование, ведь после того, как **drop**’нули таблицу, временную можно просто переименовать, и она станет постоянной!
##### Переименование поля
А вот тут **work** вам не помощник! **Orm** просто-напросто не поймет, что вы просто переименовали поле, и сделает два действия: удалит поле со старым именем из базы и добавит новое с новым. Конечно, это так же можно было обыграть в аннотации, добавив поле **old\_name**, но мне показалось, что это уже слишком, да и **orm** можно разгрузить, точно указывая ему, что делать. В свете вышеизложенного в данном абзаце, нам нужен метод **rename**:
```
OrmUtils.UpdateTable(Car.class).renameColumn("old_column_name", "new_column_name");
```
Заметьте, что нужно указывать именно имя колонки, а не поля! В результате, **orm** не будет шерстить весь класс и все поля в базе, чтобы понять, что ему надо изменить, а просто сделает изменения имени одной единственной колонки.
Так же, мы можем помочь ему добавить колонку:
```
OrmUtils.UpdateTable(Car.class).addColumn("column_name");
```
и удалить колонку:
```
OrmUtils.UpdateTable(Car.class).deleteColumn(“column_name”);
```
Само же переименование в виде **sql** запроса вызвало некоторые вопросы. Сначала я решил это, как и удаление, созданием новой таблицы с нужным именем поля, куда копируются данные из старой, и она просто удаляется, а новая — переименовывается. Но потом, я наткнулся на [эту](http://www.gfairchild.com/2012/08/03/how-to-rename-columns-in-an-sqlite-database/) статью и планирую попробовать этот метод.
##### Изменение типа поля
**Orm** опять же все может сделать за Вас, но можно ему и помочь:
```
OrmUtils.UpdateTable(Car.class).changeColumnType("column_name");
```
В принципе, вторым параметром можно было бы еще передать и новый тип колонки, но давать возможность программисту указать не тот тип, а потом ругать **orm** (:-)) мне не хотелось. Проблему же несовместимости данных старого типа и нового решает сама база, бросив исключение при копировании старой таблицы в новую. Но колонку можно и просто обнулить, передав в качестве второго параметра **true**:
```
OrmUtils.UpdateTable(Car.class).changeColumnType(“column_name”, true);
```
Еще в замысле был параметр, который указывает на то, что обнулить поле надо только в случае несовместимости типов, но пока делать не стал.
#### Заключение
Вот таким изменениям подвергся [UCAOrm](https://github.com/UCASoft/UcaOrm) за последние две недели. В [github](https://github.com/) выложено еще не все, так как, как и писал чуть выше, работа над **Updater**’ом еще ведется, и еще не все протестировано. Так же есть задумка немного упростить первоначальное создание таблиц: просто вызвав метод **createByPackeg** у **OrmUtils**, передав туда имя пакета, в котором **orm** будет искать помеченные классы. Но это пока только задумка.
Как всегда буду рад любом новым идеям и предложениям. Ждите обновления в ближайшее время. | https://habr.com/ru/post/216419/ | null | ru | null |
# Как научиться работать в Blazor, делая что-то полезное. Часть II
Как я сказал в [первой части](https://habr.com/ru/company/first/blog/583042/) этой статьи, мы решили написать систему, которая преобразует команды для отправки многочисленных инструкций на различные IoT реле на Blazor. Где по-быстрому, практически на коленке собрали отличную систему работы с этими реле. Всё было просто замечательно и быстро! Но не всё было так просто, как обещали.
Теперь давайте погрузимся в тёмный лес странных вещей, с которыми пришлось разбираться в Blazor. Естественно, технология не самая новая, и на Stackoverflow с большинством описанных проблем более-менее разобрались. Местами остался неприятный осадок, местами — недопонимание.
Итак, подводные камни Blazor, на которые вы наткнётесь в ваших проектах.
Камень 1 — WASM
---------------
Практически самая бесполезная часть работы с Blazor. Почему? Потому что итоговый размер бинарника поражает воображение. Во время дебага приложения я залез в консоль и увидел, что конечный размер всех бинарников превысил 15 мегабайт. После запуска релиза размер был взят под контроль и составил 7 мегабайт.
В принципе, если мы говорим о том, что вы выпускаете приложение во внутрикорпоративной сети, и клиенты в конце концов закешируют сам WASM, то можно отмахнуться. Но для запуска чего-то подобного для мобильных пользователей размер бинарников может быть намного более устрашающим.
Конечно, существуют способы для уменьшения размера выходного бинарника, например, [вот тут](https://www.meziantou.net/optimizing-a-blazor-webassembly-application-size.htm). Но тут уж очень сомнительные приёмы. Например, вырезание информации о временных зонах, которые обычно используются в приличных приложениях. С учётом всех ужимок можно спустить размер бинарника до четырёх мегабайт.
Но при всём при этом, если писать на [vugu](https://www.vugu.org/)(golang), то можно начать с 3-х мегабайт и жать до одного.
Так что сама разработка на подобном фреймворке — это что-то, что должно происходить после долгого и основательного обдумывания. Опять же, даже если мы переключим наше приложение в режим server-side, то оно не будет по-человечески работать без стабильного канала. А если связь выпадает один раз и что-то не рендерится, то приложение вылетает по полной программе и страницу надо будет перезагружать. При этом теряется весь стейт приложения.
Итак, заключение: WASM в Blazor хоть и есть, но является одним из самых тяжеловесных фреймворков, которые существуют на рынке.
Камень 2 — Razor
----------------
Название Blazor происходит от Razor. И хотя сам Razor (2010) намного старше Blazor (2018), в нём есть определённые, мягко выражаясь, странности.
Например, очень странно видеть, как такой, казалось бы, достаточно старый движок, непростительно относится к мелким ошибкам в коде. Один пропущенный символ @ приводит к абсолютно полному пересмотру всего кода страницы. Причём это никак не сообщается в процессе разработки. VSCode вообще об этом умалчивает (и подсвечивает код, как будто он написан правильно), а Visual Studio просто перестаёт подсвечивать код как код, и показывает его как текст.
Причём во время сборки все опять молчат, как партизаны, но зато вы увидите хороший дамп во время дебага.
Для людей, пришедших в разработку с React, это будет очень раздражительно.
**Вывод?** За Razor нужен глаз да глаз. Пишите бога ради, но обязательно проверяйте, что вы написали, потому что очепятки останутся незамеченными без хорошего тестирования.
Камень 3 — Общение компонентов
------------------------------
Как и в React, в Blazor существует понятие о том, что такое компоненты. И действительно, лично для меня в обоих языках компонентная система была самой используемой фичей. Но при всём при этом компоненты в Blazor намного более необщительные, чем в React.
Если я меняю строку поиска в компоненте поиска и хочу отобразить новые результаты в списке результатов на той же странице, то приходится [доставать бубны](https://chrissainty.com/3-ways-to-communicate-between-components-in-blazor/).
В React с этим не всё так гладко, но всё же, есть намного больше способов общаться между компонентами. Существуют Overmind, MobX и старый добрый Redux. В Blazor такого пока что не наблюдается. Приходится использовать свои собственные костыли или просто смириться с существующей системой компонентов.
Итогом этих поисков стал отдельный компонент под названием Refresher, который создавал виртуальные каналы. На эти каналы подписывались компоненты. При вызове события на канале все подписанные компоненты обновлялись. Немного странно и непривычно, но можно было жить.
Конечно, альтернативным вариантом было бы написание различных страниц и просто пропуск функционала обновления одних компонентов из других компонентов. Но это как-то бедно, я бы сказал.
**Выводы:** Прекрасное общение между компонентами нужно будет реализовывать руками.
Камень 4 — Жизненный цикл
-------------------------
И борьба с этим жизненным циклом. Если вы пришли из мира MVC, то вы наверняка знаете, что существуют различные стадии жизненного цикла страниц и компонентов. В Blazor незнание и непонимание любых аспектов жизненного цикла просто фатально.
Казалось бы, что может быть проще? У тебя есть компонент, который хочет подписаться на события в начале своего жизненного цикла и отписаться от них в конце этого цикла.
Прекрасно, так и сделаем.
```
async protected override Task OnInitializedAsync()
{
Refresher.Subscribe("ReBlaze.Pages.Devices", () =>
{
UpdateDb().Wait();
InvokeAsync(StateHasChanged);
});
await UpdateDb();
await base.OnInitializedAsync();
}
public void Dispose()
{
Refresher.Unsubscribe("ReBlaze.Pages.Devices");
Context?.Dispose();
}
```
И тут мы начинаем влетать в очень интересные дебри и проблемы. Сразу же стало понятно, что что-то не так, когда в SQL профайлере начали появляться двойные запросы в базу данных, а компонент по обработке подписок оказался постоянно поломанным из-за переподписок.
Пришлось лезть и разбираться, и в итоге после недолгих поисков был найден виновник. Им оказался тот ученик, который не сел и не изучил систему обработки жизненного цикла от начала и до конца. Естественно, жизненный цикл будет разным для WASM и Server-side приложения. Это да.
Но он в том числе будет разным для Server-side и Server-side. Чего? Ну да, мы как бы забыли вам сказать, и вы с этим встретитесь в мануалах, но чуть глубже. У нас есть два варианта Server-Side Blazor, один из них это Server Pre-Render. Этот замечательный вариант обработки будет рендерить страницу на сервере, чтобы она была. Это сделано для совместимости с поисковиками и для того, чтобы страница быстрее доставлялась на клиент при первом открытии.
Когда пользователь обращается к странице в первый раз, мы её рендерим на сервере и отсылаем на сторону пользователя. А когда она отобразится, то специальный javascript дозагрузит все необходимые компоненты, и страница начнёт работать. Всё замечательно, но при этом мы ещё раз запустим ваше событие OnInitialized. Ну так, чисто чтобы поржать.
**Что мы получаем в итоге?**
Жесть и безобразие. Страницы, которые неправильно отображают пустые компоненты, двойные запросы и поломанные менеджеры состояния.
После того как все уже были сыты по горло этими проблемами, я удалил из репозитория весь код, связанный с системой событий, и отправил всех читать мануалы на два дня.
После такого жёсткого обращения с детьми у нас появилось представление о том, что да как надо делать, и как правильно обрабатывать события жизненного цикла.
Ввиду того что приложение было локальным, мы просто отключили Server-Sider Pre-render и пошли простым путём.
**Выводы:** Если вы изучаете Blazor, ни в коем случае не пропускайте никаких материалов о том, как работать с жизненным циклом. Такие материалы просто жизненно необходимы для понимания того, как писать программу.
Камень 5 — Сообщество
---------------------
Оно есть, но оно очень вялое. Естественно, когда вы придёте в сектор корпоративной разработки на Blazor из мира npm, то вы решите, что всё вообще заброшено.
На Blazor написана одна и большая CMS под названием [oqtane](https://github.com/oqtane/oqtane.framework). Система позволяет писать свой код на Blazor и при этом более-менее по-человечески управлять контентом. С точки зрения разработки, выглядит это просто жестоко.
При создании плагина для Oqtane вам нужно будет установить саму CMS, после чего вам нужно будет создать сайт и в нём уже создавать плагин. Результатом создания плагина будет новый Solution, который надо будет открывать в VS и продолжать писать этот плагин.
Сомнительное удовольствие. Сам Oqtane пушится повсюду его создателем, и хотя коммиты делаются до сих пор, выглядит CMS в лучших традициях 2016 года.
**Вывод?** Самый лучший способ выучить Blazor — это либо прочитать инструкцию, либо взяться за толковый талмуд, учить методом тыка его не стоит. Он к этому очень непростителен.
Выводы
------
Что мы имеем? Что-то такое очень интересное. Попытка взять первое место в мире подобных фреймворков идёт в никуда. Если в 2019 году я ещё видел статьи о том, что Microsoft наконец-то выпустила убийцу React, то в 2021 году подобных статей поубавилось, да и хайпа не так много.
В итоге у нас получилась очень хорошая система для тех, кто работает в корпоративном секторе. Blazor как нельзя лучше подойдёт для внутрисетевых веб-сайтов, которые будут подгружать корпоративные данные и показывать их на экране. Портирование уже существующего C# кода на Blazor и WASM не займёт много времени. Поддержка компилирования на очень высоком уровне. И да, вы сможете напрямую использовать .NET WASM, он компилируется и очень даже стабилен. Естественно, определённые вещи в WASM недоступны, но обычная бизнес-логика переносится за секунды.
Плюс, Blazor очень легко встроить в уже существующие .NET проекты. С этим особых проблем нет.
Писать 3Д игру в браузере на Blazor? Нет, всё же лучше не стоит. Если уж очень хочется таким заниматься, то добро пожаловать в мир Rust. [Yew](https://yew.rs/) вам в помощь. Тут мы получаем намного более компактные бинарники. Или, если хочется, вот вам C++ [awesome-wasm](https://github.com/mbasso/awesome-wasm).
С другой стороны, в мире WASM фреймворков высокоуровневых языков .NET является самым продвинутым. [pyodide.org](https://pyodide.org/) и [vugu.org](https://vugu.org/) ещё не видели такой поддержки, как .NET. Только вот в этом и заключается загвоздка. .NET, golang, python — это языки, изначально разработанные для другой платформы, нежели WASM. И хотя мы и научили их компилироваться прямо в окно браузера, выглядят эти фреймворки очень даже сомнительно, в основном потому что тянут за собой наследие платформ, для которых они разрабатывались.
Хотя, несомненно, Server-Side Blazor лишён этих недостатков и просто является большой утилитой по сокрытию огромного количества подлежащего кода, который служит для выполнения ваших инструкций.
При наличии хорошего стабильного канала, эта утилита работает более чем прилично.
Учить Blazor стоит, но только если вы уже погружены в инфраструктуру .NET и готовы с ней работать. Начинать новый сервис можно и на более распространённых языках. Возьмитесь лучше за изучение TS и React.
---
НЛО прилетело и оставило здесь промокоды для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**.
[— 20% на выделенные серверы AMD Ryzen и Intel Core](https://1dedic.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=coreryzen20#server_configurator) — **HABRFIRSTDEDIC**.
Доступно до 31 декабря 2021 г. | https://habr.com/ru/post/584836/ | null | ru | null |
# Развертываем свой сайт на Heroku
Здравствуй, Хабрахабр! Недавно у меня возникла необходимость развернуть свое Rails web-приложение на Heroku и я, к своему удивлению, не нашел почти ничего об этом на просторах не только Хабра, но и рунета в целом, поэтому я решил поделиться с вами своим опытом. Подробности о том, что и как я делал находятся под катом!
Сегодня я расскажу о том, как быстро и легко задеплоить свое приложение на Heroku. Если статья вызовет интерес я напишу продолжение о том, как быстро и удобно «перевести» приложение на свой домен и несколько советов о самом приложении, связанных с этим.
---
#### Развертывание приложения на Heroku
##### Регистрация
Первым делом вам будет необходимо [зарегистрироваться на Hreoku](https://id.heroku.com/signup). После того, как вы подтвердите свой e-mail нужно будет заполнить еще немного данных в своем профиле. В общем, ничего сложного, ничего необычного.
##### Вход в свой профиль и инициализация git-репозитория
###### Установка Heroku Toolbelt
Первым делом необходимо установить ПО для командной строки от Heroku на свой компьютер, если вы еще этого не сделали. Для Ubuntu и Debian процесс установки заключается в выполнении следующей команды:
```
user@host:~/rails/myapp$ wget -qO- https://toolbelt.heroku.com/install-ubuntu.sh | sh
```
Для остальных дистрибутивов Linux — этой:
```
user@host:~/rails/myapp$ wget -qO- https://toolbelt.heroku.com/install.sh | sh
```
Честно говоря, я не знаю отличаются ли эти скрипты чем-либо. Пользователи же Windows и OS X могут скачать установочные файлы [здесь](https://toolbelt.heroku.com/).
###### Вход в профиль с командной строки
После того, как весь необходимый инструментарий установлен, вам необходимо залогиниться в Heroku с командной строки:
```
user@host:~/rails/myapp$ heroku login
Enter your Heroku credentials.
Email: user@example.com
Password:
Could not find an existing public key.
Would you like to generate one? [Yn]
Generating new SSH public key.
Uploading ssh public key /home/user/.ssh/id_rsa.pub
```
Если вы еще не генерировали открытый ключ для SSH то вам будет предложено это сделать.
###### Инициализация git-репозитория
Если вы не используете систему контроля версий или используете, но отличную от git то вам придется создать локальный git-репозиторий на своем рабочем компьютере т.к. Heroku поддерживает только эту систему контроля версий. Все очень просто:
```
user@host:~/rails/myapp$ git init && git commit -am "init"
```
##### Некоторые специфические моменты
Чтобы ваше web-приложение корректно работало необходимо добавить `rails_12factor` в ваш Gemfile (если вы использует Rails 4) и там же указать версию ruby (для всех версий Rails):
```
gem "rails_12factor", group: :production
#
# Другие ваши gem-ы
#
# Версию Ruby следует указывать в конце файла
ruby "2.1.2"
```
Обратите внимание, вы должны использовать эту же версию Ruby и у себя.
Если вы используете web-сервер отличный от WEBrick (Thin в моем случае), что, кстати, рекомендуется самим сервисом Heroku, то вам необходимо будет создать так же Procfile приблизительно следующего содержания:
```
web: bundle exec thin start -p $PORT
```
##### Последние штрихи
Наша работа по запуску web-приложения практически подошла к концу, остались последние штрихи. Далее будет предполагаться что вы используете PostgreSQL в качестве СУБД. Если вы используете MySQL — [немного ниже я рассказал о том, как подружить эту СУБД с Heroku](#MySQL). Итак, создадим приложение в Heroku:
```
user@host:~/rails/myapp$ heroku create myapp
Creating myapp... done, stack is cedar
http://myapp.herokuapp.com/ | git@heroku.com:myapp.git
Git remote heroku added
```
Вообще говоря, вы можете и не указывать имя приложения при создании, тогда Heroku сама выдумает вам что-то вроде `deep-sea-69`.
Теперь ваше приложение доступно по адресу `myapp.herokuapp.com`, но там пока ничего нет. Чтобы это исправить необходимо запушить ваше приложение на сервер Heroku:
```
user@host:~/rails/myapp$ git push heroku master
```
Возможно вам понадобится сделать asset precompile чтобы все работало нормально (лично мне пришлось, если кто-то подскажет как заставить Heroku делать все в автоматическом режиме — буду благодарен):
```
user@host:~/rails/myapp$ rake assets:precompile RAILS_ENV=production
```
После этого выполните все миграции…
```
user@host:~/rails/myapp$ heroku run rake db:migrate
```
…и можете посмотреть что же у вас получилось:
```
user@host:~/rails/myapp$ heroku open
```
###### Дружим Heroku и MySQL
Так сложилось, что для Rails более традиционной является PostgreSQL, эта СУБД является так же «родной» для Heroku. Но может так произойти, что вы используете другую популярную СУБД — MySQL. Тогда для корректной работы вашего приложения необходимо совершить еще несколько телодвижений. Не бойтесь, они достаточно просты!
Для достижения цели мы будем использовать дополнение `ClearDB`. Установим его и получим данные о выделенной нам БД:
```
user@host:~/rails/myapp$ heroku addons:add cleardb:ignite
-----> Adding cleardb to sharp-mountain-4005... done, v18 (free)
user@host:~/rails/myapp$ heroku config | grep CLEARDB_DATABASE_URL
CLEARDB_DATABASE_URL => mysql://adffdadf2341:adf4234@us-cdbr-east.cleardb.com/heroku_db?reconnect=true
```
Далее просто установим полученный адрес в качестве `DATABASE_URL` в Heroku, при необходимости изменив протокол на mysql2:
```
user@host:~/rails/myapp$ heroku config:set DATABASE_URL='mysql2://adffdadf2341:adf4234@us-cdbr-east.cleardb.com/heroku_db?reconnect=true'
```
Вот и все! На этом мое повествования заканчивается. Это мой первый пост на хабре, так что я буду очень благодарен за любые замечания по стилю и оформлению и, конечно же, я буду рад ответить на ваши вопросы в комментариях! | https://habr.com/ru/post/232679/ | null | ru | null |
# DevConf 2015 — финальное голосование за доклады. Сделаем программу лучше и полезней
Коллеги — до конференции DevConf 2015 осталось меньше 2-х недель — [помогите выбрать достойные доклады](http://devconf.ru/offers/).
[](http://devconf.ru/offers/)
В этом году у нас добавилась секция [**DevOps**](http://devconf.ru/offers/devops) — было много заявок на нее — решили вынести в отдельный поток.
Список секций: **DevOps, Storage, PHP, Python, Ruby, Javascript, Common**
[**ГОЛОСУЕМ ЗА ДОКЛАДЫ ДО 8 ИЮНЯ!**](http://devconf.ru/offers/)
**КОНКУРС № 1:**
Традиционно открываем конкурс на интересные идеи значков для участников секций Storage и DevOps
Предлагайте идеи в этом топике — 3 авторам лучших идей — [бесплатная проходка на основной день](http://devconf.ru/members/) DevConf 2015 — 19 июня!
**КОНКУРС №2:**
Каждый день c 5 по 8 июня будем разыгрывать 1 проходку на основной день за репост в социальных сетях и в твиттер:
```
Хочу на DevConf 19 июня! с тегом #devconf_ru
``` | https://habr.com/ru/post/259593/ | null | ru | null |
# Спасение раздела в Debian, когда пошло, что-то не так
Добрый день, уважаемые!
Я вам раскажу исторую, которая могла привести к полной потери данных на виртуальной машине, но выход из ситуации все же был найден при помощи: parted
**Исходные данные:**
**ОС:** Debiab 9 64bit
**ФС:** ext4 без LVM
**Цель:** Расширить ФС на виртуальной машине с 14Гб до 60Гб
В принципе для админа это задача является тривиальной, но иногда звезды могут сойтись так, что все идет не так, как хотелось бы. Под катом я постараюсь восстановить ход событий, который привел к тому, что первый админ получил почти не рабочую ВМ.
**День 1:**
Перед админом была поставлена вполне простая задача — нужно расширить размер ФС на VM. Предварительно уже были проведены работы по расширению образа диска для этой VM и поэтому дело оставалось за малым — расширить размер ФС на VM.
**Структура ФС на VM:**
/boot — 56Mb
/ — все оставшеее место — ext4
Так как виртуальная машина создается из шаблона, то отсутствует LVM, которое конечно же упростило бы всю процедуру.
И так админ в четверг вечером приступает к исполнению задачи. Первым его шагом было загрузка VM с использование iso-образа — SystemRescue. После успешной загрузки VM с помощь iso-образа админ приступает к работе и при помощи fdisk удаляет раздел **/ (/dev/vda2)**, что является правильным так как именно его необходимо расширить. После удаления раздела (/dev/vda2) админ создает новый раздел — /dev/vda2 и тут случается первая ошибка — админ создает сначала extened партицию и уже потом создает primary и сохравнив новую разметку выходит из fdisk и пытается смонтировать раздел:
Так как разметка диска изменилась и изменились начало и конец раздела /dev/vda5, то появилась ожидаемая ошибка, о том, что не найден или ошибочный superblock. Ошибка вполне серьёзная и если подойти к решению не так, то можно потерять файлы или получить их битыми. Можно конечно откатиться назад, но проблема заключается еще и в том, что админ перед своими работами не сделал скриншот предыдушей разметки диска.
Так как раздел не может быть смонтирован… админ предпринимает попытку исправить ситуацию путем удаления созданных им партиций и создания уже новой primary, но как он не значает окончания партции с данными, то все его попытки приводят к одному результату:
**Superblock invalid**.
После нескольких попыток восстановить раздел своими силами первый админ просить помощи у второго админа.
Первым делом второй админ оставливает VM и копирует текущий образ диска с именем vm\_bad\_disk. Далее поднимается VM с такой же версий ОС — Debian 9 64bit и покдлючает вторым диском — vm\_bad\_disk.
Зайдя в новую VM через ssh — смотрим листинг дисков в VM:
`root@recovery:~# fdisk -l
Disk /dev/vda: 4.9 GiB, 5242880000 bytes, 10240000 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0x09dea38e
Device Boot Start End Sectors Size Id Type
/dev/vda1 * 2048 499711 497664 243M 83 Linux
/dev/vda2 501758 10237951 9736194 4.7G 5 Extended
/dev/vda5 501760 10237951 9736192 4.7G 83 Linux
Disk /dev/vdb: 58.6 GiB, 62914560000 bytes, 122880000 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0xe8c76303
Device Boot Start End Sectors Size Id Type
/dev/vdb1 * 2048 194559 192512 94M 83 Linux
/dev/vdb2 196606 30717951 30521346 14.6G 5 Extended
/dev/vdb5 198656 30717951 30519296 14.6G 83 Linux`
Вот /dev/vdb — это и есть наш vm\_bad\_disk. Первым дело второй админ удаляет /dev/vdb2 и /dev/vdb5 и пытаемся создать /dev/vdb2 с началось 194560 и примерным концом, но так же получает:
**Superblock invalid**.
Для работы с разделом /dev/vdb — ставится parted утилита для более удобной работы с разделом.
Повторяем действие с удаление /dev/vdb2 уже в parted и делаем help.
Внимание админа привлекает команда rescue, которая возволяет задав начало и конец партиции найти на ней ФС. Ничего сложного в синтаксисе команды нет:
Просто наберите в parted:
> rescue
Система спросит:
Start — тут было указано 194560
Теперь админу необходимо расчитать End (конец партиции). Так как изначально админу известно, что размер всего диска был 14Гб и что 1 сектор это 512 байт… то делаются следующие расчеты:
14 ГБ это примерно 15032385536 байт, расчитываем количество секторов:
15032385536 / 512 = 29360128
Вот это значение и необходимо указать в parted:
End 29360128
Нажимайте смело Enter и ждите результата… В данном случае ждать пришлось не долго и parted выдало — что ФС найдено и стоит ли сделать изменения — отвечаем ДА
Parted произведет необходимые измения и админ выходит из parted.
Админ возращается в командную строку системы и делает:
**mount /dev/vdb2 /mnt**
Раздел монтируется без каких либо проблем и показывает — что его размер около 14Гб, что правильно, так расширение ФС еще не производилось. Админ бегло провяряет файлы и все говорит о том, что артефактов и битых файлов на первый взгляд нету.
Так как раздел выглядит живым админ делает: **umount /dev/vdb2** и запускает:
**e2fsck /dev/vdb2** после окончания проверки — запускает команда для расширения раздела:
resize2fs /dev/vdb2
Операция проходит без каких-либо проблем и админ монтирует еще раз раздел, чтобы убедиться, что все ОК:
**mount /dev/vdb2 /mnt**
Раздел монтируется без ошибок и при помощи команды **df -р** видит уже расширенный раздел.
Админ еще раз проверяет файлы и директории на данной партции и принимает решение, что с ФС и файлами все ОК.
Админ выполняет команду: shutdown -p now и удаляет привязанный диск с VM, с которой производились действия.
Сохраняет изначальный образ диска VM, с которой все начиналось в отдельном хранилище и заменяет его правленным образом диска и отправляет VM на загрузку.
VM загружается без каких-либо проблем и все данные на месте.
**Мораль:**
1) Сделайте SnapShot перед своими действиями
2) Сделайте скриншот нужных настроек (в данном случае разметки разделов)
3) Перед работами сделайте бэкап важных файлов | https://habr.com/ru/post/446252/ | null | ru | null |
# «65К методов хватит всем» или как бороться с лимитом DEX методов в Android
Это произошло внезапно. Только что вы писали код для своего приложения под андроид, вам это нравилось, и вы наслаждались процессом. Вы добавили крутую библиотеку чтобы получить дополнительные возможности и писать более простой код. Но вместо работающего приложения на выходе вы получаете ужасающую надпись:
`Unable to execute dex: method ID not in [0, 0xffff]: 65536`
`Conversion to Dalvik format failed: Unable to execute dex: method ID not in [0, 0xffff]: 65536`
И вы в ступоре, вы неспособны создать DEX файл для APK. Вы не имеете ни малейшего представления о том, что это и как это исправить. И что бы вы не делали, оно будет приводить вас к самому логичному состоянию: **ПАНИКА**.
#### Знакомимся с врагом
После того, как вы попробовали все свои обычные трюки (в следующем порядке: чистка проекта, перезапуск IDE, сборка через командную строку, перезагрузка ноутбука, звонок другу и даже десятиминутный перерыв в надежде, что проблема исчезнет сама собой), вы вынуждены признать жестокую правду: проблема все еще здесь. Поэтому было бы неплохо узнать, что стало ее причиной.
В интернете множество постов об этой проблеме: [вот один из них](http://stackoverflow.com/questions/15209831/unable-to-execute-dex-method-id-not-in-0-0xffff-65536), [еще один](http://stackoverflow.com/questions/15508477/android-my-application-is-too-large-and-gives-unable-to-execute-dex-method-id), [и еще один](http://stackoverflow.com/questions/15436956/how-to-solve-the-issue-with-dalvik-compiler-limitation-on-64k-methods); о, а так-же [этот](http://android-developers.blogspot.in/2011/07/custom-class-loading-in-dalvik.html) и [этот тоже](https://github.com/mmin18/Dex65536). Так что же произошло? По существу, выглядит, что вы столкнулись с чем-то, что часто (и ошибочно) называют Dalvik 65K methods limit. Кратко (спасибо [fadden](http://stackoverflow.com/a/21492160/1367571)):
*Вы можете ссылаться на очень большое число методов в DEX файле, но вызывать можете только первые 65536, потому что это вся память, которая у вас есть для инструкции вызова метода.*
*[...] ограничено число методов на которые вы можете сослаться, а не число определенных вами методов. Другими словами, если ваш DEX файл содержит всего несколько методов, но вместе они вызывают 70 000 различных внешне-определенных методов — вы превысите лимит.*
Что мы имеем? У вашего приложения слишком много методов, написанных вами или заключенных в библиотечных JAR файлах. По этой причине dx tool не может записать адреса некоторых методов просто потому, что они не помещаются в определенное для этого поле в DEX файле (который в свою очередь содержит скомпилированные Java классы). И именно поэтому проблема должна называться DEX 65K methods limit.
И да, вы все правильно поняли. Эта проблема не исчезнет даже когда андроид перейдет на новый ART рантайм, до тех пор пока Google не решит “поправить” формат DEX или не сменит его на что-то другое.
#### Давайте посчитаем
Вы наверное удивлены, как вы умудрились зарыть больше 65 000 методов в вашем драгоценном APK. А может и нет. В любом случае, должен быть способ для подсчета этих методов и определения их источника.
Заголовок DEX файла уже содержит информацию о числе ссылок на методы (для ясности, это число представляет уникальные ссылки на методы, а не сумму вызовов для каждого метода). Но мы также хотим видеть, какой пакет добавляет непомерное число этих методов.
Лучший, найденный мной инструмент, был сделан [Mihai Parparita](http://stackoverflow.com/users/343108/mihai-parparita), который написал простой bash скрипт, называющийся [dex-method-counts](https://github.com/mihaip/dex-method-counts). Скрипт очень шустрый и на выходе дает XML, который сопоставляет имя пакета с числом его методов. Другое решение принадлежит Jake Wharton, оно дает точно такой же результат, но требует намного больше времени из-за своей рекурсивной природы (Jake также написал [интереснейшую статью](http://jakewharton.com/play-services-is-a-monolith/) по этой теме).
Теперь у нас в руках есть хороший инструмент, так почему бы нам не проверить его на небольшом тестовом приложении? Назовем его SampleApp. Вот код, который содержится в нашей простой Activity:
```
package com.whyme.example;
import android.app.Activity;
import android.os.Bundle;
public class SampleActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
dummyMethod();
}
private void dummyMethod() {
System.out.println(“Oh gosh.”);
}
}
```
Я также включил в приложение Google Play Services 5.0.77, хотя я совсем не использую эту библиотеку. Смысл моего поступка прояснится несколькими строками ниже. Теперь давайте проанализируем вывод dex-method-counts (сжатый, для простоты):
```
Read in 20332 method IDs.
: 20332
: 2
android: 834
[…]
com: 18802
google: 18788
[…]
whyme: 14
example: 14
dalvik: 2
system: 2
java: 624
[…]
javax: 5
[…]
org: 63
apache: 24
[…]
json: 39
```
Подождите. ЧТО? Я всего лишь определил один метод в моей Activity и уже имею 20 000 методов в моем DEX файле?
Виновник очевиден.
#### Google Play Services: смешанные чувства
Есть ненулевая вероятность что вы знакомы с [Google Play Services](https://developer.android.com/google/play-services/index.html). Умный ход Google для поддержки API множества своих сервисов, вплоть до Android 2.3 Gingerbread, с новым релизом каждые шесть недель.
Однако все имеет свою цену, которая в данном случае явилась в виде ОГРОМНОГО числа методов которые Play Services несет в себе. Мы говорим приблизительно о 19 000 методов. И при лимите в 65536, это означает, что треть от всех методов, которые мы можем включить, уже исчерпана. Вот так.
Теперь, прежде чем мы перейдем к “решению” этой проблемы, я думаю будут уместны небольшие размышления. Некоторые разработчики как внутри, так и вне Google, разделяют общую точку зрения, которая гласит: “Если вы сталкиваетесь с ограничением, то вы плохой, очень плохой разработчик, вы заслуживаете наказания (а также вы должны гореть в аду)”. С более беспристрастной точки зрения это значит, что вы опрометчиво включили слишком много библиотек, то ли потому что вы слишком ленивы, то ли потому что ваше приложение делает слишком много. Лично я не разделяю эту точку зрения. Я считаю, что это просто оправдания для двух простых вещей:
1. Я не хочу признавать проблему / я не хочу исправлять ее.
2. Я не вышел за лимит, значит я крутой разработчик, а ты делаешь что-то не так.
Может быть, лимит был установлен из следующих соображений: “Этот лимит будет определять грань между хорошим и плохим программистом для всех будущих поколений. Да будет так.” Но что-то я в этом сомневаюсь.
#### Выбросьте все ненужное
В мире где справедливость торжествует, Google осознал глубину проблемы и решил сократить ущерб, который она наносит, разделив гигантский Play Services на модули, которые могут быть включены в зависимости от функциональности, которую использует ваше приложение. Например, если мое приложение не имеет отношения к играм, совершенно не имеет смысла включать в него все Play Games API. Это наиболее разумный ход, который можно предпринять и который возможно осуществить.
Однако Google не понимает в полной мере проблему, так что лучше мы найдем другой путь решения самостоятельно. Как было сказано, мы будем выбрасывать части google-play-services.jar, те части API, которые нам точно не понадобятся.
Для этого есть пара способов. Вы можете делать это вручную, но помните, что вам придется делать это каждые шесть недель.
Вы можете положиться на библиотеку [JarJar,](https://code.google.com/p/jarjar/) которая позволяет удалять желаемые пакеты из jar файла. Ясно и просто.
Если же вы, как и я, предпочитаете старую добрую командную строку, то вы можете использовать скрипт, который я использую для своих проектов, который называется (вы не поверите) [strip\_play\_services.sh](https://gist.github.com/dextorer/a32cad7819b7f272239b). Управлять работой скрипта можно с помощью конфигурационного файла strip.conf, который идет в комплекте. С помощью него вы можете выбрать модули Play Services Library, которые следует отключить. По существу скрипт делает следующее:
1. Извлекает контент из файла google-play-services.jar
2. Проверяет существует ли strip.conf, и если существует, то использует его для конфигурации, если же нет, то создает новый, записывая туда все модули из Play Services Library
3. Основываясь на strip.conf, удаляет ненужные модули из библиотеки
4. Перепаковывает оставшиеся модули в google-play-services-STRIPPED.jar файл
Вот простая конфигурация файла strip.conf:
> actions=true
>
> ads=true
>
> analytics=true
>
> appindexing=true
>
> appstate=true
>
> auth=true
>
> cast=true
>
> common=true
>
> drive=false
>
> dynamic=true
>
> games=false
>
> gcm=true
>
> identity=true
>
> internal=true
>
> location=false
>
> maps=false
>
> panorama=false
>
> plus=true
>
> security=true
>
> tagmanager=true
>
> wallet=false
>
> wearable=true
И все. Теперь для примера давайте посчитаем число методов нашего тестового приложения еще раз и посмотрим, что изменилось:
```
Read in 11216 method IDs.
: 11216
[...]
```
Это уже что-то. Подбирая подходящую конфигурацию, основываясь на нуждах вашего приложения, вы можете управлять “толщиной” Google Play Services и оставлять больше места для методов, которые вам (возможно) действительно нужны.
Но вы также должны быть очень осторожны. Play Services Library собрана очень хорошо (в плане модульности), и вы можете безопасно удалить модуль “games” не затронув при этом модуль “maps”. Но если вы удалите модуль, который используется другими (внутренний, проще говоря), то ничего не будет работать. Используйте метод проб и ошибок!
#### Есть ли другой путь?
Конечно есть. Запуск [ProGuard](http://developer.android.com/tools/help/proguard.html) для вашего приложения может помочь, так как он удаляет ненужные методы из вашего кода и в дополнение уменьшает размер APK. Но не ожидайте большого сокращения, этого не произойдет.
Другое решение заключается в создании второго DEX файла, который содержит часть вашего кода, доступ к которому вы будете осуществлять через интерфейсы/reflections и который вы будете грузить через кастомный ClassLoader ([подробнее](http://android-developers.blogspot.it/2011/07/custom-class-loading-in-dalvik.html)). Это решение может быть более эффективным в некоторых случаях. Однако этот путь очень нетривиален.
Я нашел еще одно решение моего хорошего друга [Dario Marcato](https://twitter.com/dmarcato). Он создал Gradle task для удаления ненужных модулей. Если вы используете Gradle, то обязательно [попробуйте!](https://gist.github.com/dmarcato/d7c91b94214acd936e42).
#### Послесловие
Это перевод оригинальной статьи [Sebastiano Gottardo](https://medium.com/@rotxed), [[DEX] Sky’s the limit? No, 65K methods is](https://medium.com/@rotxed/dex-skys-the-limit-no-65k-methods-is-28e6cb40cf71). Если перевод кажется вам «корявым» или вы нашли орфографические/синтаксические/фактические ошибки в тексте, пожалуйста, напишите мне в ЛС. | https://habr.com/ru/post/230665/ | null | ru | null |
# Попытка создать java Framework для телеграм ботов
У меня иногда появлялось желание делать ботов для телеграм, так мой основной язык Java - выбор не велик и он меня не устраивает. Каждый раз нужно было придумывать какие-то схемы обработки приходящих апдейтов и мучаться с этим всем. Либо был другой выбор - всякие непонятные Abilities / Replies, по которым нет информации нигде, а еще они используют внутри свою странную БД.
По этим причинам у меня в голове давно витает мысль сделать какую-то библиотеку / фреймворк, что бы можно было нормально и без мучений делать ботов. На данный момент уже есть небольшой framework, который работает и решает выше описанные проблемы. Он построен по принципу MVC. Есть контроллер, который обрабатывает данные, затем он передаёт модель во View, который уже отправляет сообщение пользователю, но это не обязательно и контроллер может сам отправить сообщение.Так же он поддерживает сессии и состояния.
Все это построено на Spring и работает как простая зависимость.
Демонстрация
------------
Для демонстрации способностей этого фреймворка напишем простой бот, который будет имитировать обращение в тех. поддержку интернет провайдера.
Бот будет использовать состояния и сессии, для того что бы их включить нужно добавить следующие параметры в `application.properties`
```
#Включить управление состояниями
slyrack.enableStateManagement=true
#Включить управление сессиями
slyrack.enableSessionManagement=true
#Задать время жизни сессии
slyrack.sessionTtlMillis=600000
```
Создадим бота:
```
@Component
@AllArgsConstructor
public class Bot extends TelegramLongPollingBot {
/*
* Основной компонент фреймворка, куда нужно передавать все апдейты
*/
private final UpdateHandler updateHandler;
@Override
public String getBotUsername() {
return "name";
}
@Override
public String getBotToken() {
return "token";
}
@SneakyThrows
@Override
public void onUpdateReceived(final Update update) {
updateHandler.handleUpdate(update, this);
}
}
```
### Первая команда
Комманда это метод, который аннотирован `@Command` Данный метод должен находится в классе аннотированом `@Controller` Аннотация принимает параметры:
* `UpdateType[] value` - типы апдейтов, на которые будет реагировать комманда. Это enum, который содержит некоторые типы апдейтов.
* `String[] state` - состояния, при которых будет срабатывать комманда.
* `boolean exclusive` - значит то что если команд-кандидатов на исполнение будет найдено несколько - будет выполнена только команда которая содержит в данном поле `true`
Метод-команда может возвращать `void` / `ModelAndView` / `StatefulModelAndView` на выбор. Метод-команда может принимать некоторые параметры на выбор:
* `Update`
* `AbsSender`
* `Session` - если включено управление сессиями, если нет - `null`
* `Model` - если включено управление состояниями и если было предшествующее состояние, в остальных случаях - `null`
* Любое кол-во параметров любого типа с аннотацией `SessionAtr`, если такой не найден - `null`
* Любое кол-во параметров любого типа с аннотацией `ModelAtr`, если не было предшествующего состояние или нету такого атрибута - `null`
Создадим первую команду, которая будет отвечать на любое сообщение и возвращает некоторое состояние и название view.
```
@Controller
public class InitController {
@Command(value = UpdateType.MESSAGE)
public ModelAndView start() {
return new StatefulModelAndView(
"subject-select-state",
"select-subject-view"
);
}
}
```
### Первый view
View это метод, который аннотирован `@View` Данный метод должен находится в классе аннотированом `@Controller` Аннотация `@View` принимает 1 параметр - название view.
Метод-view ничего не возвращает, т.е. `void` Метод-view принимает все те же параметры что и метод-команда с одним отличием - ей приходит модель не от состояния, а с предшествующей команды.
Создадим первый view с названием `select-subject-view`:
```
@ViewController
public class InitViews {
private static final String SELECT_SUBJECT = "Привествуем. Выберите тему вопроса.";
@SneakyThrows
@View("select-subject-view")
public void selectSubject(final AbsSender absSender,
@SessionAtr("chat-id") final String chatId) {
absSender.execute(SendMessage.builder()
.text(SELECT_SUBJECT)
.chatId(chatId)
.replyMarkup(InlineKeyboardMarkup.builder()
.keyboardRow(List.of(InlineKeyboardButton.builder()
.text("Оплата")
.callbackData("Оплата")
.build()))
.keyboardRow(List.of(InlineKeyboardButton.builder()
.text("Тарифы")
.callbackData("Тарифы")
.build()))
.keyboardRow(List.of(InlineKeyboardButton.builder()
.text("Интернет не работает")
.callbackData("Интернет не работает")
.build()))
.keyboardRow(List.of(InlineKeyboardButton.builder()
.text("Соединить с оператором")
.callbackData("Соединить с оператором")
.build()))
.build())
.build());
}
}
```
Здесь просто отсылается SendMessage с Inline клавиатурой. Но есть один момент - откуда взялся `chat-id` ? Пока что ему неоткуда взяться. С этого места мы переходим к последнему из основополагающих компонентов фреймворка.
### MiddleHandler
MiddleHandler это такая штука, которая может послужить в самых различных целях, допустим как в примере - первоначальной настройкой сессии. Аннотацией `@MiddleHandler` может быть аннотирован метод, который находится в классе аннотированом `@Controller`. Такой метод принимает все те же параметры что и метод-команда, но ничего не возвращает. Этот метод вызывается при каждом входящем апдейте, перед обработкой команд.
Создадим такой:
```
@Controller
public class SessionConfigurer {
@MiddleHandler
public void configureSession(final Update update, final Session session) {
if (session == null)
return;
if (!session.containsAttribute("chat-id"))
Util.getChatId(update)
.ifPresent(chatId -> session.setAttribute("chat-id", String.valueOf(chatId)));
if (!session.containsAttribute("user"))
Util.getUser(update)
.ifPresent(user -> session.setAttribute("user", user));
}
}
```
В данном методе мы устанавливаем 2 атрибута в сессию: `chat-id` и `user` если сессия существует и эти атрибуты ранее не были установлены. В дальнейшем мы можем их использовать по своему усмотрению.
### Добавление функций
Добавим в наш `InitController` метод обработки нажатий по Inline клавиатуре:
```
@Command(value = UpdateType.CALLBACK_QUERY, state = "subject-select-state")
public ModelAndView selectSubject(final Update update) {
return new StatefulModelAndView(
"enter-mobile-state",
"enter-mobile-view",
new Model("subject", update.getCallbackQuery().getData())
);
}
```
Эта команда будет обрабатывать только те апдейты, которые содержат CallbackQuery, и если пользователь имеет состояние `subject-select-state`. Возвращает она новое состояние и название view. Так же она сохраняет тему вопроса в модель. (в данном случае лучше это делать в сессию, но сделано так для демонстрации)
Можем еще добавить метод, который будет удалять входящие сообщения пока не была нажата кнопка на Inline клавиатуре:
```
@SneakyThrows
@Command(value = UpdateType.MESSAGE, state = "subject-select-state")
public void removeMessages(final Update update,
final AbsSender absSender,
@SessionAtr("chat-id") final String chatId) {
absSender.execute(DeleteMessage.builder()
.chatId(chatId)
.messageId(update.getMessage().getMessageId())
.build());
}
```
Теперь нужно добавить метод в `InitViews`, который будет обрабатывать новый view:
```
private static final String SUBJECT = "Тема вопроса: ";
private static final String ENTER_MOBILE_TEXT = "Введите ваш номер телефона для обратной связи.";
@SneakyThrows
@View("enter-mobile-view")
public void enterMobile(final Update update,
final AbsSender absSender,
@SessionAtr("chat-id") final String chatId) {
// answer callback select subject
absSender.execute(AnswerCallbackQuery.builder()
.callbackQueryId(update.getCallbackQuery().getId())
.build());
// edit select subject message
absSender.execute(EditMessageText.builder()
.text(SUBJECT.concat(update.getCallbackQuery().getData()))
.chatId(chatId)
.messageId(update.getCallbackQuery().getMessage().getMessageId())
.build());
// send enter mobile message
absSender.execute(SendMessage.builder()
.text(ENTER_MOBILE_TEXT)
.chatId(chatId)
.build());
}
```
Что делает данный метод:
* Отвечает на inline query как этого требует документация telegram bots.
* Редактирует сообщение с клавиатурой. Новое сообщение будет содержать выбранную тему вопроса.
* Отправляет новое сообщение с запросом ввести номер телефона.
Теперь нужно добавить метод в контроллер, который будет обрабатывать ввод номера телефона:
```
private static final Pattern MOBILE_PHONE_PATTERN = Pattern.compile("^\\d{5,12}$");
@Command(value = UpdateType.MESSAGE, state = "enter-mobile-state")
public ModelAndView enterMobile(final Update update, final Model model) {
if (update.getMessage().hasText()) {
final String text = update.getMessage().getText();
if (MOBILE_PHONE_PATTERN.matcher(text).matches()) {
model.setAttribute("mobile-phone", text);
return new StatefulModelAndView(
"support-dialog",
"start-support-dialog-view",
model
);
}
}
return new StatefulModelAndView(
"enter-mobile-state",
"enter-mobile-bad-view",
model
);
}
```
Проверка номера телефона здесь выполняется очень простой и *некоректной* регуляркой. В случае если апдейт содержит текст и он подходит под условие регулярного выражения - добавляется номер телефона в текущую модель и передаётся в новый view. В остальных случаях - состояние и его модель не изменяются, и вызывается view, который говорит о некорректности данных.
Добавим соответствующие view:
```
private static final String ENTER_MOBILE_BAD = "Вы ввели некорректный номер телефона, повторите попытку.";
private static final String START_DIALOG = "Специалист подключен. Напишите нам о вашей проблеме.";
@SneakyThrows
@View("enter-mobile-bad-view")
public void enterMobileBad(final AbsSender absSender,
@SessionAtr("chat-id") final String chatId) {
absSender.execute(SendMessage.builder()
.text(ENTER_MOBILE_BAD)
.chatId(chatId)
.build());
}
@SneakyThrows
@View("start-support-dialog-view")
public void startSupportDialog(final AbsSender absSender,
@SessionAtr("chat-id") final String chatId) {
absSender.execute(SendMessage.builder()
.text(START_DIALOG)
.chatId(chatId)
.build());
}
```
В данный момент бот уже может предложить пользователю выбрать тему вопроса и ввести номер телефона. Осталось добавить имитацию общения со специалистом. Сделаем новый класс, так как там могла бы быть сложная логика.
```
@Controller
public class SupportController {
@Command(value = UpdateType.MESSAGE, state = "support-dialog")
public ModelAndView supportDialog(final Model model) {
return new StatefulModelAndView(
"support-dialog",
"support-answer",
model);
}
}
```
И соотвествующий view:
```
@ViewController
public class SupportView {
@SneakyThrows
@View("support-answer")
public void supportAnswer(final AbsSender absSender,
final Update update,
@SessionAtr("chat-id") final String chatId,
@SessionAtr("user") final User user,
@ModelAtr("subject") final String subject,
@ModelAtr("mobile-phone") final String mobilePhone) {
final String digest = DigestUtils.md5Hex(
update.toString() + user.toString() +
chatId + subject + mobilePhone
);
absSender.execute(
SendMessage.builder()
.text(digest)
.chatId(chatId)
.build()
);
}
}
```
В этом view мы собираем собранные данные о пользователе и просто их хэшируем, для наглядности.
Вроде бы все готово, только что если пользователь захочет прервать общение со специалистом, либо передумает еще на этапе заполнения данных ? Нам нужна отмена. И можем её просто сделать. Добавим такой метод в `InitController`:
```
@Command(
value = UpdateType.MESSAGE,
state = {
"subject-select-state",
"enter-mobile-state",
"support-dialog"
},
exclusive = true
)
@HasText(textTarget = TextTarget.MESSAGE_TEXT, equals = "/cancel")
public ModelAndView cancelDialog(final Session session) {
session.stop();
return new ModelAndView("cancel-dialog");
}
```
Здесь можно увидеть что команда будет отрабатывать только если есть `Message` и пользователь находится в одном из перечисленных состояний, а так же exclusive true, что значит выполнение только этой команды, даже если подходят к обработке и другие.
Так же здесь появилась новая аннотация - `@HasText`, которая служит фильтром по тексту. Аннотация принимает TextTarget enum, в котором находятся несколько источников текста. А так же метод обработки текста. Всего их 5:
* equals
* equalsIgnoreCase
* contains
* startsWith
* endsWith
Ну и добавим соотвествующий view в `InitViews`:
```
private static final String CANCEL_DIALOG_TEXT = "Спасибо за ваше обращение!\n" +
"Если у вас снова возникнут вопросы мы будем рады вам помочь!";
@SneakyThrows
@View("cancel-dialog")
public void cancelDialog(final AbsSender absSender,
@SessionAtr("chat-id") final String chatId) {
absSender.execute(
SendMessage.builder()
.text(CANCEL_DIALOG_TEXT)
.chatId(chatId)
.build()
);
}
```
### Бот готов
[Ознакомится с ботом можно по ссылке](http://t.me/internet_support_immitation_bot)
[Исходный код бота](https://github.com/slyrack0/framework-demo-bot)
Заключение
----------
Статья получилась не очень читабельная, прошу прощения. Но мне бы хотелось что бы было что-то подобное для java.
[Ссылка на сам framework](https://github.com/slyrack0/jTelegramBotFramework)
Еще нужно добавить что по умолчанию для поддержки сессий и состояний используются in-memory хранилища. Если вы хотите использовать это не только для тестов - вам необходимо реализовать два интерфейса - SessionManager & StateManager и зарегистрировать их как бины.
С сериализацией и десериализацией отлично справляется jackson, если будет необходимо - могу предоставить пример как я использую его. | https://habr.com/ru/post/570660/ | null | ru | null |
# Откровения про отсутствующий Nested Inline от разработчика с очень маленьким Django
*— Стыдно признаться, но в нашей компании мы до сих пор используем Django…*
Так начинали со мной разговор представители навороченных стендов российских конференций [Pycon Russia 2021](https://pycon.ru/program#popup:Danilov "Ссылка нормально не работает. в программе мой доклад был первым во второй день.") и [Moscow Python Conf++ 2021](https://conf.python.ru/moscow/2021/abstracts/7910 "Это воркшоп на полтора часа."), где я выступал с докладами про Django.
Эдакий "[coming out](https://ru.wikipedia.org/wiki/%D0%9A%D0%B0%D0%BC%D0%B8%D0%BD%D0%B3-%D0%B0%D1%83%D1%82 "Это когда просят признавать нормой нечто, что считается или считалось ненормальным")" без объяснений, почему это стыдно, и зачем в этом надо признаваться. Если уж «[Все леди делают это](https://www.kinopoisk.ru/film/64038/ "Олдовая порнуха, но, типа, считается, что эротика.")» так давайте говорить об этом, как о чем-то нормальном! Я, например, рассказываю, как делать это в удовольствие и с естественными извращениями. Я про работу с Django, конечно, а вы, о чем подумали?
Под естественными извращениями я подразумеваю решение задач при помощи Django без дополнительных батареек. Этот фреймворк имеет все, чтобы решать сложные задачи просто, но, как я уже писал [ранее](https://habr.com/ru/post/530766/ "статья про малопонятный SITE_ID в настройках DJango"), отсутствие информации о необходимом существующем функционале Django не дает этого сделать. WTF?
Что начинает делать разработчик Django-проекта, когда кажется, что необходимых инструментов нет? Качать тоннами ненужные батарейки с [https://djangopackages.org/](https://djangopackages.org/ "Адово кладбище франкенштейнов с несколькими живыми проектами") или начинает рассказывать о том, как [Django может привести к ментальным заболеваниям](https://habr.com/ru/post/594601/ "статья была бы короче, если бы не документация Django").
Во время вышеупомянутых конференций, на докладе про выбор подходящего python-фреймворка Django Admin упрекнули в отсутствии **Nested-Inlines** (inline в inline). Мол, больше десятилетия лежит [Issue на djangoproject](https://code.djangoproject.com/ticket/9025 "Запрос на добавление Nested-Inline в ядро Django") и разработчики не могут это поправить.
А что если **Nested-Inlines** в Django Admin был возможен с начальных версий? Подтвердить или опровергнуть мои слова смогут дочитавшие эту статью до конца. Остальным остается смириться: понимание работы Django с полным отсутствием нормальной документации требует особой любви к извращениям.
[И, вот теперь, слайды](https://www.anekdot.ru/id/92840/ "Анекдот про доклад со слайдами о разных видах Любви"):
Предположим, у Вас проект e-commerсe. В проекте есть модель **Shop**, каждый объект этой модели содержит объекты модели **Product**, которые, в свою очередь, могут иметь связь с несколькими объектами модели **Images**.
```
from django.db import models
from django.utils.translation import gettext_lazy as _
class Shop(models.Model):
class Meta:
verbose_name = _('Это модель магазина')
title = models.CharField(verbose_name=_('это название магазина'), max_length=255)
class Product(models.Model):
class Meta:
verbose_name = _('Это модель продукта в магазине')
title = models.CharField(verbose_name=_('это название продукта'), max_length=255)
shop = models.ForeignKey(Shop, verbose_name=_('это ссылка на магазин'), on_delete=models.CASCADE)
class Image(models.Model):
class Meta:
verbose_name = _('Это картинка продукта')
src = models.ImageField(verbose_name=_('это файл картинки'))
product = models.ForeignKey(Product, verbose_name=_('это ссылка на продукт'), on_delete=models.CASCADE)
```
Давайте создадим администраторы моделей, для управления данными.
```
from django.contrib.admin.options import ModelAdmin
class ImageModelAdmin(ModelAdmin):
fields = 'title',
class ProductModelAdmin(ModelAdmin):
fields = 'title',
class ShopModelAdmin(ModelAdmin):
fields = 'title',
```
Знающий Django разработчик на этом месте, скорее всего, воскликнет:
*— Администраторы моделей не зарегистрированы!*
И, скорее всего, это потому, что он просто пропустил информацию про авторегистрацию ModelAdmin, которая, как [суслик](https://www.youtube.com/watch?v=EHX7NZS8zAI "Видишь суслика?"), вроде его нет, а он есть.
Сразу сделаем через Model-Inline правку продуктов непосредственно на странице правки магазина, и добавление картинок на странице правки продукта.
```
from django.contrib.admin.options import ModelAdmin, TabularInline, StackedInline
from django.utils.translation import gettext_lazy as _
from .models import Image, Product
class ImageAdminInline(TabularInline):
extra = 1
model = Image
class ProductModelAdmin(ModelAdmin):
inlines = ImageAdminInline,
fields = 'title',
class ProductInline(StackedInline):
extra = 1
model = Product
class ShopModelAdmin(ModelAdmin):
inlines = ProductInline,
fields = 'title',
```
Если Вы вовремя остановились в своем проекте на этом этапе, то Вы точно имеете минимум одну проблему: ошибка сохранения объекта из формы правки, если объект одновременно правят несколько пользователей.
В примере выше — ошибка будет появляться при работе нескольких пользователей в ShopModelAdmin с одним и тем же объектом модели Shop.
Допустим, Вы решили эту проблему [батарейкой](https://pypi.org/project/django-reversion/ "Норм библиотека, только излишне для Django") для версионирования, поскольку о версионировании из Django-коробки вам никто не рассказал. Заодно Вы прикрутили сторонний [модуль раздачи прав](https://pypi.org/project/django-guardian/ "Даже интересно, как много людей не знают что это есть в Django") для доступа к отдельным объектам моделей, поскольку, вы и предположить не могли, что это тоже возможно в Django.
**Все? Работа завершена? А не, показалось…**
### Задача размещения Любого Inline в любом месте формы правки объекта.
Ваш любимый менеджер приходит и спрашивает:
> *— А можно на форме правки продукта сначала показать Inline картинок, а только потом название продукта?
>
> — Да, можно.*
По — умолчанию в Django в форме правки объекта модели в Панели администраторов сначала стоят все поля редактируемого объекта, а потом идет блок инлайнов. Задачу вставки одного inline «куда хочется» на форму решается разными путями.
> Первое сносное решение я встретил в 2015 году. Там было про переопределение шаблона формы правки 'admin/change\_form.html' [примерно так](https://linevi.ch/en/django-inline-in-fieldset.html "не надо так делать").
>
>
>
> Почти «съедобное» решение я встретил позже в 2018 году у какого-то чеха, он делал вставку inline через дополнительные поля AdminForm с переопределением шаблона. Это выглядело проще и универсальнее, но еще не тянуло на «простое» решение на Django. Увы, без proof link.
А можно ли разместить любой Inline в любом месте формы администратора модели только силами Django с минимальным количеством кода? Возможно! Но это не точно…
Вероятно, Вам знакома парадигма *[добавленного поля](https://docs.djangoproject.com/en/4.0/ref/contrib/admin/#django.contrib.admin.ModelAdmin.readonly_fields "Тот ещё изврат, но работает.")* в ModelAdminForm. Вы объявляете несуществующее в модели поле в полях AdminModelForm, отмечаете его только для чтения. В момент рендера формы результат вызова одноименного метода ModelAdmin будет отображен на форме. Важно, что последовательность рендера ModelAdmin такова, что сначала создаются inline, потом рендерится форма, и, потом, рендерится блок inline. Этим мы и воспользуемся:
```
from django.contrib.admin.options import ModelAdmin, TabularInline
from django.utils.translation import gettext_lazy as _
from django.template.loader import get_template
from .models import Image
class ImageAdminInline(TabularInline):
extra = 1
model = Image
class ProductModelAdmin(ModelAdmin):
inlines = ImageAdminInline,
fields = 'image_inline', 'title',
readonly_fields= 'image_inline',
def image_inline(self, *args, **kwargs):
context = getattr(self.response, 'context_data', None) or {} # somtimes context.copy() is better
inline = context['inline_admin_formset'] = context['inline_admin_formsets'].pop(0)
return get_template(inline.opts.template).render(context, self.request)
def render_change_form(self, request, *args, **kwargs):
self.request = request
self.response = super().render_change_form(request, *args, **kwargs)
return self.response
```
В момент рендера *change\_form* будет вызван метод *image\_inline*, который вынет из списка еще не обработанных *inline\_admin\_formsets* один *inline\_formset*, и отрендерит его там, где хочется. Ниже *change\_form* отрендерятся оставшиеся *inline\_admin\_formsets*, если они есть у *ModelAdmin*.
Поскольку, мы исправили только рендер, то в остальных случаях все продолжит работать так, как и работало. Потому больше [ничего не трогаем](https://www.anekdot.ru/id/950152/ "не трогай, если работает").
Знающий Django разработчик на этом месте воскликнет:
*— Нельзя использовать self в методах ModelAdmin как контейнер для хранения данных!*
Замечание принято. Действительно, в Django без доработок этот код приведет к появлению ошибок.
> Кто не в курсе – для панелей администраторов Django хранит в реестре проинициализированные объекты классов ModelAdmin, работа всех пользователей обслуживается только этими объектами. Использовать эти объекты как контейнеры для пользовательских данных не получится. Тут Django полностью противоречит своей парадигме GCBV. Как это достаточно просто исправить, объяснено мною [тут](https://youtu.be/5tJdO0bkb3A?t=1675 "Мой доклад на конференции pycon russia 2021").
**Все. Работа завершена. А, не, показалось…**
### Задача размещения Nested-Inline в формe правки объекта.
Все тот же ваш любимый менеджер приходит и спрашивает:
> *-А можно на форме добавления продуктов в магазин сразу показать Inline для картинок?
>
> — Да. Можно.*
Вы, конечно же, любите своих менеджеров и бежите закачивать Django-Nested-Inline. По пути Вы отмечаетесь на **djangoproject.com** в [issue на добавление nested-inline](https://code.djangoproject.com/ticket/9025 "кучка псевдо программистов открывает дорогу в ад"). Вас вовсе не останавливает мысль о том, что проблему синхронной правки товаров в магазине никто не отменял, и теперь она начнет проявляться в геометрической прогрессии:
Эта угроза всегда раньше обходила вас стороной, только потому, что у вас не было Nested-Inline. Исправим это упущение.
Идея Nested-Inline базируется на предыдущей идее о размещении Inline в любом месте формы. Просто продолжим эту мысль дальше: Добавленное поле вставляем внутрь Admin inline, а в такое поле, как мы уже делали, вставляем еще inline, и получим автоматически ~~какую-то херню~~ Inline-в-Inline.
**Давайте же сделаем это:**
Создадим добавленное поле в инлайне продукта.
```
class ProductInline(StackedInline):
model = Product
fields = 'title', 'image_inline'
readonly_fields = 'image_inline',
extra = 1
def image_inline(self, obj=None, *args, **kwargs):
context = getattr(self.modeladmin.response, 'context_data', None) or {}
admin_view = ProductModelAdmin(self.model, self.modeladmin.admin_site).add_view(self.modeladmin.request)
inline = admin_view.context_data['inline_admin_formsets'][0]
return get_template(inline.opts.template).render(context | {'inline_admin_formset': inline}, self.modeladmin.request)
```
В добавленное поле объекта ProductInline я вставил ImageInline, взятый из ProductModelAdmin.
> Разумеется, это не конечный вариант, например, для существующего объекта надо вызывать change\_view, и передавать ему object\_id. Предлагаю вам подумать об этом на досуге.
Далее вызовем ShopModelAdmin с исправленным ProductInline. Заодно добавим необходимые данные для рендера nested inline (и не только) в добавленном поле **image\_inline**.
```
class ShopModelAdmin(ModelAdmin):
inlines = ProductInline,
fields = 'title',
def render_change_form(self, request, *args, **kwargs):
self.request = request
response = self.response = super().render_change_form(request, *args, **kwargs)
return response
def get_inline_instances(self, *args, **kwargs):
yield from ((inline, vars(inline).update(modeladmin=self))[0] for inline in super().get_inline_instances(*args, **kwargs))
```
Запускаем. Как я и сообщал, получилась хрень.
Django-Core разработчики может и хороши в Python, но вот c Javascript функциями на старом jquery в панелях администраторов творится какая-то лютая дичь. Глубоко по-читаемый мной [kesn](https://habr.com/ru/users/kesn/) отмечал, что:
> нужно всего-то пожениться на джанговском javascript и всё там переписать.
Не, не надо. Это будет [мезальянс](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D0%B7%D0%B0%D0%BB%D1%8C%D1%8F%D0%BD%D1%81 "Неравный брак"). Просто поверьте мне на слово, что в файле inlines.js надо поменять всего три строки:
```
// django\contrib\admin\static\admin\js\inlines.js
// row 335:
$(selector).stackedFormset(selector, inlineOptions.options);
// change to
$(this).find("[id^=" + inlineOptions.name.substring(1) + "-]").stackedFormset(selector, inlineOptions.options);
// rows 338-339:
selector = inlineOptions.name + "-group .tabular.inline-related tbody:first > tr.form-row";
$(selector).tabularFormset(selector, inlineOptions.options);
// change to
selector = inlineOptions.name + "-group .tabular.inline-related tbody:first > tr[id^=" + inlineOptions.name.substring(1) + "-].form-row ";
$(this).children().tabularFormset(selector, inlineOptions.options);
```
Увы, ребята в [djangoproject ошибку inline.js не признают](https://code.djangoproject.com/ticket/33394 "Сказочные долбоебы djangoproject"). Если Вы все сделали правильно, получите вот такую красоту:
Можете усложнить задачу и сделать больше уровней вложений. Рекомендую для глубоких вложенностей использовать **TabularInline**, а то **StackedInline** после второго вложения грустно выглядит.
**Все. Работа завершена. А, не, показалось…**
### Задача сохранения данных
С одной стороны, я показал, как получить работающий масштабируемый рендер Inline-в-Inline.
С другой…. А вы не думали, как это все будет сохраняться?
Созданная нами только что проблема сохранения состоит из нескольких частей.
* Для работы всей этой пидерсии на нужны правильные префиксы форм для вложенных инлайнов. Это просто решаемая задача.
* ModelAdmin валидирует данные для главного объекта и для объектов первой вложенности. Валидацию для вложенных инлайнов надо делать отдельно. Это тоже решаемая задача, но чуть сложнее.
* Обычное сохранение в панели администраторов подразумевает сохранение главного объекта и объектов первой вложенности. Вызов сохранения информации вложенных инлайнов надо делать отдельно. Это продолжение предыдущей задачи.
* А вот как быть с тем, что множественная правка несколькими пользователями одновременно множества разнородных объектов приводит к множественным конфликтам состояний объектов? Это оставлю вам на размышление. Вы же Nested-inline хотели? Теперь мучайтесь.
### Передача префикса
Выполняется через переопределение функции \_\_init\_\_ формы инлайна, где мы будем передавать prefix формы как префикс для вложенного формсета.
```
class MyForm(StackedInline.form):
def __init__(self, *args, **kwargs):
super(MyForm, self).__init__(*args, **kwargs)
self.instance.form = self
class ProductInline(StackedInline):
......
form = MyForm
def image_inline(self, obj=None, *args, **kwargs):
......
inline.formset.prefix = f'{inline.formset.prefix}-{obj.form.prefix}'
return get_template(inline.opts.template).render(self.context, self.context['request'])
```
Чуть позже палки в колеса с префиксами опять начнет вставлять родной javascript. Пока, вам придется поверить на слово, что для первой работоспособной версии и так сойдет.
### Валидация конечных данных
С валидацией придется повозиться. Вешается, она на ту же форму MyForm. Но есть большое **НО**! Если вызвать, метод add\_view c request.POST — то данные этого вдоженного инлайна сохранятся, даже если вы этого не хотите. В Django modelAdmin вообще невозможно проверить, что данные валидны. Я сообщил об этом в очередном [djangoproject issue](https://code.djangoproject.com/ticket/33528 "ну долбоебы, что поделать?"), и был в очередной раз ~~послан~~ не понят. И, кстати, на этом моменте я понял, что формирование вложенного inline проще делать в MyForm:
```
class MyForm(StackedInline.form):
....
def is_valid(self):
return super().is_valid() and self.nested.formset.is_valid()
@cached_property
def nested(self):
modeladmin = ProductModelAdmin(self._meta.model, self.modeladmin.admin_site)
formsets, instances = modeladmin._create_formsets(self.modeladmin.request, self.instance, change=self.instance.pk)
inline = modeladmin.get_inline_formsets(self.modeladmin.request, formsets[:1], instances[:1], self.instance)[0]
inline.formset.prefix = f'{self.prefix}_{formsets[0].prefix}'.replace('-', '_')
return inline
class ProductInline(StackedInline):
....
def image_inline(self, obj=None, *args, **kwargs):
context = getattr(self.modeladmin.response, 'context_data', None) or {}
return get_template(obj.form.nested.opts.template).render(context | {'inline_admin_formset': obj.form.nested}, self.modeladmin.request)
def get_formset(self, *args, **kwargs):
formset = super().get_formset(*args, **kwargs)
formset.form.modeladmin = self.modeladmin
return formset
```
### Сохранение вложенностей
Автосохранение вложенных инлайнов сделаем через переопределение метода save формы MyForm
```
class MyForm(StackedInline.form):
def save(self, *args, **kwargs):
return super().save(*args, **kwargs) or self.nested.formset.save(*args, **kwargs)
```
Вроде сохранилось:
#### Краткая сводка моих действий:
1. Создал приложение с тремя связанными классами и администраторы этих моделей с Inline.
2. Встроил добавленное поле в ChangeForm для вставки туда Inline.
3. Встроил добавленное поле в Inline.
4. На примере вставки Inline в добавленное поле ChangeForm, я вставил в добавленное поле Inline еще один inline, полученный из администратора другой модели.
5. Решил вопрос генерации префиксов форм из inline, вложенных в inline
6. Решил вопрос валидации данных форм из inline, вложенных в inline
7. Сохранил данные форм из inline, вложенных в inline
8. Как смог, поправил inlines.js
#### Что не решено:
1. inlines.js не верно создает кнопки удаления для tabularinline форм, если extra != 0
2. inlines.js криво работает с префиксами вложенных инлайнов, у новосозданных родительских инлайнов.
3. inlines.js не учитывает extra для вложенных inline у новосозданных родительских инлайнов.
4. Не обработан случай, если метод nested формы MyForm вернет что-то другое.
#### Упомянутые в статье возможности Django
* Авторегистрация ModelAdmin
* Версионирование состояний объектов Django-моделей
* Управление доступом к объектам Django-моделей
Итоговое решение заняло около 20 строк кода на Django 4.0, масштабируется и не использует сторонние библиотеки. Смотрите [в репозитории](https://bitbucket.org/danilovmy/nested/src/master/ "За ошибки ногами не бить!"), пробуйте. Буду рад, если подскажете, что я упустил.
### Выводы
Я хотел на этом примере показать, что решить нетривиальную для Django-разработчика задачу можно с минимальным количеством усилий используя только возможности самого фреймворка.
Получилось или нет? Решать вам.
P.S. Большой дисклеймер о том, что все персонажи из статьи являются вымышленными, и любое совпадение с реально живущими или жившими людьми ~~не~~ случайно.
P.P.S. Предложенная идея работает в моих проектах уже долгое время, я благодарю моего коллегу Павла П., который является тестером всех моих сумасшедших идей и участвовал в доработке этой.
---
«Django — это наше все» лозунг команды разработчиков, где я уже 7 лет занимаюсь обслуживанием и обновлением Django проектов. Если в Вашем Django-проекте есть нестандартные или сложные задачи — давайте попробуем решить их вместе.
--- | https://habr.com/ru/post/651179/ | null | ru | null |
# Архитектура Архитектуры. Шаг 7: Носом в пилотку
Продолжение. [К предыдущим постам и карте цикла.](https://habr.com/en/post/575106/#map)
Знаете, что случается, когда и архитектура вроде получилась и команда подобралась нормальная? Приходит [ПОЦ](https://en.wikipedia.org/wiki/Proof_of_concept). [Пилотная](https://en.wikipedia.org/wiki/Pilot_experiment) версия. Проверка боем. Да, вы уложились в сроки и даже прошли всё внутренние проверки и тестирование на стороне клиента ([UAT](https://en.wikipedia.org/wiki/Acceptance_testing), [SIT](https://en.wikipedia.org/wiki/System_integration_testing), [PPT](https://en.wikipedia.org/wiki/Deployment_environment), [ETC](https://nl.wikipedia.org/wiki/Et_cetera)), так что теперь вас ждёт всё более худшее – то, что не нашли. Потому что там точно что-то спрятали. Может и не вы, но в конце точно прозвучит: «доктор, это вам!».
Чем нас радует живая система – суровой средой обитания и дикими пользователями. Тут уже не будет новых компов и периферийных устройств, пахнущих машинным маслом. Вас ждут западающие кнопки, пролитый кофе и кабель, перебитый дверцей или намотанный на колесики офисного стула. То есть вообще совсем не радует. Это не тот цирк, где смеются, а старый добрый [римский вариант](https://en.wikipedia.org/wiki/Roman_circus), где клоуна выпускают на арену со львами. И нет, не стоит отождествлять себя со львом. Архитектор – это человек, который ничем не управляет, но за всё отвечает. Так что на этом этапе жизненного цикла будет проверка того, как вы подготовились на [предыдущем шаге](https://habr.com/en/post/556380/). Или насколько на рынке труда сейчас востребованы специалисты вашей сферы. Тот самый этап, когда корабль покидают внештатные технические советники…
Что же такое этот пробный запуск и в чём его отличие от прошлых и будущих версий? Возможно, уже [ранее](https://habr.com/en/post/548076/) вам довелось что-то запустить в закрытом реалме вашего клиента. Но это было в стиле «одноразового продукта». Как латексные перчатки. Клиент их примерил, попытался покопаться глубоко в вашем тизере, а потом всё. Сняли и выкинули. Никаких отпечатков на теле предприятия. И только у вас осталось какое-то странное ощущение того, что это была нежная прелюдия.
Оффтоп терминологии.В разных компаниях первый закрытый (публично, с рекламой и пафосом идёт официальный roll out) запуск проекта называется по-разному. Мне раньше было интересно, чем же это вызвано. Ведь странно придумывать разные имена для довольно стандартного процесса в индустрии. Потом я впервые попал в энтерпрайз и я понял, что нужно узнать историю. В той компании первый релиз назывался alpha. И всё было хорошо, пока не появился клиент с таким же именем. И альфа Альфы вызывала много проблем на совещаниях. Очень тяжело на слух понять, о чем же речь, когда говорят, что завтра merge 1.2.1 альфа в Альфа 1.1.3.
Ну переименовали в pilot. Через год у нас уже был pilot у Pilot. Чем больше ваша корпорация и чем больше стран охватывает ваша клиентская база, тем больше проблем с названиями, так как шанс коллизий растёт с каждым годом. Особенно весело, когда подключают статистический анализ на CI, чтоб предотвратить «просачивания» имени клиента в проект к другому клиенту. Самый веселый курьёз был, когда всё-таки в логах всплыло имя другого проекта и начали дуть на воду. Через месяцок [СТО](https://en.wikipedia.org/wiki/Chief_technology_officer) послал гневный мейл со скрином ошибки с тестового стенда и требованием вырвать руки, тому, кто опять вписал имя клиента в [неймспейс](https://en.wikipedia.org/wiki/Namespace). На скрине красным цветом выделялось `System.Stack.Overflow.Exception.` Ну да, есть у нас и такой клиент. Однако уровень понимания кода нашего директора стал очевиден.
От ощущения к осознанию.
------------------------
То, что ставят в прод на этом этапе будет реально работать. Ну даже если большую часть времени работать не будет вообще. Всё равно следы оставит, пусть и из крошек. Вот этот мусор и есть наша проблема. Система будет генерировать документы, управлять станками или направлять средства. Чем бы там ваш клиент не занимался. Но это уже будет иметь физические и юридические последствия. Если в демке вы запускали конвейер, то он был в стороне от настоящего производства и всё изначально шло как тест на списание. Теперь ваш конвейер уже будет делать и полезную работу, и брак. И это будет проходить по всем отчётам. Их просто не «подправишь». А уж если у вас там интеграции с внешними системами и фискальный документооборот, то тут уж всё ясно. Данные, полученные на стадии пилота, уже никогда не покинут вашу систему. Это то, с чем вам придётся жить и уже на этом этапе необходимо продумать всю процедуру миграции от версии к версии и как приводить систему в равновесие с реальностью.
Если вам довелось проектировать [распределённую систему](https://en.wikipedia.org/wiki/Distributed_computing), где каждая единица является частью целого, то тут возникает засада с накатом версий. Конечно, такие вещи продумывают заранее, но слишком часто плохо тестируют. Ну и сама идея профессионально игнорируется профессиональными менеджерами. То есть они не видят разницы между 1 рабочий офис и 20. Продолжают наивно полагать, что переустановка или обновление происходит в момент, и секунду назад всё было на версии 1.0, а потом щелчок пальцев и все на 1.1.15. Сюрпризом для неподготовленного проектировщика может стать не то, что необходимо продумать совместную работу версий 1.0 и 1.1 с хвостиком, а то, что разных версий в проде может стать много. Самый простой сценарий, который не раз уже попадался на моей практике – у клиента не все офисы одинаковые. Есть разные типы. И в них разный набор услуг или необходимого функционала. Представьте себе банк. У него есть маленькое отделение, где можно открыть счёт и вложить\снять деньги. Есть отделение побольше и там есть операции с иностранной валютой. И есть большие, центральные, где и ипотеку можно оформить и т.д. То есть 3 типовых набора функций. Клиент хочет тестировать и запускать эти 3 типа отдельно. Так как в организации, обычно, эти типы идут параллельно и управляются разными людьми. В какой-то момент они начнут накладываться и у вас будет 3 версии пилотов в проде. В каждом типе мультиверсионность (разные версии должны работать вместе). Ну а у вас на это еще накладываются бранчи с текущим релизом, будущие пару релизов и мастер под каждый тип. Нет, я не управленец и не моя болит голова по поводу количества проверочных стендов, версий в репозиториях, тестов и команд, которое растёт из-за параллельных релизов. А вот то, что изменения инфраструктуры расплываются на кучу веток и нужно помнить, что на какой стадии и где, а самое главное, как привести это в итоге к единой версии – это уже моё. Критичные вещи не будут ждать, пока очередной кусок получит даунмердж во все ветки. Надо было срочно пропатчить одну из вариаций пилота – это сделали и закинули в прод. И тут уж без конфликтов не обойдётся. И я не только про код.
Шрамы украшают мужчин, укрощая высокомерие.Когда-то я проектировал систему для небольшого ритейла. Самым простым и довольно очевидным, мне казалось, то, что завершённая сделка – нечто [неизменное](https://en.wikipedia.org/wiki/Immutable_object). Чек отпечатан, товар получен, и покупатель покидает пределы вашей галактики. Ну то есть что случилось – то случилось. С такой концепцией жизнь программистов становилась намного легче, а [ремонтопригодность](https://en.wikipedia.org/wiki/Maintainability) кода вырастала в разы. Как я понял потом – это частая ошибка и в проектировании, и в самой концепции продукта с обеих сторон баррикады (у заказчика и у исполнителя). В идеальном мире компьютерная система видится всем прямой автоматизацией – то есть делает сама то, что раньше делал человек. Раньше у человека была тетрадка, потом экселик, а теперь вот, чтоб он ручками не писал, система сама всё регистрирует и как бы заполняет всё тот же шаблончик. Вот только людям свойственно ошибаться, срезать углы, игнорировать правила. Ну нельзя изменить чек, но можно «вот тут зачеркнуть и подписать, а вы потом, когда к нам придёте» … Так что документ может и должен быть отлит в бетоне, но по факту, там оказались мои ноги, а плавать в таких ластах жутко не удобно. Пришлось много чего перекроить на пилоте, так как кассир периодически тыкал не в ту кнопку и завершал сделку другим методом оплаты. Видимо UI неудачно напоминал старую систему и человек следуя механической памяти жмякал в тоже место на экране. То есть покупатель говорил, что хочет оплатить картой, а кассир закрывал наличкой. Из-за особенностей региона (центральная цифровая фискализация и разные цены в зависимости от средства оплаты) то, либо клиент соглашался оплатить наличными постфактум, либо on the house. Чтоб прийти к жизнеспособности мы стали рассматривать сделку (да и вообще все процедуры с документами) как цепочку. То есть покупка с номером 123 могла быть представлена набором неизменяемых документов с кодом 123, и каждый документ имел порядковый номер и всё после оригинала (первого) считалось правкой (adjustment document). Тут посыпалась и уникальность ключей в базе и перекройка всех отчётов, и даже куча изменений в UX. Дорого, много и с плотно сжатыми потными сроками.
Имплементация и корреляция.
---------------------------
Во время разработки первой ступени политически важно успеть. Менеджмент будет делать всё, чтоб уложиться в дедлайн и доставить на стартовую площадку как можно больше модулей. Лучше даже, если функционал будет больше заявленного для этой версии. Оно понятно. Надо доказать клиенту, что он сделал правильный выбор и иметь запас времени и плюшек, чтоб подкупить заказчика при выявлении всевозможных ошибок. [Известный способ](https://habr.com/en/post/556380/) справиться с рисками.
Как результат такой политики – урезается влияние архитектора на проект, увеличивается бэклог и технический долг. И если вы не требовали и не проявляли инициативу, то код может сильно отличаться от того, что вы ожидали. Документация и диаграммы соответствуют дизайну, а вот имплементация уже утыкана костылями и может быть местами диаметрально противоположной техническим требованиям. Что страдает чаще всего – разграничение ответственностей и модульность. Где-то влили бизнес-логику в базу, где-то воспользовались одним и тем же контрактом для разных уровней, а где-то просто впихнули в один модуль функциональность трёх-четырёх. А бегать на костылях с непривычки крайне неудобно. Значит быстрые мелкие изменения, которые необходимы при запуске альфы, получаются глубокими или добавляют костылей. Доходит до глупостей. Клиент пожаловался на опечатку в тексте кнопки и саппорт радостно бежит в контрольную панель, поменять конфигурацию, но оказывается, что кнопку захардкодили. [ATP](https://en.wikipedia.org/wiki/Acceptance_testing) и QA прошли без проблем, так как все проверяли действие при нажатии кнопки, а не то, что текст можно сменить. Тут бы помог [код ревью](https://habr.com/en/post/556380/), но в наше время эту практику избегают. Да и грамотно проверить весь пахнущий код занимает кучу времени. Поэтому предпочитают экономить время и оставить пахнущую кучу в коде. И вот либо опечатка будет висеть и бесить клиента пару месяцев до выхода следующего релиза (привязка к конфигурации затрагивает несколько модулей и будет иметь большую зону эффекта, а значит и риск), либо нужно раскидать хотфикс, где хардкодят нужный текст (такое изменение можно функционально и не тестить).
Эхо прошлого.Бизнес в базе данных – это не всегда хранимые процедуры. Их то легко выловить. Сложности возникают, когда логику вносят в схему. Самый частый пример – [уникальность](https://www.w3schools.com/sql/sql_unique.asp). Вместо проверки в коде ставят ограничение на колонку в базе. В пилотной версии редко поддерживается сложное организационное дерево заказчика. Франшизы и дилеры обычно не выступают в роли подопытных кроликов. А вот дальше – они неотъемлемая часть бизнеса. Прописанное в схеме таблицы уникальность имени пользователя не даёт возможность использовать то же имя в юридически разных компаниях (они просто работают под одним брендом). В некоторых регионах это нарушение регуляций – компания не должна иметь контроль над дилерами, даже если это ограничение возможность выбрать имена пользователей. Смена кода (patch, upgrade) воспринимается нормально всеми участниками, а вот изменение существующих данных – это уже проблема. В отличии от тестов пилотная версия не исчезает бесследно. Она продолжает жить и данные из нее кочуют в новые версии. Вам повезло, если проблема уникальности возникла на относительно маленьком объеме данных – пользователей обычно несколько тысяч. А вот, когда это идентификатор транзакции и речь идёт о миллионах записей, то всё намного сложнее.
Две головы хуже
---------------
Большие проекты делят на несколько подрядчиков. Аккуратными дорожками с помощью безмерной корпоративной кредитки. [Прошлый блок](https://habr.com/en/post/545866/) был про вендор лок. Когда вы разрабатываете продукт, который не идёт в комплекте с закрытым железом, то приходится уповать на то, что ваша программа будет бежать в защищённой среде. Специалист по безопасности пишет вам [харденинг](https://en.wikipedia.org/wiki/Hardening_(computing)). Вы, конечно, считаете, что это требование и предварительное условие. Но те другие компании из тендера, обслуживающие вашего клиента, видят в этом сопроводительное письмо с рекомендациями. У них свои проблемы и свои условия соглашения. Часто выясняется, что в реале всё не так должно быть. Доступ к системе есть у каждого прохожего, сертификат ставят везде один и тот же и вашим аппликациям дали администраторские права. Хуже всего, что ничего из этого на работоспособность вашего продукта не влияет, а значит все вроде, как и довольны происходящим. А вот когда приходит время каких то сертификаций, проверок, аудита или реальной кибер-атаки, то всё летит к бабушке гендиректора. Ну а если у вас вместо гена директора гены инженера, то стоит позаботиться об утилитах и скриптах для верификации тех самых требований к безопасности инфраструктуры. Естественно, что просто сделать проверку частью инсталяшек будет недостаточно. Сегодня всё ок, а завтра всё сломают. Необходимо регулярно мониторить. Желательно автоматом. Лучше с калибром 7.62.
Мотивация к отслеживанию чужих обязанностей простая как английский [лук](https://en.wikipedia.org/wiki/Longbow). Чтоб попасть своей стрелой в стрелу «партнеров». Как только случиться реальный инцидент, каждый вендор будет стараться скинуть с себя ответственность. Сначала это происходит на уровне компаний участников, а потом и внутри команды. То есть, если сольют в сети базу клиентов, то скорее всего адвокаты заказчика придут к вам. У вас же менеджеры расступятся как воды перед Моисеем открывая путь истцов прямо к вашему порогу. Архитектор координирует всех специалистов проекта. В том числе и безопастников. Доказать, что базу сняли не с живой системы, а со старых накопителей, которые не уничтожили по регламенту, а растащили по домам и на барахолку – задача не тривиальная. Особенно, если всё что у вас есть – это логи вашей системы. Помогло, что даты последних записей в базе совпали с точностью до нескольких минут с записью в журнале о прибытии техника на плановую замену диска. Так что в случае успеха ваше имя никто не узнает, а вот в случае проблем – вы знаменитость. Ну и помимо серьезных инцидентов, мелочи тоже будут кидать друг другу как горячий картофель. Необходимо доказать, что проблема не у вас, а допустим в железе или на стороне тех, кто отвечает за сеть или контроль доступа. Если ваша система перестала работать, то в первую очередь постучатся к вам, а не к тем, кто сегодня планово сменил драйвера или обновлял [ось](https://en.wikipedia.org/wiki/Operational_system). Помните, что проблемы продукта вашей архитектуры влияют на имидж вашего клиента намного ощутимей, чем на ваш собственный (компании и личный).
А вот еще казус.Как бы заказчик не старался избежать завязки на одного поставщика услуг, но щит, случается, не может устоять перед копьём. Я видел такое несколько раз. Две разные компании выигрывают тендер в разных ролях и работают вместе с одним клиентом. А потом другой тендер с другим клиентом. И если вместо метания стрел возникает сотрудничество, то компании идут в партнёрстве и обычно потом сливаются. Копья становиться больше и расходы снижаются. А клиент вынужден мириться, что оба яйца в одной корзинке из рук.
Есть и другие варианты развития событий с тем же результатом. Компания, в которой я работал получила грандиозный проект (лет 5 разработки и 10+ до [EOL](https://en.wikipedia.org/wiki/End-of-life_product)). Поддержку выиграла другая компания. Какое-то местечковое агентство с телефонами на 24/7. Клиенту был важен родной язык и культура. Так вот культурой и рабочими часами мы как-то не сошлись. Где-то год нас постоянно будили по среди ночи по мелочам (разница в часовых поясах), так как ребята не хотели сами искать решение (большая текучка с минимумом обучения). Почти половина тикетов с первого уровня попадала сразу на четвертый – к разработчикам. В общем через пару лет наша компания просто купила всё эту службу поддержки с потрохами и перевела сервис в дешёвый регион с низкими ценами и смешными акцентами.
Не все друзья – враги
---------------------
Но и не все друзья – друзья. В корпоративном сегменте всегда есть [внутренняя конкуренция и сильное расслоение](https://habr.com/en/post/545866/). Всё, что шло на ура в лабораториях и тестовых стендах не всегда принимается на ура в настоящей работе. Самым первым и простым объяснением таких расхождений ожиданий и реальности -те, кто заказывают музыку сами не танцуют. Требования приходят не от работников, а от эффективных менеджеров и экспертов-теоретиков. Особенно сложно, когда эксперты задают требования глобально. Граждане некоторых больших стран не всегда в курсе, что есть и другие места, культуры и стандарты. Иногда можно сразу ткнуть носом в кусок задания и спросить: «а кто у нас тут такой умный?». Вот, например, одна ритейл компания захотела, чтоб цену на продукт можно было менять «в один клик» по всей сети. Меняешь базовую цену ([MSRP](https://en.wikipedia.org/wiki/List_price)) и автоматом везде цена поменялась по какой-то простой формуле. На подобие «база + 3%» или «база + 1». И ты сидишь и смотришь на чудо из глав. офиса, которое тебе вещает это с умным видом по видеоконфе. И после драматической паузы начинаешь делать вступление и кидать наводящие вопросы. В стиле: «Я буду очень рад помочь такой большой компании в оптимизации бизнес процессов. Конечно, невозможно вручную контролировать все 15 000 торговых точек в 49 странах. Нам только надо обсудить технические мелочи. В какой валюте будет базовая цена, ведь почти в каждом регионе своя валюта, как будет идти расчёт для регионов с [налогом](https://en.wikipedia.org/wiki/Tax_rate), заложенным в цену, как будет округляться цена при минимальной [деноминации](https://en.wikipedia.org/wiki/Denomination_(currency)) отличной от 0.01?» И далее по списку, пока человек сам не осознает абсурдность или непродуманность задания. Что, кстати, случается далеко не всегда. Иногда звучит фраза: «Вы же тут технический специалист, вот и скажите, как сделать». Но иногда вещи не столь очевидны. Так можно получить вполне логичное требование «поднимать шлагбаум после того, как установленная на нём камера определила номер машины», а пилотку запустят в стране, где передние номера на машинах не обязательны. И потом будем «удивляться всем офисом».
По мимо оторванности от мира, часто мешает то, что клиент приходит к вам со своим видением решения, а не проблемой. Очень часто решение это основано не на логике или желании улучшить процесс, а на «так оно сейчас работает». То есть от новой системы хотят то же и так же, как делает старая. Создается ощущение, что в идеале, клиент хотел бы только обои поменять. Как бы родные грабли ближе к телу. По возможности пытайтесь избегать проектов на принципе «один в один». Все они всегда убыточные, ущербные и долгие. А такие проекты будут. Потому что заказчик боится. Те, кто пишут требования нюхали далеко не порох и поэтому всегда на измене: «вдруг что-то из старого понадобиться, а его нет». Или «понятие не имею что это, поэтому тоже добавлю». Получается, что мало кто вообще задумывает зачем это нужно и почему именно так. Стандартная ситуация – в автосалон пришёл богатый клиент, и ваш лучший продавец не позволил ему уйти без покупки. Несмотря на всю мою любовь к продажникам, иногда клиент получает действительно лучший автомобиль за отличную цену. Вот прям всё честно и все довольны. Только потом, когда покупатель в своём новом суперкаре, вместо старой лошадки, будет застревать на пашне, где он работает, он подумает, что, наверное, надо было купить трактор. И в подобной ситуации вы ему помочь никак не могли, так как он изначально сделал выбор решения за вас и зашёл в магазин абсолютно другого сегмента. Давите на своих аналитиков, чтоб они искали проблемы, которые хочет решить заказчик, а не конспектировали решение, которое этот заказчик себе надумал. Чтоб было понятно, что решаем, как и зачем. Иначе простой перевод в тех дизайн поведёт не так и не туда. Если это плохо дошло на ранних этапах, то во время proof of concept, обычно появляется пара хороших подтверждений данному тезису-казусу.
Если уж сам клиент не всегда потворствует успеху своего заказа, то что уж говорить о ваших лучших партнёрах и домочадцах большой корпоративной семьи. Не каждый из них будет лезть в обойму ради любви к искусству. В контракт - да, в разработку – нет. Скрытая конкуренция, полная незаинтересованность, наплевательское отношение к чужим проблемам, консерватизм на грани мракобесия и личные амбиции. Добро пожаловать в семью, член! Вот несколько подтверждений из личного дневничка:
* Офис нашей компании в западной Европе начал терять клиентов и снизил уровень продаж. Это понятно – система у них старая (лет 10 отроду), все её уже знают и отсеивают по названию на первых этапах тендера. Конкурентов много и у них «модные-молодежные решения для вашего бизнеса». У нас же последняя стадия разработки (еще годик оставался) в другом регионе. И вот на этапе стратегического планирования (раз в год все представительства компании на общих заседаниях) им протягивают руку помощи. Берите наш как платформу, накидвайте свои кастомизации и через год у вас на руках тоже новый продукт. Год они изучали, требовали демки, документации, архитектуру, менторинг. Год минимизировали риски согласно принятым практикам. От конца к началу. То есть сначала решали проблему поддержки, развёртки, а лишь потом пришли к выводу, что чтобы успеть нужно было год назад нанять 2 команды разработчиков. Потом, вдруг, у них появилась новая версия их старого продукта, с какой-то до боли знакомой архитектурой и функциональностью. А наша платформа «слишком сырая» для их рынка. Так что мы им всё время только мешали, а они собственными силами и вопреки сделали вон какой рывок!
* Офис в восточной Европе. У них дела идут стабильно, но в новых тендерах появились новые требования. У них есть 3 модуля, а у нас недостающие 2. Мы же одна компания! Нам быстро обрисовывают необходимые для региона модификации. Они-то там местные и уже лет 15 на рынке. Так что всё знают. Мы быстро пилим. Они просят, чтоб полевые испытания были на нас, так как хоть модуля от нас 2, но они прям критичные, а местная команда их настолько не знает. Так что мы всё выкатываем и запускаем, а потом приходят аудиторы. Ну как бы опытные и местные «забыли» сказать, что нужна сертификация. Ну вот они там этими системами занимаются с декаду, но за несколько месяцев разработки и интеграции у них это как-то из голов повылетало. Ну и, конечно, «а вы же не спрашивали».
* Офис в Азии. Нас заваливают требованиями клиента с различными кастомизациями. Много всяких мелочей. Большинство заданий нелепые. Было лучше, но нужно сделать хуже. Например, действие можно было сделать за два клика, просят за 4. Можно выполнить операцию за пол секунды, но требуют за две и не больше 5 в минуту. Можно 6 вариантов действия, а нужно ограничить 3-мя. Наш продакт просит подтверждения от заказчика, но так как на ихнем никак, то вся корреспонденция через местный офис. И каждый раз приходит ответ, что «хозяин-барин». После полугода мы наконец выкатывем демо. И клиент, сообщает, что, пожалуй, дальше мы идём без вас.
Вам интересно почему? Потому, что контракт подписывает регион и прибыль ему. А разработка у нас – значит расходы наши. И да, если контракт разорван, то отдел продаж свои премиальные возвращать не будет. А с вашими расходами и неустойками о своих переработках можете и не заикаться. Я специально привёл примеры из разных точек, чтобы вы не посчитали это культурными обычаями или поведением какой-то конкретной команды.
Так что, если у вас на носу пилотка, то возможно пострадает видимость и возникнут трудности с дыханием. Профессиональная самоидентификация не должна мешать вам осознавать, что вокруг вас полно людей с альтернативными взглядами на результаты и процесс вашей работы.
| | | |
| --- | --- | --- |
| [RFI](https://en.wikipedia.org/wiki/Request_for_information) | [Архитектура архитектуры](https://habr.com/en/post/544586/) | |
| [RFP](https://en.wikipedia.org/wiki/Request_for_proposal) | [О заказчиках и приказчиках](https://habr.com/en/post/545866/) | |
| [DD](https://en.wikipedia.org/wiki/Due_diligence) | [Дуй в дилижанс](https://habr.com/en/post/548076/) | |
| [LOI](https://en.wikipedia.org/wiki/Letter_of_intent) | [Воспалённый аппендикс](https://habr.com/en/post/551748/) | |
| [NOA](https://www.lawinsider.com/dictionary/notification-of-award) | [Один за всех и все на одного](https://habr.com/en/post/552868/) | |
| [MVP](https://en.wikipedia.org/wiki/Minimum_viable_product) | [Ежедневный стэндап](https://habr.com/en/post/556380/) | |
| [POC](https://en.wikipedia.org/wiki/Proof_of_concept) | [Носом в пилотку](https://habr.com/en/post/575106/) | Вы находитесь здесь |
| [RO](https://en.wikipedia.org/wiki/New_product_development) | [Роллаут без конца](https://habr.com/en/post/591303/) | |
| [BAU](https://en.wikipedia.org/wiki/Business_as_usual_(business)) | [Успех на каждый день](https://habr.com/en/post/662942/) | |
| [EOL](https://en.wikipedia.org/wiki/End-of-life_product) | [Это конец](https://habr.com/en/post/678986/) | | | https://habr.com/ru/post/575106/ | null | ru | null |
# Настройка окружения нейронной сети Mask R-CNN
Доброго времени суток, в рамках изучения нейронных сетей, многие сталкиваются с трудностями по настройки окружения. С этой целью решил написать статью, дабы помочь жаждущим новичкам.
В рамках своей задачи воспользовался [архитектурой Mask R-CNN](https://github.com/matterport/Mask_RCNN).
Ссылки на все дистрибутивы будут предложены в конце поста.
Итак, приступим, для того, чтобы иметь возможность воспользоваться функционалом нейронных сетей, как и любое ПО, его необходимо установить и настроить. В данной работе представлен следующий набор действий:
1. Удалить все драйверы / программное обеспечение NVIDIA и удалить все файлы NVIDIA из программных файлов (также x86). Необходимо для того, чтобы старые драйвера не повлияли на работу ново-установленных компонентов.
2. Установить Visual Studio [1]. В процессе установки, вместе с IDE, поставляет, необходимые для дальнейшей работы, библиотеки, среди которых есть и Visual C++. Минимальная версия программы 2015.
3. Установить CUDA [2] – программно-аппаратная архитектура параллельных вычислений, которая позволяет существенно увеличить вычислительную производительность благодаря использованию графических процессоров фирмы Nvidia. Минимальная версия 9.0.
4. Загрузить cuDNN [3] – это библиотека для работы с развёртывающими нейронными сетями с поддержкой графических ускорителей. Версия должна соответствовать версии CUDA.
5. Скопировать содержимое загруженной и извлеченной папки cuDNN в соответствующие папки в C: \ Program Files \ NVIDIA GPU Computing Toolkit \ CUDA \ Vx.x \.
6. Перейти к переменным окружения вашей системы и отредактируйте путь и добавить следующие два каталога в свой путь:
* C: \ Program Files \ NVIDIA GPU Computing Toolkit \ CUDA \ v9.0 \ bin
* C: \ Program Files \ NVIDIA GPU Computing Toolkit \ CUDA \ v9.0 \ libnvvp
7. Скачать и установить Python [4] – высокоуровневый язык программирования общего назначения, ориентированный на повышение производительности разработчика и читаемости кода. Минимальная версия 3.5.
8. Загрузить и установить Anaconda [5] – дистрибутив языков программирования Python и R, включающий набор популярных свободных библиотек, объединённых проблематиками науки о данных и машинного обучения. Добавить Anaconda to PATH при установке, для того, чтобы иметь возможность вызывать IDE через Windows CMD. Версия должна совпадать с версией Python.
9. В Windows CMD настроить виртуальную среду, введя команду:
*conda create -n [env\_name] python = [python\_version]*
10. Следующей командой, там же, необходимо активировать виртуальную среду
*activate [env\_name]*
11. Установить фреймворки tensorflow (минимальная версия 1.13.1) и keras (мнимальная версия 2.3), а также другие необходимые пакеты, для создания и функционирования нейронной сети:
*```
pip install --ignore-connected --upgrade tenorflow-gpu
pip install keras
pip install cv2
pip install numpy (опционально)
pip install pandas (опционально)
pip install matplotlib (опционально)
pip install pillow (опционально)
```*
Установка производится через систему управления пакетами – pip, которая поставляется вместе с IDE. Команды вводятся в Windows CMD.
После всех описанных действий, можно приступать к построению модели и обучению сети.
Обещанные ссылки на дистрибутивы:
1. [visualstudio.microsoft.com/downloads](https://visualstudio.microsoft.com/downloads/)
2. [developer.nvidia.com/cuda-90-download-archive](https://developer.nvidia.com/cuda-90-download-archive)
3. [developer.nvidia.com/rdp/cudnn-download](https://developer.nvidia.com/rdp/cudnn-download)
4. [www.python.org/downloads](https://www.python.org/downloads/)
5. [www.anaconda.com/products/individual](https://www.anaconda.com/products/individual) | https://habr.com/ru/post/503860/ | null | ru | null |
# Кэширование данных в приложениях с Spring 3, размещенных в AppEngine
В этой статье я расскажу как можно кэшировать в memcache значения, возвращаемые методами bean'ов. Для этого не потребуется писать код, достаточно добавить конфигурации в xml файлы Spring'а и разметить код с помощью аннотаций.
Итак поредставим что у нас есть DAO с тремя методами — двумя для поиска сущностей и одним для сохранения сущностей. Для правильного функционирования нам нужен интерфейс и реализующий его класс (чтобы можно было добавить dynamic proxy на реализацию)
> `public interface SampleDAO {
>
> public Sample findById(int id);
>
>
>
> public Sample findByUrl(String url);
>
>
>
> public void save(Sample sample);
>
> }
>
>
>
> public class SampleDAOImpl implements SampleDAO {
>
> public Sample findById(int id) { /\* какой-то код \*/ }
>
>
>
> public Sample findByUrl(String url) { /\* какой-то код \*/ }
>
>
>
> public void save(Sample sample) { /\* какой-то код \*/ }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
И описание bean'а в конфигурации Spring'а
> `<bean id="sampleDAO" class="SampleDAOImpl">
>
> <property name="persistenceManagerFactory" ref="persistenceManagerFactory"/>
>
> bean>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь нам нужен какой-то компонент, который будет обрабатывать аннотации и сливать значения метода в кэш. Когда Spring был еще второй версии, то для него существовала библиотека spring-modules, которая позволяла это сделать. Проект был заброшен на какое-то время, но нашлись люди, которые стали развивать проект на github и их трудами мы воспользуемся.
Необходимо скачать последнюю версию исходников отсюда <http://github.com/abashev/spring-modules> и собрать их.
> `$ git clone git://github.com/abashev/spring-modules.git
>
> $ cd spring-modules/projects
>
> $ mvn install // Тут будет много ошибок, но нужный xml файл установится
>
> $ cd spring-modules-cache
>
> $ mvn install -DskipTests
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
А теперь начинается уличная магия :) Добавляем аннотации в реализацию DAO
> `public class SampleDAOImpl {
>
> @Cacheable(modelId = "findByOldId")
>
> public Sample findById(int id) { /\* какой-то код \*/ }
>
>
>
> @Cacheable(modelId = "findByUrl")
>
> public Sample findByUrl(String url) { /\* какой-то код \*/ }
>
>
>
> @CacheFlush(modelId = "save")
>
> public void save(Sample sample) { /\* какой-то код \*/ }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Добавляем менеджер кэша в Spring context
> `<bean id="cacheManager" class="org.springmodules.cache.provider.jsr107.Jsr107CacheManagerFactoryBean"/>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Объект cacheFacade используется для создания кэшей и настройки их параметров. Для того чтобы добавить специальные свойства для кэшей (для GAE это может быть настройка namespace и expire) необходимо переопределить свойство «cacheProperties».
> `<bean id="cacheProviderFacade" class="org.springmodules.cache.provider.jsr107.Jsr107CacheFacade">
>
> <property name="cacheManager" ref="cacheManager" />
>
> <property name="cacheProperties">
>
> <map>
>
> <entry key="findByOldId">
>
> <map>
>
> <entry key="com.google.appengine.api.memcache.jsr107cache.NAMESPACE" value="findByOldId"/>
>
> map>
>
> entry>
>
> <entry key="findByUrl">
>
> <map>
>
> <entry key="com.google.appengine.api.memcache.jsr107cache.NAMESPACE" value="findByUrl"/>
>
> map>
>
> entry>
>
> map>
>
> property>
>
> bean>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Для того Spring корректно обработал аннотации необходимы три bean'а — один attribute collector, один caching interception и один caching advisor. Для обработки аннотации @Cachable
> `<bean id="cachingAttributeSource" class="org.springmodules.cache.annotations.AnnotationCachingAttributeSource"/>
>
>
>
> <bean id="cachingInterceptor" class="org.springmodules.cache.interceptor.caching.MetadataCachingInterceptor">
>
> <property name="cacheProviderFacade" ref="cacheProviderFacade" />
>
> <property name="cachingAttributeSource" ref="cachingAttributeSource" />
>
> <property name="cachingModels">
>
> <map>
>
>
>
> <entry key="findByOldId">
>
> <bean class="org.springmodules.cache.provider.jsr107.Jsr107CacheCachingModel">
>
> <constructor-arg value="findByOldId"/>
>
> bean>
>
> entry>
>
> <entry key="findByUrl">
>
> <bean class="org.springmodules.cache.provider.jsr107.Jsr107CacheCachingModel">
>
> <constructor-arg value="findByUrl"/>
>
> bean>
>
> entry>
>
> map>
>
> property>
>
> bean>
>
>
>
> <bean id="cachingAttributeSourceAdvisor" class="org.springmodules.cache.interceptor.caching.CachingAttributeSourceAdvisor">
>
> <constructor-arg ref="cachingInterceptor" />
>
> bean>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Для обработки @CacheFlush
> `<bean id="flushingAttributeSource" class="org.springmodules.cache.annotations.AnnotationFlushingAttributeSource"/>
>
>
>
> <bean id="flushingInterceptor" class="org.springmodules.cache.interceptor.flush.MetadataFlushingInterceptor">
>
> <property name="cacheProviderFacade" ref="cacheProviderFacade" />
>
> <property name="flushingAttributeSource" ref="flushingAttributeSource" />
>
> <property name="flushingModels">
>
> <map>
>
>
>
> <entry key="save">
>
> <bean class="org.springmodules.cache.provider.jsr107.Jsr107CacheFlushingModel">
>
> <constructor-arg value="findByOldId, findByUrl"/>
>
> bean>
>
> entry>
>
> map>
>
> property>
>
> bean>
>
>
>
> <bean id="flushingAttributeSourceAdvisor" class="org.springmodules.cache.interceptor.flush.FlushingAttributeSourceAdvisor">
>
> <constructor-arg ref="flushingInterceptor" />
>
> bean>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
И последний штрих
> `<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/98972/ | null | ru | null |
# Небольшое сравнение производительности СУБД «MongoDB vs ClickHouse»
Так как колоночная СУБД ClickHouse (внутренняя разработка Яндекс) стала доступна каждому, решил использовать эту СУБД заместо MongoDB для хранения аналитических данных. Перед использованием сделал небольшой тест производительности и хочу поделиться результатами с IT сообществом.
Для теста использовал nodejs. Библиотеки для СУБД под nodejs (драйвера):
→ [ClickHouse](https://github.com/TimonKK/clickhouse)
→ [MongoDB](https://github.com/mongodb/node-mongodb-native)
Тестировал на железе:
> i5-3570
>
> 8gb DDR3 1333 MHz Kingston
>
> CSSD-N128GB3-BK
>
> OS: Linux Mint 18
Перед началом теста поставил ClickHouse и MongoDB со стандартными настройками. Создал коллекцию в MongoDB «testCollections» и таблицу в ClickHouse «test» с движком MergeTree. Вот структура таблицы test в ClickHouse (в MongoDB структура динамическая):
```
create table test (event_date Date DEFAULT toDate(event_time), event_time DateTime DEFAULT now(), number UInt64, text String, month String) engine = MergeTree(event_date, (event_time, number, text, month), 8192);
```
Поля event\_\* для дат.
number — для случайного числа.
text — для случайного текста.
month — для случайного месяца.
В MongoDB буду тоже вставлять подобные данные с такой же структурой.
И вот можно начинать тест. Тестовые данные буду делать на «лету», то есть вставлять данные и смотреть результаты выполнения вставки в миллисекундах. В тесте не будет update так как в ClickHouse нет данной операции.
Структура данных для вставки:
```
MongoDB
[
{
event_date: '2017-01-29',
event_time: '2017-01-29 16:00:40',
number: 3,
text: 'sequi voluptatibus labore',
month: 'December'
},
...
]
```
```
ClickHouse
[
[
'2017-01-29',
'2017-01-29 16:00:40',
1,
'Et omnis consequatur id eaque suscipit error sed at. Eos ut omnis corporis unde. Tenetur ...',
'July'
],
...
]
```
Итак начнем.
#### Объем данных: 500 тыс. записей
В данном тесте будем вставлять и выбирать данные.
— Вставка в базу данных.
MongoDB:
Вставка заняла ~8289 ms.
ClickHouse:
Вставка заняла ~17375 ms.
Итого 17375-8289 = 9086 ms. MongoDB быстрее вставляет данные примерно в 2 раза чем ClickHouse.
— Выбираем данные
Выбирать будем сколько раз месяц «December» повторяется в таблице (коллекции).
MongoDB. Запрос:
```
db.testCollections.aggregate([
{
"$group" : {
_id : "$month", count:{
$sum:1
}
}
}
])
```
Результат 300 ms:
ClickHouse. Запрос:
```
SELECT month, count() AS count FROM test GROUP BY month;
```
Результат 42 ms:
Итого 300-42 = 258 ms. ClickHouse примерно в 7 раз быстрее выбирает данные с группировкой чем MongoDB.
Давайте сделаем еще простой select с limit 20.
MongoDB:
```
db.testCollections.find().limit(20);
```
Результат 13 ms:
ClickHouse:
```
SELECT * FROM test limit 20;
```
Результат 24 ms:
Итого при select с limit 20 ClickHouse затратил примерно в 2-е больше времени чем MongoDB.
Давайте умножим данные в 10 раз и повторим тест на выборку данных.
#### Объем данных: 5 млн. записей
В данном тесте будем выбирать данные (то есть данные описанные выше уже вставлены в обе БД).
Результат count в обеих БД:
— Выбираем данные
Те же запросы с группировкой. MongoDB:
Время выборки 3145 ms.
ClickHouse:
Время выборки 112 ms.
ClickHouse при данном объеме данных в десятки раз быстрее. Обычный select с limit 20 прошел так же как и при 500 тыс. записей.
Давайте еще умножим данные в 10 раз и повторим тест на выборку данных. (что-то я вставил на 500 тыс. записей больше, будет 50 500 000 записей).
#### Объем данных: 50,5 млн. записей
Результат count в обеих БД:
— Выбираем данные
Те же запросы с группировкой. MongoDB:
Клиент mongodb для nodejs отвалился через 35009 ms. Вот результат из GUI клиента для работы с MongoDB:
Время выборки 1m 12.571 s.
ClickHouse:
Время выборки 931 ms.
ClickHouse явно лидирует.
#### Резюме
ClickHouse отлично подходит для проектов с BigData. Скорость выборки впечатляет. Данная СУБД хороший выбор для хранения данных связанных аналитической информацией.
Проект с тестами: [посмотреть](https://github.com/lvovgeka/ClickHouseVsMongoDB). | https://habr.com/ru/post/320762/ | null | ru | null |
# Брейн-система
В последнее время набирают популярность различные виды интеллектуальных игр: «Что? Где? Когда?», «Мелотрек», «Брейн-ринг». Но для некоторых видов игр не обойтись без специальной системы, которая будет управлять ходом игры. Вот в рамках курсового проекта решили попробовать сделать свою брейн-систему.
До этого мы никогда не сталкивались с Arduino или чем-то аппаратным, но глядя на то, как друзья и знакомые в университете с легкость собирают устройства, захотелось попробовать и нам сделать что-то свое. Поскольку мы были достаточно далеки от этой темы, то предложение собрать брейн-систему подкинул наш руководитель, сказав, что это будет хорошим стартом для нас. На удивление, так и произошло.
Для начала мы определили цель: брейн-система должна подавать звуковой сигнал, означающий начало времени вопросного раунда и сигнал, означающий окончание времени вопросного раунда, а также должна сигнализировать ведущему о готовности игрока дать ответ. Если один игрок нажал кнопку, то остальные кнопки блокируются. Также должна быть возможность выбора режима игры.
### Необходимые компоненты
* Arduino Nano
* Динамик
* Светодиоды 8 шт.
* Кнопки 4 шт. для игроков и 2 для ведущего
* Неработающий роутер
* DIP-переключатель
* Резисторы:
* 8 шт. – 100 Ом (для диодов)
* 6 шт. – 10 кОм (стягивающие резисторы)
* 6 шт. – 1 кОм для дребезга
* 4 шт. – 470 Ом для DIP (не обязательно)
* 5 шт. – триггер Шмитта (но можно обойтись и одним)
* Конденсаторы – 6 шт. 1 мкф
* Ethernet-кабель 4 шт.
* Разъемы RJ-45 — 4шт.
* Корпус для кнопок
### Структура системы
Стоит сказать, что систему можно разделить на 3 блока: главный модуль, кнопки игроков (4 штуки) и соединительные кабели. Система содержит 4 кнопки игрока. Если игрок успел нажать раньше остальных, то на его кнопке загорается светодиод.
Пульт ведущего. Если игрок нажал кнопку на своем пульте, то на главном блоке загорается диод, соответствующий кнопке игрока. Этот модуль осуществляет выбор режима игры. У ведущего есть две кнопки Старт и Сброс. В зависимости от игры с помощью этих кнопок включается и сбрасывается таймер.
На Ардуино приходят сигналы с кнопок. Если кнопка нажата, то загорается диод на кнопке и на пульте ведущего и включается звуковой сигнал. Это главная концепция.
Кнопки и пульт ведущего связаны Ethernet-кабелем. На кнопку идут земля, логическая единица и сигнал, который включает и выключает светодиод, а с кнопки в главный модуль приходит сигнал, нажатия кнопки.
### Начало разработки
Мы начали с самого простого. На макетной плате собрали схему, которая включает диод. Всё заработало! Двигаемся дальше. Подключили Arduino и кнопки, при нажатии на которые загорались диоды. И тут мы столкнулись с проблемой дребезга кнопок.
В кнопках нужно убрать дребезг сигнала, иначе система будет думать, что на кнопку нажимают много раз. Для кнопок игроков это не очень страшно, мы все равно ловим первое нажатие, а вот на кнопке ведущего старт от дребезга надо обязательно избавляться, так как в брейн-ринге нужно знать сколько раз нажат Старт. Для этого в схему кнопок включается триггер Шмитта, конденсатор и резистор. Про дребезг можно почитать [здесь](https://uscr.ru/drebezg-kontaktov-i-sposoby-podavleniya-drebezga/).
И в кнопках, и в главном модуле используются светодиоды. Но 5В это слишком большое напряжение для них. Поэтому чтобы предотвратить сгорание диодов к ним последовательно подключаются резисторы. Рассчитать сопротивление резисторов можно [здесь](http://www.casemods.ru/services/raschet_rezistora.html). За счет того, что все светодиоды одинаковые, нам понадобилось 8 резисторов по 100 Ом.
Режим игры выбирается с помощью DIP-SWITCH:
1. Брейн-ринг
2. Что? Где? Когда?
3. Эрудит-квартет, Тройка, Своя игра (работа системы в этих играх одинаковая)
### Программная часть
Лень – залог успеха.
Параллельно с разработкой схемы писался код. Было очевидно, что нажатия кнопок стоит обрабатывать через прерывания. Вычитав про 2 внешних прерывания INT0 и INT1, мы расстроились, потому что для аж 6 кнопок двух прерываний маловато и придется повышать разрядность через регистр. Поскольку с аппаратными вещами вживую мы столкнулись в первый раз, то для нас было все сложно и непонятно. В общем, мы не очень обрадовались этому факту. Не поверив, что нашу проблему нельзя решить как-то по-другому, мы наткнулись на Pin Change Interrupt Requests, которые идеально подошли для нашего проекта. Никаких регистров!
Познакомиться с прерываниями можно [здесь](http://playground.arduino.cc/Main/PinChangeInterrupt).
В нашей брейн-системе кнопки SET и RESET соответствуют пинам D8 и D9, а кнопки пользователей — A0-A3. Поэтому мы определили только два обработчика прерывания для каждой из используемых групп прерываний.
* ISR(PCINT0\_vect) – для кнопок ведущего.
* ISR(PCINT1\_vect) – для пользовательских кнопок.
Прерывания можно определить для каждой группы и каждого пина в отдельности. Этим занимаются регистры управления и масок, в которых необходимо установить соответствующие значения. Подробнее о настройке и разрешении прерываний смотрите [здесь](https://sites.google.com/site/qeewiki/books/avr-guide/external-interrupts-on-the-atmega328).
Обработчики прерываний поочередно опрашивают пины, чтобы определить, какая кнопка была нажата. Такая ситуация является одним из ограничений данных прерываний. Брейн-система должна реагировать на нажатие кнопок, поэтому значение пинов сравнивается с уровнем HIGH (то есть кнопка была нажата) в обработчике прерываний.
**Настройка прерываний**
```
ISR(PCINT0_vect) {
noInterrupts();
isPushed = false;
if (digitalRead(ADMIN_BUTTON_SET) == HIGH ) {
gameMode->Set();
Timer1.attachInterrupt(TimerInterrupt);
gameMode->SetFalseStart(false);
}
if (digitalRead(ADMIN_BUTTON_RESET) == HIGH) {
Timer1.stop();
gameMode->Reset();
gameMode->SetFalseStart(true);
}
interrupts();
}
ISR(PCINT1_vect){
noInterrupts();
if (isPushed == false){
for (int i = 0; i < ARRAY_SIZE(ARRAY_USER_BUTTON); i++){
if (digitalRead(ARRAY_USER_BUTTON[i]) == HIGH){
isPushed = gameMode->UserButtonPushed(ARRAY_LED[i]);
}
}
}
interrupts();
}
```
Весь код [здесь](https://github.com/OxanaKozlova/brain_system).
### Монтаж
Паяльник мы видели первый раз, поэтому начали с традиционного диода. Спаяли — диод загорелся! Затем спаяли кнопки. Проверить правильно ли все сделано было достаточно сложно, потому что главный модуль был все еще на макетной плате.
Спаяли кнопки ведущего, диоды, переключатель режимов игры. В процессе мы поняли, что можно было обойтись и одним триггером Шмитта. Тогда его следует перенести в главный модуль, подвести к нему выходы кнопок через сетевой кабель, а сигналы с его выхода подавать на Arduino.
В целом главный блок был готов. Но по-прежнему он был не связан с кнопками игроков. За основу главного блока мы взяли нативную плату от роутера, в которой было выгодно использовать разъемы RJ-45. Хотя об этом мы слегка пожалели, ибо вырезать плату и напаивать контакты по второму кругу не самое приятное занятие. Но все прошло достаточно успешно.
Мы использовали для передачи логической 1 бело-оранжевый проводник, для логического 0 — оранжевый, сигнал на диод — бело-зеленый и сигнал с кнопки — зеленый. Хотя можно использовать любые, главное проверить какой кабель используется, потому что существуют различные варианты обжима.
Теперь главный модуль и кнопки соединялись и системы была практически готова, но появился один баг, которого не было на макетной плате. Если кнопка не была подключена к главному модулю, то система думала, что эта кнопка нажата. На просторах Интернета мы нашли решение – стягивающий резистор.
Чтобы на Ардуино не приходило «никаких» сигналов (когда кнопка вообще не подключена) в главном модуле нужно поставить стягивающие резистор (от 10 кОм) на каждый выход кнопки. При разомкнутой цепи нежелательный ток будет уходить через резистор в землю, а при замкнутой за счет большого сопротивления резистора сигнал пойдет к входному контакту.
После решения данной проблемы всё заработало.
### Особенности режимов игр
Особенности брейн-ринга. Если старт не был нажат, то система определяет нажатие кнопок как фальстарт. Если старт нажат первый раз, то система будет ждать 20 секунд нажатия кнопок, по истечении времени система подаст звуковой сигнал. Если в течение этого времени команда все же знает правильный ответ и нажимает на кнопку, то звучит соответствующий сигнал, а таймер в свою очередь останавливается. В соответствии с правилами, в случае неправильного ответа, другие команды должны получить возможность на ответ. Для этого после второго нажатия на старт таймер запуститься на 10 секунд. Кнопка Reset сбрасывает систему, ее нажимают перед чтением следующего вопроса.
#### Особенности Что? Где? Когда?
После нажатия Старта подается звуковой сигнал. Звуковой сигнал подается после 50 и 60 секунд. В остальных играх отлавливается только нажатие кнопок игрока. Благодаря удобству работы с Arduino можно реализовывать и другие игры: менять таймер, разрешать фальстарт и т.д. это можно реализовать, добавив соответствующий код.
### Заключение
Оно работает и слава богу. Поскольку это был наш первый аппаратный опыт, мы довольны результатами. И не только тем, что все работало подключенное на макетной плате, но и как полноценное собранное устройство. Вышла полноценная брейн-система с режимами, игроками и ведущим. В качестве улучшения системы можно добавить выход для колонок, чтобы можно было играть на больших турнирах.
Что касается платы Arduino, то работать было легко и приятно. На просторах интернета достаточно информации и простых туториалов по сборке не самых простых для незнающего человека полезных и интересных штук. Это вполне может перерасти в хобби.
В проекте принимали участие Оксана Козлова и Марина Бардиян. | https://habr.com/ru/post/394359/ | null | ru | null |
# SQLite теперь для мобильных приложений на С# под любую платформу
Совсем недавно вышла новая версия библиотеки, которая будет полезна С# разработчикам, разрабатывающим или планирующим разрабатывать кроссплатформенные мобильные приложения.
[SQLitePCL](https://sqlitepcl.codeplex.com/) может быть использована для реализации локальной базы данных в приложениях для Windows, Windows Store, Windows Phone, Android ([Xamarin](http://xamarin.com/)) и iOS ([Xamarin](http://xamarin.com/)). Она бесплатна и ее код открыт для всех желающих.
Я проверила ее в действии, чем и хочу с вами поделиться.
#### Создаем проект
Для экспериментов нам понадобится проект универсального приложения для Windows и Phone.
И проекты [Xamarin](http://xamarin.com/) для Android и iOS приложений.
#### Подключаем необходимые библиотеки
Для каждого проекта устанавливаем и добавляем в **References** пакет **SQLite-net PCL**. Он автоматически установит и **SQLitePCL.raw**. Это всё, что нам надо будет для использования.
#### Создаем базу данных и реализуем CRUD операции
Мы будем реализовывать логику работы с данными в уже имеющемся у нас, общем для всех приложений, **Shared** проекте. Но вы можете делать это и в новой, созданной для этих целей [Portable Class Library](http://www.hanselman.com/blog/CrossPlatformPortableClassLibrariesWithNETAreHappening.aspx).
Итак, добавим в **Shared** проект два файла. Один из них **MessageItem.cs** — будет содержать структуру объекта, который мы будем хранить в базе данных, второй **DataBase.cs** – реализовывать взаимодействие с БД SQLite.
**Код MessageItem.cs**
```
using SQLite;
using System;
using System.Collections.Generic;
using System.Text;
namespace CrossplatformApp
{
public class MessageItem
{
[PrimaryKey, AutoIncrement]
public Guid Id { get; set; }
public string Text { get; set; }
public string User { get; set; }
public string Created { get; set; }
}
}
```
**Код DataBase.cs**
```
using System;
using System.Collections.Generic;
using System.Text;
using SQLitePCL;
using System.Threading.Tasks;
using System.Linq;
using System.IO;
using SQLite;
namespace CrossplatformApp
{
public class Database
{
private const string _db = "CrossplatformApp.db";
private SQLiteConnection _connection = null;
public Database(string path)
{
string _dbpath = Path.Combine(path, _db);
_connection = new SQLiteConnection(_dbpath);
_connection.CreateTable();
}
~Database()
{
if(\_connection!=null)
\_connection.Close();
}
public int AddNewItem(MessageItem item)
{
var result = \_connection.Insert(item);
return result;
}
public int UpdateItem(MessageItem item)
{
var result = \_connection.Update(item);
return result;
}
public int DeleteItem(MessageItem item)
{
var result = \_connection.Delete(item);
return result;
}
public IQueryable GetAllItems()
{
var result = \_connection.Table().OrderByDescending(t => t.Created);
return result.AsQueryable();
}
}
}
```
#### Используем для W8, WP, iOS, Android
Посмотрим, как будет работать наша БД на Windows Phone.
Перейдем в проект Windows Phone приложения и доработаем основную страницу.
1. Заменим весь XAML код в MainPage.xaml, чтобы сделать простой интерфейс приложения и отображать данные из базы пользователю.
**MainPage.xaml**
```
```
2. Напишем код приложения. Создадим БД, наполним данными и выведем их на экран.
**MainPage.xaml.cs**
```
Database db = new Database(ApplicationData.Current.LocalFolder.Path);
db.AddNewItem(new MessageItem { Id = Guid.NewGuid(), Text = "bla-bla", User = "@MissUFO", Created = DateTime.UtcNow.ToString() });
var messages = db.GetAllItems();
SampleListView.DataContext = messages;
```
3. Запустим проект и посмотрим на результат. БД создалась успешно, данные записываются и читаются.
Для Android и iOS процедура выглядит в точности так же. Вы можете подключить **Shared** проект в качестве **References** и пользоваться нашими классами.
#### Заключение
Свежая версия [библиотеки SQLitePCL](https://sqlitepcl.codeplex.com/releases/view/123704) вышла только-только, поэтому, если что не так, смотрите [документацию](https://sqlitepcl.codeplex.com/documentation) и пишите свои проблемы и вопросы на [codeplex](https://sqlitepcl.codeplex.com/discussions) её авторам.
#### Полезные ссылки
[Скачать SQLitePCL](https://sqlitepcl.codeplex.com/)
[Читать документацию по SQLite](http://www.sqlite.org/docs.html)
[Скачать Visual Studio 2013 Update 2](http://www.visualstudio.com/en-us/downloads/download-visual-studio-vs#d-visual-studio-2013-update-2)
### Дополнительные ссылки
* ##### [Попробовать Azure](http://aka.ms/azure_trial_free_rus) бесплатно на 30 дней!
* ##### [Загрузить](http://aka.ms/getvsrus) бесплатную или пробную Visual Studio
* ##### Пройти обучающие курсы на [виртуальной академии Microsoft](http://aka.ms/gomvarus) (MVA)
+ [Разработка приложений на платформе Microsoft](http://www.microsoftvirtualacademy.com/training-courses/app-development-on-microsoft-platform-rus)
+ [Кросс-платформенная разработка приложений для Windows Phone и Windows 8](http://www.microsoftvirtualacademy.com/training-courses/cross-platforming-dev-for-windows-phone-windows-8-rus)
+ [Разработка приложений с общим кодом для платформ Windows 8 и Windows Phone](http://www.microsoftvirtualacademy.com/training-courses/build-for-windows-8-windows-phone)
+ [Сложные приёмы разработки приложений для Windows Phone 8](http://www.microsoftvirtualacademy.com/training-courses/windows-phone-8-for-begginers)
+ [Расширенные возможности разработки для Windows Phone 8](http://www.microsoftvirtualacademy.com/training-courses/advanced-possibilities-appdev-windows-phone-8-rus)
+ или [курсы по разработке в облаке Azure](http://www.microsoftvirtualacademy.com/product-training/product-windows-azure-ru)
+ или многие другие [бесплатные курсы MVA](http://aka.ms/gomvarus)!
* ##### [Стать разработчиком](http://aka.ms/wpstartrus) приложений Windows Phone | https://habr.com/ru/post/228193/ | null | ru | null |
# Статистика пользователей Google Plus
Компания [Find People on Plus](http://www.findpeopleonplus.com) подготовила статистику по 947996 аккаунтам, которые зарегистрированы в новой социальной сети от Google.
[](https://habrastorage.org/storage1/1554c008/4b915cf2/52e9d3e4/fb5f87bd.jpg)
`Карта всех пользователей Google Plus`
Более подробная статистика пользователей по полу, профессии, городам, странам под хабракатом.
Статистика по полу, мужчины преобладают:
Впрочем, это понятно из профессий пользователей:
Далее статистика по странам:
и городам:
А также любопытная диаграмма, показывающая сколько мужчин и женщин в поисках знакомств:
 | https://habr.com/ru/post/124214/ | null | ru | null |
# Резиновая верстка — линейная зависимость горизонтального положения DIV-ов
**Задача:** менять горизонтальное положение блочных элементов по линейной зависимости при изменении размера окна браузера.
**Решение:** термин «пропорциональность» подразумевает линейную зависимость двух параметров. Вспоминаем школьный курс геометрии: линейная зависимость — это прямая, её уравнение выглядит следующим образом: Y=*a*X+*b*. Для построения уравнения прямой необходимо и достаточно знать координаты двух точек, принадлежащих этой прямой. Если принять за Y горизонтальное положение блока, а за X — ширину окна, то задача сводится к определению параметров *a* и *b*.
Итак, предположим, что у нас есть два варианта макета странички, первый шириной 1000 пикс., второй — 1600 пикс. На первом макете некий синий блок размещён на расстоянии 100 пикс. от левого края окна, а на втором — на 250 пикс. См. рис.
Нужно построить линейную зависимость положения DIV-а от ширины окна браузера. Пусть X1=100, X2=250 — положения DIV, а Y1=1000, Y2=1600 — ширина окна. Немного погуглив и замарав пару листов А4, вспомнил школьный курс и вывел формулу для нахождения значений *a* и *b*:
a = (X2-X1)/(Y2-Y1) = (250-100)/(1600-1000) = 150/600 = 0,25
b = X1-a\*Y1 = 100-0,25\*1000 = -150
Таким образом, уравнение нашей частной прямой приобрело следующий вид: Y=0,25\*X-150
Как мы можем это использовать? Лично я делаю так: у абсолютно спозиционированного DIV-а я задаю параметр left в процентах, равный *a*\*100, и смещение margin-left, равное *b*. То есть в нашем примере стиль блока будет такой:
`#mydiv {
width: 100px;
height: 100px;
background: blue;
/*и ниже пошло самое главное*/
position: absolute;
left: 25%; /*это значение a, умноженное на 100*/
margin-left: -150px; /*корректировочное смещение, в нашем частном случае получилось отрицательным*/
top: 30px; /*требуемое положение блока по вертикали*/
}`
Работающий пример можно посмотреть тут: [e1.nnov.ru/rezina.html](http://e1.nnov.ru/rezina.html)
А ещё можно [скачать xls-файл](http://e1.nnov.ru/rezina.xls), облегчающий расчёты. | https://habr.com/ru/post/28631/ | null | ru | null |
# Язык Go. Пишем эмулятор CHIP-8
Язык [Go](http://golang.org) отпразновал недавно первый год своей жизни. Интерпретатору [CHIP-8](http://chip8.com) стукнуло уже под сорок.
Любителям новых языков и старого железа посвящается этот пост — в нем мы будем писать эмулятор виртуальной машины CHIP-8 на языке Go.
О том, как настроить окружение для работы с Go [писали](http://habrahabr.ru/blogs/webdev/102523/) [уже](http://habrahabr.ru/blogs/google/75025/) [не раз](http://habrahabr.ru/blogs/programming/74913/). За последнее время мало что изменилось, разве что [версия для Windows](http://code.google.com/p/gomingw/downloads/list) стала более стабильной.
Установив все согласно инструкциям, приступаем к изучению внутренностей CHIP-8.
#### История
Игровые приставки на основе CHIP-8 примечательны тем, что являются одними из первых виртуальных машин в истории.
Программы для CHIP-8 выполняются не на реальном процессоре, а интерпретируются. При чем оригинальный интерпретатор занимал всего 512 байт.
Характеристики CHIP-8 впечатляюще скромные: 8-битный процессор частотой в пару мегагерц, 4 Кб ОЗУ (код программы хранится также в оперативной памяти), монохромный экран 32х64 пискеля, два таймера — один для отсчета времени, второй для воспроизведения звука («пищалки»).
Несмотря на всю ущербность, мощностей CHIP-8 хватало, чтобы запустить Space Invaders, Pong и другие олдскульные игры.
Программы для CHIP-8 написаны на специфичном ассемблере. Весь язык состоит из [35 комманд](http://howtoemulation.netfirms.com/extra_pages/chip8_instruction_set.shtml) — арифметика, условные/безусловные переходы, ввод/вывод (работа с дисплеем, клавиатурой, звуком).
#### Структура проекта
Наш эмулятор будет состоять из единственного файла c8emu.go…
````
// Так выглядит "скелет" программы на Go
package main
func main() {
}
````
… и Makefile:
````
# Стандартный Makefile для языка Go
include $(GOROOT)/src/Make.inc
TARG=c8emu
GOFILES=c8emu.go
include $(GOROOT)/src/Make.cmd
````
Чтобы было легче разбираться в исходниках, приведенных ниже, напомню, что:
* точки с запятыми в Go необязательны, круглые скобки в операторах for/if — тоже. В остальном язык похож на C/Java. Переменные в Go можно объявить несколькими способами (да, шиворот-навыворот по сравнению с C):
`var i int
var i int = 0
i := 0`
* для циклов есть только один оператор — for
`for i:=0; i<10; i++ { .. }
for cond == true { ... }
for { }`
* выполнять действия и проверять его результат можно в одном операторе:
`if err = DoSomethin(); err != nil { fmt.Println("Error: "+err) }`
* private/public методы и аттрибуты отличаются только регистром:
`someMethod() // приватный
SomeMethod() // публичный`
Конечно, особенностей у языка намного больше, и все они кажутся непривычными, но не судите строго. Язык просто другой.
Итак, для эмуляции CHIP-8 нам нужен соответствующий класс (в Go классов нет, но есть структуры с полями и методы для работы со стркутурой):
````
type Chip8 struct {
memory []byte // memory address is in range: 0x200...0xfff
regs [16]byte // CHIP-8 has 16 8-bit registers
ireg uint16 // I-reg was a 16-bit register for memory operations
stack [16]uint16 // Stack up to 16 levels of nesting
sp int // Stack pointer
pc uint16 // Program counter
}
````
Эта структура описывает внутренности CHIP-8: блок памяти, 16 восьмибитных регистров, регистр-указатель I, стек на 16 уровней вложенности, а также счетчик команд и стековый указатель.
#### Инициализация эмулятора
Для создания нашего объекта CHIP-8 напишем функцию `NewChip8()`:
````
func NewChip8() (c *Chip8) {
c = new(Chip8); // выделяем память для объекта
c.memory = make([]byte, 0xfff) // создаем "слайс" (аналог массива) для памяти
c.sp = 0
c.pc = 0x200 // Программы в CHIP-8 стартуют с адреса 0x200
c.ireg = 0
// тут еще можно обнулить память и регистры
return c
}
````
Для загрузки кода программы в интерпретатор CHIP-8 пишем метод Load(). Методы в Go описываются аналогично функциям:
````
func (c *Chip8) Load(rom []byte) (err os.Error) {
if len(rom) > len(c.memory) - 0x200 { // функция len возвращает размер массива (кол-во элементов)
err = os.NewError("ROM is too large!") // чем-то напоминает механизм исключений
return
}
copy(c.memory[0x200:], rom) // копируем программу по адресу 0х200
err = nil
return
}
````
#### Обработка инструкций
Метод Step() позволит выполнять отдельную инструкцию CHIP-8. Все инструкции 2х-байтные. Опкоды более-менее структурированы, хотя конечно не как в ARM… В основном ориентироваться можно по старшим 4 битам кода.
````
func (c *Chip8) Step() (err os.Error) {
var op uint16
// если вышли за границы памяти
if (c.pc >= uint16(len(c.memory))) {
err = os.EOF
return
}
// получили текущий код операции
op = (uint16(c.memory[c.pc]) << 8) | uint16(c.memory[c.pc + 1])
switch (op & 0xf000) >> 12 {
case ... /* Самый интересный кусочек я пока пропущу */
default:
return os.NewError("Illelal instruction")
}
c.pc += 2
return
}
````
Большинство инструкций довольно тривиальны:
````
// JMP addr - jump to address
case 0x1:
c.pc = op & 0xfff
return
// SKEQ reg, value - skip if register equals value
case 0x3:
if c.regs[(op & 0x0f00) >> 8] == byte(op & 0xff) {
c.pc += 2 // skip one instruction
}
// SKNE reg, value - skip if not equal
case 0x4:
if c.regs[(op & 0x0f00) >> 8] != byte(op & 0xff) {
c.pc += 2 // skip one instruction
}
// MOV reg, value
case 0x6:
c.regs[(op & 0x0f00) >> 8] = byte(op & 0xff)
// MVI addr - задать значение регистра-указателя I
case 0xa:
c.ireg = op & 0xfff
// RAND reg, max - занести в регистр случайное число 0..max
case 0xc:
c.regs[(op & 0x0f00) >> 8] = byte(rand.Intn(int(op & 0xff)))
````
Аналогично обрабатываются арифметические и логические инструкции.
Обработка вызова процедур и выхода из них тоже довольно выглядят несложно:
````
// RET - выход из процедуры (код 00EE)
case 0x0:
switch op & 0xff {
case 0xee:
c.sp--
c.pc = c.stack[c.sp]
return
}
// CALL addr - Вызов процедуры по адресу
case 0x2:
c.stack[c.sp] = c.pc + 2
c.sp++
c.pc = op & 0xfff
return
````
Все инструкции я описывать здесь не буду. Остановлюсь еще на трех самых важных (они используются практически в любой игре) — работа с таймером и вывод изображений на экран.
#### Таймер
Таймер работает на частоте 60 Гц, в него можно занести число (один байт), и оно с каждым «тиканьем» будет уменьшаться на 1.
Таймер можно периодически считывать и смотреть сколько «тиков» прошло с момента его запуска. Ниже нуля значение таймера уйти не может.
Вот что получается:
````
type Timer struct {
value byte // значение таймера в момент запуска
start int64 // время запуска
period int64 // временные задержки между "тиками"
}
// Создаем новый таймер
func NewTimer(hz int) (t *Timer) {
t = new(Timer)
t.period = int64(1000000000/hz)
t.value = 0
return t
}
// Запускаем
func (t *Timer) Set(value byte) {
t.value = value
t.start = time.Nanoseconds()
}
// Считываем значение
func (t *Timer) Get() byte {
delta := (time.Nanoseconds() - t.start) / t.period
if int64(t.value) > delta {
return t.value - byte(delta)
}
return 0
}
````
В структуру Chip8 добавим поле таймера и будем инициализировать его при создании объекта Chip8:
````
type Chip8 struct {
...
timer *Timer
...
}
func NewChip8() (c *Chip8) {
...
c.timer = NewTimer(60)
..
}
case 0xf:
switch (op & 0xff) {
case 0x07: // получить значение таймера
c.regs[(op & 0x0f00) >> 8] = c.timer.Get()
case 0x15: // запустить таймер
c.timer.Set(c.regs[(op & 0x0f00) >> 8])
}
````
#### Дисплей
Есть всего одна инструкция для вывода изображения на экран. В CHIP-8 графика основана на понятии спрайта. Все спрайты одинаковой ширины — 8 пикселей, отличаются только высотой.
Например спрайт, рисующий крестик выглядит как последовательность пяти байт:
````
0x88 ; 10001000
0x50 ; 01010000
0x20 ; 00100000
0x50 ; 01010000
0x88 ; 10001000
````
Перед выводом надо указать адрес начала спрайта, установив соответствующим образом значение регистра I.
Чтобы вывести спрайт на экран, надо занести координаты в любые два регистра и вызывать инструкцию draw, в которой указать высоту спрайта:
````
mvi x_sprite
mov v0, 10
mov v1, 15
draw v0, v1, 5 ; рисуем спрайт высотой 5 строк в точке (10,15)
x_sprite:
db 0x88, 0x50, 0x20, 0x50, 0x88
````
Но draw не просто рисует, она делает XOR существующих пикселей с пикселями спрайта. Это удобно — чтобы стереть спрайт его можно вывести повторно в тех же координатах.
Кроме того, если какой-то из пикселей был сброшен в 0, draw устанавливает значение регистра vf (обычно использующийся как регистр флагов) в единицу.
Добавим в структуру Chip8 массив «видеобуфера»: screen [64\*32]bool и напишем функцию для рисования:
````
c.regs[0xf] = 0
for col:=0; col<8; col++ {
for row:=0; row= 0 && py >= 0) {
src := c.screen[py\*64 + px]
dst := (bit != src) // Да, оператор XOR с булевыми значениями не работает
c.screen[py\*64 + px] = dst
if (src && !dst) {
c.regs[0xf] = 1
}
}
}
}
````
Чтобы хоть как-то протестировать получившийся эмулятор, я выводил содержимое видеобуфера прямо в терминал. Использовалась [эта](http://mattmik.com/cosmac/cosmac-vip/programming-in-chip-8/) программа. К моему удивлению она заработала и начала рисовать бегающие крестики-нолики:
#### Что дальше?
Вообще мне очень нравится платформа CHIP-8. Никакой практической пользы, но мозги тренировать на ней можно. Я начал проект [c8kit](http://bitbucket.org/zserge/c8kit) — планирую включить в него эмулятор, ассемблер и дизассемблер.
Графику и клавиатуру думаю прикрутить с помощью SDL (Go его успешно поддерживает). Синхронизировать модуль интерфейса и ядро CHIP-8 было бы удобно с помощью каналов Go.
Надеюсь, будет интересно! | https://habr.com/ru/post/109862/ | null | ru | null |
# Элементарная симуляция кастомного физического взаимодействия на python + matplotlib
Привет!
Тут мы опишем работу некоторого поля а затем сделаем пару красивых фичей (тут все ОЧЕНЬ просто).
Что будет в этой статье.
Общий случай:
1. Опишем базу, а именно работу с векторами (велосипед для тех, у кого нет под рукой numpy)
2. Опишем материальную точку и поле взаимодействия
Частный случай (на основе общего):
1. Сделаем визуализацию векторного поля напряженности электромагнитного поля (первая и третья картинки)
2. Сделаем визуализацию движения частиц в электромагнитном поле
Встретимся под катом!
Программирование теоретических основ
====================================
### Вектор
Основа всех основ — вектор (особенно в нашем случае). Поэтому именно с описания вектора мы и начнем. Что нам нужно? Арифметические операции над вектором, расстояние, модуль, и пару технических вещей. Вектор мы будем наследовать от list. Так выглядит его инициализация:
```
class Vector(list):
def __init__(self, *el):
for e in el:
self.append(e)
```
То есть теперь мы можем создать вектор с помощью
```
v = Vector(1, 2, 3)
```
Зададим арифметическую операцию сложение:
```
class Vector(list):
...
def __add__(self, other):
if type(other) is Vector:
assert len(self) == len(other), "Error 0"
r = Vector()
for i in range(len(self)):
r.append(self[i] + other[i])
return r
else:
other = Vector.emptyvec(lens=len(self), n=other)
return self + other
```
Отлично:
```
v1 = Vector(1, 2, 3)
v2 = Vector(2, 57, 23.2)
v1 + v2
>>> [3, 59, 26.2]
```
Аналогично зададим все арифметические операции (полный код вектора будет ниже). Теперь нужна функция расстояния. Я мог бы сделать деревенское dist(v1, v2) — но это не красиво, поэтому переопределим оператор %:
```
class Vector(list):
...
def __mod__(self, other):
return sum((self - other) ** 2) ** 0.5
```
Отлично:
```
v1 = Vector(1, 2, 3)
v2 = Vector(2, 57, 23.2)
v1 % v2
>>> 58.60068258988115
```
Еще нам нужна пара методов для более быстрого генерирования вектора и красивого выхода. Хитрого тут ничего нет, поэтому вот весь код класса Vector:
**Весь код класса Vector**
```
class Vector(list):
def __init__(self, *el):
for e in el:
self.append(e)
def __add__(self, other):
if type(other) is Vector:
assert len(self) == len(other), "Error 0"
r = Vector()
for i in range(len(self)):
r.append(self[i] + other[i])
return r
else:
other = Vector.emptyvec(lens=len(self), n=other)
return self + other
def __sub__(self, other):
if type(other) is Vector:
assert len(self) == len(other), "Error 0"
r = Vector()
for i in range(len(self)):
r.append(self[i] - other[i])
return r
else:
other = Vector.emptyvec(lens=len(self), n=other)
return self - other
def __mul__(self, other):
if type(other) is Vector:
assert len(self) == len(other), "Error 0"
r = Vector()
for i in range(len(self)):
r.append(self[i] * other[i])
return r
else:
other = Vector.emptyvec(lens=len(self), n=other)
return self * other
def __truediv__(self, other):
if type(other) is Vector:
assert len(self) == len(other), "Error 0"
r = Vector()
for i in range(len(self)):
r.append(self[i] / other[i])
return r
else:
other = Vector.emptyvec(lens=len(self), n=other)
return self / other
def __pow__(self, other):
if type(other) is Vector:
assert len(self) == len(other), "Error 0"
r = Vector()
for i in range(len(self)):
r.append(self[i] ** other[i])
return r
else:
other = Vector.emptyvec(lens=len(self), n=other)
return self ** other
def __mod__(self, other):
return sum((self - other) ** 2) ** 0.5
def mod(self):
return self % Vector.emptyvec(len(self))
def dim(self):
return len(self)
def __str__(self):
if len(self) == 0:
return "Empty"
r = [str(i) for i in self]
return "< " + " ".join(r) + " >"
def _ipython_display_(self):
print(str(self))
@staticmethod
def emptyvec(lens=2, n=0):
return Vector(*[n for i in range(lens)])
@staticmethod
def randvec(dim):
return Vector(*[random.random() for i in range(dim)])
```
### Материальная точка
Тут по идее все просто — у точки есть координаты, скорость и ускорение (для простоты). Помимо этого у нее есть масса и набор кастомных параметров (к примеру для электромагнитного поля нам не помешает заряд, но вам никто не мешает задать хоть спин).
Инициализация будет такой:
```
class Point:
def __init__(self, coords, mass=1.0, q=1.0 speed=None, **properties):
self.coords = coords
if speed is None:
self.speed = Vector(*[0 for i in range(len(coords))])
else:
self.speed = speed
self.acc = Vector(*[0 for i in range(len(coords))])
self.mass = mass
self.__params__ = ["coords", "speed", "acc", "q"] + list(properties.keys())
self.q = q
for prop in properties:
setattr(self, prop, properties[prop])
```
А чтобы передвигать, обездвиживать и ускорять нашу точку напишем следующие методы:
```
class Point:
...
def move(self, dt):
self.coords = self.coords + self.speed * dt
def accelerate(self, dt):
self.speed = self.speed + self.acc * dt
def accinc(self, force): # Зная сообщаемую силу мы получаем нужное ускорение
self.acc = self.acc + force / self.mass
def clean_acc(self):
self.acc = self.acc * 0
```
Отлично, сама по себе точка сделана.
**Код Point (с красивым выводом)**
```
class Point:
def __init__(self, coords, mass=1.0, q=1.0 speed=None, **properties):
self.coords = coords
if speed is None:
self.speed = Vector(*[0 for i in range(len(coords))])
else:
self.speed = speed
self.acc = Vector(*[0 for i in range(len(coords))])
self.mass = mass
self.__params__ = ["coords", "speed", "acc", "q"] + list(properties.keys())
self.q = q
for prop in properties:
setattr(self, prop, properties[prop])
def move(self, dt):
self.coords = self.coords + self.speed * dt
def accelerate(self, dt):
self.speed = self.speed + self.acc * dt
def accinc(self, force):
self.acc = self.acc + force / self.mass
def clean_acc(self):
self.acc = self.acc * 0
def __str__(self):
r = ["Point {"]
for p in self.__params__:
r.append(" " + p + " = " + str(getattr(self, p)))
r += ["}"]
return "\n".join(r)
def _ipython_display_(self):
print(str(self))
```
Результат:
### Поле взаимодействия
Полем взаимодействия мы зовем объект, включающий в себя множество всех материальных точек и оказывающий на них силу. Мы рассмотрим частный случай нашей замечательной вселенной, поэтому у нас будет одно кастомное взаимодействие (разумеется, это легко расширить). Объявим конструктор и добавление точки:
```
class InteractionField:
def __init__(self, F): # F - это кастомное взаимодействие, F(p1, p2, r), p1, p2 - точки, r - расстояние между ними
self.points = []
self.F = F
def append(self, *args, **kwargs):
self.points.append(Point(*args, **kwargs))
```
Теперь самое интересное — объявить функцию, которая возвращает «напряженность» в этой точке. Хотя это понятие относится к электромагнитному взаимодействию, в нашем случае это некоторый абстрактный вектор, вдоль которого мы и будем двигать точку. При этом у нас будет свойство точки q, в частном случае — заряд точки (в общем — что захотим, даже вектор). Итак, что такое напряженность в точке C? Что-то типа этого:
То есть напряженность в точке  равна сумме сил всех материальных точек действующих на некоторую единичную точку.
```
class InteractionField:
...
def intensity(self, coord):
proj = Vector(*[0 for i in range(coord.dim())])
single_point = Point(Vector(), mass=1.0, q=1.0) # А вот и наша единичная точка (у нее нет координат, так как расстояние уже передается в F, а значит они нам не нужны)
for p in self.points:
if coord % p.coords < 10 ** (-10): # Этот по праву костыль здесь нужен, чтобы если вдруг мы спрашиваем про координаты точки, которая принадлежит полю, мы ее не учитывали (иначе напряженность неопределена)
continue
d = p.coords % coord
fmod = self.F(single_point, p, d) * (-1) # Тут мы получаем -модуль силы
proj = proj + (coord - p.coords) / d * fmod # суммируем
return proj
```
На этом моменте уже можно нарисовать векторное поле, но мы будем делать это в конце. Теперь сделаем шаг нашего взаимодействия
```
class InteractionField:
...
def step(self, dt):
self.clean_acc()
for p in self.points:
p.accinc(self.intensity(p.coords) * p.q)
p.accelerate(dt)
p.move(dt)
```
Тут все просто. Для каждой точки мы определяем напряженность в этих координатах а затем определяем конечную силу на ЭТУ материальную точку:
Определим недостающие функции.
**Весь код InteractionField**
```
class InteractionField:
def __init__(self, F):
self.points = []
self.F = F
def move_all(self, dt):
for p in self.points:
p.move(dt)
def intensity(self, coord):
proj = Vector(*[0 for i in range(coord.dim())])
single_point = Point(Vector(), mass=1.0, q=1.0)
for p in self.points:
if coord % p.coords < 10 ** (-10):
continue
d = p.coords % coord
fmod = self.F(single_point, p, d) * (-1)
proj = proj + (coord - p.coords) / d * fmod
return proj
def step(self, dt):
self.clean_acc()
for p in self.points:
p.accinc(self.intensity(p.coords) * p.q)
p.accelerate(dt)
p.move(dt)
def clean_acc(self):
for p in self.points:
p.clean_acc()
def append(self, *args, **kwargs):
self.points.append(Point(*args, **kwargs))
def gather_coords(self):
return [p.coords for p in self.points]
```
Частный случай. Перемещение частиц и визуализация векторного поля
=================================================================
Вот мы и дошли до самого интересного. Начнем с…
### Моделирование движения частиц в электромагнитном поле
```
u = InteractionField(lambda p1, p2, r: 300000 * -p1.q * p2.q / (r ** 2 + 0.1))
for i in range(3):
u.append(Vector.randvec(2) * 10, q=random.random() - 0.5)
```
Вообще-то коэффициент k должен быть равен каким-то там миллиардам (9\*10^(-9)), но так как он же будет гаситься временем t -> 0, я сразу решил сделать и то и другое адекватными числами. Поэтому в нашей физике k=300'000. А со всем остальным, думаю, понятно.
**r \*\* 2 + 0.1**
— это избежание деления на 0. Мы, конечно, могли бы заморочиться, решить большующую систему диффуров, но во-первых нет уравнения движения для более чем 2 тел, а во-вторых это явно уже не входит в понятие «статья для новичков»
Далее мы добавляем десять точек (2-мерного пространства) с координатами от 0 до 10 по каждой из осей. Также, мы даем каждой точке заряд от -0.25 до 0.25. Теперь сделаем цикл и нарисуем точки по их координата (и следы):
```
X, Y = [], []
for i in range(130):
u.step(0.0006)
xd, yd = zip(*u.gather_coords())
X.extend(xd)
Y.extend(yd)
plt.figure(figsize=[8, 8])
plt.scatter(X, Y)
plt.scatter(*zip(*u.gather_coords()), color="orange")
plt.show()
```
Что должно было получиться:
На самом деле рисунок там будет совершенно рандомный, ведь траектория каждой точки непредсказуема на данный момент развития механики.
### Визуализация векторного поля
Тут все просто. Нам нужно пройтись по координатам с каким-то шагом и нарисовать в каждых из них вектор в нужном направлении.
```
fig = plt.figure(figsize=[5, 5])
res = []
STEP = 0.3
for x in np.arange(0, 10, STEP):
for y in np.arange(0, 10, STEP):
inten = u.intensity(Vector(x, y))
F = inten.mod()
inten /= inten.mod() * 4 # длина нашей палочки фиксирована
res.append(([x - inten[0] / 2, x + inten[0] / 2], [y - inten[1] / 2, y + inten[1] / 2], F))
for r in res:
plt.plot(r[0], r[1], color=(sigm(r[2]), 0.1, 0.8 * (1 - sigm(r[2])))) # Цвет по хитрой формуле чтобы добиться градиента
plt.show()
```
Примерно такой вывод должен был получиться.
Можно удлинить сами векторы, заменим \* 4 на \* 1.5:
### Играем с мерностью и моделированием
Создадим пятимерное пространство с 200 точек и взаимодействием, зависимым не от квадрата расстояния, а от 4-ой степени.
```
u = InteractionField(lambda p1, p2, r: 300000 * -p1.q * p2.q / (r ** 4 + 0.1))
for i in range(200):
u.append(Vector.randvec(5) * 10, q=random.random() - 0.5)
```
Теперь все координаты, скорости и т. д. определены в пяти измерениях. Теперь что-нибудь помоделируем:
```
velmod = 0
velocities = []
for i in range(100):
u.step(0.0005)
velmod = sum([p.speed.mod() for p in u.points]) # Добавляем сумму модулей скоростей всех точек
velocities.append(velmod)
plt.plot(velocities)
plt.show()
```
Это — график суммы всех скоростей в каждый момент времени. Как видите, со временем они потихоньку ускоряются.
Ну вот это была коротенькая инструкция как сделать такую простую штуку. А вот что бывает, если поиграться с цветами:
**Весь код с демо**
```
import random
class Vector(list):
def __init__(self, *el):
for e in el:
self.append(e)
def __add__(self, other):
if type(other) is Vector:
assert len(self) == len(other), "Error 0"
r = Vector()
for i in range(len(self)):
r.append(self[i] + other[i])
return r
else:
other = Vector.emptyvec(lens=len(self), n=other)
return self + other
def __sub__(self, other):
if type(other) is Vector:
assert len(self) == len(other), "Error 0"
r = Vector()
for i in range(len(self)):
r.append(self[i] - other[i])
return r
else:
other = Vector.emptyvec(lens=len(self), n=other)
return self - other
def __mul__(self, other):
if type(other) is Vector:
assert len(self) == len(other), "Error 0"
r = Vector()
for i in range(len(self)):
r.append(self[i] * other[i])
return r
else:
other = Vector.emptyvec(lens=len(self), n=other)
return self * other
def __truediv__(self, other):
if type(other) is Vector:
assert len(self) == len(other), "Error 0"
r = Vector()
for i in range(len(self)):
r.append(self[i] / other[i])
return r
else:
other = Vector.emptyvec(lens=len(self), n=other)
return self / other
def __pow__(self, other):
if type(other) is Vector:
assert len(self) == len(other), "Error 0"
r = Vector()
for i in range(len(self)):
r.append(self[i] ** other[i])
return r
else:
other = Vector.emptyvec(lens=len(self), n=other)
return self ** other
def __mod__(self, other):
return sum((self - other) ** 2) ** 0.5
def mod(self):
return self % Vector.emptyvec(len(self))
def dim(self):
return len(self)
def __str__(self):
if len(self) == 0:
return "Empty"
r = [str(i) for i in self]
return "< " + " ".join(r) + " >"
def _ipython_display_(self):
print(str(self))
@staticmethod
def emptyvec(lens=2, n=0):
return Vector(*[n for i in range(lens)])
@staticmethod
def randvec(dim):
return Vector(*[random.random() for i in range(dim)])
class Point:
def __init__(self, coords, mass=1.0, q=1.0, speed=None, **properties):
self.coords = coords
if speed is None:
self.speed = Vector(*[0 for i in range(len(coords))])
else:
self.speed = speed
self.acc = Vector(*[0 for i in range(len(coords))])
self.mass = mass
self.__params__ = ["coords", "speed", "acc", "q"] + list(properties.keys())
self.q = q
for prop in properties:
setattr(self, prop, properties[prop])
def move(self, dt):
self.coords = self.coords + self.speed * dt
def accelerate(self, dt):
self.speed = self.speed + self.acc * dt
def accinc(self, force):
self.acc = self.acc + force / self.mass
def clean_acc(self):
self.acc = self.acc * 0
def __str__(self):
r = ["Point {"]
for p in self.__params__:
r.append(" " + p + " = " + str(getattr(self, p)))
r += ["}"]
return "\n".join(r)
def _ipython_display_(self):
print(str(self))
class InteractionField:
def __init__(self, F):
self.points = []
self.F = F
def move_all(self, dt):
for p in self.points:
p.move(dt)
def intensity(self, coord):
proj = Vector(*[0 for i in range(coord.dim())])
single_point = Point(Vector(), mass=1.0, q=1.0)
for p in self.points:
if coord % p.coords < 10 ** (-10):
continue
d = p.coords % coord
fmod = self.F(single_point, p, d) * (-1)
proj = proj + (coord - p.coords) / d * fmod
return proj
def step(self, dt):
self.clean_acc()
for p in self.points:
p.accinc(self.intensity(p.coords) * p.q)
p.accelerate(dt)
p.move(dt)
def clean_acc(self):
for p in self.points:
p.clean_acc()
def append(self, *args, **kwargs):
self.points.append(Point(*args, **kwargs))
def gather_coords(self):
return [p.coords for p in self.points]
# ДЕМО
import matplotlib.pyplot as plt
import numpy as np
import time
# Моделирование частиц со следами
if False:
u = InteractionField(lambda p1, p2, r: 300000 * -p1.q * p2.q / (r ** 2 + 0.1))
for i in range(10):
u.append(Vector.randvec(2) * 10, q=(random.random() - 0.5) / 2)
X, Y = [], []
for i in range(130):
u.step(0.0006)
xd, yd = zip(*u.gather_coords())
X.extend(xd)
Y.extend(yd)
plt.figure(figsize=[8, 8])
plt.scatter(X, Y)
plt.scatter(*zip(*u.gather_coords()), color="orange")
plt.show()
def sigm(x):
return 1 / (1 + 1.10 ** (-x/1000))
# Визуализация векторного поля
if False:
u = InteractionField(lambda p1, p2, r: 300000 * -p1.q * p2.q / (r ** 2 + 0.1))
for i in range(3):
u.append(Vector.randvec(2) * 10, q=random.random() - 0.5)
fig = plt.figure(figsize=[5, 5])
res = []
STEP = 0.3
for x in np.arange(0, 10, STEP):
for y in np.arange(0, 10, STEP):
inten = u.intensity(Vector(x, y))
F = inten.mod()
inten /= inten.mod() * 1.5
res.append(([x - inten[0] / 2, x + inten[0] / 2], [y - inten[1] / 2, y + inten[1] / 2], F))
for r in res:
plt.plot(r[0], r[1], color=(sigm(r[2]), 0.1, 0.8 * (1 - sigm(r[2]))))
plt.show()
# Подсчет скоростей в 5-мерном пространстве
if False:
u = InteractionField(lambda p1, p2, r: 300000 * -p1.q * p2.q / (r ** 4 + 0.1))
for i in range(200):
u.append(Vector.randvec(5) * 10, q=random.random() - 0.5)
velmod = 0
velocities = []
for i in range(100):
u.step(0.0005)
velmod = sum([p.speed.mod() for p in u.points])
velocities.append(velmod)
plt.plot(velocities)
plt.show()
```
Следующая статья будет возможно о более сложном моделировании, а быть может и флюидах и уравнениях Навье-Стокса.
UPD: Статья написана моим коллегой [тут](https://habr.com/ru/post/470742/)
Спасибо [MomoDev](https://habr.com/ru/users/momodev/) за помощь в рендеринге видео. | https://habr.com/ru/post/467803/ | null | ru | null |
# Упрощаем работу с Check Point API с помощью Python SDK
Вся мощь взаимодействия с API раскрывается при совместном использовании с програмным кодом, когда появляются возможности динамически формировать API запросы и инструменты для анализа API ответов. Однако, малозаметным до сих пор остаётся **Python Software Development Kit** (далее — Python SDK) для **Check Point Management API**, а зря. Он ощутимо упрощает жизнь разработчикам и любителям автоматизации. Python приобрёл огромную популярность в последнее время и я решил устранить пробел и сделать обзор основных возмоностей [Check Point API Python Development Kit](https://github.com/CheckPointSW/cp_mgmt_api_python_sdk). Данная статья служит отличным дополнением другой статьи на Хабре [Check Point R80.10 API. Управление через CLI, скрипты и не только](https://habr.com/ru/company/tssolution/blog/339924/). Мы же рассмотрим как написать скрипты с использованием Python SDK и остановимся подробнее на новом функционале Management API в версии 1.6(поддерживается начиная с R80.40). Для понимания статьи понадобятся базовые знания по работе с API и Python.
Check Point активно развивает API и на данный момент на свет появились:
* [Check Point Management API (текущая версия 1.6)](https://sc1.checkpoint.com/documents/latest/APIs/#introduction~v1.6) — работа с сервером управления через API(и возможность исполнять скрипты на шлюзах под управлением сервера управления)
* [Check Point GAIA API (текущая версия 1.4)](https://sc1.checkpoint.com/documents/latest/GaiaAPIs/#introduction~v1.4) — работа со шлюзами безопасности
* [Threat Prevention API 1.0](https://sc1.checkpoint.com/documents/TPAPI/CP_1.0_ThreatPreventionAPI_APIRefGuide/html_frameset.htm) — работа с песочницей в облаке Check Point
* [Identity Awareness API](https://sc1.checkpoint.com/documents/latest/IdentityAPIs/) — работа с Identity Awareness blade на шлюзах
* [Security Management Portal API](https://sc1.checkpoint.com/documents/latest/SmpAPIs/#introduction~v1) — работа с порталом управления SMB шлюзами ([Подробнее про SMB шлюзы](https://habr.com/ru/company/tssolution/blog/336298/))
* [IoT API](https://sc1.checkpoint.com/documents/latest/IoTAPI/#introduction~v1.6) — взаимодействие c IoT контроллерами
* [CloudGuard Connect API](https://app.swaggerhub.com/apis-docs/Check-Point/cloudguard-connect-api/1.0.0) — работа с [CloudGuard Connect](https://www.checkpoint.com/ru/products/branch-cloud-security/) (решение SD-WAN security)
* [Dome9 API](https://api-v2-docs.dome9.com/) — работа с [Dome9](https://www.checkpoint.com/products/cloud-security-orchestration/)
Python SDK на данный момент поддерживает взаимодействие только с Management API и **Gaia API**. Мы рассмотрим самые важные классы, методы и переменные в данном модуле.
Установка модуля
----------------
Модуль **cpapi** устанавливается быстро и просто из [официального репозитария Check Point на github](https://github.com/CheckPointSW/cp_mgmt_api_python_sdk/) с помощью **pip**. Подбробная инструкция по установке есть в [README.md](https://github.com/CheckPointSW/cp_mgmt_api_python_sdk/blob/master/README.md). Данный модуль адаптирован для работы с версиями Python 2.7 и 3.7. В данной статье примеры будут приведены с использованием Python 3.7. Однако, Python SDK можно запускать прямо с сервера управления Check Point (Smart Management), но на них поддерживается только версия Python 2.7, поэтому в последнем разделе будет приведён код для версии 2.7. Сразу после установки модуля рекомендую посмотреть на примеры в директориях **examples\_python2** и **examples\_python3**.
Начало работы
-------------
Для того, чтобы у нас появилась возможность работать с компонентами модуля cpapi необходимо импортировать из модуля **cpapi** как минимум два необходимых класса:
**APIClient** и **APIClientArgs**
```
from cpapi import APIClient, APIClientArgs
```
Класс **APIClientArgs** отвечает за параметры подключения к API серверу, а класс **APIClient** отвечает за взаимодействие с API.
Определяем параметры подключения
--------------------------------
Чтобы определить различные параметры подключения к API, нужно создать экземпляр класса **APIClientArgs**. В принципе его параметры предопределены и при запуске скрипта на сервере управления их можно не указывать.
```
client_args = APIClientArgs()
```
Но при запуске на стороннем хосте нужно указать как минимум IP адрес или имя хоста API сервера(он же сервер управления). В примере ниже мы определяем параметр подключения server и присваиваем ему в виде строки IP адрес сервера управления.
```
client_args = APIClientArgs(server='192.168.47.241')
```
Давайте посмотрим на все параметры и их значения по умолчанию, которые можно использовать при подключении к API серверу:
**Аргументы метода \_\_init\_\_ класса APIClientArgs**
```
class APIClientArgs:
"""
This class provides arguments for APIClient configuration.
All the arguments are configured with their default values.
"""
# port is set to None by default, but it gets replaced with 443 if not specified
# context possible values - web_api (default) or gaia_api
def __init__(self, port=None, fingerprint=None, sid=None, server="127.0.0.1", http_debug_level=0,
api_calls=None, debug_file="", proxy_host=None, proxy_port=8080,
api_version=None, unsafe=False, unsafe_auto_accept=False, context="web_api"):
self.port = port
# management server fingerprint
self.fingerprint = fingerprint
# session-id.
self.sid = sid
# management server name or IP-address
self.server = server
# debug level
self.http_debug_level = http_debug_level
# an array with all the api calls (for debug purposes)
self.api_calls = api_calls if api_calls else []
# name of debug file. If left empty, debug data will not be saved to disk.
self.debug_file = debug_file
# HTTP proxy server address (without "http://")
self.proxy_host = proxy_host
# HTTP proxy port
self.proxy_port = proxy_port
# Management server's API version
self.api_version = api_version
# Indicates that the client should not check the server's certificate
self.unsafe = unsafe
# Indicates that the client should automatically accept and save the server's certificate
self.unsafe_auto_accept = unsafe_auto_accept
# The context of using the client - defaults to web_api
self.context = context
```
Полагаю, что аргументы, которые можно использовать в экземплярах класса APIClientArgs, интуитивно понятны администраторам Check Point и в дополнительных комментариях не нуждаются.
Подключаемся через APIClient и менеджер контекста
-------------------------------------------------
Класс **APIClient** удобнее всего использовать через менеджер контекста. Всё, что нужно передать экземпляру класса APIClient это параметры подключения, которые были определены в прошлом шаге.
```
with APIClient(client_args) as client:
```
Менеджер контекста не станет выполнять автоматически login вызов на API сервер, однако он выполнит вызов logout при выходе из него. Если по каким-то причинам logout по окончанию работы с API вызовами не требуется, нужно начать работу без использования менеджера контекста:
```
client = APIClient(client_args)
```
Проверка соединения
-------------------
Проверить проходит ли соединение по заданным параметрам проще всего с помощью метода **check\_fingerprint**. Если проверка хеш-суммы sha1 для fingerprint сертификата API сервера не прошла(метод вернул *False*), то обычно это вызвано проблемами с соединением и мы можем остановить выполнение программы(или дать пользователю возможность исправить данные для подключения):
```
if client.check_fingerprint() is False:
print("Could not get the server's fingerprint - Check connectivity with the server.")
exit(1)
```
Учтите, что в дальнейшем класс **APIClient** будет проверять при каждом API вызове (методы **api\_call** и **api\_query**, о них речь пойдёт чуть дальше) sha1 fingerprint сертификата на API сервере. А вот если при проверке sha1 fingerprint сертификата API сервера будет выявлена ошибка (сертификат неизвестен или был изменён), метод **check\_fingerprint** предоставит возможность добавить/изменить информацию о нём на локальной машине в автоматическом режиме. Данную проверку можно отключить вовсе (но такое можно рекомендовать только в случае запуска скриптов на самом API сервере, при подключении к 127.0.0.1), используя аргумент APIClientArgs — **unsafe\_auto\_accept** (см. подробнее про APIClientArgs ранее в «Определяем параметры подключения»).
```
client_args = APIClientArgs(unsafe_auto_accept=True)
```
Login на API сервер
-------------------
У **APIClient** есть целых 3 метода логина на API сервер, и каждый из них запонимает значение **sid**(session-id), которое использует автоматически в каждом последующем API вызове в заголовке(имя в заголовке у данного параметра — **X-chkp-sid**), так что не нужно дополнительно обрабатывать данный параметр.
### Метод login
Вариант с использованием логина и пароля(в примере имя пользователя admin и пароль 1q2w3e переданы как позиционные аргументы):
```
login = client.login('admin', '1q2w3e')
```
В методе login доступны также дополнительные опциональные параметры, привожу их имена и значения по умолчанию:
```
continue_last_session=False, domain=None, read_only=False, payload=None
```
### Метод login\_with\_api\_key
Вариант с использованием api ключа(поддерживается начиная с версии менеджмента R80.40/Management API v1.6, *«3TsbPJ8ZKjaJGvFyoFqHFA==»* это значение ключа API для одного из пользователей на сервере управления с методом авторизации API key):
```
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
```
В методе **login\_with\_api\_key** доступны такие же опциональные параметры как и в методе **login**.
### Метод login\_as\_root
Вариант login'а на локальную машину с API сервером:
```
login = client.login_as_root()
```
Для данного метода доступны всего два опциональных параметра:
```
domain=None, payload=None
```
И наконец сами API вызовы
-------------------------
У нас есть два варианта делать API вызовы через методы **api\_call** и **api\_query**. Давайте разберёмся в чём между ними разница.
### api\_call
Данный метод применим для любых вызовов. Нам нужно передать последнюю часть для api вызова и payload в теле запроса при необходимости. Если payload пустой, то его можно не передавать вовсе:
```
api_versions = client.api_call('show-api-versions')
```
**Вывод для данного запроса под катом:**
```
In [23]: api_versions
Out[23]:
APIResponse({
"data": {
"current-version": "1.6",
"supported-versions": [
"1",
"1.1",
"1.2",
"1.3",
"1.4",
"1.5",
"1.6"
]
},
"res_obj": {
"data": {
"current-version": "1.6",
"supported-versions": [
"1",
"1.1",
"1.2",
"1.3",
"1.4",
"1.5",
"1.6"
]
},
"status_code": 200
},
"status_code": 200,
"success": true
})
```
```
show_host = client.api_call('show-host', {'name' : 'h_8.8.8.8'})
```
**Вывод для данного запроса под катом:**
```
In [25]: show_host
Out[25]:
APIResponse({
"data": {
"color": "black",
"comments": "",
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"groups": [],
"icon": "Objects/host",
"interfaces": [],
"ipv4-address": "8.8.8.8",
"meta-info": {
"creation-time": {
"iso-8601": "2020-05-01T21:49+0300",
"posix": 1588358973517
},
"creator": "admin",
"last-modifier": "admin",
"last-modify-time": {
"iso-8601": "2020-05-01T21:49+0300",
"posix": 1588358973517
},
"lock": "unlocked",
"validation-state": "ok"
},
"name": "h_8.8.8.8",
"nat-settings": {
"auto-rule": false
},
"read-only": false,
"tags": [],
"type": "host",
"uid": "c210af07-1939-49d3-a351-953a9c471d9e"
},
"res_obj": {
"data": {
"color": "black",
"comments": "",
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"groups": [],
"icon": "Objects/host",
"interfaces": [],
"ipv4-address": "8.8.8.8",
"meta-info": {
"creation-time": {
"iso-8601": "2020-05-01T21:49+0300",
"posix": 1588358973517
},
"creator": "admin",
"last-modifier": "admin",
"last-modify-time": {
"iso-8601": "2020-05-01T21:49+0300",
"posix": 1588358973517
},
"lock": "unlocked",
"validation-state": "ok"
},
"name": "h_8.8.8.8",
"nat-settings": {
"auto-rule": false
},
"read-only": false,
"tags": [],
"type": "host",
"uid": "c210af07-1939-49d3-a351-953a9c471d9e"
},
"status_code": 200
},
"status_code": 200,
"success": true
})
```
### api\_query
Сразу оговорюсь, что данный метод применим только для вызовов, вывод которых предполагает offset(сдвиг). Такой вывод происходит в том случае, когда в нём содержится или может содержатся большое количество информации. Например, это может быть запрос списка всех созданных объектов типа хост на сервере управления. Для таких запросов API возвращает список из 50 объектов по умолчанию(можно увеличить лимит до 500 объектов в ответе). И для того, чтобы не дёргать информацию по несколько раз, меняя параметр offset в API запросе, есть метод api\_query, который данную работу проделывает автоматически. Примеры вызовов, где нужен данный метод: *show-sessions, show-hosts, show-networks, show-wildcards, show-groups, show-address-ranges, show-simple-gateways, show-simple-clusters, show-access-roles, show-trusted-clients, show-packages*. По факту, в имени этих API вызовов мы видим слова во множественном числе, так что эти вызовы будет проще обрабатывать через **api\_query**
```
show_hosts = client.api_query('show-hosts')
```
**Вывод для данного запроса под катом:**
```
In [21]: show_hosts
Out[21]:
APIResponse({
"data": [
{
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"ipv4-address": "192.168.47.1",
"name": "h_192.168.47.1",
"type": "host",
"uid": "5d7d7086-d70b-4995-971a-0583b15a2bfc"
},
{
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"ipv4-address": "8.8.8.8",
"name": "h_8.8.8.8",
"type": "host",
"uid": "c210af07-1939-49d3-a351-953a9c471d9e"
}
],
"res_obj": {
"data": {
"from": 1,
"objects": [
{
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"ipv4-address": "192.168.47.1",
"name": "h_192.168.47.1",
"type": "host",
"uid": "5d7d7086-d70b-4995-971a-0583b15a2bfc"
},
{
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"ipv4-address": "8.8.8.8",
"name": "h_8.8.8.8",
"type": "host",
"uid": "c210af07-1939-49d3-a351-953a9c471d9e"
}
],
"to": 2,
"total": 2
},
"status_code": 200
},
"status_code": 200,
"success": true
})
```
Обработка результатов API вызовов
---------------------------------
После этого можно использовать переменные и методы класса **APIResponse**(как внутри менеджера контекста, так и снаружи). У класса **APIResponse** предопределено 4 метода и 5 переменных, на самых важных мы остановимся подробнее.
### success
Для начала было бы неплохо убедиться в том, что API вызов прошёл успешно и вернул результат. Для этого есть метод **success**:
```
In [49]: api_versions.success
Out[49]: True
```
Возвращает True если API вызов прошёл успешно(Код ответа — 200) и False если не успешно(любой другой код ответа). Удобно использовать сразу после API вызова, чтобы в зависимости от кода ответа вывести разную информацию.
```
if api_ver.success:
print(api_versions.data)
else:
print(api_versions.err_message)
```
### statuscode
Возвращает код ответа после выполнения API вызова.
```
In [62]: api_versions.status_code
Out[62]: 400
```
Возможные коды ответов: **200,400,401,403,404,409,500,501**.
### set\_success\_status
При этом может быть необходимость изменить значение статуса success. Технически, туда можно поместить что угодно, даже обычную строку. Но реальным примером может быть сброс данного параметра в False при определенных сопутствующих условиях. Ниже обратите внимание на пример, когда есть задачи, выполняемые на сервере управления, но мы будем считать этот запрос неудачным(выставим переменную success в *False*, несмотря на то, что API вызов был успешный и вернул код 200).
```
for task in task_result.data["tasks"]:
if task["status"] == "failed" or task["status"] == "partially succeeded":
task_result.set_success_status(False)
break
```
### response()
Метод response позволяет посмотреть словарь с кодом ответа(status\_code) и с телом ответа(body).
```
In [94]: api_versions.response()
Out[94]:
{'status_code': 200,
'data': {'current-version': '1.6',
'supported-versions': ['1', '1.1', '1.2', '1.3', '1.4', '1.5', '1.6']}}
```
### data
Позволяет увидеть только тело ответа(body) без излишней информации.
```
In [93]: api_versions.data
Out[93]:
{'current-version': '1.6',
'supported-versions': ['1', '1.1', '1.2', '1.3', '1.4', '1.5', '1.6']}
```
### error\_message
Данная информация доступна, только когда при обработке API запроса возникла ошибка(код ответа не 200). Пример вывода
```
In [107]: api_versions.error_message
Out[107]: 'code: generic_err_invalid_parameter_name\nmessage: Unrecognized parameter [1]\n'
```
Полезные примеры
----------------
Ниже перечислены примеры, в которых используются API вызовы, которые были добавлены в версию Management API 1.6.
Для начала рассмотрим работу вызовов **add-host** и **add-address-range**. Допустим, нам нужно создать в качестве объектов типа хост все ip адреса подсети 192.168.0.0/24, последний октет которых равен 5, а все остальные ip адреса записать в качестве объектов типа диапазон адресов. При этом, адрес подсети и широковещательный адрес исключить.
Итак, ниже представлен скрипт в котором решается данная задача и создаются 50 объектов типа хост и 51 объект типа диапазон адресов. На решение задачи требуется 101 API вызов(не считая финального вызова publish). Также с помощью модуля timeit мы подсчитываем время на выполнение скрипта до момента публикации изменений.
**Скрипт с использование add-host и add-address-range**
```
import timeit
from cpapi import APIClient, APIClientArgs
start = timeit.default_timer()
first_ip = 1
last_ip = 4
client_args = APIClientArgs(server="192.168.47.240")
with APIClient(client_args) as client:
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
for ip in range(5,255,5):
add_host = client.api_call("add-host", {"name" : f"h_192.168.0.{ip}", "ip-address": f'192.168.0.{ip}'})
while last_ip < 255:
add_range = client.api_call("add-address-range", {"name": f"r_192.168.0.{first_ip}-{last_ip}", "ip-address-first": f"192.168.0.{first_ip}", "ip-address-last": f"192.168.0.{last_ip}"})
first_ip+=5
last_ip+=5
stop = timeit.default_timer()
publish = client.api_call("publish")
print(f'Time to execute batch request: {stop - start} seconds')
```
В моей лабораторной среде на выполнение данного скрипта уходит от 30 до 50 секунд в зависимости от нагрузки на сервер управления.
А теперь посмотрим как решить эту же задачу с помощью API вызова **add-objects-batch**, поддержка которого добавлена в версию API 1.6. Данный вызов позволяет за один API запрос создать сразу множество объектов. Причём это могут быть объекты разных типов(например хосты, подсети и диапазоны адресов). Таким образом наша задача может быть решена в рамказ одного API вызова.
**Скрипт с использование add-objects-batch**
```
import timeit
from cpapi import APIClient, APIClientArgs
start = timeit.default_timer()
client_args = APIClientArgs(server="192.168.47.240")
objects_list_ip = []
objects_list_range = []
for ip in range(5,255,5):
data = {"name": f'h_192.168.0.{ip}', "ip-address": f'192.168.0.{ip}'}
objects_list_ip.append(data)
first_ip = 1
last_ip = 4
while last_ip < 255:
data = {"name": f"r_192.168.0.{first_ip}-{last_ip}", "ip-address-first": f"192.168.0.{first_ip}", "ip-address-last": f"192.168.0.{last_ip}"}
objects_list_range.append(data)
first_ip+=5
last_ip+=5
data_for_batch = {
"objects" : [ {
"type" : "host",
"list" : objects_list_ip
}, {
"type" : "address-range",
"list" : objects_list_range
}]
}
with APIClient(client_args) as client:
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
add_objects_batch = client.api_call("add-objects-batch", data_for_batch)
stop = timeit.default_timer()
publish = client.api_call("publish")
print(f'Time to execute batch request: {stop - start} seconds')
```
А на выполнение данного скрипта в моей лабораторной среде уходит от 3 до 7 секунд в зависимости от нагрузки на сервер управления. То есть, в среднем, на 101 объекте API вызов типа batch, отрабатывает в 10 раз быстрее. На большем количестве объектов разница будет ещё более впечатляющей.
Теперь давайте посмотрим как работать с **set-objects-batch**. С помощью данного API вызова мы можем массово изменить любой параметр. Давайте настроим первой половине адресов из прошлого примера (до .124 хоста, причём и диапазонам тоже) цвет sienna, а второй половине адресов назначим цвет khaki.
**Изменение цвета объектов, созданных в предыдушем примере**
```
from cpapi import APIClient, APIClientArgs
client_args = APIClientArgs(server="192.168.47.240")
objects_list_ip_first = []
objects_list_range_first = []
objects_list_ip_second = []
objects_list_range_second = []
for ip in range(5,125,5):
data = {"name": f'h_192.168.0.{ip}', "color": "sienna"}
objects_list_ip_first.append(data)
for ip in range(125,255,5):
data = {"name": f'h_192.168.0.{ip}', "color": "khaki"}
objects_list_ip_second.append(data)
first_ip = 1
last_ip = 4
while last_ip < 125:
data = {"name": f"r_192.168.0.{first_ip}-{last_ip}", "color": "sienna"}
objects_list_range_first.append(data)
first_ip+=5
last_ip+=5
while last_ip < 255:
data = {"name": f"r_192.168.0.{first_ip}-{last_ip}", "color": "khaki"}
objects_list_range_second.append(data)
first_ip+=5
last_ip+=5
data_for_batch_first = {
"objects" : [ {
"type" : "host",
"list" : objects_list_ip_first
}, {
"type" : "address-range",
"list" : objects_list_range_first
}]
}
data_for_batch_second = {
"objects" : [ {
"type" : "host",
"list" : objects_list_ip_second
}, {
"type" : "address-range",
"list" : objects_list_range_second
}]
}
with APIClient(client_args) as client:
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
set_objects_batch_first = client.api_call("set-objects-batch", data_for_batch_first)
set_objects_batch_second = client.api_call("set-objects-batch", data_for_batch_second)
publish = client.api_call("publish")
```
Удалить множество объектов в одном API вызове можно с помощью **delete-objects-batch**. А теперь посмотрим на пример кода, который удаляет все хосты, созданные ранее через **add-objects-batch**.
**Удаление объектов с помощью delete-objects-batch**
```
from cpapi import APIClient, APIClientArgs
client_args = APIClientArgs(server="192.168.47.240")
objects_list_ip = []
objects_list_range = []
for ip in range(5,255,5):
data = {"name": f'h_192.168.0.{ip}'}
objects_list_ip.append(data)
first_ip = 1
last_ip = 4
while last_ip < 255:
data = {"name": f"r_192.168.0.{first_ip}-{last_ip}"}
objects_list_range.append(data)
first_ip+=5
last_ip+=5
data_for_batch = {
"objects" : [ {
"type" : "host",
"list" : objects_list_ip
}, {
"type" : "address-range",
"list" : objects_list_range
}]
}
with APIClient(client_args) as client:
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
delete_objects_batch = client.api_call("delete-objects-batch", data_for_batch)
publish = client.api_call("publish")
print(delete_objects_batch.data)
```
Все функции, которые появляются в новых релизах ПО Check Point, сразу же обретают и API вызовы. Так, в R80.40 появились такие «фичи» как Revert to revision и Smart Task, и для них сразу же подготовили соответствующие API вызовы. Более того, весь функционал при переходе из Legacy консолей в режим Unified Policy также обрастает поддержкой API. Например, долгожданным обновлением в версии ПО R80.40 стал переезд политики HTTPS Inspection из Legacy режима в режим Unified Policy, и данный функционал сразу же получил API вызовы. Вот пример кода, который добавляет на верхнюю позицию HTTPS Inspection policy правило, которое исключает из инспекции 3 категории(Здоровье, Финансы, Государственные услуги), которые запрещено инспектировать в соответствии с законадательством в ряде стран.
**Добавить правило в политику HTTPS Inspection**
```
from cpapi import APIClient, APIClientArgs
client_args = APIClientArgs(server="192.168.47.240")
data = {
"layer" : "Default Layer",
"position" : "top",
"name" : "Legal Requirements",
"action": "bypass",
"site-category": ["Health", "Government / Military", "Financial Services"]
}
with APIClient(client_args) as client:
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
add_https_rule = client.api_call("add-https-rule", data)
publish = client.api_call("publish")
```
Запуск Python скриптов на сервере управления Check Point
--------------------------------------------------------
Всё в том же [README.md](https://github.com/CheckPointSW/cp_mgmt_api_python_sdk/blob/master/README.md) содержится информация как запускать скрипты на Python прямо с сервера управления. Это может быть удобно, когда у вас нет возможности подключиться к API серверу с другой машины. Я записал шестиминутное видео в котором рассматриваю установку модуля **cpapi** и особенности запуска Python скриптов на сервере управления. В качестве примера запускается скрипт, который автоматизирует конфигурацию нового шлюза для такой задачи, как аудит сети **Security CheckUp**. Из особенностей, с которыми пришлось столкнуться: в версии Python 2.7 ещё не появилась функция **input**, поэтому для обработки информации, которую вводит пользователь, используется функция **raw\_input**. В остальном, код такой же как для запуска с других машин, только удобнее использовать функцию **login\_as\_root**, дабы не указывать свои же собственные username, пароль и IP адрес сервера управления ещё раз.
**Скрипт для быстрой настройки Security CheckUp**
```
from __future__ import print_function
import getpass
import sys, os
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
from cpapi import APIClient, APIClientArgs
def main():
with APIClient() as client:
# if client.check_fingerprint() is False:
# print("Could not get the server's fingerprint - Check connectivity with the server.")
# exit(1)
login_res = client.login_as_root()
if login_res.success is False:
print("Login failed:\n{}".format(login_res.error_message))
exit(1)
gw_name = raw_input("Enter the gateway name:")
gw_ip = raw_input("Enter the gateway IP address:")
if sys.stdin.isatty():
sic = getpass.getpass("Enter one-time password for the gateway(SIC): ")
else:
print("Attention! Your password will be shown on the screen!")
sic = raw_input("Enter one-time password for the gateway(SIC): ")
version = raw_input("Enter the gateway version(like RXX.YY):")
add_gw = client.api_call("add-simple-gateway", {'name' : gw_name, 'ipv4-address' : gw_ip, 'one-time-password' : sic, 'version': version.capitalize(), 'application-control' : 'true', 'url-filtering' : 'true', 'ips' : 'true', 'anti-bot' : 'true', 'anti-virus' : 'true', 'threat-emulation' : 'true'})
if add_gw.success and add_gw.data['sic-state'] != "communicating":
print("Secure connection with the gateway hasn't established!")
exit(1)
elif add_gw.success:
print("The gateway was added successfully.")
gw_uid = add_gw.data['uid']
gw_name = add_gw.data['name']
else:
print("Failed to add the gateway - {}".format(add_gw.error_message))
exit(1)
change_policy = client.api_call("set-access-layer", {"name" : "Network", "applications-and-url-filtering": "true", "content-awareness": "true"})
if change_policy.success:
print("The policy has been changed successfully")
else:
print("Failed to change the policy- {}".format(change_policy.error_message))
change_rule = client.api_call("set-access-rule", {"name" : "Cleanup rule", "layer" : "Network", "action": "Accept", "track": {"type": "Detailed Log", "accounting": "true"}})
if change_rule.success:
print("The cleanup rule has been changed successfully")
else:
print("Failed to change the cleanup rule- {}".format(change_rule.error_message))
# publish the result
publish_res = client.api_call("publish", {})
if publish_res.success:
print("The changes were published successfully.")
else:
print("Failed to publish the changes - {}".format(install_tp_policy.error_message))
install_access_policy = client.api_call("install-policy", {"policy-package" : "Standard", "access" : 'true', "threat-prevention" : 'false', "targets" : gw_uid})
if install_access_policy.success:
print("The access policy has been installed")
else:
print("Failed to install access policy - {}".format(install_tp_policy.error_message))
install_tp_policy = client.api_call("install-policy", {"policy-package" : "Standard", "access" : 'false', "threat-prevention" : 'true', "targets" : gw_uid})
if install_tp_policy.success:
print("The threat prevention policy has been installed")
else:
print("Failed to install threat prevention policy - {}".format(install_tp_policy.error_message))
# add passwords and passphrases to dictionary
with open('additional_pass.conf') as f:
line_num = 0
for line in f:
line_num += 1
add_password_dictionary = client.api_call("run-script", {"script-name" : "Add passwords and passphrases", "script" : "printf \"{}\" >> $FWDIR/conf/additional_pass.conf".format(line), "targets" : gw_name})
if add_password_dictionary.success:
print("The password dictionary line {} was added successfully".format(line_num))
else:
print("Failed to add the dictionary - {}".format(add_password_dictionary.error_message))
main()
```
**Пример файла со словарём паролей additional\_pass.conf**
`{
"passwords" : ["malware","malicious","infected","Infected"],
"phrases" : ["password","Password","Pass","pass","codigo","key","pwd","пароль","Пароль","Ключ","ключ","шифр","Шифр"]
}`
Заключение
----------
Данная статья рассматривает лишь основные возможности работы **Python SDK** и модуля **cpapi**(как вы могли догадаться, это фактически синонимы), и изучив код в данном модуле вы откроете для себя ещё больше возможностей в работе с ним. Не исключено, что у вас появится желание дополнить его своими классами, функциями, методами и переменными. Вы всегда можете делится своими наработками и просматривать другие скрипты для Check Point в разделе [CodeHub](https://community.checkpoint.com/t5/API-CLI-Discussion-and-Samples/bd-p/codehub) в сообществе [CheckMates](http://community.checkpoint.com/), которое объединяет в себе и разработчиков продуктов и пользователей.
Приятного кодинга и спасибо, что дочитали до конца! | https://habr.com/ru/post/505510/ | null | ru | null |
# Russian Code Cup 2012: подробный разбор задач с отборочного раунда (полуфинал)
В прошлую субботу, 16 июня, завершился отборочный раунд Russian Code Cup 2012. Задачи отборочного раунда посложнее, чем были на квалификации – ну на то он и полуфинал. Я уже рассказывал о том, что предлагалось участникам на предыдущих онлайн-турах, разбирал подробно варианты решений ([Q1](http://habrahabr.ru/company/mailru/blog/144793/), [Q2](http://habrahabr.ru/company/mailru/blog/145262/), [Q3](http://habrahabr.ru/company/mailru/blog/145735/)).
В отборочный раунд было приглашено 600 человек. 434 человек смогли решить хотя бы одну задачу. Все задачи решили только двое. 50 лучших перешли в финал. Всего за 3 часа тура было отправлено в проверяющую систему 3190 решений.
**Итак, перейдем к самим задачам. Я пострался объяснить их так, чтобы решения были понятны даже делающим первые шаги в спортивном программировании (да и в программировании вообще).**
Епрестановка
============
Суть задачи заключалась в том, чтобы определить, можно ли, путем применения в произвольном порядке двух типов перестановок, переместить элемент с указанной позиции на указанную в списке значений. По условию задачи можно было применять так называемую епрестановку, меняющую первые два элемента местами, и сложную перестановку, задаваемую правилом-набором значений (a1, a2, ..., aN), где каждое из значений определяет порядковый номер позиции, на которую можно переместить число с этой позиции. К примеру, последняя двойка в правиле перестановок (1,4,3,2) означает, что с последней позиции можно переставить на вторую, а с нее — на последнюю. Собственно, в итоге и требуется дать ответ вида «Yes/No» на входные данные, содержащие этот список (из N значений) и запрос в виде (позиция1, позиция2) — «можно ли переместить элемент с позиции 1 на позицию 2».
Эта задача была простейшей на контесте, с ней справились 411 человек, первое прошедшее тесты решение было предложено Жуковым Дмитрием на 3 минуте 31 секунде с начала раунда.
Очевидно, что все перестановки в конечном счете сводятся к набору циклов. В приведенном выше примере цикла три — 4->2->4->2… 1->1->1… 3->3->3… То есть, если бы у нас была только операция «применить перестановку p», то для двух элементов ai и bi ответ был бы «Yes» тогда и только тогда, когда эти элементы лежали бы на одном цикле в перестановке p.
Подумаем о том, что происходит при применении «епрестановки» z. Если изначально первый и второй элементы лежали в разных циклах, то применение «епрестановки» дает нам возможность переставить какой-то элемент из одного из этих двух циклов в другой.
Теперь можно сформулировать и общее решение.
* Разобьем всю перестановку p на циклы.
* Для каждого запроса ai и bi ответ «Yes» если ai и bi лежат в одном цикле, или если в цикле одного из них присутствует первый элемент, а в цикле другого — второй.
Разбиение на циклы производится следующим образом:
```
// Введем вспомогательный массив col, инициалируем его −1.
vector col(n, −1);
// Далее попробуем поискать цикл, начиная с каждой позиции, которая не вошла в уже найденные
for (int i = 0; i < n; i++)
{
if (col[i] != −1) continue; // входила в уже найденные
int x = i;
do
{
col[x] = i; // помечаем номером цикла
x = a[x];
} while (col[x] == −1);
}
```
Объединяем первые два цикла в один:
```
for (int i = 0; i < n; i++)
if (col[i] == 0) col[i] = 1;
```
В итоге мы получили массив col, i-й элемент которого обозначает цикл, в который входит i-я позиция.
```
for (int i = 0; i < m; i++)
{
int a, b;
cin >> a >> b;
// остается проверить, входят ли два варианта в один цикл и вывести ответ.
cout << ((col[a — 1] == col[b — 1])? «Yes» : «No») << «\n»;
}
```
Коронация
=========
По условиям задачи есть две столицы и некоторое множество городов, соединенных дорогами таким образом, чтобы из любого в любой можно было попасть единственным способом. Но они такого качества, что после проезда определенного, указанного для каждой дороги, числа машин, они становятся непригодными для проезда. Было решено добавить еще одну (возможно, дублирующую) дорогу с неограниченной пропускной способностью между любыми двумя городами, ни один из которых не является столицей. Необходимо найти максимальное число машин, которые смогут проехать между двумя столицами с учетом этой новой дороги.
Подробную постановку задачи можно прочесть [на странице раунда](http://russiancodecup.ru/round/9/) на официальном сайте Russian Code Cup.
Эта задача оказалась второй по сложности «с конца» – ее решило 313 человек. Первым правильное решение прислал Жуков Дмитрий на 12:50.
В задаче мы имеем взвешенное неориентированное дерево. То есть, граф, не имеющий петель и кратных ребер, ребрам которого («дорогам») прописаны «веса» — пропускная способность дорог.
В нем выделены две вершины — «столицы» — s и t. Нужно добавить ребро, не затрагивающее ни s, ни t, такое, чтобы поток из s в t был максимальным.
Пускай мы добавили ребро из вершины a в вершину b. Докажем, что между s и t будет не более двух простых путей (путь называется простым, если ребра в нем не повторяются). Докажем от противного. Предположим, нам удалось найти три пути.
Рассмотрим два случая:
* Хотя бы в двух из них встречается ребро ab. Здесь тоже два случая:
+ Ребро оба раза обходится в одном направлении. Возьмем одно из направлений a->b, тогда оба рассматриваемых пути содержат в себе подпуть . Так как эти пути не равны, то не равны либо подпути , либо . В обоих случаях это означает то, что между вершинами дерева есть два различных пути, что противоречит его свойствам и условию задачи.
+ Ребро обходится в противоположных направлениях. Если так, то в дереве есть цикл , что тоже противоречит условию задачи и свойствам нашего дерева.
* Ребро ab есть не более, чем в одном из них. Тогда оставшиеся два пути образуют цикл, а следовательно, простой цикл в дереве, что не может быть по условию задачи.
В итоге мы выяснили, что добавление ребра ab приводит к появлению не более двух простых путей и только в одном из них есть ребро ab, а другой, очевидно, проходит по ребрам дерева и является тем самым единственным между вершинами-городами.
Рассмотрим второй путь, проходящий через ребро ab. Одним концом это ребро соединено к пути до вершины s, другим — к пути до вершины t. Теперь, если сдвинуть место соединения ab с в узел, ближе к s, то пропускная способность не ухудшится. Аналогично рассуждая с дорогой до t, и, помня ограничение в задаче, приходим к тому, что новый путь, проходящий через узлы-столицы s,t и ребро ab в своем наиболее эффективном виде состоит из трех ребер — ребра из s, ребра ab и ребра из t.
В итоге получаем, что наш ответ состоит из двух путей, один из которых существовал до добавления ребра ab, а второй — ребро из s, ребро ab и ребро в t.
Получаем решение:
1. Найти путь из s в t по ребрам дерева,
2. Пропустить по нему максимальное число машин и, соответственно, уменьшить пропускную способность всех ребер на этом пути. При этом однозначно путь разрушится — ведь максимальное число машин соответствует наименьшей пропускной способности входящих в путь ребер.
3. Вероятно, останутся еще дороги (или одна дорога) из s и из t. Выберем те, у которых пропускная способность максимальна.
4. Соединив их ребром ab, посчитаем количество машин — минимальное значение из пропускных способностей двух ребер, выходящих из столиц.
Социофоб
========
Условие задачи стоит того, чтобы привести здесь его с минимальными сокращениями.
> «Далеко не всем людям приятно постоянно находиться в толпе. Многие любят уединение и даже готовы за него платить. Именно поэтому ОАО «Радостные Железные Дороги» ввело на своем сайте продажи билетов новую услугу, называющуюся «Социофоб». Услуга необходима для того, чтобы дать возможность каждому пассажиру ехать в купе с наименьшим возможным количеством соседей. Суть ее заключается в следующем.
>
>
>
> Пусть билеты продаются в некоторый вагон, в котором часть купе уже заполнена. Если в какой-то момент в этот вагон покупает билет очередной пассажир, ему продается место в самом незаполненном купе, то есть в купе, в котором количество людей не больше, чем во всех остальных. Если таких купе несколько, то выбирается купе с наименьшим номером. Если же пассажир из какого-то купе сдает свой билет, после чего разница между количеством людей в этом купе и в наиболее заполненном купе становится равной хотя бы двум, то из наиболее заполненного купе на освободившееся место пересаживается пассажир, который раньше других купил билет, то есть пассажир с наименьшим номером. Если наиболее заполненных купе несколько, то из них выбирается купе, ближайшее к тому, в котором был сдан билет. А если и таких несколько, то выбирается купе с наименьшим номером.
>
>
>
> По данным о том, как пассажиры покупали и сдавали билеты, требуется вывести итоговое распределение пассажиров по купе. Гарантируется, что каждый раз, когда какой-либо пассажир покупает билет, в вагоне есть хотя бы одно свободное место».
Похоже, рассматриваемый поезд в задаче поистине огромный, так как количество операций продажи и возвратов билетов — до 200000, количество купе — до 50000.
Всего эту задачу решило 167 человек, из них первым был Кунявский Павел (23:19).
Одно из решений этой задачи выглядит следующим образом. Подготовим следующие структуры данных:
```
// массив, хранящий информацию о купе пассажира. Pas[i] = купе, -1 означает «ни в каком».
vector pas(200000+1, -1);
// массив множеств – кто находится в купе. Cars[i] содержит набор идентификаторов пассажиров
vector< set > cars(50000 + 1);
```
Также будем поддерживать два множества (в C++, например, для этого можно воспользоваться set, в Java — TreeSet): zero и one. В zero будем хранить номера купе, в которых у нас наименьшее количество пассажиров, а в one — где больше всего.
```
set zero;
set one;
```
Изначально все купе пустые, поэтому помещаем их в список кандидатов на заполнение — zero.
```
for (int i = 1; i <= n; i++)
zero.insert(i);
```
Других нам не нужно, так как разница между количеством пассажиров в различных купе никогда не будет превышать одного.
**Операция продажи билета («+»).** По условию задачи мы должны выбрать вагон с наименьшим номером, в котором меньше всего людей. Для этого возьмем наименьший элемент множества zero. Обновим соответственно информацию в pas и в cars. Затем удалим найденный элемент из zero и добавим его в one, так как теперь в этом вагоне столько же людей, как и во всех вагонах, лежащих в one. Если же zero станет пустым, то надо one и zero поменять местами, так как во всех купе стало одинаковое количество людей.
```
int car = *zero.upper_bound(0); // получаем номер купе
pas[++id] = car; // добавляем пассажира в список пассажиров
cars[car].insert(id); // добавляем пассажира в набор пассажиров купе
zero.erase(car); // переносим купе из списка претендентов на заполнение
one.insert(car); // … в список заполненных купе
if (zero.empty()) // если вышло так, что претендентов на заполнение больше нет…
{
zero = one; // переносим все заполненные купе в список претендентов
zero.erase(-n); zero.erase(2 * n);
one.clear(); // очищаем список заполненных купе
one.insert(-n); one.insert(2 * n);
}
```
**Операция сдачи билета («-»).** При помощи массива pas узнаем, в каком купе сидел пассажир. Удаляем пассажира из соответствующего купе.
```
int car = pas[x]; cars[car].erase(x); pas[x] = −1;
```
Узнаем, к какому множеству принадлежало купе car. Здесь есть следующие варианты:
* принадлежало множеству one — «заполненных купе». Тогда просто удаляем X из one и добавляем его в zero, то есть переносим купе в незаполненные;
* принадлежало множеству zero и множество one пусто. Тогда переносим все zero (претенденты на заполнение) в one (заполненные), оставляя в zero только купе, из которого выбыл пассажир.
* принадлежало множеству zero и множество one не пусто. Это единственный случай, в котором возникает ситуация, в которой разница между количеством пассажиров в купе могла стать равной двум. Для этого в множестве one находим первое купе, которое по номеру больше, чем наше купе, и последнее купе, которое по номеру меньше, чем наше купе. Затем из этих двух найденных купе выбираем ближайшее. Переносим его из множества one (заполненных) в множество zero («претенденты»). Также проводим корректировки в массиве купе cars и в массиве пассажиров pas.
```
set::iterator ll = (one.upper\_bound(car));
ll--; // находим первое, по номеру меньше
set::iterator rr = (one.upper\_bound(car)); // находим первое, по номеру больше
if (abs(\*ll - car) > abs(\*rr - car)) // Из этих двух найденных купе выбираем ближайшее
ll = rr;
int l = \*ll;
one.erase(l); zero.insert(l); // переносим из one в zero
int p = \*cars[l].upper\_bound(0);
cars[l].erase(p); cars[car].insert(p); // переносим из купе в купе
pas[p] = car;
```
Для вывода ответа на задачу воспользуемся массивом cars. Чтоб вывести информацию о пассажирах в i-м купе, достаточно вывести размер множества cars[i],
```
cout << cars[i].size() << ((cars[i].size() == 0) ? "\n" : " ");
```
а затем и всех пассажиров, принадлежащих множеству cars[i].
```
set::iterator en = cars[i].end();
en--;
for (set::iterator it = cars[i].begin(); it != cars[i].end(); it++)
cout << \*it << ((it == en) ? "\n" : " ");
```
Монеты
======
По условию задачи некий волшебник Ринсвид путает монеты, и вместо оплаты, скажем, дублонами, он отсчитывает стерлинги (при этом самими настоящими стерлингами он не платит). Нужно посчитать, сколько существует пар монет, таких, что приняв первую монету за вторую, он мог заплатить ровно T долларов вместо S, как он посчитал.
Для иллюстрации приводится пример. Если в обращении есть монеты номиналом 1, 2 или 3 доллара, а Рисвинд заплатил 10 долларов вместо 9, то он мог это сделать, принявши монеты номиналом 2 за монеты номиналом 1, и заплатил, например, четыре монеты номиналом 2 и одну монету номиналом 2, которую он принял за номинал »1«.
Также он мог принять монеты номиналом 3 за монеты номиналом 2 и заплатить семь монет номиналом 1 и одну номиналом 3, которую принял за монету номиналом 2.
| | | | |
| --- | --- | --- | --- |
| **Сколько реально заплачено номиналом 1** | **Сколько реально заплачено номиналом 2** | **Сколько реально заплачено номиналом 3** | **Итого заплачено** |
| — | **реально**
4 монеты
(8 долларов, 4×2)
1 монета
(2 доллара, 2×1)
**в представлении Рисвинда —**
1 доллар (1×1) | — | **реально**
5 монет
(10 долларов, 4×2+2×1)
**в представлении Рисвинда —**
9 долларов (4×2+1×1) |
| **реально**
7 монет
(7 долларов, 7×1) | — | **реально**
1 монету
(3 доллара, 3×1)
**в представлении Рисвинда —**
2 доллара (2×1) | **реально**
8 монет
(10 долларов, 4×2+1×1)
**в представлении Рисвинда —**
9 долларов (4×2+2×1) |
Предположим, что Ринсвинд принял монету t за s. В последнем примере — монету 3 (t) за 2 (s). Это значит, что он набрал некоторую сумму V (в примере — 10 долларов), не используя монету s (в примере — 7 долларов), после чего положил еще k монет номер t, думая что это монеты номер s (в примере — 1 монету 3, думая, что это 2).
Другими словами, все разнообразие вариантов укладывается в две группы случаев:
* существуют целые числа V ≥ 0 и k > 0, такие что S = V + k · as и T = V + k · at, где T — реально заплаченная сумма, а S — сумма в представлении Рисвинда.
* сумму V можно набрать, не используя монету s.
Первое условие можно проверить за O(1). Заметим, что
k = (S − T) / (as — at);
V = S − k · as
Осталось проверить, что полученные числа целые, V ≥ 0, и k > 0.
Для того, чтобы проверить второе условие, воспользуемся методом динамического программирования. Пусть D[i][j] — можно ли при помощи первых i монет получить сумму j. База: D[0][0] = true. Переход: D[i][j] = D[i − 1][j] or D[i][j − ai]. Для реализации достаточно одного массива размера S. Время работы этого алгоритма O(S·n). Подробно про подход с использованием динамического программирования см. [Разбор задач с прошлого тура](http://habrahabr.ru/company/mailru/blog/144793/), а также [хороший материал с примерами и иллюстрациями](http://habrahabr.ru/post/113108/).
Используя описанный метод, вычислим для каждой суммы V от 1 до S, мог ли Ринсвинд набрать эту сумму, не используя монету s. После этого переберем монету, которую Ринсвинд принял за s. Теперь проверка обоих условий осуществляется за O(1). Итоговая асимптотика решения — O(S · n2).
Задачу «Монеты» решил первым Петр Митричев на 17:06. Всего правильных решений мы получили 234, что ставит эту задачу на третье место с конца по сложности.
Разбор строки
=============
В задаче рассказывается об алгоритме поиска словарных слов из данного текста — о так называемом жадном алгоритме, когда каждый раз из этого текста удаляется найденное слово. Приводится пример, что в некоторых случаях такой подход приводит к неправильным результатам. Скажем, для workingrass может быть удалено working и осталось бы некое rass, в то время как корректным решением было бы разбиение на три слова work / in / grass, каждое из которых имелось бы в словаре. Необходимо проверить, будет ли при указанном словаре жадный алгоритм отрабатывать верно, и, если не будет, привести пример строки, для которой разбиение на слова из словаря существует, но описанным алгоритмом оно не будет найдено. Если таких примеров несколько, необходимо найти кратчайший, то есть тот, длина которого не больше, чем у остальных. Если и таких несколько, нужно вывести любой.
Рассмотрим сначала ключевую идею, ведущую нас к решению задачи. Пусть есть строка t — искомый контрпример кратчайшей длины, и некоторое ее разбиение на слова из словаря w1, w2, ..., wk. Пусть жадный парсер, который мы пытаемся сломать, при исследовании этой строки первым «откусит» от нее строку w.
Докажем следующее утверждение: если длина строки w не больше, чем сумма длин строк w1, w2, ..., wk-1, то существует контрпример короче, чем строка t.
Пусть, для начала, длина строки t равна этой сумме. Тогда очевидно, что жадный парсер корректно отработает на строке t, так как от нее сначала будет «откушена» строка w, а потом строка wk, так как именно она будет являться самым длинным префиксом строки, содержащимся в словаре.
В таком случае, пусть длина строки w меньше, чем сумма длин строк w1, w2, ..., wk-1. Тогда существует число j такое, что wj разбивается на префикс wj1 и суффикс wj2, причем wj1 является суффиксом строки w (возможно, нулевой длины). Рассмотрим строку wj2. Если для нее существует корректное разбиение на слова из словаря, то достаточно оставить в качестве контрпримера конкатенацию строк wj2, wj+1, wj+2, ..., wk, которая будет являться более коротким контрпримером. Если же для строки wj2 разбиения на слова из словаря не существует в принципе, то более коротким контрпримером будет конкатенация строк w1, w2, ..., wj.
Итак, теперь мы можем представить себе то, как выглядит искомый контрпример.
Разработаем эффективный алгоритм для его построения. Пусть для каждой строки из словаря мы знаем, у каких ее суффиксов и префиксов существует разбиение на слова из словаря (позднее будет объяснено, как вычислить эти данные). Переберем все строки из словаря на предмет того, не являются ли они той строкой w, которая будет «откушена» первой. Понятно, что предпоследняя строка из верного разбиения может заканчиваться только там же, где заканчивается некоторый префикс строки w, для которого разбиение есть. Переберем все такие префиксы. Теперь осталось только понять, какие строки могут являться последними в верном разбиении контрпримера. Во-первых, это должны быть строки, длина которых больше, чем длина еще непокрытого суффикса проверяемой строки w. Во-вторых, непокрытый суффикс строки w должен в точности совпадать с префиксом строки-кандидата на последнее место в разбиении соответствующей длины. И, наконец, суффикс строки-кандидата, непокрытый строкой w, не должен иметь корректного разбиения на слова из словаря.
Здесь уместно сделать одно важное замечание. Даже если непокрытый суффикс строки-кандидата имеет разбиение на слова из словаря, то, что мы проверяем в данный момент, все-таки может быть контрпримером. Однако, тогда контрпримером будет и сам по себе этот суффик, а тогда то, что мы проверяем, не является искомым кратчайшим контрпримером, и нас не интересует.
При таком подходе к решению задачи необходимо задаться еще одним вопросом. А что будет, если вместо строки w, которую мы проверяем, первой будет «откушена» другая строка, у которой w — префикс? В таком случае жадный парсер будет вести себя непредсказуемо, и может найти какое-нибудь разбиение. Однако для того, чтобы избежать этой участи, необходимо просто проверять строки на то, не являются ли они строкой w в порядке невозрастания их длин, и запоминать строки, которые мы уже проверили. Тогда каждая строка, с которой такая проблема вообще возможна, будет проверена к моменту возникновения проблемы, и мы сможем просто проигнорировать эту строку.
Теперь, когда общий алгоритм решения задачи есть, осталось решить задачу о проверке префиксов и суффиксов на разбиваемость, а также научиться быстро сравнивать нужные подстроки нужных строк на равенство. Вторая задача решается достаточно просто с помощью алгоритмов хеширования, которые сами по себе являются темой для отдельной статьи или лекции. Первая же задача решается с помощью динамического программирования. Пусть для всех префиксов строки t, длина которых строго меньше l, мы знаем, имеется ли их разбиение на строки из словаря. Чтобы проверить, существует ли разбиение префикса длины l, достаточно перебрать все строки из словаря и проверить существование такой, что выполняются два утверждения:
* суффикс изучаемого префикса соответствующей длины в точности равен строке из словаря
* префикс изучаемого префикса соответствующей длины разбивается на слова из словаря
Использовав для проверок на совпадение строк уже упомянутые алгоритмы хеширования и сделав аналогичные операции для всех суффиксов всех строк из словаря, мы за O(sumL × n), где sumL — суммарная длина всех строк, а n — их количество, вычислим все, что нам понадобится при реализации основной части. Заметим также, что реализация самого решения будет работать за то же самое время.
Задача «Разбор строки» оказалась (да и замышлялась) самым «крепким орешком», ее решило всего три человека, из них самым первым – Епифанов Владислав на 115:47.
Принц
=====
В этой задаче необходимо найти минимальное время, за которое принц попадет к принцессе по одномерному коридору, не попав ни в одну ловушку. Известны расписание, размеры и места появления/исчезновения ловушек, а также скорость движения принца. Поскольку коридор одномерный, двигаться принц может либо по направлению к принцессе, либо от нее, либо никуда не двигаться вообще. Очевидно, существуют ситуации, когда выхода нет, и принц не попадет к принцессе — в этом случае нужно вывести Impossible.
Решение этой задачи стоит начать с того, что изобразить ловушки на плоскости, где одной координатой x является позиция в коридоре, а координатой x — время. Теперь задачу можно переформулировать в понятиях этой плоскости: требуется попасть из точки (0, 0) в точку (x, y) с минимальным y, при этом разрешено двигаться вертикально вверх (стоять на месте), по диагонали направо вверх и налево вверх (двигаться по коридору) и запрещено заходить в определенные прямоугольники (ловушки). Находиться на границе прямоугольника разрешено.
Оптимальный путь в такой задаче будет состоять из множества однотипных частей, каждая из которых будет состоять из движения по одной из диагоналей до координаты, соответствующей границе одного из прямоугольников, с последующим движением вертикально вверх до верхнего угла этого прямоугольника. Таким образом, ключевыми точками являются верхние левые и верхние правые углы каждого прямоугольника и про них необходимо выяснить, можно ли туда попасть.
При движении по диагонали будем поддерживать множество прямоугольников, находящихся над текущей позицией. Так как на границе прямоугольников находиться можно, то прямоугольники, начинающиеся или заканчивающиеся на текущей «коридорной» координате, учитывать не будем. Прямоугольники будем хранить в множестве, упорядоченными по нижнему краю. Такое множество будем называть срезом. Для хранения множества можно использовать структуры данных, подобные красно-черным или декартовым деревьям или очереди с приоритетом. Нижний край нижнего прямоугольника будем называть краем среза. Если срез не содержит прямоугольников, то будем считать его край бесконечностью.
Так как при любом движении увеличивается координата времени, то будем рассматривать углы прямоугольников в порядке неубывания этой координаты. Рассматривая очередной угол, попытаемся двигаться от него по диагонали в обе стороны. Движение осуществляется по координатам, соответствующим границам прямоугольников. Достигая очередной координаты, проверяем, можно ли, двигаясь вертикально вверх, попасть в соответствующий верхний угол какого-либо прямоугольника. Достичь угол можно, если этот угол находится не выше края текущего среза. Также необходимо проверить, что движение не уперлось в край одного из прямоугольников, начинающихся в данной координате. Если удалось достигнуть координаты двери x, то необходимо обновить текущий ответ. Если при движении от одной координаты к другой был превышен край среза, то при переходе был достигнут нижний край прямоугольника, и движение необходимо прекратить.
Поочередно рассмотрев все углы и шагая в обе стороны от каждого из них, найдем минимальный возможный ответ или информацию о том, что дверь не достижима. Описанный алгоритм совершает O(n2 log n) операций, так как необходимо из каждого из O(n) углов пройти по диагонали O(n) различных координат и проверить O(n) прямоугольников. Также для каждого угла приходится совершать O(n log n) операций для поддержания среза, так как необходимо добавлять и удалять из среза O(n) прямоугольников.
Далее приведены возможные варианты прохождения мимо прямоугольников, которые необходимо не забыть обработать.
и
В то же время на следующем тесте невозможно успеть попасть к двери.
Эта задача тоже не из простых – ее решило всего 23 человека, первым – Куликов Егор на 100:18. Тут стоит отметить Епифанова Владислава, отправившего решение этой задачи, для него – последней, за 2 минуты до конца тура. Владислав занял первое место как в квалификации, так и на отборочном туре.
---
50 лучших из отборочного раунда перешли в финал. Он состоится 10 сентября в Swissotel, в Москве. Будет видеотрансляция, и, конечно, разбор задач и рассказ о финале после мероприятия.
*Алиев Рауф
директор по образованию и исследованиям
Mail.Ru Group* | https://habr.com/ru/post/146458/ | null | ru | null |
# PostgreSQL. Добавляем not null constraints в большие таблицы
Проекты развиваются, клиентская база увеличивается, базы данных разрастаются, и наступает момент, когда мы начинаем замечать, что некогда простые манипуляции над базами данных требуют более сложных действий, а цена ошибки сильно повышается. Уже нельзя за раз промигрировать данные с одного столбца в другой, индексы лучше накатывать асинхронно, добавлять столбцы с `default` значениями теперь нельзя.
Одной из команд, с которой надо быть осторожным на таблицах с большим количеством записей, является добавление `not null constraint` на столбец. При добавлении данного `constraint` PostgreSQL приобретает [`access exclusive lock`](https://www.postgresql.org/docs/12/explicit-locking.html#LOCKING-TABLES) на таблицу, в результате чего другие сессии не могут временно даже читать таблицу; затем БД проверяет, что в столбце действительно ни одного `null` нет, и только после этого вносятся изменения. Под катом я рассмотрю различные варианты, как можно добавить `not null constraint`, лоча таблицу на минимально возможное время или даже не лоча ее совсем.
#### TL;DR:
1. В PostgreSQL 12+ можно добавить `check constraint` на таблицу, а затем "преобразовать" его в `not null constraint` для конкретного столбца.
2. Чтобы полностью избежать блокировки таблицы, можно напрямую внести изменения в системную таблицу `pg_attribute` (этот пункт подробно разбирается в статье).
PostgreSQL постепенно добавляет новые возможности для работы с огромными таблицами. В 8.2.0 добавилась [возможность создавать индексы асинхронно](https://github.com/postgres/postgres/commit/e093dcdd2853911ca1ad710581182dfcb6c78ea3) через `index concurrently`, в 9.1.0 была добавлена [возможность создавать foreign constraints с флагом not valid](https://github.com/postgres/postgres/commit/722bf7017bbe796decc79c1fde03e7a83dae9ada) и позже вызывать `validate` для этих `constraints`, чтобы не блокировать таблицу надолго. Но пока что ничего такого для `not null constraint` добавлено не было. Было бы удобно сделать что-то вроде
```
... set not null not valid;
```
, чтобы завалидировать `constraint` позже без блокировки таблицы. Или можно было бы дать возможность добавить `constraint` без валидации, если я уверен, что в столбце нет `nulls`:
```
... set not_null_but_dont_check_anything_because_i_checked_myself_i_swear;
```
К сожалению, первый вариант еще не был никем закоммичен в PostgreSQL, но я уверен, что это будет сделано в будущем. К счастью, второй вариант пока тоже не реализован, и будем надеяться, что это так и останется в будущем. Хотя, может быть, дать больше возможностей разработчику и доверять ему, когда он просит не проводить дополнительную валидацию, — это не такая плохая идея?
Итак, какие же варианты у нас присутствует, если мы решили сделать какой-то столбец `not null`.
#### 1. Just do it!
Не все БД — высоконагруженные, не во всех таблицах миллионы записей, не все базы данных должны быть доступны 24/7. В общем, если вы можете просто добавить `constraint` и время блокировки таблицы для вас приемлемо, то вам так и следует сделать.
#### 2. Just… don't do it?
Это больше вредный совет, чем директива к действию, но можно просто не добавлять `not null constraint` и делать все проверки на уровне бизнес-логики в коде приложения. Но, конечно, наличие `constraints` на уровне БД — это вещь полезная и то, от чего не стоит отказываться. А уж если БД разрослась настолько, что просто так добавить `not null`, не затронув пользователей, нельзя, то тем более стоит по максимуму использовать инструменты валидации информации, предоставляемые базой данных: `unique constraints`, `not null constraints`, `foreign key constraints`, etc.
#### 3. Проиндексируйте столбец
~~Если столбец позже будет использован для фильтрации данных или является `foreign key`, то наличие индекса будет логичным. В этом случае добавление `not null constraint` будет осуществляться несравнимо быстрее, поскольку базе будет достаточно просто проверить, присутствуют `nulls` в столбце или нет.~~
~~Однако, если индекс на столбце не нужен, то добавление индекса, просто чтобы быстрее добавить `not null constraint`, выглядит, как лишняя работа и явный workaround. Но, безусловно, это вариант решения проблемы.~~
**Update:** [Melkij](https://habr.com/ru/users/melkij/), контрибьютер в PostgreSQL, указал на то, что индексы при добавлении constraints не используются. Т.е. добавление индекса не сделает добавление constraint более быстрым.
#### 4. Добавьте check constraint и ограничьтесь этим
PostgreSQL пока не умеет добавлять `not valid not null constraints`, но он уже умеет добавлять `not valid check constraints`. Выглядит это так:
```
alter table MY_AWESOME_TABLE add constraint CHECK_MY_AWESOME_TABLE_ON_MY_SPLENDID_COLUMN check (MY_SPLENDID_COLUMN is not null) not valid;
```
После этого можно вызвать
```
alter table MY_AWESOME_TABLE validate constraint CHECK_MY_AWESOME_TABLE_ON_MY_SPLENDID_COLUMN;
```
и вуаля: `not null constraint` добавлен! Команда `validate` приобретает мягкий `share update exclusive lock`, который не мешает остальным сессиям читать и менять данные в таблице.
Какие могут быть проблемы с этим решением? Во-первых, растет сложность поддержки и последующих изменений в БД. Собрать информацию, какие столбцы `nullable`, а какие — нет, сложнее, и следовательно, больше риск совершить ошибку. Если проект разрастется, то неконсистентность в решениях может представить проблему. С другой стороны, если проект развился до такой степени, значит, скорее всего, дела идут неплохо, и есть средства, которые можно выделить на то, чтобы привести базу в порядок.
Во-вторых, существуют инструменты, которые могут сравнивать схемы базы данных и код приложения для обнаружения потенциальных ошибок в настройке ORM. Например, в проекте, ради которого я и занялся изучением вопроса быстрого добавления `not null constraints`, используется [CUBA Studio](https://www.cuba-platform.com/tools/), которая умеет при старте приложения на машине разработчика проверять, полностью ли совпадает конфигурации базы данных с Java классами сущностей. Пока что Studio не умеет сравнивать `not null constraints` и `check constraints`, и поэтому если поле в классе помечено JPA аннотацией `@NotNull`, а в БД столбец является `nullable`, будет выведено предупреждение и предложен SQL update скрипт, который приведет таблицу к консистентности с кодом. Это, конечно, все можно заигнорить и работать дальше, тем не менее это полезный инструмент, который помогает находить ошибки, и я лично не хотел бы от него отказываться.
Но если вы не используете никакое ПО для анализа структуры БД и вас не пугает не консистентный подход к проставлению `not null constraints`, то использование `check constraints` является адекватным способом решения проблемы. Тем более, что в будущем всегда можно будет заменить `check constraints` на обычные `not null constraints`, а в PostgreSQL 12 это еще и не вызовет долгого лока на таблице. Об этом рассказывает следующий пункт.
#### 5. Добавьте check constraint, но не ограничивайтесь этим
В PostgreSQL версии 12 было представлено интересное улучшение: БД не полезет проверять все записи на отсутствие `nulls`, если другой `constraint` уже гарантирует, что в столбце `nulls` нет. Если у вас включены логи уровня `DEBUG1`, то там вы увидите сообщение вида: "*existing constraints on column MY\_AWESOME\_TABLE.MY\_SPLENDID\_COLUMN are sufficient to prove that it does not contain nulls*".
[Release notes](https://www.postgresql.org/docs/release/12.0/) содержат краткое описание этого нововведения, но release notes настолько объемны, что пропустить такие приятные маленькие улучшения достаточно легко.
Что касается более ранних версий PostgreSQL, где этой фичи еще нет, то `not null constraint` можно добавить напрямую в системную таблицу. Наличие `check constraint` гарантирует, что в столбце нет `nulls`, поэтому опасности что-то сломать — нет.
#### 6. Измените системную таблицу напрямую
Как вообще хранится `not null constraint` в PostgreSQL? На самом деле, очень просто. Есть таблица [`pg_attribute`](https://www.postgresql.org/docs/12/catalog-pg-attribute.html). В этой таблице для каждого столбца в БД содержится отдельная запись, в которой есть такие данные, как: имя столбца, тип данных, порядковый номер (изменение этого атрибута гарантированно зафакапит вам таблицу), есть ли у столбца дефолтное значение, и т.д. В том числе здесь есть `boolean` столбец `attnotnull`, который как раз и определяет, могут ли храниться в определенном столбце `nulls` или нет.
На этом пункте давайте остановимся поподробней.
Разумеется, при прочих равных лучше использовать рекомендуемые в документации способы работы с БД и не лезть в системные таблицы. Через системные таблицы можно сделать много чего интересного (добавить дефолтное значение, добавить `foreign constraints`, etc.), но, конечно, безопасней все-таки это делать привычными способами: через "`alter table MY_AWESOME_TABLE add constraint …`". Это минимизирует вероятность выстрелить себе в ногу. Да и коллегам не надо ничего лишнего объяснять, добавляя миграционные SQL скрипты в репозиторий. Кроме того, то, что сейчас можно поменять `not null constraint` напрямую через `pg_attribute`, не значит, что в будущих версиях PostgreSQL это не вызывает неожиданный side-effect.
Но конкретно с `not null constraint` я считаю, что игра стоит свеч. По сути, нет нормального способа сделать столбец `not null` без долгой блокировки таблицы. Добавление `check constraint` с его опять же последующим удалением — это суть workarounds, которые базируются на знании того, как работает PostgreSQL. И при использовании этих workarounds коллегам все равно придется объяснить, как это все работает.
В итоге, я пришел к такому скрипту:
```
-- alter table MY_AWESOME_TABLE alter column MY_SPLENDID_COLUMN set not null ;
do $$
begin
if (select exists (select 1 from MY_AWESOME_TABLE where MY_SPLENDID_COLUMN is null limit 1)) then
raise exception 'MY_AWESOME_TABLE.MY_SPLENDID_COLUMN contains null values';
else
update PG_ATTRIBUTE set ATTNOTNULL = true
where ATTRELID = (select OID from PG_CLASS where RELNAME = lower('MY_AWESOME_TABLE'))
and ATTNAME = lower('MY_SPLENDID_COLUMN');
end if;
end $$;
```
Проверка `select exists` здесь на всякий случай. Если я добавляю `not null constraint`, то я уверен на 100%, что все приложения, имеющие доступ к БД, `null` в этот столбец не проставляют.
Дальше идут технические подробности. Если они вам не интересны, можете смело прыгать к заключению.
Для начала, хочу заметить, что в прошлом такой workaround [был даже прописан в документации PostgreSQL](https://www.postgresql.org/docs/9.3/catalog-pg-attribute.html): "*It is possible to change this column to enable or disable the constraint.*" В 10.12 этот [комментарий был удален](https://github.com/postgres/postgres/commit/80e6af1272750595c02e910bde907e30c592579b). Самое досадное в коммите — это то, что в сообщении коммита не содержится информации, почему документация изменена. Сообщение выглядит так: "*docs: remove mention that attnotnull should be changed*". Если бы было добавлено что-то вроде "*because it's a bad practice*", или "*because I was asked by Tom to do it*", или "*because recent changes in the attribute cache made it unsafe to work with the table directly*", или даже "*just because I decided so*", это было бы гораздо информативней. Я полагаю, что изменение в документации связано с тем, чтобы не поощрять разработчиков лезть туда, куда их не просят, дабы они не наломали там дров. Тем не менее, я решил проверить, что теоретически может пойти не так, чтобы не было сюрприза позже.
**Update:** в комментариях дали ссылку на обсуждение, которое привело к тому, что из документации был убран совет вручную менять `attnotnull`: <https://www.postgresql.org/message-id/flat/20140724122945.GD16857%40alap3.anarazel.de>.
Итак, что же теоретически может пойти не так? Очевидно два проблемных сценария: `constraint` был добавлен на столбец, в котором все-таки были `nulls`; в PostgreSQL возможен кэш для системных таблиц, который может быть не обновлен при изменении таблиц напрямую.
Проверить оба сценария — вопрос пары минуты. Можно успешно добавить `not null constraint` на столбец, где есть `nulls`. Select в этом случае продолжает работать корректно, без ошибок. Выглядит так, будто `constraint` нужен только для проверки входных значений при `update/insert`, и не проверяется в остальных случаях. Также все успешно работает при добавлении `constraint` в одном коннекшене и проверке, что все ок, — в другом. Т.е., если кэш и есть, то он корректно обновляется. Таким образом, базовые тест-кейсы были прогнаны успешно.
Разумеется, эти проверки — поверхностны, и я мог что-то не учесть, что потом вызвало бы проблему. Поэтому я поступил так, как показалось мне наиболее разумным: ~~перекрестился и накатил скрипт на проде~~ пошел в исходники. Цели было три: пробежаться по всему, что происходит при добавлении `not null constraint`; найти все места, где используется `attnotnull`, чтобы осознавать, какова цена ошибки; понять, как кэшируется/шарится `pg_attribute` между сессиями (ведь должна же информация, которая используются буквально при каждом запросе к БД, как-то кэшироваться?).
С первым пунктом все достаточно просто. Логика сконцентрирована в [ATController](https://github.com/postgres/postgres/blob/d0587f52b3bb898db3c0011954de6ae9adc076c8/src/backend/commands/tablecmds.c#L3898). Вкратце и упрощенно: перед вызовом данной функции PostgreSQL лочит таблицу; затем проверяет, есть ли у меня `permissions` на таблицу, не является ли таблица системной; обновляет таблицу `pg_attribute`; если нет `check constraint`, который гарантировал бы, что в таблице нет `nulls`, то проходится по всей таблице, чтобы удостоверится, что `nulls` действительно отсутствует (собственно, вот этот `full table scan` и послужил причиной написания статьи). Ничего такого, что заставляет сомневаться, не бросить ли идею с прямым редактирование системной таблицы.
Далее, проверяю всю логику в проекте, завязанную на `attnotnull`, чтобы понимать, чем чревато, если в `not null` столбце есть `nulls`. Как ожидалось, проверки происходят при `update` и `insert`, но это далеко не все. Проверки также осуществляются при логической репликации (logical replication), которая впрочем тоже не должна создать проблемы. Проверки осуществляются при восстановлении БД из SQL бэкапа (через pg\_dump, например). В этом случае восстановление из бэкапа не упадет, но ошибочные записи в таблицу вставлены не будут. Но это все тоже можно условно отнести к “проверкам при `update` и `insert`”. Затем идет самое интересное: `attnotnull` проверяется при [slot\_compile\_deform](https://github.com/postgres/postgres/blob/d0587f52b3bb898db3c0011954de6ae9adc076c8/src/backend/jit/llvm/llvmjit_deform.c#L34). Суть такова: для ускорения загрузки записей с жесткого диска PostgreSQL может использовать [JIT компиляцию](https://www.postgresql.org/docs/12/jit-reason.html#JIT-ACCELERATED-OPERATIONS). Для каждой таблицы может быть сгенерирован нативный код для анализа записей (преобразования байтового представления в логическое). При генерации данного кода проверяется атрибут `attnotnull`. Если он равен `true`, то компилятор считает, что в столбце точно не может быть `null`, и использует эту информацию позже, чтобы избежать лишних проверок. JIT компиляция появилась в PostgreSQL 11 и там она еще по умолчанию выключена. В PostgreSQL 12 JIT компиляция уже включена по умолчанию.
Таким образом, мое изначальное предположение о том, что флаг `attnotnull` используется только при записи данных и при чтении данных точно ничего не поломает, было ошибочным. Проставление `attnotnull = true` для столбца, в котором есть `null`, может и не вызвать никаких проблем в момент осуществления этой операции, но при миграции на будущие версии может оказаться неожиданный сюрприз.
По кэшу системных таблиц. Здесь все хорошо. При внесении изменений вызывается функция [CacheInvalidateHeapTuple](https://github.com/postgres/postgres/blob/d0587f52b3bb898db3c0011954de6ae9adc076c8/src/backend/utils/cache/inval.c#L1114), которая при необходимости сбрасывает кэши для `pg_class, pg_attribute, pg_index`. Следовательно, можно не беспокоиться, что изменения в одной сессии будут проигнорированы в другой сессии.
Итак, анализ кода показал, что проставление `not null constraint` — это простое изменение `attnotnull` в таблице `pg_attribute`. Никаких дополнительных действий (помимо множества проверок и обновления кэшей) — не происходит. Но ошибаться ни в коем случае нельзя, поскольку PostgreSQL полагается на этот параметр в большом количестве мест, в том числе, и при операциях чтения (при включенной JIT компиляции).
Хочу заметить, что я проверял только вариант, когда в БД не используются [наследование таблиц](https://www.postgresql.org/docs/12/ddl-inherit.html) и [секционирование (partitioning)](https://www.postgresql.org/docs/12/ddl-partitioning.html). Там могут быть свои нюансы, поэтому перед внесением изменений в `attnotnull`, лучше ознакомиться с функцией [ATController](https://github.com/postgres/postgres/blob/d0587f52b3bb898db3c0011954de6ae9adc076c8/src/backend/commands/tablecmds.c#L3898) в PostgreSQL.
#### Итог
Если у в продакшене крутится PostgreSQL 12+, то можно сначала добавить `check constraint` на всю таблицу, а потом уже добавить `not null constraint` к столбцу. В этом случае БД не будет делать лишнюю проверку на наличие `nulls` в столбце.
Тем, кто хочет добавить `not null constraint` очень быстро и не видит ничего зазорного в работе с системными таблицами, можно напрямую внести изменения в таблицу `pg_attribute`. | https://habr.com/ru/post/493954/ | null | ru | null |
# Сохранение пакетов Perl через local
В **perl** есть выражение **local**. Оно подменяет указанное значение **undef**-ом до конца блока. В качестве значения могут выступать глобальные хеши, массивы и скаляры, а так же элементы или срезы хешей и скаляров.
Проблема в том, что хеши пакетов **local** не сохраняет.
Под хешами пакетов я понимаю хеш с двоеточием на конце (`%Пакет::)` в котором хранятся символы пакета (GLOB).
```
package A {
sub fn {}
$x = 10;
@x = qw(1 2);
}
use DDP;
p %A:: # -> {
# fn *A::fn (layers: ),
# x *A::x (layers: )
# }
```
Тут `@x` и `$x` находятся в одном глобе - `*A::x`.
Доступ к ним можно получить так:
```
package A {
sub fn {}
$x = 10;
@x = qw(1 2);
}
$\ = "\n"; $, = ", ";
print $A::x, ${ *A::x{SCALAR} }, ${ *{ $A::{x} }{SCALAR} };
# -> 10, 10, 10
print @A::x, @{ *A::x{ARRAY} }, @{ *{ $A::{x} }{ARRAY} };
# -> 1, 2, 1, 2, 1, 2
```
То есть вначале получаем GLOB из хеша пакета (`$A::{x}`), разыменовываем его (`*{ $A::{x} }`), получаем ссылку на скаляр (`*{ $A::{x} }{SCALAR}`) и, наконец, разыменовываем скаляр (`${ *{ $A::{x} }{SCALAR} }`).
GLOB же это такой специальный хеш с предустановленными ключами: SCALAR, ARRAY, HASH, CODE, REF, GLOB, LVALUE, FORMAT, IO, VSTRING.
Каждый из них соответствует отдельному типу значения который может хранится в символе (fn и x - символы в пакете A).
Но вернёмся к **local**.
```
use DDP;
our %x = qw/a b d c/;
{
local %x;
$x{a} = "R";
p %x; # -> {
# a "R"
# }
}
p %x; # -> {
# a "b"
# d "c"
# }
```
Как видим **local** подменила `our %x` до конца блока.
С `my %x` **local** отказывается работать (выбрасывает исключение):
```
@@файл x.pl:
my %x = qw/a b/;
{
local %x;
p %x;
}
@@консоль:
$ perl x.pl
Can't localize lexical variable %x at x.pl line 13.
```
А теперь самое интересное: на хеш пакета **local** не ругается, но и не сохраняет его:
```
package A {
sub fn { 10 }
$x = 20;
}
{
local %A::;
*A::fn = sub {6};
$A::x = 3;
print &A::fn; # -> 6
print $A::x; # -> 3
}
print &A::fn; # -> 6
print $A::x; # -> 3
```
То есть `$A::x` и `A::fn` не вернулись к первоначальному состоянию.
Тем не менее если сохранять не хеш `%A::`, а срез всех его ключей (@A::{keys %A::}), то **local** сработает:
```
package A {
sub fn { 10 }
$x = 20;
}
{
local @A::{keys %A::};
*A::fn = sub {6};
$A::x = 3;
print &A::fn; # -> 6
print $A::x; # -> 3
}
print &A::fn; # 10
print $A::x; # 20
```
Вот и ещё одна тайна **perl**-а раскрыта!
Хотя не до конца. Если у кого-то есть объяснение такому странному поведению **local** c хешем пакета, то хотелось бы его увидеть в комментариях.
Ну и напоследок предлагаю полюбоваться содержимым пакета **main**:
 Обратите внимание на наш пакет **A**, который на самом деле **main::A**.
Все остальные пакеты находятся в пакете main, а пакеты с четвероточиями укладываются в них иерархически образуя древовидную структуру:
```
package A {
sub fn { 10 }
$x = 20;
}
package A::A {
$x = 30;
}
# ->
# %main::
# A:: *main::A
# fn *A::fn
# x *A::x
# A:: *A::A::
# x *A::A::x
print \%main::A == \%A? "одно и то же": "разное";
# -> одно и то же
print $main::{A::}{A::} == $A::A::? "одно и то же": "разное";
# -> одно и то же
```
Вот и всё. Остаётся только пожелать нам всем отличного программирования! | https://habr.com/ru/post/585038/ | null | ru | null |
# Статистика Google Analytics на вашем сайте
Помню, как-то проскакивала пара записей ([здесь](http://dab512.habrahabr.ru/blog/26862/) и [здесь](http://habrahabr.ru/blogs/webdev/19564/)) по поводу импортирования данных из Google Analytics для отображения сводных диаграмм на сайте, в общем, как на [хабре](http://habrahabr.ru/stats/). Прочитав вышеупомянутые топики и не обратив особого внимания тогда, я о них успешно «забыл» и пошел себе дальше. И вот сейчас, появилась необходимость реализовать нечто подобное на одном из своих проектов.
Просмотрев хабр еще раз, с удивлением обнаружил, что тогда так никто и не нашел какого-либо решения для реализации данной задачи. Поэтому, решил накропать скриптик для экспорта данных из GA и отображения их на сайте. Собственно, им и хочу поделиться с общественностью.
**UPDATE**:
Добавил еще одну версию, подробности и линк под катом.
Скачать можно [**отсюда**](http://statga.googlecode.com/files/statga_0.1b.zip).
Новую версию забирать [**здесь**](http://statga.googlecode.com/files/statga_0.1.1b.zip).
В config.php добавлена переменная $id, которая соответствует id в Google Analytics. Данный id используется в URL каждого из отчетов.
Т.е., можно либо в конфиге указать свой id в этой версии, либо подкорректировать переменные $url в предыдущей, указав в строке запроса необходимый id.
Спасибо [Orenlab](https://habrahabr.ru/users/orenlab/) за замечание.
**UPDATE 2:**
Следующая версия [**здесь**](http://statga.googlecode.com/files/statga_0.1.2b.zip).
В ga.php из запроса убран [www.askapache.com](http://www.askapache.com)
Без этой переменной все работает так же нормально. Зачем оно было надо — остается догадываться. Просмотрел гугловые заголовки — ничего подобного не увидел.
Спасибо [AlexSpaizNet](https://habrahabr.ru/users/alexspaiznet/) за замечание.
**UPDATE 3:**
Добавлена версия 1.0
Забирать [отсюда](http://statga.googlecode.com/files/statga_1.0.zip)
Это первый и последний релиз скрипта в том виде и с теми функциями, которые сейчас есть. С его помощью можно без особых сложностей подогнать все под свои нужды и использовать.
Измениения таковы:
— Немного перестроен парсер. К сожалению, возникли определенные трудности при работе с установленным в GA английским, поэтому:
**ВНИМАНИЕ! Для правильной работы в настройках Google Analytics обязательно должен быть установлен русский язык**
— Добавлены графики по посещениям
— Функция stripos заменена на strpos, так как stripos не работает в неокторых версиях PHP
— Решена проблема с кэшированием настроек и данных для графиков. Теперь при каждом рефреше вам должны отображаться обновленные данные
— index.html заменен на index.php
— в config.php появилась переменная $path — в качестве ее значения необходимо указать полный пусть к директории, в который будут писаться файлы
— также добавлена переменаая $debug — если она установлена как true, будет создаваться файл log.txt, в который будут сваливаться потоком, все отчеты, полученные от Google Analytics (т.е. именно те данные, который отдал гугл, еще до того как мы их пропарсили)
**Список всех версий —** [**здесь**](http://code.google.com/p/statga/downloads/list)
**UPDATE 4:**
В связи с последними изменениями в GA вышла версия 2.0b
Забирать как обычно [отсюда](http://statga.googlecode.com/files/statga_2.0b.zip)
Чтобы было понятно, что к чему и что поменялось, вкратце распишу изменения.
Итак, во-первых гугл поменял формат дат в отчетах, теперь вместо 25.10.2008 это выглядит как 25 октября 2008 г.
Кроме того, что-то поменялось в определении языка, используемому в отчетах. Сейчас через скрипт я всегда получаю англ язык, через броузер, нормально забирая отчет, получаю тот, который должен быть. С чем это связано пока не разобрался.
Итак, собственно к изменениям.
1) Решено было перейти на другой тип отчетов — *TSV*, как оказалось, под этим загадочным названием скрывается текстовый файл с разделителями табуляции. Это позволило нам вообще не зависеть от языка.
итак, во всех переменных $url в stat.php fmt=2 изменен на fmt=3
2) так как теперь у нас другой разделить в текстовых файлах — в обработках меняем "," на "\t"
эти строки выглядят примерно как
$line=explode("\t",$lines[$i]);
3) поскольку дату мы получаем уже в другом виде, форматнуть ее так как раньше уже не получится, посему камментим строки после
//форматируем дату
4) ну и собственно в анл языке принято тысячную долю отделять запятой, которую мы удаляем для того, чтобы amcharts нормально рисовал график
//убираем символ разделителя тысячи
$line[1]=str\_replace(chr(194).chr(160),"",$line[1]);
$line[1]=str\_replace(",","",$line[1]);
$line[2]=str\_replace(chr(194).chr(160),"",$line[2]);
$line[2]=str\_replace(",","",$line[2]);
Вроде все… с проблемами с русским разберемся в ближайшее время.
**UPDATE 5:**
Появилась версия 2.0.1
[Забираем](http://statga.googlecode.com/files/statga_2.0.1.zip)
Теперь нормально работает русский язык.
Изменения внесены в файл ga.php, добавлен один кукис — $aFoundCookies[1][]=«AnalyticsUserLocale=ru»;
Ну и по форматированию даты небольшие изменения сделаны в stat.php (но это не обязательно...)
Вкратце опишу главные нюансы, настройку и принцип работы.
(руководство по установке ниже)
Итак, наверно всем известно, что есть возможность получить из GA отчет в одном из форматов (PDF, XML, CSV и что-то еще). Таким образом, это самый простой способ экспорта данных. Однако, скачать отчет возможно лишь только после авторизации, и никаких внешних ссылок для скачивания отчета без авторизации недоступно. Правда, есть возможность отправки отчета на мыло (читал, что некоторые таким образом экспортили данные, т.е. отчет отправлялся в мыло, потом по крону запускался скрипт, который забирал почту, и парсил полученный отчет, но, имхо, это бред). В общем, для получения нам необходимо сэмулировать логин в систему и получить после этого данные. Для этого используем скрипт ga.php (который, кстати, писан не мною, а найден несколько месяцев назад в дебрях [форума серча](http://forum.searchengines.ru/), за что спасибо разработчику, т.к. это сэкономило время на разбор гугловой аутентификации).
Для реализации задачи нам бы подошли форматы либо XML, либо CSV. Уж не знаю, что меня в тот момент дернуло, но я остановился на последнем, т.е. это обычный текстовый файл, который нам необходимо определенным образом пропарсить для импорта данных и построения графиков.
Парсит полученные данные у нас скрипт stat.php (он и является основным запускаемым скриптом, который подгружает в себя ga.php и, короче говоря, генерирует резалтные файлы на диске для создания диаграмм)
Я попытался максимально прокомментировать код, чтобы было понятно, что куда и зачем, и можно было без особых сложностей добавить нужный отчет. Я же взял, на свое усмотрение, нужные мне 6 отчетов: Посещаемость с начала существования ресурса (дата указывается в настройках), Посещаемость за последние три месяца, Источники переходов, География посетителей, используемые браузеры и ОС за последние 30 дней.
Все настройки указываются в config.php
Кстати, на сайте, для которого мне необходимо было сделать отображение статистики, код google analytics был установлен только несколько месяцев назад, но хотелось показать рост посещаемости с самого начала существования, т.е. за два с лишним года в данном случае. Поэтому была добавлена возможность «приклеить» к данным, полученным из GA, информацию о посещаемости за время предшествующее установке гуглового счетчика. по умолчанию — это статичный файл default.csv, сформированным необходимым образом (в архиве есть пример всех csv-файлов, включая этот). Откуда брать для него данные — решать вам, в моем случае на сайте было установлено аж 4 счетчика вроде рамблера, мейлру и т.п. (чьи показания, кстати, разнятся ооочень существенно). Если надобности использования подобной схемы нет, просто укажите имя переменной, указывающей имя данного файла как false.
Для отображения диаграмм заюзаны [amCharts](http://www.amcharts.com/). Это платный продукт, стоимостью 85 евро за односайтовую лицензию. Однако, доступна и бесплатная версия, которая отличается лишь тем, что на диаграммах выводится ненавязчивая ссылка на сайт разработчика.
Настройки каждой из диаграмм указываются в соответствующих xml-файлах, которые хорошо прокомментированы, и я думаю, разобраться, что там к чему не составит большого труда. Я же для представления взял цветовую гамму, аналогичную графикам на хабре.
Данные для построения диаграмм подгружаются из сгенерированных нами выше csv файлов, специально подготовленных для использования в amCharts.
В конечном итоге мы получаем примерно [следующее](http://statga.ho.ua/).
Теперь можно загнать скрипт в крон, и несколько раз в сутки обновлять статистику, например так:
0 \*/8 \* \* \* /usr/local/bin/php /home/username/public\_html/stats/stat.php
С удовольствием выслушаю замечания и пожелания!
PS. **Установка**
Файл config.default.php переименовываем в config.php
Редактируем его, указывая, как мнимум, следующие настройки:
1. Ваша учетная запись в Google Analytics
id берем после логина через броузер и перехода на главную страницу с отчетами:
[www.google.com/analytics/reporting/?reset=1&id=](https://www.google.com/analytics/reporting/?reset=1&id=)**xxxxxxx**&scid=xxxxxxx
`//учетная запись GA
$u="user";
$p="password";
$id="1234567";`
2. Устанавливаем временную зону, если время сервера не совпадает с тем, что вам нужно
`//устанавливаем временную зону, во избежание недоразумений, если время на сервере отличается от необходимого
putenv('TZ=Europe/Kiev');`
Если совпадает — просто камментим или удаляем эти строки
3. Указываем начальную дату в формате YYYYMMDD
`$datestart="20080101";`
это дата, начиная с которой у вас будет рисоваться первый график, т.е. начало всей статистики
Все остальное можно не трогать, если все же хочется — остальные настройки прокомментированы
Далее заливаем все это в директорию на сервере
**ВНИМАНИЕ!** У вас должны быть права для записи в эту диреторию из PHP
Запрашиваем файл stat.php — он генерирует кучку .csv-файлов — это данные для графиков
Для отображения графиков, запрашиваем index.php
В свою очередь, stat.php можно засунуть в крон или любой другой планировщик задач и запускать несокльо раз в сутки для автоматического обновления графиков.
Удачи! Спасибо всем за проявленный интерес!
**Внимание! Новая версия доступна [здесь](http://habrahabr.ru/blogs/webdev/72335/)** | https://habr.com/ru/post/42080/ | null | ru | null |
# Разработка через тестирование в iOS
#### **Содержание:**
* Разработка через тестирование – что это?
* Три закона TDD
* Примеры применения
* Преимущества и недостатки
* Литература и ссылки
#### **Разработка через тестирование – что это?**
> Разработка через тестирование (Test-driven development) — техника разработки программного обеспечения, которая определяет разработку через написание тестов. В сущности вам нужно выполнять три простых повторяющихся шага:
>
> — Написать тест для новой функциональности, которую необходимо добавить;
>
> — Написать код, который пройдет тест;
>
> — Провести рефакторинг нового и старого кода.
>
>
>
> [Мартин Фаулер](http://martinfowler.com/bliki/TestDrivenDevelopment.html)
#### **Три закона TDD**
Сейчас многие знают, что TDD требует от нас писать сначала тесты, прежде чем писать production код. Но это правило — лишь верхушка айсберга. Предлагаю вам рассмотреть следующие три закона:
1. Не пишется production код, прежде чем для него есть неработающий тест;
2. Не пишется больше кода юнит теста, чем достаточно для его ошибки. И не компилируемость — это ошибка;
3. Не пишется больше production кода, чем достаточно для прохождения текущего неработающего теста.
Эти три закона удерживают программиста в цикле, который длится около минуты. Тесты и production код пишутся одновременно, с тестами всего на несколько секунд впереди production кода.
Если мы работаем этим путем, мы напишем десятки тестов в день, сотни каждый месяц, тысячи каждый год. Если мы работаем этим путем, то наши тесты будут полностью покрывать наш production код.
#### **Примеры применения**
##### Пример 1. Сортировка модельных объектов
Рассмотрим простейший пример написания метода сортировки модельных объектов (событий). Сначала пишем интерфейс нового метода (на вход принимает хаотичный массив объектов, а возвращает соответственно отсортированный):
Интерфейс тестируемого метода:
```
- (NSArray *)sortEvents:(NSArray *)events
```
Далее пишем тест:
Используем нотацию given, when, then для деления теста на три логических блока:
* создание окружения, предусловий теста;
* совершение действия, вызов тестируемого метода;
* проверка работы тестируемой функциональности.
Тест:
```
- (void)testSortEvents {
// given
id firstEvent = [self mockEventWithClass:kCinemaEventType name:@"В"];
id secondEvent = [self mockEventWithClass:kCinemaEventType name:@"Г"];
id thirdEvent = [self mockEventWithClass:kPerfomanceEventType name:@"А"];
id fourthEvent = [self mockEventWithClass:kPerfomanceEventType name:@"Б"];
NSArray *correctSortedArray = @[firstEvent, secondEvent, thirdEvent, fourthEvent];
NSArray *incorrectSortedArray = @[thirdEvent, secondEvent, fourthEvent, firstEvent];
// when
NSArray *sortedWithTestingMethodArray = [self.service sortEvents:incorrectSortedArray];
// then
XCTAssertEqualObjects(correctSortedArray, sortedWithTestingMethodArray, @"Сортировка эвентов работает неправильно");
}
```
Только после того, как мы убедились, что тест не выполнится, пишем реализацию метода:
Реализация метода:
```
- (NSArray *)sortEvents:(NSArray *)events {
// Сортировка событий (Сначала кино, затем остальные, обе секции по алфавиту)
NSMutableArray *cinemaEvents = [[NSMutableArray alloc] init];
NSMutableArray *otherEvents = [[NSMutableArray alloc] init];
for (Event *event in events) {
if ([event.type isEqualToString:kCinemaEventType]) {
[cinemaEvents addObject:event];
} else {
[otherEvents addObject:event];
}
}
NSComparisonResult (^sortBlock)(Event *firstEvent, Event *secondEvent) = ^NSComparisonResult(Event *firstEvent, Event *secondEvent) {
return [firstEvent.type compare:secondEvent.type
options:NSNumericSearch];
};
[cinemaEvents sortUsingComparator:sortBlock];
[otherEvents sortUsingComparator:sortBlock];
return [cinemaEvents arrayByAddingObjectsFromArray:otherEvents];
}
```
После написания реализации метода проверяем, что все тесты, включая наш новый, успешно выполняются. При необходимости проводим рефакторинг написанного кода. Важно понимать, что рефакторинг можно проводить только из зеленого состояния в зеленое, т.е. когда все тесты успешно выполнены.
Очень важная особенность TDD – это инверсия ответственности. При классическом подходе к разработке ПО программист после написания кода самолично проводит тестирование, гоняет код в дебаггере, проверяет работу всех if-ов. В TDD именно тесты подтверждают работоспособность кода.
##### Пример 2. Маппер
Рассмотрим второй пример – маппер серверной выдачи в модельные объекты.
Маппер должен отвечать следующим требованиям:
1) мапить объекты (неожиданно)
2) обрабатывать кривую выдачу (Null, неверный тип данных, неверная структура выдачи)
3) обеспечивать консистентность данных (проверка обязательных полей)
Пишем интерфейс тестируемого метода, он будет синхронным:
Интерфейс тестируемого метода:
```
- (NSArray *)mapEvents:(id)responseObject
```
Далее пишем первый тест, проверяющий позитивный сценарий, т.е. маппинг объектов при адекватной выдаче. Мы не пишем сразу все тесты, не пытаемся покрыть все требования, которым должен отвечать маппер, а пишем единственный тест к простейшей реализации:
Тест:
```
- (void)testMapEventsResponseSuccessful {
// given
NSDictionary *responseObject = @{@"event" : @[@{@"type" : @1,
@"name" : @"test",
@"description" : @"test"}]};
// when
NSArray *events = [self.mapper mapEvents:responseObject];
// then
Event *event = events[0];
[self checkObject:event
forKeyExistence:@[@"type", @"name", @"description"]];
}
```
Для проверки объекта на наличие необходимых полей используем метод-хелпер на KVC:
```
- (void)checkObject:(id)object
forKeyExistence:(NSArray *)keys {
for (NSString *key in keys) {
if (![object valueForKey:key]) {
XCTFail(@"Объект не содержит необходимого поля - %@", key);
}
}
}
```
Далее пишем простейшую реализацию метода, которая отвечает нашему тесту и проверяем, что тест будет успешно пройден. В данном случае у маппера под капотом используется маппинг движок от RESTKit, но мы рассматриваем наш метод как черную коробку, его реализация в будущем может поменяться. Но требования в большинстве случаем останутся именно такими.
Реализация метода:
```
- (NSArray *)mapEvents:(id)responseObject {
NSDictionary *mappingsDictionary = @{kEventResponseKey : [self eventResponseMapping]};
RKMappingResult *mappingResult = [self mapResponseObject:responseObject
withMappingsDictionary:mappingsDictionary];
if (mappingResult) {
return [mappingResult array];
}
return @[];
}
```
Отлично, после написания простейшей реализации добавляем еще один тест для маппера, который проверяет, что маппер учитывает обязательность некоторых полей в выдаче, в нашем случае это будет поле id, которое отсутствует в тесте. Задача теста – убедиться, что не произойдет краша, и метод вернет пустой массив после маппинга.
Тест:
```
- (void)testMapEventsResponseWithMissingMandatoryFields {
// given
NSDictionary *responseObject = @{kEventResponseKey : @[@{@"name" : @"test"}]};
// when
NSArray *events = [self.mapper mapEvents:responseObject];
// then
XCTAssertFalse([events count]);
}
```
Далее расширяем наш метод, добавляем в него проверку на обязательность некоторых полей.
Реализация метода:
```
- (NSArray *)mapEvents:(id)responseObject {
NSDictionary *mappingsDictionary = @{kEventResponseKey : [self eventResponseMapping]};
RKMappingResult *mappingResult = [self mapResponseObject:responseObject
withMappingsDictionary:mappingsDictionary];
if (mappingResult) {
//Проверяем наличие обязательных полей в объекте
NSArray *events = [self checkMandatoryFields:[mappingResult array]];
return events;
}
return @[];
}
```
Исходя из первоначальных требований, наш маппер должен корректно себя вести в случае наличия Null-ов в выдаче, пишем проверяющий это тест:
```
- (void)testMapEventsResponseWithNulls {
// given
NSDictionary *responseObject = @{kEventResponseKey : @[@{@"type" : @1,
@"name" : [NSNull null],
@"description" : [NSNull null]}]};
// when
NSArray *events = [self.mapper mapEvents:responseObject];
// then
Event *event = events[0];
XCTAssertNotNil(event.type, @"");
XCTAssertNil(event.name, @"");
}
```
После написания и запуска теста видим, что он сразу успешно выполняется. Да, такое тоже бывает, существующий код может уже отвечать новым требованиям. В такой ситуации мы, конечно же, не удаляем этот тест, т.к. его задача и в будущем, при возможном изменении реализации маппера, проверять корректность его работы. Далее добавляем тест для неправильного типа данных, вместо числа – строка. Маппинг движок от RestKit умеет и с этим справляться, так что тест опять же будет гореть зеленым цветом.
```
- (void)testMapEventsResponseWithWrongType {
// given
NSDictionary *responseObject = @{kEventResponseKey : @[@{@"type" : @"123"}]};
// when
NSArray *events = [self.mapper mapEvents:responseObject];
// then
Event *event = events[0];
XCTAssertTrue([event.type isEqual:@123]);
}
```
##### Пример 3. Сервис получения событий
Рассмотрим сервис получения модельных объектов (событий), протокол будет содержать следующие методы:
```
@interface EventService : NSObject
- (instancetype)initWithClient:(id)client
mapper:(id)mapper;
- (NSArray \*)obtainEventsForType:(EventType)eventType;
- (void)updateEventsForType:(EventType)eventType
success:(SuccessBlock)success
failure:(ErrorBlock)failure;
@end
```
Сервис будет работать с CoreData, поэтому для тестирования нам нужно будет проинициализоровать стэк CoreData в памяти. Используем для работы с CoreData библиотеку MagicalRecord, не забываем вызывать [MagicalRecord cleanUp] в teardown. В наш сервис инжектируются сетевой клиент и маппер, поэтому передаем в инициализатор их моки.
```
@interface EventServiceTests : XCTestCase
@property (nonatomic, strong) EventService *eventService;
@property (nonatomic, strong) id clientMock;
@property (nonatomic, strong) id mapperMock;
@end
@implementation EventServiceTests
- (void)setUp {
[super setUp];
[MagicalRecord setDefaultModelFromClass:[self class]];
[MagicalRecord setupCoreDataStackWithInMemoryStore];
self.clientMock = OCMProtocolMock(@protocol(Client));
self.mapperMock = OCMProtocolMock(@protocol(Mapper));
self.eventService = [[EventService alloc] initWithClient:self.clientMock
mapper:self.mapperMock];
}
- (void)tearDown {
self.eventService = nil;
self.clientMock = nil;
self.mapperMock = nil;
[MagicalRecord cleanUp];
[super tearDown];
}
```
Добавляем тест для метода obtain — синхронное получение объектов из базы данных:
```
- (void)testObtainEventsForType {
// given
Event *event = [Event MR_createEntity];
event.eventType = EventTypeCinema;
// when
NSArray *events = [self.eventService obtainEventsForType:EventTypeCinema];
// then
XCTAssertEqualObjects(event, [events firstObject]);
}
```
Реализация метода obtain и инициализатора сервиса:
```
- (instancetype)initWithClient:(id)client
mapper:(id)mapper {
self = [super init];
if (self) {
\_client = client;
\_mapper = mapper;
}
return self;
}
- (NSArray \*)obtainEventsForType:(EventType)eventType {
NSPredicate \*predicate = [NSPredicate predicateWithFormat:@"eventType = %d", eventType];
NSArray \*events = [Event MR\_findAllWithPredicate:predicate];
return events;
}
```
Добавляем тест для метода update – запрашивает у сервера события, используя клиент, затем маппит в модель и сохраняет в базу. Стабаем клиент, чтобы он всегда возвращал success блок. Проверяем, что наш сервис обратится к мапперу и вызовет success блок:
```
- (void)testUpdateEventsForTypeSuccessful {
// given
XCTestExpectation *expectation = [self expectationWithDescription:@"Callback"];
OCMStub([self.clientMock requestEventsForType:EventTypeCinema
success:OCMOCK_ANY
failure:OCMOCK_ANY).andDo(^(NSInvocation *invocation) {
SuccessBlock block;
[invocation getArgument:█ atIndex:3];
block();
});
// when
[self.eventService updateEventsForType:EventTypeCinema
success:^{
[expectation fulfill];
} failure:^(NSError *error) {
}];
// then
[self waitForExpectationsWithTimeout:DefaultTestExpectationTimeout handler:nil];
OCMVerify([self.mapperMock mapEvents:OCMOCK_ANY
forType:EventTypeCinema
mappingContext:OCMOCK_ANY]);
}
```
Пишем тест на сценарий ошибки метода update, стабаем клиент так, чтобы он возвращал ошибку:
```
- (void)testUpdateEventsForTypeFailure {
// given
XCTestExpectation *expectation = [self expectationWithDescription:@"Callback"];
NSError *clientError = [NSError errorWithDomain:@""
code:1
userInfo:nil];
OCMStub([self.clientMock requestEventsForType:EventTypeCinema
success:OCMOCK_ANY
failure:OCMOCK_ANY).andDo(^(NSInvocation *invocation) {
ErrorBlock block;
[invocation getArgument:█ atIndex:4];
block(error);
});
// when
[self.eventService updateEventsForType:EventTypeCinema
success:^{
} failure:^(NSError *error) {
XCTAssertEqual(clientError, error)
[expectation fulfill];
}];
// then
[self waitForExpectationsWithTimeout:DefaultTestExpectationTimeout handler:nil];
}
```
Реализация метода update:
```
- (void)updateEventsForType:(EventType)eventType
success:(SuccessBlock)success
failure:(ErrorBlock)failure {
@weakify(self);
[self.client requestEventsForType:eventType
success:^(id responseObject) {
@strongify(self);
NSManagedObjectContext *context = [NSManagedObjectContext MR_rootSavingContext];
NSArray *events = [self.mapper mapEvents:responseObject
forType:eventType
mappingContext:context];
[context MR_saveToPersistentStoreAndWait];
success();
} failure:^(NSError *error) {
failure(error);
}];
}
```
#### **Преимущества и недостатки**
##### Преимущества
* **Продумывание интерфейса до реализации**
Одно из основных преимуществ, TDD вынуждает программиста в первую очередь детально продумать работу новой функциональности, а потом уже написать ее.
* **Меньше отладки**
Высокий процент покрытия кода тестами позволяет нам значительно быстрее находить ошибку, не проводя долгие часы в дебаггере.
* **Уверенность при изменении**
Думаю, что многие сталкивались с ситуацией, когда мы изменили код в одном месте, а сломалось что-то в совсем другом неожиданном месте. Конечно, важно понимать, что это признак плохого дизайна кода. Покрытие тестами дает уверенность при изменении или рефакторинге существующего кода, потому что при появлении аварийной ситуации, тесты сразу ее отловят.
* **Меньше ошибок**
Достигается за счет совокупности других преимуществ TDD, в первую очередь, за счет продумывания реализации заранее и покрытия тестами.
* **Документация тестами**
Тесты являются частью документации проекта, существующей кодовой базы. Часто при приходе нового разработчика на проект проще разобраться с кодом на каком-то конкретном примере, а тест – это и есть простейший пример использования кода. В итоге при полном покрытие кода тестами – мы получаем по сути обширную практическую документацию кода.
* **Модульность**
Необходимость тестировать абсолютно все ветви выполнения кода, все if-ы вынуждает нас писать модульно, ибо мы просто не сможем протестировать всемогущий метод, который делает сразу 10 дел в нескольких потоках. Мы стремимся к тому, что каждый класс, каждый метод делает свою небольшую часть общей работы. (Следуя принципу single responsibility).
* **Полноценные тесты**
Полагаю, что многие писали тесты, но не все писали их по TDD и разница на самом деле ощутима. В случае написания тестов после реализации мы очень вероятно можем не учесть все сценарии выполнения метода, и в итоге получить неполноценные тесты. Мы считаем, что наш метод работает, потому что тест работает, но на самом деле в методе не покрыты тестами все if-ы, а при TDD такое невозможно, потому что if не может появиться в коде без теста.
##### Недостатки
* **Сложность применения (безопасность данных, UI, базы данных)**
Конечно, часто мы сталкиваемся с тем, что некоторые вещи сложно или невозможно протестировать. Иногда бывает, что сложно сходу представить как какой-то модуль будет работать.
* **Больше времени**
Когда начинаешь писать по TDD – время разработки может увеличиться до нескольких раз. Но, буквально через несколько месяцев будет уже сложно писать без него. В перспективе при наличии опыта написания тестов и применения TDD, время на разработку будет уменьшаться. Особенно это будет ощущаться на дистанции, на долгоживущих проектах.
* **Ложное ощущение надежности, ошибка в тесте**
Возможна ситуация, когда мы неправильно поняли изначальные требования. В итоге мы получим ошибку в коде, в тесте и в понимании. И главное, что мы уверены что все работает, потому что тесты горят зеленым цветом. Это достаточно опасная ситуация и она может вылиться в большую временную потерю.
* **Поддержка тестов**
Кодовая база при полном покрытии кода тестами увеличивает практически в два раза. И важно понимать, что весь этот код нужно поддерживать, рефакторить и документировать.
> Разработка через тестирование поощряет простой дизайн и внушает уверенность.
>
> TDD encourages simple designs and inspires confidence.
>
>
>
> Кент Бек
>
>
#### **Литература и ссылки**
[Kent Beck – Test-Driven Development: By example](https://books.google.co.uk/books/about/Test_driven_Development.html?id=gFgnde_vwMAC)
[Robert C. Martin – Clean code](https://books.google.co.uk/books?id=dwSfGQAACAAJ&dq=Robert+C.+Martin+%E2%80%93+Clean+code&hl=en&sa=X&ved=0CDUQ6AEwAWoVChMIlNictofnxgIVpO9yCh3OXQ7M)
[www.objc.io/issue-15](http://www.objc.io/issue-15/)
[en.wikipedia.org/wiki/Test-driven\_development](https://en.wikipedia.org/wiki/Test-driven_development)
[qualitycoding.org/objective-c-tdd](http://qualitycoding.org/objective-c-tdd/)
[agiledata.org/essays/tdd.html#WhatIsTDD](http://agiledata.org/essays/tdd.html#WhatIsTDD)
[www.basilv.com/psd/blog/2009/test-driven-development-benefits-limitations-and-techniques](http://www.basilv.com/psd/blog/2009/test-driven-development-benefits-limitations-and-techniques)
[martinfowler.com/articles/is-tdd-dead](http://martinfowler.com/articles/is-tdd-dead/)
[habrahabr.ru/post/206828](http://habrahabr.ru/post/206828/)
[habrahabr.ru/post/216923](http://habrahabr.ru/post/216923/)
[iosunittesting.com](http://iosunittesting.com/) | https://habr.com/ru/post/263087/ | null | ru | null |
# Улучшаем allOf и anyOf в CompletableFuture
*И снова здравствуйте. В преддверии старта курса [«Разработчик Java»](https://otus.pw/lzgB/) подготовили для вас перевод полезного материала.*
---
В `CompletableFuture` есть два метода, дизайн которых меня удивляет:
* CompletableFuture#allOf
* CompletableFuture#anyOf
В этой статье мы посмотрим, что с ними не так и как их можно сделать более удобными.
#### CompletableFuture#allOf
Давайте посмотрим на сигнатуру метода:
```
public static CompletableFuture allOf(CompletableFuture... cfs) {
// ...
}
```
Здесь есть как минимум два спорных момента:
1. Метод принимает несколько объектов `CompletableFuture`, возвращающих объекты разных типов.
2. Метод возвращает `CompletableFuture`, который возвращает `Void`
Также некоторым может не нравится переменное число параметров, поэтому давайте посмотрим и на эту часть.
``CompletableFuture`` часто используется в качестве сигнала завершения операции, однако, внеся небольшое изменение в API, **этот метод можно использовать как в качестве сигнального устройства, так и в качестве носителя результатов всех завершенных операций**. Давайте попробуем это сделать.
#### Асинхронный CompletableFuture#allOf
Во-первых, давайте придумаем нужную сигнатуру.
Справедливо предположить, что в большинстве случаев потребуется обработка списка однородных `CompletableFuture` и возврат `CompletableFuture`, содержащего список результатов:
```
public static CompletableFuture> allOf(
Collection> futures) {
// ...
}
```
Внутренности оригинального метода, скорее всего, более сложные, чем вы ожидаете:
```
static CompletableFuture andTree(
CompletableFuture[] cfs, int lo, int hi) {
CompletableFuture d = new CompletableFuture();
if (lo > hi) // empty
d.result = NIL;
else {
CompletableFuture a, b;
int mid = (lo + hi) >>> 1;
if ((a = (lo == mid ? cfs[lo] :
andTree(cfs, lo, mid))) == null ||
(b = (lo == hi ? a : (hi == mid+1) ? cfs[hi] :
andTree(cfs, mid+1, hi))) == null)
throw new NullPointerException();
if (!d.biRelay(a, b)) {
BiRelay,? c = new BiRelay<>(d, a, b);
a.bipush(b, c);
c.tryFire(SYNC);
}
}
return d;
}
```
Поэтому, вместо того, чтобы создавать его с нуля, попробуем использовать повторно то, что уже есть в оригинальном методе так, как если бы он был предназначен для использования в качестве сигнализатора завершения… а затем просто поменяем void-результат на список future:
```
CompletableFuture>> i = futures.stream()
.collect(collectingAndThen(
toList(),
l -> CompletableFuture.allOf(l.toArray(new CompletableFuture[0]))
.thenApply(\_\_ -> l)));
```
Пока неплохо. Нам удалось получить
``CompletableFuture``>``>`` вместо ``CompletableFuture``, что уже хорошо. Но нам не нужен список future с результатами, нам нужен список результатов.
Теперь мы можем просто обработать список и удалить из него нежелательные future. Совершенно нормально вызвать методы CompletableFuture#join, потому что мы знаем, что они никогда не будут блокироваться (на этот момент все future уже завершены):
```
CompletableFuture> result = intermediate
.thenApply(list -> list.stream()
.map(CompletableFuture::join)
.collect(toList()));
```
А теперь давайте объединим все это в окончательное решение:
```
public static CompletableFuture> allOf(
Collection> futures) {
return futures.stream()
.collect(collectingAndThen(
toList(),
l -> CompletableFuture.allOf(l.toArray(new CompletableFuture[0]))
.thenApply(\_\_ -> l.stream()
.map(CompletableFuture::join)
.collect(Collectors.toList()))));
}
```
#### Асинхронный и падающий CompletableFuture#allOf
При наличии исключений оригинальный CompletableFuture#allOf ожидает завершения всех оставшихся операций.
И если мы хотим сообщить о завершении операции при возникновении в ней исключения, то нам придется изменить реализацию.
Для этого нужно создать новый экземпляр `CompletableFuture` и завершить его вручную, после того как одна из операций вызовет исключение:
```
CompletableFuture> result = new CompletableFuture<>();
futures.forEach(f -> f
.handle((\_\_, ex) -> ex == null || result.completeExceptionally(ex)));
```
… но тогда нам нужно разобраться со сценарием, когда все future завершатся успешно. Это можно легко сделать, используя улучшенный метод allOf(), а затем просто завершить future вручную:
```
allOf(futures).thenAccept(result::complete);
```
Теперь мы можем объединить все вместе, чтобы сформировать окончательное решение:
```
public static CompletableFuture>
allOfShortcircuiting(Collection> futures) {
CompletableFuture> result = new CompletableFuture<>();
for (CompletableFuture f : futures) {
f.handle((\_\_, ex) -> ex == null || result.completeExceptionally(ex));
}
allOf(futures).thenAccept(result::complete);
return result;
}
```
#### CompletableFuture#anyOf
Начнем также с сигнатуры метода:
```
public static CompletableFuture anyOf(CompletableFuture... cfs) {
// ...
}
```
Мы сразу можем обнаружить такие же проблемы, как с методом, рассмотренным выше:
1. Метод принимает несколько объектов `CompletableFuture`, содержащих объекты разных типов.
2. Метод возвращает `CompletableFuture`, содержащий объект типа `Object`.
Насколько я понимаю, метод `CompletableFuture#allOf` был спроектирован так, чтобы он использовался в качестве сигнального устройства. Но `CompletableFuture#anyOf` не соответствует этой философии, возвращая ``CompletableFuture``, что еще более запутывает.
Посмотрите на следующий пример, где я пытаюсь обработать CompletableFuture, содержащие данные разных типов:
```
CompletableFuture f1 = CompletableFuture.completedFuture(1);
CompletableFuture f2 = CompletableFuture.completedFuture("2");
Integer result = CompletableFuture.anyOf(f1, f2)
.thenApply(r -> {
if (r instanceof Integer) {
return (Integer) r;
} else if (r instanceof String) {
return Integer.valueOf((String) r);
}
throw new IllegalStateException("unexpected object type!");
}).join();
```
Довольно неудобно, не так ли?
К счастью, это довольно легко приспособить для более распространенного сценария (ожидание одного из множества future, содержащих значения одного и того же типа), изменив сигнатуру и введя прямое приведение типов.
Таким образом, с нашими улучшениями, мы можем повторно использовать существующие методы и безопасно привести результат:
```
public static CompletableFuture anyOf(List> cfs) {
return CompletableFuture.anyOf(cfs.toArray(new CompletableFuture[0]))
.thenApply(o -> (T) o);
}
public static CompletableFuture anyOf(CompletableFuture... cfs) {
return CompletableFuture.anyOf(cfs).thenApply(o -> (T) o);
}
```
### Исходный код
Исходный код можно найти на [Github](https://github.com/pivovarit/articles/blob/master/java-completable-future-allof/src/main/java/com/pivovarit/allof/CompletableFutures.java).
На этом все. До встречи на [курсе](https://otus.pw/lzgB/). | https://habr.com/ru/post/481804/ | null | ru | null |
# Техподдержка 3CX отвечает: быстрое бесплатное обновление до последней версии 3CX
Если вы в свое время приобрели лицензию 3CX, но по какой-то причине решили ее не обновлять, сейчас такой устаревшей системой следует пользоваться весьма аккуратно. Дело в том, что для активации лицензии и загрузки обновлений 3CX использует SSL сертификаты, удостоверяющие, в частности, что вы загружаете действительно файлы от разработчика, а не «подставные» файлы, например, он распространителей вируса Petya.
Однако срок действия этих сертификатов как на серверах 3CX, так и в ваших системах, если они не обновлялись, подошел к концу. Проблема усложняется еще и тем, что центр сертификации, который в свое время выдавал сертификаты 3CX, сейчас не может их продлить в связи с техническими разногласиями с Google и другими игроками рынка.
Чтобы решить эту проблему, 3CX предложила абсолютно всем пользователям предыдущих версий 3CX перейти на самую последнюю версию бесплатно. Фактически, вы получили многолетнюю подписку на обновления в подарок! Рассылка предложений велась в течение двух месяцев по e-mail адресам, указанных при активации лицензии. Все, что требовалось сделать, — поэтапно перейти с вашей версией системы до последней через резервное копирование.
Однако все это было актуально до 31 октября 2018 г. Теперь же нужно быть особенно осторожным. Что происходит, если вы все таки не обновились до v15.5 Update 6? Ваша система продолжит работать как раньше, но вы не сможете активировать лицензию, если активация вдруг «слетит». Активация 3CX привязывается, прежде всего, к MAC адресу сетевой карты, но и к другим параметрам сервера. Поэтому в такой ситуации крайне важно не переустанавливать 3CX, и не менять конфигурацию сервера! Ваша 3CX уже не сможет активироваться и перейдет в режим бесплатной редакции (для той версии 3CX, которая у вас установлена). Фактически, ваша телефония «остановится».
Однако мы постарались обезопасить вас от такого развития событий! 3CX выпустила специальную утилиту, которая автоматически обновит 3CX v15 и выше до v15.5 Update 6, установив все недостающие сервисные пакеты. То есть, если у вас установлена v15.0 или v15.5, вы можете обновить систему одним кликом независимо от наличия подписки на обновления.
### Обновление 3CX v15 и выше на Windows
На компьютере, на котором установлена 3CX, скачайте [утилиту](https://downloads-global.3cx.com/downloads/3CXWindowsBatchUpdater.zip), разархивируйте файлы и запустите 3CX WinUpdater.exe с правами администратора.
В зависимости от количества необходимых обновлений, сервисы АТС будут перезапущены несколько раз. Процесс обновления отображается в командной строке Windows. Не закрывайте это окно!
### Обновление 3CX v15 и выше на Linux
Подключитесь к компьютеру с 3CX через SSH и переключитесь на привилегии root (команда sudo su). Введите команды обновления системы:
```
apt-get update
apt-get upgrade
```
Если у вас установлена 3CX старше версии v15.5 SP1, выполните эти команды дважды, поскольку более новые сервисные пакеты расположены в другом репозитории.
### Обновление 3CX v14 и ниже с активной подпиской на обновления
Обновляйте систему, пока не дойдете до v15.5 Update 6. Последний дистрибутив 3CX уже содержит Update 6. Процедура несложная, при этом нет необходимости каждый раз активировать лицензионный ключ при переходе между версиями.
* Сделайте резервную копию текущей системы.
* V11: загрузите [V12](https://downloads.3cx.com/downloads/3CXPhoneSystem12.exe), [V12.5](https://downloads.3cx.com/downloads/3CXPhoneSystem125.exe) и [V14](https://downloads.3cx.com/downloads/3CXPhoneSystem14.exe), и переходите между версиями, используя резервное копирование и восстановление.
* V12: загрузите [V12.5](https://downloads.3cx.com/downloads/3CXPhoneSystem125.exe) и [V14](https://downloads.3cx.com/downloads/3CXPhoneSystem14.exe), и переходите между версиями аналогично.
* V12.5: загрузите [V14](https://downloads.3cx.com/downloads/3CXPhoneSystem14.exe) и переходите между версиями аналогично.
* V14: сделайте резервную копию системы и укажите ее (файл) при установке новой системы V15.5.
* V15: последовательно обновляйте систему из интерфейса управления до текущей версии v15.5 SP6.
### Обновление 3CX v14 и ниже без подписки на обновления
[Свяжитесь](https://www.3cx.ru/company/contact/) с Отделом поддержки пользователей 3CX. Тут вам помогут перейди на 3CX v15.5 Update 6, однако необходимо будет согласовать конкретные сроки перехода.
### Особенности настройки IP-телефонов и VoIP-шлюзов
Обратите внимание, что при обновлении 3CX у вас могут возникнуть сложности в использовании IP-телефонов и VoIP-шлюзов. Для шлюзов установите последние прошивки с сайта производителя. Для телефонов, если обновленная 3CX не предложит обновить подключенные устройства автоматически, загрузите сертифицированные версии [отсюда](https://www.3cx.com/support/phone-firmwares/).
### Загрузки
* [Утилита обновления 3CX для Windows](https://downloads-global.3cx.com/downloads/3CXWindowsBatchUpdater.zip)
* [Дистрибутив 3CX v12](https://downloads.3cx.com/downloads/3CXPhoneSystem12.exe)
* [Дистрибутив 3CX v12.5](https://downloads.3cx.com/downloads/3CXPhoneSystem125.exe)
* [Дистрибутив 3CX v14](https://downloads.3cx.com/downloads/3CXPhoneSystem14.exe)
* [Дистрибутив 3CX v15.5 для Windows](https://downloads-global.3cx.com/downloads/3CXPhoneSystem155.exe)
* [ISO образ 3CX v15.5 для Debian Linux](https://downloads-global.3cx.com/downloads/debian9iso/debian-amd64-netinst-3cx.iso)
* [3CX SBC](http://downloads-global.3cx.com/downloads/3CXSBC15.msi)
* [Прошивки поддерживаемых телефонов](https://www.3cx.com/support/phone-firmwares/) | https://habr.com/ru/post/429292/ | null | ru | null |
# Домашний сервер — ESXi, паранойя
Доброго времени суток, уважаемые хабровчане!
На хабре много статей, про то настройку тех или иных кусочков домашнего сервера. Хотелось бы поделиться еще одним вариантом построения домашней сети, нацеленной на сисадмина или разработчика. На этот раз на базе ESXi.
Кого заинтересовало — добро пожаловать под кат.
Я не буду рассказывать про установку и настройку ESX и гостевых систем, ибо в сети полно статей на эту тему, да и документация на официальном сайте вполне приличная. А расскажу я некоторые идеи, которые я реализовал дома и некоторые тонкости. Но обо всем по порядку.
Начнем с самого сервера — [IBM System X3200 M2](http://www-03.ibm.com/systems/data/flash/systemx/hardware/tower/x3200M2/). Достался он мне практически даром. Узнал от друга, что его друг продает какой-то сервер. Созвонились, встретились, и — вуаля, сервер после небольшого моддинга, занял почетное место старой машинки на базе еще Celeron'a 1.8. Должен отметить правда, что корпус был слегка помят, а именно, не хватало нижней части передней крышки, а внутри не было оперативной памяти вообще. Но это мелочи. Сложнее оказалось достать 2 недостающие салазки в корзину. В городе в прямой продаже нет, в специализированных магазинах под заказ — ждать 1.5 мес и сумма 1.5к за штуку… отказался от этой идеи. Заказал с [Китая](http://www.ebay.com) за 500р с доставкой, пришли за те же 1.5 мес.
###### Итого имеем:
1. Сервер IBM System X3200 M2
* Intel® Xeon® X3320 2.5GHz
* 4Г DDR2 800MHz
* 5 жестких дисков общим объемом около 2TB (без рейда)
* ESXi
2. Ноутбук Asus F3SE (заменяет мне комп — стационарной машины, кроме сервера у меня нет, фактически, это мое рабочее место и средство для развлечений),
3. Точка доступа LinkSys WRT54GS v7 (WAN, 4xLAN 100Mb,WiFi), перепрошитая с [dd-wrt](http://www.dd-wrt.com) micro (эх, сколько мы с ней пережили :) ),
4. Телефон с WiFi — Nokia E52.
##### **Цели конечной системы:**
1. Максимально разгрузить ноутбук по программному обеспечению,
2. Предоставить платформу для разработки и тестов (схема примерно такая: установил, настроил, попробовал, выключил; когда понадобилось — включил заново),
3. Вместе со смотрящими в сеть сервисами, обеспечить корпоративный уровень защиты сервера и данных. В случае дилеммы «функционал/безопасность» выбирать безопасность.
Итак, приступим к самой интересной части. С этого момента будем считать, что сервер подключен к сети, функционирует 24/7, есть безлимитный интернет, установлен ESXi, создано несколько гостевых систем (win2k8 — 1шт, winxp — 1шт, Fedora 14 — N шт в минимальной конфигурации, или любой другой дистрибутив по вкусу и цвету), если где-то что-то запускается (mc, nano, sudo и прочее), то подразумевается, что оно уже установлено.
###### **Шаг 1.** Выбор функционала
Что же нам будет необходимо?
1. Веб сервера (Apache, IIS, GlassFish/Tomcat),
2. СУБД (MSSQL, MySQL, FireBird, PostgreSQL),
3. Torrent-клиент, FlyLinkDC клиент,
4. SSH доступ ко всем linux-серверам, RDP до одного из Win серверов,
5. Файловое хранилище.
###### **Шаг 2.** Архитектура сети
И вот что у нас примерно должно получиться:
Хочу сразу предостеречь уважаемых хабровчан от холивара на тему организации данной сети, она продиктована некоторыми субъективными требованиями, и, пока что, изменяться может только виртуальная ее часть. Простите, но «так исторически сложилось». Однако, конструктивная критика приветствуется. Учту в дальнейшем.
Как видно из диаграммы, из всех виртуальных машин, к физической сети подключена только одна — GALAXY. Этот сервер будет являться шлюзом ко всем виртуальным машинам, будет следить за доступом к важным портам (SSH, RDP) а также вести разнообразные логи.
###### **Шаг 3.** Настройка шлюза
Не мудрствуя лукаво, выложу конфиг фаирвола со своего шлюза, с небольшими изменениями. Само собой, все интерфейсы подняты, настроены статические IP, прописаны DNSы, шлюзы, на точке настроен необходимый NAT. Прошу прощения, но все IP и порты заменены или затерты. В этом плане — я параноик если что. :)
**firewall.sh**
`#!/bin/sh
modprobe ip_nat_ftp
modprobe ip_conntrack_ftp
modprobe nf_conntrack_tftp
ipt='/sbin/iptables'
home='#.#.#.#/24'
vmnet='#.#.#.#/24'
mehome='#.#.#.#'
mevmnet='#.#.#.#'
venera='#.#.#.#'
${ipt} -F -t nat
${ipt} -F -t filter
${ipt} -F -t mangle
#established
${ipt} -t filter -A INPUT -p all -m state --state ESTABLISHED,RELATED -j ACCEPT
${ipt} -t filter -A OUTPUT -p all -m state --state ESTABLISHED,RELATED -j ACCEPT
#allow forwarding
echo "1" > /proc/sys/net/ipv4/ip_forward
${ipt} -t filter -P FORWARD DROP
#log some new connections
${ipt} -A INPUT -m state --state NEW -p tcp --dport 12121 -j LOG --log-level INFO --log-prefix "SSH-NEW : "
${ipt} -A FORWARD -m state --state NEW -d ${venera} -j LOG --log-level INFO --log-prefix "VENERA : "
#localhost
${ipt} -t filter -A INPUT -i lo -j ACCEPT
#icmp home
${ipt} -t filter -A FORWARD -p icmp -s ${home} -j ACCEPT
${ipt} -t filter -A FORWARD -p icmp -d ${home} -j ACCEPT
${ipt} -t filter -A INPUT -p icmp -s ${home} -j ACCEPT
${ipt} -t filter -A OUTPUT -p icmp -d ${home} -j ACCEPT
#icmp vmnet
${ipt} -t filter -A FORWARD -p icmp -s ${vmnet} -j ACCEPT
#dns tcp
${ipt} -t filter -A INPUT -p tcp --sport 53 -j ACCEPT
${ipt} -t filter -A OUTPUT -p tcp --dport 53 -j ACCEPT
${ipt} -t filter -A FORWARD -p tcp --dport 53 -j ACCEPT
${ipt} -t filter -A FORWARD -p tcp --sport 53 -j ACCEPT
#dns udp
${ipt} -t filter -A INPUT -p udp --sport 53 -j ACCEPT
${ipt} -t filter -A OUTPUT -p udp --dport 53 -j ACCEPT
${ipt} -t filter -A FORWARD -p udp --dport 53 -j ACCEPT
${ipt} -t filter -A FORWARD -p udp --sport 53 -j ACCEPT
#ssh
${ipt} -t filter -A INPUT -p tcp --dport 12121 -j ACCEPT
#nat venera (GlassFish[80->8080], SSH[3333->12121])
${ipt} -t nat -A PREROUTING -d ${mehome} -p tcp --dport 3333 -j DNAT --to ${venera}:12121
${ipt} -t nat -A PREROUTING -d ${mehome} -p tcp --dport 80 -j DNAT --to ${venera}:8080
#${ipt} -t filter -A FORWARD -d ${venera} -p tcp --dport 8080 -j ACCEPT
${ipt} -t nat -A POSTROUTING -s ${venera} -j SNAT --to-source ${mehome}
#firwarding for venera
${ipt} -t filter -A FORWARD -s ${venera} -j ACCEPT
${ipt} -t filter -A FORWARD -d ${venera} -p tcp --dport 12121 -j ACCEPT
${ipt} -t filter -A FORWARD -d ${mehome} -p tcp --dport 80 -j ACCEPT
#исходящие временное. оставьте для разрешения доступа этого сервера куда угодно
${ipt} -t filter -A OUTPUT -p all -j ACCEPT
# политика по умолчанию
${ipt} -t filter -A INPUT -p all -j DROP
${ipt} -t filter -A OUTPUT -p all -j DROP`
По аналогии с сервером VENERA, настраиваем остальные сервера, включая и исключая нужные порты правилами. Обращу Ваше внимание, что блоке **nat venera** закомментирована 3я строчка.
Она разрешает соединения к SSH порту 12121. Закомментирована она по описанной ниже причине.
###### **Шаг 4.** Паранойя
Кульминацией сего повествования, является реализация техники [port knocking](http://en.wikipedia.org/wiki/Port_knocking).
Возможно кто-либо из вас сталкивался с этой темой, но по тем или иным причинам отбросил ее реализацию.
~~Кому лень~~ Кто не может сходить по ссылке выше, в двух словах расскажу что это и с чем едят. Эта техника позволяет открывать нужный порт, только после того, как с этого же IP постучались на некую последовательность портов. Причем порты из этой последовательности могут быть даже не открыты. Достаточным признаком, является посылка на этот порт пакета с флагом SYN ( ну или другого, по вашему усмотрению). После того как последовательность верно активирована, выполняется команда, открывающая нужный порт в фаирволе. чтобы закрыть этот порт, нужно, согласно этой же технике, постучаться таким же образом на другую последовательность портов.
Само собой «все уже украдено до нас» (С). Существует демон [knockd](http://www.zeroflux.org/projects/knock) и клиент вместе с ним, реализующий данный функционал.
Все было бы достаточно просто, если бы я не столкнулся со странной проблемой. Бинарника под RPM системы нет (ткните носом, пожалуйста, если я плохо искал).
Качаем исходники, распаковываем.
`./configure
make`
Приехали, из исходников код не компилируется с ошибкой gcc «PATH\_MAX — undeclared»… что же делать? :)
Правильно. Залезть в исходники и посмотреть что же там не так. Благо, помимо служебных файлов, там всего 4 файла: реализация клиента, сервера и реализация собственного списка (.h + .c). После недолгих размышлений вписал между существующими инклудами еще один в файле сервера:
`#include`
и все заработало :)
Кстати, с форумов народ пишет, что под FreeBSD ставят без проблем из портов, но я на своей (да, есть у меня и такая виртуалка для тестов) не пробовал. Отпишитесь, пожалуйста, об объективных результатах с последней версией.
Документация к knockd неплохая. Демон простой, удобный, проверил — работает. Так что, с Вашего разрешения, описывать его не буду, но приведу примерный конфиг для данного случая с фаирволом для полноты картины:
`[options]
logfile = /var/log/knockd.log
[openSSH]
sequence = порт1,порт2,порт3
seq_timeout = 5
command = /sbin/iptables -A FORWARD -s %IP% -p tcp --dport 8080 -j ACCEPT
tcpflags = syn
[closeSSH]
sequence = порт3,порт2,порт1
seq_timeout = 5
command = /sbin/iptables -D FORWARD -s %IP% -p tcp --dport 8080 -j ACCEPT
tcpflags = syn`
Дома использую несколько последовательностей для открытия разных портов к разным виртуальным машинам. К сожалению, порты выбрал только TCP, ибо с ними можно соединяться простым telnet'ом. Но как только разберусь с мобильным клиентом knockd для UDP, обязательно все сделаю как нужно.
На остальных виртуальных машинах заводим необходимые службы, настраиваем все как нам нравится. Не забываем пробросить через виртуальный шлюз нужные порты, и прописать нечто в /etc/knockd.conf, если необходимо. Пользуемся.
Выводы
-------
Этот сервер у меня уже с конца января 2011 года. Чего я на нем только не перепробовал делать/пробовать. И разные сервисы, и Gentoo, и FBSD, и GlassFish, и фаирволы/нат, FireFox на виндовой машине через SSH + XMing и т.п. И все это в одной машине. Теперь я с уверенностью могу заявить, что виртуализация — это круто. К сожалению пока еще не удалось попробовать KVM и XEN (лайв сиди с XEN не в счет — нужно ручками пощупать), но запускать на виртуальной машине еще один гипервизор… даже для моего извращенного мозга, это слишком. Видимо просто не пришло его время.
Скоро придет из [другого Китая](http://www.dealextreme.com/) USB звуковуха, и у меня появится навороченный будильник с управляемым производственным календарем из 1Ски. ^\_^
В общем и целом, у кого есть возможность поставить сие чудо на выделенную машину — дерзайте. Возможно кому-то этот топик поможет настроить сервер на работе. Так или иначе, буду рад, что помог.
Спасибо за внимание.
P.S. Я не претендую на 100% защищенность данной схемы, но она куда лучше открытых портов, успокаивает мою параною и дает неоценимый опыт длительного использования. Само собой, стандарные порты на конечных серверах изменены, где это возможно. Не хватает блока по IP адресам злостных брутфорсеров, но это еще все впереди.
**UPD:** Прошу прощения, если не верно выбрал блог. Ткните, пожалуйста, носом куда лучше его поместить? | https://habr.com/ru/post/118316/ | null | ru | null |
# Автоматы на службе распределенных транзакций
В этой заметке я расскажу о доменах, построенных на основе конечных автоматов, и распределенных транзакциях, реализованных при помощи таких доменов.
Такой подход я активно использую при разработке сервисов со сложным многоступенчатым поведением, где до сих пор он показал себя довольно неплохо (хотя и не без проблем).
> Дисклеймер: данная статья не пытается открыть Америку или сделать прорыв в науке. Это просто набор архитектурных решений, которые я считаю удачными, и которыми я хочу поделиться с сообществом. За подробностями приглашаю под кат, а также буду рад обсудить в комментариях.
>
>
>
> UPD: речь не идет про распределенные транзакции БД (вроде X/Open XA), здесь про уровень логики, нежели уровень хранения.
Предыстория
-----------
Микросервисная архитектура уже стала де-факто стандартом построения серверных приложений. Этот подход дает нам много хорошего — разделение ответственностей, уменьшение связанности, большая независимость при выборе инструментов и работу в маленьких командах. Однако многие вещи, которые раньше были очень просты, часто настолько, что о них не задумывались, теперь стали болью в заднице архитектора.
Одна из таких вещей — транзакции. Раньше достаточно было просто выполнять целый запрос в рамках одной транзакции БД, чтобы получить гарантии ACID относительно выполняемых операций. БД решали и проблемы конкурентного доступа, и отказоустойчивой записи, и, что главное — атомарности изменений. С переходом к распределенной системе все это стало большой проблемой. Настолько большой, что пришлось создавать подходы, фреймворки и даже специальные БД для ее решения.
Простые транзакции, затрагивающие пару сервисов в рамках одного процесса, можно реализовать с использованием 2-phase commit ([2PC](https://en.wikipedia.org/wiki/Two-phase_commit_protocol)). Это в целом подходит, если у вас есть какой-то локальный процесс и какой-то внешний сервис, где нужно сделать изменения в начале локальной обработки, а в конце либо подтвердить, либо откатить.
### 2-Phase Commit
Пример — выделение IP адреса IPAM сервисом:
1. запрос на IPAM сервис на выделение IP адреса (1 фаза)
2. IPAM сервис резервирует адрес и возвращает его
3. какая-то внутренняя логика, использующая выделенный IP
4. запрос на IPAM сервис с подтверждением (2 фаза, commit)
5. IPAM снимает резерв и сохраняет IP как выделенный.
При этом если произойдет ошибка, резерв можно отменить через запрос отмены (rollback), либо он сам отменится по таймауту.
Такой подход хорош для простых действий, однако, когда нужно выполнить операцию, затрагивающую сразу много сервисов, этого оказывается недостаточно. К счастью, придуманы и другие подходы, позволяющие это реализовать.
### Saga
Один из наиболее популярных подходов — паттерн [Saga](https://microservices.io/patterns/data/saga.html). Подход очень простой в теории, но достаточно сложный на практике. Во-первых, существуют разные подходы к реализации самой саги (оркестрация, хореография), месте ее реализации (сервис, инициирующий процесс, сервисы участвующие в процессе, отдельный сервис-оркестратор), и у сообщества нет однозначного ответа, когда и как лучше делать, а каких вариантов избегать. Во-вторых, простая идея реализации последовательности выполняемых шагов на разных сервисах значительно усложняется, если брать в расчет такие факторы, как отказоустойчивость выполнения, идемпотентность, сетевые задержки, отказы сервисов и брокеров сообщений, возможные потери данных, различные технологии реализации разных сервисов, различные протоколы коммуникации, синхронные и асинхронные API и прочее. На деле это получается довольно сложный инфраструктурный слой, который, помимо прочего, обычно нужно реализовывать вручную, в то время, когда ACID транзакции уже реализованы силами БД.
В этой статье я расскажу про другой подход к распределенным транзакциям, к которому мы пришли в процессе работы над комплексными распределенными процессами.
Путь к автоматизации
--------------------
Изначально я не планировал никаких распределенных транзакций. Передо мной стояла задача реализовать конвейерный процесс, где несколько древовидных сущностей создаются или изменяются, и при этом каждое изменение состоит из последовательности шагов. Каждый шаг подразумевает один или несколько вызовов отдельных сервисов.
Также важным требованием была отказоустойчивость процессов. Нельзя было просто прогнать все шаги подряд, а в случае ошибки вернуть ответ об ошибке клиенту. Логика заключалась в создании хитросочененного кластера виртуальных машин с большим количеством нетворкинга, и в случае ошибки нельзя просто бросить все как есть.
Первым вариантом реализации был обычный [конечный автомат](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D0%B5%D1%87%D0%BD%D1%8B%D0%B9_%D0%B0%D0%B2%D1%82%D0%BE%D0%BC%D0%B0%D1%82) (FSM) состоящий из последовательности шагов конвейерного процесса. А-ля "создание сети, создание балансировщика, создание ВМ" и т.п. Запросы были разделены на синхронные queries (Read operations) и асинхронные commands (CUD operations) — в парадигме CQRS. Каждому состоянию автомата соответствовали одна или несколько операций перехода в другое состояние, при которых и совершались асинхронные запросы. Ответ на такой запрос триггерил новый переход и т.д.
В целом идея была хорошей, но вот реализация никуда не годилась. Реальный процесс довольно сильно отличался от шагов конвейера, описанных автоматом, поэтому требовалось много дополнительных проверок внутри состояния, а сам код получился запутанным, трудно читаемым и абсолютно не покрываемым тестами.
Через какое-то время было решено переписать эту логику, и сделать наконец "нормально". Это совпало по времени с рефакторингом сервиса в DDD парадигму. В тот момент и родилась идея об автоматизированных доменах, или если проще — доменных автоматах.
Доменный автомат
----------------
Термин "автоматизированный домен" я взял у [Анатолия Шалыто](https://www.piter.com/product/avtomatnoe-programmirovanie-2-e-izd) по аналогии с его автоматизированными классами. Простыми словами это домен в рамках Domain-driven development (DDD), в основе поведения которого лежит конечный автомат.
Самая большая проблема сервиса была в том, что процесс создания не ложился на конвейерную модель, состоящую из последовательности шагов. Дело в том, что сущности, которые нужно было создавать, были не линейными, а древовидными, и у каждого узла был свой процесс создания.
Выглядело это примерно так — корневая сущность проходит какие-то шаги (допустим, кластер ВМ), затем триггерится создание дочерних узлов (группы ВМ, объединенные общими характеристиками), они также проходят какие-то шаги, а затем триггерится создание уже их дочерних узлов (самих физических ВМ), и так далее. Практика показала, что этот процесс очень плохо ложится на конвейер, описанный как последовательность шагов. Как только дочерние сущности начинают создаваться параллельно, конвейер "расслаивается" на набор параллельных шагов, которые сложно описать каким-то статусом. Отсюда и появляются кучи проверок вида "если статус такой, и статусы всех дочерних сущностей такой, и еще такое-то условие, то выполнить действие A".
Это работало довольно плохо, а для некоторых случаев вообще не работало (как, например, обработка ошибки при создании дочернего узла, который требовал инициировать другую последовательность шагов, например, для удаления сломавшейся сущности).
### DDD и FSM
На замену пришел следующий подход: домен (а точнее, доменный агрегат в терминах DDD) представляет собой древовидную структуру из набора доменных моделей. Для простоты возьмем пример с кластером ВМ, где есть корневой домен "кластер", дочерняя нода "группа ВМ", и ее дочерняя нода "ВМ"
*Пример кластера с двумя группами ВМ и тремя ВМ.*
При этом каждая модель имеет собственную систему состояний и переходов между ними (конечный автомат). Этот автомат включает **только** состояния этого узла, но не его родителей, детей или братьев. При этом изменение состояния домена могут триггерить как какие-то действия, так и изменение состояний детей или родителей.
*Пример диаграммы состояний ВМ с переходами.*
Например, при создании виртуальной машины она в какой-то момент переходит в статус `READY`. Этот переход триггерит событие VM\_READY у родительской сущности — группы ВМ. В этот момент она находится в статусе `VM_CREATION_PENDING` или вроде того. При событии VM\_READY выполняется проверка — а все ли дочерние VM имеют статус `READY` (помните, что запросы асинхронные, поэтому каждая ВМ проходит свою цепочку статусов параллельно остальным). Когда все дочерние ВМ готовы, сущность "группа ВМ" также меняет статус на `READY`, и в свою очередь триггерит событие VM\_GROUP\_READY у родительской сущности — кластера ВМ. Тот проверяет, все ли группы ВМ готовы, ну и так далее. Когда они готовы, кластер также меняет свой статус и запускает следующий шаг обработки. Все изменения статусов обязательно фиксируются в БД.
В итоге получили следующее: доменный агрегат состоит из набора (обычно древовидного) доменных моделей, поведение каждой модели описывает конечный автомат состояний и переходов между ними. При этом изменение состояния каждой доменной сущности может триггерить события как вниз, так и вверх по дереву. Таким образом по ходу какого-то сложного процесса родительская нода может запустить процесс на дочерних нодах и ожидать его исполнения (или говоря языком реализации — быть в статусе `*_PENDING`). Также она может затриггерить событие для своей родительской ноды, например, если когда та чего-то ожидает, или наоборот, сообщить ей о старте процесса изменения, чтобы она перешла в режим ожидания.
Все это позволяет составным частям доменного агрегата жить своей жизнью — самим управлять своими процессами, отправлять соответствующие запросы, дергать соответствующие сервисы — и при этом оставаться связанными с общей моделью домена. Это очень удобно на практике, потому что логика состояний, проверок и действий при переходах между состояниями остаются инкапсулированными в одном домене, и не интерферируют друг с другом. Разработчик может сконцентрироваться на одной доменной сущности как при дизайне схемы состояний, так при ее практической реализации. Каждая сущность может выполнять свои операции (например, пользователь может захотеть выключить ВМ, для этого обработка будет реализована именно в домене ВМ), а для синхронизации с остальным доменным агрегатом достаточно "уведомить" своих родителей или детей посредством соответствующего события.
### Реализация автомата
Кроме того, сам автомат очень просто реализуется в любом языке программирования. Есть два основных подхода — статическая реализация через switch и динамическая через таблицу состояний и переходов. Я предпочитаю первый вариант, так как код становится значительно более читаемым, а логика более понятной и очевидной. Плюс, если вы используете компилируемый язык, это дает дополнительные проверки при компиляции.
Мы используем Go, где автомат выглядит примерно так:
```
// State тип может быть любой, но удобно использовать строки, которые сохраняются в БД,
// чтобы было проще ориентироваться в состояниях доменов.
// Можно использовать и int или любой другой тип,
// который подойдет для описания состояния.
type State string
const (
Init State = "INIT"
CreationPending State = "CREATION_PENDING"
StartPending State = "START_PENDING"
SetupPending State = "SETUP_PENDING"
Ready State = "READY"
ShutdownPending State = "SHUTDOWN_PENDING"
DeletionPending State = "DELETION_PENDING"
Deleted State = "DELETED"
)
// Event эти значения обычно нигде не хранятся,
// поэтому можно использовать просто enum или его аналог (в Go это const + iota)
type Event int
const (
Initialized Event = iota + 1
Created
Started
SetUp
DeletedManually
ShutDown
Removed
ErrorOccured
)
// VM is a Virtual Machine domain model
type VM struct {
s State
}
func (vm *VM) handleEvent(e Event) error {
switch vm.s {
case Init:
switch e {
case Initialized:
err := createVM()
if err != nil {
return err
}
vm.s = CreationPending
}
case CreationPending:
switch e {
case Created:
err := startVM()
if err != nil {
return err
}
vm.s = StartPending
case ErrorOccured:
err := deleteVM()
if err != nil {
return err
}
vm.s = DeletionPending
}
case StartPending:
//...
}
return nil
}
```
"А при чем здесь распределенные транзакции?" — спросит внимательный читатель. Чтож, когда идея подхода понятна, пришло время поговорить и о них.
Распределенные транзакции с использованием доменных автоматов
-------------------------------------------------------------
Если внимательно посмотреть на паттерн Saga, будет видно, что в его основе тоже лежит конечный автомат. Обычно этот автомат реализован либо в одном месте (в случае оркеструемой саги), либо разбросан по системе (в случае хореографической саги). Однако в любом случае это последовательность действий, выполняемых набором синхронных или асинхронных вызовов (или событий), которая определяется набором статусов. Эти статусы описывают состояние саги в момент времени. Это не обязательно именно явные статусы у каждой сущности, но это в любом случае какое-то "состояние", в котором находится сага, и это состояние хранится персистентно (в хранилище данных) в виде одной или нескольких сущностей.
Внимательный читатель заметит, что концепция доменных автоматов тоже основана на конечных автоматах и на персистентном хранении состояния. В чем же разница?
Разница, действительно, на первый взгляд нечеткая. Но она есть, причем, довольно значительная. И чтобы понять ее, нужно взглянуть на процесс изменений, которым и управляет тот или иной подход.
### Ориентация на процесс и ориентация на данные (домены)
Любые действия, происходящие в системе (в нашем случае распределенной), объединяют два направления — процесс изменений и изменяемые данные (а на более глобальном уровне кросс-доменный процесс и изменяемые домены). Так, одна транзакция БД объединяет логический набор операций, выполняемых над данными (исторически это была одна банковская транзакция, отсюда и название), и сами модели, данные которых претерпели изменения.
Графически это можно изобразить так:
Здесь по одной оси идет процесс (**P**), который можно описать как "нужно создать кластер, затем создать внутри него сеть, затем для каждой группы ВМ создать балансировщик нагрузки, а затем запустить все ВМ из образов".
По другой оси идут изменения в данных (**D**), например "сущность кластер меняет получает параметры созданной сети и меняет статус, затем ждет готовности групп ВМ и меняет статус. Группа ВМ получает параметры созданного балансировщика нагрузки и меняет статус, затем ждет готовности ВМ и меняет статус. ВМ получает параметры созданной на сервере ВМ и меняет статус. Затем она ожидает запуска созданной ВМ и меняет статус".
Это довольно грубое упрощение, но суть должно показывать. Теперь давайте разберемся с подходами.
#### Saga — транзакция, ориентированная на процесс
Или process-oriented transaction. Она описывает, в первую очередь, какой процесс происходит, из каких шагов он состоит, в какой последовательности они выполняются на каких сервисах. При этом, если одни и те же сущности участвуют в разных процессах, это будут отдельные и никак не связанные "описания". Например, две саги, объединяющие два различных бизнес-процесса, могут иметь одни и те же шаги по работе с одним сервисом, при этом сам сервис не будет в курсе, что от его работы зависят какие-то определенные процессы.
Это хорошо с точки зрения разделения ответственностей, но часто приводят к проблеме "распределенного незнания" — когда не понятно, как именно выполняется данный процесс, или в какие процессы вплетен существующий API сервиса.
Саги хорошо справляются с задачей описания шагов процесса языком, близким к доменному, но при этом теряют обратную связь: взяв за начальную точку конкретный сервис, тяжело отследить, где и как он используется (с целью внесения обратно несовместимых изменений, например).
Именно эту проблему (а еще несколько других) решает подход доменных автоматов.
#### Доменные автоматы — транзакция, ориентированная на домен
Или domain-oriented transaction. В отличие от Saga, в рамках этого подхода последовательность действий зависит от текущего состояния домена (данных, доменного агрегата — you name it), и описывается именно им.
Ключевое различие состоит в том, что в случае Saga описание шагов бизнес-процесса локализовано, но при этом упускается обратная связь с изменяемыми доменами (или просто данными) — нельзя легко проследить, что приводит к конкретным действиям над доменом без наличия дополнительной документации (а где есть дополнительная документация вне кода, там есть устаревшая документация).
Доменные автоматы, наоборот, локализуют описание изменений домена в рамках самого домена, при этом процесс, в рамках которого происходят изменения, вторичен.
Такой подход очень хорошо ложится на DDD, потому что можно переложить информацию, полученную от бизнеса, на соответствующий домен, и реальные состояния и переходы будут соответствовать состояниям и переходам в FSM соответствующего домена. Более того, все процессы, описываемые этими автоматами, будут локализованными в рамках связанного контекта (Bounded Context) данного домена или группы доменов.
Но даже если вы не используете DDD, этот подход поможет сосредоточить знания об изменениях над данными вместе с этими данными. Таким образом, вы больше не привязаны к описаниям шагов бизнес-процессов — ваш сервис содержит понимание о том, в каких состояниях могут находится его данные, и что делать, если в каждом из этих состояний с данными происходят какие-то события.
Идеологически это чем-то похоже на хореографическую сагу, потому что у вас больше нет единой точки управления процессом — вы запускаете процесс в одном сервисе, а дальше он сам делает все нужное, пока не дойдет до какого-то конечного состояния. Это не обязательно должно быть изначально ожидаемое состояние — в случае ошибки где-то посередине процесса вам больше не нужно контролировать запуск компенсирующих транзакций — конечный автомат описывает, что делать, если ошибка приключится на каждом из состояний каждой из задействованных сущностей.
Помните, что мы создаем ВМ параллельно? Это многоступенчатый процесс, который состоит из нескольких последовательных шагов. Случай, когда при создании одной из них произошла ошибка, довольно сложно описать в рамках Saga. Что делать? Откатывать все изменения? Делать retry? Как определить конкретное состояние кластера? Он сфейлился или нет? Конечно, всю эту логику многослойных проверок можно реализовать, но читать и поддерживать такой код будет очень болезненно.
На основе доменных автоматов это решается очень просто. Конкретная доменная модель отвечает за конкретную сущность и все процессы, связанные с ней. В случае с ошибкой при создании ВМ, обработка довольно проста:
1. домен ВМ проверяет, в каком состоянии он находится сейчас, и в зависимости от этого переходит в другое состояние, сопровождающееся новыми вызовами. Например, если ВМ в статусе ожидания старта ВМ (`VM_START_PENDING`), то при ошибке нужно сначала удалить созданную ВМ, чтобы освободить ресурсы. ВМ переходит в статус `VM_DELETION_PENDING` и отправляет гипервизору запрос на удаление инстанции. Если же ошибка произошла на шаг раньше, когда статус был "ожидание создания ВМ" (`VM_CREATION_PENDING`), то удалять ничего не нужно (ничего не создано), и вместо перехода в статус `VM_START_PENDING` можно сразу переходить в статус `DELETED`.
2. домен ВМ уведомляет родительскую сущность о том, что создание ВМ не удалось, и делегирует ей принятие дальнейших решений. В свою очередь родитель в виде домена "группа ВМ" решает, что делать — попробовать создать новую ВМ (например, на другом физическом сервере), или остановить и удалить остальные ВМ, и сообщить об ошибке "выше" — родительскому домену "кластер ВМ".
В этом случае доменный агрегат сам в состоянии справиться с любой ошибкой, т.к. у него есть вся необходимая для этого логика, а также в рамках домена (как в программе, так и в реальном мире) есть нужные знания для того, чтобы принимать решения (например, что делать в случае ошибки при создании ВМ).
Плюсы
-----
Я буду сравнивать этот подход в основном с паттерном Saga, так как оба применимы для сходных задач.
### Разделение ответственностей
Одно из преимуществ состоит в том, что ответственность за логику изменения состояния и сопряженных с этим действий ложится непосредственно на тот домен/класс/сущность, к которому(ой) эта логика и относится. Домен инкапсулирует не только сами действия при разных запросах и событиях, но и контроль за соблюдением правильной последовательности действий и их консистентности.
В отличие от Saga, где процесс описывается с точки зрения последовательности действий, без углубления в особенности реализации на каждом шаге (что в перспективе приводит к появлению "костылей"), доменный автомат учитывает все особенности доменного агрегата, включая "особое" поведение и всякие трюки и хаки, которые могут потребоваться для оптимизации или для сокращения сроков разработки (я этого не говорил).
### Гранулярность моделей
Так как модель домена может быть сложной, наивно пытаться впихнуть все в один автомат. Нормальным вариантом будет реализовать отдельный автомат для каждой сущности в рамках домена (узла в дереве модели), а также в рамках нескольких доменов, которые реализует ваше приложение.
В этом случае возникает вопрос — как разные автоматы должны общаться между собой?
Я реализую это следующим образом. Любое действие над автоматизированным доменом происходит через событие. Происходит такая проверка: состояние -> событие -> условия. Например, при получении события `VM_GROUP_READY` домен "кластер ВМ" проверяет сначала свое состояние, затем для каждого состояния выполняется обработка события, а для конкретного события выполняется проверка условий, при которых можно осуществить переход к следующему статусу. Так, если "кластер ВМ" находится в состоянии `VM_GROUP_CREATION_PENDING`, то для события `VM_GROUP_READY` он выполнит проверку, все ли группы ВМ находятся в статусе `READY`, и если да — выполнит переход к собственному статусу `READY` с выполнением сопутствующих действий (например, отправит на фронтенд сообщение о готовности кластера).
[увеличенная картинка](https://habrastorage.org/webt/lq/cz/eb/lqczeb8xe_mhawu8-xql1gboq78.png)
### Инкапсуляция сложности
Доменные автоматы позволяют убрать сложную доменную логику вовнутрь, предоставив клиенту (будь то API сервиса или другой домен в этом же сервисе) упрощенный интерфейс, в котором нет лишних деталей. Например, для примера с кластером это будет интерфейс с методами
* создать кластер
* удалить кластер
* добавить ВМ
* удалить ВМ
* изменить параметры группы ВМ
Эти методы могут вызывать другие доменные автоматы, или та же Saga (если она у вас уже используется), либо напрямую клиент.
### Хорошо подходит для DDD
Реализация описанного подхода хорошо ложится на архитектурные подходы в рамках DDD. В моем случае я добавляю поле State в каждую доменную модель, а сервис домена реализует логику событий, состояний и переходов конкретного домена. Сервис доменного агрегата либо доменный сервис сложного домена (например, древовидная структура с дочерними сущностями) реализует общение между разными сущностями в рамках домена (отношения родитель-потомок с соответствующим обменом событиями или прямыми вызовами методов). Сервис слоя приложения оборачивает автоматизированные домены в общую для приложения бизнес-логику, проверки, а также представляет некий упрощённый фасад над ними. Также на этом уровне реализуется взаимодействие между разными доменными агрегатами, если их в сервисе больше одного.
### Читаемый и простой код
С этим пунктом можно поспорить — получающийся в итоге код все равно довольно сложный. Так, сам метод, содержащий FSM (при условии, что логика переходов вынесена в отдельные методы) может запросто занимать под 300 строк для автомата из дюжины состояний (по крайней мере в Go).
Однако, если сравнивать с тем же паттерном Saga, то получаемый код действительно намного лучше читается, а главное — он значительно лучше структурирован — вся доменная логика сосредоточена в домене, описание состояний и переходов лежит в одном месте, логика проверок при переходах — рядом, логика действий при выполнении проверок — тоже рядом. Конечно, хорошая документация никогда не помешает, и мне на помощь приходит Godoc и диаграммы состояний в Readme (благо, Gitlab умеет рендерить mermaid диаграммы из коробки).
К сожалению, если процесс действительно очень сложный, то и соответствующая диаграмма состояний, и реализующий ее код будут очень большими и уже не так легко читаемыми — но это все еще лучший вариант из того, что я знаю. Сложные программы писать и читать сложно.
Минусы
------
Как и у любой архитектурной идеи, у данного подхода есть как плюсы, так и минусы, а также довольно жестко ограниченная область применения.
### Подходит не для всего
Описание состояний домена через конечный автомат — довольно комплексная и многословная вещь. Далеко не для каждой задачи это нужно. Если ваш сервис реализует простые CRUD операции, пихать туда автомат будет неоправданным переусложнением.
### Подходит не для всех
Конечные автоматы — тема, которую проходят в рамках классического CS образования, однако на практике это встречается довольно редко. Вероятно, вам придется объяснять своим коллегам, что такое FSM и зачем они нужны.
### Со временем автомат может сильно разрастаться
Представьте себе сущность, у которой есть 8 состояний — от момента создания до окончательного удаления, и что-то еще при изменении. На каждое состояние прибавьте по два-три события, обработка которых предусмотрена приложением. Туда еще часто добавляются какие-то проверки/валидации, особенно если у сущности есть дочерние сущности со своими автоматами. Ну и вызов логики, которая отрабатывает при переходе в другое состояние не забудьте добавить.
Итого, получается худо-бедно `8*3*3=72` строки + обработка ошибок, итого за сотню. Если это ЯП с невыразительным синтаксисом (как Go), то смело накидывайте еще столько же. При увеличении количества состояний длина метода с автоматом растет квазиквадратично. А так как сам автомат представляет собой большой `switch` оператор, в какой-то момент вы можете оказаться с методом в 500 строк, из которого исполняется 10.
Можно пойти другим путем, и не писать `switch` на все состояния домена в одном методе, а разбить это таким образом, что каждому событию будет соответствовать отдельный метод, а внутри будет `switch` только с теми состояниями, которые умеют это событие обрабатывать. Мне больше нравится первый подход, потому что весь FSM описан в одном месте, но второй тоже неплох и лучше в плане читаемости.
### Низкая связанность в рамках глобального процесса
Низкая связанность сервисов хороша для разработки и поддержки, но усложняет восприятие всего приложения и кросс-сервисных процессов в нем. Так как, в отличие от саг, доменные автоматы локализованы внутри одного домена или доменного агрегата, для разработчика может быть затруднительным оценить весь процесс целиком, найти где он начинается и заканчивается.
Эта проблема — следствие того, что доменный автомат является domain-oriented транзакцией, в отличие от саги. Поэтому информацию о роли домена в глобальном бизнес-процессе приходится добавлять дополнительно (в виде текстовой документации или диаграмм). Ниже я расскажу, как я решаю эту проблему.
Как реализовать распределенную транзакцию, используя доменные автоматы
----------------------------------------------------------------------
Итак, мы обсудили, что же такое доменный автомат, и чем он отличается, а чем схож с паттерном Saga. Пора разобраться, как же реализовать большую и сложную распределенную транзакцию, используя этот подход.
Как вы помните, автоматы помогают сделать домен самостоятельным элементом, который умеет контролировать свое создание, удаление и различные операции. При этом он знает, какие запросы нужно отправить при каждом переходе от одного статуса к другому.
*Доменный агрегат, представляющий собой дерево из простых доменов. Либо просто древовидный домен. Каждый домен содержит автомат, каждая сущность домена характеризуется состоянием.*
Таким образом, распределенная транзакция, реализованная на основе доменных автоматов, совмещает в себе черты оркеструемой и хореографической саги, и вот как это получается.
### Оркестрация
Как и в случае с оркеструемой сагой, автоматизированный домен знает, что конкретно нужно сделать, чтобы осуществить переход от состояния А к состоянию Б. Например, это может быть создание сущности С, за которую отвечает другой сервис. В этом случае домен будет контролировать создание сущности С, то есть выступать для нее оркестратором. Также домен знает, что нужно предпринять в случае ошибки в процессе создания С — будь то какие-то еще действия, или просто переход в другое состояние.
### Хореография
Несмотря на то, что домен знает, что делать при переходе между состояниями, он абсолютно ничего не знает о том, откуда в него прилетают события (или команды), инициирующие эти переходы. И этим он похож на хореографическую сагу — каждый домен выполняет какую-то свою часть процесса, не подозревая, откуда и как он был вызван, централизованный узел при этом не требуется.
### Комбинация
В итоге получается, что доменный автомат работает в одну сторону (исходящих вызовов) как оркестрируемая транзакция и в другую (входящих вызовов) — как хореографическая. Таким образом распределенная транзакция состоит из цепочки или дерева доменных автоматов, где конкретный домен является оркестратором для своих дочерних доменов в ходе транзакции, и одновременно является участником хореографии для всех родительских автоматов кроме прямого родителя (тот явно управляет действиями домена, являясь его оркестратором).
На картинке изображен пример простой транзакции, состоящий из трех доменов (доменных агрегатов), где домен A напрямую управляет процессом на домене B (оркеструет его), а домен B управляет доменом C. При этом домен А не имеет прямого управления над доменом C, таким образом с точки зрения домена A процесс, происходящий в домене C является хореографическим. Это звучит несколько заумно, но если упростить, то получится так: **конкретный домен управляет только ближайшими к нему доменами по ходу транзакции**.
*Здесь цепочка вызова транзакции направлена слева-направо (домен A вызывается в начале транзакции, затем он инициитует измененя в домене B, а тот, в свою очередь, вызывает домен C.*
На практике же это значит, что первый в цепочке (дереве) домен управляет началом и окончанием процесса, а также его ключевыми этапами. Так, в транзакции, описывающий создание заказа на доставку еды из ресторана, первый домен будет инициировать создание заказа в других сервисах по цепочке, а также контролировать завершение процесса создания заказа и обработку возможных ошибок.
При этом сервис может управлять конкретной последовательностью вызова других сервисов (древовидная транзакция), а может делегировать ее управление следующим доменам (цепная транзакция).
#### Древовидная транзакция
В первом случае основная логика будет сосредоточена именно в первом сервисе, и каждый домен в дереве вызова будет содержать тем меньший кусок логики, чем дальше он от корня.
#### Цепная транзакция
Во втором случае логика распределяется более равномерно. При этом каждый последующий домен осуществляет контроль за последующим процессом, то есть роль оркестратора передается по цепочке слева направо.
### Документация
Как бы то ни было, задача описания всей транзакции в одном месте невыполнима при помощи доменных автоматов — как бы то ни было, каждый домен будет держать собственную логику при себе.
В этом случае не остается другого выбора, кроме как обложить процесс документацией, выходящей за рамки одного сервиса.
Я, как разработчик, с сомнением отношусь к технической документации, которая живет где-то отдельно от кода. По личному опыту такая документация почти всегда устаревает и почти никогда не обновляется. Поэтому я веду документацию проектов рядом с кодом — в Readme (который может быть не только в корне репо, но и в каждом домене, например).
Если говорить про описание распределенных транзакций, самое место для такого описания — в сервисе, который транзакцию инициирует и (в рамках подхода) заканчивает.
При этом не обязательно это должен быть какой-то один сервис для всех транзакций — нормальный случай, когда в одном процессе сервис А начинает транзакцию, которая проходится по доменам сервисов B и C, а в другом случае сервис B запускает другую транзакцию, которая передает управление сервисам A и D, и так далее.
Для меня лучше всего работает формат краткого описания, снабженного подробными диаграммами, но для вас может работать что-то другое. В описании транзакции обычно не имеет смысл сильно углубляться в реализацию, так как она принадлежит доменам и может со временем меняться независимо от сервиса, где документация ведется. Вместо этого будет достаточно описать базовые шаги и сервисы, на которых они выполняются, также возможные логические ветвления процесса.
Обобщение
---------
*спасибо [amarao](https://habr.com/ru/users/amarao/) за совет*
Как это решило мою проблему: мой процесс состоит из запуска довольно сложного кластера, который работает поверх вендорской VM платформы. В основе процесса лежит несколько доменных агрегатов, каждый из которых состоит из дерева доменных моделей (какие-то побольше, другие поменьше). Основной сервис оркестрирует процесс, инициируя запросы к другим сервисам через асинхронные запросы. Еще полдюжины сервисов обрабатывают эти запросы, инициируя собственные процессы и продолжая цепочку.
В случае инфраструктурных проблем (сеть упала, под перезапустился, бд прилегла) выполняются ретраи для синхронных запросов / повторное чтение из кафки для асинхронных.
В случае логических проблем автоматы позволяют для каждой доменной модели и каждого его состояния обработать ошибку соответствующим образом. Например, если ВМ упала на моменте создания (например, на физическом сервере закончилось место), достаточно перейти к состоянию `DELETED` и передать событие об ошибке родительской сущности. А если ВМ упала в процессе конфига посте старта ОС, то при ошибке нужно сначала выключить ОС, а затем удалить ВМ, только после этого перевести в состояние `DELETED`:
Таким образом, каждая из сущностей сама умеет выполнять компенсирующие действия. Не требуется какой-то "транзакции", которая будет это контролировать — поведение системы привязано к ее актуальному состоянию, поэтому исключены проблемы с изоляцией.
Заключение
----------
Данный подход не претендует на какой-то прорыв в теме распределенных транзакций, либо на пример архитектурного стандарта. Я также допускаю, что все уже придумано до меня, и я просто не знаю, как правильно это загуглить.
Однако подход с доменными автоматами и транзакциями на их основе оказался весьма полезным для меня и довольно сложной и запутанной логики, с которой мне приходится иметь дело. Также я вижу его как оправданную, хоть и сложную альтернативу паттерну Saga, который имеет весьма противоречивые отзывы в сообществе разработчиков.
Буду весьма признателен за любую критику, советы и отсылки к интересным материалам. Приглашаю в комментарии обсудить сам подход и его узкие места, а также варианты улучшения и упрощения.
---
*P.S.: а вот отличная [статья про Анатолия Шалыто](https://habr.com/ru/company/dataart/blog/538580/). Я сам не знал про него, когда читал его книгу, а потом встретил такую историю, которая мне очень понравилась. Просто делюсь.* | https://habr.com/ru/post/544042/ | null | ru | null |
# Режим высокой доступности HashiCorp Vault (HA)
Hashicorp Vault — open-source инструмент для управления секретами (пароли, ключи API и т.д.),
Vault может работать в режиме высокой доступности (HA) для защиты от сбоев за счет запуска нескольких серверов Vault. Vault обычно ограничивается пределами операций ввода-вывода серверной части Vault, а не требованиями к вычислениям. Некоторые серверные модули хранения, например Consul, предоставляют дополнительные функции координации, которые позволяют Vault работать в конфигурации высокой доступности, в то время как другие обеспечивают более надежный процесс резервного копирования и восстановления.
При работе в режиме высокой доступности серверы Vault имеют два дополнительных состояния: **резервное** и **активное**. В кластере Vault активным будет только один экземпляр, который будет обрабатывать все запросы (чтение и запись), а все резервные узлы перенаправляют запросы на активный узел.
ПРИМЕЧАНИЕ. Начиная с версии **0.11**, эти резервные узлы могут обрабатывать большинство запросов только для чтения и вести себя как узлы реплики для чтения. Эта функция **Performance Standby Nodes** включена в Vault Enterprise Premium, а также доступна для Vault Enterprise Pro за дополнительную плату. Это особенно полезно для обработки больших объемов запросов. Прочтите документацию по рабочим узлам и руководство для получения более подробной информации.
Это руководство проведет вас через простую реализацию кластера Vault Highly Available (HA). Хотя это не исчерпывающее или предписывающее руководство, которое можно использовать в качестве примера прямого подключения, оно охватывает основы, достаточные для информирования вашей собственной производственной установки.
**Примерное время на выполнение**
25 минут
**Предпосылки**
Это промежуточное руководство по работе с Vault предполагает, что у вас есть практические знания о Vault и Consul.
**Шаги**
Наша цель в этом руководстве, — настроить Vault HA, состоящий из:
· 2 серверов Vault: 1 активный и 1 резервный
· Кластер из 3-х серверов Consul
**Справочная диаграмма**
На этой диаграмме для справки показаны простые детали архитектуры:
Мы будем выполнять эти шаги:
* Шаг 1. Настройка кластера серверов Consul
* Шаг 2. Запуск и проверка состояния кластера Consul
* Шаг 3. Настройка клиентских агентов Consul на узлах Vault
* Шаг 4. Настройка серверов Vault
* Шаг 5. Запуск Vault и его проверка
Для реализации целей этого руководства мы будем использовать программное обеспечение с открытым исходным кодом Vault и Consul; настройка будет аналогична для версии Enterprise.
**Шаг 1. Настройка кластера серверов Consul**
Наши серверы Consul в этом руководстве будут определяться только IP-адресом, но также обозначены меткой:
* **`consul_s1: 10.1.42.101`**
* **`consul_s2: 10.1.42.102`**
* **`consul_s3: 10.1.42.103`**
Двоичный файл Consul находится в **`/usr/local/bin/consul`**, но если в вашем случае не так, вы можете соответствующим образом изменить ссылки на пути.
Имея это в виду, вот начальная точка базовой конфигурации сервера Consul:
```
{
"server": true,
"node_name": "$NODE_NAME",
"datacenter": "dc1",
"data_dir": "$CONSUL_DATA_PATH",
"bind_addr": "0.0.0.0",
"client_addr": "0.0.0.0",
"advertise_addr": "$ADVERTISE_ADDR",
"bootstrap_expect": 3,
"retry_join": ["$JOIN1", "$JOIN2", "$JOIN3"],
"ui": true,
"log_level": "DEBUG",
"enable_syslog": true,
"acl_enforce_version_8": false
}
```
Обратите внимание, что некоторые значения содержат заполнители переменных, а остальные имеют разумные значения по умолчанию. Вы должны заменить следующие значения в вашей конфигурации сервера Consul на основе примера:
* **$NODE\_NAME** — это уникальная метка для узла; в нашем случае это будут `consul_s1`, `consul_s2` и `consul_s3` соответственно.
* **$CONSUL\_DATA\_PATH**: абсолютный путь к каталогу данных Consul; убедитесь, что этот каталог доступен для записи пользователю процесса Consul.
* **$ADVERTISE\_ADDR**: задает адрес, чтобы серверы Consul объявляли другим серверам в кластере. Не должно быть установлено в `0.0.0.0`; для этого руководства он должен быть установлен на IP-адрес сервера Consul в каждом экземпляре файла конфигурации или `10.1.42.101`,`10.1.42.102` и `10.1.42.103` соответственно.
* **$JOIN1**, **$JOIN2**, **$JOIN3**: в этом примере используется метод `retry_join` для присоединения агентов сервера к формированию кластера; Таким образом, значения для этого руководства будут `10.1.42.101`, `10.1.42.102` и `10.1.42.103` соответственно.
Обратите внимание, что веб-интерфейс пользователя включен (`"ui": true`), и Consul будет вести журнал на уровне DEBUG в системный журнал (`"log_level": "DEBUG"`). Для целей этого руководства `acl_enforce_version_8` установлено в `false`, поэтому нам не нужно беспокоиться о списках ACL в этом руководстве. Тем не менее, вы могли бы включить списки ACL в производственной среде и следовать [руководству Consul ACL](https://www.consul.io/docs/guides/acl.html#acl-agent-master-token).
Создайте файл конфигурации для каждого сервера Vault и сохраните его как `/usr/local/etc/consul/client_agent.json`.
Пример `consul_s1.json`
```
{
"server": true,
"node_name": "consul_s1",
"datacenter": "dc1",
"data_dir": "/var/consul/data",
"bind_addr": "0.0.0.0",
"client_addr": "0.0.0.0",
"advertise_addr": "10.1.42.101",
"bootstrap_expect": 3,
"retry_join": ["10.1.42.101", "10.1.42.102", "10.1.42.103"],
"ui": true,
"log_level": "DEBUG",
"enable_syslog": true,
"acl_enforce_version_8": false
}
```
Пример `consul_s2.json`
```
{
"server": true,
"node_name": "consul_s2",
"datacenter": "dc1",
"data_dir": "/var/consul/data",
"bind_addr": "0.0.0.0",
"client_addr": "0.0.0.0",
"advertise_addr": "10.1.42.102",
"bootstrap_expect": 3,
"retry_join": ["10.1.42.101", "10.1.42.102", "10.1.42.103"],
"ui": true,
"log_level": "DEBUG",
"enable_syslog": true,
"acl_enforce_version_8": false
}
```
Пример `consul_s3.json`
```
{
"server": true,
"node_name": "consul_s3",
"datacenter": "dc1",
"data_dir": "/var/consul/data",
"bind_addr": "0.0.0.0",
"client_addr": "0.0.0.0",
"advertise_addr": "10.1.42.103",
"bootstrap_expect": 3,
"retry_join": ["10.1.42.101", "10.1.42.102", "10.1.42.103"],
"ui": true,
"log_level": "DEBUG",
"enable_syslog": true,
"acl_enforce_version_8": false
}
```
Консул Сервер `systemd`
У вас есть двоичные файлы Consul и базовая конфигурация, и теперь вам просто нужно запустить Consul на каждом экземпляре сервера; `systemd` популярен в большинстве современных дистрибутивов Linux, поэтому, имея это в виду, вот пример файла systemd unit:
```
### BEGIN INIT INFO
# Provides: consul
# Required-Start: $local_fs $remote_fs
# Required-Stop: $local_fs $remote_fs
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Consul agent
# Description: Consul service discovery framework
### END INIT INFO
[Unit]
Description=Consul server agent
Requires=network-online.target
After=network-online.target
[Service]
User=consul
Group=consul
PIDFile=/var/run/consul/consul.pid
PermissionsStartOnly=true
ExecStartPre=-/bin/mkdir -p /var/run/consul
ExecStartPre=/bin/chown -R consul:consul /var/run/consul
ExecStart=/usr/local/bin/consul agent \
-config-file=/usr/local/etc/consul/client_agent.json \
-pid-file=/var/run/consul/consul.pid
ExecReload=/bin/kill -HUP $MAINPID
KillMode=process
KillSignal=SIGTERM
Restart=on-failure
RestartSec=42s
[Install]
WantedBy=multi-user.target
```
Обратите внимание, что вас может заинтересовать изменение следующих значений в зависимости от стиля, стандартного уровня соблюдения иерархии файловой системы и т. Д. –
* **config-file**
* **pid-file**
После того как файл модуля определен и сохранен (например, `/etc/systemd/system/consul.service`), обязательно выполните перезагрузку демона `systemctl daemon-reload`, а затем вы можете запустить службу Consul на каждом сервере.
**Шаг 2. Запуск и проверка состояния кластера Consul**
Убедитесь, что права собственности и разрешения верны в каталоге, который вы указали для значения `data_dir`, а затем запустите службу Consul в каждой системе и проверьте статус:
```
$ sudo systemctl start consul
$ sudo systemctl status consul
● consul.service - Consul server agent
Loaded: loaded (/etc/systemd/system/consul.service; enabled; vendor preset: enabled)
Active: active (running) since Mon 2018-03-19 17:33:14 UTC; 24h ago
Main PID: 2068 (consul)
Tasks: 13
Memory: 13.6M
CPU: 0m 52.784s
CGroup: /system.slice/consul.service
└─2068 /usr/local/bin/consul agent -config-file=/usr/local/etc/consul/client_agent.json -pid-file=/var/run/consul/consul.pid
```
После запуска всех агентов сервера Consul, давайте проверим статус кластера Consul:
```
$consul members
Node Address Status Type Build Protocol DC Segment
consul_s1 10.1.42.101:8301 alive server 1.0.6 2 dc1
consul\_s2 10.1.42.102:8301 alive server 1.0.6 2 dc1
consul\_s3 10.1.42.103:8301 alive server 1.0.6 2 dc1
```
Кластер выглядит хорошо, показаны все 3 сервера; Прежде чем продолжить, убедитесь, что у нас есть лидер:
```
$consul operator raft list-peers
Node ID Address State Voter RaftProtocol
consul_s2 536b721f-645d-544a-c10d-85c2ca24e4e4 10.1.42.102:8300 follower true 3
consul_s1 e10ba554-a4f9-6a8c-f662-81c8bb2a04f5 10.1.42.101:8300 follower true 3
consul_s3 56370ec8-da25-e7dc-dfc6-bf5f27978a7a 10.1.42.103:8300 leader true 3
```
Приведенный выше вывод показывает, что `consul_s3` является текущим лидером кластера в этом примере. Теперь вы можете перейти к настройке сервера Vault.
**Шаг 3. Настройка клиентских агентов Consul на узлах Vault**
Узлам сервера Vault требуются двоичные файлы Consul и Vault на каждом узле. Consul будет настроен как агент клиента, а Vault будет настроен как сервер.
**Конфигурация агента клиента Consul**
Поскольку Consul используется для обеспечения серверной части высокодоступного хранилища, вам необходимо настроить локальные клиентские агенты Consul на серверах Vault, которые будут взаимодействовать с кластером серверов Consul для регистрации проверок работоспособности, обнаружения служб и координации переключения HA кластера (лидерство кластера).
Обратите внимание, что [не рекомендуется подключать серверы Vault напрямую к серверам Consul.](https://fix-tag--vault-www.netlify.app/docs/configuration/storage/consul#address)
Агенты клиента Consul будут использовать тот же адрес, что и серверы Vault, для сетевой связи с кластером серверов Consul, но они будут связывать `client_address` только с интерфейсом обратной связи, так что Vault может подключиться к нему через интерфейс обратной связи.
Вот пример конфигурации для агента клиента Consul:
```
{
"server": false,
"datacenter": "dc1",
"node_name": "$NODE_NAME",
"data_dir": "$CONSUL_DATA_PATH",
"bind_addr": "$BIND_ADDR",
"client_addr": "127.0.0.1",
"retry_join": ["$JOIN1", "$JOIN2", "$JOIN3"],
"log_level": "DEBUG",
"enable_syslog": true,
"acl_enforce_version_8": false
}
```
Аналогично тому, что вы сделали на **шаге 1**, замените следующие значения в своей конфигурации агента клиента Consul соответственно:
* **$NODE\_NAME** — это уникальная метка для узла; в нашем случае это будут `consul_c1` и `consul_c2` соответственно.
* **$CONSUL\_DATA\_PATH**: абсолютный путь к каталогу данных Consul; убедитесь, что этот каталог доступен для записи пользователю процесса Consul.
* **$BIND\_ADDR**: это должно быть установлено на адрес, который вы предпочитаете, чтобы серверы Consul объявляли другим серверам в кластере, и не должно быть установлено на `0.0.0.0`; в этом руководстве он должен быть установлен на IP-адрес сервера Vault в каждом экземпляре файла конфигурации или `10.1.42.201` и `10.1.42.202` соответственно.
* **$JOIN1**, **$JOIN2**, **$JOIN3**: в этом примере используется метод `retry_join` для присоединения агентов сервера для формирования кластера; Таким образом, значения для этого руководства будут `10.1.42.101`, `10.1.42.102` и `10.1.42.103` соответственно.
Создайте файл конфигурации для каждого сервера Vault и сохраните его как `/usr/local/etc/consul/client_agent.json`.
Пример consul\_c1.json
```
{
"server": false,
"datacenter": "dc1",
"node_name": "consul_c1",
"data_dir": "/var/consul/data",
"bind_addr": "10.1.42.201",
"client_addr": "127.0.0.1",
"retry_join": ["10.1.42.101", "10.1.42.102", "10.1.42.103"],
"log_level": "DEBUG",
"enable_syslog": true,
"acl_enforce_version_8": false
}
```
Пример consul\_c2.json
```
{
"server": false,
"datacenter": "dc1",
"node_name": "consul_c2",
"data_dir": "/var/consul/data",
"bind_addr": "10.1.42.202",
"client_addr": "127.0.0.1",
"retry_join": ["10.1.42.101", "10.1.42.102", "10.1.42.103"],
"log_level": "DEBUG",
"enable_syslog": true,
"acl_enforce_version_8": false
}
```
#### systemd юнит файл Consul сервера
У вас есть двоичные файлы Consul и базовая конфигурация агента клиента, и теперь вам просто нужно запустить Consul на каждом из экземпляров сервера Vault. Вот пример файла модуля `systemd`:
```
### BEGIN INIT INFO
# Provides: consul
# Required-Start: $local_fs $remote_fs
# Required-Stop: $local_fs $remote_fs
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Consul agent
# Description: Consul service discovery framework
### END INIT INFO
[Unit]
Description=Consul client agent
Requires=network-online.target
After=network-online.target
[Service]
User=consul
Group=consul
PIDFile=/var/run/consul/consul.pid
PermissionsStartOnly=true
ExecStartPre=-/bin/mkdir -p /var/run/consul
ExecStartPre=/bin/chown -R consul:consul /var/run/consul
ExecStart=/usr/local/bin/consul agent \
-config-file=/usr/local/etc/consul/client_agent.json \
-pid-file=/var/run/consul/consul.pid
ExecReload=/bin/kill -HUP $MAINPID
KillMode=process
KillSignal=SIGTERM
Restart=on-failure
RestartSec=42s
[Install]
WantedBy=multi-user.target
```
При необходимости измените следующие значения:
* **-config-file**
* **-pid-file**
После того как файл модуля определен и сохранен (например, `/etc/systemd/system/consul.service`), обязательно выполните перезагрузку демона `systemctl daemon-reload`, а затем вы можете запустить службу Consul на каждом сервере Vault.
Запустите Consul и проверьте его состояние кластера, чтобы убедиться, что права собственности и разрешения верны в каталоге, который вы указали для значения `data_dir`, а затем запустите службу Consul в каждой системе и проверьте статус:
```
$ sudo systemctl start consul
$ sudo systemctl status consul
● consul.service - Consul client agent
Loaded: loaded (/etc/systemd/system/consul.service; enabled; vendor preset: enabled)
Active: active (running) since Tue 2018-03-20 19:36:49 UTC; 6s ago
Main PID: 23758 (consul)
Tasks: 11
Memory: 9.8M
CPU: 571ms
CGroup: /system.slice/consul.service
└─23758 /usr/local/bin/consul agent -config-file=/usr/local/etc/consul/client_agent.json -pid-file=/var/run/consul/consul.pid
```
После запуска всех клиентских агентов Consul проверьте статус кластера Consul:
```
$consul members
Node Address Status Type Build Protocol DC Segment
consul_s1 10.1.42.101:8301 alive server 1.0.6 2 dc1
consul\_s2 10.1.42.102:8301 alive server 1.0.6 2 dc1
consul\_s3 10.1.42.103:8301 alive server 1.0.6 2 dc1
consul\_c1 10.1.42.201:8301 alive client 1.0.6 2 arus
consul\_c2 10.1.42.202:8301 alive client 1.0.6 2 arus
```
Приведенные выше выходные данные показывают 3 агента сервера Consul и 2 агента клиента Consul в кластере. Теперь вы можете настроить серверы Vault.
**Шаг 4. Настройка серверов Vault**
Теперь, когда у нас есть кластер Consul, состоящий из 3-х серверов и 2-х клиентских агентов для наших серверов Vault, давайте вместе получим конфигурацию для Vault и сценарий запуска, чтобы мы могли запустить настройку Vault HA.
Наши серверы Vault в этом руководстве определяются только IP-адресом, но также обозначаются меткой:
* **vault\_s1: 10.1.42.201**
* **vault\_s2: 10.1.42.202**
В нашем файле конфигурации мы настроим следующее:
* [**tcp**](https://fix-tag--vault-www.netlify.app/docs/configuration/listener/tcp) listener
* [**consul**](https://fix-tag--vault-www.netlify.app/docs/configuration/storage/consul) storage backend
* [Параметры высокой доступности](https://fix-tag--vault-www.netlify.app/docs/configuration/#high-availability-parameters)
В этом разделе предполагается, что двоичный файл Vault находится в **`/usr/local/bin/vault`**.
**Конфигурация Vault**
```
listener "tcp" {
address = "0.0.0.0:8200"
cluster_address = "0.0.0.0:8201"
tls_disable = "true"
}
storage "consul" {
address = "127.0.0.1:8500"
path = "vault/"
}
api_addr = "$API_ADDR"
cluster_addr = "$CLUSTER_ADDR"
```
Мы устанавливаем следующие параметры для нашего `tcp`-слушателя:
* [`address`](https://fix-tag--vault-www.netlify.app/guides/operations/vault-ha-consul.html#address) ("127.0.0.1:8200") — указывает адрес, к которому нужно привязаться для прослушивания.
* [`cluster_address`](https://fix-tag--vault-www.netlify.app/guides/operations/vault-ha-consul.html#cluster_address) ("127.0.0.1:8201") — указывает адрес для привязки для запросов кластера сервер-сервер. По умолчанию это значение на один порт больше, чем значение адреса. Обычно это не требуется настраивать, но может быть полезно в случае, если серверы Vault изолированы друг от друга таким образом, что им нужно переключаться через балансировщик нагрузки TCP или какую-либо другую схему для разговора.
Эта конфигурация позволяет прослушивать все интерфейсы (например, так, чтобы команда Vault для адреса обратной связи была успешной).
Мы также устанавливаем [параметры высокой доступности](https://fix-tag--vault-www.netlify.app/docs/configuration/#high-availability-parameters) Vault (`api_addr` и `cluster_addr`). Чаще всего нет необходимости настраивать эти два параметра при использовании Consul в качестве серверной части хранилища Vault, поскольку Consul будет пытаться автоматически обнаруживать и объявлять адрес активного узла Vault. Однако для некоторых конфигураций кластера может потребоваться их явная установка (например, доступ к Vault через балансировщик нагрузки).
Для простоты предположим, что клиенты в нашем сценарии подключаются непосредственно к узлам Vault (а не через балансировщик нагрузки). Просмотрите документацию [Client Redirection](https://fix-tag--vault-www.netlify.app/docs/concepts/ha#client-redirection), чтобы получить дополнительную информацию о шаблонах доступа клиентов и их последствиях.
Обратите внимание, что некоторые значения содержат заполнители переменных, а остальные имеют разумные значения по умолчанию. Вы должны заменить следующие значения в конфигурации вашего собственного сервера Vault на основе примера:
* **$API\_ADDR**: указывает адрес (полный URL) для объявления другим серверам Vault в кластере для перенаправления клиентов. Это также можно сделать с помощью переменной среды `VAULT_API_ADDR`. Как правило, это должен быть полный URL-адрес, указывающий на значение адреса слушателя. В нашем сценарии это будут <http://10.1.42.201:8200> и <http://10.1.42.202:8200> соответственно.
* **$CLUSTER\_ADDR**: указывает адрес для объявления другим серверам Vault в кластере для пересылки запросов. Это также можно сделать с помощью переменной среды `VAULT_CLUSTER_ADDR`. Это полный URL, например `api_addr`. В нашем сценарии это будут <https://10.1.42.201:8201> и <https://10.1.42.202:8201> соответственно.
Обратите внимание, что схема здесь (https) игнорируется; все члены кластера всегда будут использовать TLS с закрытым ключом / сертификатом.
Пример vault\_s1.hcl
```
listener "tcp" {
address = "0.0.0.0:8200"
cluster_address = "10.1.42.201:8201"
tls_disable = "true"
}
storage "consul" {
address = "127.0.0.1:8500"
path = "vault/"
}
api_addr = "http://10.1.42.201:8200"
cluster_addr = "https://10.1.42.201:8201"
```
Пример vault\_s2.hcl
```
listener "tcp" {
address = "0.0.0.0:8200"
cluster_address = "10.1.42.202:8201"
tls_disable = "true"
}
storage "consul" {
address = "127.0.0.1:8500"
path = "vault/"
}
api_addr = "http://10.1.42.202:8200"
cluster_addr = "https://10.1.42.202:8201"
```
**systemd юнит файл Vault сервера**
У вас есть двоичные файлы Vault и базовая конфигурация вместе с настроенными локальными агентами клиента. Теперь вам просто нужно запустить Vault на каждом экземпляре сервера. Вот пример файла модуля `systemd`:
```
### BEGIN INIT INFO
# Provides: vault
# Required-Start: $local_fs $remote_fs
# Required-Stop: $local_fs $remote_fs
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Vault server
# Description: Vault secret management tool
### END INIT INFO
[Unit]
Description=Vault secret management tool
Requires=network-online.target
After=network-online.target
[Service]
User=vault
Group=vault
PIDFile=/var/run/vault/vault.pid
ExecStart=/usr/local/bin/vault server -config=/etc/vault/vault_server.hcl -log-level=debug
ExecReload=/bin/kill -HUP $MAINPID
KillMode=process
KillSignal=SIGTERM
Restart=on-failure
RestartSec=42s
LimitMEMLOCK=infinity
[Install]
WantedBy=multi-user.target
```
Обратите внимание, что вас может заинтересовать изменение следующих значений в зависимости от стиля, стандартного уровня соблюдения иерархии файловой системы и т. д.
* **-config**
* **-log-level**
Как только файл модуля определен и сохранен, например, `/etc/systemd/system/vault.service`, обязательно выполните перезагрузку демона `systemctl daemon-reload`, а затем вы можете запустить службу Vault на каждом сервере.
**Шаг 5. Запуск Vault и его проверка**
Запустите службу Vault в каждой системе и проверьте состояние:
```
$ sudo systemctl start vault
$ sudo systemctl status vault
● vault.service - Vault secret management tool
Loaded: loaded (/etc/systemd/system/vault.service; enabled; vendor preset: enabled)
Active: active (running) since Tue 2018-03-20 20:42:10 UTC; 42s ago
Main PID: 2080 (vault)
Tasks: 12
Memory: 71.7M
CPU: 50s
CGroup: /system.slice/vault.service
└─2080 /usr/local/bin/vault server -config=/home/ubuntu/vault_nano/config/vault_server.hcl -log-level=debu
```
Теперь вам нужно перейти к [инициализации и распечатыванию](https://fix-tag--vault-www.netlify.app/intro/getting-started/deploy#initializing-the-vault) каждого экземпляра Vault.
Как только это будет сделано, проверьте статус Vault на каждом из серверов.
Активный сервер Vault:
```
$ vault status
Key Value
--- -----
Seal Type shamir
Sealed false
Total Shares 5
Threshold 3
Version 0.9.5
Cluster Name vault
Cluster ID 0ee91bd1-55ec-c84f-3c1d-dcc7f4f644a8
HA Enabled true
HA Cluster https://10.1.42.201:8201
HA Mode active
```
Резервный сервер Vault:
```
vault status
Key Value
--- -----
Seal Type shamir
Sealed false
Total Shares 5
Threshold 3
Version 0.9.5
Cluster Name vaultron
Cluster ID 0ee91bd1-55ec-c84f-3c1d-dcc7f4f644a8
HA Enabled true
HA Cluster https://10.1.42.201:8201
HA Mode standby
Active Node Address: http://10.1.42.201:8200
```
Теперь серверы Vault работают в режиме высокой доступности (HA), и вы можете записать секрет из активного или резервного экземпляра Vault и увидеть его успешное выполнение в качестве теста пересылки запросов. Кроме того, вы можете закрыть активный экземпляр (`sudo systemctl stop vault`), чтобы смоделировать сбой системы и увидеть, как резервный экземпляр принимает на себя лидерство.
**Следующие шаги**
Прочтите "[Повышение безопасности](https://fix-tag--vault-www.netlify.app/guides/operations/production)", чтобы узнать о передовых методах развертывания Vault для повышения уровня защиты в production среде. | https://habr.com/ru/post/538392/ | null | ru | null |
# Менеджер транзакций для базы данных в оперативной памяти
В этот статье я хочу еще раз пройтись по особенностям работы транзакций в Tarantool, применительно к движку в памяти и дисковому движку. И главное — расскажу про новый менеджер транзакций, который появился в Tarantool версии 2.6, про его особенности, преимущества и устройство.
Когда меня спрашивают, что такое Tarantool, я отвечаю давно въевшееся в мозг: «Tarantool — persistent in-memory noSQL СУБД с хранимыми процедурами на Lua». Но всë не так просто. Вот in-memory — да, *в основном* в Tarantool используется memtx engine, движок в памяти, однако дисковый движок (vinyl) тоже давным-давно есть, и у него множество нюансов и особенностей. Или noSQL — да, *в основном* Tarantool используется как noSQL БД, но SQL он тоже умеет, точнее, какую-то его часть, а какую именно — это надо почитать.
Даже с хранимыми процедурами не совсем всё просто: то, что затевалось как способ сделать JOIN в noSQL БД, обросло кооперативно-многозадачной инфраструктурой для работы с сетью, файлами, HTTP, массой модулей и документации; сейчас Tarantool именуют сервером приложений с БД на борту. Да и хранимые процедуры бывают не только на Lua, но и на C.
Но это, в общем, скорее приятные оговорки, дескать, что поделать, Tarantool сложный и поэтому есть много деталей. А когда меня кто-нибудь спрашивал, есть ли в Tarantool’е транзакции и какой у них уровень изоляции, то я отвечал: «есть, serializable, но...» И далее следовали оговорки мелким шрифтом, которые портили радужную картину и время от времени вызывали негодование пользователей.
Больше никаких оговорок, пора рассмотреть новый менеджер транзакций под микроскопом.
Требования к менеджеру транзакций
---------------------------------
Вряд ли я сильно совру, если скажу, что само понятие «транзакция» нужно только для обеспечения их изоляции. Если бы не транзакции, то базу данных можно было сделать примитивно. Запись производилась бы непосредственно в структуру данных индекса (TREE, HASH и прочие), удаляя предыдущее значение с тем же ключом. А чтение показывало бы последнее записанное значение по данному ключу. Я обозначу для удобства такую гипотетическую реализацию базы данных как *примитивную* базу.
Но транзакции вносят свои требования. Если рассматривать транзакцию как набор некоторых действий — чтений и записей в базу данных, — то все эти действия должны давать такой же результат, как если бы эта транзакция выполнялась в одиночестве в примитивной базе (см. выше). То есть существование одновременных транзакций допускается, но оно должно быть таким, чтобы незавершенные транзакции не влияли друг на друга.
Существуют стандартные требования к менеджеру транзакций:
* Read committed;
* Repeatable read;
* Serializable;
* Snapshot isolation.
Добавлю от себя ещё один критерий, который бессмыслен в примитивной базе, но который не хотелось бы упустить при реализации более сложного менеджера:
* Read own changes.
Давайте рассмотрим эти критерии подробнее.
### Read own
Я начал с самого простого, чтобы познакомить с моим способом визуализации транзакций. Разные транзакции я буду обозначать разными цветами. По оси Х откладывается время, по оси Y — ключи и значения. Для простоты будем считать, что база у нас key-value.
Изначально в базе данных по ключу 1 хранилось значение a, по ключу 2 — значение b, по ключу 3 — значение c. Допустим, транзакция переписала значение по ключу 2 — стало d. И тогда при чтении этого ключа она должна прочитать новое (свое) значение — d. Как я говорил, это, очевидно, работает в примитивной базе, но для менеджера транзакций это готовый тест.
### Read committed
1. Первой начинается красная транзакция.
2. Потом возникает синяя, она перезаписывает значение по ключу 1.
3. После этого возникает зеленая, которая перезаписывает по ключу 2 и сразу же коммитится. А синяя, обратите внимание, так и остается незавершенной.
4. После этого просыпается красная транзакция и начинает читать значения по ключам 1 и 2.
Критерий Read committed означает, что красная транзакция не должна увидеть синюю (значение d), поскольку она еще не завершена. Красная может увидеть зеленую (значение e), это ничему не противоречит, так как зеленая транзакция завершена.
### Repeatable read
1. Допустим, одна транзакция прочитала значение по ключу 2.
2. После этого приходит синяя транзакция, перезаписывает это значение на d и коммитится.
3. Теперь красная транзакция должна по ключу 2 продолжать читать значение b.
Это и есть Repeatable read: для одной транзакции однажды прочитанное значение должно оставаться неизменным (пока она его сама не изменит).
### Serializable
Предполагается, что транзакция совершает какие-то действия, которые каждый раз имеют какой-то результат. Результат чтения — данные, которые мы прочитали. При записи результат — данные, которые мы записали.
Операция UPDATE должна вернуть обновленный кортеж, который получился с учетом всех изменений. А INSERT может выдать, например, ошибку о том, что значение уже есть в спейсе и его не удалось вставить.
Критерий Serializable означает, что менеджер транзакций может определить любым способом некий порядок, в котором транзакции могли бы целиком исполняться последовательно в примитивное базе. При этом внутри транзакций порядок не меняется, а порядок выполнения самих транзакций выбран таким, чтобы результаты каждой операции не менялись.
На иллюстрации видно, что транзакции сериализуются в порядке зеленая — синяя — красная. Обратите внимание, что эти транзакции были завершены в другом порядке, в общем случае это не важно.
*Этот порядок сериализации крайне важен для описания того, что происходит с транзакциями. Иногда важна только часть данных об этом порядке. К примеру, можно сказать, что зеленая транзакция сериализуется до синей и красной, или красная — после синей и зеленой.*
### Не Snapshot isolation
Критерий Snapshot isolation тут приведен скорее для примера, чтобы показать, как делать неправильно. Поэтому на картинке изображен не Snapshot isolation, а то, как работает Tarantool (точнее новый MVCC, ну и старый Vinyl).
Идея Snapshot isolation в том, что в тот момент, когда транзакция начинается (вызывает begin), она сразу же попадает в read view. Она не видит вообще никакие изменения БД, которые происходят начиная с этого момента. Таким образом гарантируется Read committed и Repeatable read. Однако это не лучшее поведение базы данных.
На иллюстрации:
1. Первой начинается красная транзакция.
2. Затем начинается синяя транзакция, она меняет значение d, но не завершается.
3. Потом начинается зеленая, тоже изменяет данные (e) и успешно коммитится.
4. После этого просыпается красная транзакция и начинает читать значения, которые писали синяя с зеленой.
Если бы режим был Snapshot isolation, то красная транзакция не видела бы зеленое значение e, а только изначальные a и b. Однако такой подход сразу фиксирует относительный порядок сериализации красной и зеленой транзакций: красная должна быть строго *до* завершившейся зеленой.
Это ограничение, наложенное на порядок, может привести к конфликту позже, когда выяснится, что красная транзакция еще должна существовать *после* зеленой (это не обязательно, но часто вытекает из того, что красная еще выполняет действия после завершения зеленой).
Поэтому мы стремимся реализовывать *не* snapshot isolation. Read view, конечно, создавать приходится, но не всегда и как можно позже, так будет меньше конфликтов. Поэтому на иллюстрации видно, что красная транзакция читает зеленое значение e, успешно его перезаписывает и успешно завершается.
Транзакции в memtx 2.5 и ниже
-----------------------------
Итак, как же были реализованы транзакции для движка в памяти в более ранних версиях Tarantool?
Тут надо сказать, что Tarantool использует кооперативную многозадачность. Физически поток исполнения транзакций один, однако каждая хранимая процедура выполняется в отдельном файбере (зеленом потоке). Или просто каждый запрос, если пользователь не использует хранимую процедуру, а обращается напрямую к данным. Управление из файбера отдается исключительно по желанию самого файбера.
Многие функции внутри себя содержат функции передачи управления, например, к этому относятся все I/O-операции. Это значит, что если в хранимой процедуре сделать запись в сокет, то этот файбер уснет до того, как запись в сокет фактически произойдет. В это время другие файберы могут проснуться и сделать свою полезную работу.
**Такие функции называют йилдящими (от yield). При этом какие-то функции могут быть гарантированно не йилдящими.** За время их выполнения никакие другие файберы никаких действий сделать не могут.
В Tarantool операции чтения из in-memory таблиц никогда не уступают управление. В то же время отдельностоящие (autocommit) операции записи отдают управление до тех пор, пока в WAL не появится запись об этой операции. Однако при явном начале транзакции (при вызове `box.begin()`) все операции записи начинают накапливать записи в WAL, соответственно, перестают передавать управление.
При этом все операции над индексами — вставки, замены, удаления — выполняются как в примитивной базе. Таким образом, выполняется Read own. Только при успешном завершении транзакции (вызов `box.commit()`) инициируется запись в WAL и управление передается другим файберам.
При ошибке транзакция будет целиком откачена, в том числе будут возвращены предыдущие данные в индексы. То же самое случится, если же во время выполнения транзакции произойдет передача управления, например, нам вздумается сделать запись в сокет внутри транзакции. Таким образом, транзакции в Tarantool были строго атомарны! Получается, строго serializable в порядке записи в WAL? Да, почти… кроме одного случая. Это то самое, мелким шрифтом.
Дело в том, что не все транзакции ждут записи в WAL. Есть read-only транзакции, которые отдают результат пользователю моментально. Если такая транзакция прочитает данные, которые записала другая транзакция, ожидающая окончания записи в WAL, и эта запись в WAL завершится с ошибкой… Тогда вторая транзакция будет откачена, а первая прочитает никогда не существовавшее значение.
Таким образом мы получаем dirty read, то есть нарушается критерий read committed. Конечно, это происходит только при сбое WAL. Можно сказать, что транзакции в memtx 2.5 и ниже имеют уровень изоляции serializable, но в момент сбоя WAL могут быть dirty read.
То есть если всё хорошо — то всё очень хорошо, а если всё плохо — то всё очень плохо. Отношение к такому механизму сильно зависит от оптимистичности пользователя. Такое поведение всех более-менее устраивало. Но когда мы начали реализовывать синхронную репликацию, проблема грязных чтений встала в полный рост. Синхронная репликация заставила нас форсировать разработку нового менеджера транзакций.
Резюмируя достоинства и недостатки старого варианта движка memtx:
* Транзакции действительно атомарны.
* Fiber yield приводил к отмене транзакции.
* Интерактивных транзакций не предусмотрено.
* При сбое WAL — откат и read uncommitted.
* В синхронной репликации дела еще хуже, чем с WAL.
* Минимум (если не сказать ноль) накладных расходов.
Транзакции в vinyl
------------------
Vinyl — это дисковый движок, сделанный на основе LSM-дерева. В нем подход memtx сразу не подошел из-за неизбежного I/O. Поэтому был написан специальный менеджер транзакций.
В общем, он заслуживает отдельной статьи. Если вкратце, то он честно serializable:
1. Каждая транзакция хранит свои read set и write set.
2. Каждый кортеж (ряд в таблице) хранит тип операции и LSN.
3. История кортежей хранится в самом индексе — фактически, LSN, — это еще одно измерение ключа.
4. MVCC: при чтении происходит слияние данных из разных источников; помимо разных уровней LSM еще и собственный write set текущей транзакции.
5. Conflict Manager: при коммите транзакция пересекает свой write set с read setами остальных транзакций. При пересечении фиксируются конфликты, и читающая транзакция либо уходит в read view, либо абортится.
Тут возникает логичный вопрос: а почему так нельзя сделать в memtx, и дело с концом? И вот на него ответы, по пунктам соответственно:
1. Дорого по CPU (memtx обязан быть быстрым), дорого в реализации (это же для каждого типа индекса надо делать).
2. Дорого по памяти. Лишние 9 байт на кортеж — это много, особенно для тех, кому не нужен менеджер транзакций.
3. Это подойдет только для tree-like индекса и в некоторых ситуациях имеет существенные проблемы с производительностью.
4. Это же только для LSM tree. Более-менее понятно для TREE и HASH. Непонятно, как мержить rtree и bitset.
5. Опять же, непонятно, что делать для rtree и bitset.
Требования для менеджера транзакций в 2.6
-----------------------------------------
Для нового менеджера транзакций memtx мы сформировали список требований, которому не удовлетворяли ни текущая реализация транзакций memtx, ни менеджер транзакций vinyl:
1. Дешево по памяти и производительности по принципу «не используешь — не платишь». Если разные транзакции работают с непересекающимися данными, то хочется иметь обычную производительность, как без менеджера.
2. При пересекающихся множествах данных производительность также должна оставаться на достойном уровне.
3. Реализация должна быть максимально независимой от типа индекса.
4. Serializable без блокировок (то есть с абортами при конфликте), как в vinyl.
Дополнительным, независимым фактором является решение о том, что транзакции должны быть сериализованы в порядке записи в WAL. В общем случае это необязательно, но иные подходы приводят к массе проблем, связанных с непрерывной консистентностью при восстановлении и репликации. Учитывая, что read only транзакции не записываются в WAL, они сериализуются в любом удобном для менеджера порядке.
Подсистемы
----------
Менеджер транзакций можно удобно разделить на две почти независимые подсистемы: MVCC и менеджер конфликтов.
### MVCC — Multi version concurrency control
* Хранит в себе все модифицирующие действия всех транзакций.
* Создает для каждой транзакции её видение состояния БД.
* Умеет создавать read view — зафиксированное состояние БД, которое уже никогда не изменится другими транзакциями.
### Менеджер конфликтов
* Хранит информацию о том, какие данные читала каждая транзакция.
* При завершении транзакции для каждой другой транзакции принимает решение о возможности существования состояния БД, которое оно наблюдала.
* Умеет посылать транзакцию в read view при необходимости.
* Умеет абортить транзакцию, если ее видение БД стало невозможным.
MVCC: основная идея
-------------------
У нас есть одна точка входа на запись в любой спейс — метод `replace` (`old_tuple`, `new_tuple`). В общем случае он принимает два кортежа, старый и новый, с определенными ограничениями (если задан `new_tuple`, то `old_tuple` должен быть строго тем кортежем, который заменяется в первичном индексе). Все операции записи сводятся к такому `replace`. Например, `delete` — это вариант, когда `old_tuple` не нулевой, а `new_tuple` — нулевой. Примитивная реализация в этом случае выполняет простую работу: удаляет из всех индексов старый кортеж и добавляет новый. В некоторых случаях это приводит к ошибке, если добавление кортежа приводит к замене какого-то другого кортежа (не `old_tuple`).
Поскольку для MVCC нужно в первую очередь собирать данные о записи транзакций, то логично внедряться именно в этой точке.
Основную идею реализации нового MVCC можно расписать в пять пунктов:
* Во все кортежи добавляется всего один бит информации — флаг `is_dirty`. По-умолчанию этот бит не установлен, то есть все кортежи «чистые».
* Изменяется поведение функции `replace` для спейса: добавляемый в индексы кортеж помечается флагом `is_dirty`. Одновременно удаляемый `old_tuple` также помечается флагом `is_dirty` и специально не удаляется сразу из индексов (кроме случая, когда он явно замещается новым кортежем `new_tuple`).
* Для всех грязных кортежей хранится дополнительная структура (история), в которой записывается информация о том, какие транзакции что делали с данным кортежем.
* Для связи грязных кортежей и истории используется простейшая хеш-таблица, где ключом является сам указатель на кортеж. Никакой информации о ключевых полях кортежа не требуется.
* Вялый сборщик мусора постепенно удаляет историю и очищает кортежи.
Такой подход позволяет добиться сразу пяти целей:
* Неизбежных расходов — всего один бит на кортеж.
* Для чистых кортежей индексы (например, на чтение) работают по-старому и с той же скоростью.
* Для грязных кортежей можно легко получить историю, которую при селектах можно анализировать и находить кортеж, который должен быть в этом месте индекса для данной транзакции.
* В частности, можно делать `read_view`.
* Независимость от типа индекса.
### Детали реализации
При всей красоте такого подхода было довольно сложно подобрать удобную структуру хранения для такой истории. Есть некоторые, не очевидные сразу проблемы, которые приходится решать.
1. Индексов в одном спейсе может быть много. Для чтения желательно исследовать историю конкретного ключа. Например, если первый индекс построен по первому полю кортежа, а второй индекс — по второму, то прочитав из первого индекса грязный кортеж `{1, 2, «data»}` нужно искать, что этот кортеж заменил в первом индексе по ключу «1», а прочитав этот же кортеж во втором индексе, нужно искать других предшественников, у которых во втором поле ключ «2».
2. Историю удобно хранить последовательно, в порядке возрастания времени. А порядком времени в менеджере транзакций фактически является порядок сериализации. При этом порядок сериализации совпадает с порядком коммитов транзакций. Получается, что при добавлении изменения в историю кортежа изменений нескольких транзакций мы еще не можем знать порядок сериализации и, соответственно, порядок, в котором эти изменения нужно располагать.
3. Не могу не упомянуть одну досадную особенность операций удаления. В обычной, примитивной базе один кортеж может быть удален только один раз, это, в общем, логично. Однако при хранении истории это может быть не совсем так: могут быть несколько транзакций, которые собираются удалить кортеж, и это надо зафиксировать в истории, нельзя запрещать намерение удаления кортежа, так как неизвестно еще, какая из транзакций и когда соизволит закоммититься.
В результате попыток увязать это всё в одно родилось понятие tuple story: история одного кортежа. Она хранит информацию о том, кто и/или когда добавил в спейс этот кортеж и кто и/или когда удалил его.
Истории кортежей являются узлами сразу в нескольких двусвязных списках, по списку на каждый индекс. То есть в истории хранится по паре указателей для каждого индекса.
Порядок следования в списках совпадает с порядком транзакций, то есть для еще незавершенных транзакций он не определен. В самом верху списка, среди изменений, которые сделали еще не завершенные транзакции, их порядок еще может измениться, то есть при коммите транзакций их (возможно) придется переупорядочивать.
Однако в простейшем случае, когда транзакции не передают управление (единственно возможный режим в версии 2.5), они сразу будут находиться в нужном порядке. Это согласуется с принципом «не используешь — не платишь»: дополнительная работа появляется только при использовании yield. Также вверху этих списков, среди незавершенных транзакций, для одной истории кортежа может быть создан целый список транзакций, намеревающихся его удалить.
Таким образом формируется история, которая позволяет с любого места (начиная с любого кортежа) раскручивать историю по каждому индексу. MVCC-менеджер для каждой транзакции и для каждого индекса анализирует эти списки, игнорируя чужие незавершенные операции.
Менеджер конфликтов: основная идея
----------------------------------
В общем случае он собирает информацию о чтении всех транзакций и ориентируется на совокупность записей всех транзакций. Именно он должен отправлять их в read view, принимать решение об объявлении какой-то транзакции как невозможной.
Основная идея нового менеджера конфликтов: в истории кортежа хранить также историю чтения этого кортежа различными транзакциями. В новом менеджере сразу собираются потенциальные конфликты, в отличие от vinyl. Там история чтений просто собирается, а все решения принимаются при коммите какой-либо транзакции.
Это отлично вписываются в работу с историей кортежа. И при чтении, и при записи грязного кортежа приходится покопаться в его истории. В этот момент очень легко собрать информацию типа «если транзакция A будет закоммичена, то транзакцию B придется заабортить». При коммите транзакции придется пробежаться по этому списку и расставить соответствующие флаги — минимум накладных расходов. Но приходится делать грязными кортежи при чтении, чтобы в их историю записывать чтения.
Помимо аборта, менеджер конфликтов может перевести какую-нибудь транзакцию в read view, например, чтобы обеспечить repeatable read. Если какая-нибудь транзакция что-нибудь прочитала, а другая заменила это значение и перезаписалась, то первая отправляется в read view, чтобы не видеть наши изменения.
Как происходит отправка в read view:
Красная транзакция читает какое-то значение, синяя его перезаписывает. При коммите синей транзакции просыпается менеджер конфликтов и понимает, что красная транзакция теперь должна существовать до синей, и создает для нее специальный read view. В этому read view красная транзакция по-прежнему получает значение b при последующих чтениях ключа 2.
А вот немного другая ситуация:
Красная транзакция записала два ключа. Синяя понимает, что с точки зрения ключа 2 красная транзакция должна находиться до синей. Она не должна видеть синие изменения. Но с точки зрения ключа 3 мы понимаем, что потом красная транзакция захочет закоммититься. И тогда ей придется попасть в WAL уже после синей.
А мы очень хотим, чтобы порядок сериализации совпадал с порядком записи в WAL. Получается неискоренимый конфликт: красная транзакция должна быть и до, и после синей. Поэтому приходится помечать красную как конфликтную и дальнейшие действия над ней приведут к отмене транзакции.
Всë это позволяет достичь:
* Сериализуемость с обнаружением конфликтов, без блокировок.
* Эффективный, ленивый read view.
* Независимость от типа индекса, как и MVCC.
Но есть и проблемы. Подход, когда история чтения привязывается к кортежу, конечно, во многом хорош. Однако когда при чтении было обнаружено «ничего», такую историю просто некуда записывать, а записывать её надо для обнаружения конфликтов. Помимо этого в индексе типа TREE могут быть диапазонные чтения (от A до B) и чтения по неполным ключам. Для таких случаев приходится изобретать дополнительные индекс-зависимые структуры данных.
Smoke test и пример
-------------------
Новый режим включается специальной опцией конфига, без неё всё работает по-старому. А как проверить, какой режим сейчас?
В консоли Tarantool мы можем выполнять произвольные команды. Очевидно, что после каждой команды происходит какой-то yield. То есть по нажатию Enter просыпается файбер, выполняет команду и снова засыпает, отдавая управление главному и прочим файберам. Значит выполняя транзакцию по частям в консоли, мы должны увидеть аборт в старом режиме, и корректную работу — в новом.
Режим «по-старому». На мой взгляд, происходит какая-то дичь:
**memtx\_use\_mvcc\_engine=false**
```
tarantool> box.begin()
tarantool> s:replace{1, 2}
tarantool> s:replace{2, 1}
tarantool> s:select{}
---
- []
...
tarantool> box.commit()
2020-10-26 11:16:27.149 [21322] main/103/run.lua txn.c:705 E> ER_TRANSACTION_YIELD: Transaction has been aborted by a fiber yield
---
- error: Transaction has been aborted by a fiber yield
…
```
Режим «по-новому». Совсем другое дело:
**memtx\_use\_mvcc\_engine=true**
```
tarantool> box.begin()
tarantool> s:replace{1, 2}
tarantool> s:replace{2, 1}
tarantool> s:select{}
---
- - [1, 2]
- [2, 1]
...
tarantool> box.commit()
---
…
```
Дальше можно проверить, что до выполнения `box.commit()` никакие другие транзакции не видят этих изменений. Конечно, это и много другое проверяется в наших тестах.
Дальнейшие планы
----------------
Сейчас начинать и заканчивать транзакции можно только внутри хранимых процедур. На ближайшее время запланировано создание новых команд сетевого протокола `begin` и `commit` для возможности интерактивных транзакций по сети. Пока что есть понимание, что для этого нужно будет сделать независимые стримы в одном соединении.
Хотим сделать cross-engine транзакции, чтобы в одной транзакции можно было бы делать изменения и в memtx, и в vinyl. Вполне возможно, это получится очень легко, но могут быть определенные накладки.
Также у нас широкий простор для оптимизаций. Идей много, они записаны в отдельном тикете и ждут того момента, когда у нас дотянутся до них руки.
А еще мы планируем использовать подобный механизм и накопленный опыт для распределенных транзакций. Там тоже должен быть какой-то менеджер конфликтов, какой-то MVCC. Вполне возможно, что наработки из этой области мы будем использовать в наших дальнейших разработках по кластерам. | https://habr.com/ru/post/540842/ | null | ru | null |
# Яндекс.Диск как файловая система
Недавно Яндекс [анонсировал](http://habrahabr.ru/company/yandex/blog/141458/) свой новый сервис, подобный DropBox'у. Многие его сразу же начали поливать из ведра, хотя, я думаю, зря.
Один из плюсов лично для меня, линуксоида — не нужно устанавливать дополнительные приложения, как в случае с DropBox'ом. Сервис можно подключить через файловый менеджер Nautilus, используя WebDAV. Что я, собственно, сразу же и сделал.
Однако, я не стал на этом ограничиваться, ведь гуёвый доступ — не совсем хорошо, консольки никто не отменял.
**Подключим Яндекс.Диск как файловую систему**, например, в Ubuntu.
Установим пакет **davfs2**:
```
# apt-get install davfs2
```
Создадим точку монтирования:
```
# mkdir /mnt/yandex.disk
```
Примонтируем наш диск, введя логин и пароль от нашей почты на Я.ру (*use https, Luke*!):
```
# mount -t davfs https://webdav.yandex.ru /mnt/yandex.disk/
```
Убедимся, что всё в порядке:
```
# df -h /mnt/yandex.disk/
Filesystem Size Used Avail Use% Mounted on
https://webdav.yandex.ru
10G 7.7M 10G 1% /mnt/yandex.disk
```
10 гигабайт — всегда хорошо, для каких-нибудь бэкапов или быстрого обмена файлов, особенно, если это сервер.
**Простой скрипт для автоматического монтирования** (спасибо [uscr](http://habrahabr.ru/users/uscr/) via [habrahabr.ru/post/142067/#comment\_4752116](http://habrahabr.ru/post/142067/#comment_4752116)):
```
#!/usr/bin/expect
spawn mount.davfs https://webdav.yandex.ru /clouds/yandex.disk/
expect "Username:"
send "USERNAME@yandex.ru\r"
expect "Password:"
send "PASS\r"
expect eof
``` | https://habr.com/ru/post/142067/ | null | ru | null |
# Первое правило машинного обучения: начните без машинного обучения
Эффективное использование машинного обучения — сложная задача. Вам нужны данные. Вам нужен надёжный конвейер, поддерживающий потоки данных. И больше всего вам нужна высококачественная разметка. Поэтому чаще всего первая итерация моих проектов вообще не использует машинное обучение.
Что? Начинать *без* машинного обучения?
---------------------------------------
Об этом говорю не только я.
Догадайтесь, какое правило является первым в [43 правилах машинного обучения](https://developers.google.com/machine-learning/guides/rules-of-ml) Google?
> **Правило №1: не бойтесь запускать продукт без машинного обучения.**
>
>
>
> Машинное обучение — это здорово, но для него требуются данные. Теоретически, можно взять данные из другой задачи и подстроить модель под новый продукт, но она, скорее всего, не справится с базовыми эвристиками. Если вы предполагаете, что машинное обучение придаст вам рост на 100%, то эвристика даст вам 50%.
Множество практиков машинного обучения, с которыми я проводил интервью в рамках проекта [Applying ML](https://applyingml.com), в ответ на этот вопрос тоже дают похожие ответы: *«Представьте, что вам дали новую незнакомую задачу, которую нужно решить при помощи машинного обучения. Как вы подойдёте к её решению?»*
> «Для начала я приложу серьёзные усилия к тому, чтобы проверить, можно ли решить её без машинного обучения. Я всегда стремлюсь пробовать менее гламурные, простые вещи, прежде чем переходить к более сложным решениям». — [*Вики Бойкис, инженер ML в Tumblr*](https://applyingml.com/mentors/vicki-boykis/#imagine-youre-given-a-new-unfamiliar-problem-to-solve-with-machine-learning-how-would-you-approach-it)
> «Я думаю, что сначала важно выполнить задачу без ML. Решить задачу вручную или при помощи эвристик. Это заставит вас глубоко освоить задачу и данные, что является самым важным первым шагом. Более того, стоит получить точку отсчёта без ML, чтобы честно сравнивать показатели». — [*Хамел Хуссейн, ведущий инженер ML в Github*](https://applyingml.com/mentors/hamel-husain/#imagine-youre-given-a-new-unfamiliar-problem-to-solve-with-machine-learning-how-would-you-approach-it)
> «Сначала попробуйте решить задачу без машинного обучения. Этот совет дают все, потому что он хорош. Можно написать несколько правил или эвристик if/else, чтобы принимать простые решения и действовать на их основе». — [*Адам Лаиакано, ведущий инженер платформы ML в Spotify*](https://applyingml.com/mentors/adam-laiacano/#imagine-youre-given-a-new-unfamiliar-problem-to-solve-with-machine-learning-how-would-you-approach-it)
Тогда с чего начинать?
----------------------
Вне зависимости от того, используете ли вы простые правила или глубокое обучение, всегда помогает достаточный уровень понимания данных. Поэтому возьмите выборку данных, чтобы собрать статистику и визуализировать её! (Примечание: в основном это относится к табличным данным. По другим данным, как то изображения, текст, звук и т.д., собирать статистику может быть сложнее.)
**Простые корреляции помогают в выявлении связей** между каждым признаком и целевой переменной. Затем можно выбрать подмножество признаков с самыми сильными связями, чтобы их визуализировать. Это не только помогает с пониманием данных и нашей задачи (а значит, и с более эффективным использованием машинного обучения), но и позволяет лучше освоить контекст предметной области бизнеса. Однако стоит заметить, что корреляции и собранная статистика могут вводить в заблуждения — иногда оказывается, что переменные, имеющие сильные связи, обладают нулевой корреляцией (подробнее об этом ниже).
**Точечные диаграммы — любимый инструмент для визуализации числовых значений.** Отложите признак на оси X, а целевую переменную — на оси Y, и взаимосвязь проявится сама. В показанном ниже примере температура имеет нулевую корреляцию с продажами мороженого. Однако мы видим чёткую связь на точечной диаграмме — с повышением температуры люди покупают больше мороженого, но выше определённой температуры становится слишком жарко и они просто не выходят из дома.
*Точечная диаграмма непостоянной связи между температурой и продажами мороженого ([источник](https://www.mathsisfun.com/data/correlation.html))*
**Я выяснил, что если какая-то из переменных является категорийной, то хорошо подходят диаграммы типа «ящик с усами».** Допустим, вы пытаетесь спрогнозировать срок жизни собаки — насколько важен её размер для этого параметра?
*Ящик с усами срока жизни разных размеров пород собак ([источник](https://www.officetooltips.com/excel_365/tips/how_to_create_a_box_and_whisker_plot_in_excel.html))*
Имея понимание данных, мы можем **начать решение задачи при помощи эвристик**. Вот несколько примеров использования эвристик для решения часто встречающихся задач (вы удивитесь, насколько сложно их решить):
* **Рекомендации**: рекомендовать элементы с самыми лучшими показателями из предыдущего периода; также они могут быть сегментированы на категории (например, жанры или бренды). Если у вас есть поведение покупателя, то вы можете вычислить агрегированную статистику по совместному взаимодействию, чтобы вычислить схожесть элементов для рекомендаций i2i (см. [здесь](https://eugeneyan.com/writing/real-time-recommendations/#industry-examples-of-real-time-recommendations) Swing Algorithm компании Alibaba).
* **Классификация продуктов**: правила на основе регулярных выражений для названий продуктов. Вот пример из [классификатора продуктов Walmart (раздел 4.5)](https://dl.acm.org/doi/10.14778/2733004.2733024): если название продукта содержит «ring», «wedding band», «diamond.», "\*bridal", и т.д., то отнести его к категории колец.
* **Выявление спама в обзорах**: правила, основанные на количестве обзоров с одного IP, время публикации обзора (например, странная публикация в 3 часа ночи), схожесть (например, дистанция редактирования) между текущим обзором и другими обзорами, опубликованными в тот же день.
Многие люди также ответили на этот [твит](https://twitter.com/eugeneyan/status/1436198607972012036), предложив использовать в качестве точки отсчёта без машинного обучения регулярные выражения, межквартильный диапазон для выявления выбросов, скользящую среднюю для прогнозирования, создание словарей для сопоставления адресов, и т.д.
**Действительно ли работают эти эвристики?** Да! Меня часто поражает, насколько они эффективны, учитывая минимальные усилия, необходимые для их реализации. Вот пример того, как один простой список исключений позволил остановить скаммеров.
> «Много лет назад у нас был похожий опыт. После блокирования скаммеры быстро создавали новые веб-сайты и ускальзывали от моделей, но продолжали использовать одни и те же изображения с одинаковыми именами файлов. Попались!». Джек Хэнлон ([@JHanlon](https://twitter.com/JHanlon/status/1425978463417217028?ref_src=twsrc%5Etfw))
А вот ещё один пример, в котором регулярные выражения оказались лучше глубокого обучения.
> «Меня за это так много критиковали. В одном проекте, над которым я работал, выполнялось сравнение строк, но заказчик был разочарован тем, что я не использовал нейросети, и нанял для этого кого-то другого. Угадайте, какой способ оказался точнее и дешевле?», — Митч Хейл ([@bwahacker](https://twitter.com/bwahacker/status/1436280547219738627?ref_src=twsrc%5Etfw))
Да, вы можете сказать, что эти люди, обучавшие модели машинного обучения, не понимали, что они делают. Возможно. Тем не менее, смысл в том, что понимание данных и простые эвристики запросто могут проявить себя лучше, чем `model.fit()`, и потратить на них придётся в два раза меньше времени.
**Эти эвристики также помогают с бутстреппингом разметки (weak supervision).** Если вы начинаете с нуля и у вас нет разметки, weak supervision позволяет быстро и эффективно получить множество меток, хоть и низкого качества. Эти эвристики можно формализовать как функции разметки для генерирования меток. Другими примерами weak supervision являются использование баз знаний и заранее обученных моделей. Подробнее о weak supervision в Google и Apple можно прочитать [здесь](https://eugeneyan.com/writing/bootstrapping-data-labels/#weak-supervision-get-lots-of-lower-quality-labels-fast).
Когда же нужно использовать машинное обучение?
----------------------------------------------
**После того, как у вас появится точка отсчёта без ML с достаточно хорошими показателями**, и объём усилий по поддержке и совершенствованию этой точки отсчёта перевешивает объём усилий по созданию и развёртыванию системы на основе ML. Сложно конкретно указать, когда это случается, но когда становится невозможно изменять ваши 195 созданных вручную правил без того, чтобы что-то не сломалось, то стоит задуматься о машинном обучении. Вот правило №3 из Правил ML компании Google.
> **Правило №3: выбирайте машинное обучение вместо сложной эвристики.**
>
>
>
> Простая эвристика может позволить выпустить продукт. Сложную эвристику невозможно поддерживать. После того, как у вас накопились данные и появилось базовое понимание того, что вы пытаетесь достичь, переходите к машинному обучению… и вы обнаружите, что модель машинного обучения проще обновлять и поддерживать.
**Наличие надёжных конвейеров обработки данных и высококачественной разметки данных тоже дают понять, что вы готовы к машинному обучению.** Но прежде чем это произойдёт, имеющиеся у вас данные могут быть недостаточно хороши для машинного обучения. Допустим, вам нужно снизить уровень мошенничества на вашей платформе, но вы даже не знаете, как выглядит мошенническое поведение, не говоря уже об отсутствии меток.
Или у вас могут быть данные, но в настолько плохом состоянии, что их невозможно использовать. Например, есть данные о категориях продуктов, которые можно использовать для обучения классификатора продукции. Однако продавцы намеренно ошибочно классифицируют продукты, чтобы обмануть систему (например, чтобы была установлена меньшая комиссия на определённые категории или чтобы проще обеспечить ранжирование в категориях с малым количеством товаров).
Часто для получения «золотого стандарта» набора данных с высококачественными метками требуется разметка вручную. При его наличии обучение *и валидация* работ по машинному обучению становятся намного проще.
Но что если мне нужно использовать ML ради самого ML?
-----------------------------------------------------
Хм, тогда вы находитесь в сложном положении. Как обеспечить равновесие между решением задачи (удовлетворением требований заказчика) и тратой кучи времени и усилий просто ради самого ML? У меня нет ответа на этот вопрос, но я процитирую гениальный совет Брэндона Рорера.
> «Совет по стратегии работы с ML
>
>
>
> Когда у вас есть задача, создайте два решения — байесовский трансформер с глубоким обучением, работающий в многооблачном (multicloud) Kubernetes и SQL-запрос, построенный на основе стека чрезвычайно упрощающих допущений. Одно решение запишите в своё резюме, второе используйте в продакшене. И все будут довольны». — Брэндон Рорер ([@\_brohrer\_](https://twitter.com/_brohrer_/status/1425770502321283073?ref_src=twsrc%5Etfw)) | https://habr.com/ru/post/587508/ | null | ru | null |
# Без него не было бы YouTube, Instagram и Uber: пошаговая инструкция о том, как выжать максимум из Python
Языков в мире программирования масса, но корону по праву носит Python. Многие полюбили его за гибкость, лаконичность, бесчисленное количество модулей и поддержку сообщества. Именно этот язык стал основой для самых популярных мировых площадок: YouTube, Instagram, Uber и многих других. Однако, некоторые программисты считают Python языком с ограниченными возможностями и уверены, что он «задохнется» под тяжелой архитектурой highload системы.
Я, технический директор компании STM Labs, Андрей Комягин, за несколько минут смогу переубедить всех скептиков и доказать обратное.
Недавно в мире IT случилось важное событие — институт [IEEE опубликовал список](https://spectrum.ieee.org/top-programming-language-2020#toggle-gdpr) самых востребованных языков программирования. Корону победителя с гордостью примерил Python. Это вполне закономерный результат, поскольку Python — бесплатный язык программирования с открытым исходным кодом и удобными структурами данных. Он запускается на любых ОС и поддерживает множество сервисов, сред разработки и фреймворков. К тому же, он подходит для новичков, и его просто выучить.
Если и этого мало, то давайте не будем забывать, что именно Python стал основой для создания веб-сервисов и мобильных приложений, без которых мы не смогли бы делать ряд важных вещей ежедневно. Например, не смогли бы смотреть ролики на YouTube или следить за жизнью знаменитостей в Instagram, заказывать такси в Uber и юзать такие площадки, как Quora, Pinterest, Blender, Inkscape и Autodesk. Все они написаны на Python и, пожалуй, уже даже этот факт возводит его в «лик святых» языков программирования.
По этим и многим другим причинам мы привыкли, что в области машинного обучения (ML) и больших данных (Big Data) Python – это уже стандарт де-факто. Но, как только мы начинаем говорить о highload системах, тут же «всплывает» устоявшийся стереотип о том, что высоконагруженные системы надо делать на чем-то быстром. Чаще всего в таких случаях я слышу фразу: «Лучше взять сишечку! (*семейство языков программирования С/C++*) или, на худой конец, Java или C#». И когда я привожу в пример YouTube и говорю, что мы успешно делаем highload системы на Python, некоторые мои собеседники морщатся от удивления…
Давайте вместе ломать стереотип: на конкретном примере я расскажу, как правильно использовать Python в режиме Fast and Furious и построить на нем крутую архитектуру highload системы!
### Python vs пессимисты
В качестве задачи рассмотрим систему обработки событий или процессинга документов. Архитектура у них плюс-минус одинаковая и имеет следующий pipeline (ETL):
Для начала, решим задачу в лоб:
1. В качестве брокера возьмем Kafka;
2. В обработчике реализуем линейный процессинг сообщений из очереди на базе класса Kafka Consumer из библиотеки Kafka-Python;
3. Результат обработки запишем в СУБД MongoDb.
Имеем следующую схему:
Приведу небольшой code snippet, как это реализовать:
```
from kafka import KafkaConsumer
from pymongo import MongoClient
from json import loads
# создаем консьюмера
consumer = KafkaConsumer(
"raw_events",
bootstrap_servers=["localhost:9092"],
auto_offset_reset="earliest",
enable_auto_commit=True,
group_id="my-group",
value_deserializer=lambda x: loads(x.decode("utf-8")),
)
# открываем соединение к MongoDb
# получаем доступ к нашей коллекции событий – processed_events
client = MongoClient("localhost:27017")
collection = client.processed_events
# читаем из топика и пишем в базу
for message in consumer:
doc = message.value
collection.insert_one(doc)
```
Работает, но процессинг очереди идет слишком медленно! Пессимисты уже кричат: *«Все пропало! Что же нам теперь делать?»*. Мое решение простое и лаконичное – использовать процессный пул для параллельной обработки.
Чтобы понять, как это реализовать, приведу еще один короткий пример без лишних деталей. Задача – погрузить всю нашу логику обработки в пул воркеров, чтобы сделать процессинг параллельным, и вот как это выглядит:
```
from multiprocessing import Pool
def processing_func(msg):
# пишем тут в БД
store_data(msg)
# создаем пул воркеров из 16 процессов (лучше число ядер CPU х 2)
pool = Pool(16)
for message in consumer:
pool.apply_async(processing_func, (message,))
```
Давайте разберемся, как работает и что делает данный код:
1. Создает пул из 16 процессов
2. Читает очередь, но весь процессинг самих сообщений отдается воркерам из пула с помощью метода самого пула — apply\_async
3. Метод apply\_async принимает на вход функцию, которая, собственно, и делает весь процессинг. В нашем случае — пишет данные в БД.
Готово, все летает! «А можно еще быстрее?» — спросите вы. Ответ однозначный – легко! Давайте воспользуемся штатными возможностями партиционирования топиков в Kafka.
Напомню, разбивка топика по разделам (партициям) – это основной механизм параллелизма в Apache Kafka, который позволяет линейно масштабировать нагрузку на консьюмеров. Ключевыми моментами этой концепции являются следующие:
* каждый топик может иметь 1 или больше разделов, распараллеленных на разные узлы кластера (брокеры), чтобы сразу несколько консьюмеров могли считывать данные из одного топика одновременно;
* если число консьюмеров меньше числа разделов, то один консьюмер получает сообщения из нескольких разделов;
* если консьюмеров больше, чем разделов, то некоторые консьюмеры не получат никаких сообщений и будут простаивать;
* для повышения надежности и доступности данных в кластере Kafka, разделы могут иметь копии (реплики), число которых задается коэффициентом репликации (replication factor). Он показывает, на сколько брокеров-последователей (follower) будут скопированы данные с ведущего-лидера (leader);
* число разделов и коэффициент репликации можно настроить для всего кластера или для каждого топика отдельно.
Итак, добавим партиций (3 шт) для нашего топика raw\_events и на каждую партицию поставим отдельный экземпляр консьюмера (тоже 3 шт). Поскольку количество партиций можно динамически увеличивать, то имеем бесконечный горизонт масштабирования! Что может быть прекраснее?
**Подведем итоги:** мы получили отличную архитектуру для highload системы, затратив на это 5 минут времени. При этом, нам не пришлось менять любимый язык программирования, а значит, жертвовать гибкостью и скоростью разработки. | https://habr.com/ru/post/595739/ | null | ru | null |
# Все новинки Android 12. Обзор для разработчиков
> Привет. Меня зовут [Кирилл Розов](http://twitter.com/kirill_rozov) и вы если вы интересуетесь разработкой под Android, то скорее всего слышали о [Telegram канале "Android Broadcast"](https://t.me/android_broadcast), с ежедневными новостями для Android разработчиков, и [одноимённом YouTube канале](http://youtube.com/androidBroadcast). Этот пост является текстовой расшифровкой нового видео на канале
>
>
---
Прошла конференция Google I/O и мы узнали абсолютно всё про новую версию Android, а также всё это можно попробовать в Beta 1, которую на Pixel можно установить по воздуху, а также ряд других производителей позволяют установить GSI образ.
Основной упор в релизе был сделан на усиление безопасности ОС и приватности данных и редизайн системы. Очень хорошо поработали с поддержкой новых современных стандартов медиа, причём минимизировали объем боли которые будут испытывать флагманские устройства из-за старых или бюджетных смартфонов. App Widgets воскресили и сделали улучшения, которые просили еще с первой версии Android.
Дизайн
------
### Новый дизайн Material You
Google представила обновлённую версию Material Design, которая акцентирует внимание на персонализации цветовой палитры. Например, в Pixel устройствах цвета будут определяться на основе фоновой картинки. Полноценно попробовать Material You получится во второй Beta версии Android 12
Самый главный вопрос: "как вендоры будут адаптировать Material You в своих прошивках?" Есть вероятность что эта концепция цветов так и останется в чистом Android, а вендоры и сторонние приложения будут игнорировать дизайн и использовать свои собственные наработки. Вся палитра цветов в Material была основана на цветах бренда приложения, а сейчас должна задаваться пользователем. Хотя многое зависит как дизайнеры интерфейса приложений адаптируют новый дизайн. Пишите в комментариях как вам новый визуальный стиль Google
### Стандартный Splash Screen для всех приложений
SplashScreen API позволяет его кастомизировать для вашего бренда: задать фон, анимированную иконку и другие параметры. Отключить новый Splash Screen нельзя, поэтому у всех кого есть своя вариация такого экрана - обратите внимание.
Splash Screen - довольно популярная практика в Android приложениях чтобы скрыть долгую инициализацию. Теперь в Android появляется стандартный Splash Screen, который будет анимировать открытия приложения из иконки в launcher.
```
@color/...
@drawable/...
@color/...
@drawable/...
```
### Обновление эффектов UI
#### Ripple эффект
Обновление дизайна затронула многие аспекты UI системы, даже Ripple эффект обновился. Теперь в него добавили эффект аля "белый шум" по краям. Мне нравился старый одноцветный Ripple и новый выглядит странным и неестественным
Overscroll
----------
Новый эффект при достижении граница списке стал доступен в Android 12 для нативных (Android View) системы. Тем кто использует iOS новый эффект overscroll будет очень знаком.
RenderEffect API
----------------
Новое API, которое позволит делать размытия, цветовые фильтры и другие графические эффекты намного проще и эффективнее. Теперь добиться размытия окна как в iOS можно всего лишь одной строчкой API
```
// Задание эффекта для любой View
view.setRenderEffect(RenderEffect.createBlurEffect(radiusX, radiusY, SHADER_TILE_MODE))
```
```
// Размытие фона Window из кода
Window.setBackgroundBlurRadius(radius: Int)
```
```
// Задание размиытие фона в теме
<item name="android:windowBackgroundBlurRadius">15dp</item>
```
Виджеты
-------
В Android 12 значительно переработали API виджетов рабочего стола. Мне кажется, что появление этого функционала в iOS 14 подстегнуло Google обратить внимание на жалобы разработчиков на это API еще с самой первой версии Android. Что теперь появилось:
* Закруглённые края у фона всех виджетов на Android 12+
* Виджеты могут использовать динамические цвета из темы, которые являются нововведением Material You
* Начальная настройка виджета может быть необязательной и этот этап может пропускаться
* Добавлена поддержка CheckBox, Switch и RadioButton. Обрадоваться могу разные Todo списки и приложения, где есть настройки через тумблеры
```
```
* На превью виджета теперь можно ставить не только статическую картинку, но и верстать UI в XML и добавлять описание
```
* Анимации при открытии приложения по клику на виджет. Фон виджета будет трансформироваться в фон окна открываемой Activity
* Упрощение API для работы со списками в виджетах
* Большое руководство по обратной совместимости для виджетов до Android 12 и после
Помимо прочего нам обещают библиотеку для написания виджетов в DSL стиле подобно Compose, с поддержкой старых версий Android. Это будет специальное DSL, которое конвертируется в иерархию View, но уже приятно что Compose стиль будет идти и в существующий функционал системы.
Rounded Corner API
------------------
Rounded Corner API позволит получать информацию о дисплеях с закруглениями и размещать свой контент безопасно, чтобы он не обрезался.
Пример, который приводит Google, для смещения контента на основе полученной информации о закруглениях не выглядит маленьким, но зато теперь хотя бы есть возможность.
```
// Get the top-right rounded corner from WindowInsets.
final WindowInsets insets = getRootWindowInsets();
final RoundedCorner topRight = insets.getRoundedCorner(POSITION_TOP_RIGHT);
if (topRight == null) {
return;
}
// Get the location of the close button in window coordinates.
int [] location = new int[2];
closeButton.getLocationInWindow(location);
final int buttonRightInWindow = location[0] + closeButton.getWidth();
final int buttonTopInWindow = location[1];
// Find the point on the quarter circle with a 45 degree angle.
final int offset = (int) (topRight.getRadius() * Math.sin(Math.toRadians(45)));
final int topBoundary = topRight.getCenter().y - offset;
final int rightBoundary = topRight.getCenter().x + offset;
// Check whether the close button exceeds the boundary.
if (buttonRightInWindow < rightBoundary && buttonTopInWindow > topBoundary) {
return;
}
// Set the margin to avoid truncating.
int [] parentLocation = new int[2];
getLocationInWindow(parentLocation);
FrameLayout.LayoutParams lp = (FrameLayout.LayoutParams) closeButton.getLayoutParams();
lp.rightMargin = Math.max(buttonRightInWindow - rightBoundary, 0);
lp.topMargin = Math.max(topBoundary - buttonTopInWindow, 0);
closeButton.setLayoutParams(lp);
```
### Rich Content Insertion
Шаринг контента между разными приложениями - важная возможность любой системы. Google упрощает жизнь разработчиков и теперь вместо трёх отдельных API вставки содержимого через drag-&-drop, изображений из клавиатуры и буфера обмена мы получили один - Rich Content Insertion. Также compat API OnReceiveContentListener уже добавлено в Jetpack Core 1.5.0, который вышел в Stable.
Уведомления
-----------
Какое обновления Android без переработки уведомлений. Для начала снова поменялся их шаблон и появилось несколько новых возможностей:
* В [MessagingStyle](https://developer.android.com/reference/kotlin/android/app/Notification.MessagingStyle) и [BigPictureStyle](https://developer.android.com/reference/kotlin/android/app/Notification.BigPictureStyle) можно добавлять анимированные картинки
* Действия на уведомлениях во время показа их на экране блокировки можно потребовать обязательной авторизации пользователя перед отправкой Intent
* Новый стиль уведомлений для звонков - [CallStyle](https://developer.android.com/reference/kotlin/android/app/Notification.CallStyle), который позволяет создать разные стили для входящего, исходящего и текущего звонка. Также можно задавать важность для звонков
* Зона в уведомлении, выделяемая для Custom View, теперь становится меньше.
#### Запрет "трамплинов" в уведомлениях
Под трамплином понимается случай когда нажатие на уведомление приводит к запуску Activity, но делается это не напрямую. Например, вы сначала запускаете BroadcastReceiver, а из него уже стартует Activity. Для улучшения производительности и UX теперь так делать запрещено. Хотите запустить Activity из уведомления - делайте это напрямую. В противном случаи ничего происходит не будет, а в логи упадёт ошибка
```
Indirect notification activity start (trampoline) from PACKAGE_NAME, \
this should be avoided for performance reasons.
```
Медиа
-----
### Поддержка AVIF
Поддержка изображений формата изображений AV1, а точнее файлов AVIF. Этот формат пришёл из видео и использует все его преимущества компрессии и обеспечивает более высокое качество картинок и детализацию при одинаковом размере с JPG. Сможем ли снимать фото в таком формате?
### Compatible Media Transcoding
В Android 12 появляется возможность для любого приложения воспроизводить современные форматы видео, которые могут записать устройства без всяких проблем. Android сможет конвертировать HEVC (H.265) to AVC (H.264), а также HDR10 в SDR. Вам надо создать новый XML файл в ресурсах вашего приложения с описанием поддержки современных форматов, а затем добавить ссылку на него в AndroidManifest.
```
xml version="1.0" encoding="utf-8"?
```
Новая функция позволяет устройствам создать видео в современных форматах на устройствах и преобразовывать его автоматически для отсутствия проблем использования такого контента у приложений.
Скорость конвертации видео довольно быстрая - ролик длиной одну минуту в разрешение 1080p 30 кадров в секунду конвертируется 9 секунд на Pixel 4. Напомню, что в Pixel 4 стоит флагманский процессор Snapdragon 845 и 6 гигов оперативы. Так что результаты на середнячках могут быть хуже (
### Performance Class
Начиная с Android 12, появляется новый стандарт Performance Class. Он описывает набор возможностей устройства, который являются минимальный требуемой для версии Android. Разработчики могут проверить класс производительности и изменить настройки, чтобы предоставлять лучший пользовательский опыт для устройства пользователя.
```
if (Build.VERSION.MEDIA_PERFORMANCE_CLASS >= Build.VERSION_CODES.S) {
// Provide the most premium experience for highest performing devices
...
}
else if (Build.VERSION.MEDIA_PERFORMANCE_CLASS == Build.VERSION_CODES.R)
// Provide a high quality experience
...
}
else {
// Remove extras to keep experience functional
...
}
```
Class 12 будет опубликован с релизом Android 12 и будет включать в себя требования по возможностям проигрывания видео, возможности съемки контента, а также характеристики дисплея, скорости чтения/записи на диск и оперативной памяти. С каждой новой версией будет повышаться класс и обновляться требования, но даже на Android 13 может остаться class 12, если не будет соответствия новым требованиям.
### Прочее
* Генерации виброотдачи на основе аудио потока. Очень полезна будет для игр
* Добавили возможность использовать камеры с высоким разрешением т.е. делать сразу снимки 108 мегапикселей и других огромных размеров.
* При переключении аудио между приложениями будет происходить затухание громкости, а не резкая пауза
* Camera2 API теперь содержит расширения для использования спец режимов аналогично CameraX Extentions
Безопасность и приватность
--------------------------
### Примерное местоположение
В Android 11 появилась возможность давать разрешение на доступ к геолокации только во время использования приложения и на один раз. Этими возможностями воспользовалось 80% пользователей. Google развивает идею контроля пользователем доступа приложений к местоположению. В Android можно запросить точное и примерное местоположение, так вот теперь при запросе точной позиции, пользователь может отказать, но выдать доступ к примерному местоположению.
Изменение будет действовать только для приложений с targetSdk=S, так как разработчикам приложений, запрашивающих доступ к точному местоположению надо поменять свой код обработке получения.
```
val locationPermissionRequest = registerForActivityResult(
ActivityResultContracts.RequestMultiplePermissions()
) { permissions ->
when {
permissions.getOrDefault(Manifest.permission.ACCESS_FINE_LOCATION, false) -> {
// Точное местоположение
}
permissions.getOrDefault(Manifest.permission.ACCESS_COARSE_LOCATION, false) -> {
// Примерное местоположение
} else -> {
// Нет доступа к локации
}
}
}
// ...
locationPermissionRequest.launch(
arrayOf(
Manifest.permission.ACCESS_FINE_LOCATION,
Manifest.permission.ACCESS_COARSE_LOCATION
)
)
```
Если вам всё же нужно точное местоположение, а пользователь ранее уже выдал примерное, то при повторном запросе пользователю будет предложено дать вам доступ только на точное местоположение.
### Отдельное разрешение для Nearby сканирования через Bluetooth
В текущих версиях Android если вы хотите сканировать устройство поблизости с помощью Bluetooth, то вам приходилось запрашивать разрешение на доступ к местоположению, что порой вводило в заблуждение пользователей. Наконец-то в Android 12 эти разрешения будут отделены в новые: BLUETOOTH\_SCAN и BLUETOOTH\_CONNECT. BLUETOOTH\_SCAN используется для доступа в случае поиска Bluetooth устройств, а BLUETOOTH\_CONNECT - когда вам надо подключиться к устройствам с которыми уже связанными устройствами.
Если на основе сканирования вам всё также будет нужен доступ к местоположению, тогда без запроса на доступ к местоположению вам не обойтись.
### Exact alarm permission
Выполнение операций в заданное время - боль Android разработчиков. Каждый из них делает свои оптимизации энергопотребления, которые заставляют на каждой оболочке отключать их по своему, а приложение должно показать инструкцию. Возможно нас ждёт улучшение в работе точного срабатывания alarm-ов, так как теперь в системе появится разрешение [SCHEDULE\_EXACT\_ALARM](https://developer.android.com/reference/android/Manifest.permission#SCHEDULE_EXACT_ALARM), без получения которого вызовы exact alram-ов в AlarmManager будет приводить к выбрасыванию SecurityException.
Новый permission не является runtime, а это значит что за его получением придется отправлять пользователя в настройки системы.
Приложения должны использовать новый тип alarm-ов только если это критический функционал. Например, будильники или таймеры, а также приложения, которые содержат функционал с требованием вызывать в точное время. Возможно даже в Google Play не станут допускать все приложения.
```
// Пример открытия настроек excat alarm для приложения
if (!alarmManager.canScheduleExactAlarms()) {
startActivityForResult(
Intent(Settings.ACTION\_REQUEST\_SCHEDULE\_EXACT\_ALARM, "package:")
)
}
```
### Отслеживание доступа к Clipboard
Теперь система следит за доступом к буферу обмена, и когда фоновое приложение будет пытаться оттуда получить данные будет выдано уведомление. Хорошее нововведение, которое не даст следить за вашими данными. Часто используйте copy-paste для важных данных? Я вот порой пользуюсь для паролей и стало немного страшно что может делаться сейчас.
### Ограничения на использование Foreground Service
Главное изменение Android 12, которое доставит работы Android разработчикам - теперь Foreground Service нельзя запустить из фона, за исключением нескольких случаев. В случае неудачной попытке запуска Service приложение будет падать с исключением `ForegroundServiceStartNotAllowedException`.
Какие случае исключительные:
* High Priority Push
* Как реакция на broadcast-ы `ACTION_BOOT_COMPLETED`, `ACTION_LOCKED_BOOT_COMPLETED`, или `ACTION_MY_PACKAGE_REPLACED`
* Приложение имеет специальные разрешения или роли
* Приложение игнорирует оптимизации батареи
* Exact alarm
и некоторый другие специфичные случаи
На замену предлагается использовать новое API Expedited Jobs, которое уже было добавлено в WorkManager 2.7.0. На Android 12 и более поздних версиях будет вызывать соответствующие API из JobScheduler, а на старых версиях Android будет запускаться Foreground Service.
```
OneTimeWorkRequestBuilder().apply {
setInputData(inputData)
setExpedited(OutOfQuotaPolicy.RUN\_AS\_NON\_EXPEDITED\_WORK\_REQUEST)
}.build()
```
Expedited job позволяет приложение выполнять короткие важные задачи, предоставляя системе лучшее управление доступом к ресурсам. Expedited Job по своим характеристикам находится между Foreground Service и обычной job из JobScheduler:
* Короткий период - пара минут. Если ваша job будет выполняться дольше, система может остановить выполнение expedited job.
* Expedited job менее подвержены эффектам от менеджмента системой экономии расхода батареи, таких как Battery Saver и Doze Mode.
* Система запускает expedited job сразу же, если в системе имеется достаточно для этого ресурсов и количество уже запущенных job не превышает лимит, установленный в системе, и в хватает свободной оперативной памяти. Эти требования более строгие чем для других типов job.
### Уведомления Foreground Service будут показываться с задержкой
Как часто вы видите уведомления, которые появляются на пару секунд и исчезают? Может вы сами делали такие своим кодом? Бывалый разработчик знает что это Foreground Service, который выполняет свою работу быстро и поэтому уведомление показывается и быстро исчезает. В Android 12 уведомление, связанное с Foreground Service, не будет показываться в течении первых 5 секунд. Улучшение направлено на UX и надеюсь что будет позитивно воспринято пользователям. Конечно же есть исключения из правила, например, если у уведомления есть кнопки действий, то оно будет показано сразу. Разработчик может явно указать что уведомление нужно показать сразу c помощью нового API в Notification.Builder.**setForegroundServiceBehavior().**
```
Notification.Builder(context)
.setForegroundServiceBehavior(Notification.BEHAVIOR_IMMEDIATE_DISPLAY)
.build();
```
### Индикатор использования микрофона и камеры
Современные версии Android и iOS активно заимствуют идеи друг у друга, так вот и новая возможность системы реализована аналогично iOS. Когда приложения будут использовать камеру или микрофон, то в status bar будет появляться индикатор, который не позволит делать что-то в фоне. Помимо прочего пользователь в любой момент сможет отключить доступ к камере и микрофону всем приложениям, с помощью тоглов.
### Privaсy Dashboard
Новая функциональность Android 12 позволит пользователям видеть история доступа всеми приложениями к местоположению, микрофону и камере. Функционал будет доступен во второй Beta.
### Гибернация приложений
В Android 11 автоматический сброс разрешений неиспользуемым приложениям зашёл успешно и держите развитие фичи - гибернация приложений. Если пользователь не будет взаимодействовать с вашим приложением очень долго (несколько месяцев), то система сбросит все полученные разрешения и отправит его в гибернацию:
* Будет очищен кэш приложения
* Приложение не сможет запускать job или alert в фоне
* Приложение не будет получать push уведомления, включая high-priority FCM
После первого взаимодействия с вашим приложением все ограничения будут сняты, но вам надо будет заново создать job, alarm и уведомления, которые вам необходимы. Поведение схоже когда пользователь принудительно останавливает приложения в настройках
Вы можете запросить у пользователя отключить настройку "Отзывать разрешения и очищать память" в настройках, если ваше приложение подразумевает работу в фоне, например отправка местоположения между членами семьи или приложения для устройства-компаньона.
Ограничение частоты получения данных с сенсоров движения
--------------------------------------------------------
По умолчанию данные с различных сенсоров, таких как акселерометр, гироскоп и других будут приходить с частотой 200 Гц или реже. Чтобы вы смогли получать данные как прежде вам надо в манифесте декларировать новое разрешение [HIGH\_SAMPLING\_RATE\_SENSORS](https://developer.android.com/reference/android/Manifest.permission#HIGH_SAMPLING_RATE_SENSORS), но запрашивать у пользователя его не придётся.
### Объявление exported у всех компонентов в Manifest
Для всех компонентов в AndroidManifest теперь вы должны явно объявлять значение `android:exported=true|false`, который отвечает за доступность компонента другим приложениям. По умолчанию значение этого атрибута false, но если хотя бы один intent-filter будет объявлен у компонента, то значение поменяется на true. Такое уязвимостью пользовались злоумышленники, например так взломали авторизацию Slack.
В случае если у вас будет targetSdk=S и у какого-то компонента не будет объявлено значение exported, то установка не завершится, а в Logcat вы увидите сообщение.
```
Installation did not succeed.
The application could not be installed: INSTALL_FAILED_VERIFICATION_FAILURE
List of apks:
[0] '...app-debug.apk'
Installation failed due to: 'null'
```
Android Studio 2020.3.1 Arctic Fox содержит Android Lint проверки для того чтобы вы не пропустили ничего. Важно чтобы обновились сторонние библиотеки, которые содержат компоненты. В противном случае вам нужно будет использовать возможности Manifest Merger и задать значение exported самостоятельно.
Прочие
------
Много интересных изменений произошло в Android 12, но вместить все их в видео я не смогу, так что ловите ещё изменений в быстром формате:
* ART теперь обновляется независимо от системы
* В стандартном Build классе появились новые константы, которые позволяют получить производителя чипа и его модель ([подробности](https://developer.android.com/about/versions/12/features#soc-info)).
* Появился [новый App Standby bucket - Restrictive](https://developer.android.com/about/versions/12/behavior-changes-all#restrictive-app-standby-bucket). Он будет являться самым строгим и будет иметь больше всего ограничений
* Удалены [Bouncy Castle](https://developer.android.com/about/versions/12/behavior-changes-all#bouncy-castle) реализации криптографических алгоритмов
* [Backup и восстановление](https://developer.android.com/about/versions/12/backup-restore) данных разделили для локального бэкапа (по проводу) и облачного, а также обновили возможности конфигурации.
* При создании любого [PendingIntent](https://developer.android.com/about/versions/12/behavior-changes-12#pending-intent-mutability) теперь явно нужно указывать мутабельный он или нет
* [Улучшения поведения в PiP](https://developer.android.com/about/versions/12/features/pip-improvements) и новые возможности
* Web intent теперь будет открываться в приложении только если приложение является одобренным этим доменом. Используйте Android App Links, либо открывать системные настройки приложения и просить пользователя добавить domain в одобренные
* Поддержка SameSite куков в WebView
* Private Compute Core - изолированная от ОС среда для процессинга данных пользователя. Например, Smart Reply. У неё нет доступа к инету и исходный код открыт. Идея в том чтобы обрабатывать данные пользователя на устройстве без возможности их утечки куда-либо.
* Добавлена возможность приложениям автоматически обновлять другие приложения. Раньше это мог делать только Google Play
---
Выход Android 12 запланирован на осень этого года, но еще до этого времени нас жжёт несколько Beta версий, которые порадуют новинками, показанными на Google I/O. Помните, что с выходом Android 12 надо будет адаптировать свои приложения под Android 11. В комментариях я жду ваших впечатлений от Android 12: что понравилось, что нет, а чего еще ждали от обновления зеленого робота
``` | https://habr.com/ru/post/560302/ | null | ru | null |
# Микрооптимизации важны: предотвращаем 20 миллионов системных вызовов
Эта публикация — логическое продолжение поста «[Как настройка переменной окружения TZ позволяет избежать тысяч системных вызовов](https://blog.packagecloud.io/eng/2017/02/21/set-environment-variable-save-thousands-of-system-calls/)». Здесь мы рассмотрим характерную ситуацию, когда микрооптимизации (например, удаление системного вызова) очень сильно влияют на производительность.
Что такое заметное улучшение?
-----------------------------
Ранее мы описали [переменную окружения, которую может настраивать приложение, чтобы избежать тысяч дополнительных системных вызовов](https://blog.packagecloud.io/eng/2017/02/21/set-environment-variable-save-thousands-of-system-calls/). Эту статью встретили справедливыми вопросами с некоторой долей скепсиса:
* «Тонко, но разве удаление единственного системного вызова заметно повлияет на производительность всей программы?»
* «Это выглядит ненужным; в Linux системные вызовы и так выполняются быстро».
Трудно сказать, что каждый из разработчиков вкладывает в понятие «заметное улучшение» применительно к конкретному приложению. Разработчики ядра и драйверов часто тратят немало времени на микрооптимизацию кода и структур данных, чтобы как можно полнее использовать кеш процессора и снизить потребление самого CPU. Даже если большинство программистов сочтут выгоду очень незначительной. Нужно ли уделять меньше внимания таким оптимизациям? Кто-то может вообще сказать, что микрооптимизации нельзя расценивать как заметные.
В рамках этой статьи определим заметное как легко измеряемое и совершенно очевидное. Можем ли мы показать реальный пример, когда удаление из кода фрагмента (code path) медленного ([без vDSO](https://blog.packagecloud.io/eng/2016/04/05/the-definitive-guide-to-linux-system-calls/#virtual-system-calls)) системного вызова приводит к легко измеряемому и совершенно очевидному результату?
Есть множество реальных примеров: от снифферов пакетов до сред выполнения (runtime) программных языков. Рассмотрим такой печально известный случай, как влияние `sigprocmask` на runtime языка Ruby.
Что такое `sigprocmask`?
------------------------
`sigprocmask` — системный вызов, используемый для проверки или настройки сигнальной маски текущего процесса. Он позволяет программе блокировать или разрешать сигналы, что бывает полезно, когда нужно выполнить критически важный кусок кода, работу которого нельзя прерывать.
Это не особенно сложный системный вызов. [Код ядра, относящийся к sigprocmask](https://github.com/torvalds/linux/blob/v4.10/kernel/signal.c#L2541-L2576), говорит нам, что вызов записывает `sigset_t` в C-структуру, содержащую состояние текущего процесса (в ядре называется как `task_struct`). Это очень быстрая операция.
Давайте создадим простую тестовую программу, которая в маленьком цикле вызывает `sigprocmask`. Измерять будем с помощью `strace` и `time`:
```
#include
#include
int
main(int argc, char \*argv[])
{
int i = 0;
sigset\_t test;
for (; i < 1000000; i++) {
sigprocmask(SIG\_SETMASK, NULL, &test);
}
return 0;
}
```
Компилируем с помощью `gcc -o test test.c`. Сначала выполняем с `time`, а затем — со `strace` и `time`.
На моей тестовой системе:
* Выполнение `time ./test` показало: 0,047 секунды — реальное время, 0,012 секунды — пользовательское время, 0,036 секунды — системное время.
* Выполнение `time strace -ttT ./test` показало: 52,364 секунды — реальное время, 9,313 секунды — пользовательское время, 14,349 секунды — системное время.
В случае со `strace` для каждого вызова `sigprocmask` (в вашей системе наверняка будет отображаться как `rt_sigprocmask`) будут продемонстрированы приблизительные значения длительности выполнения. Они очень малы. На моей тестовой системе я получил в большинстве случаев значения в районе 0,000003 секунды — с неожиданным всплеском до 0,000074 секунды.
Довольно трудно измерить точное время выполнения системного вызова по целому ряду причин. Они выходят далеко за пределы вопроса, обсуждаемого в этой статье. Так что можем предположить, что все измерения были проведены в равной мере некорректно.
Итак, что мы уже знаем:
* `sigprocmask` — системный вызов, используемый для настройки или проверки сигнальной маски текущего процесса.
* Код ядра прост и должен выполняться очень быстро.
* Результаты измерений с `time` и `strace` показывают, что при выполнении в маленьком цикле миллиона вызовов sigprocmask каждый вызов занимает очень мало времени.
Так зачем нам избавляться от дополнительных `sigprocmask`, будет ли это стоить наших усилий?
Разберёмся подробнее
--------------------
Иногда чужой код, который мы используем в своих приложениях (системные библиотеки, ядро, glibc и т. д.), делает неожиданные вещи или имеет неочевидные на первый взгляд побочные эффекты. В качестве примера ниже я покажу, как косвенное использование `sigprocmask` в тестовой программе приводит к серьёзному снижению производительности. А затем продемонстрирую, как это проявляется в реальном приложении.
С Ruby 1.8.7 был связан один из самых ярких примеров того, как дополнительные вызовы `sigprocmask` приводили к очевидному и легко измеряемому снижению производительности. Это отмечалось в тех случаях, когда код компилировался с одним конкретным флагом `configure`.
Начнём со значений конфигурационных флагов по умолчанию, которые использовались на большинстве ОС (Debian, Ubuntu и т. д.) во времена широкого распространения Ruby 1.8.7.
Тестирование `sigprocmask`
--------------------------
Взгляните на тестовый код:
```
def make_thread
Thread.new do
a = []
10_000_000.times do
a << "a"
a.pop
end
end
end
t = make_thread
t1 = make_thread
t.join
t1.join
```
Тут всё просто: создаём два потока выполнения, каждый из которых 10 миллионов раз добавляет и удаляет данные из массива. Если запустить со значениями конфигурационных флагов по умолчанию и `strace`, то получим удивительные результаты:
```
$ strace -ce rt_sigprocmask /tmp/test-ruby/usr/local/bin/ruby /tmp/test.rb
Process 30018 attached
Process 30018 detached
% time seconds usecs/call calls errors syscall
------ ----------- ----------- --------- --------- ----------------
0.50 0.139288 0 20033025 rt_sigprocmask
```
Виртуальная машина Ruby сгенерировала больше **20 миллионов** системных вызовов `sigprocmask`. Вы скажете: «Но ведь они заняли очень мало времени! Что в этом такого?»
Как уже упоминалось, не так просто измерить длительность системного вызова. Перезапустим тестовую программу с `time` вместо `strace` и посмотрим, сколько времени займёт её завершение на моей системе:
```
$ time /tmp/gogo/usr/local/bin/ruby /tmp/test.rb
real 0m6.147s
user 0m5.644s
sys 0m0.476s
```
Около 6 секунд реального выполнения. То есть около 3,3 миллиона вызовов `sigprocmask` в секунду. Ого.
А если настроить один флаг `configure`, то виртуальная машина Ruby будет собирать систему, избегая вызовов `sigprocmask`!
Перезапустим тесты со `strace` и `time`, но в этот раз немножко подкрутим Ruby, чтобы он избегал вызовов `sigprocmask`:
```
$ strace -ce rt_sigprocmask /tmp/test-ruby-2/usr/local/bin/ruby /tmp/test.rb
% time seconds usecs/call calls errors syscall
------ ----------- ----------- --------- --------- ----------------
-nan 0.000000 0 3 rt_sigprocmask
```
Круто! Мы снизили количество вызовов `sigprocmask` с 20 миллионов до 3. Похоже, у `strace` были проблемы с вычислением времени выполнения системных вызовов :(
Посмотрим, что скажет `time`:
```
$ time /tmp/test-ruby-2/usr/local/bin/ruby /tmp/test.rb
real 0m3.716s
user 0m3.692s
sys 0m0.004s
```
Примерно на 40 % быстрее (реальное время выполнения), чем в предыдущем примере, и менее одного вызова `sigprocmask` в секунду.
Отличный результат, но возникает несколько вопросов:
* Не является ли пример немного надуманным?
* Когда это действительно актуально в реальных проектах?
* Что именно при настройке флагов `configure` приводит к снижению количества вызовов?
Давайте сначала рассмотрим реальный пример, а потом разберёмся с подробностями.
Реальный пример: Puppet
-----------------------
[Найденный в Puppet баг](https://projects.puppetlabs.com/issues/1781) точно демонстрирует влияние дополнительных вызовов `sigprocmask` на работу виртуальной машины Ruby:
*Я только что столкнулся с серьёзной проблемой, связанной с производительностью. Puppet очень медленно работает.*
*Первый пример:*
```
$ time puppet —version 0.24.5
real 0m0.718s user 0m0.576s sys 0m0.140s
```
*В это время совершались сотни, если не тысячи вызовов rt\_sigprocmask(SIG\_BLOCK, NULL, [], 8). И всё это ради отображения версии.*
Если вы почитаете переписку, то обнаружите и [другие комментарии](https://projects.puppetlabs.com/issues/1781#note-9), в которых люди жалуются на низкую производительность Puppet. Той же проблеме посвящены и [вопросы на Stackoverflow](http://serverfault.com/questions/514827/puppet-hang-on-100-cpu-usage).
Но это проблема не только Ruby и Puppet. О [подобных багах](https://secure.phabricator.com/T4627) пишут и пользователи других проектов, сообщая о полной загрузке процессора и сотнях тысяч вызовов `sigprocmask`.
Почему так происходит? Легко ли это исправить?
----------------------------------------------
Дело в том, что вызовы `sigprocmask` осуществляются двумя функциями из glibc (не являющимися системными вызовами): `getcontext` и `setcontext`.
Они применяются для сохранения и восстановления состояния процессора. Их широко используют программы и библиотеки, реализующие обработку исключений или потоки выполнения в пользовательском пространстве. В случае с Ruby 1.8.7 `setcontext` и `getcontext` нужны в реализации потоков выполнения в пользовательском пространстве — для переключения контекста между потоками.
Вы можете подумать, что эти две функции должны выполняться довольно быстро. Ведь они всего лишь сохраняют или восстанавливают маленький набор регистров процессора. Да, сохранение — операция очень быстрая. Но, судя по всему, реализация этих функций в glibc такова, что для сохранения и восстановления сигнальной маски используются системные вызовы `sigprocmask`.
Вспомним, что Linux предоставляет механизм ([vDSO](https://blog.packagecloud.io/eng/2016/04/05/the-definitive-guide-to-linux-system-calls/#virtual-system-calls)), который вместо ядра отвечает за выполнение определённых системных вызовов. Это позволяет снизить стоимость их выполнения. К сожалению, `sigprocmask` не входит в их число. Все системные вызовы `sigprocmask` приводят к переходу (transition) из пользовательского пространства в ядро.
Стоимость такого перехода гораздо выше стоимости других операций в `setcontext` и `getcontext` (представляющих простые записи в память). Если очень часто вызывать эти функции, то вы будете выполнять медленную операцию (в этом случае — системный вызов `sigprocmask`, который [не проходит через vDSO](https://blog.packagecloud.io/eng/2016/04/05/the-definitive-guide-to-linux-system-calls/#virtual-system-calls)) каждый раз, когда вам нужно сделать что-то быстро (например, сохранить или восстановить набор регистров процессора для переключения потоков выполнения).
Почему изменение конфигурационного флага улучшает ситуацию?
-----------------------------------------------------------
Во времена широкого использования Ruby 1.8.7 по умолчанию использовался флаг `--enable-pthread`, активирующий на уровне ОС отдельный поток выполнения, который запускался по таймеру (timer thread). Он стартовал по мере необходимости для перехвата (pre-empt) виртуальной машины Ruby. Таким образом машина узнавала, что пришло время переключиться между потоками выполнения в пользовательском пространстве, которые были сопоставлены (mapped) с потоками, созданными в Ruby-программах. Также обращение к `--enable-pthread` приводило к тому, что скрипт `configure` находил и использовал функции `getcontext` и `setcontext`.
Без `--enable-pthread` скрипт `configure` будет искать и использовать `_setjmp` и `_longjmp` (обратите внимание на подчёркивания). Эти функции не сохраняют и не восстанавливают сигнальную маску, а следовательно, и не генерируют системные вызовы `sigprocmask`.
Итак:
* `--enable-pthread` и `--disable-pthread` предназначались для управления многопоточностью в пользовательском пространстве виртуальной машины Ruby: применялся либо поток выполнения на уровне ОС, либо простой сигнал `VTALRM`, уведомляющий ВМ, что пора переключиться на выполнение другого потока Ruby.
* Неожиданным побочным эффектом переключения между этими двумя методами перехвата (pre-empt) стало то, что примитивы для реализации переключения искали либо `setcontext/getcontext`, либо `_setjmp/_longjmp`.
* Это приводило к тому, что если использовалась пара `setcontext/getcontext`, то выполнялись дополнительные вызовы `sigprocmask`.
* А это, в свою очередь, снижало производительность.
* С чем и столкнулись создателя ряда проектов, включая Puppet.
И всё это из-за одного флага, который включает или отключает единственный системный вызов.
Заключение
----------
Микрооптимизации важны. Но степень их важности, конечно, зависит от специфики самого приложения. Имейте в виду, что библиотеки и код, от которых вы зависите, могут делать то, чего вы не ожидаете (например, выполнять медленный системный вызов). Если вы будете знать, как выявлять и исправлять подобные проблемы, то это окажет огромное влияние на ваших пользователей. А в некоторых случаях — на пользователей ваших пользователей. | https://habr.com/ru/post/324466/ | null | ru | null |
# 4 главных вещи, которые я не знал перед выходом на стажировку в разработку
Всем привет! Меня зовут Даниил, и я программист-самоучка.
В разработку я хотел попасть давно, но, как это часто бывает, не слишком-то верил в свои силы. Я полагал, что мой поезд давно ушел, и мозги уже не те, чтобы освоить эту сложную профессию. К счастью, меня переубедили, более того, мне дали шанс показать себя и взяли на стажировку в отдел разработки. Это случилось так буднично и просто, что сначала я не мог в это поверить. Мне все время казалось, что вот сейчас-то все наконец поймут, что я неуч и помашут ручкой на прощание. Но этого не произошло, меня продолжали поддерживать, и я изо всех сил старался никого не подвести.
Я стажируюсь в нашем бэкенд-отделе, который занимается продуктами для трекинга и параллельно работаю в своем родном отделе технической интеграции (вот уже на протяжении 6 месяцев). Основной язык в команде — [Python](https://www.python.org/). Его я учил самостоятельно, чтобы попасть на стажировку. В основном, конечно, по мануалам и роликам в Интернете.
У меня была небольшая база — я написал несколько учебных проектов на Си, но в целом не могу сказать, что был хоть сколь-то опытным кодером, когда меня приняли на стажировку. С высоты этого скромного опыта я и хотел бы рассказать вам о паре вещей, которые не знал или почти не знал на старте.
### Командная работа с Git
Когда человек приходит на свою первую стажировку, он представляет себе, что такое Git (иначе его вообще вряд ли возьмут), однако слабо представляет, как с ним работают в команде. Все мы создавали в свое время аккаунт на GitHub и радостно коммитили в master-ветку первую строчку кода, чувствуя себя настоящими профи. Так вот: это не лучший подход для больших проектов.
В командной разработке работа с Git ведется в соответствии с утвержденным [git-flow](https://nvie.com/posts/a-successful-git-branching-model/). У нас, например, есть две ветки: develop и master. Никто, кроме тимлида, не может заливать код в master-ветку, потому что команда должна гарантировать, что там лежит рабочий код, который при деплое не разрушит прод. Ответственность за это ляжет на плечи тимлида, а тимлида злить не хочет никто.
Чтобы предотвратить такие ситуации, существует командное ревью. Каждый разработчик ведет работу над задачей в своей собственной ветке и в конце работы ставит merge request в develop-ветку. А тимлид уже ставит merge request в master-ветку и отвечает за качество кода перед его владельцем. Таким образом гарантируется чистота кода, который попадает в конечном итоге на прод, и минимизируются риски залить что-то, что испортит работу проекта.
> **Вывод:** если вы хотите лучше подготовиться к работе в команде, почитайте о git-flow и начните добавлять новые коммиты в свой пет-проект через ветки.
### Архитектура кода важна
Когда я пришел на стажировку, я ожидал, что мне будут говорить, что делать, дадут какую-нибудь маленькую функцию или юнит-тесты, и я буду работать над ними под присмотром команды.
Однако все сложилось иначе. Нет, никто не поручил мне что-то ультрасложное, но мне назначили мини-проект (milestone) по мониторингу (Python + [Prometheus](https://prometheus.io/) + [Grafana](https://grafana.com/)), который я должен был сделать за время стажировки. Причем я сам должен был продумать архитектуру, декомпозировать проект на задачи и двигать его по стадиям Канбана. Это было волнительно, но очень правильно. Такой подход позволил моему куратору и мне самому отчетливо понять, с чем у меня проблемы, и приступить к их исправлению.
Скажу честно: первое мое решение было неудачным. И второе тоже. Я делал слишком крупные задачи, несколько раз возвращал их в бэклог, выстраивал неудачную архитектуру и не мог учесть нюансы.
Однако на данный момент большая часть проекта уже реализована, и я все отчетливее понимаю, как мой код влияет на остальной проект. Это захватывает. Я прочитал несколько статей о чистой архитектуре, изучил абстрактные классы, научился сначала планировать интерфейс и только потом приступать к реализации. Не могу сказать, что я во всем разобрался, но точно лучше понял фразу «Любую проблему можно решить введением дополнительного уровня абстракции, кроме проблемы чрезмерного количества уровней абстракции». А еще я научился правильно оценивать свои силы (но это не точно).
> **Вывод:** интересуйтесь архитектурой кода. Ничего страшного, если поймете не сразу, это вопрос контекста. Почитайте, как [спроектирован](https://medium.com/@narengowda/netflix-system-design-dbec30fede8d) Netflix, или загляните на [сайт](https://martinfowler.com/tags/application%20architecture.html) Мартина Фаулера. Попробуйте спроектировать небольшую систему до того, как сядете писать код.
### Умение работать с окружением упрощает жизнь
В нашей компании все сервисы запускаются в контейнерах. Соответственно, каждый разработчик должен понимать, как работает тот же [Docker](https://www.docker.com/), как написать простой [Dockerfile](https://docs.docker.com/engine/reference/builder/) или поднять свои сервисы через [Docker Compose](https://docs.docker.com/compose/).
Человеку, который пишет только для себя и на своем компьютере, тяжело понять, зачем нужна контейнеризация. Однако на больших проектах необходимо обеспечить работу кода вне зависимости от окружения. Чуть позднее, когда вы разберетесь с азами, станет очевидно, насколько это удобно. Вам не нужно устанавливать зависимости в свое окружение, нет нужды долго и сложно запускать проект. Вы можете запускать тесты или разделить прод и dev, просто единожды написав пару конфигураций.
В этот же совет можно включить и работу с IDE. До начала стажировки я писал все свои программы исключительно в Emacs, но, когда начал работу, решил перейти на более продвинутый инструмент, и в итоге не пожалел. Кое-где я до сих пор предпочитаю пользоваться консолью (например, опустить все контейнеры удобнее через `docker stop $(docker ps -qa)`), но в остальном я от всей души благодарен [Git GUI](https://git-scm.com/downloads/guis) и подсказкам в PyCharm.
> **Вывод:** почитайте о Docker. Попробуйте запустить код в контейнере. Попробуйте IDE для вашего языка и посмотрите, какие возможности она вам может дать.
### Документация и тесты — не менее важны чем код
Однажды мой куратор сказал, что тесты — это вторая документация разработчика. И это очень верно, потому что, если реальной документации не хватает, всегда можно пойти в тесты и посмотреть, какое поведение ожидается.
До стажировки я пользовался UnitTest и PyTest, но только в рамках обучения. А [Mock](https://ru.wikipedia.org/wiki/Mock-%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82), например, не пользовался вообще, потому что мои проекты не были настолько сложны, чтобы нужно было подменять данные (ну, либо мои тесты были настолько плохи).
Я бы рекомендовал всем начинающим разработчикам писать тесты на всю логику, которая встречается в проекте. Даже если вам кажется, что поведение очевидно, лучше подстраховаться. Ведь когда другой человек будет писать функцию, которая использует ваш код, есть вероятность, что он не станет углубляться в детали и именно ваш упавший тест спасет проект от неприятностей.
А чтобы еще больше минимизировать риски, пишите понятную документацию. В Admitad метод или функция без документации вызовут вопросы на ревью. Спустя две недели никто не захочет тратить время на попытки в очередной раз разобраться в чужом коде. Это просто вопрос уважения к коллегам.
В дополнение скажу, что мы еще и подробно аннотируем типы в Python, но если вы пишете на строго типизированном языке, этот комментарий не для вас. (В этом плане очень помогает использование линтера, например [Flake8](https://flake8.pycqa.org/en/latest/)).
> **Вывод:** Уделяйте внимание тестам и документации. Начните с обычного readme-файла на Git — опишите, как запустить проект, что он делает и какой результат ожидается. Попробуйте написать тесты к ключевым методам и функциям, а еще лучше сделайте Docker Compose, который запускает прогон всех тестов.
### А какой опыт был у вас?
Состоявшимся разработчикам мои советы могут показаться банальными и очевидными. Я вас прекрасно понимаю, но поначалу мне сильно недоставало системных знаний. Уверен, с этой проблемой столкнулись многие из тех, кто осваивал профессию самостоятельно.
Поэтому я призываю вас поделиться опытом и наблюдениями, которые вы вынесли для себя после первых месяцев (или лет) в отрасли. Что бы вы посоветовали себе на старте карьеры? Какие навыки посоветовали бы развивать? И мне, и другим самоучкам могут пригодиться ваши подсказки, так что не стесняйтесь оставлять комментарии. | https://habr.com/ru/post/523730/ | null | ru | null |
# Laravel: создание фабрик и seeders при связях между моделями
В ситуациях, когда одна модель обязательно должна быть связана с другой моделью (например, статья и ее автор, компания и сотрудники и т.п.), большинство программистов допускают различные ошибки при создании фабрик (Factory) и сидов (Seeders) к этим моделям.
Предлагаю исследовать эту проблему и вывести единственно правильную реализацию создания фабрик и сидов в такой ситуации.
Спойлер: фабрики не должны зависеть от сидов.
Подготовка проекта
------------------
Возьмем очень простой пример проекта. На сайте есть список статей, где отображается название статьи и ее автор. Авторы — это пользователи сайта, каждая статья обязательно должна иметь автора. При этом мы хотим сделать так, чтобы при выполнении сидеров создавался только один пользователь и все статьи были привязаны к нему.
### Создание и настройка проекта
Подготовим этот проект (готовую реализацию уже можно посмотреть в [этом репозитории](https://github.com/mvsvolkov/laravel_relation_factories)). Создаем модель, миграцию, фабрику и сид для статей. Таблица с пользователями достаточна той версии, что идет в Laravel из коробки.
Создадим новую установка Laravel, используя установщик, и ставим проект с помощью консольной команды.
```
laravel new relation_factories
```
Теперь настроим файл .env, чтобы не создавать отдельную БД, для ускорения можно использовать БД sqlite.
```
// Параметры файла .env
DB_CONNECTION=sqlite
DB_DATABASE=/path...to...project/database/database.sqlite
```
Создать файл с БД можно также простой консольной командой.
```
touch database/database.sqlite
```
Создание модели статьи
----------------------
Пока мы находимся недалеко от консоли, создадим модель с миграцией и фабрикой, используя консольную команду.
```
php artisan make:model -f -m Article
```
На следующем шаге необходимо описать миграцию статьи. Здесь все стандартно — добавим поле для хранения заголовка и обязательную ссылку на пользователя.
```
php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
class CreateArticlesTable extends Migration
{
public function up()
{
Schema::create('articles', function (Blueprint $table) {
$table-id();
$table->string('title');
$table->foreignId('author_id')
->references('id')
->on('users')
->cascadeOnDelete()
;
$table->timestamps();
});
}
public function down()
{
Schema::dropIfExists('articles');
}
}
```
После создания миграции, добавим описание метода для связи с автором в классе статьи.
```
php
namespace App\Models;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
class Article extends Model
{
use HasFactory;
public function author(): BelongsTo
{
return $this-belongsTo(User::class, 'author_id');
}
}
```
В завершении первой части подготовки остается только выполнить миграцию. Используем знакомую консольную команду.
```
php artisan migrate
```
Создание фабрики и сидов
------------------------
Базовая часть подготовки проекта готова, мы можем перейти к описанию фабрики и сида.
Начнем с фабрики. У статьи есть только одно поле с данными — это заголовок, заполним его случайным предложением.
```
php
namespace Database\Factories;
use App\Models\Article;
use App\Models\User;
use Illuminate\Database\Eloquent\Factories\Factory;
class ArticleFactory extends Factory
{
protected $model = Article::class;
public function definition(): array
{
return [
'title' = $this->faker->sentence,
];
}
}
```
Опытный читатель уже заметил здесь ошибку, но мы вернемся к ней чуть позже, а пока опишем код сида. Будем писать код сразу в классе *DatabaseSeeder*, для упрощения без создания отдельных сидов.
Создадим, как того требует задание, одного пользователя и пять статей.
```
php
namespace Database\Seeders;
use App\Models\Article;
use App\Models\User;
use Illuminate\Database\Seeder;
class DatabaseSeeder extends Seeder
{
public function run()
{
User::factory()-create();
Article::factory()->count(5)->create();
}
}
```
А теперь попробуем выполнить сидер с помощью консольной команды.
```
php artisan db:seed
```
При попытке ее выполнить мы получили фатальную ошибку.
```
Illuminate\Database\QueryException
SQLSTATE[23000]: Integrity constraint violation: 19 NOT NULL constraint failed: articles.author_id ...
```
Как создать фабрику неправильно, вариант №1
-------------------------------------------
Мы не можем создать статью, не описав обязательное поле для связи с автором. Исправим это.
Первая мысль, которая, наверняка, приходит в голову. Поскольку внутри сида мы сначала создаем пользователя, а потом статьи, значит в фабрике мы можем выбрать нужного пользователя и привязать его к статье.
Это можно сделать разными неправильными 😈 способами.
Например, просто указав магический 1 в поле.
```
php
/* заголовки файла */
class ArticleFactory extends Factory
{
/* остальная часть класса */
public function definition(): array
{
return [
'title' = $this->faker->sentence,
'author_id' => 1,
];
}
}
```
Работать будет, но что означает эта волшебная единица? Я тоже не знаю. Так код писать нельзя, поэтому отбрасываем этот вариант.
Второй вариант неправильной реализации — это привязка к id пользователя. Выберем первого пользователя из БД и возьмем его id.
```
php
/* заголовки файла */
class ArticleFactory extends Factory
{
/* остальная часть класса */
public function definition(): array
{
return [
'title' = $this->faker->sentence,
'author_id' => User::first()->id,
];
}
}
```
Работать будет. Однако, это неверная реализация задачи, поскольку внутри фабрики формируется жесткая связь с одним определенным пользователем. В проекте, наверняка, будет много пользователей и может возникнуть необходимость привязать статьи, создаваемые фабрикой к разным пользователям.
Следующий вариант. Выбрать случайного пользователя из БД и его id, как показано на скрине ниже
```
php
/* заголовки файла */
class ArticleFactory extends Factory
{
/* остальная часть класса */
public function definition(): array
{
return [
'title' = $this->faker->sentence,
'author_id' => User::all()->random()->id,
];
}
}
```
Однако, и этот путь ошибочный. В БД могут быть миллионы пользователей. Зачем тянуть их всех, загружать в память php и потом силами php перемешивать? Нужно уже на уровне запроса к БД, взять одного случайного пользователя.
Исправляем и получаем такой промежуточный вариант фабрики.
```
php
/* заголовки файла */
class ArticleFactory extends Factory
{
/* остальная часть класса */
public function definition(): array
{
return [
'title' = $this->faker->sentence,
'author_id' => User::inRandomOrder()->first()->id,
];
}
}
```
Возможно вы подумали, что в такой реализации все будет работать. Далее в статье я объясню, почему это неправильно. А пока сбросим все миграции и выполним их снова вместе с сидами.
```
php artisan migrate:fresh --seed
```
Такой вариант реализации можно встретить очень часто. Однако, это неверное решение. Будем разбираться почему и для этого доработаем проект.
Создание страницы со списком статей и теста к ней
-------------------------------------------------
Создадим страницу, на которой будет выводиться список статей и имена авторов.
Для этого будем использовать главную страницу. Для упрощения реализуем обработчик маршрута в виде callback функции.
Отредактируем файл *web.php*
```
php
use App\Models\Article;
use Illuminate\Support\Facades\Route;
Route::get('/', function () {
$articles = Article::with('author')-get();
return view('welcome', compact('articles'));
})->name('home');
```
Теперь отредактируем файл *welcome.blade.php.* Сделаем его максимально простым.
```
@foreach ($articles as $article)
{{ $article->title }} - {{ $article->author->name }}
@endforeach
```
Запустим Laravel приложение с помощью консольной команды.
```
php artisan serve
```
Откроем запущенный сайт и увидим на нем примерно такой контент.
```
Modi eum aliquam beatae ab ut commodi dignissimos est. - Karley Nicolas
Quia nostrum id quos et inventore tenetur. - Karley Nicolas
Perferendis earum ipsam ex rerum nihil dicta. - Karley Nicolas
Amet eos rem adipisci dolorem. - Karley Nicolas
Enim debitis itaque et illo occaecati non. - Karley Nicolas
```
Создаем автотест
----------------
Ничто так хорошо не подсвечивает проблемы с приложением, как написание для него автотестов. Поэтому создадим тест, который проверит работу главной страницы.
Класс теста создадим с помощью генератора, выполнив консольную команду.
```
php artisan make:test ArticlesTest
```
Теперь напишем этот тест. Для корректной работы теста его правильнее запускать на чистой БД, поэтому обязательно используем трейт *RefreshDatabase.*
```
php
namespace Tests\Feature;
use App\Models\Article;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Foundation\Testing\WithFaker;
use Tests\TestCase;
class ArticlesTest extends TestCase
{
use RefreshDatabase;
public function test_main_page_has_articles()
{
/**
* Если на сайте создана статья
*/
$article = Article::factory()
-create(['title' => 'example'])
;
/**
* То, когда пользователь заходит на главную страницу
*/
$response = $this->get(route('home'));
/**
* Страница ДОЛЖНА открыться,
* и контент страницы ДОЛЖЕН содержать название этой статьи
*/
$response
->assertStatus(200)
->assertSee($article->title)
;
}
}
```
В Laravel функция выполнения теста доступна "из коробки", поэтому просто выполним консольную команду.
```
php ./vendor/bin/phpunit
```
Однако, такой простой тест не прошел. Он вывел ошибку
```
1) Tests\Feature\ArticlesTest::test_main_page_has_articles
ErrorException: Attempt to read property "id" on null
```
Неподготовленному разработчику Laravel может показаться, что определить источник ошибки не так-то просто. На самом деле проблема в фабрике.
Как создать фабрику неправильно, вариант №2
-------------------------------------------
Проблема в следующем. При выполнении теста на чистую БД накатываются миграции, но сидеры не выполняются. Поэтому в БД нет пользователей, а значит попытка выбрать пользователей в фабрике вернет *null*.
Таким образом, во всех тестах, которые создают объект статьи необходимо помнить о том, что сначала нужно создать пользователя для этой статьи. Это создает неприятности при написании тестов.
Второй вариант — использовать фабрику пользователя внутри фабрики статьи. Тогда фабрика статьи перестанет зависеть от внешних условий, она сама сможет создать модель и все связи, которые для нее требуются.
Воспользуемся фабрикой внутри фабрики. Сделать это очень просто. Однако, как уже заведено в этой статье, сначала я покажу вариант реализации с ошибкой. Кстати, поле id можно не указывать, Laravel достаточно умный, чтобы взять id модели за вас.
```
php
/* заголовки файла */
class ArticleFactory extends Factory
{
/* остальная часть класса */
public function definition(): array
{
return [
'title' = $this->faker->sentence,
'author_id' => User::factory()->create(),
];
}
}
```
Снова запустим тест, выполнив консольную команду.
```
php ./vendor/bin/phpunit
```
Тест прошел, но на сайте возникла другая ошибка, даже две.
Для демонстрации первой из них перевыполним все миграции и сиды, а затем посмотрим, что отобразиться на сайте.
```
php artisan migrate:fresh --seed
```
На сайте видим, что теперь каждая статья привязана к своему отдельному пользователю, что не подходит нам по условию задачи.
```
Ad id sit distinctio perspiciatis accusantium numquam rerum quia. - Isai Rohan
Fugit ipsum odio iure. - Gretchen Prosacco
Qui est quae asperiores sed. - Abby Leannon
Placeat nobis est sed aperiam. - Dahlia McKenzie
Quod iste unde assumenda molestias eaque quia dignissimos earum. - Dr. Alysha Gutkowski Jr.
```
Исправить это очень просто, для этого подкорректируем код сида, передав пользователя в качестве параметра методу create.
```
php
/* заголовки файла */
class DatabaseSeeder extends Seeder
{
public function run()
{
$user = User::factory()-create();
Article::factory()
->count(5)
->create(['author_id' => $user])
;
}
}
```
Перевыполним миграции и сиды. На сайте все отображается, тесты выполняются.
"Теперь все работает так, как надо" - подумали вы. Но не тут-то было, у нас появилась новая скрытая проблема.
Как создать фабрику неправильно, вариант №3
-------------------------------------------
Использование метода фабрики *create()* внутри другой фабрики мгновенно приводит к созданию новой модели связи. Таким образом, у нас сейчас в БД не один пользователь, как мы думаем, а шесть. Одного мы создали через сидер, еще пять созданы фабрикой статьи.
Это можно проверить с помощью тинкера, посчитав количество пользователей в БД.
```
php artisan tinker
Psy Shell v0.10.8 (PHP 8.0.10 -- cli) by Justin Hileman
>>> App\Models\User::count()
=> 6
```
Можно подумать, что вместо метода create в фабрике нужно использовать метод make, но тогда снова перестанут работать тесты. Получается замкнутый круг.
Правильное решение
------------------
Верное решение очень простое. Внутри фабрики необходимо использовать другую фабрику без вызова метода *make()* или *create().*
```
php
/* заголовки файла */
class ArticleFactory extends Factory
{
/* остальная часть класса */
public function definition(): array
{
return [
'title' = $this->faker->sentence,
'author_id' => User::factory(),
];
}
}
```
Только теперь все заработало корректно. Тесты успешно выполняются, а сиды создают только одного пользователя.
Laravel настолько умен, что при создании модели заметит, что в поле указана фабрика и, отложит ее выполнение на самый последний момент. Если в методе *create()* или *make()* поле *author\_id* не будет переопределено, только в этом случае эта фабрика выполнится и создаст нового автора для статьи.
Таким образом, можно создавать максимально независимые, универсальные и переопределяемые фабрики в вашем Laravel приложении. Если при создании фабрики для модели требуются создать привязанные модели, используйте фабрики для этих связей.
С вами был руководитель QSOFT Академии по направлению “Разработка” - [Волков Михаил](https://mvsvolkov.ru) ([@mvsvolkov](https://habr.com/ru/users/mvsvolkov/)), всем классных фабрик, вкусных сидов и тестов без ошибок. | https://habr.com/ru/post/645055/ | null | ru | null |
# Errors that static code analysis does not find because it is not used
Readers of our articles occasionally note that the PVS-Studio static code analyzer detects a large number of errors that are insignificant and don't affect the application. It is really so. For the most part, important bugs have already been fixed due to manual testing, user feedback, and other expensive methods. At the same time, many of these errors could have been found at the code writing stage and corrected with minimal loss of time, reputation and money. This article will provide several examples of real errors, which could have been immediately fixed, if project authors had used static code analysis.
The idea is very simple. We'll search for examples of pull requests on GitHub that specify that an issue is a bugfix. Then we'll try to find these bugs using the PVS-Studio static code analyzer. If an error could be found by the analyzer, then it is a bug which could have been found at the code writing stage. The earlier the bug is corrected, the cheaper it costs.
Unfortunately, GitHub let us down and we didn't manage to make a big posh article on the subject. GitHub itself has a glitch (or a feature) that doesn't allow you to search for comments of pull requests in projects written only in certain programming languages. Or I don't know how to cook it. Despite that I specify to search for comments in C, C++, C# projects, the results are given for all languages, including PHP, Python, JavaScript, and others. As a result, looking for suitable cases has proved to be extremely tedious, and I'll go for just a few examples. However, they are enough to demonstrate the usefulness of static code analysis tools when used regularly.
What if the bug had been caught at the earliest stage? The answer is simple: programmers wouldn't have to wait for it to show itself, then search and correct the defective code.
Let's look at the errors that PVS-Studio could have immediately detected:
The [first example](https://github.com/satisfactorymodding/SatisfactoryModLoader/commit/9e4b32e8f6b5c1e8d117e4cecc2586d4d2f3d8e1) is taken from the SatisfactoryModLoader project. Before fixing the error, the code looked as follows:
```
// gets an API function from the mod handler
SML_API PVOID getAPIFunction(std::string name) {
bool found = false;
for (Registry reg : modHandler.APIRegistry) {
if (reg.name == name) {
found = true;
}
}
if (!found) {
std::string msg = ...;
MessageBoxA(NULL,
msg.c_str(),
"SatisfactoryModLoader Fatal Error",
MB_ICONERROR);
abort();
}
}
```
This code contained an error, that PVS-Studio would immediately issue a warning to:
[V591](https://www.viva64.com/en/w/v591/) Non-void function should return a value. ModFunctions.cpp 44
The above function has no *return* statement, so it will return a formally undefined value. The programmer didn't use the code analyzer, so he had to look for the bug on his own. The function after editing:
```
// gets an API function from the mod handler
SML_API PVOID getAPIFunction(std::string name) {
bool found = false;
PVOID func = NULL;
for (Registry reg : modHandler.APIRegistry) {
if (reg.name == name) {
func = reg.func;
found = true;
}
}
if (!found) {
std::string msg = ...;
MessageBoxA(NULL,
msg.c_str(),
"SatisfactoryModLoader Fatal Error",
MB_ICONERROR);
abort();
}
return func;
}
```
Curiously, in the commit, the author marked the bug as critical: "*fixed* ***critical bug*** *where API functions were not returned*".
In the second [commit](https://github.com/spc476/mc6809/commit/815a5577c006b2b2c812c7cff86dc72191d47003) from the mc6809 project history, edits were introduced in the following code:
```
void mc6809dis_direct(
mc6809dis__t *const dis,
mc6809__t *const cpu,
const char *const op,
const bool b16
)
{
assert(dis != NULL);
assert(op != NULL);
addr.b[MSB] = cpu->dp;
addr.b[LSB] = (*dis->read)(dis, dis->next++);
...
if (cpu != NULL)
{
...
}
}
```
The author corrected only one line. He replaced the expression
```
addr.b[MSB] = cpu->dp;
```
for the following one
```
addr.b[MSB] = cpu != NULL ? cpu->dp : 0;
```
In the old code version there was not any check for a null pointer. If it happens so that a null pointer is passed to the *mc6809dis\_direct* function as the second argument, its dereference will occur in the body of the function. The result is [deplorable and unpredictable](https://www.viva64.com/en/b/0306/).
Null pointer dereference is one of the most common patterns we are told about: «It's not a critical bug. Who cares that it is thriving in code? If dereference occurs, the program will quietly crash and that's it.» It's strange and sad to hear this from C++ programmers, but life happens.
Anyway, in this project such dereference has turned into a bug, as the commit's subject tells us: "*Bug fix---NULL dereference*".
If the project developer had used PVS-Studio, he could have checked and found the warning two and a half months ago. This is when the bug was introduced. Here is the warning:
[V595](https://www.viva64.com/en/w/v595/) The 'cpu' pointer was utilized before it was verified against nullptr. Check lines: 1814, 1821. mc6809dis.c 1814
Thus, the bug would have been fixed at the time of its appearance, which would have saved the developer's time and nerves :).
An example of another interesting [fix](https://github.com/Forceflow/libmorton/commit/9bee7af145f24b653b8b195ffc0f4147e0268e02) was found in the libmorton project.
Code to be fixed:
```
template
inline bool findFirstSetBitZeroIdx(const morton x,
unsigned long\* firstbit\_location)
{
#if \_MSC\_VER && !\_WIN64
// 32 BIT on 32 BIT
if (sizeof(morton) <= 4) {
return \_BitScanReverse(firstbit\_location, x) != 0;
}
// 64 BIT on 32 BIT
else {
\*firstbit\_location = 0;
if (\_BitScanReverse(firstbit\_location, (x >> 32))) { // check first part
firstbit\_location += 32;
return true;
}
return \_BitScanReverse(firstbit\_location, (x & 0xFFFFFFFF)) != 0;
}
#elif \_MSC\_VER && \_WIN64
....
#elif \_\_GNUC\_\_
....
#endif
}
```
In his edit, a programmer replaces the expression "*firstbit\_location += 32*" with "***\*****firstbit\_location += 32*". The programmer expected that 32 will be added to the value of the variable referred to by the *firstbit\_location* pointer, but 32 was added to the pointer itself. The changed value of the pointer wasn't used anywhere any more and the expected variable value remained unchanged.
PVS-Studio would issue a warning to this code:
[V1001](https://www.viva64.com/en/w/v1001/) The 'firstbit\_location' variable is assigned but is not used by the end of the function. morton\_common.h 22
Well, what is so bad about the modified but further unused expression? The V1001 diagnostic doesn't look like it's meant for detecting particularly dangerous bugs. Despite this, it found an important error that influenced the program logic.
Moreover, it turned out that that error wasn't so easy to find! Not only has it been in the program since the file was created, but it has also experienced many edits in neighboring lines and existed in the project for as many as 3 (!) years! All this time the logic of the program was broken, and it didn't work in the way developers expected. If they had used PVS-Studio, the bug would have been detected much earlier.
In the end, let's look at another nice example. While I was collecting bug fixes on GitHub, I came across a fix with the [following content](https://github.com/torvalds/linux/commit/ca09f02f122b2ecb0f5ddfc5fd47b29ed657d4fd) several times. The fixed error was here:
```
int kvm_arch_prepare_memory_region(...)
{
...
do {
struct vm_area_struct *vma = find_vma(current->mm, hva);
hva_t vm_start, vm_end;
...
if (vma->vm_flags & VM_PFNMAP) {
...
phys_addr_t pa = (vma->vm_pgoff << PAGE_SHIFT) +
vm_start - vma->vm_start;
...
}
...
} while (hva < reg_end);
...
}
```
PVS-Studio issued a warning for this code snippet:
[V629](https://www.viva64.com/en/w/v629/) Consider inspecting the 'vma->vm\_pgoff << 12' expression. Bit shifting of the 32-bit value with a subsequent expansion to the 64-bit type. mmu.c 1795
I checked out declarations of variables, used in the expression "*phys\_addr\_t pa = (vma->vm\_pgoff << PAGE\_SHIFT) + vm\_start — vma->vm\_start;*" and found out that the code given above is equal to the following synthetic example:
```
void foo(unsigned long a, unsigned long b)
{
unsigned long long x = (a << 12) + b;
}
```
If the value of the *a* 32-bit variable is greater than *0xFFFFF*, 12 highest bits will have at least one nonnull value. After shifting this variable left, these significant bits will be lost, resulting in incorrect information written in *x.*
To eliminate loss of high bits, we need first to cast *a* to the *unsigned long long* type and only after this shift the variable:
```
pa = (phys_addr_t)vma->vm_pgoff << PAGE_SHIFT;
pa += vm_start - vma->vm_start;
```
This way, a correct value will always be written in *pa.*
That'd be okay but this bug, the same as the first example from the article, also turned out to be critical. It's author wrote about it in the comment. Moreover, this error found its way to an enormous number of projects. To fully appreciate the scale of the tragedy, I [suggest looking](https://github.com/search?q=arm%3A+KVM%3A+Fix+incorrect+device+to+IPA+mapping&type=Commits) at the number of results when searching for this bugfix on GitHub. Scary, isn't it?
So I've taken a new approach to demonstrate the benefits of a regular static code analyzer usage. I hope you enjoyed it. [Download and try](https://www.viva64.com/en/pvs-studio-download/) the PVS-Studio static code analyzer to check your own projects. At the time of writing, it has about 700 implemented diagnostic rules to detect a variety of error patterns. Supports C, C++, C# and Java. | https://habr.com/ru/post/460121/ | null | en | null |
# Строим свой Gmail с куртизанками и преферансом
#### Вместо предисловия
В один прекрасный, а может и не такой уж и прекрасный, день настигла паранойя и меня. Было принято решение бежать от Google подальше. При чем, бежать куда-нибудь на свою площадку, чтобы быть спокойным за сохранность своих любимых сервисов.
Итак, в этой статье я расскажу о том, как я поднимал и настраивал на своем сервере почту, календарь, контакты, RSS-аггрегатор и, в качестве бонуса, хранилище файлов.
#### 0. Сервер
Прежде чем разворачивать все необходимые сервисы, сперва необходимо решить где они будут жить. Первая мысль, которая приходит в голову — развернуть все на своем домашнем компьютере. Но включенный 24/7 компьютер дома доставляет немало неудобств. К тому же, мы хотим, чтобы наши сервисы были доступны всегда, а с качеством домашнего интернета и электроснабжения это почти невозможно. Да что там говорить о качестве, многие интернет провайдеры запрещают держать какие-либо серверы дома.
Таким образом, выбор пал на виртуальный сервер от [Digital Ocean](http://digitalocean.com). Думаю, сервис не нуждается в представлении. Для себя я выбрал самый простой [тарифный план](https://www.digitalocean.com/pricing), а именно $5/мес, 20GB SSD и 512MB RAM. Таких скромных характеристик достаточно для решения вышеописанных задач в масштабах домашнего пользования.
Также, нам необходимо зарегистрировать домен. Так как ~~я жадная жопа~~ мне было жалко денег на домен в зоне .com, то я воспользовался услугами замечательного регистратора [Dot.tk](http://www.dot.tk) — они выдают домены в зоне .tk бесплатно, с условием, что ваш сайт будет работать и вы вовремя будете продлевать регистрацию доменного имени. Другими словами — если вы доменом пользуетесь, то пользуйтесь на здоровье. Если же просто застолбили имя, то не будьте жадиной, отдайте это имя кому-то другому.
Для удобства, можно перенести обслуживание домена на серверы Digital Ocean, что я и сделал, выбрав «Custom DNS» и прописав адреса следующих NS-серверов: `ns1.digitalocean.com, ns2.digitalocean.com, ns3.digitalocean.com`.
#### 1. Почта
После того, как мы развернули сервер и зарегистрировали домен, можно приступать к установке необходимых нам служб. Я ~~еще и ленивая жопа~~ человек ленивый и люблю использовать пакеты, которые работают прямо из коробки. Поэтому для установки почтового сервера я выбрал [iRedMail](http://www.iredmail.org/). Бесплатной версии будет вполне достаточно для решения наших задач.
Это набор скриптов, которые за считанные минуты устанавливает и настраивает следующую связку:
* dovecot
* postfix
* mysql/postgresql/openldap (по выбору)
* amavisd
* clamav
* spamassissin
* apache
* roundcubemail
+ еще некоторые плюшки, о которых детально написано [тут](http://www.iredmail.org/features.html).
ВНИМАНИЕ: на [сайте](http://www.iredmail.org/) iRedAdmin написано, что его нужно устанавливать \_только\_ на свежеустановленную ОС. Я не пробовал устанавливать пакет на «бэушный» сервер, однако, подозреваю, что закончится это все не самым лучшим образом.
Не будем долго задерживаться на этапе установки, эта процедура довольно проста и подробно описана [тут](http://habrahabr.ru/post/96314/), [тут](http://www.iredmail.org/doc.html) и [тут](https://www.digitalocean.com/community/articles/how-to-install-iredmail-on-ubuntu-12-04-x64). После установки можем пойти на панель управления по адресу `example.com/iredadmin` и создать нового пользователя. Теперь у нас есть полностью рабочий почтовый сервер.
Но мы пойдем немного дальше и заменим apache на nginx. Сперва, необходимо установить сам веб-сервер. В ubuntu это делается так:
```
apt-get install nginx
```
Теперь необходимо настроить его таким образом, чтобы все наши сервисы были доступны. Так как мы хотим, чтобы весь трафик шифровался, то необходимо немного модифицировать дефолтный конфиг, включив шифрование. Подробнее о настройке шифрования в nginx можно почитать [тут](http://habrahabr.ru/post/195808/). Мой глобальный конфиг /etc/nginx/nginx.conf выглядит следующим образом:
```
http {
ssl_certificate /path/to/cert;
ssl_certificate_key /path/to/key;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_ciphers "RC4:HIGH:!aNULL:!MD5:!kEDH";
ssl_session_cache shared:SSL:10m;
ssl_session_timeout 5m;
ssl_prefer_server_ciphers on;
add_header Strict-Transport-Security 'max-age=604800';
sendfile on;
tcp_nopush on;
tcp_nodelay on;
keepalive_timeout 65;
types_hash_max_size 2048;
server_name_in_redirect on;
include /etc/nginx/mime.types;
default_type application/octet-stream;
access_log /var/log/nginx/access.log;
error_log /var/log/nginx/error.log;
gzip on;
gzip_disable "msie6";
include /etc/nginx/sites-enabled/*;
}
```
Таким образом, я включил шифрование глобально для всех сайтов, которые будет обслуживать nginx. Теперь нужно написать конфиги для необходимых нам сервисов.
Для этого в /etc/nginx/sites-enabled/ создаем новый файл примерно с таким содержанием:
```
server {
listen 80;
server_name example.com www.example.com;
return 301 https://$server_name$request_uri; # Принудительно перенаправляем на https
}
server {
listen 443 ssl;
server_name example.com www.example.com;
index index.php index.html index.htm;
ssl on;
access_log /var/log/nginx/root/access.log;
error_log /var/log/nginx/root/error.log;
location /phpmyadmin {
root /usr/share/;
location ~ ^/phpmyadmin/(.+\.php)$ {
try_files $uri = 404;
root /usr/share/;
fastcgi_pass unix:/var/run/php5-fpm.sock;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_param HTTPS on;
include fastcgi_params;
}
location ~* ^/phpmyadmin/(.+\.(jpg|jpeg|gif|css|png|js|ico|html|xml|txt))$ {
root /usr/share/;
}
}
location /iredadmin {
root /var/www;
uwsgi_pass 127.0.0.1:3031;
include uwsgi_params;
uwsgi_param SCRIPT_NAME /iredadmin;
uwsgi_modifier1 30;
location ~* ^/iredadmin/static/ {
root /var/www;
}
}
location ~/(\.ht|README|AUTHORS|INSTALL|LICENSE|CONFIG|ChangeLog) {
deny all;
}
}
```
Здесь мы видим правила обслуживания адресов /phpmyadmin и /iredadmin. Так как phpmyadmin написан на ~~вот так неожиданность~~ php, то для его работы необходимо установить php5-fpm. В ubuntu это делается так:
```
apt-get install php5-fpm
```
Далее, в конфиге /etc/php5/fpm/pool.d/www.conf прописываем строчку:
```
listen = /var/run/php5-fpm.sock
```
Таким образом мы указываем fpm, чтобы он слушал на сокете /var/run/php5-fpm.sock. Именно на этот сокет настроен наш nginx.
iredadmin, в свою очередь, написан на python и для его работы нам понадобится uwsgi. Также, для красивого запуска uwsgi, я использую supervisor. Установим эти пакеты.
```
apt-get install supervisor
pip install uwsgi
```
Конфиг uwsgi-приложения /etc/uwsgi/iredadmin.ini у меня выглядит следующим образом:
```
[uwsgi]
chdir=/var/www/iredadmin
vacuum=True
pidfile=/var/run/uwsgi/iredadmin/iredadmin.pid
socket=127.0.0.1:3031
plugins=python
file=/var/www/iredadmin/iredadmin.py
```
Конфиг супервизора /etc/supervisor/conf.d/iredadmin.conf выглядит так:
```
[program:iredadmin]
command=/usr/local/bin/uwsgi /etc/uwsgi/iredadmin.ini
stdout_logfile=/var/log/supervisor/iredadmin.log
stderr_logfile=/var/log/supervisor/iredadmin_err.log
user=iredadmin
```
Останавливаем apache, запускаем nginx и supervisor:
```
service apache2 stop
service nginx start
supervisorctl start iredadmin
```
Идем в браузер и проверяем все ли работает.
#### 2. Контакты и календари
Для того, чтобы наше рабочее окружение было максимально комфортным, нам необходимо поднять сервер контактов и календарей. Сперва мой выбор пал на [Baikal](http://baikal-server.com/). Это замечательное решение, которое разворачивается за считанные секунды и неплохо работает. Но мы ведь хотим, чтобы все наши сервисы также были доступны и через web, а Baikal, к сожалению, не имеет встроенного web-интерфейса. Таким образом, необходимо искать, устанавливать и настраивать еще один продукт. После непродожительного поиска, наткнулся на отличное решение — [ownCloud](http://owncloud.org/). Это полноценный [WebDAV](http://en.wikipedia.org/wiki/WebDAV) сервер, у которого есть веб-интерфейс и клиенты для разных платформ. Из коробки мы получаем сервер контактов и календарь. Более того, мы получаем свое личное облачное хранилище!
##### Установка
1. Скачать и распаковать архив;
2. Создать пользователя базы данных и саму БД;
3. Настроить nginx;
4. Открыть в браузере страницу установщика и следовать инструкциям.
[Конфиг](http://doc.owncloud.org/server/5.0/admin_manual/installation/installation_others.html#nginx-configuration) для nginx я взял из [документации](http://doc.owncloud.org/).
##### Интеграция контактов с RoundCubeMail
Для того, чтобы мы могли пользоваться контактами прямо в веб-интерфейсе почтового ящика, необходимо установить плагин для RoundCubeMail. Я использовал [этот](https://github.com/graviox/Roundcube-CardDAV).
Сначала нужно установить [plugin-manager](http://myroundcube.com/myroundcube-plugins/plugin-manager) для RoundCube. Видео-инструкция по установке лежит [тут](http://www.youtube.com/watch?v=EnmJ_cnkKq0&feature=youtu.be). В моем случае оказалось, что iRedMail не выдал всех привилегий пользователю БД roundcube для базы roundcubemail. Убедитесь, что все права выданы, иначе плагин-менеджер не установится. После этого качаем архив с плагином Roundcube-CardDAV, распаковываем его и кладем содержимое в папку /var/www/roundcube/plugins/carddav/. Затем необходимо включить этот плагин в настройках RoundCube в веб-интерфейсе. Теперь в настройках появился новый пункт CardDAV, в котором необходимо прописать адрес нашего CardDAV-сервера.
#### 3. RSS
В завершение осталось поднять только RSS аггрегатор. Для решения этой задачи я использовал [Tiny Tiny RSS](http://tt-rss.org). Это легкий движок, который прост в установке и настройке и имеет несколько тем оформления.
##### Установка
1. Скачать и распаковать архив;
2. Создать пользователя базы данных и саму БД;
3. Настроить nginx;
4. Открыть в браузере страницу установщика и следовать инструкциям.
Конфиг nginx /etc/nginx/sites-enabled/rss имеет следующий вид:
```
server {
listen 80;
server_name rss.example.com;
return 301 https://$server_name$request_uri;
}
server {
listen 443 ssl;
server_name rss.example.com;
index index.php index.html index.htm;
root /var/www/tt-rss;
access_log /var/log/nginx/tt-rss/access.log;
error_log /var/log/nginx/tt-rss/error.log;
location ~ ^/favicon.ico$ {
alias /var/www/tt-rss/images/favicon.png;
log_not_found off;
access_log off;
expires max;
}
location = /robots.txt {
allow all;
log_not_found off;
access_log off;
}
location ~ ^/(README\.md|INSTALL|LICENSE|CHANGELOG|UPGRADING)$ {
deny all;
}
location ~ ^/(schema|utils|install)/ {
deny all;
}
location ~/\. {
deny all;
access_log off;
log_not_found off;
}
location ~ \.php$ {
try_files $uri = 404;
include /etc/nginx/fastcgi_params;
fastcgi_pass unix:/var/run/php5-fpm.sock;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_param HTTPS on;
include fastcgi_params;
fastcgi_index index.php;
}
}
```
Для того, чтобы фиды обновлялись автоматически в фоновом режиме, я добавил еще одно приложение для супервизора:
```
# cat /etc/supervisor/conf.d/tt_rss.conf
[program:tt_rss_up]
command=/usr/bin/php /var/www/tt-rss/update_daemon2.php
stdout_logfile=/var/log/supervisor/tt_rss_up.log
stderr_logfile=/var/log/supervisor/tt_rss_up_err.log
user=www-data
```
#### 4. Синхронизация с мобильным телефоном
Зачем нам все это без синхронизации с мобильным телефоном? Вот и я думаю, что незачем.
Для синхронизации файлов, у ownCloud есть приложение для [Android](https://play.google.com/store/apps/details?id=com.owncloud.android) и [iPhone](https://itunes.apple.com/us/app/owncloud/id543672169?ls=1&mt=8). К сожалению, оно пока не умеет синхронизировать календарь и контакты, потому приходится использовать сторонние синхронизаторы.
На сколько мне известно, для iPhone ничего изобретать не надо, там синхронизация с CardDAV/CalDAV есть из коробки. В случае с Android, необходимо установить приложения, которые будут синхронизировать наши контакты и календари. В Google Play есть несколько приложений подобного рода, мой выбор пал на [CalDAV-Sync](https://play.google.com/store/apps/details?id=org.dmfs.caldav.lib) и [CardDAV-Sync](https://play.google.com/store/apps/details?id=org.dmfs.carddav.Sync).
Для Tiny Tiny RSS существует официальный [клиент](https://play.google.com/store/apps/details?id=org.fox.ttrss&feature=search_result) для Android.
#### Заключение
В итоге, мы получили хорошую альтернативу Gmail'у, полностью принадлежащую нам. Теперь можно спать спокойно, не опасаясь злых дядь, которые любят читать нашу почту и закрывать любимые сервисы. Как бонус, я обнаружил, что мой Android смартфон теперь живет в 1.5-2 раза дольше от одного заряда. Лишь благодаря отключению синхронизации гугловских календарей и контактов.
Спасибо всем, кто осилил весь этот поток мыслей. Пожелания, предложения и конструктивная критика приветствуются. | https://habr.com/ru/post/197756/ | null | ru | null |
# Ломаем iOS-приложение! Часть 2
В [первой части](http://habrahabr.ru/post/199128/) мы изучили некоторые вопросы безопасности хранения и передачи *данных*. Теперь переходим к защите *исполняемого кода*. Мы будем модифицировать функционал iOS-приложения во время выполнения и проделаем реверс-инжиниринг. И снова, помните! Наша цель — не стать гадким взломщиком, а защитить ваше приложение и пользователей от злонамеренных действий. Для этого нужно понять, что может сделать взломщик.
Чтобы успешно пройти этот урок, вы должны представлять, что такое ассемблер. Автор статьи советует пройти [туториал по ARM](http://www.raywenderlich.com/37181/ios-assembly-tutorial) (на английском).
Вообще-то, чтобы понять смысл урока, уровень необходимых знаний — это пару минут погуглить по ходу дела. Ну вы ближе к концу статьи сами решите, нужно изучать ассемблер или нет. :) *— Прим. пер.*
Начнём
------
Нам понадобится:
* Тестовый проект [Meme Collector](https://github.com/x128/MemeCollector) из предыдущей части.
* Утилита [class-dump-z](https://code.google.com/p/networkpx/wiki/class_dump_z).
* Опенсорсный HEX-редактор для OS X: [Hex Fiend](http://ridiculousfish.com/hexfiend/).
* Демо-версия [IDA](https://www.hex-rays.com/products/ida/support/download_demo.shtml) — это известный мультипроцессорный дизассемблер и отладчик. У демо-версии есть ограничения, несущественные для данного урока.
Надеюсь, вы узнаете об этих инструментах много нового!
Манипуляции со средой выполнения (runtime)
------------------------------------------
В предыдущей серии мы модифицировали файлы .plist для изменения остатка на вашем счёте. Сейчас посмотрим, как манипулировать переменными и методами прямо во время выполнения приложения (то, что зовётся runtime). Для этого используем дебаггер LLDB.
**В оригинальной статье все примеры с GDB, но**после обновления Xcode до 5.0.1 (текущая версия на момент перевода) для запуска GDB требуются танцы с бубном. Поэтому, чтобы не утяжелять туториал, я переделал его по [таблице соответствий команд между LLDB и GDB](http://lldb.llvm.org/lldb-gdb.html). *— Прим. пер.*
Откройте в терминале папку главного бандла (`Meme Collector.app`), установленного на симулятор iOS. Если вы затрудняетесь это сделать, загляните в [первую часть](http://habrahabr.ru/post/199128/).
Занимаем исходную позицию: симулятор запущен, приложение установлено, но не запущено.
В терминале наберите:
```
lldb
```
Дебаггер запущен, отлично. На следующей строчке мы видим приглашение от него: `(lldb)`
Набираем команду для дебаггера:
*я не буду писать символы `(lldb)` в начале строки, чтобы вы ничего не перепутали при копировании*
```
attach --name "Meme Collector" --waitfor
```
Команда `attach` служит для подключения к определённому процессу. Здесь мы просим LLDB, чтобы он подождал запуска нового процесса с названием "`Meme Collector`" и подключился к нему.
Итак, дебаггер ждёт. Перейдём к Симулятору iOS и выполним традиционное (по прошлой части урока) удаление приложения из многозадачности, и далее повторный запуск (запускать именно из симулятора, не из IDE) — далее будем называть это «перезапуск».
Если всё сделано правильно, LLDB начнёт ~~вместе весело шагать~~ с процессом в симуляторе. Отладчик подключится к процессу, приостановит его выполнение и скажет:
```
Process 1427 stopped
Executable module set to "/Users/dmitriy/Library/Application Support/iPhone Simulator/7.0.3/Applications/9A72F266-8851-4A25-84E4-9CF8EFF95CD4/Meme Collector.app/Meme Collector".
Architecture set to: i486-apple-macosx.
```
И приглашение для ввода новой команды: `(lldb)`
Давайте добавим точку останова (breakpoint) перед отображением каждого ViewController’а. Это как раз то место, где обычно происходит много интересных вещей. Зачастую там определяется значительная часть логики работы приложения. Например, давайте добавим точку останова на каждый вызов метода `viewDidLoad`, так как в iOS подклассы `UIViewController`’а почти всегда переопределяют `viewDidLoad`.
Выполните в терминале:
```
b viewDidLoad
```
Названия методов чувствительны к регистру, поэтому вариант `viewdidload` не пройдёт.
Этим мы устанавливаем точки останова на все методы, которые называются `viewDidLoad` (включая методы C++ и Objective C). При желании, для конкретных селекторов ObjC вы можете ввести их имена, например, `-[UIViewController viewDidLoad]`, но обратите внимание, что этот вариант не сработает для наследников класса `UIViewController`.
Итак, LLDB сообщает нам, что он нашёл 15 подходящих мест для точек останова:
```
Breakpoint 1: 15 locations.
```
Отлично. Посмотрим, куда он их поставил. Вводим команду:
```
br l
```
(Это сокращение от `breakpoint list` — если хотите, можете писать полную версию команды.)
Ну и вот они:
```
Current breakpoints:
1: name = 'viewDidLoad', locations = 15, resolved = 15
1.1: where = Meme Collector`-[ViewController viewDidLoad] + 18 at ViewController.m:27, address = 0x0001f482, resolved, hit count = 0
1.2: where = UIKit`-[UIViewController viewDidLoad], address = 0x005d3db5, resolved, hit count = 0
1.3: where = UIKit`-[_UIModalItemsPresentingViewController viewDidLoad], address = 0x0065ab4b, resolved, hit count = 0
1.4: where = UIKit`-[UIKeyboardCandidateGridCollectionViewController viewDidLoad], address = 0x00680729, resolved, hit count = 0
1.5: where = UIKit`-[UIActivityGroupViewController viewDidLoad], address = 0x008d2b6b, resolved, hit count = 0
1.6: where = UIKit`-[UIPrintPanelTableViewController viewDidLoad], address = 0x009be80f, resolved, hit count = 0
1.7: where = UIKit`-[UIPrintStatusViewController viewDidLoad], address = 0x009c8828, resolved, hit count = 0
1.8: where = UIKit`-[UIPrintRangeViewController viewDidLoad], address = 0x009d29ae, resolved, hit count = 0
1.9: where = UIKit`-[_UILongDefinitionViewController viewDidLoad], address = 0x00a10cf4, resolved, hit count = 0
1.10: where = UIKit`-[_UINoDefinitionViewController viewDidLoad], address = 0x00a1249d, resolved, hit count = 0
1.11: where = UIKit`-[UIReferenceLibraryViewController viewDidLoad], address = 0x00a13bd4, resolved, hit count = 0
1.12: where = UIKit`-[_UIFallbackPresentationViewController viewDidLoad], address = 0x00a77877, resolved, hit count = 0
1.13: where = UIKit`-[_UIViewServiceViewControllerOperator viewDidLoad], address = 0x00aba23b, resolved, hit count = 0
1.14: where = UIKit`-[UIActivityViewController viewDidLoad], address = 0x00b4f296, resolved, hit count = 0
1.15: where = UIKit`-[_UITextEditingController viewDidLoad], address = 0x00b9a6ec, resolved, hit count = 0
```
На самом деле, тут видно, что нам нужно оставить только один breakpoint: `-[ViewController viewDidLoad]`, так как остальные принадлежат Apple Private API. Но нам интересно, поэтому оставим их включенными.
Вернёмся к запуску нашего приложения! Введите команду:
```
c
```
что в полном варианте выглядит как `continue`. Приложение продолжит выполнение кода вплоть до первого вызова `viewDidLoad`:
```
Process 1427 resuming
Process 1427 stopped
* thread #1: tid = 0x83c4, 0x0001f482 Meme Collector`-[ViewController viewDidLoad](self=0x08f7c620, _cmd=0x00c50587) + 18 at ViewController.m:27, queue = 'com.apple.main-thread, stop reason = breakpoint 1.1
frame #0: 0x0001f482 Meme Collector`-[ViewController viewDidLoad](self=0x08f7c620, _cmd=0x00c50587) + 18 at ViewController.m:27
24
25 - (void)viewDidLoad
26 {
-> 27 [super viewDidLoad];
28 self.memeDescriptionTextView.clipsToBounds = YES;
29 self.memeDescriptionTextView.layer.cornerRadius = 20.0f;
30 [self.moneyLabel sizeToFit];
```
«А тепе-е-ерь… пора нам позабавиться: а то я не играю!»
Мы остановили процесс на кадре (frame) класса `ViewController` (файл ViewController.m). Значит, у нас есть доступ к его переменным экземпляра (instance variables) и к методам. Круто? И ещё! Секция кода уже загружена в память. Следовательно, у нас есть доступ ко всем другим классам, включая — внимание! — синглтоны.
Да, синглтоны. Если вы внимательно изучили этот момент в [первой части](http://habrahabr.ru/post/199128/), вы могли заметить «интересный» класс под названием `MoneyManager`. У него есть метод `purchaseCurrency`, который так и хочется потестировать, а? :)
Наберите в нашем `(lldb)`-терминале:
```
call [[MoneyManager sharedManager] purchaseCurrency]
```
Мы вызвали метод! Отладчик выведет результат выполнения:
```
(BOOL) $0 = YES
```
Если мы увидели ответ `YES` — значит, мы успешно «приобрели» виртуальную валюту. (Тут автор проболтался, это инсайдерская информация. Мы — взломщики — не должны её знать. — *Прим. пер.*)
А ещё LLDB повторяет предыдущую команду по нажатию Enter. Поэтому нажмите несколько раз Enter, чтобы ещё немного ограбить ~~Михалкова~~:
```
(lldb) call [[MoneyManager sharedManager] purchaseCurrency]
(BOOL) $0 = YES
(lldb)
(BOOL) $1 = YES
(lldb)
(BOOL) $2 = YES
(lldb)
(BOOL) $3 = YES
(lldb)
(BOOL) $4 = YES
(lldb)
(BOOL) $5 = YES
(lldb)
(BOOL) $6 = YES
(lldb)
(BOOL) $7 = YES
(lldb)
```
Приобретение ~~и так бесплатного~~ контента никогда не было таким лёгким! Теперь пару раз введите команду
```
c
```
…чтобы закончились все breakpoint'ы, которые мы понаставили, и оцените результат в симуляторе:
Неплохо, да? Ну-ка посмотрим, что мы можем с этим сделать.
Чтобы приостановить выполнение приложения и снова вернуться в командную строку, переключитесь на терминал и там нажмите Ctrl+C. Отладчик LLDB снова готов выполнять наши команды.
Давайте пока закончим сеанс отладки: введите команду **`q`** и затем для подтверждения **`y`**:
```
(lldb) q
Quitting LLDB will detach from one or more processes. Do you really want to proceed: [Y/n] y
```
Возвращаемся на сторону разработчика. Можно ли перехитрить желающих манипулировать вашим приложением через отладчик?
Защита от runtime-манипуляций
-----------------------------
К счастью, есть способ узнать, подключен ли отладчик к нашему коду! Но есть одна проблема. Эта проверка определяет, подключен ли отладчик в данное конкретное время. Хакер (крэкер, читер, ...) может подключиться к приложению после этой проверки, когда приложение уже не подозревает об опасности. Эту проблему можно решить по меньшей мере двумя способами:
1. Включить проверку в цикл выполнения (run loop), так что проверка будет выполняться постоянно.
2. Поставить проверку в наиболее критичных участках кода, где нас больше всего волнует безопасность.
Первый вариант обычно нежелателен. Его цена — трата драгоценного процессорного времени ~~на нагрев девайса~~. Давайте пойдём по второму пути.
Одно элегантное решение — сделать проверку на активность отладчика в синглтоне `MoneyManager`. Например: если мы определили, что происходит отладка, то вернуть `nil` вместо статического экземпляра класса.
**Advanced Mode**В Objective C можно легко это делать, т.к. методы в Objective C — по своей сути не методы, а [сообщения](http://ru.wikipedia.org/wiki/Objective-C). Это значит, что отправка сообщения пустому объекту абсолютно безопасна — она ничего не делает, т.е. код не падает.
Ну наконец-то, поработаем с кодом! Откройте наш проект (в вашей любимой IDE или в Xcode) и перейдите к файлу MoneyManager.m. Вот что мы сделаем: добавим макрос препроцессора, который проверит, в какой конфигурации собрано наше приложение, и если это Release, то проверит, запущен ли отладчик. Если запущен, вернёт `nil`. Иначе всё выполняется, как обычно.
Добавьте 3 строчки в начало метода `sharedManager` класса `MoneyManager`:
```
#ifndef DEBUG
SEC_IS_BEING_DEBUGGED_RETURN_NIL();
#endif
```
Теперь метод должен выглядеть так:
`SEC_IS_BEING_DEBUGGED_RETURN_NIL()` — это вызов стандартного макроса препроцессора, который возвращает `nil`, если к приложению подключен отладчик.
Обратите внимание: этот макрос доступен только в конфигурации Release. Если вы следили за нами в части первой, вы уже должны были переключиться на релиз.
**(на всякий случай напомню)**Xcode: **Product > Scheme > Edit scheme…** (**⌘<**) — слева выбрать Run…, справа вкладка Info > Build Configuration: Release.
AppCode: **Run > Edit configurations…** > Configuration: Release.
**Advanced Mode**Кто-то может сказать, что лучше написать ObjC-метод или Си-функцию вместо макроса препроцессора. Но! Есть очень специфическая причина использовать макрос. Так как мы уже узнали, что любой желающий может подсмотреть имена всех методов, а также изменить их поведение (забегая вперёд: именно это мы будем делать дальше) — зная это, мы хотим спрятать нашу проверку (например, здесь, внутри метода синглтона). В общем, взломщикам будет гораздо труднее найти и пропатчить проверку безопасности, в случае макроса, придётся повозиться в ассемблере.
А теперь запустите наше приложение из IDE (не забыли выбрать конфигурацию Release?)
Xcode: **Run** (⌘R)
AppCode: **Debug** (Ctrl+D)
Xcode автоматически подключает отладчик LLDB при выборе команды Run. Результат: остаток на счёте не отображается! Действительно, где-то там `nil`:
А в AppCode существуют две разные команды: команда **Run** не подключает отладчик, а команда **Debug** — подключает. Удобно.
Чтобы окончательно убедиться в том, что наша защита работает, проверьте: сможете ли вы сейчас купить что-то? `MoneyManager` недоступен — значит, не сможете.
Остановите приложение, нажав в IDE кнопку **Stop** (с квадратом). Также остановите дебаггер LLDB. Переключитесь на симулятор и запустите приложение оттуда. Приложение отобразит валюту, т.к. отладчик не подключен.
Как мы уже говорили, подключить отладчик к процессу можно не только при запуске, но вообще в произвольный момент времени. Выполните в терминале:
```
ps aux | grep "Meme Collector"
```
Вывод данной команды будет содержать список всех процессов, в имени которых встречается фраза «Meme Collector»:
```
dmitriy 2008 0,0 0,0 2432784 636 s001 S+ 1:05 0:00.00 grep Meme Collector
dmitriy 2001 0,0 0,4 857416 32240 ?? S 1:04 0:00.65 /Users/dmitriy/Library/Application Support/iPhone Simulator/7.0.3/Applications/9A72F266-8851-4A25-84E4-9CF8EFF95CD4/Meme Collector.app/Meme Collector
```
Можно видеть, что вторая строчка соответствует папке приложения в симуляторе. Обратите внимание на номер этого процесса (второй столбец). В моём случае это число 2001.
Из терминала запустим LLDB с ключом `-p`, чтобы он подключился к процессу по номеру:
```
lldb -p {ваш номер процесса}
```
Например, мне нужно набрать «lldb -p 2001».
LLDB запустится и сообщит об успешном подключении к процессу:
```
Attaching to process with:
process attach -p 2001
Process 2001 stopped
Executable module set to "/Users/dmitriy/Library/Application Support/iPhone Simulator/7.0.3/Applications/9A72F266-8851-4A25-84E4-9CF8EFF95CD4/Meme Collector.app/Meme Collector".
Architecture set to: i486-apple-macosx.
```
Когда LLDB запущен, попробуйте обратиться к синглтону `MoneyManager`:
```
call [[MoneyManager sharedManager] purchaseCurrency]
```
Попытка «купить» валюту теперь возвращает `NO`, то есть, не проходит.
А попробуем напечатать описание объекта `sharedManager`. Наберите команду:
```
po [MoneyManager sharedManager]
```
И что же в этом описании?
```
nil
```
Чего и требовалось добиться! Наш синглтон не возвращает хоть сколько-нибудь вразумительный результат, а также не показывает сообщение об ошибке в процессе покупки. Простой и непонятный взломщику `nil`.
Продолжим выполнение приложения командой:
```
c
```
Попробуйте легально пополнить свой счёт по кнопке «Purchase Currency». Ничего не выйдет! Ведь LLDB по-прежнему подключен к процессу.
Отключите отладчик от процесса: нажать **Ctrl+C** и затем ввести команду **q**. Кнопка «Purchase Currency» снова работает.
В дополнение к проверке на наличие отладчика, можно применить более жёсткий подход. Функция `ptrace` помогает ~~по возможности~~ сопротивляться подключению GDB / LLDB к вашему приложению.
Для этого вернитесь в IDE и откройте **main.m**. Добавьте один заголовочный файл:
```
#include
```
И три строчки в начало функции `main`:
```
#ifndef DEBUG
ptrace(PT_DENY_ATTACH, 0, 0, 0);
#endif
```
Функция `ptrace` обычно используется в отладчиках, чтобы подключиться к процессу, как это делают — как мы видели — GDB и LLDB. Мы добавили вызов `ptrace`, который со специальным параметром `PT_DENY_ATTACH` просит операционную систему запретить другие процессам (то есть, отладчикам) подключаться к нашему приложению.
Теперь запустим приложение из IDE.
**Xcode**: приложение как будто не запускается. Что происходит? Мы видим на мгновение чёрный экран, который тут же исчезает — это приложение загружается в память и начинает выполняться. При этом Xcode хочет подключить к нему LLDB, но iOS не разрешает и завершает процесс отладчика. «Раз отладчик завершён, — думает Xcode, — приложение завершилось, поэтому остановлю-ка его выполнение». Последняя фраза звучит дико, но всё работает именно так. *— Прим. пер.*
**AppCode**: по команде **Run** (⌘R) приложение нормально запускается, а по команде **Debug** (Ctrl+D) «падает» подобно Xcode.
И из симулятора запускается корректно. Попробуйте теперь подключить к нему отладчик, как обсуждалось выше:
```
lldb -p {номер процесса Meme Collector}
```
Результат — предсказуемый:
```
Attaching to process with:
process attach -p 3435
error: attach failed: process did not stop (no such process or permission problem?)
```
Это хорошее средство, чтобы остановить маленьких детей, начитавшихся хабра, от игр с вашим приложением. Но это не остановит бородатых хакеров. Они остановят ваш процесс при вызове функции `ptrace` и модифицируют её перед продолжением.
В общем, не чувствуйте себя слишком комфортно. Хакеры любят использовать [Cycript](http://www.cycript.org/) — язык скриптов (напоминающий JavaScript) — именно для манипуляций над ObjC-приложениями во время выполнения. Защита от дебаггера, которую мы сделали, не защитит вас от Cycript. Помните, с чего мы начали разговор в предыдущей статье:
> **Ни одно приложение не является безопасным!**
>
>
Препарируем бинарник
--------------------
Прежде чем приступить к модификации бинарных файлов, давайте выясним, как его разобрать на части, и что к чему.
Я буду периодически ссылаться на конкретные адреса в бинарнике для иллюстрации определённых понятий. Если у вас не такая версия компилятора, как у меня (например, поставляемая с более новой Xcode), либо вы компилируете конфигурацию Debug вместо Release, либо сами вносили изменения в проект — адреса могут быть другими. Пусть это вас не смущает — просто следите за изложением, чтобы понять идею.
Формат исполняемых файлов в OS X и iOS называется **Mach-O**. Как правило, бинарник начинается с **заголовка** (header), содержащего всю информацию о том, где и какие данные есть в бинарнике. За этой информацией следуют **команды загрузки** (load commands), которые расскажут вам о разметке файла по сегментам. Кроме того, эти команды определяют специальные флаги: например, зашифрованы ли двоичные данные в файле.
В каждом **сегменте** (segment) есть одна или несколько **секций** (sections). Два вида секций стоит отметить:
* **Текстовая секция**. В основном для данных, предназначенных только для чтения (read-only). Например, исходный код, Си-строки, константы и т.д. Особенность read-only данных в том, что если в системе заканчивается оперативная память, она может легко освободить данные из этих разделов и в дальнейшем (если понадобится) снова загрузить из файла.
* **Секция данных**. В основном для тех данных, которые могут быть модифицированы из кода. Они включают в себя BSS-секции для статических переменных, common-секцию для глобальных переменных [и т.д.](http://en.wikipedia.org/wiki/Data_segment)
А ещё у Apple есть [превосходный справочник по формату Mach-O](https://developer.apple.com/library/mac/documentation/DeveloperTools/Conceptual/MachORuntime/Reference/reference.html) на английском. *— Прим. пер.*
Теперь мы будем исследовать бинарный файл `Meme Collector`, чтобы увидеть всё это в действии. Начнём с заголовка. В терминале, по-прежнему находясь в папке главного бандла «Meme Collector.app», введите:
```
otool -h "Meme Collector"
```
Эта команда напечатает заголовок исполняемого двоичного файла «Meme Collector». Приблизительно так:
```
Meme Collector:
Mach header
magic cputype cpusubtype caps filetype ncmds sizeofcmds flags
0xfeedface 7 3 0x00 2 25 3372 0x01000085
```
**Advanced Mode**0xfeedface (0xFEEDFACE) — это шестнадцатиричный адрес или… какая-то фраза по-английски, вам не кажется? Отвечает [Википедия](http://ru.wikipedia.org/wiki/Hexspeak). *— Прим. пер.*
Заметим: файл имеет 25 команд загрузки (`cmds`), а занимают они 3372 байт (`sizeofcmds`). Посмотрим на эти команды:
```
otool -l "Meme Collector"
```
(Перед этим можно очистить окно терминала, нажав ⌘K. Так будет удобнее листать. — *Прим. пер.*)
Вы получите много-много строк. Из этих строк (даже без предварительной подготовки) можно увидеть много интересного о порядке загрузки сегментов и секций в память. Но это исследование выходит за рамки данного туториала, оставим его наиболее любопытным читателям на [самостоятельное](http://lists.apple.com/archives/xcode-users/2008/Aug/msg00503.html) изучение.
А мы продолжаем наш урок. Найдите (**⌘F**) секцию под названием `__objc_classname`, обратите внимание на `offset` — это «позиция» или «сдвиг» данной секции относительно начала виртуальной памяти, занимаемой приложением.
**Advanced Mode**Про `offset`. Наиболее любопытные, может быть, уже поняли разницу между `addr` и `offset`, почему эта разница везде равна 0x1000 = 4096 байт? Если ещё нет, то почитайте [подробнее](https://developer.apple.com/library/mac/documentation/DeveloperTools/Conceptual/MachORuntime/Reference/reference.html) про `__PAGEZERO`, очень интересная страница.
Здесь сдвиг секции `__objc_classname` равен 159942 байт (в десятичном представлении). На изображении ниже, в левой части — подчёркнуто красным.
Перейдите в терминал. Откройте новое окно терминала (**⌘N**) и из той же папки «Meme Collector.app» выполните:
```
strings -o "Meme Collector"
```
Команда `strings` ищет строки в бинарном файле, а флаг `-o` напишет у каждой строки её позицию относительно начала файла.
Ну-ка, что у нас находится по адресу 159942? Имена классов! (Выделены красным.) Логично, мы же искали секцию `__objc_classname`:
Непосредственно над этой секцией мы видим секцию `__objc_methname`, она начинается начиная с 140887 — здесь у нас имена методов (выделены синим), начиная с метода `init`.
**Advanced Mode**Интересно, почему метод `init` идёт первым?
Там, где имена методов заканчиваются, сразу начинаются имена классов. Секция `__objc_classname` идёт сразу после секции `__objc_methname`. В командах загрузки они шли друг за другом — и загружаются в память последовательно.
Итак, мы видим, как команды загрузки (load commands) позволяют упорядочить тот хаос, который представляет из себя бинарный файл Mach-O. С этим знанием мы приступаем… тадааам! к модификации секции кода.
Тяжёлая артиллерия: дизассемблер и реверс-инжиниринг
----------------------------------------------------
Вы готовы пустить в ход серьёзные пушки? Наконец мы узнаем, как модифицировать бинарный файл приложения!
Вероятно, вы часто слышите в жизни фразу: приложение «взломано». Это значит, кто-то модифицировал приложение так, что оно работает… ммм… иначе, чем задумывал разработчик. Например, не просит зарегистрироваться. Поэтому мы (автор и переводчик) искренне надеемся, что наш труд послужит вам во благо. **Только** для защиты ваших приложений.
Скачайте [IDA Demo](https://www.hex-rays.com/products/ida/support/download_demo.shtml) и какой-нибудь HEX-редактор, например, [Hex Fiend](http://ridiculousfish.com/hexfiend/). IDA — это инструмент, к которому хакеры обращаются чаще всего при изучении бинарников. Это невероятно мощный дизассемблер, отладчик и декомпилятор. И полная версия стоит не так уж дорого.
Но если вы ещё не готовы купить программу, о которой услышали 15 секунд назад, IDA предлагает демонстрационную версию с ограниченным функционалом. В демо-версии ограничены типы ассемблерных файлов, которые можно в нём изучать. А также отключена возможность модификации кода.
Но в ней есть наш тип ассемблера x86. А все модификации мы будем делать вручную в другой программе — Hex Fiend.
**Advanced Mode**«Тип ассемблера… как это x86? Почему не ARM?» — спросите вы. Действительно, iOS-приложение является ARM-бинарником. Но для симулятора компилируются исполняемые файлы под архитектуру x86. Код, скомпилированный для одной архитектуры, не будет работать корректно на другой.
Установите и запустите IDA. Нас приветствует Ада Лавлейс (Ada Lovelace) — первый в мире программист:
Нажмите кнопку **Go**. В терминале мы (да-да) всё ещё находимся в папке бандла (`Meme Collector.app`). Введите следующую команду, чтобы показать данную папку в Finder'е:
```
open -R .
```
Не забудьте про точку в конце. Символ точки здесь означает «текущую папку».
Далее в открывшемся окне Finder: правой кнопкой мыши > **Показать содержимое пакета**:
(OS Mavericks в русском переводе называет бандл (bundle) «пакетом», но мне это название кажется неинформативным. *— Прим. пер.*)
Внутри бандла-пакета вы найдёте исполняемый файл `Meme Collector`, перетащим его в окно IDA и получим диалоговое окно:
Действительно, IDA определил, что этот бинарный файл является исполняемым файлом архитектуры i386.
Ваши настройки должны соответствовать тем, что изображены выше (думаю, вам не придётся ничего менять) — и нажимайте ~~«Поехали!»~~ OK. Дизассемблер разберёт файл по мелким кусочкам и составит его схему (mapping) — то, чем мы занимались выше, но… как сказать… более профессионально. :)
Если спросит «Objective-C 2.0 structures detected. Do you want to parse them and rename methods?» — отвечайте Yes. Если спросит что-то про «proximity view», отвечайте No.
Когда IDA закончит обработку бинарного файла, вы ~~конечно же, придёте в шок~~ увидите главный экран. Если окно IDA не очень похоже на то, что ниже, то в левой панели найдите имя функции `start`, щёлкните на нём и затем нажимайте пробел до тех пор, пока не увидите вот такую красивую блок-схему:
(В моём случае оказалось недостаточно одного пробела, пришлось ещё Enter нажать раз-другой. Ну вы быстро разберётесь, что к чему. *— Прим. пер.*)
И откройте проект в Xcode или AppCode. В целях сокращения изложения, мы чуть-чуть подсмотрим в код.
Откройте **MoneyManager.m** и взгляните на метод `buyObject:`
```
- (BOOL)buyObject:(id)object
{
NSUInteger totalMoney = self.money.unsignedIntegerValue;
NSUInteger cost = [object cost].unsignedIntegerValue;
if (totalMoney < cost) {
return NO;
}
\_money = @(totalMoney - cost);
return [self saveState];
}
```
Изучите алгоритм, он довольно простой. Если переменная эклемпляра `_money` не имеет достаточной суммы, чтобы расплатиться, то функция вернёт `NO`, и транзакция не будет выполнена. Этот условный оператор, разрешающий/запрещающий покупку, полагается на одно булево значение: достаточно ли у пользователя денег? (Напоминает поведение некоторых людей в магазине? — *Прим. пер.*)
Если бы эту проверку обойти («перепрыгнуть», в терминах ассемблера) — можно было бы купить всё, что угодно, тогда значение `_money` уже бы **не** рассматривалось как фактор при покупке.
Теперь найдём тот же код в дизассемблере. Вернитесь к IDA, щёлкните по любой функции на панели Functions (просто чтобы активировать эту панель) и затем нажмите **Сtrl+F** (или из меню: **Edit > Quick Filter**). Появится поле ввода для поиска нашей функции. Нам нужно найти `buyObject:`
Ага, нашли, дважды щёлкните на названии метода. IDA покажет окошко дизассемблера, которое отлично демонстрирует условный оператор и ветвление кода:
Даже если вы ничего не знаете из ~~школьного курса~~ ассемблера, из сравнения с исходным кодом `buyObject:` можно предположить, что зелёная стрелка «вправо» — именно то место, куда мы хотим хакерски пойти, там выполняется много действий. А краткий код под красной стрелкой «влево» больше похож на лаконичное "`return nil`".
Немного нагружу вас ассемблером. Посмотрим на условный оператор («jump»), самый нижний в верхнем блоке, из которого идут две стрелки — красная и зелёная. Это **`jnb`**, что означает «jump if not below» (перейти, если «не меньше»). Судя по всему, мы должны заменить эту инструкцию на «jump always» — инструкцию **`jmp`**.
Чтобы инструкцию заменить, нужно её найти. Дважды щёлкните на операнде `jnb`. Он подсветится жёлтым. Теперь нажмите пробел, чтобы перейти в текстовый режим.
Здесь та же информация, но в линейном виде. Найдите номер строки с командой `jnb` (эта строка выделена):
В моём случае адрес оказался 0x00018D88. Напомню, у вас может быть любой другой адрес.
Код операнда "`jnb short`" — это `0x73??`, где знаки вопроса означают относительное смещение в байтах, куда мы хотим перейти. Нам нужно поменять код операнда на `0xEB??` — код безусловного перехода "`jmp short`" (на то же количество байт). Откуда я взял коды операндов? Например, из [Intel Software Developer’s Manual](http://download.intel.com/products/processor/manual/325462.pdf) (кстати, захватывающее чтение!)
Скачайте (если ещё не скачали) [Hex Fiend](http://ridiculousfish.com/hexfiend/). Установите его, например, скопировав в папку `/Applications`. Из терминала (предполагая, что мы по-прежнему находимся в папке бандла «Meme Collector.app») наберите команду:
```
open -a "/Applications/Hex Fiend.app/" "Meme Collector"
```
Откроется окно с нашим бинарником. Красиво, правда? Вот они — наши знакомые: `__objc_classname` и другие секции. Перед нами явно заголовок исполняемого файла.
Теперь наберите в терминале:
```
otool -l "Meme Collector" | grep -a10 "sectname __text"
```
Как мы видели ранее, `otool -l` отображает команды загрузки двоичного файла в память. Нас интересует секция кода («текстовая» секция), поэтому мы сужаем область поиска командой `grep`. Получили примерно такой ответ:
```
segname __TEXT
vmaddr 0x00001000
vmsize 0x0002e000
fileoff 0
filesize 188416
maxprot 0x00000007
initprot 0x00000005
nsects 11
flags 0x0
Section
sectname __text
segname __TEXT
addr 0x00002970
size 0x0001dec3
offset 6512
align 2^4 (16)
reloff 0
nreloc 0
flags 0x80000400
reserved1 0
reserved2 0
```
Здесь мы видим стартовый адрес секции (`addr`) 0x00002970, а сдвиг (`offset`) — 6512 (десятичное число). Вы можете взять IDA и наглядно убедиться, что стартовый адрес, с которого начинается код — именно 0x2970, для этого надо проскроллить (в «линейном» виде) на самый-самый верх. (Напоминаю, ваши конкретные значения могут отличаться, но смысл тот же).
Отлично! Время заняться арифметикой: нужно пересчитать смещение инструкции `jnb` (найденное для «текстовой» секции) в абсолютное значение внутри бинарного файла. Если вы попробуете изменить байты по адресу, найденному в IDA, вы наверняка где-то словите крэш, т.к. они не совпадают.
Чтобы нам не сильно отвлекаться, я приготовил для вас формулу:
{абсолютная позиция команды в бинарном файле} =
{адрес команды} – {стартовый адрес текстовой секции} + {сдвиг текстовой секции}
В моём случае:
Адрес команды `jnb` = 0x18D88 (из IDA)
Стартовый адрес текстовой секции = 0x2970 (из `otool`)
Сдвиг текстовой секции = десятичное 6512 (из `otool`)
Берём калькулятор, переключаем из меню: **Вид > Для программиста…** (не забудьте переключать на нужную систему счисления при вводе десятичных и 16-ричных чисел).
У меня получилось:
0x18D88 – 0x2970 + 6512 = 0x17D88
**Advanced Mode**Читатели предыдущих спойлеров «Advanced Mode» уже поняли, почему позиция команды в файле отличается от позиции команды в оперативке именно на 0x1000 (0x18D88 – 0x17D88).
Если ваши расчёты оказались верны, это и будет адрес той инструкции `jnb`, которую мы видели в IDA. Теперь в Hex Fiend нажмите **⌘L** (либо из меню **Edit > Jump To Offset**), чтобы открыть поле ввода адреса. Введите своё значение адреса (если вводите в шестнадцатиричном формате, не забудьте `0x` в начале).
Хм, номера строк почему-то в десятичном виде. Ну ладно, пересчитаем: 0x17D88 = 97672, т.е. от позиции 97664 нужно отсчитать ещё 8 байт вправо. 8 байт = 16 шестнадцатиричных цифр = два 4-байтных слова. Видите, Hex Fiend группирует бинарный «текст» по словам:
Пропускаем первые два слова, а в начале третьего слова — вот он — наш код операции `0x7304`. `0x73` — код инструкции, а `0x04` — смещение, на сколько байт процессор должен «прыгнуть» вперёд.
Исправьте `0x73` на `0xEB` (аккуратно: одно нажатие Backspace удаляет сразу 1 байт = два шестнадцатиричных символа). Сохраните (**⌘S**) и закройте файл. Откройте симулятор, удалите приложение из памяти и снова запустите (именно из симулятора, а не из IDE, чтобы не скомпилировалось заново). «Покупайте» мемы, пока у вас не закончатся деньги. Что произошло, когда вы попытались купить товар, который стоит дороже, чем у вас осталось «денег»?
Да, мы действительно выкинули проверку условия «есть ли у пользователя деньги?» Даже без денег, транзакция выполняется. И небольшой бонус: unsigned-значение `_money` «зацикливается», в силу особенностей представления чисел в памяти, вместо отрицательного становится чуть меньше, чем 1032 (около 4 миллиардов).
Защита от реверс-инжиниринга
----------------------------
Как же нам защититься? Помните, я говорил: «ничто не безопасно». Это утверждение работает и здесь. Реверс-инжиниринг можно сильно затруднить, но вы не можете остановить взломщика, если он настроен серьёзно. Ваша единственная надежда — запутать злоумышленников настолько, что они бросят это дело и пойдут ломать другие приложения.
Один из способов — изменить имена важных классов и методов через препроцессор. Откройте проект в IDE и найдите в нём файл «Meme Collector-Prefix.pch». Добавьте в него строчку:
```
#define MoneyManager DS_UIColor_Theme
```
Этот код заменит все вхождения "`MoneyManager`" на название, которое покажется взломщикам менее интересным: "`DS_UIColor_Theme`".
Данный подход должен применяться с большой осторожностью, чтобы ничего не сломать. Нужно убедиться на 100%, что выбранное новое имя больше нигде не встречается в вашем приложении. Иначе запутаете сами себя, с приложением начнут происходить необъяснимые вещи.
Обычно в исполняемом файле есть таблица символов, в которой хранится отображение адресов в читабельные имена функций и методов. И вот, ещё один способ запутать код — удалить таблицу символов после сборки проекта. Это больше подходит для того, чтобы спрятать функции Cи и C++, потому что сообщения Objective C обрабатываются одной функцией `objc_msgSend()`.
Снова откройте **MoneyManager.m** и добавьте следующую Си-функцию в начало:
```
BOOL aSecretFunction(void) {
return YES;
}
```
Затем снова скомпилируйте приложение. Проверим существование данной функции в таблице символов. Из терминала:
```
nm "Meme Collector" | grep aSecretFunction
```
Команда `nm` выводит таблицу символов, а `grep` фильтрует по имени функции. Вот, она тут есть:
```
00018b8f t _aSecretFunction
```
Лёгкий способ удалить таблицу символов из iOS-приложения — в настройках проекта найти две опции: Deployment Postprocessing и Strip Linked Product, и выставить их в Yes:
Затем необходимо «очистить» проект (Xcode: **Product > Clean** или в AppCode: **Run > Clean**) и заново скомплировать. После чего перейдите в терминал и выполните ту же команду:
```
nm "Meme Collector" | grep aSecretFunction
```
Превосходно! Мы успешно удалили символ, который ссылался на `aSecretFunction()`. Теперь взломщику придётся потратить больше времени, чтобы найти критичные моменты в коде.
Что дальше?
-----------
Мы убедились, что злоумышленник может:
* легко увидеть названия селекторов Objective C;
* манипулировать файлами, к которым обращается ваше приложение;
* перехватывать и модифицировать сетевое взаимодействие;
* управлять средой выполнения;
* менять исполняемый файл вашего приложения.
При создании приложения важно помнить эти вещи. Подумайте, сколько усилий вы готовы приложить, чтобы сделать приложение более безопасным. **Что такое безопасность?** Это всегда баланс между вашими ресурсами (временем), уровнем проблем для ваших пользователей, и — вероятностью взлома.
Безопасность iOS-приложения — это серьёзная тема. Можно ещё многому научиться. Пока мы только чуть-чуть поскребли по поверхности. Весь спектр возможностей отладчика и других инструментов для анализа кроется гораздо глубже. Если вам интересна эта тема, советую подумать о джейлбрейке тестового девайса. Файловая система даст богатую пищу для исследований.
Если у вас нет проблем с английским, обязательно ознакомьтесь с книгой **Hacking and Securing iOS Applications** (автор Jonathan Zdziarski). Хотя она слегка устарела (придётся погуглить на предмет изменений в механизме шифрования приложений Apple), но у автора статьи это одна из любимых книг по iOS и по безопасности.
Ещё пара книг:
**Hacking: The Art of Exploitation, 2nd Edition** by Jon Erickson
**Mac OS X and iOS Internals: To the Apple's Core** by Jonathan Levin
Форумы:
<http://www.woodmann.com>
<http://www.reddit.com/r/ReverseEngineering>
Статья по инъекции кода:
<http://blog.timac.org/?p=761>
Автору можно писать [в комменты](http://www.raywenderlich.com/46223/ios-app-security-analysis-part-2#comments), а по переводу пишите на почту *dev`@`x128.ru*. | https://habr.com/ru/post/199130/ | null | ru | null |
# Mozilla Firefox завибрирует
Этой зимою нам довелось заметить такие полезные новинки в мобильном Файерфоксе, как контроль за [зарядом аккумулятора](http://habrahabr.ru/blogs/firefox/135474/) и управление [мобильной связью и SMS](http://habrahabr.ru/blogs/firefox/137054/). Позавчера [во блоге Mozilla Hacks](http://hacks.mozilla.org/2012/01/using-the-vibrator-api-part-of-webapi/) были опубликованы сведения о том, что разработчики Firefox 11 также обеспечили сайтам интерфейс, управляющий **вибрацией** мобильного телефона.
В простейшем случае достаточно задать джаваскриптом длительность вибрации, выраженную в миллисекундах:
```
navigator.mozVibrate(1000);
```
Несколько более сложная вибрация задаётся при помощи массива, нечётные элементы которого задают длительность вибрации, а чётные — длительность последующей паузы. Вот пример краткой двойной вибрации:
```
navigator.mozVibrate([200, 100, 200, 100]);
```
Чтобы немедленно прекратить вибрацию мобильника (не дожидаясь окончания указанных длительностей), достаточно передать тому же методу нулевую длительность или пустой массив:
```
navigator.mozVibrate(0);
navigator.mozVibrate([]);
```
Черновик соответствующего стантарта опубликован [на сайте W3C](http://www.w3.org/TR/vibration/). | https://habr.com/ru/post/137173/ | null | ru | null |
# Шифрование в EXT4. How It Works?
 Паранойя не лечится! Но и не преследуется по закону. Поэтому в Linux Kernel 4.1 добавлена поддержка шифрования файловой системы ext4 на уровне отдельных файлов и директорий. Зашифровать можно только пустую директорию. Все файлы, которые будут созданы в такой директории, также будут зашифрованы. Шифруются только имена файлов и содержимое, метаданные не шифруются, inline data (когда данные файла, не превышающие по размеру 60 байт, хранятся в айноде) в файлах не поддерживается. Поскольку расшифровка содержимого файла выполняется непосредственно в памяти, шифрование доступно только в том случае, когда размер кластера совпадает с PAGE\_SIZE, т.е. равен 4К.
### 1. Как это работает
Для начала необходимо освоить несколько полезных команд
**Форматирование тома с опцией шифрования**
```
# mkfs.ext4 -O encrypt /dev/xxx
```
**Включение опции шифрования на существующий том**
```
# tune2fs -O encrypt /dev/xxx
```
**Создание ключа шифрования**
```
# mount /dev/xxx /mnt/xxx
$ e4crypt add_key
Enter passphrase (echo disabled):
Added key with descriptor [8e679e4449bb9235]
```
При создании ключа том с поддержкой шифрования должен быть примонтирован, иначе e4crypt выдаст ошибку “No salt values available”. Если примонтировано несколько томов с опцией encrypt, то будут созданы ключи для каждого. Утилита e4crypt входит в состав e2fsprogs.
Ключи добавляются в Linux Kernel Keyring [1].
**Чтение списка ключей**
```
$ keyctl show
Session Keyring
771961813 --alswrv 1000 65534 keyring: _uid_ses.1000
771026675 --alswrv 1000 65534 \_ keyring: _uid.1000
803843970 --alsw-v 1000 1000 \_ logon: ext4:8e679e4449bb9235
```
Ключи, используемые для шифрования, имеют тип “logon”. Содержимое (payload) ключей такого типа недоступно из пространства пользователя — keyctl команды read, pipe, print вернут ошибку. В данном примере у ключа префикс “ext4”, но может быть и “fscrypt”. Если keyctl отсутствует в системе, то необходимо установить пакет keyutils.
**Создание зашифрованной директории**
```
$ mkdir /mnt/xxx/encrypted_folder
$ e4crypt set_policy 8e679e4449bb9235 /mnt/xxx/encrypted_folder/
Key with descriptor [8e679e4449bb9235] applied to /mnt/xxx/encrypted_folder/.
```
Здесь в команду set\_policy передается дескриптор созданного ключа без указания префикса (ext4) и типа (logon). Одним и тем же ключом можно зашифровать несколько директорий. Для шифрования разных директорий можно использовать разные ключи. Чтобы узнать, каким ключом зашифрована директория, необходимо выполнить команду:
```
$ e4crypt get_policy /mnt/xxx/encrypted_folder/
/mnt/xxx/encrypted_folder/: 8e679e4449bb9235
```
Установить другую политику безопасности на зашифрованную директорию не получится:
```
$ e4crypt add_key
Enter passphrase (echo disabled):
Added key with descriptor [9dafe822ae6e7994]
$ e4crypt set_policy 9dafe822ae6e7994 /mnt/xxx/encrypted_folder/
Error [Invalid argument] setting policy.
The key descriptor [9dafe822ae6e7994] may not match the existing encryption context for directory [/mnt/xxx/encrypted_folder/].
```
Зато такую директорию можно беспрепятственно удалить:
```
$ rm -rf /mnt/xxx/encrypted_folder/
$ ll /mnt/xxx
total 24
drwxr-xr-x 3 user user 4096 Apr 21 15:14 ./
drwxr-xr-x 4 root root 4096 Mar 29 15:30 ../
drwx------ 2 root root 16384 Apr 17 12:41 lost+found/
$
```
**Шифрование файла**
```
$ echo "My secret file content" > /mnt/xxx/encrypted_folder/my_secrets.txt
$ cat /mnt/xxx/encrypted_folder/my_secrets.txt
My secret file content
$ ll /mnt/xxx/encrypted_folder/
total 12
drwxr-xr-x 2 user user 4096 Apr 20 14:25 ./
drwxr-xr-x 5 user user 4096 Apr 20 14:15 ../
-rw-r--r-- 1 user user 23 Apr 20 14:26 my_secrets.txt
```
Имена файлов в директории и содержимое файла будут доступны, пока в хранилище ключей существует ключ, которым была зашифрована директория. После аннулирования ключа доступ к директории будет сильно ограничен:
```
$ keyctl revoke 803843970
$ keyctl show
Session Keyring
771961813 --alswrv 1000 65534 keyring: _uid_ses.1000
771026675 --alswrv 1000 65534 \_ keyring: _uid.1000
803843970: key inaccessible (Key has been revoked)
```
Ключ аннулирован, читаем содержимое директории:
```
$ ll /mnt/xxx/encrypted_folder/
total 12
drwxr-xr-x 2 user user 4096 Apr 20 14:25 ./
drwxr-xr-x 5 user user 4096 Apr 20 14:15 ../
-rw-r--r-- 1 user user 23 Apr 20 14:26 BhqTNRNHDBwpa9S1qCaXwC
```
Имя файла уже абырвалг. Но всё-таки попробуем прочитать файл:
```
$ cat /mnt/xxx/encrypted_folder/BhqTNRNHDBwpa9S1qCaXwC
cat: /mnt/xxx/encrypted_folder/BhqTNRNHDBwpa9S1qCaXwC: Required key not available
```
**NOTE:** в Ubuntu 17.04 (kernel 4.10.0-19) директория остается доступной после удаления ключа до перемонтирования.
```
$ keyctl show
Session Keyring
771961813 --alswrv 1000 65534 keyring: _uid_ses.1000
771026675 --alswrv 1000 65534 \_ keyring: _uid.1000
$ e4crypt get_policy /mnt/xxx/encrypted_folder/
/mnt/xxx/encrypted_folder/: 8e679e4449bb9235
```
Директория зашифрована ключом с дескриптором “8e679e4449bb9235”. Ключ отсутствует в хранилище. Несмотря на это, директория и содержимое файла в свободном доступе.
```
$ ll /mnt/xxx/encrypted_folder/
total 12
drwxr-xr-x 2 user user 4096 Apr 20 14:25 ./
drwxr-xr-x 5 user user 4096 Apr 20 14:15 ../
-rw-r--r-- 1 user user 23 Apr 20 14:26 my_secrets.txt
$ cat /mnt/xxx/encrypted_folder/my_secrets.txt
My secret file content
```
Перемонтирование:
```
# umount /dev/xxx
# mount /dev/xxx /mnt/xxx
$ ll /mnt/xxx/encrypted_folder/
total 12
drwxr-xr-x 2 user user 4096 Apr 20 14:25 ./
drwxr-xr-x 5 user user 4096 Apr 20 14:15 ../
-rw-r--r-- 1 user user 23 Apr 20 14:26 BhqTNRNHDBwpa9S1qCaXwC
```
### 2. Изменения в файловой системе
В Суперблоке: набор опций s\_feature\_incompat на томе с поддержкой шифрования содержит флаг EXT4\_FEATURE\_INCOMPAT\_ENCRYPT,
s\_encrypt\_algos[4] — хранит алгоритмы шифрования; на данный момент это:
s\_encrypt\_algos[0] = EXT4\_ENCRYPTION\_MODE\_AES\_256\_XTS;
s\_encrypt\_algos[1] = EXT4\_ENCRYPTION\_MODE\_AES\_256\_CTS;
s\_encrypt\_pw\_salt — также задается при форматировании.
В айноде: i\_flags содержит флаг EXT4\_ENCRYPT\_FL и именно по нему можно определить, что объект зашифрован.
**Структура зашифрованной директории**
Чтобы прочитать содержимое директории, нужно по ее айноду определить ее местоположение на диске.
**1. Определение номера айнода:**
```
$ stat /mnt/xxx/encrypted_folder/
File: /mnt/xxx/encrypted_folder/
Size: 4096 Blocks: 8 IO Block: 4096 directory
Device: 811h/2065d Inode: 14 Links: 2
```
**2. Поиск айнода в таблице айнодов.**
Айнод 14 принадлежит 0-й группе, поэтому необходимо прочитать таблицу дескрипторов 0-й группы и найти в ней номер блока таблицы айнодов. Таблица дескрипторов 0-й группы находится в кластере, следующим за суперблоком:
```
# dd if=/dev/xxx of=gdt bs=4096 count=1 skip=1
```
*Рис. 1. Таблица дескрипторов 0-й группы*
Вначале пропускаем номера кластеров битмапа блоков и битмапа айнодов, номер кластера начала таблицы айнодов читаем по смещению 8 байт от начала таблицы — 0x00000424 (1060) в BigEndian формате. Айнод директории = 14, при размере айнода в 256 байт в таблице он будет находиться по смещению 0x0D00 от ее начала. Таким образом, достаточно прочитать только 1-й кластер таблицы айнодов:
```
# dd if=/dev/xxx of=itable bs=4096 count=1 skip=1060
```
*Рис. 2. Айнод зашифрованной директории.*
В айноде определяем начало поля i\_block[]. Т.к. это ext4, то в первых 2 байтах i\_block находится заголовок дерева экстентов — 0xF30A. Далее можно увидеть номер блока, в котором хранится зашифрованная директория — 0x00000402 (1026). (На рисунке выделено не всё поле i\_block, а только информативные 24 байта — остальные 36 байт заполнены нулями.)
**3. Чтение блока директории:**
```
# dd if=/dev/xxx of=dirdata bs=4096 count=1 skip=1026
```
*Рис. 3. Дамп зашифрованной директории.*
Подробнее: первые две entry (выделены красным) — это записи “.” и “..”, соответственно, текущая и родительская директории. У текущей директории айнод 0x0000000E, длина записи 0x000C байт, количество символов в имени файла — 01 и тип entry 02 — это директория. Далее следует имя директории, выровненное по 4-байтовой границе — 2E000000 (2E соответствует символу ‘.’ — точка).
Следующая, родительская директория, имеет айнод 0x00000002 (корневая директория), аналогичная длина записи 0x000C, в имени 02 символа, тип также 02, после чего идет имя директории — 2E2E0000 (две точки).
Наконец, последняя entry в данной директории имеет айнод 0x0000000F, размер записи 0x0FDC, количество символов в имени 0x10, тип 01 — это и есть зашифрованный файл. Как видно его имя не соответствует созданному my\_secrets.txt. К тому же, в исходном имени файла всего 14 символов, а не 16 как здесь.
**NOTE:** особенно внимательные читатели с калькулятором могли заметить, что т.к. зашифрованный файл является последней entry в директории, то его размер записи должен ссылаться на границу блока. Однако, 0x1000 — 0xC — 0xC = 0xFE8, а не 0xFDC. Это связано с тем, что том создавался с опцией “metadata\_csum”, которая задается по умолчанию, начиная с Ubuntu 16.10. При включении этой опции в конце каждого блока директории создается 12-байтовая структура, содержащая контрольную сумму этого блока.
**4. Чтение зашифрованного файла.**
Из дампа директории определяем, что файл имеет айнод 15 (0xF). Ищем его в таблице айнодов и аналогично определяем его положение на диске:
*Рис. 4. Айнод зашифрованного файла.*
Читаем содержимое кластера 0x0000AA00 (43520)
```
# dd if=/dev/xxx of=filedata bs=4096 count=1 skip=43520
```
*Рис. 5. Содержимое зашифрованного файла*
И это совсем не соответствует записанной в файл информации. Настоящий размер файла можно прочитать в поле i\_size айнода (отмечен синим прямоугольником на рис. 4): 0x00000017 — именно столько было записано командой echo “My secret file content” + символ перевода строки 0x0A.
### 3. Расшифровка
**Расшифровка имени файла**
Согласно EXT4 Encryption Design Document [2] расшифровка имен файлов выполняется в два этапа:
1. DerivedKey = AES-128-ECB(data=MasterKey, key=DirNonce);
2. EncFileName = AES-256-CBC-CTS(data=DecFileName, key=DerivedKey);
Т.е. на первом этапе надо получить ключ для расшифровки. Для этого используются данные Мастер-ключа, созданного при добавлении ключа в keyring, которые шифруются по AES-ECB 128-битным ключом DirNonce. На втором этапе используется фиксированный вектор инициализации (IV), заполненный нулями. Для AES-ECB вектор инициализации не нужен.
Что такое DirNonce? В айноде зашифрованной директории есть extended attribute.
*Рис. 6. Айнод зашифрованной директории и его extended attribute*
При размере айнода в 256 байт в структуре остается около сотни неиспользуемых байт (0x100 — EXT2\_GOOD\_OLD\_INODE\_SIZE — i\_extra\_size), в которых можно хранить информацию (красная область на рис. 6). Как видно по заголовку 0xEA020000 в первых четырех байтах этой области, здесь хранится extended attribute с индексом 09, данные которого смещены на 0x40 байт от заголовка и имеют размер 0x1C. Область данных поделена на 3 зоны: в первой (01 01 04 00) записаны алгоритмы, по которым был зашифрован айнод. Во второй — хранится 8 байт (8E 67 9E 44 49 BB 92 35), повторяющие дескриптор ключа. В третьей — содержится 16-байтовый одноразовый код (нонс [3]), используемый при шифровании Мастер-ключа.
Таким образом, для расшифровки имени файла, необходимо:
1) прочитать значение безымянного extended attribute директории с индексом 9 — получаем нонс директории;
2) по алгоритму AES-ECB зашифровать данные Мастер-ключа, используя в качестве ключа 128 бит нонса директории;
3) по алгоритму AES-CBC-CTS расшифровать имя файла, используя в качестве ключа первые 256 бит (половину) ключа, полученного на предыдущем этапе.
**Расшифровка содержимого файла**
Выполняется аналогично процедуре расшифровки имени файла, за исключением того, что в качестве нонса используется значение extended attribute, полученное из айнода файла. И вместо CBC содержимое дешифруется по алгоритму AES-XTS с полным 64-байтовым ключом. В качестве IV используется Logical Block Offset относительно начала файла
*Рис. 7. Айнод зашифрованного файла и его extended attribute.*
Сравнивая значение extended attribute зашифрованного файла и директории, можно заметить, что их нонсы различаются, в то время как алгоритмы шифрования и дескрипторы ключей совпадают (желтая и синяя зоны на рисунках).
Содержимое файлов шифруется постранично, поэтому для расшифровки контента обязательно использовать целый кластер файла (4K), а не размер, указанный в поле i\_size айнода.
**4. Реализация**
Реализация дешифратора выполнена на основе Linux Kernel Crypto API [4]. В цепочке используется два вида шифраторов в зависимости от того, что прописано в /proc/crypto для алгоритмов ebc(aes), cts(cbc(aes)), xts(aes). Рассматриваем ядро 4.10.0-19: шифр ebc реализуется через blkcipher, cts(cbc) и xts — через skcipher:
**$ cat /proc/crypto**$ cat /proc/crypto
name: ecb(aes)
driver: ecb(aes-aesni)
module: kernel
priority: 300
internal: no
type: blkcipher
blocksize: 16
min keysize: 16
max keysize: 32
ivsize: 0
geniv: default
name: cts(cbc(aes))
driver: cts(cbc-aes-aesni)
module: kernel
priority: 400
internal: no
type: skcipher
async: yes
blocksize: 16
min keysize: 16
max keysize: 32
ivsize: 16
chunksize: 16
name: xts(aes)
driver: xts-aes-aesni
module: aesni\_intel
priority: 401
internal: no
type: skcipher
async: yes
blocksize: 16
min keysize: 32
max keysize: 64
ivsize: 16
chunksize: 16
**Реализация шифратора через blkcipher**
```
typedef enum { ENCRYPT, DECRYPT } cipher_mode;
static int do_blkcrypt(const u8* cipher, const u8* key, u32 key_len,
void* iv, void* dst, void* src, size_t src_len, cipher_mode mode)
{
int res;
struct crypto_blkcipher* blk;
struct blkcipher_desc desc;
struct scatterlist sg_src, sg_dst;
blk = crypto_alloc_blkcipher(cipher, 0, 0);
if (IS_ERR(blk))
{
printk(KERN_WARNING "Failed to initialize blkcipher mode %s\n", cipher);
return PTR_ERR(blk);
}
res = crypto_blkcipher_setkey(blk, key, key_len);
if (res)
{
printk(KERN_WARNING "Failed to set key. len=%#x\n", key_len);
crypto_free_blkcipher(blk);
return res;
}
crypto_blkcipher_set_iv(blk, iv, 16);
sg_init_one(&sg_src, src, src_len);
sg_init_one(&sg_dst, dst, src_len);
desc.tfm = blk;
desc.flags = 0;
if (mode == ENCRYPT)
res = crypto_blkcipher_encrypt(&desc, &sg_dst, &sg_src, src_len);
else
res = crypto_blkcipher_decrypt(&desc, &sg_dst, &sg_src, src_len);
crypto_free_blkcipher(blk);
return res;
}
```
**Реализация шифратора через skcipher**
```
struct tcrypt_result {
struct completion completion;
int err;
};
static void crypt_complete_cb(struct crypto_async_request* req, int error)
{
struct tcrypt_result* res = req->data;
if (error == -EINPROGRESS)
return;
res->err = error;
complete(&res->completion);
}
static int do_skcrypt(const u8* cipher, const u8* key, u32 key_len,
void* iv, void* dst, void* src, size_t src_len, cipher_mode mode)
{
struct scatterlist src_sg, dst_sg;
struct crypto_skcipher* tfm;
struct skcipher_request* req = 0;
struct tcrypt_result crypt_res;
int res = -EFAULT;
tfm = crypto_alloc_skcipher(cipher, 0, 0);
if (IS_ERR(tfm))
{
printk(KERN_WARNING "Failed to initialize skcipher mode %s\n", cipher);
res = PTR_ERR(tfm);
tfm = NULL;
goto out;
}
req = skcipher_request_alloc(tfm, GFP_NOFS);
if (!req)
{
printk(KERN_WARNING "Couldn't allocate skcipher handle\n");
res = -ENOMEM;
goto out;
}
skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG | CRYPTO_TFM_REQ_MAY_SLEEP,
crypt_complete_cb, &crypt_res);
if (crypto_skcipher_setkey(tfm, key, key_len))
{
printk(KERN_WARNING "Failed to set key\n");
res = -EINVAL;
goto out;
}
sg_init_one(&src_sg, src, src_len);
sg_init_one(&dst_sg, dst, src_len);
skcipher_request_set_crypt(req, &src_sg, &dst_sg, src_len, iv);
init_completion(&crypt_res.completion);
if (mode == ENCRYPT)
res = crypto_skcipher_encrypt(req);
else
res = crypto_skcipher_decrypt(req);
switch (res)
{
case 0: break;
case -EINPROGRESS:
case -EBUSY:
wait_for_completion(&crypt_res.completion);
if (!res && !crypt_res.err)
{
reinit_completion(&crypt_res.completion);
break;
}
default:
printk("Skcipher %scrypt returned with err = %d, result %#x\n",
mode == ENCRYPT ? "en" : "de", res, crypt_res.err);
break;
}
out:
if (tfm)
crypto_free_skcipher(tfm);
if (req)
skcipher_request_free(req);
return res;
}
```
**Чтение данных (payload) Мастер-ключа**
```
#define MASTER_KEY_SIZE 64
static int GetMasterKey(const u8* descriptor, u8* raw)
{
struct key* keyring_key = NULL;
const struct user_key_payload* ukp;
struct fscrypt_key* master_key;
keyring_key = request_key(&key_type_logon, descriptor, NULL);
if (IS_ERR(keyring_key))
return -EINVAL;
if (keyring_key->type != &key_type_logon)
{
printk_once(KERN_WARNING "%s: key type must be 'logon'\n", __func__);
return -EINVAL;
}
down_read(&keyring_key->sem);
ukp = user_key_payload(keyring_key);
master_key = (struct fscrypt_key*)ukp->data;
up_read(&keyring_key->sem);
if (master_key->size != MASTER_KEY_SIZE)
{
printk(KERN_WARNING "Wrong Master key size %#x\n", master_key->size);
return -EINVAL;
}
memcpy(raw, master_key->raw, master_key->size);
return 0;
}
```
**NOTE:** В версиях ядра младше 4.4 отсутствует функция user\_key\_payload. Данные ключа можно прочитать непосредственно из struct key\* keyring\_key.
**Расшифровка имени файла**
```
int err;
u8 iv[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
u8 nonce_dir[16] = { ... };
u8 master_key[64], derived_key[64];
u8 dec_file_name[] = { ... };
u8 enc_file_name[sizeof(dec_file_name)];
err = do_blkcrypt("ecb(aes)", nonce_dir, 16, iv, derived_key, master_key,
MASTER_KEY_SIZE, ENCRYPT);
if (err)
return err;
err = do_skcrypt("cts(cbc(aes))", derived_key, MASTER_KEY_SIZE / 2, iv,
dec_file_name, enc_file_name, sizeof(dec_file_name), DECRYPT);
return err;
```
**Расшифровка контента**
Для упрощения опущена работа с памятью. Предположим, 2 x PAGE\_SIZE нам дали на стеке.
```
u8 nonce_file[16] = { ... };
u8 enc_file_data[PAGE_SIZE] = { ... };
u8 dec_file_data[PAGE_SIZE];
err = do_blkcrypt("ecb(aes)", nonce_file, 16, iv, derived_key, master_key,
MASTER_KEY_SIZE, ENCRYPT);
if (err)
return err;
err = do_skcrypt("xts(aes)", derived_key, MASTER_KEY_SIZE, iv,
dec_file_data, enc_file_data, PAGE_SIZE, DECRYPT);
return err;
```
**Используемые заголовочные файлы (актуально для 4.10.0-19)**
```
#include
#include
#include
#include
```
**Makefile**
```
obj-m += ciphertest.o
all:
make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
clean:
make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
```
### 5. Результаты
Исходные данные:
```
u8 master_key[MASTER_KEY_SIZE] = {
0xa5, 0xb5, 0xc9, 0x23, 0x02, 0x14, 0xfc, 0xf7,
0x28, 0xdc, 0x90, 0x25, 0x24, 0x9e, 0xe6, 0xbc,
0x7c, 0xa8, 0xf8, 0xe1, 0x94, 0xf6, 0x67, 0x32,
0x33, 0xc4, 0xc1, 0xe8, 0x78, 0x59, 0xab, 0xfb,
0xae, 0xb0, 0xbf, 0x5d, 0x2c, 0x69, 0xc3, 0x8f,
0x51, 0x37, 0x26, 0x3f, 0xd1, 0xce, 0x37, 0xef,
0x3f, 0x80, 0xe3, 0x2d, 0xd5, 0xfd, 0x78, 0x45,
0x62, 0xf3, 0xa5, 0x24, 0x6b, 0xcf, 0x4a, 0x88
};
u8 enc_file_name[] = {
0x41, 0xa8, 0x4e, 0x4d, 0xd4, 0x1c, 0x43, 0x00,
0xa7, 0x5a, 0x2f, 0xd5, 0xaa, 0xa0, 0x5d, 0xb0
};
u8 nonce_dir[] = {
0x37, 0xba, 0x14, 0x16, 0x3e, 0xa8, 0xd5, 0x48,
0xd1, 0x3c, 0xb5, 0x6a, 0x01, 0xb7, 0x7c, 0x41
};
u8 nonce_file[] = {
0x61, 0x63, 0xb8, 0x31, 0xf4, 0xf5, 0xfc, 0x99,
0x1e, 0x3c, 0xf1, 0x8a, 0x23, 0xaf, 0x1e, 0xa8
};
```
Закодированное имя файла enc\_file\_name получено из дампа директории (рис. 3).
Нонс директории nonce\_dir получен из дампа айнода директории (рис. 6)
Нонс файла nonce\_file получен из дампа айнода файла (рис. 7)
Мастер-ключ показан здесь полностью для наглядности. Его можно получить при отладке e4crypt:
Результат работы созданного драйвера
**Ссылки**[1] KERNEL KEY RETENTION SERVICE, [www.kernel.org/doc/Documentation/security/keys.txt](https://www.kernel.org/doc/Documentation/security/keys.txt)
[2] EXT4 Encryption Design Document, [docs.google.com/document/d/1ft26lUQyuSpiu6VleP70\_npaWdRfXFoNnB8JYnykNTg/edit](https://docs.google.com/document/d/1ft26lUQyuSpiu6VleP70_npaWdRfXFoNnB8JYnykNTg/edit)
[3] Wikipedia — Nonce, [ru.wikipedia.org/wiki/Nonce](https://ru.wikipedia.org/wiki/Nonce)
[4] Linux Kernel Crypto API, [www.kernel.org/doc/html/latest/crypto/index.html](https://www.kernel.org/doc/html/latest/crypto/index.html) | https://habr.com/ru/post/327682/ | null | ru | null |
# Rust 1.60.0: покрытие на основе исходного кода, новый синтаксис условной компиляции в Cargo, инкрементальная компиляция
Команда Rust публикует новую версию языка — 1.60.0. Rust — это язык программирования, позволяющий каждому создавать надёжное и эффективное программное обеспечение.
Если у вас есть предыдущая версия Rust, установленная через `rustup`, то для обновления до версии 1.60.0 вам достаточно выполнить команду:
```
rustup update stable
```
Если у вас ещё нет `rustup`, то можете установить его со [страницы](https://www.rust-lang.org/install.html) на нашем веб-сайте, а также ознакомиться с [подробным описанием выпуска 1.60.0](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1600-2022-04-07) на GitHub. Если вы хотите помочь нам протестировать будущие выпуски, вы можете использовать beta (`rustup default beta`) или nightly (`rustup default nightly`) канал. Пожалуйста, [сообщайте](https://github.com/rust-lang/rust/issues/new/choose) обо всех встреченных вами ошибках.
Что стабилизировано в 1.60.0
----------------------------
### Покрытие исходного кода
Поддержка инструментов покрытия на основе LLVM стабилизирована в rustc. Вы можете попробовать это на своём коде, перестроив его с помощью `-Cinstrument-coverage`, например так:
```
RUSTFLAGS="-C instrument-coverage" cargo build
```
После этого вы можете запустить полученный двоичный файл, который создаст файл `default.profraw` в текущем каталоге. (Путь и имя файла могут быть переопределены переменной среды; подробности см. в [документации](https://doc.rust-lang.org/stable/rustc/instrument-coverage.html#running-the-instrumented-binary-to-generate-raw-coverage-profiling-data)).
Компонент `llvm-tools-preview` включает `llvm-profdata` для обработки и слияния необработанных выходных данных профиля (счётчики выполнения области покрытия), а также `llvm-cov` для генерации отчётов. `llvm-cov` объединяет обработанный вывод из `llvm-profdata` и сам двоичный файл, потому что двоичный файл включает сопоставление счётчиков с фактическими областями исходного кода.
```
rustup component add llvm-tools-preview
$(rustc --print sysroot)/lib/rustlib/x86_64-unknown-linux-gnu/bin/llvm-profdata merge -sparse default.profraw -o default.profdata
$(rustc --print sysroot)/lib/rustlib/x86_64-unknown-linux-gnu/bin/llvm-cov show -Xdemangler=rustfilt target/debug/coverage-testing \
-instr-profile=default.profdata \
-show-line-counts-or-regions \
-show-instantiations
```
Приведённые выше команды в простом двоичном файле helloworld создают этот аннотированный отчёт, показывающий, что каждая строка ввода была обработана.
```
1| 1|fn main() {
2| 1| println!("Hello, world!");
3| 1|}
```
Для получения более подробной информации, пожалуйста, прочитайте [документацию](https://doc.rust-lang.org/rustc/instrument-coverage.html) в книге rustc. Базовая функциональность стабильна и будет существовать в той или иной форме во всех будущих выпусках Rust, но конкретный формат вывода и инструменты LLVM, которые его производят, могут быть изменены. По этой причине важно убедиться, что вы используете одну и ту же версию как для `llvm-tools-preview`, так и для двоичного файла rustc, используемого для компиляции вашего кода.
### `cargo --timings`
В Cargo стабилизирована поддержка сбора информации о сборке с помощью флага `--timings`.
```
$ cargo build --timings
Compiling hello-world v0.1.0 (hello-world)
Timing report saved to target/cargo-timings/cargo-timing-20220318T174818Z.html
Finished dev [unoptimized + debuginfo] target(s) in 0.98s
```
Этот отчёт так же сохраняется в `target/cargo-timings/cargo-timing.html`. Отчёт релизной сборки можно найти [здесь](/images/2022-04-07-timing.html). Эти отчёты будут полезны для улучшения производительности сборки. В [документации](https://doc.rust-lang.org/nightly/cargo/reference/timings.html) можно найти больше информации об этих отчётах.
### Новый синтаксис для свойств Cargo
В этом выпуске представлены два изменения, которые улучшают поддержку [свойств Cargo](https://doc.rust-lang.org/cargo/reference/features.html) и то, как они взаимодействуют с [необязательными зависимостями](https://doc.rust-lang.org/cargo/reference/features.html#optional-dependencies): пространствами имён зависимостей и слабыми свойствами зависимостей.
У Cargo есть постоянно поддерживаемые свойства и необязательные зависимости, как показано в следующем фрагменте:
```
[dependencies]
jpeg-decoder = { version = "0.1.20", default-features = false, optional = true }
[features]
# Включает поддержку параллельной обработки при помощи включения функциональности "rayon" у jpeg-decoder.
parallel = ["jpeg-decoder/rayon"]
```
По этому примеру есть два замечания:
* Необязательная зависимость `jpeg-decoder` неявно объявляет свойство с таким же именем. Подключение свойства `jpeg-decoder` подключит зависимость `jpeg-decoder`
* Синтаксис `"jpeg-decoder/rayon"` подключает зависимость `jpeg-decoder` *и* функциональность `rayon` у зависимости `jpeg-decoder`.
Пространства имён свойств решают первую задачу. Теперь вы можете использовать префикс `dep:` в таблице `[features]` для явной отсылки к необязательной зависимости без неявного создания одноимённого свойства. Это даёт вам больше контроля над тем, как объявленное свойство соотносится с необязательными зависимостями, включая скрытие опциональных зависимостей за более описательными именами.
Свойства (features) слабых зависимостей решают вторую задачу, в которой синтаксис `"optional-dependency/feature-name"` всегда будет подключать `optional-dependency`. Однако часто нужно включить свойство необязательной зависимости *только* если включено некоторое другое свойство опциональной зависимости. Начиная с 1.60 вы можете добавить символ `?` — как в `"package-name?/feature-name"`, чтобы показать, что нужно включить данное свойство только если подключена опциональная зависимость.
Например, мы добавим поддержку сериализации в нашу библиотеку, что потребует включить соответствующее свойство в некоторых необязательных зависимостях. Сделать это можно следующим образом:
```
[dependencies]
serde = { version = "1.0.133", optional = true }
rgb = { version = "0.8.25", optional = true }
[features]
serde = ["dep:serde", "rgb?/serde"]
```
В этом примере подключение свойства `serde` подключит зависимость `serde`. Также она подключит свойство `serde` пакета `rgb`, но только в случае, если эта зависимость подключена.
### Статус инкрементальной компиляции
Инкрементальная компиляция была снова включена в выпуске 1.60. Команда Rust продолжает работать над исправлением в ней ошибок, но в настоящее время не известно никаких проблем, вызывающих глобальные поломки, так что мы решили вернуть инкрементальную сборку. Дополнительно команда, работающая над компилятором, сейчас продолжает создавать долгосрочную стратегию, чтобы в будущем избежать проблем такого типа. Этот процесс только начался, так что мы пока что не готовы предоставить подробности по этому направлению работы.
### Гарантии монотонности `Instant`
На всех платформах `Instant` пытается использовать API операционной системы. Это гарантирует монотонное поведение, если оно доступно (которое присутствует на всех платформах 1-го уровня). На практике в редких случаях такие гарантии сломаны аппаратно — виртуализацией или ошибками операционной системы. Чтобы обойти эти ошибки и поддерживать системы без монотонных часов, `Instant::duration_since`, `Instant::elapsed` и `Instant::sub` насыщаются до 0. В предыдущих версиях Rust это приводило бы к панике. Чтобы определить и обработать ситуации, когда монотонность нарушена или `Instant` вычитается в неправильном порядке, можно использовать `Instant::checked_duration_since`.
Этот обходной путь скрывает программные ошибки, где более ранний и более поздний моменты времени случайно поменялись местами. По этой причине в будущих версиях Rust может вернуться паника как минимум в таких случаях.
До 1.60 гарантии монотонности были предоставлены через мьютексы или атомики в std, которые давали большие накладные расходы при использовании `Instant::now()`. К тому же поведение с паникой означало, что программы на Rust могут паниковать на некотором подмножестве окружений, что было в значительной степени нежелательным, так как автор такой программы мог не иметь возможности обновить операционную систему, железо или используемую систему виртуализации. Наконец, введение неожиданной паники для таких окружений делало программы на Rust менее надёжными и переносимыми, что создавало в итоге более важную проблему, чем скучный поиск платформенных ошибок конечными пользователями.
### Стабилизированные API
Стабилизированы следующие методы и реализации типажей:
* [`Arc::new_cyclic`](https://doc.rust-lang.org/stable/std/sync/struct.Arc.html#method.new_cyclic)
* [`Rc::new_cyclic`](https://doc.rust-lang.org/stable/std/rc/struct.Rc.html#method.new_cyclic)
* [`slice::EscapeAscii`](https://doc.rust-lang.org/stable/std/slice/struct.EscapeAscii.html)
* [`<[u8]>::escape_ascii`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.escape_ascii)
* [`u8::escape_ascii`](https://doc.rust-lang.org/stable/std/primitive.u8.html#method.escape_ascii)
* [`Vec::spare_capacity_mut`](https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.spare_capacity_mut)
* [`MaybeUninit::assume_init_drop`](https://doc.rust-lang.org/stable/std/mem/union.MaybeUninit.html#method.assume_init_drop)
* [`MaybeUninit::assume_init_read`](https://doc.rust-lang.org/stable/std/mem/union.MaybeUninit.html#method.assume_init_read)
* [`i8::abs_diff`](https://doc.rust-lang.org/stable/std/primitive.i8.html#method.abs_diff)
* [`i16::abs_diff`](https://doc.rust-lang.org/stable/std/primitive.i16.html#method.abs_diff)
* [`i32::abs_diff`](https://doc.rust-lang.org/stable/std/primitive.i32.html#method.abs_diff)
* [`i64::abs_diff`](https://doc.rust-lang.org/stable/std/primitive.i64.html#method.abs_diff)
* [`i128::abs_diff`](https://doc.rust-lang.org/stable/std/primitive.i128.html#method.abs_diff)
* [`isize::abs_diff`](https://doc.rust-lang.org/stable/std/primitive.isize.html#method.abs_diff)
* [`u8::abs_diff`](https://doc.rust-lang.org/stable/std/primitive.u8.html#method.abs_diff)
* [`u16::abs_diff`](https://doc.rust-lang.org/stable/std/primitive.u16.html#method.abs_diff)
* [`u32::abs_diff`](https://doc.rust-lang.org/stable/std/primitive.u32.html#method.abs_diff)
* [`u64::abs_diff`](https://doc.rust-lang.org/stable/std/primitive.u64.html#method.abs_diff)
* [`u128::abs_diff`](https://doc.rust-lang.org/stable/std/primitive.u128.html#method.abs_diff)
* [`usize::abs_diff`](https://doc.rust-lang.org/stable/std/primitive.usize.html#method.abs_diff)
* [`Display for io::ErrorKind`](https://doc.rust-lang.org/stable/std/io/enum.ErrorKind.html#impl-Display)
* [`From for ExitCode`](https://doc.rust-lang.org/stable/std/process/struct.ExitCode.html#impl-From%3Cu8%3E)
* [`Not for !` (Тип "never")](https://doc.rust-lang.org/stable/std/primitive.never.html#impl-Not)
* [`*Op*Assign<$t> for Wrapping<$t>`](https://doc.rust-lang.org/stable/std/num/struct.Wrapping.html#trait-implementations)
* [`arch::is_aarch64_feature_detected!`](https://doc.rust-lang.org/stable/std/arch/macro.is_aarch64_feature_detected.html)
### Прочие изменения
В выпуске Rust 1.60.0 есть и другие изменения: узнайте, что изменилось в [Rust](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1600-2022-04-07), [Cargo](https://github.com/rust-lang/cargo/blob/master/CHANGELOG.md#cargo-160-2022-04-07) и [Clippy](https://github.com/rust-lang/rust-clippy/blob/master/CHANGELOG.md#rust-160).
### Участники 1.60.0
Многие люди собрались вместе, чтобы создать Rust 1.60.0. Без вас мы бы не справились. [Спасибо!](https://thanks.rust-lang.org/rust/1.60.0/)
От переводчиков
---------------
С любыми вопросами по языку Rust вам смогут помочь в [русскоязычном Телеграм-чате](https://t.me/rustlang_ru) или же в аналогичном [чате для новичковых вопросов](https://t.me/rust_beginners_ru). Если у вас есть вопросы по переводам или хотите помогать с ними, то обращайтесь в [чат переводчиков](https://t.me/rustlang_ru_translations).
Данную статью совместными усилиями перевели [belanchuk](https://habr.com/ru/users/belanchuk/), [andreevlex](https://habr.com/ru/users/andreevlex/), [TelegaOvoshey](https://habr.com/ru/users/telegaovoshey/) и [funkill](https://habr.com/ru/users/funkill/). | https://habr.com/ru/post/659905/ | null | ru | null |
# SafetyNet Attestation — описание и реализация проверки на PHP
В эту тему пришлось детально погрузиться во время работы над обеспечением стандартных механизмов верификации устройств для разных мобильных платформ. Задача сводилась к разработке полноценной реализацию проверки JWS-токенов по протоколу SafetyNet на серверной стороне.
После многочасовых поисков и скрупулёзного изучения официальной документации Google решил поделиться полученным опытом. Потому что, кроме официальной документации, я нашел только отрывочные описания частных примеров реализации на разных ЯП. И ни намека на комплексное объяснение особенностей проверки по SafetyNet на сервере.
Статья будет полезна разработчикам, которые хотят подробнее разобраться с технологией верификации устройств по протоколу SafetyNet Attestation. Для изучения описательной части не обязательно знать какой-либо язык программирования. Я сознательно убрал примеры кода, чтобы сфокусироваться именно на алгоритмах проверки. Сам пример реализации на PHP сформулирован в виде подключаемой через composer библиотеки и будет описан ниже.
А в конце статьи — ссылка на разработанную мной библиотеку на PHP, которая обеспечивает полный цикл верификации JWS.
*Дисклеймер: материал в явном виде содержит перевод* [*официальной документации*](https://developer.android.com/training/safetynet/attestation) *от Google с разъяснениями и описанием особенностей реализации, с которыми я столкнулся.*
### О технологии
Технология SafetyNet Attestation разработана Google как средство предоставления разработчикам мобильных приложений информации о надёжности приложения клиента при взаимодействии с сервером, который обслуживает мобильное приложение. Для этого в протоколе взаимодействия предусмотрен удостоверяющий сервис от Google, обеспечивающий верификацию, и представлены рекомендации по проверке ответа от удостоверяющего центра на стороне сервера.
Google пишет, что данный метод проверки не может исключить все принятые на сегодняшний момент методы защиты и верификации устройств. То есть SafetyNet не представляет собой единственный механизм защиты от небезопасного трафика, а создавался как дополнительный инструмент.
Что позволяет проверить технология:
1. Что именно вы являетесь автором приложения, которое сейчас взаимодействует с сервером.
2. Что в процессе взаимодействия клиента и сервера нет больше никого, кроме вашего приложения и сервера.
3. Что операционная система мобильного устройства не претерпела изменений, критичных для обеспечения безопасного обмена с сервером (не «заручено» — не взломано, а также то, что устройство прошло аттестацию совместимости с Android).
В каких случаях механизм не применим или не имеет смысла:
1. На устройстве пользователя отсутствует интернет, нет возможности связаться с удостоверяющим центром. В таком случае API выдаст ошибку на клиенте, и мы не сможем получить подписанный токен для проверки на сервере.
2. Если попытаемся выполнить верификацию подписанного токена в самом мобильном приложении (без участия сервера), так как проверка клиента не должна происходить на клиенте. Если у вас приложение без Backend, или вы в принципе не планируете верификацию SafetyNet на серверной части приложения, то нет смысла устанавливать и настраивать этот механизм проверки.
3. Если требуется детальное понимание статусов модификации системы, на которой работает мобильное приложение. В протокол заложен механизм однозначного определения модификации устройства. Он состоит из двух переменных: ctsProfileMatch и basicIntegrity. Об их назначении — чуть ниже.
Остальные пункты в рамках этой статьи, на мой взгляд, менее интересны. Общий принцип такой: если вам нужно что-то очень точное или что-то, что обезопасит контент, — ищите другой (дополнительный) способ защиты. Аналогично в случае, когда вы не собираетесь реализовывать проверку в нормальном порядке, как это задумано протоколом, или ваше приложение опирается на созданные уязвимости в конфигурации устройства.
Схематично процесс проверки клиента можно представить в виде схемы:
Рассмотрим поэтапно процесс верификации устройств по протоколу:
1. Инициация процесса проверки со стороны клиента.Отправка запроса от клиента на Backend на генерацию уникального идентификатора проверки (nonce) сессии. В процессе выполнения запроса на сервере генерируется ключ (nonce) сессии, сохраняется и передаётся на клиент для последующей проверки.
2. Генерация JWS-токена на стороне удостоверяющего центра.Клиент, получив nonce, отправляет его на удостоверяющий центр вместе со служебной информацией. Затем в качестве ответа клиенту возвращается JWS, содержащий информацию о клиенте, время генерации токена, информацию о приложении (хеши сертификатов, которыми подписывается приложение в процессе публикации в Google Store), информацию о том, чем был подписан ответ (сигнатуру). О JWS, его структуре и прочих подробностях расскажу дальше в статье.
3. Затем клиент передаёт JWS в неизменном виде на Backend для проверки. А на стороне сервера формируется ответ с информацией о результате прохождения аттестации.После получения статуса проверки JWS на стороне сервера обычно сохраняют факт проверки и, опираясь на него, влияют на функциональность положительным или негативным образом. Например, клиентам, не прошедшим аттестацию, можно отключить возможность писать комментарии, голосовать за рейтинг, совершать иные активности, которые могут повлиять на качество контента приложения или создавать угрозу и неудобство другим пользователям.
### Описание процесса верификации на стороне сервера JWS от удостоверяющего центра
Документация Google в рамках тестирования на сервере предлагает организовать online-механизм верификации JWS, при котором с сервера приложения отправляется запрос с JWS на удостоверяющий сервис Google. А в ответе от сервиса Google содержится полный результат проверки JWS.
Но данный метод проверки JWS для промышленного использования не рекомендуются. И даже больше: для каждого приложения существует ограничение в виде 10 000 запросов в сутки (подробнее об ограничениях — [здесь](https://developer.android.com/training/safetynet/attestation.html#quota-monitoring)), после которых вы выгребите квоту и перестанете получать от него вменяемый ответ. Только информацию об ошибке.
Далее расскажу обо всём алгоритме верификации JWS, в том числе о верификации самих сертификатов (проверке цепочки сертификатов).
### Подробнее о JWS
JWS представляет собой три текстовых (base64 зашифрованных) выражения, разделенные точками (header.body.signature):
Например:
> eyJhbGciOiJSUzI1NiIsICJ4NWMiOiBbInZlcnlzZWN1cmVwdWJsaWNzZXJ0Y2hhaW4xIiwgInZlcnlzZWN1cmVwdWJsaWNzZXJ0Y2hhaW4yIl19.ewogICJub25jZSI6ICJ2ZXJ5c2VjdXJlbm91bmNlIiwKICAidGltZXN0YW1wTXMiOiAxNTM5ODg4NjUzNTAzLAogICJhcGtQYWNrYWdlTmFtZSI6ICJ2ZXJ5Lmdvb2QuYXBwIiwKICAiYXBrRGlnZXN0U2hhMjU2IjogInh5eHl4eXh5eHl4eXh5eHl5eHl4eXg9IiwKICAiY3RzUHJvZmlsZU1hdGNoIjogdHJ1ZSwKICAiYXBrQ2VydGlmaWNhdGVEaWdlc3RTaGEyNTYiOiBbCiAgICAieHl4eXh5eHl4eXh5eHl4eXh5eD09PT09Lz0iCiAgXSwKICAiYmFzaWNJbnRlZ3JpdHkiOiB0cnVlCn0=.c2lnbmF0dXJl
>
>
В данном примере после расшифровки base64 получим:
**Header :**
```
json_decode(
base64_decode(
“eyJhbGciOiJSUzI1NiIsICJ4NWMiOiBbInZlcnlzZWN1cmVwdWJsaWNzZXJ0Y2hhaW4xIiwgInZlcnlzZWN1cmVwdWJsaWNzZXJ0Y2hhaW4yIl19”
)
)
=
{
"alg":"RS256",
"x5c":[
"verysecurepublicsertchain1",
"verysecurepublicsertchain2"
]
}
```
**Body:**
```
json_decode(
base64_decode(
“ewogICJub25jZSI6ICJ2ZXJ5c2VjdXJlbm91bmNlIiwKICAidGltZXN0YW1wTXMiOiAxNTM5ODg4NjUzNTAzLAogICJhcGtQYWNrYWdlTmFtZSI6ICJ2ZXJ5Lmdvb2QuYXBwIiwKICAiYXBrRGlnZXN0U2hhMjU2IjogInh5eHl4eXh5eHl4eXh5eHl5eHl4eXg9IiwKICAiY3RzUHJvZmlsZU1hdGNoIjogdHJ1ZSwKICAiYXBrQ2VydGlmaWNhdGVEaWdlc3RTaGEyNTYiOiBbCiAgICAieHl4eXh5eHl4eXh5eHl4eXh5eD09PT09Lz0iCiAgXSwKICAiYmFzaWNJbnRlZ3JpdHkiOiB0cnVlCn0=”
)
)
=
{
"nonce":"verysecurenounce",
"timestampMs":1539888653503,
"apkPackageName":"very.good.app",
"apkDigestSha256":"xyxyxyxyxyxyxyxyyxyxyx=",
"ctsProfileMatch":true,
"apkCertificateDigestSha256":[
"xyxyxyxyxyxyxyxyxyx=====/="
],
"basicIntegrity":true
}
```
**Signature**
```
json_decode(
base64_decode(
“c2lnbmF0dXJl”
)
)
=
“signature”
```
Остановимся на том, что именно содержится во всем JWS.
**Header:**
* alg — алгоритм, которым зашифрованы Header и Body JWS. Нужен для проверки сигнатуры.
* x5c — публичная часть сертификата (или цепочка сертификатов). Также нужен для проверки сигнатуры.
**Body:**
* nonce — произвольная строка полученная с сервера и сохранённая на нём же.
* timestampMs — время начала аттестации.
* apkPackageName — название приложения, которое запросило аттестацию.
* apkDigestSha256 — хеш подписи приложения, которое загружено в Google Play.
* ctsProfileMatch — флаг, показывающий прошло ли устройство пользователя верификацию в системе безопасности Google (основной и самый жёсткий критерий, по которому можно понять было ли устройство заручено и прошло ли оно сертификацию в Google).
* apkCertificateDigestSha256 — хеш сертификата (цепочки сертификатов), которыми подписано приложение в Google Play.
* basicIntegrity — более мягкий (по сравнению с ctsProfileMatch) критерий целостности установки.
**Signature**
Бинарная сигнатура, с помощью которой можно сделать заключение, что тело сообщения JWS было подписано с использованием сертификатов (цепочки сертификатов) указанных в Header**,** и с использованием известного нам приватного ключа. Ключевое — позволяет понять, что в цепочке взаимодействия нет никого, кроме нас и удостоверяющего центра Google.
### Проверка сертификатов
Перейдём к непосредственной проверки каждой части полученного JWS. Начнём с сертификатов и алгоритма шифрования:
1. Проверяем, что алгоритм, с помощью которого подписано тело, нами поддерживается:
```
[$checkMethod, $algorithm] = JWT::$supported_algs[$statement->getHeader()->getAlgorithm()];
if ($checkMethod != 'openssl') {
throw new CheckSignatureException('Not supported algorithm function');
}
```
2. Проверяем, что сертификат (цепочка сертификатов), содержащиеся в Header (поле x5c), удовлетворяют нас по содержимому (загружаются в качестве публичных ключей):
```
private function extractAlgorithm(array $headers): string
{
if (empty($headers['alg'])) {
throw new EmptyAlgorithmField('Empty alg field in headers');
}
return $headers['alg'];
}
private function extractCertificateChain(array $headers): X509
{
if (empty($headers['x5c'])) {
throw new MissingCertificates('Missing certificates');
}
$x509 = new X509();
if ($x509->loadX509(array_shift($headers['x5c'])) === false) {
throw new CertificateLoadError('Failed to load certificate');
}
while ($textCertificate = array_shift($headers['x5c'])) {
if ($x509->loadCA($textCertificate) === false) {
throw new CertificateCALoadError('Failed to load certificate');
}
}
if ($x509->loadCA(RootGoogleCertService::rootCertificate()) === false) {
throw new RootCertificateError('Failed to load Root-CA certificate');
}
return $x509;
}
```
3. Валидируем сигнатуру сертификата (цепочки сертификатов):
```
private function guardCertificateChain(StatementHeader $header): bool
{
if (!$header->getCertificateChain()->validateSignature()) {
throw new CertificateChainError('Certificate chain signature is not valid');
}
return true;
}
```
4. Сверяем hostname подписавшего сервера с сервером аттестации Google (ISSUINGHOSTNAME = 'attest.android.com'):
```
private function guardAttestHostname(StatementHeader $header): bool
{
$commonNames = $header->getCertificateChain()->getDNProp('CN');
$issuingHostname = $commonNames[0] ?? null;
if ($issuingHostname !== self::ISSUING_HOSTNAME) {
throw new CertificateHostnameError(
'Certificate isn\'t issued for the hostname ' . self::ISSUING_HOSTNAME
);
}
return true;
}
```
### Верификация тела JWS
Самый значимым пункт для определения характеристик, участвующего в обмене устройства с приложением. Что нам нужно проверить на данном этапе:
1. Проверка nonce.
Тут все просто. Распаковали JWS, получили в Body nonce и сверили с тем, что у нас сохранено на сервере:
```
private function guardNonce(Nonce $nonce, StatementBody $statementBody): bool
{
$statementNonce = $statementBody->getNonce();
if (!$statementNonce->isEqual($nonce)) {
throw new WrongNonce('Invalid nonce');
}
return true;
}
```
2. Проверяем заручено ли устройство, с которого происходит запрос.
Тут нужно принять решение, на что вы будете опираться для закрытия того или иного функционала пользователей, не прошедших эту проверку.
Есть два параметра, на основе которых можно принимать решение о надежности устройства: ctsProfileMatch и basicIntegrity. ctsProfileMatch — более строгий критерий, он определяет сертифицировано ли устройство в Google Play и верифицировано ли устройство в сервисе проверки безопасности Google. basicIntegrity — определяет, что устройство не было скомпрометировано.
```
private function guardDeviceIsNotRooted(StatementBody $statementBody): bool
{
$ctsProfileMatch = $statementBody->getCtsProfileMatch();
$basicIntegrity = $statementBody->getBasicIntegrity();
if (empty($ctsProfileMatch) || !$ctsProfileMatch) {
throw new ProfileMatchFieldError('Device is rooted');
}
if (empty($basicIntegrity) || !$basicIntegrity) {
throw new BasicIntegrityFieldError('Device can be rooted');
}
return true;
}
```
3. Проверяем время начала прохождения аттестации.
Тоже ничего сложного. Нужно проверить, что с момента ответа от сервера Google прошло немного времени. По сути, нет чётких критериев прохождения теста — с реферальным значением нужно определиться самим.
```
private function guardTimestamp(StatementBody $statementBody): bool
{
$timestampDiff = $this->config->getTimeStampDiffInterval();
$timestampMs = $statementBody->getTimestampMs();
if (abs(microtime(true) * 1000 - $timestampMs) > $timestampDiff) {
throw new TimestampFieldError('TimestampMS and the current time is more than ' . $timestampDiff . ' MS');
}
return true;
}
```
4. Проверяем подпись приложения.
Здесь тоже два параметра: apkDigestSha256 и apkCertificateDigestSha256. Но apkDigestSha256 самой Google помечен как нерекомендуемый способ проверки. С марта 2018 года они начали добавлять мета-информацию в приложения — из-за чего ваш хеш подписи приложения может не сходиться с тем, который будет приходить в JWS (подробнее — [здесь](https://github.com/scottyab/safetynethelper/issues/35)).
Поэтому единственным способом проверки остается проверка хеша подписи приложения apkCertificateDigestSha256. Фактически этот параметр нужно сравнить с теми sha1 ключа, которым подписываете apk при загрузке в Google Play.
```
private function guardApkCertificateDigestSha256(StatementBody $statementBody): bool
{
$apkCertificateDigestSha256 = $this->config->getApkCertificateDigestSha256();
$testApkCertificateDigestSha256 = $statementBody->getApkCertificateDigestSha256();
if (empty($testApkCertificateDigestSha256)) {
throw new ApkDigestShaError('Empty apkCertificateDigestSha256 field');
}
$configSha256 = [];
foreach ($apkCertificateDigestSha256 as $sha256) {
$configSha256[] = base64_encode(hex2bin($sha256));
}
foreach ($testApkCertificateDigestSha256 as $digestSha) {
if (in_array($digestSha, $configSha256)) {
return true;
}
}
throw new ApkDigestShaError('apkCertificateDigestSha256 is not valid');
}
```
5. Проверяем имя приложения, запросившего аттестацию.
Сверяем название приложения в JWS с известным названием нашего приложения.
```
private function guardApkPackageName(StatementBody $statementBody): bool
{
$apkPackageName = $this->config->getApkPackageName();
$testApkPackageName = $statementBody->getApkPackageName();
if (empty($testApkPackageName)) {
throw new ApkNameError('Empty apkPackageName field');
}
if (!in_array($testApkPackageName, $apkPackageName)) {
throw new ApkNameError('apkPackageName ' . $testApkPackageName. ' not equal ' . join(", ", $apkPackageName));
}
return true;
}
```
### Верификация сигнатуры
Здесь нужно совершить одно действие, которое даст нам понимание того, что Header и Body ответа JWS подписаны сервером авторизации Google. Для этого в исходном виде склеиваем Header c Body (с разделителем в виде ".") и проверяем сигнатуру:
```
protected function guardSignature(Statement $statement): bool
{
$jwsHeaders = $statement->getRawHeaders();
$jwsBody = $statement->getRawBody();
$signData = $jwsHeaders . '.' . $jwsBody;
$stringPublicKey = (string)$statement->getHeader()->getCertificateChain()->getPublicKey();
[$checkMethod, $algorithm] = JWT::$supported_algs[$statement->getHeader()->getAlgorithm()];
if ($checkMethod != 'openssl') {
throw new CheckSignatureException('Not supported algorithm function');
}
if (openssl_verify($signData, $statement->getSignature(), $stringPublicKey, $algorithm) < 1) {
throw new CheckSignatureException('Signature is invalid');
}
return true;
}
```
### Вместо заключения. Библиотека на PHP
Уже после решения задачи и отдельно от нашей кодовой базы, я разработал библиотеку на PHP, которая обеспечивает полный цикл верификации JWS.
Её можно [скачать из Packagist](https://packagist.org/packages/gorokhovdv/safetynet-verification) и использовать в своих проектах. | https://habr.com/ru/post/541934/ | null | ru | null |
# (псевдо)Наследование для компонентов ReactJS
Я хочу написать коротенький пост, про то, как я решил проблему наследования в ReactJS. Обычно, на форумах, люди советуют использовать миксины для наследования функционала, но, по-моему, это не совсем правильно. Все-таки трэйты/миксины и классы это не одно и то же, да еще и из-за возможности множественного наследования могут возникать вот такие казусы:
```
var A = {
doStuff (){}
}
var B = {
doStuff (){}
}
var C = React.createClass({
mixins: [A, B]
});
//упс... ошибка, потому что React не может решить какой из doStuff унаследовать
```
К тому же, миксины не позволяют делать стандартные ООПешные фишки вроде перезаписи методов(method override):
```
var A = {
doStuff (){}
}
var C = React.createClass({
mixins: [A],
doStuff (){
//неа, не получится
}
});
```
А без этого, естественно, не сработает и расширение функционала как во «взрослых» ООП языках:
```
doStuff (){
super.doStuff()
//дополнительный функционал
}
```
Конечно, классы ES6 решат эту проблему, и команда ReactJS к этому готовится, если судить по постам на их блоге, но ждать ES6 придется как второго пришествия, а затем, придется еще подождать пока не вымрут старые Интернет Эксплореры без поддержки ES6.
Итак, я хочу предложить вам альтернативный метод, который и сам использую, но для этого вам понадобятся:
1) Система модулей/зависимостей: RequireJS/Browserify/WebPack/что там еще сейчас в моде. Если вы не пользуетесь/не знаете что такое JavaScript модули, что ж, самое время [узнать](http://davidbcalhoun.com/2014/what-is-amd-commonjs-and-umd/).
2) Какая-нибудь функция/либа для глубокого копирования объектов, например, jQuery.extend, \_.extend и т.п.
Итак, я пишу модули своих компонент следующим образом:
```
var React = require('react');
var Human = {
whoAreYou (){
return "I'm a human";
}
whatDoYouDo (){
return "I'm just chilling";
}
render (){
return (
{this.whoAreYou()}{this.whatDoYouDo()}
======================================
)
}
}
module.exports = {
Class: Human,
Component: React.createClass(Human)
}
```
Фишка в том, что я экспортирую не только компоненту, но и «чистый» объект, из которого эта компонента создается, таким образом, когда мне надо использовать просто компоненту , я беру поле Component из экспорта моего модуля:
```
var Human = require('human').Component;
```
А вот когда мне надо от моего модуля унаследовать, и тут начинается самое интересное, я использую поле Class:
```
var React = require('react');
var Parent = require('human').Class;
var Programmer = {};
jQuery.extend(true, Programmer, Parent, {
whoAreYou (){
return Parent.whoAreYou.apply(this) + " and a programmer";//вызов метода из родителя!
}
whatDoYouDo (){
//перезапись метода полностью
return "I write code";
}
drinkCoffee (){
//добавление нового метода
console.log('*sip*');
}
});
```
Естественно, этот модуль я тоже экспортирую согласно вышеописанной «конвенции»:
```
module.exports = {
Class: Programmer,
Component: React.createClass(Programmer)
}
```
И теперь его можно использовать в приложении:
```
var Programmer = require('programmer').Component;
```
Ну, или наследовать/расширять дальше, например, в JuniorDeveloper.
И на этом все, это был мой коротенький пост про костыль для (псевдо)наследования в ReactJS. Успешной вам трудовой недели, господа! | https://habr.com/ru/post/247347/ | null | ru | null |
# Находим опечатки в **kwargs
По мере разрастания проекта, в котором я сейчас принимаю активное участие, стал все чаще встречаться с подобными опечатками в именах аргументов у функции, как на картинке справа. Особенно дорого в отладке обходились подобные ошибки в конструкторе класса, когда при длинной цепочке наследования передавался неправильный параметр базового класса, или вообще не передавался. Перекраивание интерфейсов на специальные пользовательские структуры вроде namedtuple вместо \*\*kwargs имело несколько проблем:
* Ухудшало взаимодействие с пользователем. Нужно передавать в функцию специально сконструированный объект. Не понятно что делать с необязательными аргументами.
* Усложняло разработку. При наследовании классов нужно наследовать соответствующие структуры аргументов. С namedtuple-ом не получится это сделать, надо писать собственный хитрый класс. Куча работы по внедрению.
* И главное, все равно полностью не спасало от опечаток в именах.
Решение, к которому я в итоге пришел, не может защитить в 100% всех возможных случаев, однако в тех необходимых 80% (в моем проекте, 100%) прекрасно справляется со своей задачей. Если кратко, оно заключается в анализе исходного (байт)кода функции, построении матрицы расстояний между найденными «настоящими» именами и переданными извне и печати предупреждений по заданным критериям. [Исходники](https://github.com/vmarkovtsev/kwarg_misprints_detection).
#### TDD
Итак, сперва точно поставим задачу. В следующем примере должно печататься 5 «подозрительных» предупреждений:
```
def foo(arg1, arg2=1, **kwargs):
kwa1 = kwargs["foo"]
kwa2 = kwargs.get("bar", 200)
kwa3 = kwargs.get("baz") or 3000
return arg1 + arg2 + kwa1 + kwa2 + kwa3
res = foo(0, arg3=100, foo=10, fo=2, bard=3, bas=4, last=5)
```
1. Вместо arg2 передали arg3
2. Вместо bar или baz передали bas
3. Вместо bar передали bard
4. Помимо foo передали fo
5. last вообще лишний
Аналогично, в примере с классами и наследованием должны быть те же предупреждения плюс еще одно (вместо boo передали bog):
```
class Foo(object):
def __init__(self, arg1, arg2=1, **kwargs):
self.kwa0 = arg2
self.kwa1 = kwargs["foo"]
self.kwa2 = kwargs.get("bar", 200)
self.kwa3 = kwargs.get("baz") or 3000
class Bar(Foo):
def __init__(self, arg1, arg2=1, **kwargs):
super(Bar, self).__init__(arg1, arg2, **kwargs)
self.kwa4 = kwargs.get("boo")
bar = Bar(0, arg3=100, foo=10, fo=2, bard=3, bas=4, last=5, bog=6)
```
#### План решения задачи
* Для первого примера с функцией сделаем умный декоратор, для второго с классами — сделаем метакласс. Они должны разделять всю внутреннюю сложную логику и по сути ничем не различаться. Следовательно, сначала делаем внутренний микро API и на нем уже делаем ~~userspace~~ пользовательский API. Декоратор назвал detect\_misprints, а метакласс — KeywordArgsMisprintsDetector (тяжелое наследие Java/C#, ага).
* Задумка решения была в анализе байткода и нахождении матрицы расстояний. Это независимые друг от друга шаги, так что микро API будет состоять из двух соответствующих функций. Я назвал их get\_kwarg\_names и check\_misprints.
* Для анализа кода применим стандартные [inspect](https://docs.python.org/3/library/inspect.html) и [dis](https://docs.python.org/3/library/dis.html), для вычисления расстояний между строками — [pyxDamerauLevenshtein](https://github.com/gfairchild/pyxDamerauLevenshtein). В требованиях проекта стояло совместимость с двойкой и с тройкой, а также PyPy. Как видим, зависимости ~~малину не портят~~ совместимы с этими требованиями.
#### get\_kwarg\_names (извлечение имен из кода)
Тут должна быть портянка кода, но лучше я дам на нее [ссылку](https://github.com/vmarkovtsev/kwarg_misprints_detection/blob/master/kwarg_misprints_detection.py#L46). Функция принимает на вход функцию ~~которая принимает на вход функцию которая...~~ и должна возвращать множество найденных именованных аргументов. Я не особо комментариеобилен, так что кратко пройдусь по основным моментам.
Первое, что стоит сделать — узнать, есть ли у функции вообще \*\*kwargs. Если нет — возвращаем пустоту. Дальше уточняем имя «двойной звезды», ведь \*\*kwargs это общепринятое соглашение и не более того. Дальше логика, как это часто бывает в портабельном по версиям коде, раздваивается, но не как обычно на ветки для двойки и для тройки, а на < 3.4 и >=. Дело в том, что вменяемая поддержка дизассемблирования (вместе с тотальным рефакторингом dis) появилась именно в 3.4. До этого, как нb странно, без сторонних модулей можно было лишь печатать питоний байткод в stdout (sic!). Функция [dis.get\_instructions()](https://docs.python.org/3/library/dis.html#dis.get_instructions) возвращает генератор экземпляров всех байткодных инструкций анализируемого объекта. Вообще, насколько я понял, единственным надежным описанием байткода является [хидер его опкодов](https://hg.python.org/cpython/file/b3f0d7f50544/Include/opcode.h), что, конечно, печально, потому что разворачивание в опкоды конкретных инструкций приходилось определять экспериментально.
Мы будем матчить два паттерна: var = kwargs[«key»] и kwargs.get(«key»[, default]).
```
>>> from dis import dis
>>> def foo(**kwargs):
return kwargs["key"]
>>> dis(foo)
2 0 LOAD_FAST 0 (kwargs)
3 LOAD_CONST 1 ('key')
6 BINARY_SUBSCR
7 RETURN_VALUE
>>> def foo(**kwargs):
return kwargs.get("key", 0)
>>> dis(foo)
2 0 LOAD_FAST 0 (kwargs)
3 LOAD_ATTR 0 (get)
6 LOAD_CONST 1 ('key')
9 LOAD_CONST 2 (0)
12 CALL_FUNCTION 2 (2 positional, 0 keyword pair)
15 RETURN_VALUE
```
Как видим, в первом случае это комбинация из LOAD\_FAST + LOAD\_CONST, во втором LOAD\_FAST + LOAD\_ATTR + LOAD\_CONST. Вместо «kwargs» в аргументе инструкций надо искать найденное в начале имя «двойной звезды». Отсылаю за подробным описанием байткода к сведущим людям, ну а мы будем getting things done, то есть двигаться дальше.
А дальше у нас некрасивый workaround для старых версий Питона на регулярных выражениях. С помощью inspect.getsourcelines() получаем список исходных строк функции, и фигачим по каждой прекомпилированной регуляркой. Этот способ еще хуже чем анализ байткода, например, в текущем виде не определятся выражения, состоящие из нескольких строк или несколько выражений, скленных точкой с запятой. Ну, на то он и workaround чтобы сильно не напрягаться… Впрочем, эту часть можно объективно улучшить, хочу pull request :)
#### check\_misprints (матрица расстояний)
[Код](https://github.com/vmarkovtsev/kwarg_misprints_detection/blob/master/kwarg_misprints_detection.py#L97). На вход получаем результат предыдущего этапа, переданные именованные аргументы, загадочный tolerance и функцию, которой делать предупреждения. Для каждого переданного аргумента нужно найти editing distance до каждого «настоящего», т.е. которого нашли при анализе байткода. На самом деле, незачем считать тупо всю матрицу целиком, если уже нашли идеальное соответствие, дальше можно не продолжать. Ну и, конечно, матрица симметричная, и, следовательно, можно вычислять только ее половину. Думаю, можно еще как-нибудь соптимизировать, но при типичном количестве kwarg-ов, меньшем 30, сойдет и n2. Расстояние будем вычислять [Дамерау-Левенштейна](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D1%81%D1%81%D1%82%D0%BE%D1%8F%D0%BD%D0%B8%D0%B5_%D0%94%D0%B0%D0%BC%D0%B5%D1%80%D0%B0%D1%83_%E2%80%94_%D0%9B%D0%B5%D0%B2%D0%B5%D0%BD%D1%88%D1%82%D0%B5%D0%B9%D0%BD%D0%B0) как широко известное, популярное и понятное автору :) На хабре о нем писали, например, [здесь](http://habrahabr.ru/post/117063/). Для него написано несколько пакетов под Питон, я выбрал PyxDamerauLevenshtein за портабельность Cython-а, на котором он написан и оптимальное линейное потребление памяти.
Дальше дело техники: если для аргумента не нашлось ни одного даже отдаленно похожего эталона, заявляем о его категорической бесполезности. Если нашлось несколько соответствий с расстоянием меньше tolerance — заявляем о своих смутных подозрениях.
#### detect\_misprints
[Классический декоратор](https://github.com/vmarkovtsev/kwarg_misprints_detection/blob/master/kwarg_misprints_detection.py#L134), заранее вычисляем «настоящие» имена именованных аргументов (пардон за тавтологию), и при каждом вызове дергаем check\_misprints.
#### KeywordArgsMisprintsDetector
[Наш метакласс](https://github.com/vmarkovtsev/kwarg_misprints_detection/blob/master/kwarg_misprints_detection.py#L152) будет перехватывать момент создания типа класса (\_\_init\_\_, при котором один раз за все время жизни вычислит «настоящие» имена да-да их самых) и момент создания экземпляра класса (\_\_call\_\_, который дергает check\_misprints). Единственный момент — у класса есть [mro](http://habrahabr.ru/post/62203/) и базовые классы, в конструкторах которых, возможно, тоже используются \*\*kwargs. Так что в \_\_init\_\_-е мы должны пробежать по всем базовым классам и добавить в общее множество имена аргументов каждого.
#### Как использовать
Просто добавляем описанные выше декоратор к функции или метакласс к классу.
```
@detect_misprints
def foo(**kwargs):
...
@six.add_metaclass(KeywordArgsMisprintsDetector)
class Foo(object):
def __init__(self, **kwargs):
...
```
#### Резюме
Я рассмотрел один из способов борьбы с опечатками в именах \*\*kwargs, и в моем случае он решил все проблемы и удовлетворил всем требованиям. Сначала мы анализировали байткод функции или просто исходный код на старых версиях Питона, а потом строили матрицу расстояний между именами, которые используются в функции, и переданными пользователем. Расстояние считали по Дамерау-Левенштейну, и в конце писали warning-и по двум случаям ошибок — когда аргумент «совсем левый» и когда он похож на один из «настоящих».
Исходный код из статьи [выложен на GitHub](https://github.com/vmarkovtsev/kwarg_misprints_detection). Буду рад исправлениям и улучшениям. Также хочу узнать ваще мнение, стоит ли это творение выкладывать на PyPi. | https://habr.com/ru/post/249423/ | null | ru | null |
# ORM в Android c помощью ORMLite
На данный момент для платформы Android существует несколько решений, позволяющих реализовать ORM-подход для работы с базой данных, но основных два. Это [ORMLite](http://ormlite.com) и [GreenDAO](http://greendao-orm.com/).
Для новичков стоит сделать отступление и рассказать что такое ORM вообще. [ORM](http://ru.wikipedia.org/wiki/ORM) — object-ralational mapping. Объектно-реляционное отображение означает, что программисту гораздо удобнее оперировать с объектами, которые он использует в своём приложении, нежели чем с таблицами, в которых хранятся данные в [реляционных базах данных](http://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%BB%D1%8F%D1%86%D0%B8%D0%BE%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B1%D0%B0%D0%B7%D0%B0_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85). Для связи реляционных СУБД с объектной моделью приложения используются ORM-технологии. Так для решения задач объектно-реляционного отображения в Android используют один из сторонних фреймворков. GreenDAO и ORMLite — являются библиотеками с открытым кодом.
##### GreenDAO
Фреймворк от немецких разработчиков, который они используют в своих приложениях.
###### Преимущества:
Не использует отражения ([Reflection](http://ru.wikipedia.org/wiki/%D0%9E%D1%82%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_(%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)) для работы
Максимальная производительность для Android ORM
Минимальное использование памяти
Маленький размер библиотеки, не оказывает большого влияния на Android проект.
###### Недостатки:
* Отсутствует механизм для переноса данных при обновлении схемы.
* Невозможность аннотирования классов, а необходимость описания алгоритма построения новых сущностей.
##### ORMLite
Популярный фреймворк для Java, имеющий адаптированную версию под Android.
##### Преимущества:
* Мощная и в тоже время простая аннотация
* Богатый функционал
* Поддержка многих БД, в т.ч. SQLite
* Архитектура в соответсвии с принципом KISS
###### Недостатки:
… хм… я их не находил) всё что кажется не возможным, реализуется при более глубоком изучении доков.
OrmLite я использую в нескольких и проектах и знаком с ним достаточно тесно. Поэтому рассажу как раз о нем.
#### Простая аннотация классов
Каждый класс, отображение в базу данных (сохрание в БД) которого мы хотим сделать должен быть аннотирован. (можно использовать [class-configuration](http://ormlite.com/javadoc/ormlite-core/doc-files/ormlite_5.html#SEC47), но это совсем другая история)Стоит заметить, что у класса должен обязательно присутствовать конструктор без аргументов. Пример аннотации:
```
@DatabaseTable(tableName = "goals")
public class Goal{
public final static String GOAL_NAME_FIELD_NAME = "name";
@DatabaseField(generatedId = true)
private int Id;
@DatabaseField(canBeNull = false, dataType = DataType.STRING, columnName = GOAL_NAME_FIELD_NAME)
private String name;
@DatabaseField(dataType = DataType.DATE)
private Date lastEditDate;
@DatabaseField()
private String notes;
public Goal(){
scheduleList = new ArrayList();
priorities = new ArrayList();
}
}
```
Первая аннотация `@DatabaseTable(tableName = "goals")` указывает название таблицы, куда будут отображены объекты этого класса.
Перед каждым полем должна быть аннотация `@DatabaseField` с различными аргументами. (также можно не указывать аргументов — всё установится по умолчанию, а название столбца в таблице будет совпадать с названием поля). У поля name три аргумента. `canBeNull = false` означает, что в таблице этот столбец не может быть пустым. `dataType = DataType.STRING` принудительно обязывает приводить тип столбца к типу `String`. (доступные типы можно посмотреть [здесь](http://ormlite.com/javadoc/ormlite-core/doc-files/ormlite_2.html#SEC11)). `columnName = GOAL_NAME_FIELD_NAME` — принудительное указание имени столбца в таблице поможет нам в дальнейшем при построении select-запросов для получения данных из БД.
Первичным ключем может служить любое поле — достаточно указать у него `id = true`, но рекомендуется сделать автогенерируемое значение id и поставить ему `generatedId = true`. ORMLite сама назначит ему уникальный номер.
Для индексации столбца в БД указывается `index = true`
Полное описание всех доступных агументов аннотации полей можно посмотреть [здесь](http://ormlite.com/javadoc/ormlite-core/doc-files/ormlite_2.html#SEC7)
Также помимо аннотаций ORMLite можно использовать привычные некоторым javax.persistence аннотации
#### Подключение к SQLite в андроид
Существует несколько способов получения доступа к данным БД с помощью ORMLite в андроид. Можно наследовать каждую activity от ORMLiteBaseActivity и тогда нам не придется следить за жизненным циклом соединения с БД, но при этом мы не сможем получить доступа из других классов. ([см примеры](http://ormlite.com/javadoc/ormlite-core/doc-files/ormlite_7.html#SEC66))
Гораздо предпочтительнее подход, рассмотренный далее.
Нужно создать класс, который будет инстанцировать помощника в создании и работе с БД:
```
public class HelperFactory{
private static DatabaseHelper databaseHelper;
public static DatabaseHelper getHelper(){
return databaseHelper;
}
public static void setHelper(Context context){
databaseHelper = OpenHelperManager.getHelper(context, DatabaseHelper.class);
}
public static void releaseHelper(){
OpenHelperManager.releaseHelper();
databaseHelper = null;
}
}
```
Обращение к нему будет происходить во время начала и конца жизни приложения:
Это предотвратит утечки памяти из-за незакрытого соединения с БД
```
public class MyApplication extends Application{
@Override
public void onCreate() {
super.onCreate();
HelperFactory.setHelper(getApplicationContext());
}
@Override
public void onTerminate() {
HelperFactory.releaseHelper();
super.onTerminate();
}
}
```
Так же не забываем описать наш класс наследник Application в манифесте:
```
```
Создадим класс DataBaseHelper, который будет отвечать за создание БД и за получение ссылок на DAO:
```
public class DatabaseHelper extends OrmLiteSqliteOpenHelper{
private static final String TAG = DatabaseHelper.class.getSimpleName();
//имя файла базы данных который будет храниться в /data/data/APPNAME/DATABASE_NAME.db
private static final String DATABASE_NAME ="myappname.db";
//с каждым увеличением версии, при нахождении в устройстве БД с предыдущей версией будет выполнен метод onUpgrade();
private static final int DATABASE_VERSION = 1;
//ссылки на DAO соответсвующие сущностям, хранимым в БД
private GoalDAO goalDao = null;
private RoleDAO roleDao = null;
public DatabaseHelper(Context context){
super(context,DATABASE_NAME, null, DATABASE_VERSION);
}
//Выполняется, когда файл с БД не найден на устройстве
@Override
public void onCreate(SQLiteDatabase db, ConnectionSource connectionSource){
try
{
TableUtils.createTable(connectionSource, Goal.class);
TableUtils.createTable(connectionSource, Role.class);
}
catch (SQLException e){
Log.e(TAG, "error creating DB " + DATABASE_NAME);
throw new RuntimeException(e);
}
}
//Выполняется, когда БД имеет версию отличную от текущей
@Override
public void onUpgrade(SQLiteDatabase db, ConnectionSource connectionSource, int oldVer,
int newVer){
try{
//Так делают ленивые, гораздо предпочтительнее не удаляя БД аккуратно вносить изменения
TableUtils.dropTable(connectionSource, Goal.class, true);
TableUtils.dropTable(connectionSource, Role.class, true);
onCreate(db, connectionSource);
}
catch (SQLException e){
Log.e(TAG,"error upgrading db "+DATABASE_NAME+"from ver "+oldVer);
throw new RuntimeException(e);
}
}
//синглтон для GoalDAO
public GoalDAO getGoalDAO() throws SQLException{
if(goalDao == null){
goalDao = new GoalDAO(getConnectionSource(), Goal.class);
}
return goalDao;
}
/синглтон для RoleDAO
public RoleDAO getRoleDAO() throws SQLException{
if(roleDao == null){
roleDao = new RoleDAO(getConnectionSource(), Role.class);
}
return roleDao;
}
//выполняется при закрытии приложения
@Override
public void close(){
super.close();
goalDao = null;
roleDao = null;
}
}
```
Как видно в примере, нужно описать создание полей и таблицы, а также реализовать получение ссылки на синглтон с DAO-объектом. Теперь рассмотрим непосредственно сами DAO.
#### DAO
Самой простой реализацией является следующий класс
```
public class RoleDAO extends BaseDaoImpl{
protected RoleDAO(ConnectionSource connectionSource,
Class dataClass) throws SQLException{
super(connectionSource, dataClass);
}
public List getAllRoles() throws SQLException{
return this.queryForAll();
}
}
```
Здесь создан лишь один дополнительный метод для получения коллекции всех объектов класса Role.
Основные методы create, update, delete реализованы в предке BaseDaoImpl.
Для обращения к методом класса RoleDao в любом классе приложения достаточно обратиться к классу-фабрике:
`RoleDAO roleDao = HelperFactory.GetHelper().getRoleDAO();`
#### Создание запросов
Для построения специфичных запросов можно создавать свои методы в классе DAO.
```
public List getGoalByName(String name) throws SQLException{
QueryBuilder queryBuilder = queryBuilder();
queryBuilder.where().eq(Goal.GOAL\_NAME\_FIELD\_NAME, "First goal");
PreparedQuery preparedQuery = queryBuilder.prepare();
List goalList =query(preparedQuery);
return goalList;
}
```
Как видно, здесь производился поиск по объектам с соответствующим полем имени.
При построении более сложных запросов помимо `eq` (что означает equals) есть и другие вроде `gt`(greater), `ge`(greater and equals) и остальных соответсвующих стандартным where-конструкцииям в SQL (полный список [здесь](http://ormlite.com/javadoc/ormlite-core/doc-files/ormlite_3.html#SEC37))
Для построения сложного запроса можно добавлять `and`:
`queryBuilder.where().eq(Goal.GOAL_NAME_FIELD_NAME, "First goal").and().eq(Goal.GOAL_NOTES_NAME_FIELD_NAME,”aaa”);`
Соответсвенно помимо запросов из БД подобным образом можно [удалять и обновлять таблицы](http://ormlite.com/javadoc/ormlite-core/doc-files/ormlite_3.html#SEC35).
#### Работа с вложенным сущностями
Рассмотрим отношения вида много к одному. Допустим объект Goal имеет поле указывающее на Role.
Соответственно в классе Goal поле должно быть аннотированно
```
@DatabaseField(foreign = true)
private Role role;
public void setRole(Role value){
this.role = value;
}
public Role getRole(){
return role;
}
```
Теперь мы можем сохранить наши объекты в БД
```
Goal g = new Goal();
g.setName(“asd”);
Role r = new Role();
g.setRole(r);
HelperFactory.getHelper.getRoleDAO().create(r);
HelperFactory.getHelper.getGoalDAO().create(g);
```
Чтобы получить доступ к объекту класса Role, который связан с объектом типа Goal:
```
Goal g = HelperFactory.getHelper.getRoleDAO().getGoalByName(“asd”);
Role r = g.getRole();
HelperFactory.getHelper.getRolelDAO().refresh(g);
```
`refresh()` необходимо выполнять, чтобы r получил все поля из БД соответвующие этому объекту.
При хранинии ссылки на коллекцию подход немного отличается:
в классе Goal:
```
@ForeignCollectionField(eager = true)
private Collection roleList;
public addRole(Role value){
value.setGoal(this);
HelperFactory.GetHelper().getRoleDAO().create(value);
roleList.add(value);
}
public void removeRole(Role value){
roleList.remove(value);
HelperFactory.GetHelper().getRoleDAO().delete(value);
}
```
Аргумент в аннотации `eager` означает, что все объекты из roleList будут получаться из БД вместе с извлечением объекта типа Goal. Обязательной является ссылка на Goal в объекте Role. А так же нужно отдельно сохранять с помощью RoleDAO каждый из объектов Role.
Соответственно в классе Role должна быть аннотация:
```
@DatabaseField(foreign = true, foreignAutoRefresh = true)
private Goal goal;
```
Если не ставить `eager=true`, то будет осуществлена lazy-инициализация, т.е. при запросе объекта Goal объекты соотвествующие коллекции roleList не будут извлечены. Для их извлечения нужно будет произвести их итерацию:
```
Iterator iter = state.goal.getRoleList().iterator();
while (iter.hasNext()) {
Role r = iter.next();
}
```
[Ссылка на библиотеку](http://ormlite.com/releases/).
[Ссылка на туториалы](http://ormlite.com/javadoc/ormlite-core/doc-files/ormlite_toc.html#SEC_Contents). | https://habr.com/ru/post/143431/ | null | ru | null |
# Почему наш стартап переехал с Flask на FastAPI
Продукт стартапа Datafold — платформа для мониторинга аналитических данных. Они подключаются к хранилищам данных и ETL и BI-системам, помогая дата-сайентистам и инженерам отслеживать потоки данных, их качество и аномалии
И однажды стартап решил поменять стек. Как так случилось? Это же затраты и все возникающие при этом сложности переезда. Но если хочешь получить короткий, эргономичный, хорошо читаемый код, приходится идти на жертвы. Но давайте по порядку.
Алекс Морозов, co-founder & [CTO](https://www.linkedin.com/in/alex-morozov-54b5081aa?lipi=urn%3Ali%3Apage%3Ad_flagship3_profile_view_base_contact_details%3Bfig4q4%2B0TAqcGzIbSwJjyw%3D%3D) в компании [Datafold](https://www.datafold.com/), рассказал, как они переехали с Flask на FastAPI и поделился собственным опытом такого переезда. Это не только то, что пишут в документации, а конкретные проблемы, с которыми они столкнулись при переезде, и как они их обошли. На примерах посмотрим, что стоит сделать, а каких решений лучше избегать.
Полтора года назад стартап Datafold прошел в Ycombinator, ведущий акселератор для небольших компаний. Это значило, что у них было 4 месяца, чтобы показать результат, и 1-2 месяца — чтобы написать MVP.
У фаундеров не было глубокой экспертизы в веб-разработке — до этого они занимались Data Engineering и системным программированием. Поэтому они решили стартовать с готового проекта и на его базе построить нужный функционал. Рассмотрев несколько вариантов, остановились на Redash — он оказался очень близок по тематике. У него те же самые аналитические базы, подключение и стандартный User Management. К тому же у Redash лицензия MIT, то есть разработчики разрешают использовать код даже в закрытых форках. И наконец, это современный Single Page Application.
Почему решили менять стек
-------------------------
В Redash всё от начала и до конца было построено на Flask: адаптеры sqlalchemy, миграции alembic, REST, auth, rate-limiters, CSRF, etc и даже CLI!. А фронтенд сделан на стандартной комбинации React и JS. Например, код типичного хэндлера Flask-RESTful:
Хэндлер получает данные, достает их из тела запроса как JSON, валидирует и конвертирует поля. То есть для простых вещей требуется очень много кода. А если еще хочется получать толковые сообщения об ошибках (например, поле не того типа или нужное поле отсутствует), то boilerplate выходит еще в несколько раз больше.
Есть несколько вариантов, упростить и ускорить конвертацию и валидацию. Например, можно использовать JSON-схему, но тогда date/datetime все равно придется парсить руками. Ещё вариант — использовать модули pydantic или marshmallow, которые в Redash не употреблялись.
Дальше видно, что привязка роутов делается позже, в отдельном месте. Хотя лучше было бы сделать её декоратором сразу на хэндлере. В хэндлере объявляется переменная idx, и её тип дублируется в роуте.
Кроме того, вся логика сдвинута на 2 отступа, что кажется мелочью. Но в реальном коде может быть, например, контекстный менеджер, exception handling, цикл, пара вложенных if/else. Ещё по сути ничего не написано, а код уже размазывается об правую границу экрана. И лишний второй отступ хорошо в этом помогает.
Ещё Flask-RESTful ничего не знает о типах данных, и поэтому не может экспортировать схему в каком-либо машиночитаемом формате. C автодокументацией тоже проблемы. Flask-RESTful находится в режиме поддержки и не развивается, хотя есть более современные форки.
Или вот еще одна часть, которая вызывает трение — Flask-SQLAlchemy:
Есть стандартный интерфейс для выборок данных SQLAlchemy, с которым все знакомы. Flask-SQLAlchemy добавляет урезанный вариант выборок, который короче на десяток символов. Такая экономия хороша для CRUD-бэкэндов. Но если вы делаете что-то более сложное, то вдобавок к урезанному интерфейсу приходится использовать и стандартный. Получающаяся смесь того не стоит. Ещё надо добавить, что на всех моделях резервируется слово «query», которое в области Data Engineering используется везде, и приходится выдумывать для него синонимы.
Использование Flask-SQLAlchemy в проекте Datafold-а приводило к циклическим зависимостям: для инициализации приложения надо было достать конфигурацию из БД, а чтобы достать что-то из БД через Flask-SQLAlchemy, нужно инициализированное приложение. Это можно решить некрасивыми хаками, но за них приходится платить понятностью кода.
Есть ещё один момент — Flask-SQLAlchemy использует scoped-сессии БД. То есть в начале каждого запроса кладет сессию в thread-locals, и потом каждый раз магически достает её оттуда. Когда дело выходит за пределы http-хэндлеров, то становится удобнее передавать сессию в явном виде. Хотя это, во многом, дело вкуса. До той поры, когда в воркерах Celery вам приходится инициализировать приложение Flask, чтобы бизнес-логика могла работать с базой из воркеров.
На фронтенде тоже возникали проблемы. При использовании React + JS были постоянные ошибки типов в рантайме. А поскольку все данные передаются по приложению с помощью Object (в Python аналог передача словарями), то местами сложно понять, с каким типом данных имеешь дело. Поэтому проект решили переводить на React + TypeScript. При этом интерфейсные типы в TS переносились из API бэкэнда руками. Из-за переноса вручную часто получался рассинхрон, и снова возникали ошибки в рантайме.
Надо было искать более подходящее решение, поэтому начали прорабатывать другие варианты и остановились на FastAPI.
Сравнение с FastAPI
-------------------
Код того же самого хэндлера с FastAPI будет выглядеть так:
Здесь мы видим несколько положительных моментов.
Валидация делается с помощью pydantic, надо только определить модель (CiRun) и задать типы полей. Всё остальное: парсинг, валидацию, handling и формирование текста ошибок pydantic делает сам, спасая от boilerplate.Также, FastAPI позволяет избавиться от проблемы с дублированием аннотации типов в URL. Здесь тип достаточно указать только в одном месте. А ещё теперь в коде один отступ!
Сомнительно выглядит то, что возвращаемый тип указан не в аннотации метода, а в декораторе. Но если подумать, то это резонно — часто нужно возвращать типы в обертках, например с нестандартными HTTP-статусами.
### FastAPI — OpenAPI / Swagger
Поскольку FastAPI «знает» формат данных на входе и на выходе эндпоинта, он может выдать полную схему API в виде JSON-а. Ее можно скачать curl’ом с работающей системы или экспортировать напрямую из Python кода. На выходе получается описание схемы в JSON в формате Open API / Swagger, который уже можно конвертировать в структуры и boilerplate вызовов для разных языков.
Например, как сгенерировать описание интерфейса для TypeScript:
```
$ curl https://localhost:8000/openapi.json >openapi.json
$ npx openapi-typescript schema.json --output schema.ts
```
Если генерацию типов выполнять во время билда, то проблема синхронизации между фронтом и бэком решается.
### FastAPI async
Одной из ключевых фич FastAPI заявляется высокая производительность. Но для Datafold это не было важно. Хоть их SaaS-ом пользуется большое количество компаний, из-за предметной области тут нет речи о тысячах запросов в секунду.
Часто с производительностью смешивают поддержку async. Если она вдруг нужна, то хэндлер просто декларируется как async и в нем пишется асинхронный код как обычно:
```
@router.post('/api/...')
async def ci_run_async(...):
...
```
Тут стоит заметить, что async реально нужен только в небольшом количестве случаев, например если вы используете вебсокеты, или long-polling. В случае Datafold внутренняя асинхронность FastAPI только доставляла проблемы.
Переход
-------
Поскольку у стартапа не было возможности остановить разработку и переконвертировать всё за пару-тройку недель, они делали переход частями, перенося их в прод небольшими батчами. Пришлось заменить около десятка плагинов Flask: аутентификацию, rate limiter, Flask-SQLAlchemy и другие. Поэтому, когда стал понятен масштаб, они сделали дополнительный Proof Of Concept, чтобы проверить, что FastAPI точно заделиверит по своим обещаниям.
Сначала начали убирать модули, которые можно было убрать на рабочем Flask. Заменили Flask-Migrate на стандартный alembic, flask.cli на click, а для Flask—SQLAlchemy сделали затычку. Подставили атрибут Model.query на все модели, чтобы не разрушать интерфейс выборок, иначе пришлось бы сразу рефакторить 90% кода.
После этого они вставили FastAPI-сервер непосредственно перед Flask. Запросы сначала приходили на него, а он передавал их дальше Flask:
```
fastapi_app.mount(
"/api",
WSGIMiddleware(flask_app, workers=10)
)
```
Аутентификацию нужно было делать по cookie и по токенам. Для этого на базе имеющихся в FastAPI классов пришлось написать немного кода и тщательно его проверить.
Процесс перехода ещё продолжается. Сейчас они конвертируют эндпоинты и везде добавляют Pydantic, но основные результаты уже достигнуты.
### Проблемы sync/async
Теперь о проблемах, с которыми столкнулись в Datafold при переходе.
У FastAPI все асинхронно, включая middleware — он сделан надстройкой над асинхронным сервером Starlette. Это приводит к определенным проблемам в синхронных хэндлерах. Например, при интеграции с GitHub нужно уметь считать HMAC тела запроса, чтобы проверять, что запрос пришел именно от GitHub, а не откуда-то еще.
Напрашивается очевидный код, который достает тело Request:
```
@router.post('/api/...')
def ci_run(request: Request):
body = request.body()
```
Но так это не работает, потому что функция request.body() возвращает корутину, а не данные, и её надо выполнять на асинхронном event loop. Что так просто из синхронного кода не сделать. Чтобы обойти эту проблему, можно сделать отдельную асинхронную функцию, которая достает тело запроса из request:
```
async def get_body(request: Request):
return await request.body()
@router.post('/api/...')
def ci_run(body=Depends(get_body)):
pass
```
Дальше в хэндлер FastAPI эта функция включается как dependency. FastAPI перед вызовом функции резолвит все зависимости. Поскольку это делается в асинхронном контексте, get\_body() правильно отрабатывает, и синхронному хэндлеру на вход передается уже тело самого запроса. Точно также можно делать и с формами, и с JSON-ом в теле запроса.
В юнит-тестах body можно передавать в явном виде, без каких-либо хитрых моков.
### Проблемы с SQLAlchemy
В проекте использовали GraphQL фрэймворк Ariadne, который построен на async, что имеет некоторый смысл — сервер GraphQL ориентирован на сбор данных из множества источников, и поэтому из них желательно собирать данные одновременно, чтобы уменьшить суммарное время ответа. Одним из таких источников в проекте Datafold является PostgreSQL со всеми моделями приложения на SQLAlchemy. Но в версии 1.3 SQLAlchemy аsync не поддерживается. Поэтому надо было либо мигрировать на версию 1.4, которая уже поддерживала async, либо как-то это обходить в async эндпоинтах.
Может показаться, что можно просто написать обычную выборку:
Но так делать нельзя, потому что заблокируются все корутины event loop-а, пока выборка не выполнится. Что увеличит задержку для всех остальных корутин, сделает её плохо предсказуемой, и полностью уберет конкурентность.
Можно попробовать сделать обычную связку, которую делают, когда из async-кода вызывают sync-код (run\_in\_executor).
При этом выборка запустится в thread-пуле, и создаст впечатление, что все будет хорошо. Но, скорее всего, не будет, потому что треды thread-пула запускаются без контекста, который управляет соединениями SQLAlchemy. Запросить сессию БД из отсутствующего контекста очевидно не получится. Что показывает, что неявное имеет тенденцию приводить к неприятным сюрпризам.
Решить это можно, написав wrapper, который создаст ScopedSession, и внутри ScopedSession уже делать выборку:
```
async def graphql_resolver():
def wrap():
with ScopedSession():
return session.query(DataSource).all()
objs = await (
asyncio.get_event_loop().run_in_executor(
None, wrap
)
)
```
#### Другие проблемы
При переходе возникали и другие проблемы. Те самые ScopedSession сначала не до конца написали корректно, поэтому в некоторых случаях соединения к базе оставались открытыми, что выловили при тестировании.
Ещё одна проблема, которая дошла до прода, была связана с запуском FastAPI. В документации в качестве http-сервера рекомендуется использовать Uvicorn (асинхронный аналог Gunicorn). При этом, в качестве последней линии защиты от утечки памяти, в проекте сделали перезапуск рабочих процессов. Например, после 1000 реквестов, рабочий процесс перезапускается и освобождает всю память. Проблема в том, что Uvicorn останавливает старый процесс, но новый не запускает. В результате все процессы останавливаются, и сервер по факту перестает работать. В проде это было обнаружено через 20 минут после выкатки, и оперативно починено.
Чтобы обойти эту проблему, можно использовать в качестве супервизора Gunicorn, с плагином Uvicorn. В этой конфигурации Gunicorn отвечает за менеджмент рабочих процессов, а Uvicorn работает внутри воркеров и обрабатывает запросы:
```
gunicorn \
--worker-class uvicorn.workers.UvicornWorker \
...
```
Результат
---------
После переезда с Flask на FastAPI код проекта стал более кратким, эргономичным и хорошо читаемым. Появилась возможность документации API, экспорта его структуры и автоматической генерации типов. В эндпоинтах API из-за использования pydantic стало значительно меньше boilerplate и автоматически появились качественные сообщения об ошибках валидации входных данных.
Видео моего выступления на Moscow Python Conf++ 2021:
> На конференции [HighLoad++ Foundation 2022](https://clck.ru/ZAJtT) будет также [секция](https://clck.ru/ZAJqN), посвященная BigData и машинному обучению. 17 и 18 марта в Крокус-Экспо в Москве встретятся Python-разработчики выкосонагруженных систем. Присоединяйтесь :)
>
> В рамках конференции также будет Open Source трибуна, где 10 лучших авторов смогут рассказать о своем решении. Сейчас [идет](https://clck.ru/ZAKjq) прием заявок.
>
> | https://habr.com/ru/post/575958/ | null | ru | null |
# Еще один Port knocking
Приветствую коллеги! В данной статье хочется описать свою доработку популярной технологии защиты сетевых рубежей под названием Port Knocking, реализованную на оборудовании MIKROTIK. Технология древняя, неоднократно описана и разжевана. Используется повсеместно и довольно эффективна. По этому в статье я не стану подробно объяснять что это и для чего нужно. Предполагается что читатель в теме. Если не в теме но есть интерес, рекомендую вначале познакомиться с технологией в других публикациях, коих огромное количество.
---
Для чего статья:
Hidden textНадеюсь что данная реализация кому то да будет полезной, поскольку у меня она зарекомендовала себя хорошо, а у других я чего то подобного не встречал. Идея родилась в самый разгар Корона дампа, когда на “удаленку” отправили 90% (а где то и больше) персонала. Конечно технологией удаленного доступа к локальным ресурсам компании у нас пользовались и до этого. И Port Knocking, был настроен давно. И работал по классике. Была настроена цепочка правил где микротик принимал пакеты определенного размера по протоколу ICMP (обычный пинг), если пакеты идут в правильной последовательности и правильного размера, для IP источника открывается удаленный доступ к нужному ресурсу. Для этого у меня (для WINDOWS клиентов) было написано несколько БАТ файлов. От самых простых с зацикленным пингом нужного ресурса, до довольно изощренных. В основном для VPN клиентов. Где единожды закинув клиенту на флэшку некий дистрибутив из БАТ файлов и кое каких других, процесс установки VPN соединения полностью автоматизировался. Даже если клиент до этого не пользовался ВПНом совсем. Помимо этого в зависимости от задачи через некое подобие меню можно подключать сетевые диски, устанавливать RDP соединения и выполнять ряд других действий. Этот способ является основным и по сей день. Но только для WINDOWS клиентов, поскольку в других OS я к сожалению не силен. По окончании работы батника все следы его работы и установленных соединений удаляются почти бесследно. Способ для меня крайне хорош и удобен. Но постепенно стало выяснятся что не все сидят под ВИНДОЙ (самая частая альтернатива, оказалась MAC OS) . А у кого-то и флэшку вставить некуда, или политиками разрешен запуск только определенного софта. Короче нюансов хватало.
В результате этой вакханалии родилась идея некого кроссплатформенного решения. Простого и не замысловатого. Работающего как с флэшки так и с общедоступного ресурса. И первое что пришло на ум, старый добрый HTML + JavaScript . JS был выбран как раз по тому что способен исполнятся на стороне клиента (наверно любого). Оговорюсь, скрипт писал фрилансер, по-моему ТЗ. Возможно, что код не идеален. Поэтому прошу воздержаться от критики. Если вы специалист и можете помочь допилить код, буду рад. Если, по-вашему, прям чего-то очень не хватает, то рынок фриланса к вашим услугам. Я вам вряд ли помогу.
Что нам нужно?
1. **На МИКРОТИКЕ настраиваем**
Port Knocking. Но не классический ICMP (пинг с заданным размером пакета), а по
обращению к портам в определенной последовательности по протоколу TCP. В примере мы
задействуем 4 порта. Порты лучше брать выше 1024 и до 65535 (следите что бы
порты были свободны на вашем микротике и не использавались где либо еще.
([Подробнее о портах](https://ru.wikipedia.org/wiki/%D0%A1%D0%BF%D0%B8%D1%81%D0%BE%D0%BA_%D0%BF%D0%BE%D1%80%D1%82%D0%BE%D0%B2_TCP_%D0%B8_UDP)). В случае если порядок соблюден верно, для адреса источника становятся доступен пинг хоста назначения (у себя вы можете изменить конечный результат по своему усмотрению). В качестве примера, ниже я размещу ссылку на работающую форму и укажу адрес хоста и код для проверки работоспособности. Подтверждением работы будет возможность пинга удаленного хоста который до выполнения скрипта будет невозможным. Может быть, когда вы будете читать статью форма уже будет недоступна. Но исходники кода я приложу, так что возможность проверки сохранится в любом случае, но уже на ваших ресурсах.
2. **Код правил “firewall filter” для микротика:**
Hidden text
```
/ip firewall filter
add action=accept chain=input comment=ICMP in-interface=[имя внешнего интерфейса. Обычно ether1] protocol=icmp src-address-list=ICMP
add action=jump chain=input connection-state=new dst-address=[ip адрес внешнего интерфейса (по желанию)] dst-port=1025,1088,1051,1549 in-interface=[имя внешнего интерфейса. Обычно ether1] jump-target=Kn-Tcp protocol=tcp
add action=add-src-to-address-list address-list=Gate001 address-list-timeout=2s chain=Kn-Tcp connection-state=new dst-port=1025 protocol=tcp
add action=add-src-to-address-list address-list=Gate002 address-list-timeout=2s chain=Kn-Tcp connection-state=new dst-port=1088 protocol=tcp src-address-list=Gate001
add action=add-src-to-address-list address-list=Gate003 address-list-timeout= 2s chain=Kn-Tcp connection-state=new dst-port=1051 protocol=tcp src-address-list=Gate002
add action=add-src-to-address-list address-list=ICMP address-list-timeout=1h chain=Kn-Tcp connection-state=new dst-port=1549 protocol=tcp src-address-list=Gate003
add action=return chain=Kn-Tcp connection-state=new
/
```
В данном примере:
Hidden textмы использовали порты: 1025, 1088, 1051 и 1549. При поступлении пакета на каждый из этих портов он попадет в созданную цепочку “Kn-Tcp” (в принципе конструкцию с правилом “Jump” и “Return” можно не использовать, работать будет и без нее. В примере эти правила как дань классике. Если откажитесь от них то в других правилах желательно указать IN interface и выбрать цепочку input) при верной последовательности поступления пакетов, создаются временные адрес листы, последний из которых сроком на 1 час. И именем ICMP. Из этого адрес листа получает IP адреса источников правило с комментарием “ICMP”. Если IP есть в листе, то для него разрешается пинг. Перед вставкой кода в консоль микротика поправьте его под ваше оборудование. В частности укажите IP и имя внешнего интерфейса. Править код рекомендую в нормальном редакторе с подсветкой синтаксиса, к примеру notepad++, который наконец начал понимать синтаксис ROS. Если будете использовать штатный notepad windows возможны ошибки при COPY PASTE.
3. Размещаем где либо HTML страницу с JavaScript. Это может быть как общедоступный WEB сервер. Так и локальная директория на компьютере или usb флэшке.
На январь 2023 года демо страница общедоступна по адресу <https://kn.invstdev.ru> (напомню, что не гарантирую ее вечную работу по этому адресу. Ищите исходники в конце статьи)
4. Открываем страницу, прописываем хост и код (перечень портов разделенных “-”), жмем капу “отправить”. Если не поставили галку “повторять”, получаем доступ к ресурсу на 1 час с соответствующем уведомлением (страницу с уведомлением можно переопределить в файле “index.html” на любую другую). Если галку “повторять” поставили, скрипт будет регулярно повторяться в течении 8 часов.
Работу скрипта вы можете проверить на демо ресурсе:
Hidden text(вечную работу которого так же не гарантирую), Хост: [kn.papiruss.ru](https://kn.papiruss.ru) Код: 1025-1088-1051-1549
После нажатия кнопки отправить вы сможете пропинговать вышеуказанный хост. Пинг которого до этого был невозможен.
Для особо параноидально настроенных товарищей, во избежании попыток подбора нужной комбинации портов, могу предложить до оснастить конструкцию "сладким горшочком" (Honeypot). Гугл вам в помощь. Но я не думаю что это хоть сколько то целесообразно в вашем случае. Смаил
---
**Коды HTML и** **JavaScript.**
Создаем 2 пустых файла с именами index.html и theend.html, а так же поддиректорию js с файлом main.js
**Файл main.js (нужно положить в
поддиректорию js):**
Hidden text
```
'use strict';
const TIMEOUT = 1000 * 60 * 60 * 8;
function main() {
const submitButton = document.getElementById('submit');
const hostElement = document.getElementById('host');
const codeElement = document.getElementById('code');
const needIterateElement = document.getElementById('needIterate');
submitButton.addEventListener('click', (e) => {
e.preventDefault();
const host = hostElement.value;
const code = codeElement.value;
const ports = code.split("-");
let value = needIterateElement.checked;
if (value) {
makeRequests(host, ports);
let timerId = setInterval(() => {
makeRequests(host, ports);
}, 10 * 60 * 1000);
setTimeout(() => {
clearInterval(timerId);
window.location.replace("./theend.html");
}, TIMEOUT);
} else {
makeRequests(host, ports);
setTimeout(() => {
window.location.replace("./theend.html");
}, 1000);
}
});
}
function sleep(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
function makeRequests(host, ports) {
console.log(ports);
for (let i = 0; i < ports.length; i++) {
try {
console.log(ports[i]);
const newLocal = 'https://' + host + ":" + ports[i];
console.log(newLocal);
// fetch(newLocal).then().catch();
var oReq = new XMLHttpRequest();
oReq.onload = function (e) {
var arraybuffer = oReq.response; // not responseText
console.log(arraybuffer);
}
oReq.open("GET", newLocal);
oReq.responseType = "arraybuffer";
oReq.send();
} catch (e) {
console.log(e);
}
}
}
main();
```
**Cтраница index.html:**
Hidden text
```
KNOCK
Хост
Код
Повторять
Отправить
```
**Страница theend.html:**
Hidden text
```
KNOCK THE END
Работа скрипта окончена. Ваш сеанс будет активен еще 1 час.
```
В завершении статьи в качестве бонуса за то что дочитали подскажу один не очевидный для многих лайфхак. Если вдруг вы не знали. Микротик способен защищать не только те ресурсы которые находятся за ним. Но и те которые (как бы это сказать) по бокам.
Всего двумя правилами в таблице FIREWALL/NAT вы можете перенаправлять запросы к любому общедоступному ресурсу от имени вашего микротика. Если еще не понимаете зачем это надо, вот пример. На VPS хостинге вы подняли свою виртуалку, скажем с RDP. И уже где то минуту спустя вы сталкиваетесь с тем что вас начинают нещадно брутить. И конечно есть уйма способов как защитить себя и свою VPS от этой напасти. Но я предложу один. У вас есть микротик на котором мы только что настроили Port Knocking. Пишем в NAT два правила (редиректа и маскарада), а в FIREWALL своей VPS разрешаем подключения к RDP только с определенных IP, среди которых указываем IP своего микртотика. Клиенты прошедшие авторизацию через Port Knocking, в качестве адреса назначения указывают адрес и порт вашего микротика, а тот перенаправляет подключения на ваш RDP. Вуаля, без особых хлопот вы получили Port Knocking на своем RDP сервере периметр которого не защищен микротиком явно. Они вообще могут быть на разных континентах.
**КОД для firewall NAT:**
Hidden text
```
/ip firewall nat
add action=dst-nat chain=dstnat comment=REDIREKT_KUDA_TO dst-port=3389 protocol=tcp src-address-list=ICMP to-addresses=1.1.1.1
add action=masquerade chain=srcnat dst-address=1.1.1.1 dst-port=3389 protocol=tcp
/
```
**В этом примере:**
Hidden textмикротик принимает TCP пакеты на порт 3389 от источников из адрес листа ICMP и пересылат их хосту 1.1.1.1 на тот же порт, с маскарадом (таким образом хост получателя видит не ваш реальный IP, а IP микротика). Если правило маскарада исключить то пакеты так же будут пересылаться, но ответа вы не получите. Поскольку хост назначения будет отвечать вам на прямую, иначе говоря ответы на ваши запросы будут приходить от хоста 1.1.1.1, в то время когда ваша система будет ожидать их от хоста микротика. При желании это можно решить правкой маршрутов на сервере "получателе" или его аппаратном шлюзе (если таковой есть). Но проще просто использовать второе правило. При чем с точки зрения лучшей производительности и при наличии статического IP адреса на микротике посреднике, макард в экшене лучше заменить на “src-nat” с указанием ip адреса внешнего интерфейса микротика. Это правило всегда более предпочтительно вместо маскарада, но при условии что на микротике имеется белая статика. Еще одним бонусом такого способа подключения будет то что ваши клиенты (если они не через чур любознательны и технически грамотны) не будут знать реального адреса сервера RDP. Получается как в офисной АТС, связь через доп номера. На RDP сервере фаервол вообще можно не трогать. Полностью оградив его от атак из внешней среды (атаки из локальной подсети при этом остаются возможными), тем что бы не указывать в настройках сети, адрес шлюза. Добавив в таблицу маршрутизации один только статистический маршрут к вашему микротику. При этом на сервере перестанет работать интернет, но и это можно решить различными способами, о которых я возможно расскажу в других статьях.
На этом считаю что статью можно закончить. Глубоко признателен всем кто дочитал до конца!
С уважением, всем Хабра ))) | https://habr.com/ru/post/709022/ | null | ru | null |
# Разбираемся с цветами, палитрами, фильтрами CSS и не только
Этот материал — карманный справочник о том, как работать с цветом в CSS и вебе в целом. Он начинается с теоретических основ и содержит множество инструментов и примеров работы с градиентами, анимацией, SVG и не только.
Статья будет полезна и новичку, и специалисту с опытом. За подробностями приглашаем под кат, пока у нас начинается [курс по Frontend-разработке](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_171021&utm_term=lead).
---
Огромная часть работы с цветом — это понимание того, что цвет в мониторах работает не так, как мы привыкли в детстве, когда смешивали краски. К примеру, краска и чернила принтера содержат крошечные частицы, — пигменты, которые смешиваются друг с другом и отражаются, чтобы представить цвет глазу. Так происходит субтрактивное смешивание цветов.
Чем больше цветов вы добавляете к исходному цвету, тем темнее он становится, пока не станет коричневым. Основные цвета принтера близки к привычным красному, жёлтому, синему, но смешивая цвета субтрактивно вы получите коричневый.
С другой стороны, на мониторах мы работаем со светом: когда все цвета смешиваются, они образуют белый цвет.
До знаменитого [эксперимента](http://www.college-optometrists.org/en/college/museyeum/online_exhibitions/observatory/newton.cfm) Исаака Ньютона считалось, что цвет содержится в объектах, а не отражается или поглощается ими. Ньютон при помощи призмы доказал теорию о том, что солнечный свет состоит из нескольких цветов. Он разделил цвета призмой — получилась радуга.
Затем Ньютон попытался разделить синий цвет, но синий не разделился. Это означало, что цвет не находится внутри призмы, а, скорее, призма разделяет свет. То есть при аддитивном смешивании цветов в мониторе красный, зелёный и синий цвета могут использоваться, чтобы получить все цвета. При таком смешивании красный и зелёный цвета создают жёлтый.
Мониторы — это множество комбинаций кусочков света. Резонируя, они создают мириады других цветов. Разрешение — это количество отдельных цветных точек, известных как пиксели, которые содержатся на дисплее.
Художники использовали этот тип частоты света ещё до того, как у нас появились мониторы. Сёра и пуантилисты использовали красный и зелёный цвета, чтобы получить жёлтый, на таких картинах, как «La Grande Jatte» (хотя сам Сёра предпочитал термин «хромо-люминаризм»). Другие люди называют подход [дивизионизмом](https://en.wikipedia.org/wiki/Divisionism).
Этот тип живописи был создан на основе убеждения, что оптическое смешение создаёт более чистый резонанс, чем традиционное субтрактивное смешение цветов пигмента.
Количество цветов, которые могут быть отображены одновременно, определяется битовой глубиной цвета. Если битовая глубина равна 1, мы можем получить два цвета, или монохром.
Битовая глубина 2 даст 4 цвета, и так далее, пока мы не достигнем битовой глубины 32, хотя обычно мониторы, отображающие веб-страницы, имеют плотность 24 битовой глубины и 16 777 216 цветов, — это True Color и альфа-канал.
True Color называется так потому, что наши глаза различают 10 000 000 уникальных цветов, а значит, 24-бит, безусловно, позволяет это. В этой 24-битной глубине по 8 бит отводится на красный, зелёный и синий цвета. Остальные используются для прозрачности или альфа-каналов.
Значения цвета
--------------
### RGB
Последний раздел иллюстрирует, что rbga(x, x, x, y); передаёт информацию, но давайте разберём цветовые значения немного подробнее и покажем некоторые другие свойства и их использование. Цвета в канале RGB задаются в диапазоне 0-255.
```
x is a number from 0-255
y is a number from 0.0 to 1.0
rgb(x, x, x); or rgba(x, x, x, y);
Example: rbga(150, 150, 150, 0.5);
```
### Hex (шестнадцатеричные цвета)
Шестнадцатеричные цвета — это немного другой формат для представления значений тем же способом. И это, пожалуй, самый распространённый способ обозначения цвета в Интернете.
Если вы помните, что байт — это 8 бит, каждый цвет или число Hex представляет собой байт. Цвет задаётся в соответствии с интенсивностью его красного, зелёного и синего компонентов. Эти три значения называются триплетом.
Один байт представляет собой число в диапазоне от 00 до FF (в шестнадцатеричной системе счисления) или от 0 до 255 в десятичной системе счисления. Первый байт — красный, творой байт — зелёный, а байт 3 — синий.
Шестнадцатеричная система называется так потому, что в ней используется система оснований 16. В качестве значений используются диапазоны от 0-9 и от A-F, причём 0 — наименьшее значение, а F — наибольшее, то есть `#00000` — чёрный, а #FFFFFF — белый.
Для триплетов с повторяющимися значениями можно устранить повторение, написав их сокращённо, например, `#00FFFF` становится `#0FF`. Если вы собираетесь работать с цветами глубже, немного лучше читается HSL.
### HSL
Значения hsl работают с диапазонами, как и RGB, но вместо того, чтобы работать со значениями, соответствующими логике интерпретации монитора, значения hsl — это оттенок, насыщенность, светлота. Похоже на значения RGB, но диапазоны отличаются. Эта система основана на колориметрической [системе](https://en.wikipedia.org/wiki/Munsell_color_system) Манселла (он был первым, кто разделил цвет на эти три канала, или создал трёхмерную систему, основанную на математических принципах, привязанных к человеческому зрению).
Трёхмерное представление HSLОттенок вращается на 360 градусов, полный круг, а насыщенность и светлота — это проценты от 0 до 100. Представьте себе колесо, в центре которого находится плотное и насыщенное содержимое. [Эта демонстрация](http://www.workwithcolor.com/hsl-color-picker-01.htm) довольно хорошо отражает систему.
 https://css-tricks.com/examples/HSLaExplorer/Если вы не особенно опытны в работе с цветом, hsla() позволяет использовать некоторые довольно простые правила для приятных эффектов для разработчиков. Подробнее об этом — в разделе “Генеративный цвет”.
### Именованные цвета
Именованные цвета имеют репутацию неудобных из-за неточных названий.
Самые яркие, "знаменитые" примеры: тёмно-серый на самом деле светлее серого, а лайм и лайм-грин — совершенно разные цвета. Есть даже игра, где нужно [угадать](https://codepo8.github.io/css-colour-names/) название цвета в вебе, созданная Крисом Хеилманном.
В давние времена chucknorris был кроваво-красным цветом (сейчас он поддерживается только в HTML, насколько я могу судить), это был мой любимый цвет.
Именованные цвета могут быть полезны в быстрой демонстрации, но обычно разработчики используют Sass или другие препроцессоры для хранения значений цветов в формате hex, rgba или hsla и сопоставления их с названиями цветов, используемых в компании.
### Переменные цвета
Хорошая практика — хранить переменные цвета и никогда не использовать их напрямую, вместо этого отображая их на переменные с более осмысленными именами, вот так:
```
:root {
--brandColor: red;
}
body {
background: var(--brandColor);
}
```
На момент написания этой статьи в браузерах Microsoft [переменных не было](https://caniuse.com/#feat=css-variables). Препроцессоры CSS тоже поддерживают переменные, поэтому вы можете установить переменные типа $brandPrimary или [отображение](https://www.sitepoint.com/using-sass-maps/):
```
$colors: (
mainBrand: #FA6ACC,
secondaryBrand: #F02A52,
highlight: #09A6E4
);
@function color($key) {
@if map-has-key($colors, $key) {
@return map-get($colors, $key);
}
@warn "Unknown `#{$key}` in $colors.";
@return null;
}
// _component.scss
.element {
background-color: color(highlight); // #09A6E4
}
```
Помните, что именование здесь очень важно. Абстрактное именование иногда полезно, чтобы при изменении переменной, которая представляла синий цвет, на оранжевый, вам не пришлось переименовывать все значения цвета. Или, что хуже, повесить табличку с надписью "$blue теперь оранжевый".
### currentColor
`currentColor` — это невероятно полезное значение. Полезно оно для распространения значения цвета на тени, контуры, границы или даже фон. Допустим, вы создали div (внешний, то есть `.div-xternal`), а внутри него ещё один, `div-internal`. Обведём внутренний div оранжевой границей с помощью `currentColor`:
```
.div-external { color: orange; }
.div-internal { border: 1px solid currentColor; }
```
Это невероятно полезно для систем иконок, либо шрифтовых SVG-иконок. Вы можете установить `currentColor` в качестве значения по умолчанию для заливки, обводки или цвета, а затем использовать семантически подходящие классы CSS для стилизации.
### Препроцессоры
Для настройки цветов отлично подходят препроцессоры CSS. Вот несколько ссылок на документацию по цветовым функциям различных препроцессоров:
* [функции Sass](http://sass-lang.com/documentation/Sass/Script/Functions.html);
* [функции Less](http://lesscss.org/functions/#color-operations);
* [функции Stylus](http://stylus-lang.com/docs/bifs.html);
* [пример плагина PostCSS](https://github.com/postcss/postcss-color-function) для цветовых функций.
А ниже несколько интересных вещей, которые мы можем сделать с помощью Sass:
```
mix($color1, $color2, [$weight])
adjust-hue($color, $degrees)
lighten($color, $amount)
darken($color, $amount)
saturate($color, $amount)
```
На самом деле есть десятки способов программного смешивания и изменения цветов с помощью препроцессоров, не будем в них углубляться, но вот отличный интерактивный ресурс, чтобы узнать больше.
Свойства цвета
--------------
Как свойство CSS `color` относится к цвету шрифта. Если вы задаёте цвет для большой области, то используете `background-color`, а в случае SVG-элемент работаете с `fill`. Border — это граница вокруг элемента HTML, а `stroke` — аналог этой границы в SVG.
### Прямоугольник и тень текста
Свойства box-shadow и text-shadow принимают значение цвета. Тени текста принимают 2 или 3 значения, `h-shadow` (горизонтальная тень), `v-shadow` (вертикальная тень) и необязательный радиус размытия.
Тени прямоугольника принимают 2 или 4 значения, `h-shadow`, `v-shadow`, дополнительное расстояние размытия и дополнительное расстояние распространения. Вы также можете обозначить вставку в начале, чтобы создать перевёрнутую тень. На этом сайте есть отличная демонстрация с простым, легко вставляемым кодом.
### Градиенты
Линейные градиенты работают, обозначая направление от и до, в зависимости от префикса браузера сверху, снизу, слева, справа, можно задать градусы и радиальный градиент. Затем мы указываем остановки цвета и цвет, которого хотим добиться на каждой остановке. Цвета могут быть и прозрачными:
Синтаксис градиентов не так уж сложно написать, но мне очень нравится работать с этим [генератором](http://www.colorzilla.com/gradient-editor/) градиентов, потому что он создаёт сложное свойство фильтра, поддерживая IE6-9. Есть ещё один очень красивый Open Source [генератор](http://uigradients.com/).
Градиенты также легко пишутся на SVG. По желанию мы можем задать площадь поверхности для градиента. С помощью идентификатора мы определяем блок, на который ссылаемся.
```
```
Эти градиенты также поддерживают непрозрачность, поэтому можно добиться красивых эффектов слоя, например, анимировать слои как маску.
Градиентный текст возможен только в webkit. Вот простой [код](https://css-tricks.com/snippets/css/gradient-text/) на CSS-Tricks.
Генеративные цвета
------------------
В пределах указанных ранее диапазонов вы можете использовать циклы for в любом препроцессоре, или же JavaScript функцию `Math.random()` и `Math.floor()`. Здесь нам нужны `Math.floor()` или `Math.ceil()`, потому что если не вернуть полные целые числа, то вместо значения цвета получим ошибку. Хорошее эмпирическое правило: не следует обновлять все три значения.
При помощи HSL очень легко переходить от одного цвета к другому, потому что вы знаете, что перебор оттенков от 0 до 360 даст вам полный диапазон. Ещё одна приятная особенность hue-rotate в градусах заключается в том, что поскольку это полный круг, вам не нужно придерживаться диапазона 0–360, можно написать даже -480 или 600 — браузер вас поймёт.
### Sass
```
@mixin colors($max, $color-frequency) {
$color: 300/$max;
@for $i from 1 through $max {
.s#{$i} {
border: 1px solid hsl(($i - 10)*($color*1.25), ($i - 1)*($color / $color-frequency), 40%);
}
}
}
.demo {
@include colors(20,2);
}
```
Я использую его, чтобы сгенерировать эти цвета:
А также этот, с другим диапазоном (прокрутите очень быстро):
Ниже я использую `Math.random()` в значениях rgb, чтобы получить множество цветов в одном диапазоне. Демонстрация написана на React, создаётся впечатление трёхмерности. Я могла бы пройти по нему при помощи `for`, но хотелось, чтобы цвет был случайным, отражал движение. Здесь нет предела совершенству.
A-Frame React Demo 1[sdras.github.io](https://sdras.github.io/react-aframe-demo1/)JavaScript
----------
```
class App extends React.Component {
render () {
const items = [],
amt1 = 5,
amt2 = 7;
for (let i = 0; i < 30; i++) {
let rando = Math.floor(Math.random() * (amt2 - 0 + 1)) + 0,
addColor1 = parseInt(rando * i),
addColor2 = 255 - parseInt(7 * i),
updateColor = `rgb(200, ${addColor1}, ${addColor2})`;
items.push(
// ...
);
}
return (
// ...
{items}
);
}
}
```
[GreenSock](http://greensock.com/) выпустили инструмент, позволяющий анимировать относительные значения цвета, что очень полезно: можно захватывать сразу множество элементов и анимировать эти элементы относительно их собственных цветовых координат. Вот несколько демонстрирующих идею черепах. Чтобы увидеть эффект, наведите курсор на черепаху.
Вот код:
```
TweenMax.to(".turtle2 path, .turtle2 circle, .turtle2 ellipse", 1.5, {fill:"hsl(+=0, +=50%, +=0%)"});
```
### Смешение цветов и режимы смешения фонов
Если вы использовали эффекты слоёв в Photoshop, то, вероятно, знакомы с режимами смешивания (наложения). Почти каждый сайт в 90-е годы использовал их (мой тоже). Режимы смешивания и фонового наложения позволяют соединить два разных многослойных изображения, при этом доступно 16 режимов.
Верхнее изображение, или цвет, называется исходным, нижний слой называется конечным. Область между слоями, где происходит смешивание, называется фоном. Изображения смешиваются при помощи довольно простых формул.
Если вы хотите прослыть настоящим занудой, знайте, что формулы для режимов наложения зависят от типа эффекта. Например, multiply — это destination source = backdrop. Другие эффекты — это вариации простой математики с вычитанием, умножением, сложением и делением. Формула линейного эффекта — A+B-1, а эффекта Color Burn — это 1-(1-B)\*A.
Вот [более обширная документация](https://css-tricks.com/almanac/properties/m/mix-blend-mode/), а ниже простая демонстрация, иллюстрирующая работу цвета в таких эффектах:
В [этой](https://css-tricks.com/chaining-multiple-blend-modes/) замечательной статье Робин демонстрирует некоторые действительно сложные и впечатляющие эффекты, которых можно добиться с помощью наложения нескольких режимов смешивания. Ниже мы рассмотрим их смешивание с фильтрами.
### Фильтры
Фильтры CSS предоставляют множество классных цветовых эффектов, а также возможность взять цветное изображение и сделать его серым. На CSS-Tricks есть [замечательный ресурс](https://css-tricks.com/almanac/properties/f/filter/), который показывает, как они работают, и хорошо поддерживается браузерами. У Беннета Фили вы [найдёте](http://bennettfeely.com/filters-gallery/) хорошую галерею фильтров.
Фильтры и режимы размытия могут работать вместе! Уна Кравец создала этот классный инструмент под названием [CSS Gram](http://una.im/CSSgram/), комбинируя некоторые эффекты, чтобы создать фильтры из Instagram. В конце есть хорошая документация.
### feColorMatrix
В другой статье Уна [исследует](http://alistapart.com/article/finessing-fecolormatrix) создание этих изображений через feColorMatrix, — примитива фильтра в SVG, который также может применяться к элементам HTML. Он очень мощный и позволяет точно настроить цвет. Как следует из названия, базовая разметка feColorMatrix использует матрицу значений, а применяется она через её относительный id.
```
```
Матрицу можно расширить и отрегулировать оттенок, насыщенность и так далее:
```
```
В статье Уны подробно рассматриваются все возможности этого инструмента. Ещё больше информации об этом и многих других сумасшедших цветах SVG, а также об инструментах градиента в [книге](http://shop.oreilly.com/product/0636920043065.do) Амелии Белами-Ройд от O’Reilly или в [исследовательской](https://codepen.io/mullany/full/qJCDk/) демонстрации Майка Муллани.
Доступность и другие замечания
------------------------------
Цвет проявляется только в отношении с другими цветами. Вы, вероятно, немного знакомы с этим в плане стандартов доступности [для людей с ограничениями по зрению]. Светло-зелёный цвет на чёрном может быть доступным [видимым], но, когда вы меняете фон на белый, зелёный различается плохо.
Доступность цвета можно измерить многими инструментами. Ниже некоторые из моих любимых:
* [Текст на изображении, проверка a11y](http://www.brandwood.com/a11y/).
* [Accessible Colors](http://accessible-colors.com/).
Также очень хорошо с самого начала настроить свою палитру так, чтобы она была доступной [контрастной].
[Color Safe](http://colorsafe.co/) — отличный инструмент, который помогает в этом. Как только вы всё подготовите, [WAVE (Web Accessibility Tool)](http://wave.webaim.org/) поможет оценить веб-страницу.
### Цвет и атмосфера
Атмосфера влияет на цвет. Знать это довольно важно, если вы собираетесь создать хоть какую-то иллюзию глубины. Предметы ближе к вам более насыщены и контрастны. Предметы дальше более размыты.
Ландшафт подчёркивает зависимость контраста от расстояния### Тени
Тени не серые, они дополняют цвет света: если свет обладает жёлтым оттенком, тень будет казаться фиолетовой. Это полезно знать, если вы создаёте очень длинные тени.
### Нативный ввод цвета
Существует встроенный в браузер селектор цветов, который вы можете использовать, чтобы помочь пользователям выбирать цвета динамически. Такой код:
Отобразит элемент выбора цветов, например такой:
Следует иметь в виду, что в разных браузерах селектор цветов будет отображаться по-разному, как и любой другой встроенный элемент управления.
[Этот пен](https://codepen.io/noahblon/pen/ZbjmbK/) Ноя Блона показывает, как использовать его в сочетании с цветовым фильтром hue в CSS, чтобы выбирать части изображения динамически и изменять цвета. Оставшаяся часть изображения — это градации серого, поэтому она не затрагивается, что довольно умно.
Полезное
--------
* [Color Highlighter Plugin](https://packagecontrol.io/packages/Color%20Highlighter) для Sublime Text я использую, чтобы увидеть, какой цвет интерпретирует браузер. Мне нравится использовать `{"ha_style": "outlined"}`.
* Существует несколько различных традиционных комбинаций палитры, а также интернет-ресурсы, которые помогут вам их составить. Вот более научное представление — [Paletton](http://paletton.com/) или [Adobe Color](https://color.adobe.com/create/color-wheel/).
* Бенджамин Найт [написал](https://codepen.io/benknight/pen/nADpy) аналог Adobe Color при помощи d3 на CodePen, инструмент довольно крут и заслуживает внимания.
* Если вы хотите, чтобы веб делал за вас тяжёлую работу (а кто этого не хочет?), посмотрите на [Coolors](https://coolors.co/), настолько простой, насколько это возможно.
* Если вам нужна помощь в интерпретации цветов, и вы хотите быстрый простой инструмент перевода цвета из одной цветовой модели в другую, в [энциклопедии цвета](https://www.colorhexa.com/) ColorHexa вы найдёте преобразования цветов в разные системы, которые только можно придумать.
И для самых занудных цветоманов. Вы можете даже заставить свою консоль выводить цвета для вас. Вот великолепный [пен](https://codepen.io/jscottsmith/pen/VLzMLo/), показывающий, как это работает. Надеюсь, эта статья даст вам отправную точку для экспериментов и понимания.
Продолжить изучение цветов, чтобы стать профессиональным веб-разработчиком, вы можете на наших курсах:
* [Профессия Frontend-разработчик (7 месяцев)](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_171021&utm_term=conc)
* [Профессия Fullstack-разработчик на Python (15 месяцев)](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_171021&utm_term=conc)
Также вы можете перейти на страницы [из каталога](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_171021&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_171021&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_171021&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_171021&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_171021&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_171021&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_171021&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_171021&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_171021&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_171021&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_171021&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_171021&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_171021&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_171021&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_171021&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_171021&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_171021&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_171021&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_171021&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_171021&utm_term=cat)
* [Профессия Этичный хакер](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_171021&utm_term=cat)
**А также:**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_171021&utm_term=cat) | https://habr.com/ru/post/581888/ | null | ru | null |
# SFINAE — это просто
TLDR: *как определять, есть ли в типе метод с данным именем и сигнатурой, а также узнавать другие свойства типов, не сойдя при этом с ума.*
Здравствуйте, коллеги.
Хочу рассказать о SFINAE, интересном и очень полезном (к сожалению\*) механизме языка C++, который, однако, может представляться неподготовленному человеку весьма мозгоразрывающим. В действительности принцип его использования достаточно прост и ясен, будучи сформулирован в виде нескольких чётких положений. Эта заметка рассчитана на читателей, обладающих базовыми знаниями о шаблонах в C++ и знакомых, хотя бы шапочно, с C++11.
**\*** *Почему к сожалению? Хотя использование SFINAE — интересный и красивый приём, переросший в широко используемую идиому языка, гораздо лучше было бы иметь средства, явно описывающие работу с типами.*
Сначала, на всякий случай, очень коротко скажу о метапрограммировании в C++. Метапрограммирование — это операции, производимые во время компиляции программы. Подобно тому, как обычные функции позволяют получать значения, при помощи метафункций получают типы и константы времени компиляции. Одно из наиболее популярных применений метапрограммирования, хотя далеко не единственное — узнавать свойства типов. Всё это, разумеется, применяется при разработке шаблонов: где-то бывает полезно знать, имеем мы дело со сложным пользовательским классом с нетривиальным конструктором или с обычным **`int`**, где-то необходимо установить, унаследован ли один тип от другого, или можно ли преобразовать один тип в другой. Мы рассмотрим механизм применения SFINAE на классическом примере: проверке того, существует ли в классе функция-член с заданными типами аргументов и возвращаемого значения. Я постараюсь подробно и детально пройти по всем этапам создания проверочной метафункции и проследить откуда что берётся.
Аббревиатура SFINAE расшифровывается как *substitution failure is not an error* и означает следующее: при определении перегрузок функции ошибочные инстанциации шаблонов не вызывают ошибку компиляции, а отбрасываются из списка кандидатов на наиболее подходящую перегрузку. Выражаясь по-человечески, это означает вот что:
* Когда речь заходит о SFINAE, это обязательно связано с перегрузкой функций.
* Это работает при автоматическом выводе типов шаблона (type deduction) по аргументам функции.
* Некоторые перегрузки могут отбрасываться в том случае, когда их невозможно инстанциировать из-за возникающей синтаксической ошибки; компиляция при этом продолжается как ни в чём не бывало, без ошибок.
* Отбросить могут только шаблон.
* SFINAE рассматривает только заголовок функции, ошибки в теле функции не будут пропущены.
Получается, что мы имеем возможность манипулировать перегрузками какой-то функции, при необходимости скрывая некоторые из них при помощи создания искусственных ошибок. При этом скрываемый кандидат обязан быть шаблоном, а факт наличия ошибки должен зависеть от параметра этого шаблона. Другие виды ошибок компилятор сможет определить без подстановки, едва увидев само определение шаблона, и никакого SFINAE не получится, а вместо этого нас больно заругают.
Рассмотрим простой пример:
```
int difference(int val1, int val2)
{
return val1 - val2;
}
template
typename T::difference\_type difference(const T& val1, const T& val2)
{
return val1 - val2;
}
```
Функция `difference` отлично работает для целых аргументов. А вот с пользовательскими типами данных начинаются тонкости. Результат вычитания не всегда имеет тот же самый тип, что и операнды. Так, разность двух дат — интервал времени, который сам по себе датой не является. Если пользовательский тип `MyDate` имеет внутри себя определение `typedef MyInterval difference_type;` и оператор вычитания `MyInterval operator - (const MyDate& rhs) const;`, к нему применима шаблонная перегрузка. Вызов `difference(date1, date2)` сможет «увидеть» и шаблонную перегрузку, и версию, принимающую **`int`**, при этом шаблонная перегрузка будет сочтена более подходящей.
Тип `MyString`, в котором нет `difference_type`, при подстановке вызовет ошибку: функция возвращала бы несуществующий тип. Вызов `difference` с аргументами типа `MyString` сможет «увидеть» только **`int`**-версию функции. Эта единственная версия окажется достаточно подходящей только если в `MyString` определён оператор преобразования в число. Конструкция `val1 - val2` требует наличия бинарного оператора «минус» и тоже может породить синтаксическую ошибку. Получается, что шаблонная функция `difference` проверяет тип аргумента на одновременное выполнение сразу трёх условий: наличие `difference_type`, наличие оператора вычитания и возможность приведения результата вычитания к типу `difference_type` (преобразование подразумевается оператором **`return`**). Но в то время, как типам, нарушающим первое условие, эта перегрузка не видна, нарушение второго или третьего условий вызовет ошибку компиляции.
Попробуем же придумать, как сделать метафункцию, которая говорит нам, есть ли в каком-то типе метод `void foo(int)`. Заботливая STL, особенно начиная с версии C++11, уже определила для нас много полезных метафункций, размещённых в основном в заголовках [`type_traits`](http://en.cppreference.com/w/cpp/types) и [`limits`](http://en.cppreference.com/w/cpp/header/limits), однако именно такой, какую мы дерзновенно замыслили сделать, там почему-то нет. Метафункция обычно выглядит как шаблонная структура без данных, внутри которой определён результат операции: заданный через **`typedef`** тип с именем `type` или статическая константа `value`. Такого соглашения придерживается STL, и причин оригинальничать у нас нет, поэтому будем придерживаться установленного образца.
Можно сразу написать «скелет» нашей будущей метафункции:
```
template struct has\_foo{};
```
Она определяет *наличие* метода, из чего сразу ясно, что результат должен иметь булевский тип:
```
template struct has\_foo{
static constexpr bool value = true; // Сейчас придумаем, что здесь написать, а пока всем отвечаем "да".
};
```
А вот теперь надо придумать, как сделать перегрузку, определяющую нужные нам свойства типа, и как получить из неё булевскую константу. Прелесть в том, что нам не нужно давать тела перегрузкам: поскольку вся работа происходит в режиме компиляции за счёт манипуляций с типами, хватит одних объявлений.
Очевидно, мы хотим, чтобы наша метафункция была применима для любого типа. Ведь про любой тип можно сказать, есть ли в нём искомый метод. Значит, `has_foo` не должна вызывать ошибки компиляции, какой бы параметр мы ни подставили. А ошибка-то произойдёт, если вдруг окажется, что нужного метода в типе T нет. Получается, что нам нужно две перегрузки одной проверочной функции. Одна из них, «детектор» должна быть синтаксически правильной только для типов, содержащих нужный метод. Другая, «подложка», должна быть всеядной, то есть быть достаточно подходящей для любых подставленных типов. В то же время «детектор» должен иметь неоспоримое преимущество в «подходящести» перед «подложкой». Наименее приоритетным и в то же время максимально всеядным в определении перегрузок является эллипсис (троеточие, обозначающее переменное количество аргументов):
```
template struct has\_foo{
void detect(...); // С "подложкой" всё просто.
static constexpr bool value = true; // Ладно-ладно, уже скоро придумаем!
};
```
Теперь надо объявить «детектор». Это должен быть шаблон: того, что он уже внутри шаблоной структуры, недостаточно! Нужен шаблон внутри шаблона [несколько секунд наслаждаемся одобрительными взглядами со стороны героев фильма [Inception](http://www.quickmeme.com/img/66/66361e04d5af38305505578359c92784eaa7bbf58b132a1f6276eefe797fecf5.jpg)]. К «подложке» это не относится, поскольку её мы не будем выкидывать никогда. А вот для «детектора» воспользуемся волшебным словом [`**decltype**`](http://en.cppreference.com/w/cpp/language/decltype), которое определяет тип выражения, причём само выражение не вычисляется и в код не переводится. Подставим в качестве выражения вызов того самого метода, с аргументами нужного типа. Тогда ответом **`decltype`** будет возвращаемый тип метода. А если метода с таким именем нет, или он принимает другие типы аргументов, то мы получим ту самую контролируемую ошибку, которую и хотели. Пусть «детектор» возвращает то же, что и `foo`:
```
template struct has\_foo{
void detect(...);
template decltype(U().foo(42)) detect(const U&);
static constexpr bool value = true; // Теперь точно скоро!
};
```
Если передадим в `detect` ссылку на `const T&`, получится, что `U` — тот же самый тип, что и `T`. Для проверки соответствия типа возвращаемого значения мы потом усовершенствуем детектор или придумаем что-то другое по ходу дела.
Однако постойте! Мы вызываем метод на свежесконструированном анонимном объекте, причём сконструирован-то он по умолчанию. А что будет, если мы передадим в `has_foo` тип, у которого нет конструктора по умолчанию? Конечно же, ошибка компиляции. Правильнее было бы объявить какую-нибудь функцию, возвращающую значение нужного типа. Вызываться она всё равно не будет, а нужный эффект будет достигнут. STL позаботилась и об этом: в заголовке `utility` есть функция [`declval`](http://en.cppreference.com/w/cpp/utility/declval):
```
template struct has\_foo{
void detect(...);
template decltype(std::declval().foo(42)) detect(const U&);
static constexpr bool value = true; // Почти готово!
};
```
Осталось только научиться отличать «подложку» от «детектора». Тут нам поможет всё тот же **`decltype`**. У «подложки» тип возвращаемого значения всегда **`void`**, а у «детектора» — тип, возвращаемый методом, то есть в случае, когда метод соответствует нашим требованиям… тот же самый **`void`**. Так не пойдёт. Сменим-ка мы для «подложки» тип на **`int`**. Тогда проверка получается простой: если вызов `detect` на объекте `T` имеет тип **`void`**, то сработал «детектор» и метод полностью соответствует нашим требованиям. Если тип другой, то либо сработала «подложка», либо метод существует, принимает те самые аргументы, но возвращает что-то не то. Проверяем, насколько заботлива STL, и тут же находим метафункцию проверки типов на равенство [`is_same`](http://en.cppreference.com/w/cpp/types/is_same):
```
template struct has\_foo{
private: // Спрячем от пользователя детали реализации.
static int detect(...); // Статическую функцию и вызывать проще.
template static decltype(std::declval().foo(42)) detect(const U&);
public:
static constexpr bool value = std::is\_same()))>::value; // Вот видите, готово.
};
```
Ура, мы добились желаемого. Как видите, всё и в самом деле достаточно просто. Отдадим дань уважения тем программистам, которые ухитрялись проделывать этот фокус в суровых условиях предыдущего стандарта, гораздо более многословно и хитроумно из-за отсутствия таких полезных штук, как **`declval`**.
SFINAE используется настолько широко, что даже в заботливую STL включили специальную метафункцию [`enable_if`](http://en.cppreference.com/w/cpp/types/enable_if). Её параметры — булевская константа и тип (по умолчанию **`void`**). Если передано **`true`**, то в метафункции присутствует тип `type`: тот, что передан вторым параметром. Если же передано **`false`**, то никакого `type` там нет, что и создаёт ту самую контролируемую ошибку. В свете соображений, перечисленных выше в аккуратном списочке, надо помнить, что `enable_if` сможет «вычеркнуть» перегрузку функции только если она — шаблон, а также озаботиться тем, чтобы список «невычеркнутых» перегрузок никогда не оставался совсем пустым. Можно применять `enable_if` и в специализациях шаблонного класса, но в таком случае это уже не SFINAE, а нечто вроде [`**static\_assert**`](http://en.cppreference.com/w/cpp/language/static_assert).
В заключение хочу заострить внимание на том, что потенциал применения этого механизма намного шире, чем проверка свойств типов. Можно использовать его непосредственно по прямому назначению, создавая оптимизированные перегрузки функций и методов: с итераторами произвольного доступа, например, можно позволить себе больше вольностей, чем с последовательными итераторами. А при желании можно и придумать куда более причудливые конструкции, ~~особенно если ваша фамилия Александреску~~. Отталкиваясь от изложенных в этой заметке базовых принципов, можно создавать мощный, гибкий и надёжный код, умеющий самостоятельно приспосабливаться «на лету» к особенностям используемых типов. | https://habr.com/ru/post/205772/ | null | ru | null |
# Модели глубоких нейронных сетей sequence-to-sequence на PyTorch (Часть 4)
4 - Упакованные дополненные последовательности, маскировка, вывод и метод оценки BLEU
-------------------------------------------------------------------------------------
В этой части мы добавим несколько улучшений — упакованные дополненные последовательности и маскировка — к модели из предыдущего раздела. Упакованные дополненные последовательности используются, чтобы сообщить нашей RNN, что нужно пропускать маркеры заполнения в нашем кодировщике. Маскировка явно заставляет модель игнорировать определенные значения, такие как внимание к элементам с заполнением. Оба эти метода обычно используются в обработке естественного языка (NLP).
Кроме того, мы рассмотрим как использовать нашу модель для вывода целевого предложения, давая ей входное предложение, видя результат её перевода, и выясняя, на что именно она обращает внимание при переводе каждого слова.
Наконец, мы будем использовать метрику BLEU для измерения качества наших переводов.
Как и ранее, если визуальный формат поста вас не удовлетворяет, то ниже ссылки на английскую и русскую версию jupyter notebook:
[Исходная версия](https://github.com/bentrevett/pytorch-seq2seq/blob/master/4%20-%20Packed%20Padded%20Sequences%2C%20Masking%2C%20Inference%20and%20BLEU.ipynb) [Open jupyter notebook In Colab](https://colab.research.google.com/github/bentrevett/pytorch-seq2seq/blob/master/4%20-%20Packed%20Padded%20Sequences%2C%20Masking%2C%20Inference%20and%20BLEU.ipynb)
[Русская версия](https://github.com/vasiliyeskin/bentrevett-pytorch-seq2seq_ru/blob/master/4%20-%20Packed%20Padded%20Sequences%2C%20Masking%2C%20Inference%20and%20BLEU.ipynb) [Open jupyter notebook In Colab](https://colab.research.google.com/github/vasiliyeskin/bentrevett-pytorch-seq2seq_ru/blob/master/4%20-%20Packed%20Padded%20Sequences%2C%20Masking%2C%20Inference%20and%20BLEU.ipynb)
**Замечание**: русская версия jupyter notebook отличается от исходной добавленным в конце тестом на инверсию предложения. Очень простая для человека задача, но, порой, непреодолима для искусственных систем.
### Подготовка данных
Сначала мы импортируем все модули, как и раньше, с добавлением модулей `matplotlib`, используемых для просмотра вектора внимания.
```
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torchtext.legacy.datasets import Multi30k
from torchtext.legacy.data import Field, BucketIterator, TabularDataset
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
import spacy
import numpy as np
import random
import math
import time
```
Затем мы установим случайное начальное число для воспроизводимости.
```
SEED = 1234
random.seed(SEED)
np.random.seed(SEED)
torch.manual_seed(SEED)
torch.cuda.manual_seed(SEED)
torch.backends.cudnn.deterministic = True
```
Загрузите немецкую и английскую модели spaCy.
```
python -m spacy download en_core_web_sm
python -m spacy download de_core_news_sm
```
Для загрузки в Google Colab используем следующие команды (После загрузки обязательно перезапустите colab runtime! Наибыстрейший способ через короткую комаду： **Ctrl + M + .**):
```
!pip install -U spacy==3.0
!python -m spacy download en_core_web_sm
!python -m spacy download de_core_news_sm
```
Как и раньше, мы импортируем spaCy и определим токенизаторы для немецкого и английского языков.
```
spacy_de = spacy.load('de_core_news_sm')
spacy_en = spacy.load('en_core_web_sm')
```
```
def tokenize_de(text):
"""
Tokenizes German text from a string into a list of strings
"""
return [tok.text for tok in spacy_de.tokenizer(text)]
def tokenize_en(text):
"""
Tokenizes English text from a string into a list of strings
"""
return [tok.text for tok in spacy_en.tokenizer(text)]
```
При использовании упакованных дополненных последовательностей нам нужно сообщить PyTorch, какова длина фактических (не дополненных) последовательностей. К счастью для нас, объекты TorchText `Field` позволяют нам использовать аргумент `include_lengths`, это приведет к тому, что наш `batch.src` будет кортежем. Первый элемент кортежа такой же, как и раньше, пакет числовых исходных предложений в качестве тензора, а второй элемент — это длины без дополнений каждого исходного предложения в пакете.
```
SRC = Field(tokenize = tokenize_de,
init_token = '',
eos\_token = '',
lower = True,
include\_lengths = True)
TRG = Field(tokenize = tokenize\_en,
init\_token = '',
eos\_token = '',
lower = True)
```
Затем мы загружаем данные.
```
train_data, valid_data, test_data = Multi30k.splits(exts = ('.de', '.en'),
fields = (SRC, TRG))
```
И заполняем словарь.
```
SRC.build_vocab(train_data, min_freq = 2)
TRG.build_vocab(train_data, min_freq = 2)
```
Далее мы подготавливаем итераторы.
Одна из особенностей упакованных последовательностей с дополнениями заключается в том, что все элементы (предложения) в пакете должны быть отсортированы по их длине без дополнений в порядке убывания, т.е. первое предложение в пакете должно быть самым длинным. Мы используем два аргумента итератора для обработки этого: `sort_within_batch`, который сообщает итератору, что содержимое пакета необходимо отсортировать, и `sort_key` - функцию, которая сообщает итератору, как сортировать элементы в пакете. Здесь мы сортируем по длине предложения `src`.
```
BATCH_SIZE = 128
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
train_iterator, valid_iterator, test_iterator = BucketIterator.splits(
(train_data, valid_data, test_data),
batch_size = BATCH_SIZE,
sort_within_batch = True,
sort_key = lambda x : len(x.src),
device = device)
```
### Построение модели
#### Кодировщик
Далее мы определяем кодировщик.
Все изменения здесь происходят в методе `forward`. Теперь он принимает длину исходных предложений и сами предложения.
После того, как исходное предложение (автоматически дополненное итератором) было пропущено через эмбеддинг, мы можем использовать для него `pack_padded_sequence` с длинами предложений. Обратите внимание, что тензор, содержащий длины последовательностей, должен быть тензором CPU в последней версии PyTorch, что мы явно делаем с помощью `to ('cpu')`. `Packaged_embedded` будет нашей упакованной последовательностью. Затем передаём в нашу RNN как обычно, и она возвращает `packed_outputs`, упакованный тензор, содержащий все скрытые состояния из последовательности, и `hidden` - это просто последнее скрытое состояние из нашей последовательности. `hidden` стандартный тензор и никак не упакованный, единственная разница в том, что на входе была упакованная последовательность, этот тензор из последнего **элемента без дополнений** в последовательности.
Затем мы распаковываем наши `packed_outputs` с использованием `pad_packed_sequence` который возвращает `outputs` и длины каждого, которые нам не нужны.
Первое измерение `outputs` - это длины дополненных последовательностей. Однако из-за использования упакованной дополненной последовательности значения тензоров будут нулевыми, в случае когда на входе был маркер заполнения.
```
class Encoder(nn.Module):
def __init__(self, input_dim, emb_dim, enc_hid_dim, dec_hid_dim, dropout):
super().__init__()
self.embedding = nn.Embedding(input_dim, emb_dim)
self.rnn = nn.GRU(emb_dim, enc_hid_dim, bidirectional = True)
self.fc = nn.Linear(enc_hid_dim * 2, dec_hid_dim)
self.dropout = nn.Dropout(dropout)
def forward(self, src, src_len):
#src = [src len, batch size]
#src_len = [batch size]
embedded = self.dropout(self.embedding(src))
#embedded = [src len, batch size, emb dim]
#need to explicitly put lengths on cpu!
packed_embedded = nn.utils.rnn.pack_padded_sequence(embedded, src_len.to('cpu'))
packed_outputs, hidden = self.rnn(packed_embedded)
#packed_outputs is a packed sequence containing all hidden states
#hidden is now from the final non-padded element in the batch
outputs, _ = nn.utils.rnn.pad_packed_sequence(packed_outputs)
#outputs is now a non-packed sequence, all hidden states obtained
# when the input is a pad token are all zeros
#outputs = [src len, batch size, hid dim * num directions]
#hidden = [n layers * num directions, batch size, hid dim]
#hidden is stacked [forward_1, backward_1, forward_2, backward_2, ...]
#outputs are always from the last layer
#hidden [-2, :, : ] is the last of the forwards RNN
#hidden [-1, :, : ] is the last of the backwards RNN
#initial decoder hidden is final hidden state of the forwards and backwards
# encoder RNNs fed through a linear layer
hidden = torch.tanh(self.fc(torch.cat((hidden[-2,:,:], hidden[-1,:,:]), dim = 1)))
#outputs = [src len, batch size, enc hid dim * 2]
#hidden = [batch size, dec hid dim]
return outputs, hidden
```
#### Внимание
Модуль внимания — это та часть, в которой мы вычисляем значения внимания по исходному предложению.
Ранее мы позволяли этому модулю «обращать внимание» на токены заполнения в исходном предложении. Однако, используя *маскировку*, мы можем заставить внимание концентрироваться только на элементах, не являющиеся заполнением.
Метод `forward` теперь принимает на входе `mask`. Это тензор **[batch size, source sentence length]**, который равен 1, если токен исходного предложения не является токеном заполнения, и 0, когда это маркер заполнения. Например, если исходное предложение ["hello", "how", "are", "you", "?", , ], то маска будет [1, 1, 1, 1, 1, 0, 0].
Мы применяем маску после того, как внимание было рассчитано, но до того, как оно будет нормализовано функцией `softmax`. Это реализовано с использованием `masked_fill`. Тензор заполняется для каждого элемента, для которого выполняется условие для первого аргумента `mask == 0`, значением, заданным вторым аргументом `-1e10`. Другими словами, он примет ненормализованные значения внимания и изменит их для элементов заполнения на`-1e10`. Поскольку эти числа будут мизерными по сравнению с другими значениями, они станут равными нулю при прохождении через слой `softmax`, что гарантирует отсутствие внимания к маркерам заполнения в исходном предложении.
```
class Attention(nn.Module):
def __init__(self, enc_hid_dim, dec_hid_dim):
super().__init__()
self.attn = nn.Linear((enc_hid_dim * 2) + dec_hid_dim, dec_hid_dim)
self.v = nn.Linear(dec_hid_dim, 1, bias = False)
def forward(self, hidden, encoder_outputs, mask):
#hidden = [batch size, dec hid dim]
#encoder_outputs = [src len, batch size, enc hid dim * 2]
batch_size = encoder_outputs.shape[1]
src_len = encoder_outputs.shape[0]
#repeat decoder hidden state src_len times
hidden = hidden.unsqueeze(1).repeat(1, src_len, 1)
encoder_outputs = encoder_outputs.permute(1, 0, 2)
#hidden = [batch size, src len, dec hid dim]
#encoder_outputs = [batch size, src len, enc hid dim * 2]
energy = torch.tanh(self.attn(torch.cat((hidden, encoder_outputs), dim = 2)))
#energy = [batch size, src len, dec hid dim]
attention = self.v(energy).squeeze(2)
#attention = [batch size, src len]
attention = attention.masked_fill(mask == 0, -1e10)
return F.softmax(attention, dim = 1)
```
#### Декодер
В декодере нужно внести лишь несколько небольших изменений. Ему необходимо принять маску исходного предложения и передать ее модулю внимания. Поскольку мы хотим просмотреть значения внимания во время вывода, мы возвращаем и тензор внимания.
```
class Decoder(nn.Module):
def __init__(self, output_dim, emb_dim, enc_hid_dim, dec_hid_dim, dropout, attention):
super().__init__()
self.output_dim = output_dim
self.attention = attention
self.embedding = nn.Embedding(output_dim, emb_dim)
self.rnn = nn.GRU((enc_hid_dim * 2) + emb_dim, dec_hid_dim)
self.fc_out = nn.Linear((enc_hid_dim * 2) + dec_hid_dim + emb_dim, output_dim)
self.dropout = nn.Dropout(dropout)
def forward(self, input, hidden, encoder_outputs, mask):
#input = [batch size]
#hidden = [batch size, dec hid dim]
#encoder_outputs = [src len, batch size, enc hid dim * 2]
#mask = [batch size, src len]
input = input.unsqueeze(0)
#input = [1, batch size]
embedded = self.dropout(self.embedding(input))
#embedded = [1, batch size, emb dim]
a = self.attention(hidden, encoder_outputs, mask)
#a = [batch size, src len]
a = a.unsqueeze(1)
#a = [batch size, 1, src len]
encoder_outputs = encoder_outputs.permute(1, 0, 2)
#encoder_outputs = [batch size, src len, enc hid dim * 2]
weighted = torch.bmm(a, encoder_outputs)
#weighted = [batch size, 1, enc hid dim * 2]
weighted = weighted.permute(1, 0, 2)
#weighted = [1, batch size, enc hid dim * 2]
rnn_input = torch.cat((embedded, weighted), dim = 2)
#rnn_input = [1, batch size, (enc hid dim * 2) + emb dim]
output, hidden = self.rnn(rnn_input, hidden.unsqueeze(0))
#output = [seq len, batch size, dec hid dim * n directions]
#hidden = [n layers * n directions, batch size, dec hid dim]
#seq len, n layers and n directions will always be 1 in this decoder, therefore:
#output = [1, batch size, dec hid dim]
#hidden = [1, batch size, dec hid dim]
#this also means that output == hidden
assert (output == hidden).all()
embedded = embedded.squeeze(0)
output = output.squeeze(0)
weighted = weighted.squeeze(0)
prediction = self.fc_out(torch.cat((output, weighted, embedded), dim = 1))
#prediction = [batch size, output dim]
return prediction, hidden.squeeze(0), a.squeeze(1)
```
#### Seq2Seq
Общая модель seq2seq нуждается в некоторых изменениях для упакованных дополненных последовательностей, маскирования и логического вывода.
Нам нужно сообщить модели, каковы индексы для токена заполнения, а также передать длину исходного предложения в качестве входных данных в метод `forward`.
Мы используем индекс токена заполнения для создания масок, создавая тензор маски, равный 1, везде, где исходное предложение не равно токену заполнения. Все это делается с помощью функции `create_mask`.
Длины последовательностей, которые необходимо передать кодеру для использования упакованных дополненных последовательностей.
Внимание на каждом временном шаге сохраняется в `attentions`
```
class Seq2Seq(nn.Module):
def __init__(self, encoder, decoder, src_pad_idx, device):
super().__init__()
self.encoder = encoder
self.decoder = decoder
self.src_pad_idx = src_pad_idx
self.device = device
def create_mask(self, src):
mask = (src != self.src_pad_idx).permute(1, 0)
return mask
def forward(self, src, src_len, trg, teacher_forcing_ratio = 0.5):
#src = [src len, batch size]
#src_len = [batch size]
#trg = [trg len, batch size]
#teacher_forcing_ratio is probability to use teacher forcing
#e.g. if teacher_forcing_ratio is 0.75 we use teacher forcing 75% of the time
batch_size = src.shape[1]
trg_len = trg.shape[0]
trg_vocab_size = self.decoder.output_dim
#tensor to store decoder outputs
outputs = torch.zeros(trg_len, batch_size, trg_vocab_size).to(self.device)
#encoder_outputs is all hidden states of the input sequence, back and forwards
#hidden is the final forward and backward hidden states, passed through a linear layer
encoder_outputs, hidden = self.encoder(src, src_len)
#first input to the decoder is the tokens
input = trg[0,:]
mask = self.create\_mask(src)
#mask = [batch size, src len]
for t in range(1, trg\_len):
#insert input token embedding, previous hidden state, all encoder hidden states
# and mask
#receive output tensor (predictions) and new hidden state
output, hidden, \_ = self.decoder(input, hidden, encoder\_outputs, mask)
#place predictions in a tensor holding predictions for each token
outputs[t] = output
#decide if we are going to use teacher forcing or not
teacher\_force = random.random() < teacher\_forcing\_ratio
#get the highest predicted token from our predictions
top1 = output.argmax(1)
#if teacher forcing, use actual next token as next input
#if not, use predicted token
input = trg[t] if teacher\_force else top1
return outputs
```
### Обучение модели Seq2Seq
Затем инициализируем модель и размещаем ее на GPU.
```
INPUT_DIM = len(SRC.vocab)
OUTPUT_DIM = len(TRG.vocab)
ENC_EMB_DIM = 256
DEC_EMB_DIM = 256
ENC_HID_DIM = 512
DEC_HID_DIM = 512
ENC_DROPOUT = 0.5
DEC_DROPOUT = 0.5
SRC_PAD_IDX = SRC.vocab.stoi[SRC.pad_token]
attn = Attention(ENC_HID_DIM, DEC_HID_DIM)
enc = Encoder(INPUT_DIM, ENC_EMB_DIM, ENC_HID_DIM, DEC_HID_DIM, ENC_DROPOUT)
dec = Decoder(OUTPUT_DIM, DEC_EMB_DIM, ENC_HID_DIM, DEC_HID_DIM, DEC_DROPOUT, attn)
model = Seq2Seq(enc, dec, SRC_PAD_IDX, device).to(device)
```
Затем мы инициализируем параметры модели.
```
def init_weights(m):
for name, param in m.named_parameters():
if 'weight' in name:
nn.init.normal_(param.data, mean=0, std=0.01)
else:
nn.init.constant_(param.data, 0)
model.apply(init_weights)
```
Мы распечатаем количество обучаемых параметров в модели, заметив, что она имеет точно такое же количество параметров, что и модель без улучшений.
```
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f'The model has {count_parameters(model):,} trainable parameters')
```
Затем мы определяем наш оптимизатор и критерий оптимизации.
`ignore_index` для критерия должен быть индексом токена заполнения для целевого языка, но не для исходного.
```
optimizer = optim.Adam(model.parameters())
```
```
TRG_PAD_IDX = TRG.vocab.stoi[TRG.pad_token]
criterion = nn.CrossEntropyLoss(ignore_index = TRG_PAD_IDX)
```
Далее мы определим наши циклы обучения и оценки.
Поскольку мы используем `include_lengths = True` для нашего исходного поля, `batch.src` теперь является кортежем, первый элемент которого представляет собой числовой тензор, представляющий предложение, а второй элемент — длины каждого предложения в пакете.
Наша модель возвращает, в том числе, векторы внимания для батча исходных предложений на каждом временном шаге декодирования. Мы не будем использовать их во время обучения и оценки точности обучения, но мы будем использовать их позже для вывода.
Для отображения прогресса в Google Colab устанавливаем tensorboard
```
!pip install tensorboardX
```
```
from tensorboardX import SummaryWriter
import datetime
```
```
%load_ext tensorboard
```
```
def train(model, iterator, optimizer, criterion, clip):
model.train()
epoch_loss = 0
for i, batch in enumerate(iterator):
src, src_len = batch.src
trg = batch.trg
optimizer.zero_grad()
output = model(src, src_len, trg)
#trg = [trg len, batch size]
#output = [trg len, batch size, output dim]
output_dim = output.shape[-1]
output = output[1:].view(-1, output_dim)
trg = trg[1:].view(-1)
#trg = [(trg len - 1) * batch size]
#output = [(trg len - 1) * batch size, output dim]
loss = criterion(output, trg)
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), clip)
optimizer.step()
epoch_loss += loss.item()
return epoch_loss / len(iterator)
```
```
def evaluate(model, iterator, criterion):
model.eval()
epoch_loss = 0
with torch.no_grad():
for i, batch in enumerate(iterator):
src, src_len = batch.src
trg = batch.trg
output = model(src, src_len, trg, 0) #turn off teacher forcing
#trg = [trg len, batch size]
#output = [trg len, batch size, output dim]
output_dim = output.shape[-1]
output = output[1:].view(-1, output_dim)
trg = trg[1:].view(-1)
#trg = [(trg len - 1) * batch size]
#output = [(trg len - 1) * batch size, output dim]
loss = criterion(output, trg)
epoch_loss += loss.item()
return epoch_loss / len(iterator)
```
Затем мы определим функцию для определения продолжительности эпох.
```
def epoch_time(start_time, end_time):
elapsed_time = end_time - start_time
elapsed_mins = int(elapsed_time / 60)
elapsed_secs = int(elapsed_time - (elapsed_mins * 60))
return elapsed_mins, elapsed_secs
```
Запускаем tensorboard. Отображение данных начнётся после запуска обучения. Обновить данные можно кликнув по иконке справа вверху
```
!rm -rf ./logs/
%tensorboard --logdir runs
```
Предпоследний шаг — обучить нашу модель. Обратите внимание, что это занимает только почти половину времени по сравнению с нашей моделью без улучшений, добавленных в этот раздел.
```
N_EPOCHS = 10
CLIP = 1
best_valid_loss = float('inf')
writer = SummaryWriter()
for epoch in range(N_EPOCHS):
start_time = time.time()
train_loss = train(model, train_iterator, optimizer, criterion, CLIP)
valid_loss = evaluate(model, valid_iterator, criterion)
end_time = time.time()
epoch_mins, epoch_secs = epoch_time(start_time, end_time)
if valid_loss < best_valid_loss:
best_valid_loss = valid_loss
torch.save(model.state_dict(), 'tut4-model.pt')
print(f'Epoch: {epoch+1:02} | Time: {epoch_mins}m {epoch_secs}s')
print(f'\tTrain Loss: {train_loss:.3f} | Train PPL: {math.exp(train_loss):7.3f}')
print(f'\t Val. Loss: {valid_loss:.3f} | Val. PPL: {math.exp(valid_loss):7.3f}')
writer.add_scalar("Train Loss", train_loss, epoch+1)
writer.add_scalar("Train PPL", math.exp(train_loss), epoch+1)
writer.add_scalar("Val. Loss", valid_loss, epoch+1)
writer.add_scalar("Val. PPL", math.exp(valid_loss), epoch+1)
writer.close()
```
Наконец, мы загружаем параметры из нашей лучшей модели и проводим проверку на тестовом наборе.
Мы получаем модель с лучшими результатами, но при этом почти вдвое быстрее!
```
model.load_state_dict(torch.load('tut4-model.pt'))
test_loss = evaluate(model, test_iterator, criterion)
print(f'| Test Loss: {test_loss:.3f} | Test PPL: {math.exp(test_loss):7.3f} |')
```
### Вывод
Теперь мы можем использовать нашу обученную модель для создания переводов.
**Примечание:** эти переводы будут хуже, чем показанные в статье, поскольку авторы в статье использовали скрытые размеры 1000 и тренировали модеь в течение 4 дней! Они были подобраны для того, чтобы продемонстрировать, как должно выглядеть внимание на модели достаточно большого размера.
Наш `translate_sentence` будет делать следующее:
* убедится, что наша модель находится в режиме оценки, который всегда должен быть включён для вывода
* токенизируем исходное предложение, если оно не было токенизировано (является строкой)
* "оцифрует" исходное предложение
* преобразует его в тензор и добавить размер батча
* получит длину исходного предложения и преобразует его в тензор
* передаст исходное предложение в кодировщик
* создаст маску для исходного предложения
* создаст список для хранения выходного предложения, инициализированного токеном
* создаст тензор для удержания значений внимания
* пока мы не достигли максимальной длины
+ получит входной тензор, который должен быть либо , либо последним предсказанным токеном
+ передаст входной тензор, все выходы кодировщика, скрытое состояние и маску в декодер
+ сохранит значения внимания
+ получит предсказанный следующий токен
+ добавит предсказание к предсказанию текущего выходного предложения
+ прервёт выполнение, если предсказание было токеном
* преобразует выходное предложение из индексов в токены
* вернёт выходное предложение (с удаленным токеном ) и значения внимания для последовательности
```
def translate_sentence(sentence, src_field, trg_field, model, device, max_len = 50):
model.eval()
if isinstance(sentence, str):
nlp = spacy.load('de')
tokens = [token.text.lower() for token in nlp(sentence)]
else:
tokens = [token.lower() for token in sentence]
tokens = [src_field.init_token] + tokens + [src_field.eos_token]
src_indexes = [src_field.vocab.stoi[token] for token in tokens]
src_tensor = torch.LongTensor(src_indexes).unsqueeze(1).to(device)
src_len = torch.LongTensor([len(src_indexes)])
with torch.no_grad():
encoder_outputs, hidden = model.encoder(src_tensor, src_len)
mask = model.create_mask(src_tensor)
trg_indexes = [trg_field.vocab.stoi[trg_field.init_token]]
attentions = torch.zeros(max_len, 1, len(src_indexes)).to(device)
for i in range(max_len):
trg_tensor = torch.LongTensor([trg_indexes[-1]]).to(device)
with torch.no_grad():
output, hidden, attention = model.decoder(trg_tensor, hidden, encoder_outputs, mask)
attentions[i] = attention
pred_token = output.argmax(1).item()
trg_indexes.append(pred_token)
if pred_token == trg_field.vocab.stoi[trg_field.eos_token]:
break
trg_tokens = [trg_field.vocab.itos[i] for i in trg_indexes]
return trg_tokens[1:], attentions[:len(trg_tokens)-1]
```
Затем мы создадим функцию, которая отображает внимание модели к исходному предложению для каждого сгенерированного целевого токена.
```
def display_attention(sentence, translation, attention):
fig = plt.figure(figsize=(10,10))
ax = fig.add_subplot(111)
attention = attention.squeeze(1).cpu().detach().numpy()
cax = ax.matshow(attention, cmap='bone')
ax.tick_params(labelsize=15)
x_ticks = [''] + [''] + [t.lower() for t in sentence] + ['']
y\_ticks = [''] + translation
ax.set\_xticklabels(x\_ticks, rotation=45)
ax.set\_yticklabels(y\_ticks)
ax.xaxis.set\_major\_locator(ticker.MultipleLocator(1))
ax.yaxis.set\_major\_locator(ticker.MultipleLocator(1))
plt.show()
plt.close()
```
Теперь мы возьмем несколько переводов из нашего набора данных и посмотрим, насколько хорошо работает наша модель. Обратите внимание: здесь мы собираемся выбрать некоторые рафинированные примеры, чтобы было что-то интересное, но не стесняйтесь изменять значение `example_idx`, чтобы посмотреть на другие примеры.
Сначала мы получим исходное и целевое предложения из нашего набора данных.
```
example_idx = 12
src = vars(train_data.examples[example_idx])['src']
trg = vars(train_data.examples[example_idx])['trg']
print(f'src = {src}')
print(f'trg = {trg}')
```
Затем мы воспользуемся функцией `translate_sentence`, чтобы получить предсказанный перевод и внимание. Мы показываем это графически, располагая исходное предложение на оси x и прогнозируемый перевод на оси y. Чем светлее квадрат на пересечении двух слов, тем больше внимания модель уделяла этому исходному слову при переводе этого целевого слова.
Ниже приведен пример, который модель пыталась перевести, она получает правильный перевод, за исключением некоторых слов.
```
translation, attention = translate_sentence(src, SRC, TRG, model, device)
print(f'predicted trg = {translation}')
display_attention(src, translation, attention)
```
Переводы из обучающей выборки модель могла просто запомнить. Так что справедливо, что мы также смотрим на переводы из набора для проверки и тестирования.
```
example_idx = 14
src = vars(valid_data.examples[example_idx])['src']
trg = vars(valid_data.examples[example_idx])['trg']
print(f'src = {src}')
print(f'trg = {trg}')
```
### BLEU
Раньше мы заботились только о потерях/достоверности модели. Однако есть показатели, специально разработанные для измерения качества перевода. Наиболее популярным из них является *BLEU*. Не вдаваясь в подробности, BLEU рассматривает совпадение предсказанных и фактических целевых последовательностей с точки зрения их n-грамм. Он даст нам число от 0 до 1 для каждой последовательности, где 1 означает полное совпадение, то есть идеальный перевод (хотя обычно отображают в процентах от 0 до 100). BLEU был разработан для работы с несколькими кандидатами переводов для каждой исходной последовательности, однако в нашем наборе данных у есть только один кандидат.
Мы определяем функцию `calculate_bleu`, которая вычисляет оценку BLEU по предоставленному набору данных TorchText. Эта функция создает корпус фактического и прогнозируемого перевода для каждого исходного предложения, а затем вычисляет оценку BLEU.
```
from torchtext.data.metrics import bleu_score
def calculate_bleu(data, src_field, trg_field, model, device, max_len = 50):
trgs = []
pred_trgs = []
for datum in data:
src = vars(datum)['src']
trg = vars(datum)['trg']
pred_trg, _ = translate_sentence(src, src_field, trg_field, model, device, max_len)
#cut off token
pred\_trg = pred\_trg[:-1]
pred\_trgs.append(pred\_trg)
trgs.append([trg])
return bleu\_score(pred\_trgs, trgs)
```
Мы получаем BLEU около 28. Если мы сравним этот результат со статьёй, из которой пытаемся воспроизвести модель с внимания, то там авторы достигают 26,75 балла по шкале BLEU. Это похоже на нашу оценку, однако они используют совершенно другой набор данных, а размер их модели намного больше - 1000 скрытых состояний, обучение которых занимает 4 дня! - так что мы не можем сравнивать результаты с ними.
Это число на самом деле не поддается интерпретации, мы не можем сказать о нем много. Самая полезная часть оценки BLEU заключается в том, что её можно использовать для сравнения разных моделей в одном наборе данных, где модель с более высокой оценкой BLEU «лучше».
```
bleu_score = calculate_bleu(test_data, SRC, TRG, model, device)
print(f'BLEU score = {bleu_score*100:.2f}')
```
### Обучение сети инвертированию предложения
В конце приведу один из моих любимых тестов: тест на инверсию предложения. Очень простая для человека задача (ученики начальной школы обучаются за 10-15 примеров), но, порой, непреодолима для искусственных систем.
Для Google Colab скачаем обучающие последовательности
```
!wget https://raw.githubusercontent.com/vasiliyeskin/bentrevett-pytorch-seq2seq_ru/master/toy_revert/train.csv -P toy_revert
!wget https://raw.githubusercontent.com/vasiliyeskin/bentrevett-pytorch-seq2seq_ru/master/toy_revert/val.csv -P toy_revert
!wget https://raw.githubusercontent.com/vasiliyeskin/bentrevett-pytorch-seq2seq_ru/master/toy_revert/test.csv -P toy_revert
```
В начале обучим сеть инверсии и посмотрим на результат.
```
SRC = Field(tokenize="spacy",
init_token='',
eos\_token='',
lower=True,
include\_lengths = True)
TRG = Field(tokenize="spacy",
init\_token='',
eos\_token='',
lower=True)
data\_fields = [('src', SRC), ('trg', TRG)]
# load the dataset in csv format
train\_data, valid\_data, test\_data = TabularDataset.splits(
path='toy\_revert',
train='train.csv',
validation='val.csv',
test='test.csv',
format='csv',
fields=data\_fields,
skip\_header=True
)
SRC.build\_vocab(train\_data)
TRG.build\_vocab(train\_data)
```
```
BATCH_SIZE = 128
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
train_iterator, valid_iterator, test_iterator = BucketIterator.splits(
(train_data, valid_data, test_data),
batch_size = BATCH_SIZE,
sort_within_batch = True,
sort_key = lambda x : len(x.src),
device = device)
################## create DNN Seq2Seq ###############################
INPUT_DIM = len(SRC.vocab)
OUTPUT_DIM = len(TRG.vocab)
ENC_EMB_DIM = 256
DEC_EMB_DIM = 256
ENC_HID_DIM = 512
DEC_HID_DIM = 512
ENC_DROPOUT = 0.5
DEC_DROPOUT = 0.5
SRC_PAD_IDX = SRC.vocab.stoi[SRC.pad_token]
TRG_PAD_IDX = TRG.vocab.stoi[TRG.pad_token]
attn = Attention(ENC_HID_DIM, DEC_HID_DIM)
enc = Encoder(INPUT_DIM, ENC_EMB_DIM, ENC_HID_DIM, DEC_HID_DIM, ENC_DROPOUT)
dec = Decoder(OUTPUT_DIM, DEC_EMB_DIM, ENC_HID_DIM, DEC_HID_DIM, DEC_DROPOUT, attn)
model = Seq2Seq(enc, dec, SRC_PAD_IDX, device).to(device)
####################################################################
####### initial weights
model.apply(init_weights);
# print(model)
print(f'The model has {count_parameters(model):,} trainable parameters')
optimizer = optim.Adam(model.parameters())
criterion = nn.CrossEntropyLoss(ignore_index=TRG_PAD_IDX)
N_EPOCHS = 10
CLIP = 1
best_valid_loss = float('inf')
for epoch in range(N_EPOCHS):
start_time = time.time()
train_loss = train(model, train_iterator, optimizer, criterion, CLIP)
valid_loss = evaluate(model, valid_iterator, criterion)
end_time = time.time()
epoch_mins, epoch_secs = epoch_time(start_time, end_time)
if valid_loss < best_valid_loss:
best_valid_loss = valid_loss
torch.save(model.state_dict(), 'tut4-model.pt')
print(f'Epoch: {epoch + 1:02} | Time: {epoch_mins}m {epoch_secs}s')
print(f'\tTrain Loss: {train_loss:.3f} | Train PPL: {math.exp(train_loss):7.3f}')
print(f'\t Val. Loss: {valid_loss:.3f} | Val. PPL: {math.exp(valid_loss):7.3f}')
# writer.add_scalar("Train_loss_average_per_epoch", train_loss, epoch)
# writer.add_scalar("Validate_loss_average_per_epoch", valid_loss, epoch)
model.load_state_dict(torch.load('tut4-model.pt'))
test_loss = evaluate(model, test_iterator, criterion)
print(f'| Test Loss: {test_loss:.3f} | Test PPL: {math.exp(test_loss):7.3f} |')
```
```
from torchtext.data.metrics import bleu_score
def calculate_bleu(data, src_field, trg_field, model, device, max_len = 50):
trgs = []
pred_trgs = []
for datum in data:
src = vars(datum)['src']
trg = vars(datum)['trg']
pred_trg, _ = translate_sentence(src, src_field, trg_field, model, device, max_len)
#cut off token
pred\_trg = pred\_trg[:-1]
pred\_trgs.append(pred\_trg)
trgs.append([trg])
return bleu\_score(pred\_trgs, trgs)
```
```
example_idx = 10
src = vars(test_data.examples[example_idx])['src']
trg = vars(test_data.examples[example_idx])['trg']
print(f'src = {src}')
print(f'trg = {trg}')
print(f'source = {src}')
translation, attention = translate_sentence(src, SRC, TRG, model, device)
display_attention(src, translation, attention)
print(f'predicted trg = {translation}')
src = ['a', 'b', 'c', 'a', 'd']
print(f'source = {src}')
translation, attention = translate_sentence(src, SRC, TRG, model, device)
display_attention(src, translation, attention)
print(f'predicted trg = {translation}')
src = 'd b c d'.split(' ')
print(f'source = {src}')
translation, attention = translate_sentence(src, SRC, TRG, model, device)
display_attention(src, translation, attention)
print(f'predicted trg = {translation}')
src = ['a', 'a', 'a', 'a', 'd']
print(f'source = {src}')
translation, attention = translate_sentence(src, SRC, TRG, model, device)
print(f'predicted trg = {translation}')
src = ['d', 'b', 'c', 'a']
print(f'source = {src}')
translation, attention = translate_sentence(src, SRC, TRG, model, device)
print(f'predicted trg = {translation}')
src = ['d', 'd', 'd', 'd', 'd', 'd', 'd', 'd']
print(f'source = {src}')
translation, attention = translate_sentence(src, SRC, TRG, model, device)
print(f'predicted trg = {translation}')
bleu_score = calculate_bleu(test_data, SRC, TRG, model, device)
print(f'BLEU score = {bleu_score * 100:.2f}')
```
В следующих разделах мы отойдем от использования рекуррентных нейронных сетей и начнем искать другие способы построения моделей sequence-to-sequence. В частности, [в следующей части](https://habr.com/ru/post/568176/) мы будем использовать свёрточные нейронные сети. | https://habr.com/ru/post/567998/ | null | ru | null |
# 3.2 Обработка событий
*От переводчика: данная статья является десятой в цикле переводов официального руководства по библиотеке SFML. Прошлую статью можно найти [тут.](https://habrahabr.ru/post/279957/ "Предыдущая статья: Открытие и управление окнами") Данный цикл статей ставит своей целью предоставить людям, не знающим язык оригинала, возможность ознакомится с этой библиотекой. SFML — это простая и кроссплатформенная мультимедиа библиотека. SFML обеспечивает простой интерфейс для разработки игр и прочих мультимедийных приложений. Оригинальную статью можно найти [тут](http://www.sfml-dev.org/tutorials/2.3/window-events.php "Оригинальная статья: Events explained"). Начнем.*
**Оглавление:**0.1 Вступление
1. Приступая к работе
1. [SFML и Visual Studio](https://habrahabr.ru/post/278977/ "Перейти к статье: SFML и Visual Studio")
2. [SFML и Code::Blocks (MinGW)](https://habrahabr.ru/post/279069/ "Перейти к статье: SFML и Code::Blocks (MinGW)")
3. [SFML и Linux](https://habrahabr.ru/post/279107/ "Перейти к статье: SFML и Linux")
4. [SFML и Xcode (Mac OS X)](https://habrahabr.ru/post/279147/ "Перейти к статье: SFML и Xcode (Mac OS X)")
5. [Компиляция SFML с помощью CMake](https://habrahabr.ru/post/279279/ "Перейти к статье: Компиляция SFML с помощью CMake")
2. Модуль System
1. [Обработка времени](https://habrahabr.ru/post/279347/ "Перейти к статье: Обработка времени")
2. [Потоки](https://habrahabr.ru/post/279653/ "Перейти к статье: Потоки")
3. [Работа с пользовательскими потоками данных](https://habrahabr.ru/post/279689/ "Перейти к статье: Работа с пользовательскими потоками данных")
3. Модуль Window
1. [Открытие и управление окнами](https://habrahabr.ru/post/279957/ "Перейти к статье: Открытие и управление окнами")
2. [Обработка событий](https://habrahabr.ru/post/280153/ "Перейти к статье: Обработка событий")
3. Работа с клавиатурой, мышью и джойстиками
4. Использование OpenGL
4. Модуль Graphics
1. Рисование 2D объектов
2. Спрайты и текстуры
3. Текст и шрифты
4. Формы
5. Проектирование ваших собственных объектов с помощью массивов вершин
6. Позиция, вращение, масштаб: преобразование объектов
7. Добавление специальных эффектов с шейдерами
8. Контроль 2D камеры и вида
5. Модуль Audio
1. Проигрывание звуков и музыки
2. Запись аудио
3. Пользовательские потоки аудио
4. Спатиализация: звуки в 3D
6. Модуль Network
1. Коммуникация с использованием сокетов
2. Использование и расширение пакетов
3. Веб-запросы с помощью HTTP
4. Передача файлов с помощью FTP
Вступление
----------
В этой статье приводится подробный список событий и объясняется, как эти события обрабатывать.
Тип sf::Event
-------------
До детального разбора обработки событий важно понять, что из себя представляет тип [sf::Event](http://www.sfml-dev.org/documentation/2.3/classsf_1_1Event.php "Документация по sf::Event"), и как правильно использовать его. [sf::Event](http://www.sfml-dev.org/documentation/2.3/classsf_1_1Event.php "Документация по sf::Event") состоит из объединения, хранящего в себе тип события, и вспомагательных функций и членов. Доступному члену объединения соответсвует один или несколько членов класса, например, `event.key` соответствует событию `KeyPressed`. Попытка обработки любых других членов приведет к неопределенному поведению. Никогда не пытайтесь обработать не произошедшее событие.
Экземпляр [sf::Event](http://www.sfml-dev.org/documentation/2.3/classsf_1_1Event.php "Документация по sf::Event") можно инициализировать функцией `pollEvent` (или `waitEvent`) класса [sf::Window](http://www.sfml-dev.org/documentation/2.3/classsf_1_1Window.php "Документация по sf::Window"). Только эти две функции могут инициализировать экземпляр [sf::Event](http://www.sfml-dev.org/documentation/2.3/classsf_1_1Event.php "Документация по sf::Event").
Для ясности, вот как выглядит типичный цикл обработки событий:
```
sf::Event event;
// пока есть события, обрабатывать их...
while (window.pollEvent(event))
{
// проверяем тип события...
switch (event.type)
{
// закрытие окна
case sf::Event::Closed:
window.close();
break;
// нажатие клавиши
case sf::Event::KeyPressed:
...
break;
// мы не обрабатываем другие типы событий
default:
break;
}
}
```
Перечитайте параграф выше и убедитесь, что вы все поняли. Класс [sf::Event](http://www.sfml-dev.org/documentation/2.3/classsf_1_1Event.php "Документация по sf::Event") вызывает много проблем у начинающих программистов.
Ладно, теперь мы знаем, как события представлены в SFML, настало время выяснить, что каждое событие означает.
Событие Closed
--------------
Событие `sf::Event::Closed` срабатывает, когда пользователь хочет закрыть окно, используя любой из методов, предоставляемых менеджером окон (кнопка закрытия, макросы клавиатуры и так далее). Это событие предоставляет информацию о том, что пользователь попытался закрыть окно; оно еще не закрыто.
Обычно, в ответ на это событие, код вызывает `window.close()`, чтобы закрыть окно. Однако, вы можете сделать еще что-то, например, сохранить текущее состояние приложения или спросить пользователя, что надо сделать. Если вы ничего не сделаете в ответ на это событие, окно будет оставаться открытым.
Член класса, ассоциируемый с этим событием, не существует.
```
if (event.type == sf::Event::Closed)
window.close();
```
Событие Resized
---------------
Событие `sf::Event::Resized` срабатывает, когда происходит изменение размера окна. Либо в результате действия пользователя, либо программно, после вызова `window.setSize`.
Вы можете использовать это событие, чтобы отрегулировать настройки отображения: область просмотра, если вы используете OpenGL напрямую, или текущую точку обзора, если вы используете `sfml-graphics`.
Член класса, ассоциируемый с этим событием, называется event.size и содержит новый размер окна.
```
if (event.type == sf::Event::Resized)
{
std::cout << "new width: " << event.size.width << std::endl;
std::cout << "new height: " << event.size.height << std::endl;
}
```
События LostFocus и GainedFocus
-------------------------------
События `sf::Event::LostFocus` и `sf::Event::GainedFocus` срабатывают, когда окно потеряло/приобрело фокус; это происходит, когда пользователь меняет текущее активное окно. Когда окно теряет фокус, оно не получает события клавиатуры.
Это событие можно использовать, например, для приостановки игры, когда окно неактивно.
Член класса, ассоциируемый с этим событием, не существует.
```
if (event.type == sf::Event::LostFocus)
myGame.pause();
if (event.type == sf::Event::GainedFocus)
myGame.resume();
```
События TextEntered
-------------------
Событие `sf::Event::TextEntered` срабатывает, когда происходит ввод символа. Это не событие `KeyPressed`: `TextEntered` срабатывает, когда пользователь вводит символ, который может быть выведен. Например, нажатие '^' и 'e' на французской клавиатуре приведет к двум событиям `KeyPressed` и только к одному `TextEntered`, содержащему символ 'ê'. Это работает для всех методов ввода, предоставленным операционной системой.
Это событие обычно используется для отлова пользовательского ввода в текстовое поле.
Член класса, ассоциируемый с этим событием, называется `event.text` и содержит номер символа Unicode введенного символа. Вы можете поместить это значение в [sf::String](http://www.sfml-dev.org/documentation/2.3/classsf_1_1String.php "Документация по sf::String"), или привести его к типу `char` после того, как убедитесь, что этот символ лежит в диапазоне ASCII символов (0 — 127).
```
if (event.type == sf::Event::TextEntered)
{
if (event.text.unicode < 128)
std::cout << "ASCII character typed: " << static_cast(event.text.unicode) << std::endl;
}
```
Многие программисты используют событие `KeyPressed` для обработки пользовательского ввода и применяют сумасшедшие алгоритмы для обработки пользовательского ввода, которые пытаются интерпретировать все возможные комбинации клавиш. Не делайте этого!
События KeyPressed и KeyReleased
--------------------------------
События `sf::Event::KeyPressed` и `sf::Event::KeyReleased` срабативают, когда клавиша на клавиатуре нажата/отжата.
Если клавиша зажата, события `KeyPressed` будут генерироваться с определенным интервалов, заданным операционной системой (т.е. та же задержка, что применяется, когда вы вводите текст в редакторе). Чтобы отменить повторение событий `KeyPressed`, вы можете вызвать `window.setKeyRepeatEnabled(false)`. Очевидно, что событие `KeyReleased` никогда не повторяется.
Эти события можно использовать, если вы хотите вызвать какое-нибудь действие ровно один раз, когда клавиша нажата или отжата, например, чтобы заставить персонажа прыгнуть.
Иногда люди пытаются использовать событие `KeyPressed` для реализации плавного движения. Это не приводит к ожидаемому эффекту, потому что это событие генерируется с определенным интервалом. Чтобы реализовать плавное движение с помощью событий, вы должны использовать логическое значение, устанавливаемое `KeyPressed` и обнуляемое `KeyReleased`; движение должно осуществляться, пока это логическое значение установлено.
Другие (более простые) пути реализации плавного движение, с использованием вода с клавиатуры с помощью [sf::Keyboard](http://www.sfml-dev.org/documentation/2.3/classsf_1_1Keyboard.php "Документация по sf::Keyboard") (смотрите [посвященную этому статью](http://www.sfml-dev.org/tutorials/2.3/window-inputs.php "Статья о вводе в реальном времени")).
Член класса, ассоциируемый с этим событием, называется `event.key` и содержит код нажатого/отжатого символа, а также текущее состояние клавиш-модификаторов (alt, control, shift, system).
```
if (event.type == sf::Event::KeyPressed)
{
if (event.key.code == sf::Keyboard::Escape)
{
std::cout << "the escape key was pressed" << std::endl;
std::cout << "control:" << event.key.control << std::endl;
std::cout << "alt:" << event.key.alt << std::endl;
std::cout << "shift:" << event.key.shift << std::endl;
std::cout << "system:" << event.key.system << std::endl;
}
}
```
Помните, что некторые клавиши имеют специфичное значение для операционной системы, обработка этих клавиш приводит к неопределенному поведению. Например, клавиша F10 в Windows, которая меняет фокус, или клавиша F12, которая запуска дебагер при использовании Visual Studio. Эта проблема будет решена в будущих версиях SFML.
Событие MouseWheelMoved
-----------------------
Событие `sf::Event::MouseWheelMoved` устарело и было упразнено в SFML 2.3. Используйте `MouseWheelScrolled`.
Событие MouseWheelScrolled
--------------------------
Событие `sf::Event::MouseWheelScrolled` вызыватеся, когда колесо мыши двигается вверх, вниз или вбок (если это поддерживается мышью).
Член класса, ассоциируемый с этим событием, называется `event.mouseWheelScroll` и содержит число тиков, на которое сместилось колесо, ориентацию движения колеса и текущую позицию курсора мыши.
```
if (event.type == sf::Event::MouseWheelScrolled)
{
if (event.mouseWheelScroll.wheel == sf::Mouse::VerticalWheel)
std::cout << "wheel type: vertical" << std::endl;
else if (event.mouseWheelScroll.wheel == sf::Mouse::HorizontalWheel)
std::cout << "wheel type: horizontal" << std::endl;
else
std::cout << "wheel type: unknown" << std::endl;
std::cout << "wheel movement: " << event.mouseWheelScroll.delta << std::endl;
std::cout << "mouse x: " << event.mouseWheelScroll.x << std::endl;
std::cout << "mouse y: " << event.mouseWheelScroll.y << std::endl;
}
```
События MouseButtonPressed и MouseButtonReleased
------------------------------------------------
События `sf::Event::MouseButtonPressed` и `sf::Event::MouseButtonReleased` срабатывают, когда кнопка мыши нажата/отпущена.
SFML поддерживает 5 кнопок мыши: левую, правую, среднюю (колесо мыши), экстра #1 и экстра #2 (кнопки на боковой стороне).
Член класса, ассоциируемый с этим событием, называется `event.mouseButton` и содержит код нажатой/отжатой кнопки, а также позицию курсора мыши.
```
if (event.type == sf::Event::MouseButtonPressed)
{
if (event.mouseButton.button == sf::Mouse::Right)
{
std::cout << "the right button was pressed" << std::endl;
std::cout << "mouse x: " << event.mouseButton.x << std::endl;
std::cout << "mouse y: " << event.mouseButton.y << std::endl;
}
}
```
Событие MouseMoved
------------------
Событие `sf::Event::MouseMoved` срабатывает, когда курсор мыши движется внутри окна.
Это событие срабатывает, даже если окно не в фокусе. Однако, срабатывание происходит только когда курсор мыши движется только в пределах внутренней области окна (во внутреннюю облась окна не входят заголов и границы),
Член класса, ассоциируемый с этим событием, называется `event.mouseMove` и содержит позицию курсора мыши относительно окна.
```
if (event.type == sf::Event::MouseMoved)
{
std::cout << "new mouse x: " << event.mouseMove.x << std::endl;
std::cout << "new mouse y: " << event.mouseMove.y << std::endl;
}
```
События MouseEntered и MouseLeft
--------------------------------
События `sf::Event::MouseEntered` и `sf::Event::MouseLeft` срабатывают, когда курсор мыши входит в облась окна или покидает ее.
Член класса, ассоциируемый с этим событием, не существует.
```
if (event.type == sf::Event::MouseEntered)
std::cout << "the mouse cursor has entered the window" << std::endl;
if (event.type == sf::Event::MouseLeft)
std::cout << "the mouse cursor has left the window" << std::endl;
```
События JoystickButtonPressed и JoystickButtonReleased
------------------------------------------------------
События `sf::Event::JoystickButtonPressed` и `sf::Event::JoystickButtonReleased` срабатывают, когда кнопка геймпада нажата/отжата.
SFML поддерживает 8 джойстиков и 32 кнопки.
Член класса, ассоциируемый с этим событием, называется `event.joystickButton` и содержит идентификатор джойстика и индекс нажатой/отжатой кнопки.
```
if (event.type == sf::Event::JoystickButtonPressed)
{
std::cout << "joystick button pressed!" << std::endl;
std::cout << "joystick id: " << event.joystickButton.joystickId << std::endl;
std::cout << "button: " << event.joystickButton.button << std::endl;
}
```
Событие JoystickMoved
---------------------
Событие `sf::Event::JoystickMoved` срабатывает, когда стик геймпада движется.
Стики джойстика, как правило, очень чувствительны, именно поэтому SFML использует порог обнаружения, чтобы избежать постоянных срабатываний `JoystickMoved`. Это пороговое значение можно изменить с помощью вызова функции `Window::setJoystickThreshold`.
SFML поддерживает 8 стиков джойстика: X, Y, Z, R, U, V, POV X и POV Y. Как происходит взаимодействие с геймпадом зависит от драйвера этого геймпада.
Член класса, ассоциируемый с этим событием, называется `event.joystickMove` и содержит идентификатор джойстика, имя стика и его текущую позицию (в интервале [-100, 100]).
```
if (event.type == sf::Event::JoystickMoved)
{
if (event.joystickMove.axis == sf::Joystick::X)
{
std::cout << "X axis moved!" << std::endl;
std::cout << "joystick id: " << event.joystickMove.joystickId << std::endl;
std::cout << "new position: " << event.joystickMove.position << std::endl;
}
}
```
События JoystickConnected и JoystickDisconnected
------------------------------------------------
События `sf::Event::JoystickConnected` и `sf::Event::JoystickDisconnected` срабатывают, когда джойстик присоединяется/отсоединяется.
Член класс, ассоциируемый с этим событием, называется `event.joystickConnect` и содержит идентификатор присоединенного/отсоединенного джойстика.
```
if (event.type == sf::Event::JoystickConnected)
std::cout << "joystick connected: " << event.joystickConnect.joystickId << std::endl;
if (event.type == sf::Event::JoystickDisconnected)
std::cout << "joystick disconnected: " << event.joystickConnect.joystickId << std::endl;
```
Следующая статья: Работа с клавиатурой, мышью и джойстиками. | https://habr.com/ru/post/280153/ | null | ru | null |
# Arduino, модуль Nokia 5110 LCD и любая картинка
Наверное, у меня, как и у всех Arduino-строителей, появилась какая-то бредовая идея в голове. Заказал в Китае все необходимые детали. Ждать пришлось очень долго, но тут раньше срока был доставлен [клон платы Arduino Uno](http://http://www.betemcu.cn/) и [LCD-дисплей Nokia 5110](http://arduino-ua.com/prod407-Nokia5110_LCD_modyl). Так как до этого с электроникой и программированием я был не знаком, решил не терять время зря и начал учиться выводить информацию на данный модуль.
Первым делом я загуглил и попал на публикацию [«Arduino, модуль Nokia 5110 LCD и кириллица»](http://habrahabr.ru/post/242957) от автора [Shrim](http://geektimes.ru/users/shrim/). И тут я понял, что всё, что раньше задумал, будет не так уже и просто сделать.
С кириллицей я разобрался, там все просто, не буду копипастить прошлый пост, а вот с картинками действительно проблема. Стоит задача: нужно нарисовать картинку и залить ее на дисплей. Столкнулся с первой проблемой, зашел в среду программирования Arduino я увидел, что там нет такой штуки как «Вставить — Изображения», а нужно картинку записать определенным кодом в [hex системе исчисления](https://ru.wikipedia.org/wiki/%D0%A8%D0%B5%D1%81%D1%82%D0%BD%D0%B0%D0%B4%D1%86%D0%B0%D1%82%D0%B5%D1%80%D0%B8%D1%87%D0%BD%D0%B0%D1%8F_%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D1%81%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F). Нашел несколько редакторов, но не тут то было. Картинка адекватно не отображается. Я начал искать проблемы что может быть.
Методом кучей экспериментов, попыток и проб получился алгоритм которым я с вами поделюсь:
1) Нужно получить саму картинку, в черно-белом формате .bmp с расширением 84 х 48 пикселей.
Сделать это можно кучей способами почти у каждом графическом редакторе есть функция «Cохранить как» где указываем необходимые параметры.
Я делал в [corelDRAW](http://uk.wikipedia.org/wiki/CorelDraw). Получаем что-то похожее. Нужно уточнить, что имя картинки обязательно должно сохранено латинской раскладкой клавиатуры, так как следующая программа ее не сможет открыть.
2) Если необходимо, можно отредактировать картинку в paint, как ни странно, там есть несколько простых и интересных инструментов.
3) При помощи [GLCD Tools](http://sourceforge.net/projects/glcdtools/) получаем hex-код картинки.
4) Вставляем данный код в программный код Arduino и заливаем на плату:
```
// SCK - Pin 8
// MOSI - Pin 9
// DC - Pin 10
// RST - Pin 11
// CS - Pin 12
//
#include
LCD5110 myGLCD(8,9,10,11,12);
extern uint8\_t OKO[];
float y;
uint8\_t\* bm;
int pacy;
void setup()
{
myGLCD.InitLCD();
}
void loop()
{
myGLCD.clrScr();
myGLCD.drawBitmap(0, 0, OKO, 84, 48);
myGLCD.update();
delay(2000);
}
```
```
#include
const uint8\_t OKO[] PROGMEM={
//Скопированный hex-код GLCD tools
};
```
 | https://habr.com/ru/post/247639/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.