text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Создание модели распознавания лиц с использованием глубокого обучения на языке Python
*Переводчик Елена Борноволокова специально для [Нетологии](https://netology.ru/?utm_source=blog&utm_medium=747&utm_campaign=habr&stop=1) адаптировала [статью](https://www.analyticsvidhya.com/blog/2018/12/introduction-face-detection-video-deep-learning-python/) Файзана Шайха о том, как создать модель распознавания лиц и в каких сферах ее можно применять.*
Введение
--------
За последние годы компьютерное зрение набрало популярность и выделилось в отдельное направление. Разработчики создают новые приложения, которыми пользуются по всему миру.
В этом направлении меня привлекает концепция открытого исходного кода. Даже технологические гиганты готовы делиться новыми открытиями и инновациями со всеми, чтобы технологии не оставались привилегией богатых.
Одна из таких технологий — распознавание лиц. При правильном и этичном использовании эта технология может применяться во многих сферах жизни.
В этой статье я покажу вам, как создать эффективный алгоритм распознавания лиц, используя инструменты с открытым исходным кодом. Прежде чем перейти к этой информации, хочу, чтобы вы подготовились и испытали вдохновение, посмотрев это видео:
Распознавание лиц: потенциальные сферы применения
-------------------------------------------------
Приведу несколько потенциальных сфер применения технологии распознавания лиц.
**Распознавание лиц в соцсетях**. Facebook заменил присвоение тегов изображениям вручную на автоматически генерируемые предложения тегов для каждого изображения, загружаемого на платформу. Facebook использует простой алгоритм распознавания лиц для анализа пикселей на изображении и сравнения его с соответствующими пользователями.
**Распознавание лиц в сфере безопасности**. Простой пример использования технологии распознавания лиц для защиты личных данных — разблокировка смартфона «по лицу». Такую технологию можно внедрить и в пропускную систему: человек смотрит в камеру, а она определяет разрешить ему войти или нет.
**Распознавание лиц для подсчета количества людей**. Технологию распознавания лиц можно использовать при подсчете количества людей, посещающих какое-либо мероприятие (например, конференцию или концерт). Вместо того чтобы вручную подсчитывать участников, мы устанавливаем камеру, которая может захватывать изображения лиц участников и выдавать общее количество посетителей. Это поможет автоматизировать процесс и сэкономить время.
Настройка системы: требования к аппаратному и программному обеспечению
----------------------------------------------------------------------
Рассмотрим, как мы можем использовать технологию распознавания лиц, обратившись к доступным нам инструментам с открытым исходным кодом.
Я использовал следующие инструменты, которые рекомендую вам:
* Веб-камера (Logitech C920) для построения модели распознавания лиц в реальном времени на ноутбуке Lenovo E470 ThinkPad (Core i5 7th Gen). Вы также можете использовать встроенную камеру своего ноутбука или видеокамеру с любой подходящей системой для анализа видео в режиме реального времени вместо тех, которые использовал я.
* Предпочтительно использовать графический процессор для более быстрой обработки видео.
* Мы использовали операционную систему Ubuntu 18.04 со всем необходимым ПО.
Прежде чем приступить к построению нашей модели распознавания лиц, разберем эти пункты более подробно.
### Шаг 1: Настройка аппаратного обеспечения
Проверьте, правильно ли настроена камера. С Ubuntu это сделать просто: посмотрите, опознано ли устройство операционной системой. Для этого выполните следующие шаги:
1. Прежде чем подключить веб-камеру к ноутбуку, проверьте все подключенные видео устройства, напечатав в командной строке `ls /dev/video*`. В результате выйдет список всех видео устройств, подключенных к системе.
2. Подключите веб-камеру и задайте команду снова. Если веб-камера подключена правильно, новое устройство будет отражено в результате выполнения команды.
3. Также вы можете использовать ПО веб-камеры для проверки ее корректной работы. В Ubuntu для этого можно использовать программу «Сheese».
### Шаг 2: Настройка программного обеспечения
**Шаг 2.1: Установка Python**
Код, указанный в данной статье, написан с использованием Python (версия 3.5). Для установки Python рекомендую использовать [Anaconda](https://www.anaconda.com/download) – популярный дистрибутив Python для обработки и анализа данных.
**Шаг 2.2: Установка OpenCV**
[OpenCV](https://opencv.org/) – библиотека с открытым кодом, которая предназначена для создания приложений компьютерного зрения. Установка OpenCV производится с помощью `pip`:
```
pip3 install opencv-python
```
**Шаг 2.3: Установите face\_recognition API**
Мы будем использовать `face_recognition API`, который считается самым простым API для распознавания лиц на Python во всем мире. Для установки используйте:
```
pip install dlib
pip install face_recognition
```
Внедрение
---------
После настройки системы переходим к внедрению. Для начала, мы создадим программу, а затем объясним, что сделали.
### Пошаговое руководство
Создайте файл `face_detector.py` и затем скопируйте приведенный ниже код:
```
# import libraries
import cv2
import face_recognition
# Get a reference to webcam
video_capture = cv2.VideoCapture("/dev/video1")
# Initialize variables
face_locations = []
while True:
# Grab a single frame of video
ret, frame = video_capture.read()
# Convert the image from BGR color (which OpenCV uses) to RGB color (which face_recognition uses)
rgb_frame = frame[:, :, ::-1]
# Find all the faces in the current frame of video
face_locations = face_recognition.face_locations(rgb_frame)
# Display the results
for top, right, bottom, left in face_locations:
# Draw a box around the face
cv2.rectangle(frame, (left, top), (right, bottom), (0, 0, 255), 2)
# Display the resulting image
cv2.imshow('Video', frame)
# Hit 'q' on the keyboard to quit!
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# Release handle to the webcam
video_capture.release()
cv2.destroyAllWindows()
```
Затем запустите этот файл Python, напечатав:
```
python face_detector.py
```
Если все работает правильно, откроется новое окно с запущенным режимом распознавания лиц в реальном времени.
Подведем итоги и объясним, что сделал наш код:
1. Сначала мы **указали аппаратное обеспечение**, на котором будет производиться анализ видео.
2. Далее сделали **захват видео** в реальном времени кадр за кадром.
3. Затем **обработали каждый кадр** и **извлекли местонахождение всех лиц** на изображении.
4. В итоге, **воспроизвели эти кадры в форме видео** вместе с указанием на то, где расположены лица.
### Пример применения технологии распознавания лиц
На этом все самое интересное не заканчивается. Мы сделаем еще одну классную вещь: создадим полноценный пример применения на основе кода, приведенного выше. Внесем небольшие изменения в код, и все будет готово.
Предположим, что вы хотите создать автоматизированную систему с использованием видеокамеры для отслеживания, где спикер находится в данный момент времени. В зависимости от его положения, система поворачивает камеру так, что спикер всегда остается в центре кадра.
Первый шаг — создайте систему, которая идентифицирует человека или людей на видео и фокусируется на местонахождении спикера.
Разберем, как это сделать. В качестве примера я выбрал видео на YouTube с выступлением спикеров конференции «DataHack Summit 2017».
Сначала импортируем необходимые библиотеки:
```
import cv2
import face_recognition
```
Затем считываем видео и устанавливаем длину:
```
input_movie = cv2.VideoCapture("sample_video.mp4")
length = int(input_movie.get(cv2.CAP_PROP_FRAME_COUNT))
```
После этого создаем файл вывода с необходимым разрешением и скоростью передачи кадров, аналогичной той, что была в файле ввода.
Загружаем изображение спикера в качестве образца для распознания его на видео:
```
image = face_recognition.load_image_file("sample_image.jpeg")
face_encoding = face_recognition.face_encodings(image)[0]
known_faces = [
face_encoding,
]
```
Закончив, запускаем цикл, который будет:
* Извлекать кадр из видео.
* Находить все лица и идентифицировать их.
* Создавать новое видео, которое будет сочетать в себе оригинал кадра с указанием местонахождения лица спикера с подписью.
Посмотрим на код, который будет это выполнять:
```
# Initialize variables
face_locations = []
face_encodings = []
face_names = []
frame_number = 0
while True:
# Grab a single frame of video
ret, frame = input_movie.read()
frame_number += 1
# Quit when the input video file ends
if not ret:
break
# Convert the image from BGR color (which OpenCV uses) to RGB color (which face_recognition uses)
rgb_frame = frame[:, :, ::-1]
# Find all the faces and face encodings in the current frame of video
face_locations = face_recognition.face_locations(rgb_frame, model="cnn")
face_encodings = face_recognition.face_encodings(rgb_frame, face_locations)
face_names = []
for face_encoding in face_encodings:
# See if the face is a match for the known face(s)
match = face_recognition.compare_faces(known_faces, face_encoding, tolerance=0.50)
name = None
if match[0]:
name = "Phani Srikant"
face_names.append(name)
# Label the results
for (top, right, bottom, left), name in zip(face_locations, face_names):
if not name:
continue
# Draw a box around the face
cv2.rectangle(frame, (left, top), (right, bottom), (0, 0, 255), 2)
# Draw a label with a name below the face
cv2.rectangle(frame, (left, bottom - 25), (right, bottom), (0, 0, 255), cv2.FILLED)
font = cv2.FONT_HERSHEY_DUPLEX
cv2.putText(frame, name, (left + 6, bottom - 6), font, 0.5, (255, 255, 255), 1)
# Write the resulting image to the output video file
print("Writing frame {} / {}".format(frame_number, length))
output_movie.write(frame)
# All done!
input_movie.release()
cv2.destroyAllWindows()
```
Код даст вам вот такой результат:
От редакции
-----------
Курсы «Нетологии» по теме:
* онлайн-профессия «[Python-разработчик](https://netology.ru/programs/python?utm_source=blog&utm_medium=747&utm_campaign=habr)»
* онлайн-профессия «[Data Scientist](https://netology.ru/programs/data-scientist?utm_source=blog&utm_medium=747&utm_campaign=habr)» | https://habr.com/ru/post/434354/ | null | ru | null |
# Ищем причины тормозов БД, используя sys schema в MySQL 5.7
Есть у нас веб-приложение. Относительно большое и старое — много-много кода, в котором много-много разных запросов к базе данных. При этом мы не гугл, но несколько тысяч запросов в секунду на сервер БД приходится.
Ну и безусловно растёт наше приложение во все стороны — добавляются новые фичи, наворачиваются и усложняются старые, растёт количество клиентов и соответственно количество данных в БД. И в один не очень прекрасный момент приходит понимание, что что-то наше приложение тормозит. А значит надо или найти, что именно нагружает БД, хотя могло бы не нагружать, ну или если ничего такого нет, то взять ещё серверов побольше, да помощнее.
Стандартный совет как найти, что нагружает MySQL — включить slow-query-log и посмотреть, какие запросы будут туда попадать. Но в MySQL 5.7 по умолчанию присутствует куда лучший инструмент — [sys schema](https://dev.mysql.com/doc/refman/5.7/en/sys-schema.html), которая агрегирует данные из performance schema и позволяет их получить простыми запросами, буквально вида «Ok, MySQL, покажи мне топ запросов по максимальному суммарному времени выполнения»
Для начала, какие проблемы есть с использованием slow-query-log:
* Когда MySQL тормозит, туда валятся сотнями запросы, которые в периоды нормальной нагрузки не медленные — например, мы наблюдаем там время от времени выборки по первичному ключу.
* Если, к примеру, поставить long\_query\_time=3 в него не попадёт запрос, который выполняется за 0.5 секунды, но вызовов которого очень много.
В MySQL 5.5 появилась, и в более новых версиях развивалась performance schema, но пользоваться ей не так просто, как хотелось бы.
На этом заканчиваем со введением и переходим к тому, как пользоваться sys schema, и примерам того, что можно увидеть.
Для начала, если у вас запросы сложнее чем “SELECT a FROM b WHERE c = ?”, стоит поправить ограничения на сохраняемую в performance schema длину текста запросов. По умолчанию она 1024 — вдруг вам этого достаточно, но мне оказалось мало.
Добавляем в my.cnf:
```
max_digest_length=10240
performance_schema_max_sql_text_length=10240
performance_schema_max_digest_length=10240
```
Переменные не динамические, поэтому после этого потребуется перезагрузка сервера. Это, конечно, минус.
Далее изменяем максимальную отображаемую длину текста запросов в ответах sys schema (по умолчанию она 64 — и тут я совсем не понимаю, кому этого будет достаточно)
```
use sys;
update sys_config set value=10240 WHERE variable='statement_truncate_len';
```
Ну а затем можно пользоваться.
Упоминаемый ранее топ запросов по максимальному суммарному времени выполнения:
```
mysql> select * from statement_analysis limit 10 \G
*************************** 1. row ***************************
query: SELECT `AccSettingValue` FROM `accsetting` WHERE `accsetting` . `AccSettingName` = ?
db: mydb
full_scan:
exec_count: 2065339
err_count: 0
warn_count: 0
total_latency: 1.75 m
max_latency: 16.52 ms
avg_latency: 50.72 us
lock_latency: 48.90 s
rows_sent: 0
rows_sent_avg: 0
rows_examined: 0
rows_examined_avg: 0
rows_affected: 0
rows_affected_avg: 0
tmp_tables: 0
tmp_disk_tables: 0
rows_sorted: 0
sort_merge_passes: 0
digest: 229c950384bddbaa0e537f54beaa1ac4
first_seen: 2018-03-19 20:20:43
last_seen: 2018-03-21 12:27:21
```
На примере этого запроса видим, что значения %\_latency возвращаются в человекопонятном виде, что удобно, чтобы читать результат, но неудобно, если захотеть по ним отсортировать. Для этого у всех таблиц в sys schema есть близнецы вида x$table\_name.
Выборка запросов, отсортированных по avg\_latency, создававших временные таблицы на диске, будет выглядеть как-то так:
```
mysql> select * from x$statement_analysis WHERE tmp_disk_tables > 0 ORDER BY avg_latency DESC limit 10 \G
```
Ещё пара примеров, что полезного можно увидеть используя sys schema.
Запросы, среднее время выполнения которых, входит в топ 5%:
```
mysql> select * from statements_with_runtimes_in_95th_percentile LIMIT 10\G
```
Запросы, создающие временные таблицы:
```
mysql> select * from statements_with_temp_tables limit 10\G
```
Запросы, делающие full table scan
```
mysql> select * from statements_with_full_table_scans limit 10\G
```
Неиспользуемые индексы (сервер должен работать достаточно продолжительное время, чтобы этим данным можно было верить):
```
mysql> select * from schema_unused_indexes limit 10;
```
Это то, что было наиболее полезным лично для меня, если заинтересовались — подробная документация и примеры использования есть [на github](https://github.com/mysql/mysql-sys/blob/master/README.md) или в [официальной документации](https://dev.mysql.com/doc/refman/5.7/en/sys-schema-views.html). | https://habr.com/ru/post/351740/ | null | ru | null |
# Кривые Безье. Немного о пересечениях и как можно проще
Вы сталкивались когда-нибудь с построением (непрерывного) пути обхода кривой на плоскости, заданной отрезками и кривыми Безье?
Вроде бы не сильно сложная задача: состыковать отрезки кривых в один путь и обойти его "не отрывая пера". Замкнутая кривая обходится в одном направлении, ответвления — в прямом и обратном, начало и конец в одном узле.
Всё было хорошо, пока из-под рук дизайнеров не стали вылезать монструозные пути, где отдельные кривые могли пересекаться или не точно состыковываться. Объяснение было предельно простым — визуально они все лежат как надо, а для станка, который этот путь будет обходить, такие отклонения незаметны.
Вооружившись знанием о величине максимально допустимого отклонения, я приступил к исследованию, результатами которого хочу поделиться.
Первое что я сделал — это разобрался как на сегодняшний день (октябрь 2020) обстоят дела с поиском точек пересечения кривых. То ли я не там искал, то ли не то спрашивал, но найти простого решения не получилось. Хотя, идея с [результантом пары полиномов](http://alex-black.ru/article.php?content=114) довольно занимательна. Много разных алгоритмов связанных с кривыми Безье собрано [здесь](https://pomax.github.io/bezierinfo/).
Что не понравилось в известных способах и что точно не хочется делать, так это численно искать корни полиномов, или даже решать квадратичные уравнения. Очень не хочется исследовать кривые на экстремумы. Да и вообще, хотелось бы избежать деления, возведения в степень и всего того, что может привести к неопределённому поведению.
**Пример**
Если пытаться продолжить кривую, то не факт что она вообще пересечётся с другой кривой, хотя они находятся достаточно близко
Итак, с чем придётся работать.
* Точки задаются типом `Point`, например так:
```
using Point = std::array;
```
Для `Point` определены операторы сложения, вычитания, умножения на скаляр, скалярного умножения.
* Задана величина `R` допустимого отклонения точек.
* Кривые заданы массивами опорных (контрольных) точек `std::vector`.
* Почти совпадающие кривые следует отмечать и, по возможности, удалять, например, если это забытый дубликат (копипаста — это зло).
Первое, что точно понадобиться, это простой способ вычисления значения параметрической кривой. (Простой в смысле реализации и читабельности):
```
Point point(const std::vector &curve, double t, int n, int i)
{
return n == 0 ? curve[i] : (point(curve, t, n - 1, i - 1) \* (1 - t) + point(curve, t, n - 1, i) \* t);
}
```
Оставлять функцию в таком виде для постоянного использования не стоит — лучше спрятать её подальше, а пользоваться такой:
```
Point point(const std::vector &curve, double t)
{
return point(curve, t, curve.size() - 1, curve.size() - 1);
}
```
Здесь, `curve` — контейнер для опорных точек: для отрезка их две, для кривой Безье три или четыре или более.
Второе — точки надо как-то сравнивать, с учётом `R`:
```
template <>
struct std::less
{
bool operator()(const Point &a, const Point &b, const double edge = R) const
{
for (auto i = a.size(); i-- > 0;) {
if (a[i] + edge < b[i])
return true;
if (a[i] > b[i] + edge)
return false;
}
return false;
}
};
```
Для поиска точек пересечения пары кривых я воспользовался идеей деления каждой кривой на две до тех пор пока есть пересечение области значений этих кривых. А чтобы не заморачиваться с экстремумами и интервалами монотонности, использовал тот факт, что кривая Безье ограничена выпуклым многоугольником, вершинами которого являются опорные точки кривой. Или даже ещё проще — достаточно ограничивающего эти точки прямоугольника:
```
struct Rect
{
Point topLeft, bottomRight;
Rect(const Point &point);
Rect(const std::vector &curve);
bool isCross(const Rect ▭, const double edge) const
{
for (auto i = topLeft.size(); i-- > 0;) {
if (topLeft[i] > rect.bottomRight[i] + edge
|| bottomRight[i] + edge < rect.topLeft[i])
return false;
}
return true;
}
};
```
Алгоритм поиска рекурсивный и достаточно простой
```
void find(const std::vector &curveA, const std::vector &curveB,
double tA, double tB, double dt)
{
```
**1. Проверить, что эти кривые ещё не отмечены как подобные.**
```
if (m_isSimilarCurve)
return;
```
**2. Проверить, что ограничивающие прямоугольники кривых пересекаются**
```
Rect aRect(curveA);
Rect bRect(curveB);
if (!aRect.isCross(bRect, R))
return;
```
**3. Если отрезки кривых меньше R/2, то можно считать, что пересечение найдено**
```
if (isNear(aRect.tl, aRect.br, R / 2) && isNear(bRect.tl, bRect.br, R / 2)) {
// 3.1 Для найденного пересечения сохранить наиболее близкие концы кривых
addBest(curveA.front(), curveA.back(), curveB.front(), curveB.back(), tA, tB, dt);
m_isSimilarCurve = (m_result.size() > curveA.size() * curveB.size());
return;
}
```
**4. Разделить кривые**
```
const auto curveALeft = subCurve(curveA, 0, 0.5);
const auto curveARight = subCurve(curveA, 0.5, 1.0);
const auto curveBLeft = subCurve(curveB, 0, 0.5);
const auto curveBRight = subCurve(curveB, 0.5, 1.0);
```
**5. Продолжить поиск для каждого отрезка кривой**
```
const auto dtHalf = dt / 2;
find(curveALeft, curveBLeft, tA, tB, dtHalf);
find(curveALeft, curveBRight, tA, tB + dtHalf, dtHalf);
find(curveARight, curveBLeft, tA + dtHalf, tB, dtHalf);
find(curveARight, curveBRight, tA + dtHalf, tB + dtHalf, dtHalf);
```
```
}
```
Вот тут-то и выполз самый главный вопрос: как найти опорные точки кривой, которая является частью исходной кривой в интервале `t` от `t1` до `t2`?
После исследования к чему приводит подстановка `t = (t2 - t1) t' + t1` я обнаружил простую закономерность. Первая опорная точка вычисляется по исходной кривой при `t = t1`, последняя при `t = t2`. Это логично, так как по свойствам кривых Безье (полиномов [Бернштейна](https://ru.wikipedia.org/wiki/%D0%91%D0%B5%D1%80%D0%BD%D1%88%D1%82%D0%B5%D0%B9%D0%BD,_%D0%A1%D0%B5%D1%80%D0%B3%D0%B5%D0%B9_%D0%9D%D0%B0%D1%82%D0%B0%D0%BD%D0%BE%D0%B2%D0%B8%D1%87)) крайние точки лежат на кривой. Для остальных точек нашлось простое правило: если в процессе вычисления на шаге `k` вместо `t2` подставить `t1`, то в результате получим опорную точку под номером `k`:
```
Point point(const std::vector &curve, double t1, int n, int i, double t2, int k)
{
return n > k ? (point(curve, t1, n - 1, i - 1, t2, k) \* (1 - t2) +
point(curve, t1, n - 1, i, t2, k) \* t2)
: point(curve, t1, n, i);
}
```
Эту функцию тоже лучше спрятать куда подальше, а для получения всех опорных точек воспользоваться этой:
```
std::vector subCurve(const std::vector &curve, double t1, double t2)
{
std::vector result(curve.size());
for (auto k = result.size(); k-- > 0;) {
result[k] = point(curve, t1, curve.size() - 1, curve.size() - 1, t2, curve.size() - 1 - k);
}
return result;
}
```
Вот, собственно, и всё.
#### Примечания.
1. `t1` и `t2` могут быть любыми:
* `subCurve(curve, 1, 0)` даст кривую, которая "движется" от конечной точки `curve` к начальной,
* `subCurve(curve, 1, 2)` экстраполирует `curve` за пределами последней опорной точки.
2. Реализации некоторых методов опущены намеренно, так как не содержат ничего особенно интересного.
3. Функция `point(curve, t)` не подходит для вычисления множества точек на кривой (например для растрезации), для этого лучше подойдёт вычисление с помощью треугольной матрицы. | https://habr.com/ru/post/522950/ | null | ru | null |
# Пишем GUI к 1С RAC, или снова о Tcl/Tk
По мере вникания в тему работы 1С-овских продуктов в среде linux, обнаружился один недостаток — отсутствие удобного графического мультиплатформенного инструмента для управления кластером серверов 1С. И решено было этот недостаток исправить, путём написания GUI для консольной утилиты rac. Языком для разработки был выбран tcl/tk как, на мой взгляд, наиболее подходящий для этой задачи. И вот, некоторые интересные аспекты решения хочу представить в данном материале.
Для работы понадобятся дистрибутивы tcl/tk и 1С. А так как я решил максимально использовать возможности базовой поставки tcl/tk без применения сторонних пакетов, то понадобится версия 8.6.7, куда входит ttk — пакет с дополнительными графическими элементами, из которых нам потребуется, в основном, ttk::TreeView, он позволяет выводить данные как в виде древовидной структуры так и в виде таблицы (списка). Ещё, в новой версии переделана работа с исключениями (команда try, которая в проекте используется при запуске внешних команд).
Проект состоит из нескольких файлов (хотя ничего не мешает всё сделать одним):
rac\_gui.cfg — дефолтный конфиг
rac\_gui.tcl — основной скрипт запуска
В каталоге lib лежат файлы автоматически загружаемые при старте:
function.tcl — файл с процедурами
gui.tcl — основной графический интерфейс
images.tcl — библиотека изображений в base64
Файл rac\_gui.tcl, собственно, запускает интерпретатор, инициализирует переменные, загружает модули, конфиги и так далее. Содержимое файла с комментариями:
**rac\_gui.tcl**
```
#!/bin/sh
exec wish "$0" -- "$@"
# Устанавливаем текущий каталог
set dir(root) [pwd]
# Устанавливаем рабочий каталог, если его нет то создаём
set dir(work) [file join $env(HOME) .rac_gui]
if {[file exists $dir(work)] == 0 } {
file mkdir $dir(work)
}
# каталог с модулями
set dir(lib) "[file join $dir(root) lib]"
# загружаем пользовательский конфиг, если он отсутствует, то копируем дефолтный
if {[file exists [file join $dir(work) rac_gui.cfg]] ==0} {
file copy [file join [pwd] rac_gui.cfg] [file join $dir(work) rac_gui.cfg]
}
source [file join $dir(work) rac_gui.cfg]
# Код проверки наличия rac и правильности указания пути в конфиге
# если программа не найдена то будет выведен диалог для указания корректного пути
# и этот путь будет записан в пользовательский конфиг
if {[file exists $rac_cmd] == 0} {
set rac_cmd [tk_getOpenFile -initialdir $env(HOME) -parent . -title "Укажите путь до rac" -initialfile rac]
file copy [file join $dir(work) rac_gui.cfg] [file join $dir(work) rac_gui.cfg.bak]
set orig_file [open [file join $dir(work) rac_gui.cfg.bak] "r"]
set file [open [file join $dir(work) rac_gui.cfg] "w"]
while {[gets $orig_file line] >=0 } {
if {[string match "set rac_cmd*" $line]} {
puts $file "set rac_cmd $rac_cmd"
} else {
puts $file $line
}
}
close $file
close $orig_file
#return "$host:$port"
file delete [file join $dir(work) 1c_srv.cfg.bak]
} else {
puts "Found $rac_cmd"
}
set cluster_user ""
set cluster_pwd ""
set agent_user ""
set agent_pwd ""
## LOAD FILE ##
# Загружаем модули кроме gui.tcl так как его надо загрузить последним
foreach modFile [lsort [glob -nocomplain [file join $dir(lib) *.tcl]]] {
if {[file tail $modFile] ne "gui.tcl"} {
source $modFile
puts "Loaded module $modFile"
}
}
source [file join $dir(lib) gui.tcl]
source [file join $dir(work) rac_gui.cfg]
# Читаем файл со списком серверов 1С
# и добавляем в дерево
if [file exists [file join $dir(work) 1c_srv.cfg]] {
set f [open [file join $dir(work) 1c_srv.cfg] "RDONLY"]
while {[gets $f line] >=0} {
.frm_tree.tree insert {} end -id "server::$line" -text "$line" -values "$line"
}
}
```
После загрузки всего, что требуется и проверки наличия утилиты rac, будет запущено графическое окно. Интерфейс программы состоит из трёх элементов:
Панель инструментов, дерево и список
Содержимое «дерева» я сделал максимально похожим на штатную windows-оснастку от 1С.
[](https://nuk-svk.ru/wp-content/uploads/2018/07/rac_gui_1.png)
Основной код формирующий данное окно содержится в файле
**lib/gui.tcl**
```
# установка размера и положения основного окна
# можно установить в переменную topLevelGeometry в конфиг программы
if {[info exists topLevelGeometry]} {
wm geometry . $topLevelGeometry
} else {
wm geometry . 1024x768
}
# Заголовок окна
wm title . "1C Rac GUI"
wm iconname . "1C Rac Gui"
# иконка окна (берется из файла lib/imges.tcl)
wm iconphoto . tcl
wm protocol . WM_DELETE_WINDOW Quit
wm overrideredirect . 0
wm positionfrom . user
ttk::style theme use clam
# Панель инсрументов
set frm_tool [frame .frm_tool]
pack $frm_tool -side left -fill y
ttk::panedwindow .panel -orient horizontal -style TPanedwindow
pack .panel -expand true -fill both
pack propagate .panel false
ttk::button $frm_tool.btn_add -command Add -image add_grey_32
ttk::button $frm_tool.btn_del -command Del -image del_grey_32
ttk::button $frm_tool.btn_edit -command Edit -image edit_grey_32
ttk::button $frm_tool.btn_quit -command Quit -image quit_grey_32
pack $frm_tool.btn_add $frm_tool.btn_del $frm_tool.btn_edit -side top -padx 5 -pady 5
pack $frm_tool.btn_quit -side bottom -padx 5 -pady 5
# Дерево с полосами прокрутки
set frm_tree [frame .frm_tree]
ttk::scrollbar $frm_tree.hsb1 -orient horizontal -command [list $frm_tree.tree xview]
ttk::scrollbar $frm_tree.vsb1 -orient vertical -command [list $frm_tree.tree yview]
set tree [ttk::treeview $frm_tree.tree -show tree \
-xscrollcommand [list $frm_tree.hsb1 set] -yscrollcommand [list $frm_tree.vsb1 set]]
grid $tree -row 0 -column 0 -sticky nsew
grid $frm_tree.vsb1 -row 0 -column 1 -sticky nsew
grid $frm_tree.hsb1 -row 1 -column 0 -sticky nsew
grid columnconfigure $frm_tree 0 -weight 1
grid rowconfigure $frm_tree 0 -weight 1
# назначение обработчика нажатия кнопкой мыши
bind $frm_tree.tree "TreePress $frm\_tree.tree"
# Список для данных (таблица)
set frm\_work [frame .frm\_work]
ttk::scrollbar $frm\_work.hsb -orient horizontal -command [list $frm\_work.tree\_work xview]
ttk::scrollbar $frm\_work.vsb -orient vertical -command [list $frm\_work.tree\_work yview]
set tree\_work [
ttk::treeview $frm\_work.tree\_work \
-show headings -columns "par val" -displaycolumns "par val"\
-xscrollcommand [list $frm\_work.hsb set] \
-yscrollcommand [list $frm\_work.vsb set]
]
# Установка цветов для чередования в таблице
$tree\_work tag configure dark -background $color(dark\_table\_bg)
$tree\_work tag configure light -background $color(light\_table\_bg)
# Размещение элементов на форме
grid $tree\_work -row 0 -column 0 -sticky nsew
grid $frm\_work.vsb -row 0 -column 1 -sticky nsew
grid $frm\_work.hsb -row 1 -column 0 -sticky nsew
grid columnconfigure $frm\_work 0 -weight 1
grid rowconfigure $frm\_work 0 -weight 1
pack $frm\_tree $frm\_work -side left -expand true -fill both
#.panel add $frm\_tool -weight 1
.panel add $frm\_tree -weight 1
.panel add $frm\_work -weight 1
```
Алгоритм работы с программой следующий:
1. В начале, надо добавить основной сервер кластера (т.е. сервер управления кластером (в linux управление запускается командой "/opt/1C/v8.3/x86\_64/ras cluster --daemon")).
Для этого жмёт на кнопку "+" и в открывшемся окне, вводим адрес сервера и порт:
После, в дереве появится наш сервер по щелчку на котором, откроется список кластеров либо будет выведена ошибка соединения.
2. Щелкнув на имя кластера откроется список функций доступный для него.
3.…
Ну и так далее, т.е. чтобы добавить новый кластер, выделяем любой доступный в списке и нажимаем кнопку "+" в панели инструментов и будет выведен диалог добавления нового:
[](https://nuk-svk.ru/wp-content/uploads/2018/07/rac_gui_3.png)
Кнопки в панели инструментов выполняют функции в зависимости от контекста, т.е. от того какой элемент дерева или списка выбран, будет выполнена та или иная процедура.
Рассмотрим на примере кнопки добавления ("+"):
Код формирования кнопки:
```
ttk::button $frm_tool.btn_add -command Add -image add_grey_32
```
Тут видим, что при нажатии кнопки будет выполнена процедура «Add», её код:
```
proc Add {} {
global active_cluster host
# Определяем идентификатор выделенного элемента
set id [.frm_tree.tree selection]
# Определяем значение этого элемента
set values [.frm_tree.tree item [.frm_tree.tree selection] -values]
set key [lindex [split $id "::"] 0]
# в зависимости от того что выделили будет запущена нужная процедура
if {$key eq "" || $key eq "server"} {
set host [ Add::server ]
return
}
Add::$key .frm_tree.tree $host $values
}
```
Вот и проглядывает один из плюсов тикля — в качестве имени процедуры можно передать значение переменной:
```
Add::$key .frm_tree.tree $host $values
```
Т.е., к примеру, если мы ткнём в основной сервер и нажмём "+" то будет запущена процедура Add::server, если в кластер — Add::cluster и так далее (о том откуда берутся нужные «ключи» напишу чуть ниже), перечисленные процедуры отрисовывают графические элементы соответствующие контексту.
Как вы уже могли заметить, формы похожи по стилю — это и не удивительно, ведь они выводятся одной процедурой, точнее основной каркас формы (окно, кнопки, изображение, метка), название процедуры **AddTopLevel**
```
proc AddToplevel {lbl img {win_name .add}} {
set cmd "destroy $win_name"
if [winfo exists $win_name] {destroy $win_name}
toplevel $win_name
wm title $win_name $lbl
wm iconphoto $win_name tcl
# метка с иконкой
ttk::label $win_name.lbl -image $img
# фрейм с полями ввода
set frm [ttk::labelframe $win_name.frm -text $lbl -labelanchor nw]
grid columnconfigure $frm 0 -weight 1
grid rowconfigure $frm 0 -weight 1
# фрейм и кнопки
set frm_btn [frame $win_name.frm_btn -border 0]
ttk::button $frm_btn.btn_ok -image ok_grey_24 -command { }
ttk::button $frm_btn.btn_cancel -command $cmd -image quit_grey_24
grid $win_name.lbl -row 0 -column 0 -sticky nw -padx 5 -pady 10
grid $frm -row 0 -column 1 -sticky nw -padx 5 -pady 5
grid $frm_btn -row 1 -column 1 -sticky se -padx 5 -pady 5
pack $frm_btn.btn_cancel -side right
pack $frm_btn.btn_ok -side right -padx 10
return $frm
}
```
Параметры вызова: заголовок, название изображения для иконки из библиотеки (lib/images.tcl) и опциональный параметр имя окна (по умолчанию .add). Таким образом, если брать вышеприведённые примеры для добавления основного сервера и кластера то вызов будет соответственно:
```
AddToplevel "Добавление основного сервера" server_grey_64
```
или
```
AddToplevel "Добавление кластера" cluster_grey_64
```
Ну и продолжив с этим примерами покажу процедуры, которые выводят диалоги добавления для сервера или кластера.
**Add::server**
```
proc Add::server {} {
global default
# выводим основную форму
set frm [AddToplevel "Добавление основного сервера" server_grey_64]
# добавляем етки и поля ввода на эту форму
label $frm.lbl_host -text "Адрес сервера"
entry $frm.ent_host
label $frm.lbl_port -text "Порт"
entry $frm.ent_port
$frm.ent_port insert end $default(port)
grid $frm.lbl_host -row 0 -column 0 -sticky nw -padx 5 -pady 5
grid $frm.ent_host -row 0 -column 1 -sticky nsew -padx 5 -pady 5
grid $frm.lbl_port -row 1 -column 0 -sticky nw -padx 5 -pady 5
grid $frm.ent_port -row 1 -column 1 -sticky nsew -padx 5 -pady 5
grid columnconfigure $frm 0 -weight 1
grid rowconfigure $frm 0 -weight 1
#set frm_btn [frame .add.frm_btn -border 0]
# переопределяем обработчик нажатия кнопки
.add.frm_btn.btn_ok configure -command {
set host [SaveMainServer [.add.frm.ent_host get] [.add.frm.ent_port get]]
.frm_tree.tree insert {} end -id "server::$host" -text "$host" -values "$host"
destroy .add
return $host
}
return $frm
}
```
**Add::cluster**
```
proc Add::cluster {tree host values} {
global default lifetime_limit expiration_timeout session_fault_tolerance_level
global max_memory_size max_memory_time_limit errors_count_threshold security_level
global load_balancing_mode kill_problem_processes \
agent_user agent_pwd cluster_user cluster_pwd auth_agent
if {$agent_user ne "" && $agent_pwd ne ""} {
set auth_agent "--agent-user=$agent_user --agent-pwd=$agent_pwd"
} else {
set auth_agent ""
}
# устанавливаем глобальные переменные ()
set lifetime_limit $default(lifetime_limit)
set expiration_timeout $default(expiration_timeout)
set session_fault_tolerance_level $default(session_fault_tolerance_level)
set max_memory_size $default(max_memory_size)
set max_memory_time_limit $default(max_memory_time_limit)
set errors_count_threshold $default(errors_count_threshold)
set security_level [lindex $default(security_level) 0]
set load_balancing_mode [lindex $default(load_balancing_mode) 0]
set frm [AddToplevel "Добавление кластера" cluster_grey_64]
label $frm.lbl_host -text "Адрес основного сервера"
entry $frm.ent_host
label $frm.lbl_port -text "Порт"
entry $frm.ent_port
$frm.ent_port insert end $default(port)
label $frm.lbl_name -text "Название кластера"
entry $frm.ent_name
label $frm.lbl_secure_connect -text "Защищённое соединение"
ttk::combobox $frm.cb_security_level -textvariable security_level -values $default(security_level)
label $frm.lbl_expiration_timeout -text "Останавливать выключенные процессы через:"
entry $frm.ent_expiration_timeout -textvariable expiration_timeout
label $frm.lbl_session_fault_tolerance_level -text "Уровень отказоустойчивости"
entry $frm.ent_session_fault_tolerance_level -textvariable session_fault_tolerance_level
label $frm.lbl_load_balancing_mode -text "Режим распределения нагрузки"
ttk::combobox $frm.cb_load_balancing_mode -textvariable load_balancing_mode \
-values $default(load_balancing_mode)
label $frm.lbl_errors_count_threshold -text "Допустимое отклонение количества ошибок сервера, %"
entry $frm.ent_errors_count_threshold -textvariable errors_count_threshold
label $frm.lbl_processes -text "Рабочие процессы:"
label $frm.lbl_lifetime_limit -text "Период перезапуска, сек."
entry $frm.ent_lifetime_limit -textvariable lifetime_limit
label $frm.lbl_max_memory_size -text "Допустимый объём памяти, КБ"
entry $frm.ent_max_memory_size -textvariable max_memory_size
label $frm.lbl_max_memory_time_limit -text "Интервал превышения допустимого объёма памяти, сек."
entry $frm.ent_max_memory_time_limit -textvariable max_memory_time_limit
label $frm.lbl_kill_problem_processes -justify left -anchor nw -text "Принудительно завершать проблемные процессы"
checkbutton $frm.check_kill_problem_processes -variable kill_problem_processes -onvalue yes -offvalue no
grid $frm.lbl_host -row 0 -column 0 -sticky nw -padx 5 -pady 5
grid $frm.ent_host -row 0 -column 1 -sticky nsew -padx 5 -pady 5
grid $frm.lbl_port -row 1 -column 0 -sticky nw -padx 5 -pady 5
grid $frm.ent_port -row 1 -column 1 -sticky nsew -padx 5 -pady 5
grid $frm.lbl_name -row 2 -column 0 -sticky nw -padx 5 -pady 5
grid $frm.ent_name -row 2 -column 1 -sticky nsew -padx 5 -pady 5
grid $frm.lbl_secure_connect -row 3 -column 0 -sticky nw -padx 5 -pady 5
grid $frm.cb_security_level -row 3 -column 1 -sticky nsew -padx 5 -pady 5
grid $frm.lbl_expiration_timeout -row 4 -column 0 -sticky nw -padx 5 -pady 5
grid $frm.ent_expiration_timeout -row 4 -column 1 -sticky nsew -padx 5 -pady 5
grid $frm.lbl_session_fault_tolerance_level -row 5 -column 0 -sticky nw -padx 5 -pady 5
grid $frm.ent_session_fault_tolerance_level -row 5 -column 1 -sticky nsew -padx 5 -pady 5
grid $frm.lbl_load_balancing_mode -row 6 -column 0 -sticky nw -padx 5 -pady 5
grid $frm.cb_load_balancing_mode -row 6 -column 1 -sticky nsew -padx 5 -pady 5
grid $frm.lbl_errors_count_threshold -row 7 -column 0 -sticky nw -padx 5 -pady 5
grid $frm.ent_errors_count_threshold -row 7 -column 1 -sticky nsew -padx 5 -pady 5
grid $frm.lbl_processes -row 8 -column 0 -sticky nw -padx 5 -pady 5
grid $frm.lbl_lifetime_limit -row 9 -column 0 -sticky nw -padx 5 -pady 5
grid $frm.ent_lifetime_limit -row 9 -column 1 -sticky nsew -padx 5 -pady 5
grid $frm.lbl_max_memory_size -row 10 -column 0 -sticky nw -padx 5 -pady 5
grid $frm.ent_max_memory_size -row 10 -column 1 -sticky nsew -padx 5 -pady 5
grid $frm.lbl_max_memory_time_limit -row 11 -column 0 -sticky nw -padx 5 -pady 5
grid $frm.ent_max_memory_time_limit -row 11 -column 1 -sticky nsew -padx 5 -pady 5
grid $frm.lbl_kill_problem_processes -row 12 -column 0 -sticky nw -padx 5 -pady 5
grid $frm.check_kill_problem_processes -row 12 -column 1 -sticky nw -padx 5 -pady 5
# переопределяем обработчик
.add.frm_btn.btn_ok configure -command {
RunCommand "" "cluster insert \
--host=[.add.frm.ent_host get] \
--port=[.add.frm.ent_port get] \
--name=[.add.frm.ent_name get] \
--expiration-timeout=$expiration_timeout \
--lifetime-limit=$lifetime_limit \
--max-memory-size=$max_memory_size \
--max-memory-time-limit=$max_memory_time_limit \
--security-level=$security_level \
--session-fault-tolerance-level=$session_fault_tolerance_level \
--load-balancing-mode=$load_balancing_mode \
--errors-count-threshold=$errors_count_threshold \
--kill-problem-processes=$kill_problem_processes \
$auth_agent $host"
Run::server $tree $host ""
destroy .add
}
return $frm
}
```
При сравнении кода этих процедур, разница видна не вооруженным глазом, внимание заострю на обработчике кнопки «Ок». В Tk свойства графических элементов можно переопределять вовремя выполнения программы при помощи опции *configure*. К примеру, первоначальная команда вывода кнопки:
```
ttk::button $frm_btn.btn_ok -image ok_grey_24 -command { }
```
Но а в наших формах команда зависит от требуемой функциональности:
```
.add.frm_btn.btn_ok configure -command {
RunCommand "" "cluster insert \
--host=[.add.frm.ent_host get] \
--port=[.add.frm.ent_port get] \
--name=[.add.frm.ent_name get] \
--expiration-timeout=$expiration_timeout \
--lifetime-limit=$lifetime_limit \
--max-memory-size=$max_memory_size \
--max-memory-time-limit=$max_memory_time_limit \
--security-level=$security_level \
--session-fault-tolerance-level=$session_fault_tolerance_level \
--load-balancing-mode=$load_balancing_mode \
--errors-count-threshold=$errors_count_threshold \
--kill-problem-processes=$kill_problem_processes \
$auth_agent $host"
Run::server $tree $host ""
destroy .add
}
```
В приведённом выше примере на кнопку «забит» запуск процедуры добавления кластера.
Тут стоит сделать отступление в сторону работы с графическими элементами в Tk — для различных элементов ввода данных (entry, combobox, checkbutton и т.д.) введён такой параметр как текстовая переменная (textvariable):
```
entry $frm.ent_lifetime_limit -textvariable lifetime_limit
```
Переменная эта определена в глобальном пространстве имён и содержит текущее введённое значение. Т.е. дабы получить введённый текст из поля надо просто считать значение, соответствующей переменной (конечно при условии, что она определена при создании элемента).
Второй метод получения введённого текста (для элементов типа entry) это использование команды get:
```
.add.frm.ent_name get
```
Оба эти метода можно увидеть в вышеприведённом коде.
Нажатие этой кнопки, в данном случае, запускает процедуру RunCommand с сформированной строкой команды добавления кластера в терминах rac:
```
/opt/1C/v8.3/x86_64/rac cluster insert --host=localhost --port=1540 --name=dsdsds --expiration-timeout=0 --lifetime-limit=0 --max-memory-size=0 --max-memory-time-limit=0 --security-level=0 --session-fault-tolerance-level=0 --load-balancing-mode=performance --errors-count-threshold=0 --kill-problem-processes=no localhost:1545
```
Вот и подошли к основной команде, которая и управляет запуском rac с нужными нам параметрами, также разбирает вывод команд на списки и возвращает, если это требуется:
**RunCommand**
```
proc RunCommand {root par} {
global dir rac_cmd cluster work_list_row_count agent_user agent_pwd cluster_user cluster_pwd
puts "$rac_cmd $par"
set work_list_row_count 0
# открываем канал в неблокирующем режиме
# $rac - команда с полным путём
# $par - сформированные ключи запуска и опции
set pipe [open "|$rac_cmd $par" "r"]
try {
set lst ""
set l ""
# вывод команды добавляем в список списков
while {[gets $pipe line]>=0} {
#puts $line
if {$line eq ""} {
lappend l $lst
set lst ""
} else {
lappend lst [string trim $line]
}
}
close $pipe
return $l
} on error {result options} {
# Запуск обработчика ошибок
ErrorParcing $result $options
return ""
}
}
```
После ввода данных основного сервера он будет добавлен в дерево, за это, в выше приведённой процедуре Add:server, отвечает следующий код:
```
.frm_tree.tree insert {} end -id "server::$host" -text "$host" -values "$host"
```
Теперь щелкнув по имени сервера в дереве, мы получим список кластеров управляемых оным сервером, а щелкнув на кластере, получим список элементов кластера (серверов, информационных баз и т.д.). Реализовано это в процедуре TreePress (файл lib/function.tcl):
```
proc TreePress {tree} {
global host server active_cluster infobase
# определяем выделенный элемент
set id [$tree selection]
# устанавливаем нужные глобальные переменные
SetGlobalVarFromTreeItems $tree $id
# Определяем ключ и значение, т.е. именно тип выбранного элемента
set values [$tree item $id -values]
set key [lindex [split $id "::"] 0]
# и в зависимости от того что выбрали будет запущена соответствующая процедура
# в пространстве имён Run
Run::$key $tree $host $values
}
```
Соответственно, для основного сервера запустится Run::server (для кластера — Run::cluster, для рабочего сервера — Run::work\_server и т.д.). Т.е. значение переменной $key это часть имени элемента дерева, задаваемого опцией *-id*.
Обратим внимание на процедуру
**Run::server**
```
proc Run::server {tree host values} {
# получаем список кластеров требуемого сервера
set lst [RunCommand server::$host "cluster list $host"]
if {$lst eq ""} {return}
set l [lindex $lst 0]
#puts $lst
# удаляем лишнее из списка
.frm_work.tree_work delete [ .frm_work.tree_work children {}]
# читаем список
foreach cluster_list $lst {
# Заполняем список полученными значениями
InsertItemsWorkList $cluster_list
# обрабатываем вывод (список) для добавления данных в дерево
foreach i $cluster_list {
#puts $i
set cluster_list [split $i ":"]
if {[string trim [lindex $cluster_list 0]] eq "cluster"} {
set cluster_id [string trim [lindex $cluster_list 1]]
lappend cluster($cluster_id) $cluster_id
}
if {[string trim [lindex $cluster_list 0]] eq "name"} {
lappend cluster($cluster_id) [string trim [lindex $cluster_list 1]]
}
}
}
# добавляем кластеры в дерево
foreach x [array names cluster] {
set id [lindex $cluster($x) 0]
if { [$tree exists "cluster::$id"] == 0 } {
$tree insert "server::$host" end -id "cluster::$id" -text "[lindex $cluster($x) 1]" -values "$id"
# добавляем элементы в кластер
InsertClusterItems $tree $id
}
}
if { [$tree exists "agent_admins::$id"] == 0 } {
$tree insert "server::$host" end -id "agent_admins::$id" -text "Администраторы" -values "$id"
#InsertClusterItems $tree $id
}
}
```
Данная процедура обрабатывает то, что было получено от сервера через команду RunCommand, и добавляет всякое-разное в дерево — кластеры, различные корневые элементы (базы, рабочие серверы, сеансы и так далее). Если приглядеться, то внутри можно заметить вызов процедуры InsertItemsWorkList. Она используется для добавления элементов в графический список, обрабатывая вывод консольной утилиты rac, который ранее был в виде списка возвращен в переменную $lst. Это список списков, содержащий пары элементов разделённые двоеточием.
Например, список соединений кластера:
```
svk@svk ~]$ /opt/1C/v8.3/x86_64/rac connection list --cluster=783d2170-56c3-11e8-c586-fc75165efbb2 localhost:1545
connection : dcf5991c-7d24-11e8-1690-fc75165efbb2
conn-id : 0
host : svk.home
process : 79de2e16-56c3-11e8-c586-fc75165efbb2
infobase : 00000000-0000-0000-0000-000000000000
application : "JobScheduler"
connected-at : 2018-07-01T14:49:51
session-number : 0
blocked-by-ls : 0
connection : b993293a-7d24-11e8-1690-fc75165efbb2
conn-id : 0
host : svk.home
process : 79de2e16-56c3-11e8-c586-fc75165efbb2
infobase : 00000000-0000-0000-0000-000000000000
application : "JobScheduler"
connected-at : 2018-07-01T14:48:52
session-number : 0
blocked-by-ls : 0
```
В графическом виде это будет выглядеть примерно так:
[](https://nuk-svk.ru/wp-content/uploads/2018/07/rac_gui_4.png)
Вышеозначенная процедура выделяет наименования элементов для заголовка и данные для заполнения таблицы:
**InsertItemsWorkList**
```
proc InsertItemsWorkList {lst} {
global work_list_row_count
# установка чередования цвета для строки
if [expr $work_list_row_count % 2] {
set tag dark
} else {
set tag light
}
# разбор строк на пары ключ - значение
foreach i $lst {
if [regexp -nocase -all -- {(\D+)(\s*?|)(:)(\s*?|)(.*)} $i match param v2 v3 v4 value] {
lappend column_list [string trim $param]
lappend value_list [string trim $value]
}
}
# заполнение таблицы
.frm_work.tree_work configure -columns $column_list -displaycolumns $column_list
.frm_work.tree_work insert {} end -values $value_list -tags $tag
.frm_work.tree_work column #0 -stretch
# установка заголовков
foreach j $column_list {
.frm_work.tree_work heading $j -text $j
}
incr work_list_row_count
}
```
Тут вместо простой команды [split $str ":"], которая разбивает строку на элементы разделенные ":" и возвращает список, применено регулярное выражение, так как некоторые элементы также содержат двоеточие.
Процедура InsertClusterItems (одна из нескольких подобных) просто добавляет в дерево к требуемому элементу cluster список дочерних элементов с соответствующими идентификаторами
**InsertClusterItems**
```
proc InsertClusterItems {tree id} {
set parent "cluster::$id"
$tree insert $parent end -id "infobases::$id" -text "Информационные базы" -values "$id"
$tree insert $parent end -id "servers::$id" -text "Рабочие серверы" -values "$id"
$tree insert $parent end -id "admins::$id" -text "Администраторы" -values "$id"
$tree insert $parent end -id "managers::$id" -text "Менеджеры кластера" -values $id
$tree insert $parent end -id "processes::$id" -text "Рабочие процессы" -values "workprocess-all"
$tree insert $parent end -id "sessions::$id" -text "Сеансы" -values "sessions-all"
$tree insert $parent end -id "locks::$id" -text "Блокировки" -values "blocks-all"
$tree insert $parent end -id "connections::$id" -text "Соединения" -values "connections-all"
$tree insert $parent end -id "profiles::$id" -text "Профили безопасности" -values $id
}
```
Можно рассмотреть ещё два варианта реализации подобной процедуры, где будет наглядно видно как можно оптимизировать и избавиться от повторяющихся команд:
В данной процедуре добавление и проверка решены в лоб:
**InsertBaseItems**
```
proc InsertBaseItems {tree id} {
set parent "infobase::$id"
if { [$tree exists "sessions::$id"] == 0 } {
$tree insert $parent end -id "sessions::$id" -text "Сеансы" -values "$id"
}
if { [$tree exists "locks::$id"] == 0 } {
$tree insert $parent end -id "locks::$id" -text "Блокировки" -values "$id"
}
if { [$tree exists "connections::$id"] == 0 } {
$tree insert $parent end -id "connections::$id" -text "Соединения" -values "$id"
}
}
```
А тут подход более правильный:
**InsertProfileItems**
```
proc InsertProfileItems {tree id} {
set parent "profile::$id"
set lst {
{dir "Виртуальные каталоги"}
{com "Разрешённые COM-классы"}
{addin "Внешние компоненты"}
{module "Внешние отчёты и обработки"}
{app "Разрешённые приложения"}
{inet "Ресурсы интернет"}
}
foreach i $lst {
append item [lindex $i 0] "::$id"
if { [$tree exists $item] == 0 } {
$tree insert $parent end -id $item -text [lindex $i 1] -values "$id"
}
unset item
}
}
```
Разница между ними в применении цикла, в котором и выполняется повторяющаяся команда (команды). Какой подход применять — это уже на усмотрение разработчика.
Добавление элементов и получение данных мы рассмотрели, самое время остановиться на редактировании. Так как, в основном, для редактирования и добавления используются одни и те же параметры (исключение составляет информационная база) то и диалоговые формы используются одинаковые. Алгоритм вызова процедур для добавления выглядит так:
*Add::$key->AddToplevel*
А для редактирования так:
*Edit::$key->Add::$key->AddTopLevel*
Для примера возьмём редактирование кластера, т.е. щелкнув в дереве на названии кластера, нажимаем кнопку редактирования в панели инструментов (карандашик) и на экран будет выведена соответствующая форма:
**Edit::cluster**
```
proc Edit::cluster {tree host values} {
global default lifetime_limit expiration_timeout session_fault_tolerance_level
global max_memory_size max_memory_time_limit errors_count_threshold security_level
global load_balancing_mode kill_problem_processes active_cluster \
agent_user agent_pwd cluster_user cluster_pwd auth
if {$cluster_user ne "" && $cluster_pwd ne ""} {
set auth "--cluster-user=$cluster_user --cluster-pwd=$cluster_pwd"
} else {
set auth ""
}
# рисуем форму для кластера
set frm [Add::cluster $tree $host $values]
# меняем текст на метке
$frm configure -text "Редактирование кластера"
set active_cluster $values
# получаем данные по выделенному кластеру
set lst [RunCommand cluster::$values "cluster info --cluster=$active_cluster $host"]
# заполняем поля
FormFieldsDataInsert $frm $lst
# выключаем поля, редактирование которых запрещено
$frm.ent_host configure -state disable
$frm.ent_port configure -state disable
# переназначаем обработчик
.add.frm_btn.btn_ok configure -command {
RunCommand "" "cluster update \
--cluster=$active_cluster $auth \
--name=[.add.frm.ent_name get] \
--expiration-timeout=$expiration_timeout \
--lifetime-limit=$lifetime_limit \
--max-memory-size=$max_memory_size \
--max-memory-time-limit=$max_memory_time_limit \
--security-level=$security_level \
--session-fault-tolerance-level=$session_fault_tolerance_level \
--load-balancing-mode=$load_balancing_mode \
--errors-count-threshold=$errors_count_threshold \
--kill-problem-processes=$kill_problem_processes \
$auth $host"
$tree delete "cluster::$active_cluster"
Run::server $tree $host ""
destroy .add
}
}
```
По комментариям в коде, в принципе, всё понятно, кроме того, что код обработчика кнопки переопределён и присутствует процедура FormFieldsDataInsert, которая заполняет поля данными и инициализирует переменные:
**FormFieldsDataInsert**
```
proc FormFieldsDataInsert {frm lst} {
foreach i [lindex $lst 0] {
# получаем список параметров и значений
if [regexp -nocase -all -- {(\D+)(\s*?|)(:)(\s*?|)(.*)} $i match param v2 v3 v4 value] {
# меняем символы
regsub -all -- "-" [string trim $param] "_" entry_name
# заполняем данными
if [winfo exists $frm.ent_$entry_name] {
$frm.ent_$entry_name delete 0 end
$frm.ent_$entry_name insert end [string trim $value "\""]
}
if [winfo exists $frm.cb_$entry_name] {
global $entry_name
set $entry_name [string trim $value "\""]
}
# для чекбоксов меняем значения
if [winfo exists $frm.check_$entry_name] {
global $entry_name
if {$value eq "0"} {
set $entry_name no
} elseif {$value eq "1"} {
set $entry_name yes
} else {
set $entry_name $value
}
}
}
}
}
```
В данной процедуре всплыл еще один плюс tcl — в качестве имён переменных подставляются значения других переменных. Т.е. для автоматизации заполнения форм и инициализации переменных наименования полей и переменных, соответствуют ключам командной строки утилиты rac и наименованиям параметров вывода команд с некоторым исключением — тире заменено на подчерк. К примеру *scheduled-jobs-deny* соответствует полю *ent\_scheduled\_jobs\_deny* и переменной *scheduled\_jobs\_deny*.
Формы добавления и редактирования могут отличаться составом полей, к примеру, работа с информационной базой:
Добавление ИБ
Редактирование ИБ
В процедуре редактирования Edit::infobase на форму добавляются требуемые поля, код объёмный посему тут не привожу.
По аналогии реализованы процедуры добавления, редактирования, удаления и для остальных элементов.
Так как работа утилиты подразумевает неограниченное количество серверов, кластеров, информационных баз и т.п., то для определения к какому кластеру относится какой сервер или ИБ, введены несколько глобальных переменных, значения которых устанавливаются при каждом щелчке по элементам дерева. Т.е. процедура рекурсивно пробегает по всем родительским элементам и выставляет переменные:
**SetGlobalVarFromTreeItems**
```
proc SetGlobalVarFromTreeItems {tree id} {
global host server active_cluster infobase
set parent [$tree parent $id]
set values [$tree item $id -values]
set key [lindex [split $id "::"] 0]
switch -- $key {
server {set host $values}
work_server {set server $values}
cluster {set active_cluster $values}
infobase {set infobase $values}
}
if {$parent eq ""} {
return
} else {
SetGlobalVarFromTreeItems $tree $parent
}
}
```
Кластер 1С позволяет работу как с авторизацией так и без. Существует два вида администраторов — администратор агента кластера и администратор кластера. Соответственно для корректной работы введены ещё 4 глобальных переменных, содержащих логин и пароль администратора. Т.е. если в кластере присутствует учётная запись администратора, то будет выведен диалог для ввода логина и пароля, данные будут сохранены в памяти и подставятся в каждую команду для соответствующего кластера.
За это отвечает процедура обработки ошибок
**ErrorParcing**
```
proc ErrorParcing {err opt} {
global cluster_user cluster_pwd agent_user agent_pwd
switch -regexp -- $err {
"Cluster administrator is not authenticated" {
AuthorisationDialog "Администратор кластера"
.auth_win.frm_btn.btn_ok configure -command {
set cluster_user [.auth_win.frm.ent_name get]
set cluster_pwd [.auth_win.frm.ent_pwd get]
destroy .auth_win
}
#RunCommand $root $par
}
"Central server administrator is not authenticated" {
AuthorisationDialog "Администратор агента кластера"
.auth_win.frm_btn.btn_ok configure -command {
set agent_user [.auth_win.frm.ent_name get]
set agent_pwd [.auth_win.frm.ent_pwd get]
destroy .auth_win
}
}
"Администратор кластера не аутентифицирован" {
AuthorisationDialog "Администратор кластера"
.auth_win.frm_btn.btn_ok configure -command {
set cluster_user [.auth_win.frm.ent_name get]
set cluster_pwd [.auth_win.frm.ent_pwd get]
destroy .auth_win
}
#RunCommand $root $par
}
"Администратор центрального сервера не аутентифицирован" {
AuthorisationDialog "Администратор агента кластера"
.auth_win.frm_btn.btn_ok configure -command {
set agent_user [.auth_win.frm.ent_name get]
set agent_pwd [.auth_win.frm.ent_pwd get]
destroy .auth_win
}
}
(.+) {
tk_messageBox -type ok -icon error -message "$err"
}
}
}
```
Т.е. в зависимости от того, что возвращает команда, будет соответственно и реакция.
На данный момент функциональность реализована процентов эдак на 95, осталось реализовать работу с профилями безопасности ну и оттестировать =). На этом всё. Прошу прощения за скомканное повествование.
Код, по традиции доступен [тут](https://bitbucket.org/svk28/rac-gui).
Обновление: Доделал работу с профилями безопасности. Теперь функциональность реализована на 100%.
Обновление 2: добавлена локализация на английский и русский, проверена работа в win7
 | https://habr.com/ru/post/415835/ | null | ru | null |
# Измеряем задержку от клавиатуры до фотона с помощью оптического датчика
Для измерения времени отклика или задержки (latency) на компьютерах и в интерфейсах я давным-давно использую приложение [Is It Snappy](https://isitsnappy.com/) с высокоскоростной камерой iPhone для подсчёта кадров между нажатием клавиши и изменением экрана. Однако проблема заключается в определении на глаз точных кадров для тайминга, что раздражает при выполнении множества тестов. Это также затрудняет измерение вариабельности результатов. Я уже упростил эти тесты, [добавив в прошивку клавиатуры режим, который изменяет цвет светодиода после отправки события по USB](https://thume.ca/2017/12/29/fixing-my-keyboards-latency/), но это лишь немного повышает скорость и точность. Хотелось бы чего-то получше.
Поэтому я пошел по стопам моего друга [Рафа](https://raphlinus.github.io/) и сделал аппаратный тестер задержки, который посылает события клавиатуры, а затем с помощью оптического датчика измеряет время изменения экрана! Это было довольно легко, и в этой статье я расскажу о некоторых результатах, а также о сложностях качественного тестирования задержки и как сделать собственный тестер.
Мой тестер сделан на базе датчика освещённости с Amazon. Он установлен на регулируемый штатив, подключённый к микроконтроллеру [Teensy LC](https://www.pjrc.com/teensy/teensyLC.html), который нажимает 'а' и ждёт, когда изменится уровень освещённости, удаляет букву, а потом продолжает собирать образцы, пока удерживается кнопка. При коротком нажатии кнопки он выводит красивую гистограмму задержки, которая выглядит следующим образом:
```
lat i= 60.3 +/- 9.3, a= 60, d= 59 (n= 65,q= 41) | 239_ |
```
Эта строка показывает среднюю задержку вставок (`i=`), удалений (`d=`) и их вместе взятых (`a=`), стандартное отклонение времени вставки (`+/-`), количество измерений (`n=`) и качество (`q=`), а также небольшую ascii-гистограмму, где каждый символ представляет собой фрагмент (бакет) в 10 мс, а цифры от 1 до 9 пропорционально представляют собой, насколько заполнен этот бакет. Символ `_` означает бакет с по крайней мере одним образцом, но его недостаточно до заполнения одной девятой бакета, так что это хвост задержек с малым количеством случайных образцов. Вот как это выглядит (на фотографии мониторы в портретном режиме, но все тесты делались в ландшафтном):
Я также сделал так, что при повторном нажатии кнопки выводятся все результаты измерений, например, `[35, 35, 33, 44]`, так что можно сгенерировать график:
Время отклика монитора
======================
Начну с моего любимого набора результатов:
```
Sublime Text, macOS, distraction-free full-screen mode on two 4k monitors:
lat i= 35.3 +/- 4.7, a= 36, d= 36 (n= 67,q= 99) | 193 | Dell P2415Q top
lat i= 52.9 +/- 5.0, a= 53, d= 54 (n= 66,q= 45) | _391 | Dell P2415Q bottom
lat i= 65.1 +/- 5.0, a= 64, d= 63 (n=109,q=111) | _292 | HP Z27 top
lat i= 79.7 +/- 5.0, a= 80, d= 80 (n= 98,q=114) | 89_ | HP Z27 bottom
```
Здесь есть на что посмотреть:
* Прежде всего, мне нравится, что однострочный формат гистограммы фиксированной ширины позволяет поместить все результаты рядышком в текстовом файле и помечать для сравнения.
* Мы видим ожидаемую разницу в 16 мс между временем отклика вверху и внизу экрана из-за времени сканирования строк для кадров на 60 Гц.
* Стандартное отклонение не сильно отличается от [4,6 мс](https://www.quora.com/What-is-the-standard-deviation-of-a-uniform-distribution-How-is-this-formula-determined) от равномерного распределения результатов с временем обновления экрана 16 мс.
* **У HP Z27 время отклика примерно на 30 мс больше, чем у Dell P2415Q!** И это измерение до самого начала отображения символа. Я почти уверен, что на Z27 полное отображение также занимает больше времени. То есть на Z27 в редакторе Sublime почти половина всей задержки — это лишняя задержка с монитора!
Все измерения в остальной части статьи сделаны на моём Dell P2415Q. У обоих мониторов время отклика установлено на «быстрый», у Z27 есть ещё более быстрая настройка времени отклика, но она влияет только на время перехода с начала до конца отображения (transition time) и вводит неприглядные призрачные следы, не помогая уменьшить начальную задержку.
Трудности измерения
===================
В большинстве известных способов качественно измерить задержку на самом деле сложнее, чем вы думаете. Чтобы получить реалистичные результаты, я приложил больше усилий, чем большинство экспериментаторов, но всё в первые несколько раз потерпел неудачу, так что пришлось исправлять ошибки.
Фактически измерение сквозной задержки
======================================
Главная причина использования аппаратного тестера заключается в том, что существует множество неполных и ложных способов измерения сквозной задержки.
Есть известная и действительно отличная статья под названием [«Печатаем с удовольствием»](https://pavelfatin.com/typing-with-pleasure/) с хорошим анализом и красивыми графиками. Там сравнивается задержка различных текстовых редакторов на разных операционных системах. Но автор реализовал измерения через имитацию входных событий и скрапинг экрана с помощью системных API. Я сам не делал повторных измерений, поэтому не могу указать на что-то конкретно неправильное, но с этим подходом много потенциальных проблем. Например, проверка буфера экрана на CPU может неоправданно штрафовать приложения, которые рендерятся на GPU, из-за копий буфера окна в некоторых случаях, когда может cработать захват. Имитация входных данных может пойти по другому пути, чем реальные нажатия клавиш. Несмотря на это, даже в случае действительно качественных измерений и объективных результатов (а мы не можем действительно быть в этом уверены, не проверив их на сквозном тесте), эти результаты не говорят нам о полном времени отклика от начала до конца, что важно для реального опыта.
### USB-опрос на 1000 Гц
Один из источников задержки, которую испытывают пользователи, но которую не измеряет мой тестер, — это [задержка клавиатуры](https://danluu.com/keyboard-latency/). Многие клавиатуры могут увеличить замеренное мной время отклика в два раза ([как моя прошлая клавиатура](https://thume.ca/2017/12/29/fixing-my-keyboards-latency/)) из-за 8-миллисекундных интервалов опроса USB, низкой скорости сканирования сетки клавиатуры, медленной прошивки и спорного механического дизайна.
Чтобы построить тестер задержки с низкой дисперсией для эмуляции клавиатуры нельзя просто взять любой микроконтроллер — обычно там по умолчанию реализован опрос с частотой 125 Гц. Мой микроконтроллер [Teensy LC](https://www.pjrc.com/teensy/teensyLC.html) — один из немногих, кто по умолчанию использует 1000 Гц.
### Обеспечение хорошего уровня сигнала
В первое время, когда я сконструировал свой тестер для времени отклика, я никак не измерял силу сигнала. В конце концов, я запутался: в одном и том же приложении, на том же экране в немного разных сценариях получались совершенно разные результаты. Я провёл некоторое тестирование и выяснил, что иногда на маленьких шрифтах с плохим размещении датчиков сигнал совсем слабенький, поэтому датчик срабатывает только на окончании вывода символа, хотя должен срабатывать в начале (это уже его собственный сложный субъективный выбор).
Я знал, что причина должна быть во времени полного перехода с начала до конца отображения, потому что ещё до написания прошивки я игрался с простым опросом оптического датчика каждую миллисекунду, используя для вывода результатов плоттер Arduino. Просто набирал и удалял символы, чтобы посмотреть на сигнал. Можете заметить, что в некоторых комбинациях оптического датчика и монитора полный переход занимает почти 100 мс. Но по видеосъёмке с [Is It Snappy](https://isitsnappy.com/) создаётся впечатление, что на мониторе Z27 полный переход занимает всего около 20 мс.
Для исправления я добавил измерение силы сигнала от пика к пику после полного перехода для проверки, что получаю адекватное разрешение измерений для своего порога в пять шагов к началу перехода. Это цифра, которую вы видите после `q=`. Как выяснилось, очень важно установить большой размер шрифта и высокую яркость экрана.
### Сильный разброс от маленьких различий
Вполне возможно, что кажущиеся незначительными различия в объекте измерений приведут к серьёзным различиям задержки. Например, я хотел посмотреть, есть ли существенная разница между временем отклика Sublime и VSCode при выделении текста в маленьком файле по сравнению с большим файлом со сложной грамматикой выделения и всплывающим окном автозаполнения. Конечно, разница есть. Но когда я заметил некоторый разброс значений, то провёл ещё несколько тестов и обнаружил, что время отклика сильно отличается между вводом 'а' в пустой строке и вводом 'а' после предыдущего 'а' ('аа').
Вот результаты создания новой строки после 3469-й строки в большом файле [parser.rs](https://github.com/trishume/syntect/blob/master/testdata/parser.rs) на 6199 строк. Все результаты получены после аналогичного позиционирования датчика ближе к нижней части монитора Dell.
```
lat i= 40.2 +/- 4.1, a= 40, d= 39 (n= 38,q= 90) | _89 | sublime small .txt
lat i= 41.2 +/- 6.9, a= 41, d= 42 (n= 54,q= 92) | 992 | sublime aa parser.rs
lat i= 43.6 +/- 6.1, a= 43, d= 42 (n= 48,q=100) | 492 |
lat i= 52.2 +/- 6.0, a= 52, d= 52 (n= 26,q=100) | 49 |
lat i= 44.3 +/- 5.6, a= 43, d= 42 (n= 45,q=100) | 391 |
lat i= 42.7 +/- 7.6, a= 42, d= 42 (n= 46,q=100) | _491 |
lat i= 48.1 +/- 6.8, a= 49, d= 50 (n= 43,q= 89) | 269 | sublime a parser.rs
lat i= 43.9 +/- 5.4, a= 48, d= 52 (n= 32,q= 97) | 197 |
lat i= 47.8 +/- 8.4, a= 49, d= 49 (n= 29,q= 97) | 197_ |
lat i= 46.1 +/- 6.8, a= 47, d= 49 (n= 42,q= 97) | 196_ |
lat i= 63.3 +/- 9.3, a= 63, d= 62 (n= 68,q=118) | _963__ | vscode aa parser.rs
lat i= 63.6 +/- 7.6, a= 64, d= 65 (n= 71,q=139) | _49__ _ |
lat i= 62.3 +/- 6.3, a= 61, d= 59 (n= 52,q=132) | _791 |
lat i= 62.0 +/- 5.8, a= 61, d= 60 (n= 40,q=111) | _49_ |
lat i= 61.9 +/- 9.7, a= 62, d= 61 (n= 35,q=111) | 981_ |
lat i= 53.1 +/- 7.7, a= 51, d= 49 (n= 54,q=116) | _79__ | vscode a parser.rs
lat i= 52.2 +/- 6.3, a= 52, d= 51 (n= 41,q=133) | 692 |
lat i= 53.2 +/- 7.8, a= 52, d= 52 (n= 57,q=134) | 591_ |
lat i= 52.1 +/- 7.1, a= 52, d= 52 (n= 55,q=134) | 591_ |
```
Я сделал множество измерений в разное время и с незначительными вариациями, чтобы подтвердить эффект. Как видите, между измерениями в одном и том же сценарии есть некоторые различия, но гораздо больше вариаций между простым вводом 'а' и добавлением 'а' после существующего 'а'. Посмотрите на столбец `a=`, который включает в себя результаты и вставки, и удаления, поэтому там наименьший шум. Sublime быстрее вводит второй символ в последовательности 'aa', чем первый, а VSCode — наоборот.
В обоих редакторах 'aa' заставляет появиться и исчезнуть всплывающее окно автозаполнения для выбора варианта между двумя списками и буквами 'a'. Могу предположить, что Sublime медленнее в случае 'а', потому что открытие и закрытие всплывающего окна автозаполнения занимает определённое время, но у меня нет чёткой версии, почему VSCode медленнее в случае 'aa' как при вставке, так и при удалении.
### Рассинхрон с обновлением экрана
Потом я заметил, что значения стандартных отклонений какие-то подозрительно низкие. Иногда стандартное отклонение получалось 1 мс, хотя по логике оно должно превышать 4,6 мс из-за интервалов обновления экрана 16 мс.
Я посмотрел на свой код и понял, что измерения случайно синхронизируются с обновлениями экрана. После каждого измерения прошивка ждала ровно 300 мс, прежде чем снова набрать 'a' или удалить символ и произвести следующее измерение. Это значит, что входные данные всегда отправлялись примерно через 300 мс после обновления экрана, довольно стабильно попадая в один и тот же интервал обновлений. Я исправил эту проблему, добавив между измерениями случайную задержку 50 мс, такой своеобразный джиттеринг.
В основном, эта ошибка вызывала слишком низкие отклонения, но могла привести и к неправильным средним значениям, если приложение пропустит дедлайн для отрисовки, когда входное событие приходит в конце фрейма. Я обнаружил это во время тестирования для этой статьи и уже не мог повторять все предыдущие тесты, поэтому кое-где можете заметить некоторые низкие значения отклонений. Но я перепроверил средние значения по важным тестам, таким как Sublime и VSCode.
Текстовые редакторы
===================
Я протестировал время отклика нескольких текстовых редакторов на одном и том же обычном текстовом файле. Но как я заметил выше, тесты сделаны до реализации рассинхрона с обновлением экрана через джиттеринг. Повторные тесты проведены только для Sublime и VSCode.
```
lat i= 32.5 +/- 4.0, a= 34, d= 35 (n= 38,q= 78) | 9_ | sublime text
lat i= 33.4 +/- 1.4, a= 33, d= 33 (n= 68,q= 23) | _9 | textedit
lat i= 47.6 +/- 7.0, a= 47, d= 47 (n= 71,q=130) | 219 | vscode
lat i= 34.2 +/- 3.5, a= 34, d= 33 (n= 57,q= 37) | 9 _ | chrome html input
lat i= 33.2 +/- 1.1, a= 33, d= 33 (n= 55,q= 30) | 9 | stock mac emacs
lat i= 45.6 +/- 7.0, a= 43, d= 41 (n= 35,q= 56) | 992_ | atom
lat i= 35.0 +/- 4.7, a= 35, d= 35 (n= 66,q= 11) | 9__ | xi
```
Учитывая отсутствие джиттеринга, по этим результатам я бы сказал, что все редакторы, кроме VSCode и Atom, работают одинаково отлично. И даже у этих двух при обычном наборе текста меньший штраф на время отклика, чем обычно у монитора или клавиатуры.
Терминалы
=========
Я также измерил задержку в разных терминалах. Похоже, что у терминала Apple по умолчанию и у [kitty](https://sw.kovidgoyal.net/kitty/) оптимальное время отклика, в то время как [iTerm2](https://www.iterm2.com/) и [Alacritty](https://github.com/alacritty/alacritty) выглядят чуть хуже.
```
lat i= 53.1 +/- 6.6, a= 54, d= 55 (n= 53,q= 59) | 291 _ | iterm2 gpu render
lat i= 50.5 +/- 2.5, a= 50, d= 50 (n= 56,q= 59) | 19_ | iterm2 no gpu
lat i= 35.8 +/- 7.0, a= 34, d= 33 (n= 73,q= 48) | 9___ | apple terminal
lat i= 35.1 +/- 2.5, a= 34, d= 32 (n= 35,q= 52) | 9_ | apple terminal vim
lat i= 50.4 +/- 3.9, a= 50, d= 49 (n= 60,q=269) | _59 | alacritty
lat i= 36.1 +/- 5.6, a= 35, d= 34 (n= 78,q=199) | 9__ | kitty
```
Как его сделать
===============
Вот список деталей, которые я использовал:
* **$12**: [Teensy LC](https://www.pjrc.com/teensy/teensyLC.html) или любой другой микроконтроллер Teensy 3+. Можете взять Arduino, но USB-библиотека Teensy опрашивает плату на частоте 1000 Гц (задержка 1 мс), в то время как большинство USB-устройств по умолчанию работают на частоте 125 Гц (дополнительные 8 мс случайной задержки в ваших измерениях). Впрочем, можете использовать любой микроконтроллер на 1000 Гц. Если не хотите припаивать пины, купите плату с уже припаянными, такой Teensy 3 стоит подороже.
* **$12**: [модуль оптического датчика](https://www.amazon.com/gp/product/B01N1FKS4L/) (Amazon предлагает пакет из десяти штук, я использовал только один). Можете изготовить собственную схему, но эти модули экономят кучу времени и легко подключаются к плате.
* **$13**: [штатив](https://www.amazon.com/gp/product/B07SBZRF6S/) для удерживания оптического датчика в стабильном положении возле экрана.
* Какая-нибудь кнопка/переключатель для запуска тестирования
* Провода для подключения оптического датчика, Teensy и кнопки
* Изолента для изготовления чёрного экрана, который ограничивает поле зрения датчика
* Кабель USB micro-B для подключения Teensy к компьютеру
Устройство можно собрать разными способами. Суть в том, что нужно просто каким-то образом подключить три провода (3V, заземление, аналоговый выход) от модуля оптического датчика к соответствующим пинам Teensy (3V, заземление и любой аналоговый пин). Самый простой способ сделать это, который даже не требует пайки, если вы купили Teensy с предварительно припаянными пинами — подключить три [провода с джамперами мама-мама](https://www.amazon.com/Uxcell-a16072600ux1043-Female-Jumper-Breadboard/dp/B01M1CDI7M/). Затем просто нужен какой-то переключатель, чтобы запустить тест. Тут один пин на Teensy подключается к земле, а другой к пину цифрового ввода-вывода. Если вы действительно ленивы, достаточно прикосновения двух проводов!
Чтобы убедиться, что модуль оптического датчика видит только ограниченную область экрана, я завернул его в маленький цилиндр из изоленты — и аккуратно отрезал конец ножницами. Получилось маленькое круглое окошко, которое можно прижать к экрану штативом, чтобы свести к минимуму внешние помехи и получить самый чистый сигнал.
Я уже раньше делал [корпус для педали](https://twitter.com/trishume/status/950585012700684288) с Teensy LC и небольшой платой внутри, и у него сбоку был дополнительный [разъём TRRS](https://www.cablechick.com.au/blog/understanding-trrs-and-audio-jacks/), который я специально поставил, ожидая в будущем подобного проекта, где он понадобится. Поэтому оставалось припаять оптический датчик к TRRS-кабелю. Тогда для управления тестированием можно использовать одну из моих педалей!
С пайкой мне повезло, потому что для одного проекта я как раз купил магнитные ручки, который можно использовать и в процессе пайки. К сожалению, выяснилось, что на самом деле у меня не так много больших кусков металла, на которые они могут прикрепиться, поэтому в конечном итоге для пайки я взял чугунную сковороду, а для операций на столе — [свой вольфрамовый кубик](https://thume.ca/2019/03/03/my-tungsten-cube/) (оказалось, что он слегка магнитится).
Предлагаю вам проявить фантазию и сделать что-нибудь более интересное, чем просто болтающиеся соединительные провода. Для своей педали я купил в местном магазине электроники пластиковую коробку, просверлил несколько отверстий по бокам, вставил аудиоразъёмы и поставил небольшую макетную плату, чтобы перенастраивать подключения. На Amazon куча педалей для татуировочных машин и электрических пианино с телефонными разъёмами 1/4”, можете выбрать из них. [Вот](https://www.amazon.com/Casio-SP3-SP-3-Sustain-Pedal/dp/B00070E8I8/) мои любимые по тишине и тактильным ощущениям. Но есть более дешёвые варианты, которые могут быть ненадёжными, трудно нажиматься или неприятно шуметь.
Я бы не рекомендовал использовать для сенсорного модуля гнездо TRRS по моему примеру. Хотя оно хорошее и компактное и для него много доступных кабелей, но позже оказалось, что из-за него слишком часто закорачиваются разные соединения при подключении и отключении питания. Я попытался свести это к минимуму, разведя питание и заземление по противоположным концам платы, но вам советую взять кабель какого-нибудь более лучшего типа, может, [телефонный](https://en.wikipedia.org/wiki/Registered_jack).
Прошивка
========
Для определения начала и конца вывода символа на экран у меня не самая изысканная прошивка, но я потратил некоторое время на настройку, чтобы она хорошо работала, и добавил различные функции, поэтому рекомендую начать с неё. Установите [Teensyduino](https://www.pjrc.com/teensy/teensyduino.html), затем можете загрузить мой [скетч Arduino](https://gist.github.com/trishume/bbdae75792d2888708a01d5625fa9229), который работает для педали — но вы можете закомментировать ненужные фрагменты и настроить его на использование правильных контактов. Затем всё просто — долгое нажатие на кнопку запускает измерения, а короткое нажатие выводит результаты! | https://habr.com/ru/post/505260/ | null | ru | null |
# Возможно ли без Redux?
На сегодняшний день можно найти уйму позиций, где требуется react/redux. React прекрасен, вопросов нет. Вопрос к Redux — возможно ли без него. Если погуглить чуть-чуть, найдется добротная [статья на Хабре](https://habr.com/ru/post/350850/), где автор задается таким же вопросом. В статье на простом примере (todoList) метод this.updateViews() вызывается слишком часто (семь-восемь раз) и кажется, что можно сделать проще.
Основная идея тут observable models, react отвечает за observable, дело осталось за малым — создать model.
Перед созданием модели пару слов о дизайне (архитектуре) клиента:
index — raw data
history — array[model]
observer — model
view — errors, focus, flags
index.jsx — точка входа программы для экрана пользователя. Index отрисовывает все компоненты с данными по умолчанию, делает асинхронные запросы, перерисовывает компоненты с новыми данными.
```
// index.jsx
```
Observer.jsx отвечает за синхронизацию модели для нескольких views. Например, Петя заполняет форму для оффера и в шапке страницы видит real-time preview. Observer хранит объект модели, предоставляя дочерним компонентам api: onModelChange(field, value).
History.jsx — это stack объектов модели, где api: commit и rollback.
Model.js — это то, что пользователь может ввести ручками,— то есть самое ценное. Другие данные в модели хранить не нужно. Model — это не react компонент, а обычный js class.
```
class Model {
constructor(other = {}) {} // copy constructor (and default too)
isEqual(other) {} // operator ==
less(other) {} // operator<
swap(other) {}
hash() {}
fieldNameConstrains() {} //see below please
}
```
Конструктор копирования как минимум нужен для History. Метод isEqual — для popup-unsaved-changes (что гораздо удобнее флага в state). Метод fieldNameConstrains — для зависимых полей.
Грубо говоря, если есть зависимые поля, их нужно изменять всем скопом.
```
class Model {
// constrains
// distance <== velocity * time
velocityConstrains(newVelocity) {
this.velocity = newVelocity;
this.distance = this.velocity * this.time;
}
timeConstrains(newTime) { … }
distanceConstrains(newDistance) {
this.distance = newDistance;
this.time = this.distance / this.velocity;
}
}
```
По личному опыту, что-то типа model.field.onchange не работает, так как иногда нужно вызвать конструктор копирования и onchange события совсем не нужны.
View.jsx
```
class View extends React.Component {
state = {
errors: {},
focus: {},
…
}
render() {
…
this.props.onModelChange(‘title’, e.target.value)} />
…
}
}
```
Валидация. Валидацию не нужно делать в модели. Ее нужно проводить во view (не забываем, что view это экран пользователя и что на экране может быть показана не вся модель). Валидаторы это набор предикатов. Для валидации есть всего два алгоритма: 1) находим все ошибки в форме или 2) находим первую ошибку. Например,
```
class View extends React.Component {
onClickSaveButton() {
const mapper = {
title: () => model.title.length && !maxLenValidator(model.title, 25),
price: () => !(model.price % 40 == 0),
url: () => !urlValidator(model.url),
…
}
const errors = map(mapper, (validator, key) => {
return validator() ? key : undefined;
}).filter(Boolean);
}
// валидаторы легко тестировать и легко переиспользовать
```
Права доступа. Тут главное удержаться и не использовать наследование. Идея такая, что модель содержит все поля и мы урезаем поля под роли. То есть это whitelist, остальные поля в модели остаются по умолчанию. Для валидации добавляется один шаг — делаем проекцию объекта валидации (он же mapper, см. выше), то есть валидируем только нужные поля.
О продакшне. Данный подход крутится в продакшне уже год — это интерфейс для создания рекламных кампаний, включая баннеры. Формы разной сложности — начиная от одной модели на экран, заканчивая множеством моделей разных типов. Тут можно добавить, что бэкенд любит присылать вложенные структуры, нужно не стесняться и хранить только плоские структуры во view.
O методе модели isEqual. Где-нибудь в utils.js будут методы isEqual и isEqualArray:
```
function isEqual(left, right) {
return left.isEqual(right);
}
isEqualArray(v1, v2) {
if (v1.length !== v2.length) { return false }
for (var k = 0; k != v1.length; k++) {
if (!isEqual(v1[k], v2[k])) { return false; }
}
return true;
}
```
Нужно стараться не делать модели вложенными. Не забываем, что модель — это данные пользователя, а не структура данных.
Ссылки:
→ [Раз](https://parasol.tamu.edu/~jarvi/papers/gpce08.pdf)
→ [Два](https://stlab.cc/tips/about-mvc.html) | https://habr.com/ru/post/455176/ | null | ru | null |
# Прикладное применение задачи нелинейного программирования
Доброго времени суток, Хабр! В свое время, будучи студентом младших курсов, я начал заниматься научно-исследовательской работой в области теории оптимизации и синтеза оптимальных нелинейных динамических систем. Примерно в то же время появилось желание популяризировать данную область, делиться своими наработками и мыслями с людьми. Подтверждением этому служит пара-тройка моих ~~детских~~ незрелых статей на Хабре. Тем не менее, на тот момент эта идея оказалась для меня непосильной. Возможно ввиду моей занятости, неопытности, неумения работать с критикой и советами или чего-то еще. Можно до бесконечности пытаться найти причину, но ситуацию это не изменит: я забросил эту идею на полку, где она благополучно лежала и пылилась до этого момента.
Закончив специалитет и готовясь к защите кандидатской диссертации, я задался вполне логичным вопросом: «а что же дальше?» Имея за плечами опыт как обычной работы, так и исследовательской, я вновь вернулся к той самой идее, которая, казалось бы, должна была утонуть под толщей пыли. Но вернулся я к этой идее в более осознанной форме.
Я решил заняться разработкой программного обеспечения, связанного с той отраслью, которой занимаюсь уже на протяжении 8 лет, и моими личными академическими пристрастиями, которые включают в себя методы оптимизации и машинное обучение.
Ну что ж, всем заинтересовавшимся:
Занимаясь реализацией программного обеспечения для своего диплома (и впоследствии диссертации), я подходил к этому вопросу «в лоб»: меня не волновало, насколько создаваемая система будет гибкой, как легко она будет модифицируема. Желание получить результат здесь и сейчас вкупе с неопытностью приводили к тому, что код постоянно приходилось переписывать, что, конечно же, не влияло положительно на профессиональное развитие. Уже сейчас я понимаю, что, как бы ни хотелось, нельзя сломя голову бросаться решать задачу. Надо вникнуть в ее суть, оценить имеющиеся знания, понять, чего недостает, сопоставить понятия предметной области классам, интерфейсам и абстракциям. Словом, нужно осознать имеющиеся резервы и грамотно подойти к проектированию архитектуры программного приложения.
Как вы уже догадались, эта статья будет посвящена разработке и описанию первых элементов будущего приложения.
### **Определение подхода к разработке и формулировка основной задачи**
На Хабре есть большое количество статей, посвященных методологиям разработки ПО. Например, в [этой](https://habrahabr.ru/company/edison/blog/269789/) достаточно понятно описаны основные подходы. Остановимся подробнее на каждом из них:
1. **«Waterfall Model»** — не подходит по причине как минимум того, что четко определенных требований у меня нет, есть лишь набор идей, между которыми придется впоследствии наладить взаимодействие,
2. **«V-Model»** — не подходит по той же причине,
3. **«Incremental Model»** — более подходящая по сравнению с предыдущими модель, однако тут так же требуется подробная формализация
4. **«RAD Model»** — модель, которая больше подходит команде опытных специалистов,
5. **«Agile Model»** — отлично подходит по критерию отсутствия необходимости конкретизации требований, а также по гибкости в процессе разработки,
6. **«Iterative Model»** — несмотря на то что в работе указана необходимость четкого определения целей, идейно такая модель кажется близкой (учитывая слова «Основная задача должна быть определена, но детали реализации могут эволюционировать с течением времени»),
7. **«Spiral Model»** — направлена для реализации больших проектов, к которым вряд ли можно отнести предполагаемое ПО.
Я буду стараться придерживаться концепций модели «Agile». На каждую итерацию разработки будет предлагаться определенный набор целей и задач, которые будут подробнее освещаться в статьях.
Итак, на данный момент имеется следующая формулировка общей задачи: разрабатываемое программное обеспечение, должно реализовывать различные алгоритмы оптимизации (как и классические аналитические, так и современные эвристические) и машинного обучения (алгоритмы классификации, кластеризации, редукции размерности пространства, регрессии). Итоговой финальной целью является разработка методик применения данных алгоритмов в области синтеза оптимального управления и создания торговых стратегий на финансовых рынках. В качестве основного языка для разработки был выбран Scala.
Итак, в этой работе я расскажу:
1. О задаче оптимизации и причинах ее выбора в качестве основополагающего объекта изучения,
2. Об основных абстракциях и их реализациях, которые позволят использовать подход, основывающийся на решении прикладных задач путем сведения к задаче оптимизации,
3. Об алгоритме K-Means, простейшем алгоритме Random Search и как заставить их дружить и работать на благо единой цели.
### **Оптимизация**
Вследствие того что большую часть своей исследовательской практики я посвятил решениям задачи оптимизации, мне будет удобней оперировать именно с этой точки зрения.
Обычно под решением задачи оптимизации, как бы это банально и косноязычно ни звучало, понимается поиск некоторого «оптимального» (с точки зрения условий задачи) объекта. Понятия «оптимальности» варьируются от одной предметной области к другой. Например, в задаче поиска минимума функции требуется найти точку, которой соответствует наименьшее значение целевой функции, в задача мета-оптимизации требуется определить параметры алгоритма, при которых он дает наиболее точный результат/наиболее быстро отрабатывает/дает наиболее стабильный результат, в задаче синтеза оптимального управления требуется синтезировать контроллер, позволяющий перевести объект в терминальное состояние за наименьшее время и т.д. Уверен, что каждый специалист сможет продолжить это список задачами, связанными с его профессиональной сферой.
В математике, особое внимание уделяется задаче [нелинейного программирования](https://ru.wikipedia.org/wiki/%D0%9D%D0%B5%D0%BB%D0%B8%D0%BD%D0%B5%D0%B9%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5), к которой можно свести большое количество других прикладных задач. В общем случае, для постановки задачи нелинейного программирования требуется задать:
* произвольную функцию  (она выполняет роль некоторого критерия качества: для задач минимизации требуется найти вектор, которому соответствует наименьшее значение, для максимизации — наоборот),
* набор ограничений, которые по сути определяют область допустимых значений  аргумента  оптимизируемой функции.
Таким образом, суть данной задачи можно описать следующим образом: требуется найти в области поиска вектор, обеспечивающий минимальное/максимальное значение целевой функции.
Существует огромное количество алгоритмов решения этой задачи. Условно их можно разделить на две группы:
* **аналитические алгоритмы:**
+ имеют более узкий круг решаемых задач в связи с тем, что могут накладывать ограничения на компоненты задачи,
+ могут вводить в задачу объекты более высокого уровня (например, производные определенного порядка),
+ несомненным достоинством таких методов является то, что по большей части они позволяют гарантированно получить результат определенной точности.
* **эвристические алгоритмы:**
+ отсутствует свойство гарантированности вычислений, т.е. нельзя быть уверенным в том, что полученное решение попало хотя бы в область притяжения [локального экстремума](https://ru.wikipedia.org/wiki/%D0%AD%D0%BA%D1%81%D1%82%D1%80%D0%B5%D0%BC%D1%83%D0%BC),
+ имеют меньшую вычислительную сложность, что дает возможность их применения с целью получения практически приемлемого результата за приемлемое время (например, на задачах большой размерности, когда получение ответа с помощью аналитического алгоритма может занять сутки).
В принципе, эвристические алгоритмы можно воспринимать как способ направленного перебора. В этой группе вы можете обнаружить достаточно известные [генетические алгоритмы](https://habrahabr.ru/post/128704/), [алгоритм симуляции отжига](https://habrahabr.ru/post/112189/), различные [популяционные](https://en.wikipedia.org/wiki/Fish_School_Search) алгоритмы. Большое количество алгоритмов объясняется достаточно просто: нет универсального алгоритма, который был бы хорош одновременно для всех типов задач. Кто-то лучше справляется с выпуклыми функциями, другой направлен на работу с функциями, обладающими овражной структурой линий уровня, третий специализируется на многоэкстремальных функциях. Как и в жизни — у всего есть своя специализация.
### **Используемые абстракции**
На основе приведенных ранее рассуждений мне кажется, что проще всего работать с двумя понятиями: **преобразование** и **алгоритм**. На них и остановимся подробнее.
#### **Преобразования (Transformations)**
Вследствие того что почти любую процедуру/функцию/алгоритм можно рассматривать как некоторое преобразование, будем оперировать с этим объектом как с одним из базовых.
Предлагается следующая иерархия между различными типами преобразований:
Остановимся на элементах поподробнее:
* Неоднородное преобразование (Inhomogeneous Transformation) — самый общий вид преобразования, когда классы входного и выходного объекта могут быть различными,
* Однородное преобразование (Homogeneous Transformation) — частный вид неоднородного преобразования, когда классы входного и выходного объекта одинаковые,
* Векторная функция (Vector Function) — преобразование, которой трансформирует вектор, состоящий из элементов множества A, в другой вектор, состоящий из элементов того же множества,
* Функция (Function) — аналогична векторной функции (за исключением того, что выходной элемент теперь является скаляром),
* Метрика (Metric) — некоторое оценивающее преобразование, ставящее в соответствие объекту числовое значение.
**Код класса неоднородного преобразования**
```
class InhomogeneousTransformation[A, B](transform: A => B) extends Serializable {
def apply(a: A): B = transform(a)
def *[C](f: InhomogeneousTransformation[B, C]) =
new InhomogeneousTransformation[A, C](x => f(transform(x)))
}
```
Видно, что он содержит всего два метода, один из которых реализует процедуру составления [композиции](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BC%D0%BF%D0%BE%D0%B7%D0%B8%D1%86%D0%B8%D1%8F_%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%B9) нескольких преобразований (только в не совсем привычном порядке). Это в дальнейшем понадобится для создания более сложных преобразований из простых.
**Код класса однородного преобразования**
```
class HomogeneousTransformation[A](transform: A => A)
extends InhomogeneousTransformation[A, A](transform) { }
```
Здесь два параметра типа были свернуты в один.
**Код класса векторной функции**
```
class VectorFunction[A <: Algebra[A]]
(transform: Vector[A] => Vector[A])(implicit converter: Double => A)
extends HomogeneousTransformation[Vector[A]](transform) { }
```
Налицо измененная параметризация обобщенного класса. Теперь данный параметр определяет то, из объектов какого класса будет состоять преобразуемый вектор. Следует отметить ограничение, накладываемое на класс, что определяется данным кодом "[A <: Algebra[A]]". Ограничение выражается в следующем: объекты, из которых составляется вектор, должны поддерживать основные арифметические операции и их можно использовать как аргумент привычных элементарных функций (показательных, тригонометрических и т.п.). Подробный код можно будет посмотреть на исходниках, которые выложены на github'e (ссылка будет в конце работы).
**Коды класса Function и способа его неявного приведения к неоднородному преобразованию**
```
class Function[A <: Algebra[A]]
(transform: Vector[A] => A)(implicit converter: Double => A)
extends VectorFunction[A](x => Vector("result" -> transform(x))) {
def calculate(v: Vector[A]): A = transform(v)
}
object Function {
implicit def createFromInhomogeneousTransformation[A <: Algebra[A]]
(transformation: InhomogeneousTransformation[Vector[A], A])(implicit converter: Double => A) =
new Function[A](x => transformation(x))
}
```
**Код класса метрики и соответствующие преобразования**
```
class Metric[A](transform: A => Real)
extends InhomogeneousTransformation[A, Real](transform) { }
object Metric {
implicit def createFromInhomogeneousTransformation[A](transformation: InhomogeneousTransformation[A, Real]) =
new Metric[A](x => transformation(x))
implicit def toFunction
(metric: Metric[Vector[Real]])(implicit converter: Double => Real): Function[Real] =
new Function[Real](x => metric(x))
}
```
Приведенные абстракции, на первый взгляд, охватывают основные типы преобразований, который могут понадобится для дальнейших формулировок задач.
#### **Алгоритм**
Я думаю, что естественным будет определить алгоритм как набор трех операций: инициализация, итеративная часть и терминация. На вход алгоритма подается некоторое **задание (Task)**. В ходе инициализации происходит генерация начального **состояния (State)** алгоритма, которое модифицируется в ходе повторения итеративной части. В конце с помощью процедуры терминации из последнего **состояния** алгоритма создается объект, соответствующий **типу R выходного параметра** алгоритма.
**Код класса алгоритм**
```
trait GeneralAlgorithm[T <: GeneralTask, S <: GeneralState, R] {
def initializeRandomly(task: T): S
def initializeFromSeed(task: T, seed: S): S
final def initialize(task: T, state: Option[S]): S = {
state match {
case None => initializeRandomly(task)
case Some(seed) => initializeFromSeed(task, seed)
}
}
def iterate(task: T, state: S): S
def terminate(task: T, state: S): R
def prepareFolder(log: Option[String]): Unit = {
if (log.isDefined) {
val temp = new File(log.get)
if (!temp.exists() || !temp.isDirectory())
temp.mkdir()
else {
if (temp.exists() && temp.isDirectory()) {
def prepare(file: File): Unit =
if (file.isDirectory()) {
file.listFiles.foreach(prepare)
file.delete()
}
else file.delete()
prepare(temp)
}
}
}
}
def logState(log: Option[String], state: S, fileId: Int): Unit = {
log match {
case Some(fileName) => {
val writer = new ObjectOutputStream(new FileOutputStream(s"${fileName}/${fileId}.st"))
writer.writeObject(state)
writer.close()
}
case None => ()
}
}
final def work(task: T, terminationRule: S => Boolean, seed: Option[S] = None, log: Option[String] = None): R = {
prepareFolder(log)
var currentState = initialize(task, seed)
var id = 0
logState(log, currentState, id)
val startTime = System.nanoTime()
while (!terminationRule(currentState)) {
currentState = iterate(task, currentState)
id = id + 1
currentState.id = id
currentState.timestamp = 1e-9 * (System.nanoTime() - startTime)
logState(log, currentState, id)
}
terminate(task, currentState)
}
}
```
Таким образом, для создания конкретного алгоритма, необходимо будет переопределить три описанные ранее процедуры.
**Что представляет из себя алгоритм оптимизации?**Из предыдущего описания задачи нелинейного программирования ясно, что **задание (Task)** для алгоритма оптимизации состоит из функции и области поиска (пока ограничимся простым случаем, когда область поиска задается многомерным параллелепипедом).
```
case class OptimizationTask[A <: Algebra[A]](f: Function[A], searchArea: Map[String, (Double, Double)]) extends GeneralTask {
def apply(v: Vector[A]): A = f.calculate(v)
}
```
Обычно **состояния (State)** у алгоритмов оптимизации имеют одну из следующих форм: одноточечную (когда в ходе работы анализируется и модифицируется один вектор) или популяционная/многоточечная (когда в ходе работы анализируются и модифицируются несколько векторов).
```
abstract class OptimizationState[A <: Algebra[A]] extends GeneralState {
def getCurrentBest(optimizationTask: OptimizationTask[A])(implicit cmp: Ordering[A]): Vector[A]
}
class MultiPointOptimizationState[A <: Algebra[A]](points: Seq[Vector[A]]) extends OptimizationState[A] {
override def toString: String = {
s"ID: ${id}\n" +
s"Timestamp: ${timestamp}\n" +
points.zipWithIndex.map{ case (point, id) => s"# ${id}\n${point}\n"}.mkString("\n")
}
override def getCurrentBest(optimizationTask: OptimizationTask[A])(implicit cmp: Ordering[A]): Vector[A] =
points.minBy(point => optimizationTask(point))
def apply(id: Int): Vector[A] = points(id)
def size: Int = points.size
}
class OnePointOptimizationState[A <: Algebra[A]](point: Vector[A]) extends MultiPointOptimizationState(points = Seq(point)) {
override def getCurrentBest(optimizationTask: OptimizationTask[A])(implicit cmp: Ordering[A]): Vector[A] = point
def apply(): Vector[A] = point
}
```
Таким образом, оптимизационный алгоритм описывается следующим кодом:
```
abstract class OptimizationAlgorithm[A <: Algebra[A], S <: OptimizationState[A]]
extends GeneralAlgorithm[OptimizationTask[A], S, Vector[A]] { }
```
### **K-Means VS. Random Search**
Что ж, первые два пункта обещанной программы освещены, пора переходить к третьему.
Оба алгоритма хорошо описаны в различных источниках, поэтому я думаю, что у читателей не составит труда разобраться с ними. Вместо этого я проведу параллели к описанным ранее абстракциям.
**Алгоритм K-Means**Задание для алгоритма K-Means однозначно можно определить как набор точек для кластеризации и требуемое количество кластеров.
```
class Task(val vectors: Seq[Vector[Real]], val numberOfCentroids: Int) extends GeneralTask {
def apply(id: Int): Vector[Real] = vectors(id)
def size: Int = vectors.size
def toOptimizationTask(): (OptimizationTask[Real], InhomogeneousTransformation[Vector[Real], kCentroidsClusterization]) = {
val varNames = vectors.head.components.keys.toSeq
val values = vectors.flatMap(_.components.toSeq)
val searchAreaPerName =
varNames.map { name =>
val accordingValues =
values
.filter(_._1 == name)
.map(_._2.value)
(name, (accordingValues.min, accordingValues.max))
}
val totalSearchArea =
Range(0, numberOfCentroids)
.flatMap { centroidId =>
searchAreaPerName
.map { case (varName, area) => (s"${varName}_${centroidId}", area) }
}.toMap
val varNamesForCentroids =
Range(0, numberOfCentroids)
.map { centroidId => (centroidId, varNames.map { varName => s"${varName}_${centroidId}" }) }
.toMap
val splitVector: InhomogeneousTransformation[Vector[Real], Map[Int, Vector[Real]]] =
new InhomogeneousTransformation(
v =>
Range(0, numberOfCentroids)
.map { centroidId =>
(centroidId,
Vector(v(varNamesForCentroids(centroidId))
.components
.map { case (key, value) => (key.dropRight(1 + centroidId.toString.length), value) }))
}.toMap)
val vectorsToClusterization: InhomogeneousTransformation[Map[Int, Vector[Real]], kCentroidsClusterization] =
new InhomogeneousTransformation(v => new kCentroidsClusterization(v))
val clusterizationForMetric: InhomogeneousTransformation[kCentroidsClusterization, (kCentroidsClusterization, Seq[Vector[Real]])] =
new InhomogeneousTransformation(clusterization => (clusterization, vectors))
val quality: Metric[Vector[Real]] = splitVector * vectorsToClusterization * clusterizationForMetric * SquareDeviationSumMetric
(new OptimizationTask(f = quality, searchArea = totalSearchArea), splitVector * vectorsToClusterization)
}
}
```
Здесь следует обратить внимание на две строки:
```
val quality: Metric[Vector[Real]] = splitVector * vectorsToClusterization * clusterizationForMetric * SquareDeviationSumMetric
(new OptimizationTask(f = quality, searchArea = totalSearchArea), splitVector * vectorsToClusterization)
```
В первой из них строится композиция преобразований: вектор разбивается на систему векторов, описывающие центроиды, центроиды преобразуются в кластеризатор, кластеризатор оценивается по метрике «суммарное расстояние точек кластеров от соответствующих центроид» . Полученная композиция преобразований в дальнейшем может рассматриваться как целевая функция для задачи оптимизации.
**Алгоритм случайного поиска**Простейшее описание алгоритма случайного поиска можно посмотреть на [википедии](https://en.wikipedia.org/wiki/Random_optimization). Отличия в реализованной версии заключаются в том, что генерируется не одна точка из текущей, а несколько, а также вместо нормального распределения используется равномерное.
Кластеризатор, построенный с помощью алгоритма K-Means однозначно определяется своими центроидами. Сам алгоритм K-Means представляет собой постоянную замену текущих центроид новыми центроидами, рассчитанными как среднее значение всех векторов в отдельно взятых кластерах. Таким образом, в любой момент времени состояние алгоритма K-Means можно представить как набор векторов.
Таким образом, кластеризатор может быть построен либо напрямую с помощью алгоритма K-Means, либо с помощью решения задачи поиска оптимального кластеризатора, обеспечивающего минимум суммарного расстояния точек кластеров от соответствующих центроид.
Сгенерируем несколько синтетических наборов данных размерности 2, 3 и 5.
**Код генерации данных****Генерация нормально распределенной случайной величины**
```
f[mu_, sigma_, N_] :=
RandomVariate[#, N] & /@ MapThread[NormalDistribution, {mu, sigma}] //
Transpose
```
**2D**
```
Num = 100;
sigma = 0.1;
data2D = Join[
f[{0.5, 0}, {sigma, sigma}, Num],
f[{-0.5, 0}, {sigma, sigma}, Num]
];
ListPlot[data2D]
Export[NotebookDirectory[] <> "data2D.csv", data2D, "CSV"];
```
**3D (проекция на двумерное пространство с помощью t-SNE)**
```
Num = 100;
mu1 = 0.0; sigma1 = 0.1;
mu2 = 2.0; sigma2 = 0.2;
mu3 = 5.0; sigma3 = 0.3;
data3D = Join[
f[{mu1, mu1, mu1}, {sigma1, sigma1, sigma1}, Num],
f[{mu2, mu2, mu2}, {sigma2, sigma2, sigma2}, Num],
f[{mu3, mu3, mu3}, {sigma3, sigma3, sigma3}, Num]
];
dimReducer = DimensionReduction[data3D, Method -> "TSNE"];
ListPlot[dimReducer[data3D]]
Export[NotebookDirectory[] <> "data3D.csv", data3D, "CSV"];
```
**5D (проекция на двумерное пространство с помощью t-SNE)**
```
Num = 250;
mu1 = -2.5; sigma1 = 0.9;
mu2 = 0.0; sigma2 = 1.5;
mu3 = 2.5; sigma3 = 0.9;
data5D = Join[
f[{mu1, mu1, mu1, mu1, mu1}, {sigma1, sigma1, sigma1, sigma1,
sigma1}, Num],
f[{mu2, mu2, mu2, mu2, mu2}, {sigma2, sigma2, sigma2, sigma2,
sigma2}, Num],
f[{mu3, mu3, mu3, mu3, mu3}, {sigma3, sigma3, sigma3, sigma3,
sigma3}, Num]
];
dimReducer = DimensionReduction[data5D, Method -> "TSNE"];
ListPlot[dimReducer[data5D]]
Export[NotebookDirectory[] <> "data5D.csv", data5D, "CSV"];
```
И «прогоним» их через оба алгоритма построение кластеризатора. Полученные результаты сведем в таблицу:
| | 2D | 3D | 5D |
| --- | --- | --- | --- |
| Clusterization Quality (via K-Means): | 90.30318857796479 | 96.48947132305597 | 1761.3743823022821 |
| Clusterization Quality (via Optimization): | 87.42370021528419 | 96.4552486768293 | 1760.993575500699 |
**Результаты работы кластеризатора****2D**
**3D (проекция на двумерное пространство с помощью t-SNE)**
**5D (проекция на двумерное пространство с помощью t-SNE)**
По таблице видно, что даже несложный алгоритм оптимизации может успешно решить задачу построения простейшего кластеризатора. При этом созданный кластеризатор будет оптимальным (а если честно, то субоптимальным, так как используемый метод оптимизации не гарантирует нахождение точки [глобального оптимума](https://ru.wikipedia.org/wiki/%D0%AD%D0%BA%D1%81%D1%82%D1%80%D0%B5%D0%BC%D1%83%D0%BC)) с точки зрения используемой метрики качества. Естественно, для задач большей размерности используемый алгоритм оптимизации уже вряд ли подойдет (тут лучше пользоваться более сложными и эффективными алгоритмами, основывающимися на нескольких эвристиках разного уровня). Для небольшой же синтетической задачи Random Search справился достаточно хорошо.
### **Вместо послесловия**
Хочется поблагодарить всех, кто прочитал статью, отписался в комментариях. Словом, всех, кто внес свой вклад в создание данной работы. Наверное, следует сразу отметить, что статьи на эту тематику будут появляться по мере возможностей и моей текущей загруженности. Но мне хочется сказать, что на этот раз я постараюсь довести начатое мной дело до конца.
**Ссылки и литература**
* [Код проекта](https://github.com/wol4aravio/Kaimere/tree/7aa7b634983c3410e99dab3b0b0c4919c31ba54a),
* [Код для генерации/визуализации](https://github.com/wol4aravio/Habrahabr-Article-1),
* K-means: [[1](https://ru.wikipedia.org/wiki/K-means)], [[2](https://en.wikipedia.org/wiki/K-means_clustering)], [[3](http://projecteuclid.org/euclid.bsmsp/1200512992)], [[4](https://habrahabr.ru/post/67078/)]
* Random Search: [[1](https://en.wikipedia.org/wiki/Random_optimization)], [[2](https://books.google.ru/books?id=y4JUSgAACAAJ&dq=%D0%BF%D0%B0%D0%BD%D1%82%D0%B5%D0%BB%D0%B5%D0%B5%D0%B2+%D0%BB%D0%B5%D1%82%D0%BE%D0%B2%D0%B0+%D0%BC%D0%B5%D1%82%D0%BE%D0%B4%D1%8B+%D0%BE%D0%BF%D1%82%D0%B8%D0%BC%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B8+%D0%B2+%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80%D0%B0%D1%85+%D0%B8+%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D0%B0%D1%85&hl=en&sa=X&redir_esc=y)], [[3](http://www.springer.com/us/book/9781441916631)],
* Scala: [[1](https://books.google.ru/books?id=RIn-oAEACAAJ&dq=learning+scala&hl=en&sa=X&ved=0ahUKEwjJub6b1enTAhWrHJoKHfeVC9kQ6AEILDAB)], [[2](https://books.google.ru/books?id=xVU2AAAAQBAJ&printsec=frontcover&dq=learning+scala&hl=en&sa=X&ved=0ahUKEwjJub6b1enTAhWrHJoKHfeVC9kQ6AEIXTAJ)]. | https://habr.com/ru/post/328198/ | null | ru | null |
# Немного о Steam Web Api
Сервис цифровой дистрибуции Steam от компании Valve становится всё более популярным среди игроков. По состоянию на январь 2013, через Steam распространяется более трёх тысяч товаров, на которые действуют ежедневные, срединедельные и скидки на выходные дни, а количество зарегистрированных аккаунтов превысило 60 миллионов.
В настоящее время, в рунете очень мало информации об использовании Steam Api *(или же Steam Web Api)*. В данном топике я расскажу о том, как получать нужную вам информацию из сообщества Steam для интеграции её в свои сайты, блоги или же просто получить информацию о пользователе, не заходя в Steam.
Начнем с главного. После несложных действий, я создал одну php страницу, которая, по запросу *имени пользователя*, либо *SteamID* или *SteamcommunityID*, выводит множество подробной информации о профиле Steam. Информации там намного больше, чем предоставляют аналогичные англоязычные сервисы.
Посмотреть работу страницы можно [здесь](http://heavenanvil.ru/). При желании, можно существенно доработать сервис, например добавить возможность определить, какие игры есть на аккаунте конкретного пользователя, и сколько они стоят *(как когда-то делал [steamcalculator](http://steamcalculator.com/))*.
Кому интересен исходный код моей страницы, алгоритм определения типа вводимых данных или алгоритм перебора одинаковых xml параметров, можете написать мне тут, или в контактной информации на той странице.
**Открываем капот Steam**
Информацию о пользователе Steam можно получить несколькими способами. Наиболее популярные из них, это:
— использовать именно Steam Web Api, который предлагают они нам сами *(но предоставленной информации там увы не много)*
— получать и обрабатывать данные сообщества напрямую, в формате xml.
— получать и обрабатывать данные сообщества напрямую, в формате json.
Первый способ мне не особо интересен, я пользовался сразу двумя оставшимися.
**XML**
Получить информацию о пользователе довольно просто. Достаточно лишь ввести в адресную строку браузера запрос в виде:
[steamcommunity.com/profiles](http://steamcommunity.com/profiles/)\*SteamID\*/?xml=1
Например:
[steamcommunity.com/profiles/76561198036370701/?xml=1](http://steamcommunity.com/profiles/76561198036370701/?xml=1)
*(к слову, если пользователь имеет CustomURL, то адрес ссылки изменится с "**.../profiles/\*SteamID\*/...**" на "**.../id/\*CustomURL\*/...**")*
Эту страницу можно ловить и обрабатывать при помощи **cURL** или *(что для меня проще)* функции **simplexml\_load\_file();**, например:
`$slf = "http://steamcommunity.com/profiles/76561198036370701/?xml=1";`
`$url = simplexml_load_file($slf);`
Теперь, чтобы вывести, например, содержимое тегов < steamID>...< /steamID>, в любом месте вашей страницы, можно использовать следующий код:
`php echo $url-steamID;?>`
**JSON**
Прежде всего вам понадобится **apikey**. Зарегистрировать его можно [здесь](http://steamcommunity.com/dev/apikey).
Получить суммарную информацию о пользователе Steam можно по ссылке вида:
[api.steampowered.com/ISteamUser/GetPlayerSummaries/v0002/?key=](http://api.steampowered.com/ISteamUser/GetPlayerSummaries/v0002/?key=)\*apikey\*&steamids=\*SteamID\*
Например:
[api.steampowered.com/ISteamUser/GetPlayerSummaries/v0002/?key=38A3BEAE3EFA726E4438207D08CB0EC7&steamids=76561198036370701](http://api.steampowered.com/ISteamUser/GetPlayerSummaries/v0002/?key=38A3BEAE3EFA726E4438207D08CB0EC7&steamids=76561198036370701)
Получать и обрабатывать эти данные можно командой **file\_get\_contents**, а в последствии сконвертировать всё в массив примерно вот таким способом:
`$urljson = file_get_contents("http://api.steampowered.com/ISteamUser/GetPlayerSummaries/v0002/?key=*apikey*&steamids=*steamid*");`
`$data = (array) json_decode($urljson)->response->players[0];`
Например:
`$urljson = file_get_contents("http://api.steampowered.com/ISteamUser/GetPlayerSummaries/v0002/?key=38A3BEAE3EFA726E4438207D08CB0EC7&steamids=76561198036370701");`
`$data = (array) json_decode($urljson)->response->players[0];`
А выводить, например содержимое блока **profileurl** строчкой кода:
`php echo $data['profileurl'];?`
**Подводим итог**
Методы получения информации о пользователе Steam не ограничиваются теми, что я привел. Те ссылки, которыми я получал данные используются только для получения суммарной *(общей)* информации. Отдельно можно получать список игр пользователя, список друзей, список групп, предметов инвентаря и мастерской и многое другое.
На основе полученных данных можно также сделать сервис генерации баннеров, юзербаров, профайлов для форумов и блогов, по аналогии с сервисом [steamprofile](http://steamprofile.com/).
Из недостатков работы сервиса можно выделить то, что в пик нагруженности серверов Steam, для получения информации о пользователе время запроса данных может колебаться от 0,1 до 12 секунд, а также часто втречается ошибка 503 (сервис недоступен), приходится отправлять запрос заново. Как вариант решения проблемы — не отправлять запрос чаще, чем раз в 10 секунд. Если у вас есть другие способы решения проблемы, пишите.
Некоторые ссылки, которые помогут в освоении Steam Web Api:
[steamcommunity.com/dev?l=russian](http://steamcommunity.com/dev?l=russian)
[partner.steamgames.com/documentation/webapi](https://partner.steamgames.com/documentation/webapi)
[developer.valvesoftware.com/wiki/Steam\_Web\_API](https://developer.valvesoftware.com/wiki/Steam_Web_API)
[steamcommunityapi.googlecode.com/svn-history/r5/trunk](http://steamcommunityapi.googlecode.com/svn-history/r5/trunk/) | https://habr.com/ru/post/172223/ | null | ru | null |
# Fugue-Icons — динамический Sprite
Для одного из проектов мне нужно было использовать набор простых иконок. Сначала я остановил свой выбор на популярный набор [Silk Icons](http://www.famfamfam.com/lab/icons/silk/) и его Sprite-плагин для Blueprint, но чем дальше я с ним работал, тем сильнее требовалось что-то большее. Иконок было маловато, ненужных гораздо больше, чем нужных, а подгружать приходилось все.
Далее мой выбор остановился на [Fugue Icons](http://p.yusukekamiyamane.com/). Я поискал в гугле что-либо для CSS и нашел два решения. Первое: каждая иконка отдельным файлом. Сразу нет, потому что при загрузке страницы это смотрится очень убого. Второе: несколько отдельных PNG со спрайтами и единый CSS. Все это дело весило 1.4 Мб, что никак не допустимо для среднестатистического сайта.
Посему было принято решение паковать Sprite с нужными иконками и писать для него CSS самому, однако это можно сделать единожды, но не каждый раз при каких-то изменениях на сайте, да и для новых проектов тоже было бы не лишним как-то упростить задачу.
Итак, я написал простой скрипт на Python, который автоматизирует задачу. От нас требуется только закинуть в каталог со скриптом нужную иконку и запустить скрипт на выполнение.
Исходник (mkicons.py) с комментариями:
```
#!/usr/bin/env python
#Импортируем все нужное. Из нестандартного только PIL
import Image
import glob
import os
ICON_WIDTH, ICON_HEIGHT = 16, 16 #Ширина и высота иконки (На случай использования скрипта для другого набора).
OUTPUT_DIR_NAME = 'sprite' #Каталог, в который будем сохранять готовые файлы
OUTPUT_SPRITE_PNG = 'sprite.png' #Имя файла со спрайтом
OUTPUT_SPRITE_CSS = 'sprite.css' #Имя CSS-файла
OUTPUT_SPRITE_HTML = 'test.html' #Имя HTML-файла для тестирования иконок
CSS_SPRITE_TEMPLATE = '.fg_%s{background-position:0px %spx}' #Шаблон для одной иконки в CSS
#Шаблон для одной иконки в тестовом HTML
HTML_SPRITE_TEMPLATE = '''
\'>
'''
#Исходное содержимое CSS-файла. Общий стиль для всех иконок
CSS_CONTENT='''
.fg_sprite{
display:inline;
overflow:hidden;
background-repeat:no-repeat;
background-image:url('../img/%s');
height:16px; width:16px; overflow:hidden; margin:-2px 3px 3px 0; padding: 0px;
display:-moz-inline-box;display:inline-block; vertical-align:middle;
}
''' % OUTPUT_SPRITE_PNG #Сразу подключаем png-шку со спрайтом
#Исходное содержимое HTML-файла. Между и будут вставляться иконки по одной
HTML_CONTENT = '''
input{width:400px;}
%s
'''
pngs = glob.glob('*.png') + glob.glob('*.PNG') #Выбираем все иконки к текущем каталоге
sprite_height = len(pngs)*ICON_HEIGHT #Считаем общую высоту всего спрайта
sprite = Image.new('RGBA', (ICON_WIDTH, sprite_height),(0,0,0,0)) #Создаем спрайт с прозрачным фоном. Высота и ширина уже известны
html_include='' #Будущий HTML для инклюда
#Обрабатываем каждую иконку в отдельности.
for idx,png in enumerate(pngs):
icon = Image.open(png) #Открываем иконку
offset = ICON_HEIGHT * idx #Будущее смещение по вертикали в спрайте
sprite.paste(icon,(0, offset)) #Вставляем в спрайт по смещению
spritename=png.replace('.png','').replace('.PNG','').replace('--','-') #Для CSS - убираем расширение и лишние тире
CSS_CONTENT+=CSS_SPRITE_TEMPLATE % (spritename,-offset) #Вставляем в CSS стиль для этой иконки
html_include+=HTML_SPRITE_TEMPLATE % {'spritename':spritename} #И в HTML
#Создаем каталоги для новых файлов, если их не существует
if not os.path.exists(OUTPUT_DIR_NAME):
os.makedirs(OUTPUT_DIR_NAME)
if not os.path.exists(os.path.join(OUTPUT_DIR_NAME, 'img')):
os.makedirs(os.path.join(OUTPUT_DIR_NAME, 'img'))
if not os.path.exists(os.path.join(OUTPUT_DIR_NAME, 'css')):
os.makedirs(os.path.join(OUTPUT_DIR_NAME, 'css'))
#И сохраняем файлы
sprite.save(os.path.join(OUTPUT_DIR_NAME, 'img', OUTPUT_SPRITE_PNG),'PNG')
cssfile = open(os.path.join(OUTPUT_DIR_NAME, 'css', OUTPUT_SPRITE_CSS),'w')
cssfile.write(CSS_CONTENT)
cssfile.close()
htmlfile = open(os.path.join(OUTPUT_DIR_NAME, OUTPUT_SPRITE_HTML),'w')
htmlfile.write(HTML_CONTENT % html_include)
htmlfile.close()
```
Работает так:
1. Создаем каталог для проекта
2. Кидаем туда файл mkicons.py (Исходник выше)
3. И нужные иконки из набора
4. Запускаем «python mkicons.py»
5. Идем в каталог «sprite» и забираем оттуда готовые файлы
6. Для просмотра и получения кода иконок открываем test.html
test.html выглядит так:
Вообще, я программирую на Django и чтобы избежать лишних телодвижений с копированием и вставкой получившихся файлов, я использую django-static. Просто указываю в STATICFILES\_DIRS каталог к этим файлам.
И еще, если кто-то пользуется Less, то вместо:
```
OUTPUT_SPRITE_CSS = 'sprite.css'
```
пишем:
```
OUTPUT_SPRITE_CSS = 'sprite.less'
```
А затем инклюдим:
```
@import "/path/to/fg-icons/sprite/css/sprite.less";
```
Вот вроде и все. Спасибо за внимание, буду рад выслушать ваши комментарии. | https://habr.com/ru/post/129546/ | null | ru | null |
# Как мы интегрировали и настроили для работы Conventional Commits в PHPStorm
Поднялся вопрос стандартизации коммитов в команде. До этого были такие правила, мы пишем номер задачи и через тире описание того, что было сделано кратко. Номер задачи берется из номера issue. Например: `#1 - реализован функционал сборки прода`. Но, это надоело и стало как-то неудобно, когда у нас есть четкое деление задач на фиксы, фичи и так далее.
Нашли [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) и попробовали его на тестовом репозитории, понравилось. Решили внедрить это в команду, но столкнулись с тем, что люди не всегда делают коммиты правильно, а значит нужна какая-то валидация.
В нашей команде принято по максимуму IDE и его возможности. То есть, коммиты мы делаем не через консоль, а через встроенные утилиты. Поэтому, сразу пошли искать плагины, которые есть в PHPStorm и нашли вот эти 2 важных плагина: [Conventional Commit](https://plugins.jetbrains.com/plugin/13389-conventional-commit) и [Git Commit Template](https://plugins.jetbrains.com/plugin/9861-git-commit-template). После их установки видим новые кнопки в окне коммита:
Первая - это от плагина Git Commit Template, а остальные от Conventional Commits. Если рассмотреть каждую из низ, то открываются следующие окна:
Окно создания коммита в Git Commit Template Окно создания коммита в Conventional CommitsОни очень походи, выбирайте сами то, что вам больше нравится. Результат обоих окно будет коммитом в нужном формате. Но, после создания коммита вы можете его руками изменить, что опять же может привести к нарушению стиля и правил коммитов. Здесь уже мы решили через `npm` поставить специальный хук, который будет перед созданием коммита проверять его.
Для решения задачи валидации нужно установить пакет `@commitlint/cli` и `husky`. Первый проверяет коммиты, а второй реализует клиентские хуки для `git`. Но тут мы столкнулись с проблемой проверки, так как у нас node стоит через nvm и PHPStorm отказывается это принимать, хотя в конфигах самого PHPStorm ссылки корректные. Возможно, тут кто-то еще не знает про это, но это уже не важно, так как мы решили данную проблему через скрипты npm.
В секцию **scripts** `package.json` нужно добавить установку самого **husky** и добавление хука на `commit-msg` в git:
```
{
"scripts": {
...
"prepare": "husky install && npx husky add .husky/commit-msg 'npx --no -- commitlint --edit ${1}'"
}
}
```
Эта часть реализует то, что было написано выше, но проблема с проверкой версии ноды при коммите через PHPStorm не решилась, хотя через терминал все работает корректно.
Долго читая документацию и разбирая скрипты, я понял, что в скрипте (создается после выполнения скрипт в prepare) `.husky/_/husky.sh` есть код:
```
if [ -f ~/.huskyrc ]; then
debug "sourcing ~/.huskyrc"
. ~/.huskyrc
fi
```
Он проверяет наличие файла **.huskyrc** в домашнем разделе пользователя UNIX систем. Если он есть, то смотрит то, что там написано. Как раз в этом файле можно явно указать где лежит **node** в системе.
Для автоматизации процесса для UNIX системы мы обновили секцию prepare и добавили туда создание этого файла в домашнюю директорию пользователя:
```
{
"scripts": {
...
"prepare": "husky install && npx husky add .husky/commit-msg 'npx --no -- commitlint --edit ${1}' && echo \"export PATH=\\\"$(dirname $(which node)):\\$PATH\\\"\" > ~/.huskyrc\n"
},
}
```
Соответственно, создался файл с содержимым (версия ноды может быть другой у вас):
```
export PATH="/home/ТУТ_ПОЛЬЗОВАТЕЛЬ_UNIX/.nvm/versions/node/v14.20.1/bin:$PATH"
```
После чего тестируем. Создаем кривой коммит сами: `git commit -m "error`" - получаем ответ:
Вывод ошибки коммита в терминалеВывод ошибки коммита в PHPStorm через средства IDEТеперь, все работает, но хотелось бы немного ограничить разработчиков и "заставить" писать коммиты по правилам. Помните, мы подключали commitlint/cli? Так вот эта штука регламентирует правила. Подробнее про правила можно прочитать [тут](https://commitlint.js.org/#/reference-rules?id=rules).
Чтобы правила заработали, создаем в корне проекта файл .commitlintrc.js с содержимым:
```
module.exports = {
rules: {
// Тело коммита должно начинаться с пустой строки
'body-leading-blank': [2, 'always'],
// Нижний колонтитул коммита должен начинаться с пустой строки
'footer-leading-blank': [2, 'always'],
// Максимальная длина заголовка 72 символа
'header-max-length': [2, 'always', 72],
// Область всегда только в нижнем регистре
'scope-case': [2, 'always', 'lower-case'],
// Описание не может быть пустым
'subject-empty': [2, 'never'],
// Описание не должно заканчиваться '.'
'subject-full-stop': [2, 'never', '.'],
// Тип всегда только в нижнем регистре
'type-case': [2, 'always', 'lower-case'],
// Тип не может быть пустым
'type-empty': [2, 'never'],
// Перечислим все возможные варианты коммитов
'type-enum': [
2,
'always',
[
'build',
'ci',
'docs',
'feat',
'fix',
'perf',
'refactor',
'revert',
'style',
'test',
],
],
},
};
```
После чего делаем будут дополнительные правила проверки каждой секции. Секции можно посмотреть на сайте [Conventional Commits в разделе Summary](https://www.conventionalcommits.org/en/v1.0.0/#summary).
Подытожим. С помощью этих плагинов и подходов удалось стандартизировать коммиты, сделать проверку правильности коммитов, решить вопрос с NVM установкой, автоматизировать реализацию данных компонентов. | https://habr.com/ru/post/706772/ | null | ru | null |
# Клади плитку эффективно ( Про CSS, SVG, pattern и другое)
Статья ~~про ремонт квартиры~~, про эффективное использование графических ресурсов для современных устройств. От смарт часов до телевизоров на стену.
Сказ о том, как вставлять фоновые повторяющиеся изображения страниц, что бы всем было хорошо.
Ну, что готовы поиграть ..? Тогда погнали
Вводные
-------
Поступила задача на создание страницы сайта с повторяющимся изображением.
Как будем решать ?
Level 1 Банально примитивный
----------------------------
Самый простой способ, которым воспользуется большое количество верстальщиков это забрать фоновую картинку, всю разом (чаще всего png форматом, поскольку он по умолчанию в Figma и Avocode выставлен) и плюхнуть её блоку через background-image;
*(\* ну, ты ведь не такой, мой юный читатель ?)*
```
body { background: url(‘bg.png’) 50% 50% no-repeat;
background-size:contain;
}
```
Если разработчик немного опытнее, и знает что jpg сжимается, как правило, лучше png, то фон будет формата jpg.
Level 2 Мне не плевать на производительность
--------------------------------------------
Если верстальщику вдруг стало не пофиг на производительность разрабатываемой страницы, и он знает что в этом месте можно существенно экономить трафик пользователя, он может вычленить паттерн (повторяющуюся часть фона) из данного изображения, если повезет.
Если макет был реализован в PhotoShop, то придется обрезать. Потому что там background задается нераздельным элементом
*Пример вынимания повторяющегося фона из Avocode*
В Figma это реализовано несколько проще. Хотя это будет зависеть, от того как дизайнер вам создавал этот фон.
*\*Кто желается поиграться, [я оставлю свой пример для скачивания.](https://www.figma.com/file/QWRiGaJuBXuHEtK0Oc6ZHe/SVG-Pattern?node-id=0%3A1)
В примере два варианта с png и svg паттернами о которых пойдет речь дальше.*
Ок, теперь вместо одного большого фонового изображения у нас есть повторяющийся элемент плитки (CSS Tiling).
```
body {
background: url("bg.jpg");
}
```
Отлично, мы молодцы. Вот уже вместо (586кБ) пользователь забирает с сервера всего ( ~24кБ); Profit !
Level 3 Сожму тебя по максимуму
-------------------------------
Давайте, подумаем, а можно ли это ещё как-то улучшить положение? Хмм, а рисунок то не сложный, может можно его перегнать в вектор?
И тут спрятался демон соблазна.
> Стремясь к лучшему, мы часто портим хорошее
*\* Уильям Шекспир*
Когда этого делать не рационально, или вообще нельзя:
1. У вас сложный повторяющийся рисунок. Его перерисовка займет n часов, а если вы этой задачей ещё и напряжете дизайнера, то карма у вас точно уменьшиться.
2. В изображении присутствуют тени или элементы с размытием, и вы не согласны от них отказаться.
\* Тут надо объяснить
Если вы экспортируете SVG графику предположим из Figma или Illustrator, a не кодите её сами в редакторе, то скорее всего элементы размытия или тени вам будут вставлены в SVG в формате base64 и это ни как не улучшит ваш performance, поскольку такой файл, по факту, может весить больше аналога jpg формата.
Всегда проверяйте, что вам предлагают. Разуметься некоторые из этих элементов можно создать и кодом, при помощи тегов
Хорошо, давайте создадим SVG и посмотрим что у нас получиться.
*\* Ради чистоты эксперимента приведенные изображения ни как не сжимались сторонними утилитами и сохранялись в 100% качестве при помощи PhotoShop, Illustrator and Avocode.*
Ок, да наша svg оказывается меньше jpg/png исходно варианта.
Это не удивительно, поскольку в ней мы оставили только базовые цвета, которые видели, а не те, что появляться на стыке объектов с размытием.
Разница между размерами файлов png/jpg кажется не сильно существенной, и она начинает играть роль, только если рисунок большого размера. (Я предпочитаю png, а фоновый цвет задавать свойством background-color)
Меня несколько смутило, что полученные png/jpg созданные из svg по размеру меньше SVG (даже очищенного от системного мусора средствами [SVGO](https://jakearchibald.github.io/svgomg/))
Но, потом, до меня дошло, что если захочется уменьшить/увеличить размер плитки фона для мобильных или телевизоров, то это потребует подключение новых паттернов (pattern-bg\_min) а SVG останется всё тем же (15кБ — всегда), да и размытия изображения не наблюдается
Это является значимым плюсом, особенно если пользователь смотрит страницу с дорогого телефона с хорошим разрешением, а верстальщик в угоду Google Page Speed ужал всю графику до появления шакалов. Вот она экономия =)
```
body { background-image: url(picture.svg); }
```
Выглядит, довольно привычно.
Ок, усложняем. Предположим что стили, которые в body будут подключать в критический CSS, давайте тогда отдавать вектор прям в стилях. *\*дабы не захламлять страницу, возьму другой паттерн, поменьше.*
```
body {
background: url:(‘ ’);
}
```
Стало довольно много CSS, и он перестал работать.Плохо
Так, необходимо теперь правильно это всё закодировать. Вставку незакодированного SVG поддерживают только браузеры на Webkit. Спасибо, [Юлии Бухваловой, за полезный ресурс кодирования,](http://yoksel.github.io/url-encoder/ru/) который нам в этом поможет.
```
body {
background-color: #DFDBE5;
background-image: url("data:image/svg+xml,%3Csvg width='64' height='64' viewBox='0 0 64 64' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M8 16c4.418 0 8-3.582 8-8s-3.582-8-8-8-8 3.582-8 8 3.582 8 8 8zm0-2c3.314 0 6-2.686 6-6s-2.686-6-6-6-6 2.686-6 6 2.686 6 6 6zm33.414-6l5.95-5.95L45.95.636 40 6.586 34.05.636 32.636 2.05 38.586 8l-5.95 5.95 1.414 1.414L40 9.414l5.95 5.95 1.414-1.414L41.414 8zM40 48c4.418 0 8-3.582 8-8s-3.582-8-8-8-8 3.582-8 8 3.582 8 8 8zm0-2c3.314 0 6-2.686 6-6s-2.686-6-6-6-6 2.686-6 6 2.686 6 6 6zM9.414 40l5.95-5.95-1.414-1.414L8 38.586l-5.95-5.95L.636 34.05 6.586 40l-5.95 5.95 1.414 1.414L8 41.414l5.95 5.95 1.414-1.414L9.414 40z' fill='%239C92AC' fill-opacity='0.4' fill-rule='evenodd'/%3E%3C/svg%3E");
}
```
Примеры для наглядности, Как SVG можно в CSS запаковывать.
Курсор – это SVG
Всё вроде как хорошо, но я точно уверен, что буду использовать данный паттерн на всех страницах своего сайта? Точно его надо засовывать в критический CSS, а может правильнее будет в обычный — подключаемый CSS и надеяться, что браузер его закеширует? Может всё таки можно его подключать только для определенных станиц? Кто-то умный говорил, что код помещенный в HTML собирается браузером быстрее и имеет больший приоритет по скорости выдачи. Так много вопросов… надо пробовать.
Level 4 Я выжму из тебя все соки
--------------------------------
Для начала мы создадим элемент svg, который будет иметь высоту и ширину 100% от наружного блока, чтобы он занимал любой контейнер, в который мы его поместили.
```
```
Чтобы создать pattern, мы должны поместить его в тег defs (определения) svg, например, так:
```
```
Уже неплохо, дальше необходимо добавить атрибутов при помощи, которых мы можем взаимодействовать с pattern и как-то его вызывать.
```
```
Мы дадим ему идентификатор, чтобы была возможность ссылаться на него позже, также укажем начальные координаты отсчета X и Y, значения ширины и высоты которое задаем в графическом редакторе, зададим значения области видимости ViewBox (можно взять из готового svg)
**Немножко от темы, про ViewBox**
но очень мне уж понравился пример визуализации масштабирования и координат ViewBox SVG Амелии Ваттенбергер <https://wattenberger.com/guide/scaling-svg>
… и установим, атрибут patternUnits в значение userSpaceOnUse (это определяет систему координат, о которой можно [узнать больше на MDN](https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/patternUnits) )
*Если вкратце, при patternUnits=”userSpaceOnUse” фигура на холсте SVG полностью заполняется плитками паттерна. Если последняя плитка не входит целиком по длине или по ширине, то она обрезается.*
Теперь надо определиться с изображением, которое будет повторяться
```
```
Всё почти готово, осталось вызывать наш паттерн на неком объекте, ну к примеру создадим прямоугольную область под заполнение.
```
< pattern id="pattern-bg" x="0" y="0" width="80" height="80" viewBox =”0 0 80 80” patternUnits="userSpaceOnUse">
```
Вы можете видеть, что атрибут fill (который обычно содержит цвет заливки теперь указывает на URL-адрес, содержащий идентификатор нашего вновь определенного шаблона: fill = «url (#pattern-bg)».
Наш повторяемый паттерн занимает всё пространство по ширине, но хотелось бы ещё и что б по высоте всё заняло. Для этого обернем наш svg в с высотой height:100vh;
```
```
вот теперь хорошо. Разумеется, в теге вам стоит попробовать вставить ваши, более серьезные изображения, но правильное направление я вам указал.
Данный метод вставки, в отличие от метода через background позволяет вам контролировать детализацию элементов SVG. Всё что вам не нужно, можно и не отдавать на рендер пользователю. А если есть желание экспериментировать, и добавить немного JS то можно ещё и морфинга (изменения фигур) достичь.
*Из проблем такого метода вставки повторяющейся плитки, обнаружил, что нету возможности (ну или это я не смог найти, и знающие напишут в комментариях), как менять размер плитки при изменении размера экрана браузера. По факту за это отвечают атрибуты width/height тега pattern но достучаться до них через CSS и медиа выражения не получилось.*
Cheats Я не умею графику, но хочу прикоснуться к прекрасному
------------------------------------------------------------
Если по каким-то причинам вы не умеете нарисовать повторяющийся элемент паттерна в графическом редакторе, или у вас нету на это времени. Вот сайты с готовыми решениями, в которых добрые люди делятся с миром хорошими вещами.
* <http://www.heropatterns.com/>
* <https://philiprogers.com/svgpatterns/>
* <http://thepatternlibrary.com/>
* <http://btmills.github.io/geopattern/>
\* маленькая добавка (куда же без порно в наше время то ) <https://svgporn.com/>
Team Support Что там с поддержкой?
----------------------------------
В начале статьи я написал, что всем будет хорошо, каюсь, это был обман.
Пользователи [IE ваших стараний не увидят](https://caniuse.com/#search=pattern) поддержка данного тега к IE так и не пришла, и уже не придет, но в остальном c SVG всё не так плохо, даже до 9 IE [caniuse.com](https://caniuse.com/#search=svg)
Так же рекомендовал бы проверять готовую работу в Firefox, иногда бывают казусы.
Для любителей почитать документацию, тоже оставлю пару ссылок
<https://developer.mozilla.org/ru/docs/Web/SVG/%D0%AD%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82/pattern>
<https://developer.mozilla.org/ru/docs/Web/SVG/Tutorial/Patterns>
Для тех, кто долистал до конца, оставлю свой пример, как можно развлекаться с встроенным SVG, из начала статьи
**Сделаем web лучше.**
Отдельное спасибо [Alexandr\_TT](https://ru.stackoverflow.com/users/28748/alexandr-tt) И его сайту <https://svg-art.ru/> в продвижении SVG на просторах русскоязычного Интернета | https://habr.com/ru/post/483470/ | null | ru | null |
# Может, нам слегка успокоиться с JavaScript?
У меня *очень странная* проблема с браузером. Скрипты на некоторых страницах просто не работают, пока не пройдёт около 20 секунд.
Что бы вы ни собирались предложить — да, я уже думала об этом, и нет, не помогло. Я рассказываю об этом не в надежде, что кто-то подскажет с отладкой, а потому что этот случай заставил меня *остро* осознать некоторые, как бы сказать… причуды… разработки на фронте.
(В самом деле, даже не пытайтесь диагностировать проблему по одному предложению, **не надо**, я слышала и перепробовала почти всё, что вы можете себе представить).
Статья написана в марте 2016 года, некоторые примеры устарели — прим. пер.
Бесполезные страницы
====================
Смотрите, вот скриншот твита. В нём красным цветом выделены те части, которые *не работают без JavaScript*. Я это знаю, потому что по-прежнему 20 секунд гляжу на страницу, на которой ещё не сработала большая часть кода.
Кое-что я могу понять. Например, кнопка «Ответить» разворачивает текстовое поле внизу и переводит на него фокус. Этого никак не сделать без некоторых скриптов. Кнопка `...` открывает всплывающее меню, что *сомнительно*, так как вы можете воспроизвести его и с помощью CSS. Аналогично, кнопка с сердечком выполняет действие в фоновом режиме, что тоже является *сомнительным*, поскольку его можно воспроизвести с полной загрузкой страницы. Но это нетривиальные изменения, которые будут работать совершенно по-разному со скриптами и без.
С другой стороны…
Эта кнопка × в правом верхнем углу и все пустое окружающее пространство? Их единственная функция — отправить вас в мой профиль, который виден за твитом. С таким же успехом они могли быть обычными ссылками, как стрелки влево и вправо для навигации. Но это сделано иначе, поэтому не работает без JavaScript.
Или маленькая кнопка с графиками, для аналитики? Её единственная функция — загрузить другую страницу в искусственном всплывающем окне со встроенным фреймом. Здесь могла быть обычная ссылка, которая превращается во всплывающее окно с помощью скрипта. Но это сделано иначе, поэтому не работает без JavaScript.
Текстовое поле? Конечно, это просто текстовое поле. Но если нажать на него до запуска JavaScript, в поле останется неуклюжая надпись `Reply to @eevee`. А когда скрипт всё-таки запускается, он стирает всё, что вы набрали, и снова вставляет `Reply to @eevee`, только теперь `@eevee` написано синенькими буквами, а не серенькими.
То же самое происходит на странице поиска Twitter, что очень странно, потому что в поле поиска нет текста! Если вы начнёте печатать до окончания работы скриптов, они просто сотрут всё, что вы набрали. Даже не для того, чтобы вставить свой текст-заполнитель или применить пользовательский стиль. Без всякой видимой причины, просто так.
Поскольку у меня работает NoScript, я частенько замечаю странные дизайнерские решения на сайтах, которые посещаю впервые. Конечно, пустые белые страницы — обычное дело. Довольно долго статьи на сайте Time отлично загружались без скрипта, но только не прокручивались — для страницы применялось свойство `overflow: hidden;` по причинам, которые я не могу понять. Статьи Vox также загружаются нормально, за исключением того, что перед каждым изображением выводится пустое пространство на всю высоту экрана. Некоторые особенно плохие корпоративные сайты представляют собой месиво перекрывающихся блоков текста. Думаю, что они отказались от CSS и написали макет на JavaScript.
Для этого нет никаких веских причин. Это не передовые интерактивные приложения, это просто страницы с текстом. Мы раньше их печатали на бумаге, но как только перешли на информационные технологии, стало невозможно поместить слова на экран, не запустив на исполнение несколько мегабайт мусора?
Я прямо слышу, как меня называют луддиткой, потому что я не согласна окружать пять абзацев статического текста тысячами строк скриптов. Ну, позвольте заранее ответить: идите в баню. Я думаю, что веб и интерактивные страницы — это здорово, я вижу отличный прогресс в последнее десятилетие. Просто супер, что веб изначально поддерживал пользовательские настройки, а я могу заранее настроить для каждого сайта разрешения, что он может запускать на моём компьютере, а что нет.
А вот что не очень здорово, так это группа высокооплачиваемых и высококвалифицированных специалистов, у каждого из которых установлен Chrome на последней модели Mac Pro, которые работают в офисе на расстоянии не больше километра от каждого сервера, на который они заходят. И вот эти ребята работают, а потом поворачиваются и хихикают над всеми остальными, у кого нет такой конфигурации. Учтите, что любое из следующих условий помешает работе вашего JavaScript:
* Кто-то на медленном компьютере.
* Кто-то на медленном соединении.
* Кто-то на телефоне, то есть на медленном компьютере с медленным соединением.
* Кто-то застрял со старым браузером на компьютере, который он не контролирует — на работе, в школе, в библиотеке и т. д.
* Кто-то пытается написать небольшую программу, которая взаимодействует с вашим сайтом, у которого нет API.
* Кто-то пытается загрузить копию вашего сайта, чтобы почитать в офлайне.
* Кто-то — это кэш Google или Архив Интернета.
* Кто-то сломал графическое окружение в Linux и пытается выяснить, как его починить, загружая статьи с вашего сайта через браузер командной строки Elinks.
* Кто-то внёс изменения в ваш сайт с помощью пользовательского скрипта, и это мешает вашему собственному коду.
* Кто-то использует NoScript и видит на вашем сайте только пустой экран. Он настолько раздражён, что просто уходит, а не вносит ваш сайт в белый список.
* Кто-то использует NoScript и вносит в белый список вас, но ни один из десятков трекеров, которые вы используете. Позже вы случайно ставите скрипт в зависимость от трекера, и он таинственным образом больше не работает для таких пользователей.
* Вы даёте критически важному скрипту название, связанное с рекламой, и он не загружается у десятков миллионов пользователей с блокировщиками рекламы.
* Ваш CDN упал.
* У вашего CDN есть адрес IPv6, но на самом деле он не работает (да, я видела такое и у компаний стоимостью в миллиард долларов, и у федерального правительства). Заходит кто-то по IPv6, страница загружается, но JS вылетает по таймауту.
* Ваш деплой идёт немного неудачно, и JavaScript повреждается.
* Вы случайно использовали новую функцию, которая не работает в предыдущей версии самого популярного браузера. Выводится синтаксическая ошибка, и ни один из ваших сценариев не запускается.
* Вы прямо вводите синтаксическую ошибку, и никто не замечает, пока она не попадает в продакшн.
Я не говорю, что следует стереть с лица Земли интерактивные веб-приложения, такие как Google Maps, хотя даже для Google Maps много лет был запасной вариант без скриптов, до текущей версии WebGL! Я говорю, что мы свернули куда-то не туда, когда базовые функции *обычного HTML* вдруг перестали работать без JavaScript. А именно, без 40 мегабайт JavaScript, согласно `about:memory` — это данные в памяти, а не размер загрузки. Это может показаться не очень много (для страницы, которая выводит на экран 140 символов?), но в моём браузере часто накапливается десяток открытых вкладок Twitter, то есть *полгигабайта памяти*, выделенных максимум на 6 КБ текста.
Изобретение квадратного колеса
==============================
Вам действительно нужно постараться, чтобы добиться такого плачевного результата. Я имею в виду, если вам нужна ссылка, вы просто пишете `[label](somewhere)`, и готово. Но если вы начнёте изобретать это с помощью JavaScript, то нужен обработчик кликов, и он должен работать в нужное время, чтобы вы знали, что ссылка действительно существует, и, возможно, вам придётся сделать некоторую работу, чтобы добавить обработчики кликов к фальшивым ссылкам, которые добавляет Ajax. Так ведь?
Нет! Вы получите лишь бледную, дрянную имитацию ссылки. Рассмотрим все функции нативных ссылок:
* Я могу перейти по ссылке.
* Я могу открыть ссылку в новой вкладке или окне с помощью комбинации клавиш ctrl, shift и колёсика (средней кнопки) мыши.
* Я могу скопировать адрес ссылки и вставить его куда-нибудь или открыть в другом браузере, или ещё что-нибудь.
* Я могу использовать `'` в Firefox для поиска только ссылок.
* В некоторых браузерах — Opera, Konqueror, uzbl, Firefox с vimperator? — есть горячая клавиша, которая показывает цифру или букву рядом с каждой ссылкой на странице, так что вы можете очень быстро «щёлкнуть» ссылку визуально, даже не касаясь мыши.
* Я считаю, что скринридеры обрабатывают ссылки специальным образом.
* Простые краулеры составляют по ссылкам карту сайта.
* Браузеры начинают экспериментировать с предварительной загрузкой видных ссылок, так что если пользователь действительно нажимает на неё, то страница открывается мгновенно.
Общая нить здесь заключается в том, что тег *нечто значит*. Он говорит: «Это путь, по которому можно пройти». Тонны инструментов полагаются на эту информацию. Если заменить его на , то да, нажатие на div что-то сделает, но весь *смысл* полностью потерян. И наоборот, если использовать , то вы фактически лжёте этим инструментам; вы вызываете смысл, но отдаёте бессмысленную информацию.
Вот что люди имеют в виду, когда говорят о «семантике» — что есть полезная информация, которую нужно собрать. Если вы начинаете изобретать подобие ссылок, то анализ этого синтетического конструкта потребует либо спекулятивного выполнения большого количества произвольного кода, либо написания *чрезвычайно* умного статического анализатора, либо просто обучения программиста-человека. Декларирование намерений — гораздо более мощный и гибкий метод, чем просто выполнение работы, потому что в первом случае универсальные инструменты делают полезные вещи почти тривиально.
Еще один хороший пример — выпадающие формы . Некоторые разработчики иногда полностью с нуля создают свою замену из неродных виджетов. Наверное, чтобы сделать их красивее? Благородная цель. Но знаете ли вы, что в нативных выпадающих формах при начале набора текста автоматически выбирается первая подходящая позиция? Очевидно, в большинстве альтернативных реализаций это не поддерживается. Визуально они выглядят лучше (или просто иначе), но функционально намного хуже для длинных списков.
Самодельное текстовое поле Twitter — это вовсе не текстовое поле, а `contenteditable` . Здесь `contenteditable` означает, что большинство нативных элементов управления работают довольно хорошо, но всё равно этот объект время от времени демонстрирует некое странное поведение, например, перемещает курсор в начало текста, когда я переключаюсь между вкладками. Или иногда у скрипта возникают какие-то проблемы с моей скоростью набора и он начинает з а м е т н о о т с т а в а т ь. Единственная причина, зачем вообще ставить его вместо обычного , кажется, это чтобы подкрасить `@handles` и ссылки синим цветом? Самодельное текстовое поле не сокращает ссылки и не заменяет твиттеровские эмодзи, поэтому на самом деле это не предварительный просмотр того, как будет выглядеть ваш твит.
Вы знаете, что на некоторых сайтах работают горячие клавиши? Мило, правда? Но на самом деле `/` — это встроенная в Firefox горячая клавиша, которая открывает панель быстрого поиска. Очевидно, никто в Twitter или GitHub, или BitBucket, или Tumblr, или в десятке других мест не знает об этом, потому что все они назначили этой клавише перемещение фокуса на собственную панель поиска по сайту. Что полностью отличается от поиска на текущей странице (к чести GitHub, они это исправили, когда я пожаловалась в твиттере). В течение длительного времени Google+ отключал пробел для прокрутки вниз. Почему никто в этих огромных компаниях не остановился и не сказал: «Эй, подождите, это ведь рабочая функция в браузере, а мы её ломаем»? Веб-разработчики сами вообще пользуются браузерами?
Тут вспомнилось, что каждая страница Twitter молча поглощает любые события клавиатуры и нажатия мыши, пока не отработают все скрипты. Это означает, что я не могу даже сменить вкладку, пока не подожду эти 20 секунд загрузки страницы: ctrl-t, ctrl-w, ctrl-tab, ctrl-pgup и ctrl-pgdn — все события клавиатуры полностью поглощаются. Так работает механизм под названием «очередь быстрых действий» (swift action queue). Звучит так, будто эта очередь должна воспроизводить события по окончании загрузки страницы, но (а) вы не можете воспользоваться горячими клавишами в браузере; (б) похоже, она всё равно не работает. Чтобы это исправить, мне пришлось написать пользовательский скрипт, чтобы заблокировать тег скрипта с определённым идентификатором.
Я не думаю, что очень привередничаю. Это базовые функции браузера, и вы их нарушаете, часто без уважительной причины. Я не ожидаю, что вы заставите Google Docs работать без JavaScript. Я просто надеюсь, что вы не сломаете мою чёртову клавиатуру.
Позвольте дать совет
====================
Примите тот факт, что иногда для некоторых людей ваш JavaScript не будет работать. Подумайте, что это значит. Когда есть выбор, всегда выбирайте существующие HTML-механизмы. Может, раз в год ваша команда разработчиков отключит JavaScript и попытается использовать сайт. Начинай плакать.
Если вы собираетесь переопределить или переосмыслить то, что уже существует, сначала изучите это. Вы не можете создать хорошую замену без понимания оригинала. Поспрашивайте вокруг. Чёрт, просто попробуйте нажать `/` в браузере, прежде чем делать это горячей клавишей на своём сайте.
Помните, что при всей власти, которую даёт вам интернет, в конечном счёте контроль всё равно находится в руках пользователя. Интернет — это не игровая приставка, действуйте соответственно. Создавайте модули. Заранее учитывайте вероятные или распространённые настройки. Может, что-нибудь немного уменьшить, когда достигнете 40 мегабайт скриптов на странице.
Спасибо. | https://habr.com/ru/post/490412/ | null | ru | null |
# Thunderbird, RNP и важность хорошего API
Недавно мне довелось побеседовать с разработчиком [Thunderbird](https://thunderbird.net/) о проектировании API. В ходе этой беседы я поделился соображениями о [RNP](https://www.rnpgp.org/), [новой реализации OpenPGP,](https://blog.thunderbird.net/2020/09/openpgp-in-thunderbird-78/) которую Thunderbird недавно стал использовать вместо [GnuPG](https://gnupg.org/).
Собеседник скептически отнесся к моему тезису о том, что API RNP нуждается в улучшении, и спросил, «разве это не субъективно – какие API лучше, а какие хуже?». Согласен, у нас нет хороших метрик для оценки API. Но не соглашусь, что мы в принципе не в силах судить об API.
На самом деле, подозреваю, что большинство опытных программистов узнают плохой API, если увидят его. Думаю, далее в этой статье получится разработать хорошую эвристику, которую я попытаюсь выстроить на моем собственном опыте работы с (и над) GnuPG, [Sequoia](https://sequoia-pgp.org/) и RNP. Затем я рассмотрю API RNP. К сожалению, этот API не только можно запросто использовать неправильно – он к тому же обманчив, поэтому пока его не следует использовать в контекстах, где принципиальная роль отводится соблюдению безопасности. Но целевая аудитория Thunderbird – это люди, известные своей уязвимостью, в частности, журналисты, активисты, юристы и их партнеры, отвечающие за коммуникацию; все эти люди нуждаются в защите. На мой взгляд, это означает, что в Thunderbird должны лишний раз подумать, стоит ли использовать RNP.
**Примечание: также предлагаю ознакомиться с этим электронным письмом:**[**Let’s Use GPL Libraries in Thunderbird!**](https://thunderbird.topicbox.com/groups/planning/T45cf6d9d100202e9/lets-use-gpl-libraries-in-thunderbird)**, которое я отправил**[**в постовую рассылку по планированию развития Thunderbird**](https://thunderbird.topicbox.com/groups/planning)**.**
Каковы черты плохого API?
-------------------------
Прежде, чем мы вместе с Юстусом и Каем приступили к проекту [Sequoia](https://sequoia-pgp.org/), мы все втроем работали над [GnuPG](https://gnupg.org/). Мы не только сами копались в gpg, но и беседовали, и сотрудничали со многими последующими пользователями gpg. Люди смогли сказать [много хорошего по поводу GnuPG](https://www.youtube.com/watch?v=-ExPXCgMiEw).
Что касается критики gpg, наиболее значительными нам показались два вида замечаний по поводу API. Первое сводится к следующему: API gpg слишком догматичен. Например, в gpg применяется подход, основанный на использовании личной базы ключей (keyring). Таким образом, просмотреть или использовать сертификат OpenPGP можно лишь в том случае, если он импортирован в личную базу ключей. Но некоторые разработчики желают сначала просмотреть сертификат, и лишь потом импортировать его. Например, при поиске сертификата на сервере ключей по его отпечатку, можно [проверить и убедиться, что возвращенный сертификат – действительно тот, что нужен](https://dev.gnupg.org/T1579), поскольку его URL является самоаутентифицируемым. Это можно сделать при помощи gpg, но только обходным путем, огибая принципы той модели программирования, которая в него заложена. Базовая идея такова: создать временный каталог, добавить в него конфигурационный файл, приказать gpg использовать альтернативный каталог, импортировать туда сертификат, проверить сертификат, после чего очистить временный каталог. Это [официальная рекомендация](https://gnupg.org/documentation/manuals/gnupg/Ephemeral-home-directories.html#Ephemeral-home-directories), добавленная [Юстусом](https://git.gnupg.org/cgi-bin/gitweb.cgi?p=gnupg.git;a=commit;h=116a78eb869c4c589228bd0d6deff7c7a9f92dfb) на основе наших бесед с последующими пользователями gpg. Да, этот метод работает. Но для него требуется писать код, специфичный для операционной системы, этот код медленный, и в нем часто заводятся ошибки.
Другой класс замечаний, с которыми мы сталкивались неоднократно, заключается в том, что для работы с gpg требуется знать массу неочевидных вещей – чтобы не злоупотреблять этим механизмом. Или, выражаясь иначе, нужно проявлять *крайнюю* осмотрительность при использовании API gpg, чтобы ненароком не привнести в код уязвимость.
Чтобы лучше понять второй повод для беспокойства, рассмотрим уязвимости [EFAIL](https://efail.de/). Основная проблема, связанная с API дешифрования gpg: при дешифровании сообщения gpg выдает обычный текст, даже если ввод был поврежден. gpg в таком случае действительно возвращает ошибку, но некоторые программы все равно выводят обычный текст в поврежденном виде. Так как, почему нет? Определенно, лучше показать хотя бы часть сообщения, чем не показать ничего, верно? Так вот, уязвимости EFAIL демонстрируют, как злоумышленник может этим воспользоваться, чтобы внедрить [веб-баг](https://en.wikipedia.org/wiki/Web_beacon) в зашифрованное сообщение. Когда пользователь просматривает это сообщение, веб-баг просачивается из сообщения. Уф.
Итак, на чьей совести этот баг? Разработчики [GnuPG](https://lists.gnupg.org/pipermail/gnupg-users/2018-May/060315.html) [настаивали,](https://lists.gnupg.org/pipermail/gnupg-users/2018-May/060318.html) [что](https://lists.gnupg.org/pipermail/gnupg-users/2018-May/060320.html) проблема – на уровне приложений, в том, что они используют gpg неправильно:
Рекомендуется, чтобы в почтовых пользовательских агентах учитывался код состояния DECRYPTION\_FAILED, и не отображались данные, либо, как минимум, подбирался уместный способ для отображения потенциально поврежденной почты, не создавая оракул и информируя пользователя о том, что почта не внушает доверия.
gpg просигнализировала об ошибке; приложения не соблюдают контракт API. Должен согласиться с разработчиками GnuPG и добавить: интерфейс gpg был (и остается) бомбой замедленного действия, поскольку не подсказывает пользователю, как действовать правильно. Напротив, легкое и, казалось бы, полезное действие является неверным. И [API](https://lists.gnupg.org/pipermail/gnupg-users/2004-August/023141.html) такого [типа](https://lists.zx2c4.com/pipermail/password-store/2018-June/003308.html), к сожалению, обычны в GnuPG.
Из чего слагается хороший API?
------------------------------
Осознание двух этих вещей — что API gpg слишком догматичен, и что им сложно пользоваться как следует — сформировало мои планы. Когда мы приступили к проекту Sequoia, мы сошлись на том, что подобных ошибок хотим избежать. Основываясь на наблюдениях, мы ввели в практику два теста, которыми продолжаем пользоваться в качестве ориентиров при разработке API Sequoia. Во-первых, *дополнительно к любому высокоуровневому API должен существовать и низкоуровневый, который не догматичен – в том смысле, что не мешает пользователю делать что-либо, что не запрещено.* В то же время, *API должен наводить пользователя на верные (жестко прописанные) вещи, делая так, чтобы правильные действия были просты в исполнении и наиболее очевидны при выборе действия*.
Для воплощения двух этих слегка конфликтующих целей – сделать возможным всё, но предотвратить ошибки, мы особенно активно опирались на два средства: типы и примеры. Благодаря типам, становится сложно использовать объект непредусмотренным образом, так как контракт API формализуется во время компиляции и даже [навязывает конкретные преобразования](https://www.youtube.com/watch?v=3Q2hQfYW-XM). Примеры же — фрагменты кода — будут [копироваться](https://stackoverflow.blog/2021/04/19/how-often-do-people-actually-copy-and-paste-from-stack-overflow-now-we-know/). Поэтому, хорошие примеры не только приучат пользователей правильно обращаться с функцией, но и сильно повлияют на то, как именно они будут ее использовать.
### Типы
Покажу на примере, как мы используем типы в Sequoia, и как они помогают нам сделать хороший API. Чтобы пример был понятнее, полезно будет напомнить некоторый контекст, касающийся OpenPGP.
*Простой сертификат OpenPGP*
В OpenPGP существует несколько фундаментальных типов данных, а именно: сертификаты, компоненты (например, ключи и пользовательские ID), а также подписи привязки. Корень сертификата – это первичный ключ, полностью определяющий отпечаток сертификата (fingerprint = Hash(primary key)). В состав сертификата обычно входят такие компоненты как подключи и пользовательские ID. OpenPGP привязывает компонент к сертификату при помощи так называемой подписи привязки. Когда мы используем в качестве отпечатка обычный хеш первичного ключа и используем подписи для привязки компонентов к первичному ключу, создаются условия, чтобы впоследствии можно было добавить и дополнительные компоненты. В состав подписей привязки также входят свойства. Поэтому есть возможность изменить компонент, например, продлить срок действия подключа. Вследствие этого с конкретным компонентом может быть ассоциировано несколько действительных подписей. Подписи привязки являются не только фундаментальной, но и неотъемлемой частью механизма безопасности OpenPGP.
Поскольку может существовать множество действительных подписей привязки, требуется способ выбирать из них нужную. В качестве первого приближения предположим, что нужная нам подпись – самая недавняя, неистекшая, неотозванная действительная подпись, создание которой не отложено на будущее. Но что такое действительная подпись? В Sequoia подпись должна не только пройти математическую проверку, но и согласовываться с политикой. Например, в силу [противодействия скомпрометированным коллизиям](https://sha-mbles.github.io/), мы [допускаем SHA-1 только в очень небольшом количестве ситуаций](https://docs.sequoia-pgp.org/sequoia_openpgp/policy/enum.HashAlgoSecurity.html). ([Пол Шауб](https://blog.jabberhead.tk/), работающий над [PGPainless](https://pgpainless.org/), недавно [подробно написал об этих сложностях](https://blog.jabberhead.tk/2021/04/03/why-signature-verification-in-openpgp-is-hard/).) Вынуждая пользователя API держать в уме все эти соображения, мы создаем почву для уязвимостей. В Sequoia легкий способ получить время истечения – это безопасный способ. Рассмотрим следующий код, который работает как надо:
```
let p = &StandardPolicy::new();
let cert = Cert::from_str(CERT)?;
for k in cert.with_policy(p, None)?.keys().subkeys() {
println!("Key {}: expiry: {}",
k.fingerprint(),
if let Some(t) = k.key_expiration_time() {
DateTime::::from(t).to\_rfc3339()
} else {
"never".into()
});
}
```
`cert` – это сертификат. Начинаем с применения политики к нему. (Политики определяются пользователем, но, как правило, [StandardPolicy](https://docs.sequoia-pgp.org/sequoia_openpgp/policy/struct.StandardPolicy.html) не только достаточна, но и наиболее уместна). Фактически здесь создается представление сертификата, в котором видны только компоненты с действительной подписью привязки. Важно, что она также изменяет и предоставляет ряд новых методов. Метод keys, к примеру, изменен так, что [возвращает ValidKeyAmalgamation](https://docs.sequoia-pgp.org/sequoia_openpgp/cert/struct.ValidCert.html#method.keys) [вместо KeyAmalgamation](https://docs.sequoia-pgp.org/sequoia_openpgp/cert/struct.Cert.html#method.keys). (Это слияние, так как результат включает не только Key, но и все подписи, связанные с ним; некоторые считают, что этот процесс было бы удачнее назвать [Катамари](https://en.wikipedia.org/wiki/Katamari_Damacy). ¯\\_(ツ)\_/¯) У ValidKeyAmalgamation есть действительная подпись привязки, согласно вышеприведенным критериям. А также предоставляет такие методы как key\_expiration\_time, что имеет смысл только с действительным ключом! Также отметим: возвращаемый тип, используемый с key\_expiration\_time, эргономичен. Вместо того, чтобы возвращать необработанное значение, key\_expiration\_time возвращает [SystemTime](https://doc.rust-lang.org/stable/std/time/struct.SystemTime.html), безопасный и удобный в работе.
В соответствии с нашим первым принципом «позволить использовать все», разработчик по-прежнему сохраняет [доступ к единичным подписям](https://docs.sequoia-pgp.org/sequoia_openpgp/cert/amalgamation/struct.ComponentAmalgamation.html#method.signatures) и [исследует субпакеты](https://docs.sequoia-pgp.org/sequoia_openpgp/packet/signature/subpacket/struct.SubpacketAreas.html#method.key_expiration_time), чтобы узнать из иной привязки подписи, когда истекает срок действия ключа. Но, по сравнению с тем, как в API Sequoia положено правильно узнавать срок истечения действия ключа, любой иной подход противоречил бы API. По нашему мнению, это хороший API.
Примеры
-------
[Релиз 1.0](https://sequoia-pgp.org/blog/2020/12/16/202012-1.0/) библиотеки Sequoia состоялся в декабре 2020 года. За девять месяцев до того мы вышли на ситуацию полной работоспособности (feature complete) и были готовы к релизу. Но [выжидали](https://sequoia-pgp.org/blog/2020/04/26/202004-towards-sequoia-v1.0/). Следующие девять месяцев ушли у нас на добавление документации и примеров к публичному API. Посмотрите документацию к структуре данных [Cert](https://docs.sequoia-pgp.org/sequoia_openpgp/struct.Cert.html) в качестве примера, посмотрите, что у нас получилось. Как указано в нашем посте, нам не удалось предоставить примеры для всех функций до одной, но мы успели довольно много. В качестве бонуса к написанию примеров мы также успели найти несколько шероховатостей, которые при этом отполировали.
После релиза нам удалось пообщаться со многими разработчиками, включившими Sequoia в свой код. Красной нитью через их отзывы проходили признания в том, насколько полезны оказались и документация, и примеры. Можем подтвердить: хотя это и наш код, мы заглядываем в документацию практически ежедневно и копируем наши собственные примеры. Так проще. Поскольку в примерах показано, как правильно использовать ту или иную функцию, зачем переделывать работу с нуля?
API RNP
-------
[RNP](https://www.rnpgp.org/) – это свежая реализация OpenPGP, разработанная преимущественно [Ribose](https://www.ribose.com/about). Примерно [два года назад](https://blog.thunderbird.net/2019/03/fosdem-2019-and-deltachat/) в Thunderbird решили интегрировать [Enigmail](https://enigmail.net/) в Thunderbird и одновременно с этим [заменить GnuPG на RNP](https://blog.thunderbird.net/2020/09/openpgp-in-thunderbird-78/). Тот факт, что в Thunderbird выбрали RNP – не только лестен для RNP; он также означает, что RNP стал, пожалуй, самой востребованной реализацией OpenPGP для шифрования почты.
Критику легко воспринять как негатив. Я хочу совершенно однозначно высказаться: думаю, что работа, которую делают в Ribose, хороша и важна, я благодарен им за то, что они вкладывают время и силы в новую реализацию OpenPGP. В экосистеме OpenPGP отчаянно требуется добавить разнообразия. Но это не оправдание за выпуск незрелого продукта для использования в контексте, где безопасность критически важна.
### Инфраструктура с критически важными требованиями к безопасности
К сожалению, RNP пока не дошла до состояния в котором, на мой взгляд, ее можно безопасно развертывать. Enigmail пользовались не только люди, озабоченные приватностью своих данных, но и журналисты, активисты и адвокаты, которым важна собственная безопасность и безопасность их собеседников. В интервью, данном в 2017 году, Бенджамин Исмаил, глава Азиатско-Тихоокеанского отделения организации [Репортеры без границ](https://rsf.org/en), сказал:
В основном мы используем GPG для свободной коммуникации с нашими источниками. Информация, которую они сообщают нам о правах человека и нарушениях этих прав – небезопасна для них, поэтому необходимо защищать неприкосновенность наших разговоров.
[Интервью с Бенджамином Исмаилом](https://www.youtube.com/watch?v=atFz16nInIs) из организации [Репортеры без границ](https://rsf.org/en)
Принципиально важно, чтобы Thunderbird и далее обеспечивала этих пользователей максимально безопасными возможностями работы, даже в такой переходный период.
### RNP и подписи привязки подключа
Говоря о том, как мы используем типы в Sequoia для того, чтобы усложнить неправильное использование API, я показал, как узнать срок истечения действия ключа, написав всего несколько строк кода. Хотел начать с примера, демонстрирующего человеку, неискушенному в OpenPGP или RNP, как тот же самый функционал можно реализовать при помощи RNP. Следующий код перебирает подключи сертификата (key) и выводит на экран срок истечения действия каждого подключа. Напоминаю: время истечения действия хранится в подписи привязки подключа, а значение 0 свидетельствует, что срок действия ключа не истечет никогда.
```
int i;
for (i = 0; i < sk_count; i ++) {
rnp_key_handle_t sk;
err = rnp_key_get_subkey_at(key, i, &sk);
if (err) {
printf("rnp_key_get_subkey_at(%d): %x\n", i, err);
return 1;
}
uint32_t expiration_time;
err = rnp_key_get_expiration(sk, &expiration_time);
if (err) {
printf("#%d (%s). rnp_key_get_expiration: %x\n",
i + 1, desc[i], err);
} else {
printf("#%d (%s) expires %"PRIu32" seconds after key's creation time.\n",
i + 1, desc[i],
expiration_time);
}
}
```
Я проверил этот код на сертификате с пятью подключами. Первый подключ имеет действительную подпись привязки и не истекает; второй имеет действительную подпись привязки и в будущем истекает; у третьего действительная подпись привязки, но срок его действия уже истек; у четвертого недействительная подпись привязки, согласно которой срок действия подключа истекает в будущем; у пятого подписи привязки нет вообще. Вот вывод:
```
#1 (doesn't expire) expires 0 seconds after key's creation time.
#2 (expires) expires 94670781 seconds after key's creation time.
#3 (expired) expires 86400 seconds after key's creation time.
#4 (invalid sig) expires 0 seconds after key's creation time.
#5 (no sig) expires 0 seconds after key's creation time.
```
Первым делом отмечаем, что вызов rnp\_key\_get\_expiration оканчивается успешно, независимо от того, есть ли у подключа действительная подпись привязки, либо недействительная подпись привязки, либо вообще нет подписи привязки. Если почитать [документацию](https://github.com/rnpgp/rnp/blob/e654904b77/include/rnp/rnp.h#L1484), то это поведение кажется немного удивительным. Там сказано:
```
Получить время истечения срока действия ключа в секундах.
Обратите внимание: 0 означает, что ключ не истечет никогда.
```
Поскольку время истечения срока действия ключа сохранено в подписи привязки, я, эксперт по OpenPGP, понимаю это так: вызов к rnp\_key\_get\_expiration увенчается успехом лишь в том случае, если у подключа есть действительная подпись привязки. На самом же деле оказывается, что, если действительная подпись привязки отсутствует, то функция просто принимает по умолчанию значение 0, что, учитывая вышеприведенное замечание, пользователь API ожидаемо интерпретирует так: данный ключ действует бессрочно.
Чтобы улучшить этот код, сначала необходимо проверить, есть ли у ключа действительная подпись привязки. Некоторые функции, делающие именно это, недавно были добавлены в RNP для решения проблемы [CVE-2021-23991](https://www.mozilla.org/en-US/security/advisories/mfsa2021-13/#CVE-2021-23991). В частности, разработчики RNP [добавили функцию rnp\_key\_is\_valid](https://github.com/rnpgp/rnp/commit/978294e37cbabdebcc1a065e5a1498e478998823), чтобы возвращать информацию о том, действителен ли ключ. Это дополнение улучшает ситуацию, но требует от разработчика явно выбирать, должны ли проводиться эти критичные для безопасности проверки (а не явно отказываться от уже заданных проверок – как было бы в случае работы с Sequoia). Поскольку проверки безопасности не относятся к выполнению полезной работы, о них легко забыть: код работает, даже если проверка безопасности проведена не была. А поскольку чтобы правильно выбрать, что проверять, нужны экспертные знания, о проверках забывают.
Следующий код предусматривает проверку безопасности и пропускает любые ключи, которые rnp\_key\_is\_valid сочтет недействительными:
```
int i;
for (i = 0; i < sk_count; i ++) {
rnp_key_handle_t sk;
err = rnp_key_get_subkey_at(key, i, &sk);
if (err) {
printf("rnp_key_get_subkey_at(%d): %x\n", i, err);
return 1;
}
bool is_valid = false;
err = rnp_key_is_valid(sk, &is_valid);
if (err) {
printf("rnp_key_is_valid: %x\n", err);
return 1;
}
if (! is_valid) {
printf("#%d (%s) is invalid, skipping.\n",
i + 1, desc[i]);
continue;
}
uint32_t expiration_time;
err = rnp_key_get_expiration(sk, &expiration_time);
if (err) {
printf("#%d (%s). rnp_key_get_expiration: %x\n",
i + 1, desc[i], err);
} else {
printf("#%d (%s) expires %"PRIu32" seconds after key's creation time.\n",
i + 1, desc[i],
expiration_time);
}
}
```
Вывод:
```
#1 (doesn't expire) expires 0 seconds after key's creation time.
#2 (expires) expires 94670781 seconds after key's creation time.
#3 (expired) is invalid, skipping.
#4 (invalid sig) is invalid, skipping.
#5 (no sig) is invalid, skipping.
```
Этот код правильно пропускает два ключа, не имеющих действительной подписи привязки, но он также пропускает и истекший ключ – пожалуй, не этого мы хотели, пусть документация нас и предупреждает, что эта функция «проверяет … сроки истечения».
Хотя бывает и так, что мы не хотим использовать тот ключ или сертификат, срок действия которого истек, иногда мы к ним прибегаем. Например, если пользователь забудет продлить срок действия ключа, то у него должна быть возможность увидеть, что ключ истек, и тогда проверить сертификат, а также продлить в таком случае срок действия ключа. Хотя `gpg --list-keys` не показывает истекшие ключи, при редактировании сертификата все-таки видны истекшие подключи, так, чтобы пользователь мог продлить срок их действия:
```
$ gpg --edit-key 93D3A2B8DF67CE4B674999B807A5D8589F2492F9
Secret key is available.
sec ed25519/07A5D8589F2492F9
created: 2021-04-26 expires: 2024-04-26 usage: C
trust: unknown validity: unknown
ssb ed25519/1E2F512A0FE99515
created: 2021-04-27 expires: never usage: S
ssb cv25519/8CDDC2BC5EEB61A3
created: 2021-04-26 expires: 2024-04-26 usage: E
ssb ed25519/142D550E6E6DF02E
created: 2021-04-26 expired: 2021-04-27 usage: S
[ unknown] (1). Alice
```
Есть и другие ситуации, в которых истекший ключ не должен считаться недействительным. Предположим, например, что Алиса посылает Бобу подписанное сообщение: «я заплачу тебе 100 евро за год,» а срок действия ключа подписи истекает через полгода. Когда год закончится, будет ли Алиса должна Бобу, если исходить из этой подписи? По-моему, да. Подпись была действительна, когда ставилась. Тот факт, что срок действия ключа уже истек, не имеет значения. Разумеется, когда ключ истек, подписи, скрепленные им после момента его истечения, должны считаться недействительными. Аналогично, сообщение не следует шифровать истекшим ключом.
Короче говоря, то, должен ли ключ считаться действительным, сильно зависит от контекста. rnp\_key\_is\_valid лучше, чем ничего, но, несмотря на название, эта функция предусматривает достаточно нюансов при определении того, действителен ли ключ.
В рамках того же коммита была добавлена вторая функция, `rnp_key_valid_till`. Эта функция возвращает «метку времени, до наступления которого ключ может считаться действительным… Если ключ никогда не был действителен, то в качестве значения возвращается ноль.» При помощи этой функции можно определить, был ли ключ действителен когда-либо, для этого нужно проверить, возвращает ли эта функция ненулевое значение:
```
int i;
for (i = 0; i < sk_count; i ++) {
rnp_key_handle_t sk;
err = rnp_key_get_subkey_at(key, i, &sk);
if (err) {
printf("rnp_key_get_subkey_at(%d): %x\n", i, err);
return 1;
}
uint32_t valid_till;
err = rnp_key_valid_till(sk, &valid_till);
if (err) {
printf("rnp_key_valid_till: %x\n", err);
return 1;
}
printf("#%d (%s) valid till %"PRIu32" seconds after epoch; ",
i + 1, desc[i], valid_till);
if (valid_till == 0) {
printf("invalid, skipping.\n");
continue;
}
uint32_t expiration_time;
err = rnp_key_get_expiration(sk, &expiration_time);
if (err) {
printf("rnp_key_get_expiration: %x\n", err);
} else {
printf("expires %"PRIu32" seconds after key's creation time.\n",
expiration_time);
}
}
```
Результаты:
```
#1 (doesn't expire) valid till 1714111110 seconds after epoch; expires 0 seconds after key's creation time.
#2 (expires) valid till 1714111110 seconds after epoch; expires 94670781 seconds after key's creation time.
#3 (expired) valid till 1619527593 seconds after epoch; expires 86400 seconds after key's creation time.
#4 (invalid sig) valid till 0 seconds after epoch; invalid, skipping.
#5 (no sig) valid till 0 seconds after epoch; invalid, skipping.
```
Теперь мы получили те результаты, которых добивались! Мы выводим на экран правильное время истечения для первых трех подключей, а также указываем, что последние два подключа недействительны.
Но давайте подробнее рассмотрим `rnp_key_valid_till`. Во-первых, в OpenPGP время истечения ключа хранится как беззнаковый 32-разрядный отступ от времени создания ключа, также в беззнаковом 32-разрядном формате. Следовательно, функция должна была бы использовать более широкий тип или, как минимум, проверять код на переполнение. (Я [сообщил об этой проблеме](https://github.com/rnpgp/rnp/issues/1480), и ее уже исправили.)
Но, даже если игнорировать этот косяк, функция все равно странная. В OpenPGP ключ может быть действителен в течение нескольких периодов времени. Допустим, срок действия ключа истекает 1 июля, а пользователь продлевает его только с 10 июля. В период с 1 по 10 июля ключ был недействителен, а подписи, сгенерированные в это время, также должны считаться недействительными. Итак, что же должна возвращать рассматриваемая функция для такого ключа? Гораздо важнее, как пользователь такого API должен интерпретировать результат? Уместно ли вообще использовать такой API? ([Да, я спрашивал](https://github.com/rnpgp/rnp/issues/1483).)
В Sequoia мы пошли другим путем. Вместо того, чтобы возвращать информацию, что ключ действителен, мы переворачиваем ситуацию; пользователь API может спросить: [действителен ли этот ключ в момент t](https://docs.sequoia-pgp.org/sequoia_openpgp/cert/struct.Cert.html#method.with_policy). По нашему опыту, это все, что на самом деле требовалось во всех известных нам случаях.
Не подумайте, что я специально придираюсь именно к этой проблеме с API RNP. Это просто [сложность](https://bugzilla.mozilla.org/show_bug.cgi?id=1706270), о которой я недавно размышлял. Когда мы заново реализовали API RNP, чтобы создать [альтернативный бэкенд OpenPGP](https://gitlab.com/sequoia-pgp/sequoia-octopus-librnp) для Thunderbird, мы столкнулись [со многими подобными проблемами](https://gitlab.com/sequoia-pgp/sequoia-octopus-librnp/-/blob/main/notes.org).
Заключение
----------
Ошибки, допущенные разработчиками RNP, понятны и простительны. OpenPGP сложен, как и многие другие протоколы. Но его можно существенно упростить, если мы стремимся сохранить его гибкую и надежную [ИОК](https://en.wikipedia.org/wiki/Public_key_infrastructure), а не просто иметь инструмент для шифрования файлов.
Тем не менее, API RNP опасен. А Thunderbird *используется* в контекстах с критическими требованиями к безопасности. [В интервью от 2017](https://youtu.be/6DqfWz-KHSI?t=350) года [Михал ‘Рысьек’ Возняк](http://rys.io/) из Центра по исследованию коррупции и организованной преступности (OCCRP) четко сообщил, что на кону чьи-то жизни:
Я действительно категорически уверен, что, если бы мы не использовали GnuPG все это время, то многие наши информаторы и журналисты оказались бы в опасности или за решеткой…
[Интервью](https://youtu.be/6DqfWz-KHSI?t=350) с [Михалом ‘Рысьеком’ Возняк](http://rys.io/)ом из Центра по исследованию коррупции и организованной преступности
Как это отразится на Thunderbird? Вижу три варианта. Во-первых, Thunderbird мог бы переключиться обратно на Enigmail. Можно подумать, что портирование Enigmail на Thunderbird 78 далось бы сложно, но я слышал от многих разработчиков Thunderbird, что это технически осуществимо вполне подъемными усилиями. Но одна из причин, по которым Thunderbird предпочла уйти от Enigmail – огромное время, которое разработчикам Enigmail приходилось тратить, чтобы помочь пользователям правильно установить и сконфигурировать GnuPG. Поэтому такой путь неидеален.
Во-вторых, Thunderbird могла бы переключиться на иную реализацию OpenPGP. В наше время их [целая куча](https://tests.sequoia-pgp.org/) на выбор. Лично я считаю, что Thunderbird следовало бы переключиться на Sequoia. Конечно же, я разработчик Sequoia, поэтому необъективен. Но дело здесь не в деньгах: мне платит фонд, а на свободном рынке мне предложили бы, пожалуй, вдвое больше, чем я зарабатываю сейчас. Я работаю ради того, чтобы защитить пользователей. Но, даже кроме API Sequoia и преимуществ реализации, Thunderbird в данном случае выигрывает и еще в одном отношении: мы уже заставили эту реализацию работать. Несколько недель назад мы выпустили [Octopus](https://gitlab.com/sequoia-pgp/sequoia-octopus-librnp), альтернативный бекенд OpenPGP для Thunderbird. У него не только функциональный паритет с RNP, но и есть ряд ранее недостававших фич, например, интеграция с gpg, а также залатаны некоторые бреши в безопасности и выполнено несколько нефункциональных требований.
В-третьих, Thunderbird мог бы вообще отказаться от использования OpenPGP. Такое решение меня не устраивает. Но несколько раз мне доводилось беспокоиться о безопасности наиболее уязвимых пользователей Thunderbird, и я считаю, что не предоставлять никакой поддержки OpenPGP вообще – это решение, возможно, даже более безопасное, чем статус-кво.
---
[VPS от Маклауд](https://macloud.ru/?partner=4189mjxpzx) идеально подходят для разработки API.
Зарегистрируйтесь по ссылке выше или кликнув на баннер и получите 10% скидку на первый месяц аренды сервера любой конфигурации!
[](https://macloud.ru/?partner=4189mjxpzx&utm_source=habr&utm_medium=perevod&utm_campaign=oleg) | https://habr.com/ru/post/556974/ | null | ru | null |
# Переезд на кластер под управлением «1С-Битрикс: Веб-окружение»
В определённый момент появилась задача — перевести, существующий и активно работающий в production, проект на работу в кластере серверов. Т.к. проект разработан на базе 1C-Bitrix, было принято решение построить кластер с использованием «1С-Битрикс»: Веб-окружение». Цель данного мероприятия — получить возможность выдерживать большие нагрузки при наплывах посетителей сайта, а также возможность в дальнейшем быстрее масштабироваться горизонтально.
Собственно, если мы обратимся на [сайт](https://www.1c-bitrix.ru/products/env/) вендора, то там увидим что:
**«1С-Битрикс»: Веб-окружение» — Linux служит для быстрой и простой установки всего ПО, необходимого для работы продуктов и решений «1С-Битрикс» на Linux-платформах CentOS 6 (i386, x86\_64) и CentOS 7 (x86\_64). Устанавливать необходимо на «чистый» CentOS, без уже установленного веб-сервера.**
В состав «1С-Битрикс: Веб-окружение» — Linux входят: mysql-server, httpd, php, nginx, nodejs push-server, memcached, stunnel, catdoc, xpdf, munin, nagios, sphinx.
По сути, данный комплекс ПО содержит в себе настроенный LAMP, консольную панель управления сервером, плюс дополнительные, необходимые для работы некоторых модулей 1C-Bitrix, пакеты. Весь софт настроен с учётом особенностей 1C-Bitrix, а именно:
* установлены необходимые расширения (gd, zip, socket, mbstring)
* включена поддержка short-тегов
* заданы необходимые значения для параметров memory\_limit, max\_input\_vars, safe mode, opcache.validate\_timestamps, opcache.revalidate\_freq, mbstring.func\_overload, default\_charset, display\_errors и др.
* установлен одинаковой часовой пояс для БД, php и на самом сервере
* и др.
Это позволяет в большинстве случаев не заниматься настройкой сервера и его тюнингом.
Итак, у нас было 2 app сервера (назовём их app01 и app01), 2 db сервера (db01, db02), 1 сервер под кэширование (cache01, ну вы поняли), точнее была идея реализовать структуру кластера подобным образом. Под этот план были получены 5 серверов, с установленными на них последними версиями centos7 (к сожалению, debian, ubuntu, fedora, rhel и др. не подходят), кроме os на серверы больше ничего не устанавливалось.
Т.к. мы собираем кластер, то необходимо определить, какой из серверов будет основным. Из-за особенностей балансировки запросов к приложению, один из серверов, где будет работать httpd, будет также содержать nginx. Все входящие запросы будет принимать также он, и после этого перенаправлять запрос на одну из доступных web-нод. Мы выбрали основным сервер app01.
В дальнейшем работа пошла по следующему плану:
#### 1. Установить bitrixenv
Установка не подразумевает сверхъестественных знаний linux или администрирования. Заходим на каждый сервер через ssh и выполняем такие команды:
```
cd ~
wget http://repos.1c-bitrix.ru/yum/bitrix-env.sh
chmod +x bitrix-env.sh
./bitrix-env.sh
```
Ставить bitrixenv необходимо на все серверы, которые планируется использовать в кластере. Даже если сервер будет работать только как инстанс memcached, bitrixenv необходим, т.к. позволяет управлять всем кластером из основного сервера.
#### 2. Настроить bitrixenv
Т.к. использовать весь этот зоопарк мы будем как кластер, то производить настройку серверов можно через меню окружения на app01. Для этого заходим на сервер через ssh, и запускаем файл /root/menu.sh. При первом запуске необходимо задать пароль для пользователя bitrix (аналогичную операцию необходимо провести на всех серверах, где планируется запуск сайта):
Собственно, это тот пользователь, под которым будет работать приложение. После этого мы видим экран, предлагающий создать пул серверов:
Тут нам необходимо выбрать первый пункт меню. В процессе создания окружение запросит имя текущего сервера, тут то мы и указываем app01:
После того, как пул будет создан, нас возвращают на первый экран окружения, но на этот раз там доступно куда больше пунктов:
В общем окружение уже готово и можно им пользоваться. Если кластер нам не нужен, то на этом можно было бы и заканчивать, но мы пойдём дальше.
Теперь нам необходимо добавить в созданный пул все доступные серверы. Для этого воспользуемся первым пунктом меню и увидим такие варианты:
Опять выбираем первый пункт меню, и указываем ip нового сервера, его имя в кластере (те самые app02, db01, db02, cache01) и root-пароль от подключаемого сервера. Таким образом, поочерёдно добавляем каждый имеющийся сервер. После того, как все серверы зарегистрированы в кластере, мы должны получить примерно такой список на главном экране окружения:
Настройку ролей серверов пока отложим на следующий шаг.
#### 3. Перенос проекта
Т.к. наше приложение изначально работает на одном сервере, то модуль масштабирования и управления кластером отключены, база не реплицирована. Сам перенос ничего сверхъестественного из себя не представляет — упаковали папки bitrix и upload, сняли дамп БД.
После того, как архивы и дампы готовы, заходим на app01, и тянем через git код проекта в дефолтную папку сайта в bitrixenv — /home/bitrix/www, скачиваем wget-ом или curl-ом архивы и дамп БД, распаковываем архивы и заливаем дамп в БД на app01, переносим записи cron.
Если ваше приложение использует дополнительный софт, то самое время его установить и настроить. В нашем случае были установлены и настроены supervisord и RabbitMQ, т.к. приложение работало с использованием очередей.
Есть небольшой, но важный, нюанс. При переносе сайта в кластер, необходимо чтобы на сайте были отключены модули scale и cluster, а в окружении кластера, в которое планируется перенос, серверы пулла были не задействованы. Включать в работу серверы кластера необходимо только после того, как сайт будет перенесён и развёрнут на основном сервере. В противном случае сайт не сможет корректно определять серверы кластера.
#### 4. Включение кластерного режима работы
После того, как приложение было перенесено на app01, и мы проверили корректность его работы, пришла пора заняться самым интересным — масштабированием. Для начала необходимо установить модули scale и cluster в админ-панели 1C-Bitrix. Во время установки ничего особо делать не нужно, вся работа происходит далее.
Как только модули установлены, переходим в ssh-соединение с основным сервером, а это app01, и открываем меню bitrixenv (лежит тут /root/menu.sh). Прежде чем приступить к дальнейшей настройке, необходимо выяснить один важный момент — bitrixenv оперирует понятием “роль сервера”. Не имеет особого значения, как называется сервер в пуле, т.к. каждый сервер содержит весь софт, который входит в пакет bitrixenv, мы всегда можем назначить ему одну или несколько ролей, а можем снять их с него или поменять на другие. Основные роли это — mgmt (балансировщик, т.е. nginx), web (т.е. httpd/apache), mysql\_master и mysql\_slave (инстанс БД, slave появляется уже когда начинаем делать репликацию), memcached (сервер с memcached). Общая картина теперь понятна, и мы решили начать с memcached-сервера. Для этого заходим в пункт
```
4. Configure memcahed servers > 1. Configure memcached service
```
и видим запрос имени сервера, который будет выполнять роль memcached-сервера. У нас уже есть заготовленный для этого сервер cache01, поэтому смотрим в список доступных серверов. Если cache01 есть в списке, значит никаких проблем с установкой нет, и мы можем дать серверу выбранную роль.
Вписываем название cache01, видим, что задача на установку роли поставлена в очередь. Дожидаемся окончания фоновых работ и видим готовый к работе сервер с необходимой нам ролью.
Пришло время добавить второй app-сервер. Для этого переходим по пути
```
8. Manage web nodes in the pool > 1. Create web role on server,
```
где нам необходимо указывать имя сервера и способ синхронизации между основной и новой web-нодой. Исходя из документации bitrixenv и предварительных испытаний, нашему проекту было достаточно выбрать первый вариант (за один шаг происходит и копирование проекта и настройка конфигов ноды). После того, как фоновые работы закончатся, мы должны увидеть в главном меню примерно такую картину:
Обратим внимание на то, что в колонке Roles напротив сервера app02 указана роль web.
Осталось разобраться с БД, её настройка занимает больше всего времени. Для начала вкратце объясню, как раздаются роли mysql в контексте bitrixenv. По-умолчанию на основном сервере кластера стоит master версия БД. В нашем случае необходимо было вынести БД на отдельный сервер и добавить ещё один сервер с slave-версией БД. В bitrixenv нельзя просто так взять и перенести master с одного сервера на другой)
Последовательность такая:
1. Даём роль mysql\_slave серверу, на который мы планируем перенести БД
2. На целевом сервере меняем роль mysql\_slave на роль mysql\_master (автоматом старый mysql\_master переходит в режим mysql\_slave)
3. Удаляем роль mysql\_slave на исходном сервере, бывшем master
4. …
5. PROFIT!!!
Мы последовали этой логике таким образом:
Перешли в
```
3. Configure MySQL servers > 4. Create MySQL slave
```
Указали сервер, которому хотим дать роль mysql\_slave — db01. Дожидаемся окончания фоновых работ и видим такой результат:
Отлично, теперь переходим в
```
3. Configure MySQL servers > 5. Change MySQL master
```
Указываем app01 и ждём. В итоге должны увидеть примерно такой результат:
Медленно и неотвратимо мы подошли к установке последней роли — mysql\_slave. Для этого необходимо повторить действия, которыми мы устанавливали такую роль для db01, но указать уже db02.
Наконец, все серверы подключены и настроены.
#### 5. Тюнинг производительности
После того, как кластер готов, есть некоторые особенности в настройке приложения, позволяющие провести дополнительную оптимизацию:
* Прокачиваем работу с сессиями. Подробно описано [здесь](https://dev.1c-bitrix.ru/community/blogs/rns/hidden-features-of-work-with-sessions.php). Вкратце — переключаем хранение сессий в memcached.
* Удаляем файлы /bitrix/php\_interface/after\_connect\_d7.php и /bitrix/php\_interface/after\_connect.php, т.к. команды из них обрывают конвейер кластера (если не используется bitrixenv, то их лучше оставить).
* Увеличиваем количество памяти, выделяемое memcached, и устанавливаем процент использования серверов с ролью memcached до 100%.
* Отключаем модули php: apcu, ldap
* Отключить модули БУС «Компрессия», и “Веб-аналитика” (по возможности).
* Рассмотреть вариант использования локального кэша. Подробнее описано [тут](https://dev.1c-bitrix.ru/community/blogs/rns/the-use-of-local-caches-in-the-cluster.php). В нашем случае прироста не было, но идея интересная. Решение имеет пару особенностей:
+ Количество инстансов memcached должно равняться количеству web-нод.
+ Для отдачи композитного кэша nginx-ом напрямую из локального memcached придётся поковырять конфиг nginx, из коробки не работает.
* Перенести выполнение всех агентов на cron.
### Выводы
В рамках данной статьи мы разобрали последовательность действий, необходимых для настройки кластера серверов на базе bitrixenv, а также некоторых возможных подводных камней. По итогам работы с bitrixenv, и кластером на нём, можем выделить плюсы и минусы данного подхода:
#### Плюсы bitrixenv
* Время установки
Установка и базовая настройка занимает менее 30 минут. Нет необходимости настраивать элементы LAMP (как интеграцию этих служб друг с другом, так и для корректной работы проектов на 1C-Bitrix).
* Службы для ускорения работы сайта
Установленные и настроенные службы, которые позволяют организовать более быстрое кэширование через memcached, а не файлы, поиск с использованием движка sphinx и функционал видеозвонков и чатов на корп.портале (модуль nginx push&pull). Кроме того, nginx в окружении настроен таким образом, что при включении соответствующих опций на сайте и в меню bitrixenv, кэш отдаётся при помощи nginx сразу из memcached (в обход httpd и php)
* Кластеризация
Возможность включить репликацию БД, без ковыряния настроек MySQL. Подключение произвольного количества web-нод, которые будут автоматически синхронизироваться друг с другом, и memcached-нод. Управление распределением нагрузки на web- и memcached-ноды как из меню bitrixenv, так и через админ-панель проекта на 1C-Bitrix. Плюс к этому, добавление новых серверов и ролей к ним не вызывает простой проекта (кроме разве что ролей серверов БД)
#### Минусы bitrixenv
* Балансировщик всегда вместе с основной web-нодой
Т.к. у нас уже был свой балансировщик, мы столкнулись с тем, что невозможно отказаться от встроенного в bitrixenv балансировщика. Нельзя в т.ч. разместить его отдельно от основной web-ноды.
* Много лишнего софта для некоторых ролей
Т.к. каждый сервер в пулле содержит полную версию окружения, то получается что на db-нодах стоят httpd, memcached, sphinx, пусть они и не используются. Аналогично можно встретить MySQL на сервере, который занимается только кэшированием, но в этом случае MySQL можно остановить в меню окружения или админ.панели сайта.
* Php работает в режиме apache2handler
Нет возможности безболезненно включить php в работу в режиме fcgi, не говоря уже о режиме nginx+php-fpm. Так же не получится поменять версию php, без танцев с бубном.
#### Источники:
[www.1c-bitrix.ru/products/env](https://www.1c-bitrix.ru/products/env/)
[dev.1c-bitrix.ru/community/blogs/rns/hidden-features-of-work-with-sessions.php](https://dev.1c-bitrix.ru/community/blogs/rns/hidden-features-of-work-with-sessions.php)
[dev.1c-bitrix.ru/community/blogs/rns/the-use-of-local-caches-in-the-cluster.php](https://dev.1c-bitrix.ru/community/blogs/rns/the-use-of-local-caches-in-the-cluster.php)
[dev.1c-bitrix.ru/learning/course/index.php?COURSE\_ID=32&INDEX=Y](https://dev.1c-bitrix.ru/learning/course/index.php?COURSE_ID=32&INDEX=Y)
[dev.1c-bitrix.ru/learning/course/index.php?COURSE\_ID=37&INDEX=Y](https://dev.1c-bitrix.ru/learning/course/index.php?COURSE_ID=37&INDEX=Y) | https://habr.com/ru/post/430080/ | null | ru | null |
# Работа с виртуальными машинами KVM. Клонирование виртуальных машин
Продолжаем серию статей о виртуализации на базе KVM. В предыдущих статьях было рассказано [об инструментарии](http://habrahabr.ru/blogs/virtualization/120432/), о настройке хост-машины и [создании виртуальной машины](http://habrahabr.ru/blogs/virtualization/120717/). Сегодня мы поговорим о создании образа виртуальной машины и его клонировании.
Исследования вопроса дали удручающие результаты: информацию по созданию образов виртуальных машин в сети очень сложно найти, а та, что есть, качеством и полнотой не отличается.
Для получения образа виртуальной машины в минимальной системе в ней достаточно поменять всего пару файлов чтобы получить нормально работающую систему, но в случае Debian появляются небольшие сложности.
Для создания новой виртуальной машины на основе имеющейся системы нужно внести следующие изменения:
* изменить hostname
* поправить файл hosts
* изменить настройки DNS
* заменить хост-ключи SSH
* изменить пароль для root
Большой находкой для меня оказалась библиотека [libguestfs](http://libguestfs.org/) — она позволяет управлять дисками и оперировать файлами виртуальных машин как в интерактивном режиме, так и по заранее составленному сценарию.
Эту библиотеку написал Richard Jones из небезызвестной компании Red Hat. Она позволяет работать с файловыми системами (начиная от ext2 и заканчивая NTFS в Windows, UFS в FreeBSD — в общем, со всеми файловыми системами, с которыми умеет работать ядро), образами систем, LVM-разделами, в случае установки гостевых ОС из семейства MS Windows — править системный реестр (через библиотеку hivex). В общем, утилита очень богатая возможностями и очень гибкая. И что самое главное — не требует административных (root) прав для ее использования.
#### Исследуем образ
Итак, приступим к работе.
Основным инструментом, с помощью которого мы будем работать с образом гостевой системы, является **guestfish**.
Попробуем произвести некоторые операции в интерактивном режиме:
`$ guestfish
> add-drive debian\_5\_i386.img
> run
> list-filesystems
/dev/vda1: ext3
> mount-vfs rw ext3 /dev/vda1 /
> cat /etc/fstab
# /etc/fstab: static file system information.
#
#
proc /proc proc defaults 0 0
/dev/vda1 / ext3 errors=remount-ro 0 1
/dev/hdc /media/cdrom0 udf,iso9660 user,noauto 0 0`
Что очень здорово — все необходимые операции можно производить и в неинтерактивном режиме (по заранее составленному сценарию). Приведу пример скрипта, который редактирует файлы hosts, hostname и interfaces в системе:
`$ guestfish <
add-drive debian_guest.img
run
mount-vfs rw ext3 /dev/vda1 /
upload -<
127.0.0.1 localhost.localdomain localhost debian_guest.local debian_guest
10.10.10.100 debian_guest.local
END
upload -<
nameserver 8.8.8.8
END
upload -<
debian_guest.local
END
upload -<
auto lo
iface lo inet loopback
allow-hotplug eth0
iface eth0 inet static
address 10.10.10.100
gateway 10.10.10.10
netmask 255.255.255.0
network 10.10.10.0
broadcast 10.10.10.255
END
EOF`
Использование **heredoc** оказалось очень удобным в данном контексте.
(К слову: если возникают какие-либо вопросы по библиотеке, на них сам автор очень быстро отвечает на IRC канале **#libguestfs** на irc.freenode.net. Да и вообще парень очень интересный.)
#### Secure Hell
Как видно из названия, я с этим вопросом достаточно долго промучился: в Debian/Ubuntu автоматической регенерации ключей при их удалении попросту нет. В других системах, которые я пробовал использовать, с этим всё в порядке, а для deb-based операционных систем с этим проблемы.
Я сделал вот так:
`$ guestfish
> add-drive debian\_guest.img
> run
> mount-vfs rw ext3 /dev/vda1 /
> download /etc/init.d/ssh /home/username/debian\_5\_etc\_init\_ssh`
Далее были сделаны следующие изменения:
`--- /home/username/debian_5_etc_init_ssh 2012-12-21 00:00:00.000000000 +0000
+++ /home/username/debian_5_etc_init_ssh_fixed 2012-12-21 00:00:00.000000000 +0000
@@ -32,6 +32,10 @@
([ "$previous" ] && [ "$runlevel" ]) || [ "$runlevel" = S ]
}
+check_ssh_host_key() {
+ if [ ! -e /etc/ssh/ssh_host_key ] ; then
+ echo "Generating Hostkey..."
+ /usr/bin/ssh-keygen -t rsa1 -f /etc/ssh/ssh_host_key -N '' || return 1
+ fi
+ if [ ! -e /etc/ssh/ssh_host_dsa_key ] ; then
+ echo "Generating DSA-Hostkey..."
+ /usr/bin/ssh-keygen -d -f /etc/ssh/ssh_host_dsa_key -N '' || return 1
+ fi
+ if [ ! -e /etc/ssh/ssh_host_rsa_key ] ; then
+ echo "Generating RSA-Hostkey..."
+ /usr/bin/ssh-keygen -t rsa -f /etc/ssh/ssh_host_rsa_key -N '' || return 1
+ fi
+}
+
check_for_no_start() {
# forget it if we're trying to start, and /etc/ssh/sshd_not_to_be_run exists
if [ -e /etc/ssh/sshd_not_to_be_run ]; then
@@ -75,6 +79,7 @@
case "$1" in
start)
+ check_ssh_host_key
check_privsep_dir
check_for_no_start
check_dev_null
@@ -106,6 +111,7 @@
;;
restart)
+ check_ssh_host_key
check_privsep_dir
check_config
log_daemon_msg "Restarting OpenBSD Secure Shell server" "sshd"`
*Внимание, патч нерабочий, он приведён как пример необходимых изменений.*
И для двух версий Debian/Ubuntu я сделал аналогичный файл с уже изменённым файлом ssh. Далее его можно просто загрузить в виртуальную машину.
`> upload /home/username/debian\_5\_etc\_init\_ssh\_fixed /etc/init.d/ssh`
А теперь удалим ключи, чтобы они сгенерировались автоматически:
`> glob rm /etc/ssh\_host\_\*\_key\*`
Удаление по маске не работает. Поскольку в API данный метод не реализован, префикс glob позволяет развернуть маску в список файлов.
Для FreeBSD и CentOS достаточно просто удалить ключи, при старте они сами сгенерируются.
#### Идентификация пользователей
Для начала стоит рассказать о том, как представлено хранение информации о пользователях в Linux/FreeBSD. Это будет немного занудно, но необходимо для понимания того, что мы всё-таки делаем. Хотя по минимуму достаточно информации только о shadow-файле.
Вся необходимая для аутентификации пользователей хранится в файлах /etc/passwd и /etc/shadow(/etc/master.passwd в FreeBSD).
Рассмотрим структуру файла /etc/passwd
`root:x:0:0:root:/root:/bin/bash`
Процитирую из [вики](http://ru.wikipedia.org/wiki//etc/passwd#.D0.9F.D1.80.D0.B8.D0.BD.D1.86.D0.B8.D0.BF.D1.8B) порядок использования полей:
* регистрационное имя или логин
* хеш пароля (сейчас не используется, используется скрытый в shadow пароль)
* идентификатор пользователя
* идентификатор группы по умолчанию
* информационное поле GECOS
* начальный (он же домашний) каталог
* регистрационная оболочка, или shell
Рассмотрим структуру **/etc/shadow**
`root:$1$APv1HQOB$HJQhYFq9JSnhusQ.1Ql10.:14977:0:99999:7:::`
Опять же [из wiki](http://ru.wikipedia.org/wiki//etc/passwd#.D0.A4.D0.B0.D0.B9.D0.BB_.2Fetc.2Fshadow):
* имя пользователя
* хэш пароля
* дата последнего изменения пароля
* через сколько дней можно будет поменять пароль
* через сколько дней пароль устареет
* за сколько дней до того, как пароль устареет, начать напоминать о необходимости смены пароля
* через сколько дней после того, как пароль устареет, заблокировать учётную запись пользователя
* дата, при достижении которой учётная запись блокируется
* зарезервированное поле
Нам нужно изменить конкретно второе поле (хэш пароля). Его можно разбить на три части:
* 1 — тип шифрования md5, 2 — SHA512 (поправьте меня если я не прав)
* APv1HQOB — соль, через которую шифруется пароль
* HJQhYFq9JSnhusQ.1Ql10. — непосредственно хэш пароля с солью.
Хэш генерируется командой:
`$ mkpasswd --method=md5 --salt="APv1HQOB" "$password"
$1$APv1HQOB$HJQhYFq9JSnhusQ.1Ql10.`
Его нам и нужно подставить в файл /etc/shadow.
Я написал небольшой скрипт, который будет генерировать случайный пароль и соль длиной 8 символов, выводить его, генерировать хэш и подставлять его в нужный файл:
`#!/bin/bash
tempfile=`mktemp`
shadow="/etc/shadow"
salt=`pwdgen`
passwd=`pwdgen`
hash=`pwhash $salt $password`
hash_esc=`escape_hash $hash `
pwdgen() {
charspool=('a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 'u' 'v' 'w' 'x' 'y' 'z' '0' '1' '2' '3' '4' '5' '6' '7' '8' '9' '0' 'A' 'B' 'C' 'D' 'E' 'F' 'G' 'H' 'I' 'J' 'K' 'L' 'M' 'N' 'O' 'P' 'Q' 'R' 'S' 'T' 'U' 'V' 'W' 'X' 'Y' 'Z');
len=${#charspool[*]}
for c in $(seq 8); do
echo -n ${charspool[$((RANDOM % len))]}
done
}
pwhash(){
salt=$1
password=$2
hash=`mkpasswd --method=md5 --salt=$salt $password`
echo $hash
}
# Функция нужна, чтобы sed корректно отработал закрывающие слэши и знаки $
escape_hash() {
echo $1 | sed -e 's/\//\\\//g' -e 's/\$/\\\$/g'
}
guestfish <
add-drive debian_guest.img
run
mount-vfs rw ext3 /dev/vda1 /
download /etc/shadow $tempfile
! sed 's/^root:[^:]\+:/root:$hash_esc:/' $tempfile > $tempfile.new
upload $tempfile.new $shadow
EOF`
Как вы наверняка заметили, мы использовали внешнюю команду внутри скрипта, в которой мы заменили содержимое первой секции на полученный в скрипте хэш. Для этого используется внешний оператор "**!** ": он очень удобен, когда нам нужно сделать какие-то небольшие операции, не прерывая процесс работы с **guestfish** (поскольку на запуск **guestfish** всё таки требуется некоторое время).
#### Подготовка мастер-образа
Поскольку образы требуется периодически обновлять (в случае выхода важных обновлений или исправления ошибки в образе), нам следует подготовить мастер-образы, в которых мы будет производить необходимые манипуляции. Для разворачивания мы будем готовить эти образы при помощи отдельного скрипта.
Что нам нужно убрать в нашем образе:
1. Очистить логи
2. Удалить следы пребывания в системе
3. Удалить скачанные пакеты (актуально для Debian и Ubuntu, только они мусорят)
4. Удалить файл с настройками сетевой карты
5. Удалить ключи.
После этого нам нужно будет уменьшить размер файловой системы, уменьшить раздел и отрезать от образа лишнее.
Приложу небольшой участок кода, который выполняет первую часть необходимого действия:
`guestfish <
add-drive debian_guest.img
run
mount-vfs rw ext3 /dev/vda1 /
upload /home/username/debian_5_etc_init_ssh_fixed /etc/init.d/ssh
-glob rm /etc/ssh/ssh_host_*
-glob rm /etc/udev/rules.d/70-persistent-net.rules
-glob rm /root/*
-glob rm /root/.*
-glob rm /var/log/*
-glob rm /var/cache/apt/archives/*deb`
EOF
Флаг "-" перед командой означает, что мы не должны выходить, если какая-то из команд вернёт **-1**. Это сделано специально, чтобы отсутствие каких-либо файлов не прерывало выполнение остальных команд; таким образом, кастомизация данного скрипта для различных дистрибутивов становится не нужной, хотя она и возможна.
А теперь приступим к уменьшению образа:
`$ guestfish <
add-drive add-drive ${images}/${os}_${version}_${arch}.img
run
e2fsck-f /dev/vda1
resize2fs-M /dev/vda1
tune2fs /dev/vda1 | grep "Block count:" | sed -e 's/Block\ count:\ //g' -e 's/$/*4+2144/g' | bc > /tmp/block_count
EOF
$ foo=`cat /tmp/block_count`
$ guestfish <
allocate debian_guest_minimal.img ${foo}k
EOF`
Цифра **2144** — это размер загрузчика и таблицы разделов.
Вкратце суть проделанного в следующем: мы ужимаем файловую систему до минимального размера, вычисляем, сколько она стала занимать (минимальное количество блоков), и умножаем их на 4, поскольку размер блока 4 кбайта, после чего создаём образ полученной величины.
После этого нам необходимо будет воспользоваться утилитой **virt-resize** из комплекта утилит **libguestfs**, чтобы перенести получившуюся файловую систему в новый, меньший образ.
`$ virt-resize --shrink /dev/vda1 debian_guestl.img debian_guest_minimal.img`
Следует сразу обговорить ограничения данного метода: это применимо только для файловых систем ext2-4, поскольку resize2fs работает только с ними. Для чего-то нестандартного можно легко допилить нужный функционал (правда, как я уже упоминал [ранее](http://habrahabr.ru/blogs/virtualization/120432/), libguestfs очень сложно собрать). Для образца можно посмотреть мой [патч для реализации resize2fs-M](http://git.annexia.org/?p=libguestfs.git;a=commitdiff;h=4ffa2d6798f7a2bf0baec8e1084659cf6358bc31).
К сожалению с FreeBSD всё сильно сложнее, и пока нет никаких вариантов решения проблемы с ней кроме добавления в конфиг виртуальной машины ещё одного диска и его монтирования.
Теперь же мы должны, по желанию, конечно, упаковать получившийся образ при помощи **xz** (это долго, но результат стоит того):
`$ xz -9 debian_guest.img
$ ls -lsha debian_guest.img.xz
107M -rw-r--r-- 1 username username 107M Dec 21 00:00 debian_guest.img.xz`
#### Разворачивание образа
Итак, образ виртуальной машины мы получили, но образы — это не готовые рабочие системы. Чтобы получить рабочую систему, нам нужно произвести несколько операций:
1. Аллоцировать образ на диск
2. Скопировать загрузчик и таблицу разделов
3. Перенести информацию из шаблона в образ виртуальной машины
4. Расширить файловую систему
5. Сменить пароль root
6. прописать сетевые настройки
Для Linux всё элементарно: в составе **libguestfs** есть замечательная утилита, написанная на OCaml — **virt-resize**, пункты с 2 по 4 выполняются ею без проблем.
По ряду причин на '''guestfish''' реализовать изменение размера диска невозможно (копирование mbr в **guestfish** невозможно), посему нужно использовать более функциональные средства.
`$ guestfish <
allocate debian_guest_clone.img 10G
EOF
$ virt-resize --expand /dev/vda1 debian_guest.img debian_guest_clone.img`
Собственно, это все, что минимально требуется знать для осуществления клонирования образов виртуальных машин.
Следующая статья расскажет про лимитирование ресурсов виртуальных машин. | https://habr.com/ru/post/121218/ | null | ru | null |
# Работа с базами данных в Qt в многопоточном окружении
Все кто разрабатывают приложения на Qt, рано или поздно сталкиваются с работой с БД в многопоточном окружении. И если невнимательно читать Ассистант, то можно натолкнуться на одни очень интересные грабли.
Описание окружения
------------------
Рассмотрим типовую проблему. Вы пишите приложение, работающее с бд, при этом вам необходимо обращаться к БД из нескольких потоков (не важно одновременно или нет). Например такое бывает если вы пишите серверную часть некоего приложения или просто у вас есть логгирующий поток с записью в БД.
Грабли
------
#### Описание граблей
Если внимательно читать ассистант (то есть не только описание классов, но и общие статьи), то мы увидим следующую надпись в описании многопоточного программирования под Qt: «Подключение может быть использовано только тем потоком, который его создал. При этом, перенос самого подключения либо использование запросов из других потоков не поддерживается» (вольный перевод).
#### Объяснение граблей
Таким образом, запланированный нами банальный мутекс на подключение к БД работать к сожалению не будет. Так же (если нам не нужно все время делить подключение между несколькими потоками, а в первой половине работы программы его должен использовать один поток, а потом другой) не будет и работать метод moveToThread(), так хорошо показывающий себя при работе например с сокетами.
Попытка поразмыслить над проблемой
----------------------------------
Ок, мы не можем делить одно подключение между несколькими потоками. Но как мы можем обойти эту проблему? Я вижу два пути:
1. Не париться и делать в каждом потоке свое подключение
2. Обратиться к старому доброму паттерну Singleton
Ну первый вариант слишком прост и не подходит для варианта, когда потоки создаются, что-то делают с БД и почти сразу умирают (будут лишник накладные расходы на коннект). Хотя для части случаев первый вариант подходит идеально;)
Итак, второй способ.
Немного теории о паттерне
-------------------------
Паттерн Singleton подразумевает, что у нас может быть только один объект определенного класса и при любом обращении будет исполняться код в рамках этого объекта. Далее в статье мы слегка отступим от канонической формы этого паттерна, но об этом позже.
Реализация Singleton на C++
---------------------------
Чтобы реализовать данный паттерн мы должны запретить следующее для класса:
1. Создание нового объекта
2. Создание копии объекта
3. Операцию присвоения объекта
Также мы должны дать возможность получить этот самый единственный экземпляр класса.
Класс назовем DatabaseAccessor. Напишем минимальную реализацию синглтона.
> `//databaseaccessor.h
>
>
>
> class DatabaseAccessor
>
> {
>
> public:
>
> static DatabaseAccessor\* getInstance();
>
>
>
> private:
>
> DatabaseAccessor();
>
> DatabaseAccessor(const DatabaseAccessor& );
>
> DatabaseAccessor& operator=(const DatabaseAccessor& );
>
> };
>
>
>
> //databaseaccessor.cpp
>
>
>
> DatabaseAccessor::DatabaseAccessor()
>
> {
>
> }
>
>
>
> DatabaseAccessor\* DatabaseAccessor::getInstance()
>
> {
>
> static DatabaseAccessor instance;
>
> return &instance
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
То есть мы просто при первом обращении к DatabaseAccessor::getInstance() создаем объект и его возвращаем. В дальнейшем мы возвращаем этот же объект.
Добавляем подключение к БД
--------------------------
Ну тут все просто, добавляем в конструктор подключение к БД.
> `//databaseaccessor.h
>
>
>
> class DatabaseAccessor
>
> {
>
> public:
>
> static DatabaseAccessor\* getInstance();
>
> static QString dbHost;
>
> static QString dbName;
>
> static QString dbUser;
>
> static QString dbPass;
>
> private:
>
>
>
> DatabaseAccessor();
>
> DatabaseAccessor(const DatabaseAccessor& );
>
> DatabaseAccessor& operator=(const DatabaseAccessor& );
>
> QSqlDatabase db;
>
> };
>
>
>
> //databaseaccessor.cpp
>
>
>
> DatabaseAccessor::DatabaseAccessor()
>
> {
>
>
>
> db = QSqlDatabase::addDatabase("QMYSQL");
>
> db.setHostName(dbHost);
>
> db.setDatabaseName(dbName);
>
> db.setUserName(dbUser);
>
> db.setPassword(dbPass);
>
> if (db.open())
>
> {
>
> qDebug("connected to database");
>
> }
>
> else
>
> {
>
> qDebug("Error occured in connection to database");
>
> }
>
> }
>
>
>
> DatabaseAccessor\* DatabaseAccessor::getInstance()
>
> {
>
> static DatabaseAccessor instance;
>
> return &instance
>
> }
>
>
>
> //main.cpp
>
>
>
> int main(int argc, char \*argv[])
>
> {
>
> //...
>
> DatabaseAccessor::dbHost = "localhost";
>
> DatabaseAccessor::dbName = "our\_db";
>
> DatabaseAccessor::dbUser = "root";
>
> DatabaseAccessor::dbPass = "";
>
> DatabaseAccessor::getInstance();
>
> //...
>
>
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
При инциализации программы мы просто прописали нужные данные для доступа к БД и создали объект подключения к БД.
И что дальше?
-------------
Теперь нам необходимо дать возможность работать с этой БД. Для начала реализуем возможность простого запроса без получения данных обратно (апдейт, удаление, вставка без необходимости знания нового id).
> `//databaseaccessor.h
>
>
>
> class DatabaseAccessor
>
> {
>
> public:
>
> static DatabaseAccessor\* getInstance();
>
> static QString dbHost;
>
> static QString dbName;
>
> static QString dbUser;
>
> static QString dbPass;
>
>
>
> public slots:
>
> void executeSqlQuery(QString);
>
>
>
> private:
>
>
>
> DatabaseAccessor();
>
> DatabaseAccessor(const DatabaseAccessor& );
>
> DatabaseAccessor& operator=(const DatabaseAccessor& );
>
> QSqlDatabase db;
>
> };
>
>
>
> //databaseaccessor.cpp
>
>
>
> DatabaseAccessor::DatabaseAccessor()
>
> {
>
>
>
> db = QSqlDatabase::addDatabase("QMYSQL");
>
> db.setHostName(dbHost);
>
> db.setDatabaseName(dbName);
>
> db.setUserName(dbUser);
>
> db.setPassword(dbPass);
>
> if (db.open())
>
> {
>
> qDebug("connected to database");
>
> }
>
> else
>
> {
>
> qDebug("Error occured in connection to database");
>
> }
>
> }
>
>
>
> DatabaseAccessor\* DatabaseAccessor::getInstance()
>
> {
>
> static DatabaseAccessor instance;
>
> return &instance
>
> }
>
>
>
> void DatabaseAccessor::executeSqlQuery(QString query)
>
> {
>
> QSqlQuery sqlQuery(query, db);
>
> }
>
>
>
> //ourthread.h
>
>
>
> class OurThread : public QThread
>
> {
>
> Q\_OBJECT
>
> //...
>
> signals:
>
> void executeSqlQuery(QString);
>
> //...
>
> }
>
>
>
> //ourthread.cpp
>
>
>
> OurThread::OurThread()
>
> {
>
> connect(this, SIGNAL(executeSqlQuery(QString)), DatabaseAccessor::getInstance(), SLOT(executeSqlQuery(QString)));
>
> }
>
>
>
> void OurThread::run()
>
> {
>
> emit executeSqlQuery("DELETE FROM users WHERE uid=5");
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Тут мы создаем в нашем синглтоне паблик слот, который принимает строку запроса и посылает ее БД. В типовом потоке мы создаем сигнал и соединяем его со слотом синглтона. При запуске потока отправляем запрос на удаление юзера с id 5.
А как же получить результат запроса?
------------------------------------
Во-первых нам необходимо сначала решить, что мы хотим от нашего синглтона. Либо мы хотим чтобы он выполнял большое количество разнообразных запросов (аналог обычного класса для работы с БД), либо у нас есть некий набор типовых запросов, которые нам необходимо выполнять. Во втором варианте мы можем перенести всю валидацию в наш синглтон и тем самым уменьшить количество кода в проекте;) По старой традиции будем реализовывать второй вариант;) Добавим метод, который будет проверять логин/пароль пользователя.
> `//databaseaccessor.h
>
>
>
> class DatabaseAccessor
>
> {
>
> public:
>
> static DatabaseAccessor\* getInstance();
>
> static QString dbHost;
>
> static QString dbName;
>
> static QString dbUser;
>
> static QString dbPass;
>
>
>
> public slots:
>
> void executeSqlQuery(QString);
>
> void validateUser(QString, QString);
>
>
>
> private:
>
>
>
> DatabaseAccessor();
>
> DatabaseAccessor(const DatabaseAccessor& );
>
> DatabaseAccessor& operator=(const DatabaseAccessor& );
>
> QSqlDatabase db;
>
> };
>
>
>
> //databaseaccessor.cpp
>
>
>
> DatabaseAccessor::DatabaseAccessor()
>
> {
>
>
>
> db = QSqlDatabase::addDatabase("QMYSQL");
>
> db.setHostName(dbHost);
>
> db.setDatabaseName(dbName);
>
> db.setUserName(dbUser);
>
> db.setPassword(dbPass);
>
> if (db.open())
>
> {
>
> qDebug("connected to database");
>
> }
>
> else
>
> {
>
> qDebug("Error occured in connection to database");
>
> }
>
> }
>
>
>
> DatabaseAccessor\* DatabaseAccessor::getInstance()
>
> {
>
> static DatabaseAccessor instance;
>
> return &instance
>
> }
>
>
>
> void DatabaseAccessor::executeSqlQuery(QString query)
>
> {
>
> QSqlQuery sqlQuery(query, db);
>
> }
>
>
>
> void DatabaseAccessor::validateUser(QString login, QString pass)
>
> {
>
> login.remove(QRegExp("['\"]"));
>
> pass.remove(QRegExp("['\"]"));
>
> QString query = "SELECT IFNULL(uid, -1) as user\_id FROM users WHERE username='"+login+"' AND password='"+pass+"'";
>
> QSqlQuery sqlQuery(query, db);
>
> if (sqlQuery.first())
>
> {
>
> long userId = sqlQuery.value(0).toInt();
>
> QMetaObject::invokeMethod(sender(), "setUserId", Qt::DirectConnection, Q\_ARG(long, userId));
>
> }
>
> else
>
> {
>
> QMetaObject::invokeMethod(sender(), "setUserId", Qt::DirectConnection, Q\_ARG(long, -1));
>
> }
>
> }
>
>
>
> //ourthread.h
>
>
>
> class OurThread : public QThread
>
> {
>
> Q\_OBJECT
>
> //...
>
> signals:
>
> void executeSqlQuery(QString);
>
> void validateUser(QString, QString);
>
>
>
> public slots:
>
> void setUserId(long);
>
>
>
> private:
>
> bool lastResultQueryIsReallyLast;
>
> long userId;
>
> bool checkUser(const char\*, const char\*);
>
>
>
> //...
>
> }
>
>
>
> //ourthread.cpp
>
>
>
> OurThread::OurThread()
>
> {
>
> lastResultQueryIsReallyLast = false;
>
> connect(this, SIGNAL(validateUser(QString,QString)), DatabaseAccessor::getInstance(), SLOT(validateUser(QString,QString)), Qt::BlockingQueuedConnection);
>
> connect(this, SIGNAL(executeSqlQuery(QString)), DatabaseAccessor::getInstance(), SLOT(executeSqlQuery(QString)));
>
> }
>
>
>
> void OurThread::run()
>
> {
>
> checkUser("user", "password");
>
> }
>
>
>
> bool OurThread::checkUser(const char\* login, const char\* pass)
>
> {
>
> emit validateUser(login, pass);
>
> while (!lastResultQueryIsReallyLast)
>
> {
>
> msleep(1);
>
> }
>
> lastResultQueryIsReallyLast = false;
>
> return (userId > 0);
>
> }
>
>
>
> void OurThread::setUserId(long userId)
>
> {
>
> this->userId = userId;
>
> lastResultQueryIsReallyLast = true;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Тут мы добавили еще один слот в наш синглтон, который принимает 2 параметра (логин и пароль). Также в нашем потоке мы его соединили с сигналом в режиме «очереди с блокировкой» (то есть слот будет выполняться в контексте потока с синглтоном, но наш поток будет ждать пока сигнал не дойдет до адресата). Также мы добавили в наш поток слот, который принимает id найденного пользователя. При старте поток емитит сигнал на проверку пользователя и ждет пока не придет ответ (за это отвечает переменная lastResultQueryIsReallyLast). Естественно, синглтон не знает всех своих потоков-пользователей, поэтому используется метод invokeMethod() для вызова метода у объекта, которого вернет sender() (это метод, который возвращает отправителя сигнала если мы находимся в слоте). Причем метод сендера вызывается напрямую, чтобы не ждать следующего прохода цикла событий.
Впринципе, первый метод (когда мы делаем более общие методы доступа к БД) легко получается из второго. Просто надо в методе синглтона обойти все ряды, возвращенные БД и запихнуть их в какой-нибудь QList, который вернуть отправителю запроса.
В заключение
------------
Впринципе, получилось не сложно и вполне приятно.
Плюс, мы имеем возможность разбить на несколько коннектов (помните я говорил об отступлении от паттерна). В этом случае нам надо слегка переписать метод получения инстанции (надо добавить балансировку по нескольким инстанциям и возврат наименее занятой плюс конечно надо запоминать кто какую инстанцию взял), также надо добавить в создание БД наименование подключения (например название можно генерировать по первому объекту, который получил доступ к этой инстанции) и добавить метод, который будет возвращать нужное название подключение исходя из отправителя запроса. | https://habr.com/ru/post/52536/ | null | ru | null |
# Удаляем фон у фото используя CoreML
Всем привет! Однажды передо мной встала задача сделать фон картинки прозрачным, без мам, пап и бекндов... Задача есть, надо её решать! В этой статье вы узнаете, с чем мне пришлось столкнуться и как я реализовал вырезание заднего фона у фотографий в приложении на iOS.
Зачем вообще вот это вот всё ?
------------------------------
В приложении, над которым я работаю, есть редактор создания коллажа. Коллаж создаётся из фотографий одежды, аксессуаров, обуви и прочего. Все фотографии нашего каталога, имеют белый фон, но для реализации качественного результата этот фон нужно вырезать, а иначе получится мозаика из фотографий. Исторически, обрезание фона происходило ~~на~~ ~~бекенде~~ на устройстве силами библиотеки GPUImage, но результат оставлял желать лучшего...
Пример обрезания фона с использованием GPUImageКак можно заметить, присутствует очень много "снега" и артефактов.
**Решено**, внедряем машинное обучение !
Ищем способ удаления заднего фона
---------------------------------
На просторах интернета есть хорошие туториалы, описывающие удаление фона с использованием модели машинного обучения **DeeplabV3**, представленной на официальном [сайте Аpple](https://developer.apple.com/machine-learning/models/). Только есть одно **но**. Данная моделька распознаёт ограниченный набор натренированных объектов и если скормить ей картинку с кроссовками или сумкой, она просто не распознает объекта на ней.
Продолжительный гуглинг открыл для меня прекрасную модель под названием [u2Net](https://github.com/xuebinqin/U-2-Net). Данная модель очень качественно сегментирует фотографию на объекты, расположенные на ней. Но на страничке гитхаба модельки лежат в неведомом формате .pth, а ведь наш родной CoreML принимает только формат .mlModel, что делать ?
Есть два пути:
1. Используем [официальную python тулзу](https://coremltools.readme.io/docs) для конвертации моделей в .mlModel формат
2. Заходим на [страничку гитхаба](https://github.com/john-rocky/CoreML-Models), где сконвертировали всё за вас
Выбор очевиден 😅
Внедряем U2Net в своё приложение
--------------------------------
И так, для того, что бы магия свершилась, нам нужно, чтобы моделька оказалась внутри нашего приложения. Самый простой путь - перетащить её в директорию. На выбор вам предоставляется две модели, u2Net и u2Netp, пока выбирайте любую, в чём их отличие помимо размера мы поговорим далее.
Модель машинного обучения среди файловПосле того как модель окажется внутри вашего файлового дерева, будет сгенерирован класс для импортированной модели, название его вы увидите на страничке модельки.
Расположение названия классаНаконец-то настало время попрограммировать. Разминаем пальчики !
Давайте, для удобства сделаем функцию, которая будет присутствовать у каждого экземпляра UIImage класса, что бы, если нам вздумается, мы могли вырезать фон где угодно !! И забегая немного вперёд, уточню, что модель машинного обучения принимают изображения строго определённого размера, который описан на страничке модели во вкладке **Predictions.**
Размеры входного изображения
```
import UIKit
extension UIImage {
func removeBackgroudIfPosible() -> UIImage? {
let resizedImage: UIImage = resize(size: .init(width: 320, height: 320))
...
}
}
```
Используемая функция resize
```
extension UIImage {
func resize(size: CGSize? = nil, insets: UIEdgeInsets = .zero, fill: UIColor = .white) -> UIImage {
var size: CGSize = size ?? self.size
let widthRatio = size.width / self.size.width
let heightRatio = size.height / self.size.height
if widthRatio > heightRatio {
size = CGSize(width: floor(self.size.width * heightRatio), height: floor(self.size.height * heightRatio))
} else if heightRatio > widthRatio {
size = CGSize(width: floor(self.size.width * widthRatio), height: floor(self.size.height * widthRatio))
}
let rect = CGRect(x: 0,
y: 0,
width: size.width + insets.left + insets.right,
height: size.height + insets.top + insets.bottom)
UIGraphicsBeginImageContextWithOptions(rect.size, false, scale)
fill.setFill()
UIGraphicsGetCurrentContext()?.fill(rect)
draw(in: CGRect(x: insets.left,
y: insets.top,
width: size.width,
height: size.height))
let newImage = UIGraphicsGetImageFromCurrentImageContext()
UIGraphicsEndImageContext()
return newImage!
}
}
```
Так, картинку мы отресайзили под нужные нам размеры, что дальше, спросите вы ?
Дальше - **магия** машинного обучения и предсказание !!
```
import UIKit
extension UIImage {
func removeBackgroudIfPosible() -> UIImage? {
let resizedImage: UIImage = resize(size: .init(width: 320, height: 320))
guard
let resizedCGImage = resizedImage.cgImage,
let originalCGImage = cgImage,
let mlModel = try? u2netp(),
let resultMask = try? mlModel.prediction(input: u2netpInput(in_0With: resizedCGImage)).out_p1 else {
return nil
}
...
}
}
```
Давайте я опишу, получившийся, жирный guard и что там происходит.
* resizedCGImage - У u2netpInput, есть несколько инициализаторов, мы будем работать с тем, что принимает cgImage;
* originalCGImage - cgImage оригинального изображения, будем использовать далее для наложения маски;
* mlModel - инстанс модели машинного обучения, инициализированный на основе сгенерированного класса;
* **resultMask** - та самая магия! Функция prediction, возвращает нам u2netpOutput, где out\_p1 можно использовать в качестве маски нашего изображения!
Если преобразовать получившуюся маску в картинку, то мы сможем увидеть то, как моделька обработала входящие картинки. Так как возвращаемая картинка имеет размер 320x320, не забудьте заресайзить её под исходные размеры.
```
let originalImage = CIImage(cgImage: originalCGImage)
var maskImage = CIImage(cvPixelBuffer: resultMask)
let scaleX = originalImage.extent.width / maskImage.extent.width
let scaleY = originalImage.extent.height / maskImage.extent.height
maskImage = maskImage.transformed(by: .init(scaleX: scaleX, y: scaleY))
return UIImage(ciImage: maskImage)
```
Маски исходных изображенийВау! Выглядит очень аккуратно, нет снега и каки-то сильных вкраплений, давайте накладывать маску на оригинальную картинку !
Применяем получившуюся маску
----------------------------
У Apple есть [хорошая статья](https://developer.apple.com/documentation/vision/applying_matte_effects_to_people_in_images_and_video), демонстрирующая подход по применения сегментирующей маски к исходному изображению. Её то мы и возьмём за основу с небольшими доработками.
```
let context = CIContext(options: nil)
guard let inputCGImage = context.createCGImage(originalImage, from: originalImage.extent) else {
return nil
}
let blendFilter = CIFilter.blendWithRedMask()
blendFilter.inputImage = CIImage(cgImage: inputCGImage)
blendFilter.maskImage = maskImage
guard let outputCIImage = blendFilter.outputImage?.oriented(.up),
let outputCGImage = context.createCGImage(outputCIImage, from: outputCIImage.extent) else {
return nil
}
return UIImage(cgImage: outputCGImage)
```
Итак, поскольку мы оперируем CIImage и применяем к ней фильтр, я бы хотел сохранить исходное качество, с использованием CIContext удалось этого добиться.
Используя эти не хитрые манипуляции, мы можем взглянуть на результат!
Хочется сказать только одно - **ВАУ**! О такой качественном обрезании мы могли только мечтать, а количество кода, которое пришлось написать, просто мизирное!
Финальная функция для обрезания фото у картинки
```
import UIKit
import CoreML
import CoreImage.CIFilterBuiltins
extension UIImage {
func removeBackgroudIfPosible() -> UIImage? {
let resizedImage: UIImage = resize(size: .init(width: 320, height: 320))
guard
let resizedCGImage = resizedImage.cgImage,
let originalCGImage = cgImage,
let mlModel = try? u2netp(),
let resultMask = try? mlModel.prediction(input: u2netpInput(in_0With: resizedCGImage)).out_p1 else {
return nil
}
let originalImage = CIImage(cgImage: originalCGImage)
var maskImage = CIImage(cvPixelBuffer: resultMask)
let scaleX = originalImage.extent.width / maskImage.extent.width
let scaleY = originalImage.extent.height / maskImage.extent.height
maskImage = maskImage.transformed(by: .init(scaleX: scaleX, y: scaleY))
let context = CIContext(options: nil)
guard let inputCGImage = context.createCGImage(originalImage, from: originalImage.extent) else {
return nil
}
let blendFilter = CIFilter.blendWithRedMask()
blendFilter.inputImage = CIImage(cgImage: inputCGImage)
blendFilter.maskImage = maskImage
guard let outputCIImage = blendFilter.outputImage?.oriented(.up),
let outputCGImage = context.createCGImage(outputCIImage, from: outputCIImage.extent) else {
return nil
}
return UIImage(cgImage: outputCGImage)
}
}
```
Всё круто, но как ты собираешься хранить такую тяжёлую модель ?
---------------------------------------------------------------
Модель машинного обучения u2Net, распространяется в двух версиях, u2Netp - light версия 4.6 мб и u2Net - full версия 175.9 мб . Разница между ними очень ощутима, если обратить внимание на их вес. Полную версию u2Net даже не получится хранить в гите, так что не советую вам комитить код с полной моделькой, если планируете его пушить на github. На результат работы light модели можно взглянуть ниже.
Обрезание фона с использованием Light версии моделиМы же приняли решение хранить в приложении light версию модели, а большую, полную версию модели загружать в фоне, что позволило сохранить функциональность редактора, пока модель не загружена. Если вы захотите сделать тоже самое, Apple и тут о нас подумали и [написали туториал](https://developer.apple.com/documentation/coreml/downloading_and_compiling_a_model_on_the_user_s_device?changes=latest_minor) !
Итог
----
Теперь мы умеем пользоваться моделями машинного обучения в iOS приложении и применять их на практике. Машинное обучение открывает море возможностей для распознания, сегментации, классификации, оценки глубины, обнаружения объектов и позы человека и это всё только про фото, а ведь можно ещё и работать с текстом !
Помимо сторонних моделей машинного обучения, iOS имеет встроенный фраемворк Vision, который, оперируя алгоритмами машинного зрения, поможет вам обнаружить лицо, кисть, штрихкод или человека!
---
Спасибо за прочтение! Надеюсь, что эта статья помогла вам решить аналогичную задачу или просто помогла узнать, как работать с ML моделями в iOS.
> **Используемые материалы**
>
> [Список ML моделей от Apple](https://developer.apple.com/machine-learning/models/)
>
> [Тулза по конвертации моделей в mlModel](https://coremltools.readme.io/docs)
>
> [Конвертированные популярные ML модели](https://github.com/john-rocky/CoreML-Models)
>
> [Статья Apple по применению сегментированной маски](https://developer.apple.com/documentation/vision/applying_matte_effects_to_people_in_images_and_video)
>
> [Статья Apple по загрузки ML модели из сети](https://developer.apple.com/documentation/coreml/downloading_and_compiling_a_model_on_the_user_s_device?changes=latest_minor)
>
> [Статья по удалению фона с использованием **DeeplabV3**](https://medium.com/macoclock/remove-the-image-background-in-swift-using-core-ml-8646ed3a1c14)
>
> | https://habr.com/ru/post/703280/ | null | ru | null |
# Атака на чёрный ящик. Реверс-инжиниринг виртуализированного и мутированного кода
Защита собственного программного обеспечения от реверс инжиниринга достаточно старая проблема, в своё время терзавшая сердца многих shareware разработчиков и не только. Обычно для таких целей применяют протектор, но насколько бы ни был крутой протектор, всегда найдутся люди которые его распилят и взломают. Однако последнее время протекторы стали применять технологии видоизменения кода(мутацию и виртуализацию), которые позволяют из исходного алгоритма сделать кашу, внешне напоминающую 'чёрный ящик'. И действительно встречаются люди, уверенные в том, что виртуализация и мутация исполняемого кода современными коммерческими протекторами является некой панацеей. Понятное дело что любой безопасник скорее ухмыльнётся и не согласится с таким утверждением, ведь люди знающие горькую цену безопасности любые намёки на идеальную защиту скорее всего воспримут как миф и маркетинговую сказку. В этой статье я расскажу о собственном опыте и виденье исследования чёрного ящика коммерческих протекторов и возможных атаках на него. Надеюсь понимание недостатков таких технологий, поможет вам более разумно и эффективно применять их на практике или не применять вообще.
##### 0x00. Разбор механизмов защиты кода
Для начала давайте определим технологии которые мы будем исследовать:
1. Мутирование — это метод обфускации кода, при котором исходный граф потока управления разбивается дополнительными вершинами, ветвлениями, дополняется мусорными инструкциями, циклами, не нарушая исходного алгоритма программы. Часто исходные инструкции мутируются в некоторое подмножество других инструкций выполняющих одну и ту же работу.
2. Виртуализация — это метод обфускации кода, при котором исходные инструкции алгоритма, транслируются в инструкции виртуальной машины, сгенерированной протектором. На место исходного алгоритма встраивается код, который во время выполнения передаёт промежуточные инструкции на вход в виртуальную машину, интерпретирующую их.
Оба способа усложняют как статический так и динамический анализ исполняемого кода и часто протекторы допускают комбинирование способов.
Далее в статье я буду рассматривать бесплатные демо-версии двух протекторов: [VMProtect](http://vmpsoft.com/), [Safengine](http://www.safengine.com/en-us), они позволяют мутировать, виртуализировать и комбинировать оба способа обфускации.
Для наложение технологий мутации и виртуализации кода протекторы предоставляют следующие способы:
1. На этапе разработки, через специальные маркеры (SDK)
Разработчик софта помечает в исходном коде фрагмент защищаемого кода специальными функциями из SDK протектора, затем после компиляции, на этапе установки протектора, данные участки будут обнаружены, вырезаны и обфусцированы.
```
int main ()
{
VMProtectMutate("Critical_code_mut");
... // critical code here
VMProtectEnd();
return 0;
}
```
*Пример пометки исходного кода маркерами VMProtect'a*
2. На этапе протекции, через отладочные файлы
Непосредственно в процессе установки протектора, считываются отладочные файлы (pdb, map) и на их основе определяется карта обьектов приложения. Далее разработчик выбирает какие функции требуется защитить и как, после чего они целиком вырезаются из кода и обрабатываются.
Почему вырезается защищаемый код? Дело в том что при разбавлении кода, его размер значительно увеличивается, а следовательно уместить в исходном сегменте новые инструкции невозможно, поэтому и применяется вырезание кода в собственный участок памяти протектора.
*Упрощенная схема мутации исполняемого кода функции void Test() { printf(«Hello»); }*
##### 0x01. Преимущества и недостатки протекторов
Очевидным преимуществом мутации конечно же является невозможность визуального исследования алгоритма. Перед исследователем на первый взгляд лежит просто тарелка с горой спагетти, разобрать которую в ручную запредельно сложно, именно на это и делают ставки современные протекторы.
Не менее важным является комбинирование различных техник антиотладки, антипатчинга, антихукинга, мутации и т.д. В совокупности всё это ведёт к усложнению процессов анализа, но не останавливает их.
Недостатков у таких технологий тоже хватает. Первый из которых, это потеря производительности, ведь мутируемый код увеличивается в сотни, а то и в тысячи раз. Не меньше это касается и виртуализации, обычно виртуальная машина намного тяжелее мутируемого кода. А если совместить оба подхода, то получается маниакально раздутый код. Причём накладные расходы не всегда оправдывают такую обфускацию, применение мутирующих технологий однобоко направлено на усложние восстановления оригинального графа выполнения программы.
Вот пример трассировки примитивнейшей функции:
```
void test()
{
printf("This is protected message #1\n");
printf("This is protected message #2\n");
}
```
До мутации:
**Trace log**
```
main 00405A2A CALL 004059F0 ESP=0018FEE0
main 004059F0 PUSH EBP ESP=0018FEDC
main 004059F1 MOV EBP,ESP EBP=0018FEDC
main 004059F3 SUB ESP,40 ESP=0018FE9C
main 004059F6 PUSH EBX ESP=0018FE98
main 004059F7 PUSH ESI ESP=0018FE94
main 004059F8 PUSH EDI ESP=0018FE90
main 004059F9 PUSH OFFSET 0040ED10 ESP=0018FE8C
main 004059FE CALL DWORD PTR DS:[<&MSVCR100D.printf>] EAX=00000012, ECX=84CB6CA9, EDX=7418F4B8
main 00405A04 ADD ESP,4 ESP=0018FE90
main 00405A07 PUSH OFFSET 0040ECF8 ESP=0018FE8C
main 00405A0C CALL DWORD PTR DS:[<&MSVCR100D.printf>] EAX=00000014
main 00405A12 ADD ESP,4 ESP=0018FE90
main 00405A15 POP EDI ESP=0018FE94
main 00405A16 POP ESI ESP=0018FE98
main 00405A17 POP EBX ESP=0018FE9C
main 00405A18 MOV ESP,EBP ESP=0018FEDC
main 00405A1A POP EBP ESP=0018FEE0, EBP=0018FF30
main 00405A1B RETN ESP=0018FEE4
```
После мутации протектором Safengine:
**Trace log**
```
main 00405A2A CALL 004059F0 ESP=0018FEE0
main 004059F0 JMP 004C9C6A
main 004C9C6A JMP 004C8391
main 004C8391 CALL 004C82D6 ESP=0018FEDC
main 004C82D6 LEA ESP,[ESP+2] ESP=0018FEDE
main 004C82DA LEA ESP,[ESP+2] ESP=0018FEE0
main 004C82DE PUSH EBP ESP=0018FEDC
main 004C82DF NEG BP EBP=001800D0
main 004C82E2 JMP 004C812E
main 004C812E MOV EBP,ESP EBP=0018FEDC
main 004C8130 STC
main 004C8131 SUB ESP,40 ESP=0018FE9C
main 004C8134 CALL 004C8006 ESP=0018FE98
main 004C8006 JMP SHORT 004C7F96
main 004C7F96 LEA ESP,[ESP+4] ESP=0018FE9C
main 004C7F9A PUSH EBX ESP=0018FE98
main 004C7F9B CALL 004C7F80 ESP=0018FE94
main 004C7F80 LEA ESP,[ESP+4] ESP=0018FE98
main 004C7F84 PUSH ESI ESP=0018FE94
main 004C7F85 JMP SHORT 004C7FB6
main 004C7FB6 PUSH EDI ESP=0018FE90
main 004C7FB7 PUSH 0040ED10 ESP=0018FE8C
main 004C7FBC CALL DWORD PTR DS:[40E19C] EAX=00000012, ECX=93D2AD8F, EDX=7418F4B8
main 004C7FC2 JMP SHORT 004C7FA0
main 004C7FA0 STC
main 004C7FA1 JMP SHORT 004C7FDA
main 004C7FDA ADD ESP,4 ESP=0018FE90
main 004C7FDD CALL 004C7FC4 ESP=0018FE8C
main 004C7FC4 LEA ESP,[ESP+4] ESP=0018FE90
main 004C7FC8 PUSH 0040ECF8 ESP=0018FE8C
main 004C7FCD CALL 004C7FE2 ESP=0018FE88
main 004C7FE2 MOV BYTE PTR SS:[ESP],CH
main 004C7FE5 JMP SHORT 004C7FEB
main 004C7FEB LEA ESP,[ESP+4] ESP=0018FE8C
main 004C7FEF CALL DWORD PTR DS:[40E19C] EAX=00000014
main 004C7FF5 SETPE BH EBX=7EFD0100
main 004C7FF8 XCHG BL,BH EBX=7EFD0001
main 004C7FFA INC EBX EBX=7EFD0002
main 004C7FFB JMP SHORT 004C805A
main 004C805A ADD ESP,4 ESP=0018FE90
main 004C805D POP EDI ESP=0018FE94
main 004C805E MOV ESI,4B536EDD ESI=4B536EDD
main 004C8063 MOV SI,WORD PTR SS:[ESP] ESI=4B530000
main 004C8067 JMP SHORT 004C801E
main 004C801E LEA EBX,[CDDFCA2F] EBX=CDDFCA2F
main 004C8024 POP ESI ESP=0018FE98, ESI=00000000
main 004C8025 CALL 004C8008 ESP=0018FE94
main 004C8008 POP WORD PTR SS:[ESP] ESP=0018FE96
main 004C800C MOV BX,WORD PTR SS:[ESP+1] EBX=CDDF0000
main 004C8011 XCHG BYTE PTR SS:[ESP],BL EBX=CDDF004C
main 004C8014 JMP SHORT 004C8040
main 004C8040 LEA ESP,[ESP+2] ESP=0018FE98
main 004C8044 POP EBX EBX=7EFDE000, ESP=0018FE9C
main 004C8045 JMP SHORT 004C802A
main 004C802A MOV ESP,EBP ESP=0018FEDC
main 004C802C LEA EBP,[EDI+EAX] EBP=00000014
main 004C802F MOV BP,3200 EBP=00003200
main 004C8033 MOV EBP,CEF73787 EBP=CEF73787
main 004C8038 JMP 004C80ED
main 004C80ED POP EBP ESP=0018FEE0, EBP=0018FF30
main 004C80EE RETN ESP=0018FEE4
-------- Logging stopped
```
В приведённом примере мутация кода выполнена на самом маленьком уровне сложности. Safengine позволяет увеличивать эту сложность до 254 раз, что в итоге может раздуть ваш код из 10 инструкций в набор мусора превышающий размер исходной программы в пару раз, что достаточно избыточно.
Так же к недостатком можно отнести случаи повреждения программы, которые к сожалению на моей памяти бывали. Одно дело если такие сбои возникнут в обычной программе, что приведёт к падению и совершенно другое если падение произойдёт в драйвере, что совершенно не приемлимо. Как известно протекторы могут обрабатывать различные исполняемые файлы (exe, dll, ocx, sys).
Маркетинговая политика тоже порой оставляет желать лучшего. Технический мусор в уши клиентам создающий иллюзию защищённости, не есть хорошо. Ведь разработчики протекторов не пишут в описаниях своих продуктов что эта технология хороша, но в ней есть вот такой-то такой-то изьян.
##### 0x02. Проблема неполноты защиты кода
Наконец перейдём к вопросу, что же мешает разработчикам протекторов написать еще более сложную и стойкую защиту? Ответ достаточно прост — неполнота информации. Получая на вход бинарный файл, даже при наличии отладочной информации существует ряд ограничений, нарушение которых приведёт к неуниверсальности протектора, либо повреждению защищаемого приложения. Для примера таких ограничений взглянем на структуру обычного PE приложения:
```
Raw Virtual Name
------------------------------------
00000000 00400000 PE header
00000200 00401000 Code sector
00000400 00402000 Data sector
00000600 00403000 Resources sector
```
Код и данные в приложении помещаются в различные секции, но между ними есть чёткие связи. Таким образом несколько различных функций могут ссылаться на один и тот же блок данных, а данные могут ссылаться на другие данные и функции. Причем не всегда эта связь является явной. Исходя из этого, протекторы не могут свободно манипулировать структурой исполняемого файла: передвигать данные, расширять, перемещать функции в исходном сегменте и т.д. Хотя когда-то я предпринимал попытки [расширения секций](http://k0rnev.blogspot.com/2013/12/pe.html) исполняемого файла, но это частный случай не являющийся универсальным. Поэтому протекторы укладывают свои данные следующим образом:
```
Raw Virtual Name
------------------------------------
00000000 00400000 PE header
00000200 00401000 Code sector
00000400 00402000 Data sector
00000600 00403000 Protector sector
00000800 00404000 Resources sector
```
Исходное местоположение кода и данных не меняется, хотя перемещение некоторых других секторов возможно(ресурсы, релокации, ...). Защищаемый код вырезается и на его место помещается мусорные инструкции, чаще всего эти инструкции являются частью мутированного графа исполнения. Мутированный граф и виртуальная машина помещаются в сектор протектора.
Так же в связи с увеличением вычислительной нагрузки, протекторы не могут мутировать весь код приложения. Поэтому выбор защищаемых участков кода ложится на плечи программисту. Но программист не всегда может применить это наложение разумно. Например накрыв какой-то алгоритм шифрования мутацией, программист забудет накрыть мутацией все вызовы этого шифра, найдя которые исследователь сможет заполучить входные данные этого алгоритма и на их основе строить предположения по устройству шифра и возможно даже классифицировать или воспроизвести его.
Всё это приводит к утечке информации из мутированого\виртуализированного кода и позволяет выполнять атаки на него. Зная примерное местоположение данных или каких-то функций мы можем отслеживать обращение к ним из чёрного ящика, тем самым вместо распутывания клубка, мы составляем фантомную модель алгоритма. Конечно такой подход далеко не претендует на то чтобы дать нам полною картину алгоритма программы, однако в некоторых случаях этого вполне достаточно.
##### 0x03. Рыбачим в чёрном ящике
Типичным средством исследования чёрного ящика, является трассировщик. Однако трасса обфусцированного кода на 80-99% состоит из мусора, поэтому нам нужно как-то из этого мусора получить только полезную информацию. Этот процесс чем-то напоминает рыбалку. Представим что трасса это озеро, трассировщик удочка, а условия трассировки эта наживка. Используя вышеописанные недостатки протекторов, мы можем подобрать правильную наживку и словить правильную информацию. Взглянем как же это выглядит на практике.
Предположим у нас есть следующая программа:
```
void array_fill(unsigned char *buf, size_t size)
{
for (int i = 0; i < size; i++) {
buf[i] = i;
if (i > 0) {
buf[i] ^= buf[i - 1];
}
}
}
int main()
{
unsigned char buf[10];
array_fill(buf, sizeof(buf));
return 0;
}
```
Пусть на функцию array\_fill() будет наложена и мутация и виртуализация. Давайте оттрассируем вызов функции array\_fill():
Исходное кол-во шагов: **230**
Кол-во шагов после обфускации VMProtect: **83924**
Кол-во шагов после обфускации Safengine: **250382**
Как видно по цифрам разобрать трассу вручную просто нереально. Поэтому воспользуемся методом рыбалки.
Представим что мы ничего не знаем о функции array\_fill(). Исследовав main() мы можем точно сказать что её подвызов принимает на входе адрес буфера и его размер, после чего согласно какому-то алгоритму буфер заполняется информацией. Поэтому мы зададим нашему трассировщику правило, по которому мы будем логировать только обращения на чтение\запись к передаваемому в функцию буферу. Результат для всех трёх вариантов приложений будет один и тот же:
**Trace log**
```
main 004B7898 MOV BYTE PTR DS:[ECX],AL EAX=004B7700, ECX=0018FF34
main 004B7898 MOV BYTE PTR DS:[ECX],AL EAX=004B7701, ECX=0018FF35
main 004B7A8E MOV AL,BYTE PTR DS:[ECX] EAX=004B7A89, ECX=0018FF34
main 004B7A8E MOV AL,BYTE PTR DS:[ECX] EAX=004B7A89, ECX=0018FF35
main 004B7898 MOV BYTE PTR DS:[ECX],AL EAX=004B7701, ECX=0018FF35
main 004B7898 MOV BYTE PTR DS:[ECX],AL EAX=004B7702, ECX=0018FF36
main 004B7A8E MOV AL,BYTE PTR DS:[ECX] EAX=004B7A89, ECX=0018FF35
main 004B7A8E MOV AL,BYTE PTR DS:[ECX] EAX=004B7A89, ECX=0018FF36
main 004B7898 MOV BYTE PTR DS:[ECX],AL EAX=004B7703, ECX=0018FF36
main 004B7898 MOV BYTE PTR DS:[ECX],AL EAX=004B7703, ECX=0018FF37
main 004B7A8E MOV AL,BYTE PTR DS:[ECX] EAX=004B7A89, ECX=0018FF36
main 004B7A8E MOV AL,BYTE PTR DS:[ECX] EAX=004B7A89, ECX=0018FF37
main 004B7898 MOV BYTE PTR DS:[ECX],AL EAX=004B7700, ECX=0018FF37
main 004B7898 MOV BYTE PTR DS:[ECX],AL EAX=004B7704, ECX=0018FF38
main 004B7A8E MOV AL,BYTE PTR DS:[ECX] EAX=004B7A89, ECX=0018FF37
main 004B7A8E MOV AL,BYTE PTR DS:[ECX] EAX=004B7A89, ECX=0018FF38
main 004B7898 MOV BYTE PTR DS:[ECX],AL EAX=004B7704, ECX=0018FF38
main 004B7898 MOV BYTE PTR DS:[ECX],AL EAX=004B7705, ECX=0018FF39
main 004B7A8E MOV AL,BYTE PTR DS:[ECX] EAX=004B7A89, ECX=0018FF38
main 004B7A8E MOV AL,BYTE PTR DS:[ECX] EAX=004B7A89, ECX=0018FF39
main 004B7898 MOV BYTE PTR DS:[ECX],AL EAX=004B7701, ECX=0018FF39
main 004B7898 MOV BYTE PTR DS:[ECX],AL EAX=004B7706, ECX=0018FF3A
main 004B7A8E MOV AL,BYTE PTR DS:[ECX] EAX=004B7A89, ECX=0018FF39
main 004B7A8E MOV AL,BYTE PTR DS:[ECX] EAX=004B7A89, ECX=0018FF3A
main 004B7898 MOV BYTE PTR DS:[ECX],AL EAX=004B7707, ECX=0018FF3A
main 004B7898 MOV BYTE PTR DS:[ECX],AL EAX=004B7707, ECX=0018FF3B
main 004B7A8E MOV AL,BYTE PTR DS:[ECX] EAX=004B7A89, ECX=0018FF3A
main 004B7A8E MOV AL,BYTE PTR DS:[ECX] EAX=004B7A89, ECX=0018FF3B
main 004B7898 MOV BYTE PTR DS:[ECX],AL EAX=004B7700, ECX=0018FF3B
main 004B7898 MOV BYTE PTR DS:[ECX],AL EAX=004B7708, ECX=0018FF3C
main 004B7A8E MOV AL,BYTE PTR DS:[ECX] EAX=004B7A89, ECX=0018FF3B
main 004B7A8E MOV AL,BYTE PTR DS:[ECX] EAX=004B7A89, ECX=0018FF3C
main 004B7898 MOV BYTE PTR DS:[ECX],AL EAX=004B7708, ECX=0018FF3C
main 004B7898 MOV BYTE PTR DS:[ECX],AL EAX=004B7709, ECX=0018FF3D
main 004B7A8E MOV AL,BYTE PTR DS:[ECX] EAX=004B7A89, ECX=0018FF3C
main 004B7A8E MOV AL,BYTE PTR DS:[ECX] EAX=004B7A89, ECX=0018FF3D
```
Как видно независимо от степени мутации кода и кол-ва мусора, мы смогли получить чистую трассу описывающую все обращения к буферу. Но сможем ли мы восстановить по ней исходный алгоритм? Давайте попробуем.
И так если всмотреться в трассу становится виден цикл (это видно по повторяющимся обращениям к коду по адресу 004B7898):
```
; 1 step
main 004B7898 MOV BYTE PTR DS:[ECX],AL EAX=004B7700, ECX=0018FF34
; 2 step
main 004B7898 MOV BYTE PTR DS:[ECX],AL EAX=004B7701, ECX=0018FF35
main 004B7A8E MOV AL,BYTE PTR DS:[ECX] EAX=004B7A89, ECX=0018FF34
main 004B7A8E MOV AL,BYTE PTR DS:[ECX] EAX=004B7A89, ECX=0018FF35
main 004B7898 MOV BYTE PTR DS:[ECX],AL EAX=004B7701, ECX=0018FF35
; 3 step
main 004B7898 MOV BYTE PTR DS:[ECX],AL EAX=004B7702, ECX=0018FF36
main 004B7A8E MOV AL,BYTE PTR DS:[ECX] EAX=004B7A89, ECX=0018FF35
main 004B7A8E MOV AL,BYTE PTR DS:[ECX] EAX=004B7A89, ECX=0018FF36
main 004B7898 MOV BYTE PTR DS:[ECX],AL EAX=004B7703, ECX=0018FF36
...
```
и таких шагов всего 10, что соответствует размеру нашего буфера. Далее всё достаточно просто, зная какие значения берутся и какие кладутся назад, наш алгоритм работы лежит у нас практически на ладони. Единственное что тут нужно угадать, это применение операции XOR, но в данном случае это абсолютно не сложно.
Конечно данный пример является искусственным, на практике же приходится сталкиваться с более сложными алгоритмами с вложенными вызовами и неявной логикой, получение информации о которых может оказаться в десятки раз сложнее. В таких ситуациях применяются более сложные трассировщики, деобфускаторы, DBI и т.д. Тем не менее всё сводится к выдиранию информации трассировщиками и её анализу. Зная адреса к которым алгоритм может обратиться, мы собираем достаточно полезной информации о нём.
##### 0x04. Анализ вложенных вызовов
Не менее важной информацией которую можно вытянуть из чёрного ящика, является информация о вложенных вызовах. Это могут быть вызовы WinAPI, библиотечные функции, функции самого приложения. Такая информация помогла бы нам более детально изучить внутреннее устройство и зависимости защищённого алгоритма.
В простейшем случае для анализа вложенных вызовов, мы можем воспользоваться известной информацией о структуре исполняемого файла. То есть зная в каком сегменте расположен мутированный код, можно отследить все выходы из данного сегмента, которые будут соответствовать вызовам внешних функций. И это действительно будет работать для библиотечных функций, но проблемы могут возникнуть для вызова собственных функций программы. Как я говорил где-то выше, вырезая защищаемый код, на его место протектор может положить часть собственного кода (мутированный граф, кусок виртуальной машины). Таким образом если выполнение кода выходит из секции протектора в секцию кода приложения, нет никакой гарантии что это именно вызов вложенной функции, а не выполнение части мутированного графа.
Решение этой проблемы опять достаточно вероятностное. Во-первых нам потребуется гибкий трассировщик, например можно воспользоваться фреймворком [Intel Pin](https://software.intel.com/en-us/articles/pin-a-dynamic-binary-instrumentation-tool), в прошлый раз я использовал трассировщик встроенный в OllyDbg. Во-вторых нужно создать грамотные трассировочные правила, которые позволят нам логировать только вложенные вызовы, исключая мусор, расположенный в секции кода. Если мы хотим определить вызов библиотечной функции то нам достаточно создать правило, которое будет фиксировать передачу управления за пределы участка памяти принадлежащему исследуемому модулю. В большинстве случаев это будет передача управления в какую-то библиотеку, хотя в некоторых нестандартных ситуациях передача управления может быть выполнена в некоторый базонезависимый код протектора. Но такие частные случаи мы рассматривать не будем. Однако что же делать с вложенными вызовами в самой программе?
Как вариант можно определять вложенные функции по сигнатуре пролога. Компиляторы обычно придают функциям достаточно шаблонный вид, за что и можно зацепится.
*Шаблонный пролог функции*
То есть при возврате управления из обфусцируемого кода (секции протектора), в секцию кода приложения мы можем проверять наличие инструкций Int3, Retn расположенных до предполагаемого пролога и так же сверять пролог с заранее подготовленными сигнатурами. Это поможет не всегда, так как компилятор может напихать чего угодно в код, особенно после оптимизации, но это больше чем ничего.
Так же я заметил один маленький недостаток в обфускации протектором Safengine, который может присутствовать и в других протекторах, но которого нет в VMProtect. Недостаток заключается в том, что если протектор мутирует какую-то функцию и в ней есть вызов другой мутируемой функции, то вложенная функция вызывается не в мутируемом коде, а через переходник (инструкцию jmp) который расположен по её оригинальному адресу. Это так же является утечкой информации из мутированного кода и может быть использовано для создания правила трассировщика. Хотя в VMProtect например вложенная мутируемая функция будет вызываться сразу в сегменте протектора, не позволяя нам таким образом определять вложенный вызов. Возможно этот недостаток существует только в демо версии Safengine.
Я уже не стал засорять статью исходниками трассировщика на Intel Pin, но если статья вам понравится, то можно и про трассировщик написать отдельной статьёй.
##### 0x05. Восстановление графа выполнения
Мы всё ходили вокруг да около, пытались всячески избегать полного анализа мутированного кода, однако деобфускация и девиртуализация далеко не миф. Просто на деле такие технологии достаточно сложны и не пишутся на коленке. Я думаю специалисты из университетов и антивирусных лабораторий вовсю уже освоили данное направление и имеют богатый набор средств для их реализации. К сожалению я не сильно знаком с практикой применения таких технологий и сказать про них мне особо нечего, кроме того что они есть и что это круто :)
Если у вас есть какие-то знания и опыт в данном вопросе буду признателен если подкинете пару ссылочек в комментариях.
##### 0x06. Заключение
Как видите чёрный ящик на деле оказывается не таким уж чёрным. По собранным крупицам информации, мы можем частично восстанавливать логику защищенного алгоритма и порой в достаточном обьёме.
А вообще я считаю лучше всего раскрыть потенциал применения технологий виртуализации и мутации могут только специализированные компиляторы. Ведь компилятор в отличии от протектора, обладает практически полной информацией о защищаемом коде и может спокойно манипулировать расположением и внешним видом защищаемого кода. Если реализовать какой-то набор подсказок для компилятора, то можно помочь программисту самостоятельно выбирать степень сложности обфускации для определённых функций и методов, что обеспечит более эффективное распределение защиты и следовательно нагрузки.
Напоследок, желающим проверить свои навыки реверса обфусцированного кода, предлагаю решить [данный crackme](http://forum.reverse4you.org/showthread.php?t=1731&p=7113#post7113).
Спасибо за внимание. | https://habr.com/ru/post/225963/ | null | ru | null |
# Flutter 2.8: что нового
Повышение производительности, новые фичи Firebase, состояние десктопной версии, новые инструменты и многое другое.
*Я — Евгений Сатуров, Head of Flutter в*[*Surf*](http://go.surf.ru/hr/flutter/habr/flutter2.8) *и ведущий* [*Flutter Dev Podcast*](http://go.surf.ru/hr/flutter/habr/flutter2.8-1)*. Представляю перевод*[*официальной статьи про свежий релиз Flutter 2.8*](https://medium.com/flutter/whats-new-in-flutter-2-8-d085b763d181)*, дополненный моими комментариями.*
Вот в северное полушарие и пришла та самая пора: листва опадает, на улице холодает, и последний стабильный релиз этого года уже тут как тут. Всем привет и добро пожаловать во Flutter 2.8! Этот релиз стал результатом труда 207 контрибьюторов и 178 рецензентов, которым удалось смёрджить 2 424 PR и решить 2976 проблемных моментов.
Благодаря коллективной работе контрибьюторов:
* существенно улучшилась производительность движка и Flutter DevTools,
* вышел стабильный релиз Google Mobile Ads SDK для Flutter,
* появилась целая гора новых фич и усовершенствований Firebase, WebView 3.0,
* добавилась новая партия пакетов Flutter Favorite,
* много обновлений для десктопа уже на пути к стабильному релизу.
В довесок к ним вышла новая версия DartPad, которая теперь поддерживает ещё больше пакетов, включая Firebase. Может, это и последний релиз года, но точно не по значимости. Погнали разбираться!
Производительность
------------------
На первом месте для нас во Flutter стоит качество. Существенную часть времени тратим на то, чтобы Flutter работал как можно плавнее и устойчивее на самых разных устройствах, поддерживаемых фреймворком.
### Запуск
Улучшения коснулись задержки запуска. Их мы протестировали на Google Pay — огромном и крайне популярном приложении, в котором более одного миллиона строк кода. Последние улучшения помогли сократить задержку при запуске Google Pay на 50% на слабых Android-устройствах и на 10% — на мощных.
Мы ослабили влияние Flutter на политику сборки мусора Dart VM: это помогло избежать несвоевременного запуска циклов сбора при запуске приложения. К примеру, теперь перед рендерингом первого кадра на Android Flutter [уведомляет Dart VM только о сигналах нехватки памяти уровня TRIM\_LEVEL\_RUNNING\_CRITICAL и выше](https://github.com/flutter/flutter/issues/90551). При локальном тестировании это изменение в некоторых случаях сократило время отрисовки первого кадра на слабых устройствах на целых 300 мс.
В предыдущих релизах мы подходили к разработке с [чрезмерной осторожностью](https://github.com/flutter/engine/pull/29145#pullrequestreview-778935616), поэтому Flutter блокировал поток платформы при создании платформенных view. Благодаря [рациональным аргументам разработчиков и результатам тестирования](https://github.com/flutter/flutter/issues/91711), мы выяснили, что в некоторых случаях сериализации можно избежать. Это сокращает задержку запуска Google Pay на слабом устройстве более чем на 100 мс.
Раньше запуск дефолтного менеджера шрифтов вызывал искусственную задержку при запуске первого Dart-изолята. Мы сократили задержку: [отложили запуск дефолтного менеджера шрифтов](https://github.com/flutter/engine/pull/29291), чтобы он происходил одновременно с запуском `Isolate` в Dart.
> **Комментарий Евгения Сатурова**
>
> Мы действительно заметили, что в последних версиях Flutter появились ощутимые проблемы со скоростью запуска приложения. Проблема проявилась в одном из наших флагманских проектов, у команды которого теперь есть особенная мотивация для скорейшей миграции на новую версию фреймворка. Очень радует, что Flutter-команда стала уделять более пристальное внимание критическим проблемам с производительностью. Фикс прилетел очень своевременно.
>
>
### Память
Flutter-разработчики, занимавшиеся устройствами с ограниченной памятью, [столкнулись с проблемой](https://github.com/flutter/flutter/issues/91382) при трассировке производительности. Flutter бросался загружать «сервисный изолят» Dart VM: AOT-код связывался с приложением таким образом, что Flutter считывал их в память одновременно.
Для Android в релизе 2.8 мы выделили сервисному изоляту Dart VM [свой собственный bundle](https://github.com/flutter/engine/pull/29245), который можно загружать отдельно. Благодаря этому в приложении удаётся сэкономить до 40 мб памяти — пока не потребуется использовать сервисный изолят.
Кроме того, мы сократили объём требуемой памяти на 10%: научили [Dart VM сообщать ОС](https://github.com/flutter/flutter/issues/92120), что страницы памяти, используемые AOT-программой, содержат сохранённую в файл информацию. Она, скорее всего, больше не будет считываться в память. В результате страницы, которые были заняты копией данных, можно очистить и переиспользовать.
Профилирование
--------------
Иногда разработчикам требуется посмотреть данные о производительности Flutter или статистику в релизных сборках, чтобы подробнее разобраться, какие проблемы с производительностью есть в приложении.
В [стабильном релизе 2.8](https://github.com/flutter/engine/pull/28903) события трассировки отправляются в регистратор системной трассировки Android, если его активировали при запуске приложения. Более того, события отправляются, даже если это релизная сборка Flutter-приложения.
*События трассировки во Flutter теперь отображаются (снизу) в инструментах регистрации системной трассировки для Android*
> **Комментарий Евгения Сатурова**
>
> Наши разработчики, которые раньше писали под Android, пожалуй, больше всего скучают по нативному профайлеру, которым может похвастаться Android Studio. Это действительно мощный инструмент, который… совершено бесполезен во Flutter-разработке. Был. До выхода 2.8. Примечательно, что параллельно с развитием своей экосистемы инструментов, Flutter не забывает встраиваться и в инструменты родственных платформ.
>
>
Чтобы создавать анимации с меньшим количеством лагов, некоторые из вас хотели получать при трассировке производительности [больше информации](https://github.com/flutter/flutter/issues/92286) о кэшировании растровых изображений. Благодаря ему Flutter переиспользует фрагменты тяжёлых изображений — вместо того, чтобы перерисовывать их для каждого кадра. [Новые события потоков](https://github.com/flutter/flutter/issues/92286) в статистике производительности позволяют отследить жизненный цикл кэшированных растровых изображений.
### Flutter DevTools
Для отладки проблем с производительностью в этом релизе DevTools мы добавили [новую фичу расширенной трассировки «Enhance Tracing»](https://github.com/flutter/devtools/pull/3451). С её помощью можно диагностировать причины лагов UI: ресурсозатратные сборки, вёрстку и отрисовку объектов.
Если активировать любую из фич трассировки на картинке, на временной шкале будут отображаться новые события для собранных виджетов, а также скомпонованных и отрисованных объектов, если такие есть.
В этом релизе DevTools добавились новые возможности [профилирования производительности при запуске приложения](https://github.com/flutter/devtools/pull/3357). Новая статистика содержит анализ нагрузки ЦП: начиная с инициализации Dart VM и заканчивая рендерингом первого кадра на Flutter. Как только вы нажмёте кнопку «Profile app start up» («Профилировать запуск приложения») и статистика по запуску приложения загрузится, программа выберет для неё тег «AppStartUp» («Запуск приложения»). Профилирование загрузки приложения также можно запустить, выбрав сам тег (если он есть) из списка доступных пользовательских тегов. Так вы получите доступ к данным профилирования при запуске приложения.
### Платформенные view из веба
Android и iOS — не единственные платформы, которым достанутся обновления, повышающие производительность. В этом релизе мы также улучшили производительность платформенных view для Flutter web.
С помощью платформенных view можно размещать в приложении компоненты нативного UI из платформы используемого вами устройства. Flutter web позволяет поместить HTML элементы в веб-приложение на Flutter с помощью виджета [HtmlElementView](https://api.flutter.dev/flutter/widgets/HtmlElementView-class.html). Если вы пользуетесь веб-версиями плагина google\_maps\_flutter, плагина video\_player или следуете рекомендациям команды Flutter об оптимизации [отображения картинок в веб](https://docs.flutter.dev/development/platform-integration/web-images#use-img-in-a-platform-view), вы пользуетесь платформенными view.
Чтобы встроить платформенные view, в прошлых версиях Flutter приходилось создавать новый холст каждый раз. Чем больше платформенных view, тем больше холстов. Каждый новый холст требует очень много ресурсов, так как занимает всё окно целиком. В этом релизе Flutter [переиспользует холсты, созданные для предыдущих view](https://github.com/flutter/engine/pull/28087). В результате, вместо того, чтобы тратить в 60 раз больше ресурсов каждую секунду, приложение требует их один раз за время работы. Можно добавлять в веб-приложение несколько экземпляров `HtmlElementView`: это не снизит производительность и уменьшит лаги при скроллинге страницы с платформенными view.
> **Комментарий Евгения Сатурова**
>
> Flutter for Web — это пока не наша история. Мы подходим к выбору технолгий для нашего стека очень аккуратно. Хотя по нам и не скажешь: кто ещё писал на Flutter уже в начале 2019 года? А мы писали.
>
> Но в случае с Flutter for Web — это другое. Имеющиеся сейчас проблемы с поддержкой фреймворком веб-платформы уходят довольно глубоко в фундаментальные принципы, на которых он основан. Можно дошлифовать производительность и UX, а вот что делать с адаптацией к SEO и оптимизацией скорости загрузки приложения, пока непонятно.
>
> А вот оптимизация платформенных компонентов для веба — это отлично. Но это капля в море.
>
>
Экосистема
----------
Flutter — это не просто фреймворк, движок и инструменты. На [pub.dev](https://pub.dev) представлено более 20 тысяч совместимых с Flutter пакетов и плагинов, и каждый день их количество растёт. То, с чем Flutter разработчики взаимодействуют ежедневно, – лишь верхушка огромной экосистемы. Давайте посмотрим, что нового успело произойти в экосистеме Flutter с предыдущего релиза.
### Flutter Ads в общем доступе
Начнём с [релиза Google Mobile SDK для Flutter в общий доступ](https://medium.com/flutter/announcing-general-availability-for-the-google-mobile-ads-sdk-for-flutter-574e51ea6783) в ноябре.
Баннерная реклама | Полноэкранная реклама | Видеореклама с вознаграждением | Нативная реклама | Реклама при запуске приложения
Google Mobile Ads SDK для FlutterРелиз поддерживает пять форматов рекламы, интеграцию с AdMob и Ad Manager и включает бета-версию новой фичи для размещения рекламы от посредников. С её помощью можно оптимизировать производительность приложения. Более подробно об интеграции Google Рекламы во Flutter-приложение и других способах монетизации [рассказываем на новой страничке о монетизации на flutter.dev](https://flutter.dev/monetization).
### WebView 3.0
Ещё один новый релиз, вышедший в этот раз вместе с Flutter, — версия 3.0 плагина [webview\_flutter](https://pub.dev/packages/webview_flutter). Мы подняли номер версии: в ней добавилось много новых фич, а ещё она, скорее всего, существенным образом изменит принцип работы webview на Android.
В предыдущих версиях `webview_flutter` режим гибридной компоновки («Hybrid Composition») уже был доступен, но не по умолчанию. Гибридная компоновка решает ряд проблем, существовавших в предыдущем дефолтном режиме «Virtual Display». Учитывая отзывы пользователей и статистику багов, мы решили, что пришло время сделать гибридную компоновку дефолтной. Кроме того, с `webview_flutter` добавилось несколько фич, о которых многие просили:
* Поддержка POST и GET для наполнения контентом ([4450](https://github.com/flutter/plugins/pull/4450), [4479](https://github.com/flutter/plugins/pull/4479), [4480](https://github.com/flutter/plugins/pull/4480), [4573](https://github.com/flutter/plugins/pull/4573))
* Загрузка HTML из файлов и строк с текстовой информацией ([4446](https://github.com/flutter/plugins/pull/4446), [4486](https://github.com/flutter/plugins/pull/4486), [4544](https://github.com/flutter/plugins/pull/4544), [4558](https://github.com/flutter/plugins/pull/4558))
* Поддержка прозрачного фона ([3431](https://github.com/flutter/plugins/pull/3431), [4569](https://github.com/flutter/plugins/pull/4569), [4570](https://github.com/flutter/plugins/pull/4570))
* Запись информации в cookies до загрузки контента ([4555](https://github.com/flutter/plugins/pull/4555), [4556](https://github.com/flutter/plugins/pull/4556), [4557](https://github.com/flutter/plugins/pull/4557))
Помимо этого, в релизе `webview_flutter` 3.0 добавилась пробная поддержка новой платформы — веб. Многие из вас просили о возможности размещать webview в веб-приложении на Flutter, с помощью которого можно собрать мобильное или веб-приложение на единой кодовой базе. Как выглядит webview в веб-приложении на Flutter? С точки зрения кода — как обычно:
```
import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:webview_flutter/webview_flutter.dart';
import 'package:webview_flutter_web/webview_flutter_web.dart';
void main() {
runApp(const MaterialApp(home: HomePage()));
}
class HomePage extends StatefulWidget {
const HomePage({Key? key}) : super(key: key);
@override
State createState() => \_HomePageState();
}
class \_HomePageState extends State {
@override
void initState() {
super.initState();
// required while web support is in preview
if (kIsWeb) WebView.platform = WebWebViewPlatform();
}
@override
Widget build(BuildContext context) => Scaffold(
appBar: AppBar(title: const Text('Flutter WebView example')),
body: const WebView(initialUrl: 'https://flutter.dev'),
);
}
```
При запуске в веб работает так, как и ожидается:
Следует заметить, что у текущей реализации `webview_flutter` для веб есть ряд ограничений. Она написана с помощью `iframe`: он поддерживает только загрузку простых URL и не умеет контролировать или взаимодействовать с загруженным контентом (подробнее читайте в [the webview\_flutter\_web README](https://pub.dev/packages/webview_flutter_web)). Однако по просьбе сообщества мы предоставляем доступ к `webview_flutter_web` в виде [неофициального плагина](https://docs.flutter.dev/development/packages-and-plugins/developing-packages#endorsed-federated-plugin). Если хотите его попробовать, добавьте следующую строку к pubspec.yaml:
```
dependencies:
webview_flutter: ^3.0.0
webview_flutter_web: ^0.1.0 # add unendorsed plugin explicitly
```
Если у вас возникла проблема с webview\_flutter v3.0, [пишите во Flutter репозиторий с пометкой «webview issue»](https://github.com/flutter/flutter/issues). Если же вы ещё не пользовались webview, прочтите [новый codelab по webview](https://codelabs.developers.google.com/codelabs/flutter-webview), в котором пошагово расписан процесс внедрения веб-контента в приложении на Flutter.
### Flutter Favorites
[Комитет по экосистеме Flutter](https://docs.flutter.dev/development/packages-and-plugins/favorites#flutter-ecosystem--committee) провёл очередную встречу и включил следующие пакеты во Flutter Favorite:
* Три кастомных пакета маршрутизации для нового Router API: [beamer](https://pub.dev/packages/beamer), [routemaster](https://pub.dev/packages/routemaster) и [go\_router](https://pub.dev/packages/go_router).
* [drift](https://pub.dev/packages/drift) — получившая новое имя функциональная и популярная реактивная библиотека для управления базами данных во Flutter и Dart, созданная на основе [sqlite](https://pub.dev/packages/sqlite3).
* [freezed](https://pub.dev/packages/freezed) — «языковой патч» для Dart, содержащий простой синтаксис для описания моделей, клонирования объектов, поиска по шаблону и других действий.
* [dart\_code\_metrics](https://pub.dev/packages/dart_code_metrics).
* Несколько красивых пакетов для графического интерфейса: [flex\_color\_scheme](https://pub.dev/packages/flex_color_scheme), [flutter\_svg](https://pub.dev/packages/flutter_svg), [feedback](https://pub.dev/packages/feedback), [toggle\_switch](https://pub.dev/packages/toggle_switch) и [auto\_size\_text](https://pub.dev/packages/auto_size_text).
Любимый пакет Flutter можно выдвинуть на премию Flutter Favorite. Руководство и инструкции — на [странице программы «Flutter Favorite»](https://docs.flutter.dev/development/packages-and-plugins/favorites).
> **Комментарий Евгения Сатурова**
>
> Попадание пакета в программу сертификации Flutter Favorite — большое событие. На данный момент таких пакетов всего 64 (из 22 тысяч, доступных на pub.dev). Лычка Flutter Favorite — это безоговорочное признание ценности и качества пакета сообществом и создателями самого фреймворка.
>
> Тем радостнее мне наблюдать [dart\_code\_metrics](https://pub.dev/packages/dart_code_metrics) среди пакетов, наконец получивших этот почётный статус. dart\_code\_metrics был создан бывшим членом нашей дружной команды (привет, Дима!). А наш Flutter-разработчик Влад Коношенко активно контрибьютит в dart\_code\_metrics и по сей день.
>
> Мы используем dart\_code\_metrics для мониторинга качества кодовой базы наших проектов, и рекомендуем делать это вам.
>
>
Платформо-специфичные пакеты
----------------------------
Если вы создаёте пакет, вам необходимо решить, какие платформы поддерживать. Если плагин содержит платформо-специфичный нативный код, это можно сделать [с помощью свойства pluginClass в pubspec.yaml проекта](https://docs.flutter.dev/development/packages-and-plugins/developing-packages#plugin-platforms), где указывается нативный класс, обеспечивающий выполнение фичи:
```
flutter:
plugin:
platforms:
android:
package: com.example.hello
pluginClass: HelloPlugin
ios:
pluginClass: HelloPlugin
```
Однако [Dart FFI](https://dart.dev/guides/libraries/c-interop) не стоит на месте: сейчас можно внедрить платформо-специфичную функциональность с помощью кода, на 100% состоящего из Dart, как сделали с [пакетом path\_provider\_windows](https://pub.dev/packages/path_provider_windows). Даже если пакет не имеет нативных классов, вы всё ещё можете указать, что он поддерживает определённую платформу. В таком случае используйте свойство `dartPluginClass`:
```
flutter:
plugin:
implements: hello
platforms:
windows:
dartPluginClass: HelloPluginWindows
```
С помощью этих свойств вы можете указать, что пакет поддерживает только определённые платформы, даже если в приложении вообще нет нативного кода. Также вам необходимо указать класс Dart плагина. Подробнее об этом можно прочитать в [документах о платформенных реализациях на чистом Dart на flutter.dev](https://docs.flutter.dev/development/packages-and-plugins/developing-packages#dart-only-platform-implementations).
Firebase
--------
Ещё одна важная часть экосистемы Flutter — это FlutterFire. В этом релизе мы добавили ряд новых фич, благодаря которым писать приложения с помощью Flutter и Firebase станет проще:
* Все плагины FlutterFire переходят из беты в стабильный канал.
* Поддержка нескольких сервисов Firebase в DartPad.
* Новые библиотеки, с которыми станет легче собирать UI для аутентификации и отправлять запросы в Firestore в реальном времени.
* Новая функциональность Firestore Object/Document Mapping для Flutter доступна в альфа-канале.
### Стабильный канал
Почти все [плагины FlutterFire](http://firebase.flutter.dev/) уже перешли из беты в стабильный канал.
Плагины, которые перешли в стабильный канал для Android, iOS и веб, включают:
* [аналитику (Analytics)](https://firebase.flutter.dev/docs/analytics/overview),
* [динамические ссылки (Dynamic Links)](https://firebase.flutter.dev/docs/dynamic-links/overview),
* [сообщения внутри приложений (In-App Messaging)](https://firebase.flutter.dev/docs/in-app-messaging/overview/),
* [мониторинг производительности (Performance Monitoring)](https://firebase.flutter.dev/docs/performance/overview),
* [базу данных, синхронизированных в реальном времени (Realtime Database)](https://firebase.flutter.dev/docs/database/overview)
* [дистанционную настройку приложений (Remote Config)](https://firebase.flutter.dev/docs/remote-config/overview).
Кроме того, в этом релизе добавился [контроль установленных приложений (Installations)](https://firebase.flutter.dev/docs/installations/overview). Плагин App Check и поддержка платформы macOS всё ещё находятся в бета-канале, так как библиотеки Firebase пока тоже в бета-канале.
Realtime Database, Analytics и Remote Config теперь — полноценные плагины, готовые к использованию в продакшене.
### Инициализация Firebase через Dart
С переходом пакетов в стабильный канал мы добавили возможность [инициализировать Firebase на любой из поддерживаемых платформ средствами Dart](https://github.com/FirebaseExtended/flutterfire/pull/6549):
```
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart'; // generated via `flutterfire` CLI
Future main() async {
// initialize firebase across all supported platforms
WidgetsFlutterBinding.ensureInitialized();
await Firebase.initializeApp(options: DefaultFirebaseOptions.currentPlatform);
runApp(MyApp());
}
```
Программный код инициализирует приложение Firebase способом, соответствующим определённой поддерживаемой платформе, согласно информации в файле firebase\_options.dart:
```
static const FirebaseOptions web = FirebaseOptions(
apiKey: 'AIzaSyCZFKryCEiKhD0JMPeq_weJguspf09h7Cg',
appId: '1:111079797892:web:b9195888086158195ffed1',
messagingSenderId: '111079797892',
projectId: 'flutterfire-fun',
authDomain: 'flutterfire-fun.firebaseapp.com',
storageBucket: 'flutterfire-fun.appspot.com',
measurementId: 'G-K029Y6KJDX',
);
```
> **Комментарий Евгения Сатурова**
>
> Изменение, которое прошло малозаметным, но… как же это прекрасно. Лишний раз не лезть в дебри нативных модулей Flutter-проекта всегда приятно. Работать с Firebase стало ещё проще, чем раньше. Экономия времени даже на таких мелочах позволяет сфокусироваться на главном — на качестве и технологичности продуктов.
>
> Но причина моей радости не только в этом улучшении. Ниже вы узнаете про FlutterFire CLI, который возмужал настолько, что позволяет вообще забыть про веб-интерфейс Firebase навсегда. Даже в том случае, если вы ещё не создали Firebase-проект.
>
>
Чтобы подробнее узнать о структуре данных каждого способа инициализации для той или иной платформы, [ознакомьтесь с новым инструментом flutterfire CLI](https://pub.dev/packages/flutterfire_cli).
Этот инструмент отправляется в данные в платформо-специфичных вложенных папках и ищет уникальный bundle ID. Затем использует его, чтобы найти подробную информацию по определённому проекту Firebase для соответствующего платформо-специфичного приложения или даже создать новый проект Firebase и новые платформо-специфичные приложения, если таких нет.
Какая в этом польза? Больше не надо скачивать и добавлять json-файл в Android-проект, скачивать и добавлять plist файл в iOS и macOS проекты или [копипастить код в index.html web-проекта](https://github.com/FirebaseExtended/flutterfire/pull/7359). Не важно, какую из поддерживаемых Firebase платформ вы выбрали, — этот кусочек кода на Dart инициализирует Firebase для приложения.
Однако, возможно, это не единственная инициализация, которую надо будет выполнить, чтобы FlutterFire-приложение заработало. Например, может потребоваться интегрировать символы Crashlytics в [Android](https://firebase.google.com/docs/crashlytics/get-started?platform=android#add-plugin) или [iOS](https://firebase.google.com/docs/crashlytics/get-started?platform=ios#set-up-dsym-uploading) сборку. Однако с любым новым Firebase-проектом на это должны уйти считанные минуты.
### Используем Firebase с DartPad
Так как FlutterFire инициализируется исключительно средствами Dart, Firebase теперь можно использовать прямо внутри DartPad.
[В этом примере](https://dartpad.dev/?id=d57c6c898dabb8c6fb41018588b8cf73) показано [небольшое приложение-чат](https://twitter.com/puf/status/1458516522133909506), которое использует Flutter, Firebase и DartPad. Их уже можно использовать, не устанавливая. Поддержка Firebase в DartPad уже включает основные API, аутентификацию и Firestore. Со временем в DartPad будут появляться новые сервисы Firebase.
Помимо этого, поддержка FlutterFire в DartPad даёт возможность [использовать версию DartPad, встроенную прямо в документы](https://firebase.flutter.dev/docs/firestore/example/).
В этом примере — документы для Cloud Firestore, в одном из которых написан код для [примера приложения](https://github.com/FirebaseExtended/flutterfire/tree/master/packages/cloud_firestore/cloud_firestore/example). Его можно запускать и редактировать прямо в браузере. Здесь можно создавать тестовый проект или даже копипастить код. Всё необходимое будет под рукой.
### Firebase UI
У большинства приложений, которые интегрируются с Firebase, есть процесс аутентификации. В том числе — возможность залогиниться с помощью электронной почты и пароля или через аккаунт в другом сервисе, например, Google.
Firebase Authentication позволяет создавать новый аккаунт в два счёта, подтверждать адрес электронной почты, менять пароль, а в некоторых случаях — выполнить двухэтапную верификацию через SMS, залогиниться через номер телефона или даже объединить несколько пользовательских аккаунтов в один.
Пакет [flutterfire\_ui](https://pub.dev/packages/flutterfire_ui) умеет воплощать основные сценарии аутентификации с минимальным количеством кода. Представим, что в проекте Firebase доступна аутентификация через email и Google-аккаунт:
С этим пакетом можно создать процесс аутентификации следующим образом:
```
import 'package:flutter/material.dart';
import 'package:firebase_core/firebase_core.dart';
import 'package:firebase_auth/firebase_auth.dart';
import 'package:flutterfire_ui/auth.dart';
import 'firebase_options.dart';
Future main() async {
WidgetsFlutterBinding.ensureInitialized();
await Firebase.initializeApp(options: DefaultFirebaseOptions.currentPlatform);
runApp(MyApp());
}
class MyApp extends StatelessWidget {
const MyApp({Key? key}) : super(key: key);
@override
Widget build(BuildContext context) => MaterialApp(
home: AuthenticationGate(),
);
}
class AuthenticationGate extends StatelessWidget {
const AuthenticationGate({Key? key}) : super(key: key);
@override
Widget build(BuildContext context) => StreamBuilder(
stream: FirebaseAuth.instance.authStateChanges(),
builder: (context, snapshot) {
// User is not signed in - show a sign-in screen
if (!snapshot.hasData) {
return SignInScreen(
providerConfigs: [
EmailProviderConfiguration(),
GoogleProviderConfiguration(
clientId: 'xxxx-xxxx.apps.googleusercontent.com',
),
],
);
}
return HomePage(); // show your app’s home page after login
},
);
}
```
Этот код инициализирует Firebase. Если он заметит, что пользователь ещё не залогинился, покажет экран регистрации. В виджете `SigninScreen` есть возможность аутентификации через email и Google-аккаунт. Кроме того, код анализирует аутентификационное состояние пользователя с помощью пакета `firebase_auth`: как только пользователь зарегистрируется, вы сможете показать ему все остальные экраны приложения. С помощью этого кода вы получаете рабочий процесс авторизации для всех платформ, поддерживаемых Firebase: Android, iOS, веб и macOS.
Выполнив ещё несколько действий, вы с лёгкостью можете вставить изображение и какой-нибудь кастомный текст (подробнее в [документации](https://firebase.flutter.dev/docs/ui/overview)) и таким образом выстроить полноценный процесс входа в приложение:
Мобильная версияЭкраны flutterfire\_ui адаптивны. Отображение на десктопном устройстве Если у пользователей уже есть email и пароль, они могут их ввести и войти в приложение. Если они используют авторизацию через Google, приложение покажет им классический процесс авторизации через Google-аккаунт, независимо от того, мобильная это версия, веб- или десктопная. Если у них ещё нет аккаунта, они могут нажать на кнопку на экране входа в приложение и перейти на экран регистрации.
После входа в приложение или регистрации, приложение может показать пользователю экраны валидации электронной почты, смены забытого пароля, выхода из аккаунта и привязки аккаунта социальной сети для последующей аутентификации. Вход через email работает на всех платформах. Также есть возможность авторизации через аккаунты Google, Facebook и Twitter. Она частично поддерживается для Apple, но не работает на Android. Аутентификация с `flutterfire_ui` поддерживает несколько сценариев и схем навигации. Помимо этого, у `flutterfire_ui` есть возможность кастомизации и локализации. [Подробная информацию и примеры — в документации на firebase.flutter.dev](https://firebase.flutter.dev/docs/ui/overview).
Аутентификация — не единственная связанная с Firebase UI фича, которую поддерживает flutterfire\_ui. Чтобы в реальном времени показать пользователю список данных из запроса Firebase с возможностью бесконечной прокрутки, мы включили в этот релиз `FirestoreListView`, который можно добавить в приложение с активным запросом следующим образом:
```
class UserListView extends StatelessWidget {
UserListView({Key? key}) : super(key: key);
// live Firestore query
final usersCollection = FirebaseFirestore.instance.collection('users');
@override
Widget build(BuildContext context) => Scaffold(
appBar: AppBar(title: const Text('Contacts')),
body: FirestoreListView(
query: usersCollection,
pageSize: 15,
primary: true,
padding: const EdgeInsets.all(8),
itemBuilder: (context, snapshot) {
final user = snapshot.data();
return Column(
children: [
Row(
children: [
CircleAvatar(
child: Text((user['firstName'] ?? 'Unknown')[0]),
),
const SizedBox(width: 8),
Column(
crossAxisAlignment: CrossAxisAlignment.start,
mainAxisAlignment: MainAxisAlignment.center,
mainAxisSize: MainAxisSize.min,
children: [
Text(
'${user['firstName'] ?? 'unknown'} '
'${user['lastName'] ?? 'unknown'}',
style: Theme.of(context).textTheme.subtitle1,
),
Text(
user['number'] ?? 'unknown',
style: Theme.of(context).textTheme.caption,
),
],
),
],
),
const Divider(),
],
);
},
),
);
}
```
Так список выглядит в приложении:
А если вы хотите, чтобы пользователи могли создавать, читать, обновлять и удалять элементы таблицы, в `FirestoreDataTable` уже появляются такие возможности:
```
class FirestoreTableStory extends StatelessWidget {
FirestoreTableStory({Key? key}) : super(key: key);
// live Firestore query
final usersCollection = FirebaseFirestore.instance.collection('users');
@override
Widget build(BuildContext context) {
return FirestoreDataTable(
query: usersCollection,
columnLabels: const {
'firstName': Text('First name'),
'lastName': Text('Last name'),
'prefix': Text('Prefix'),
'userName': Text('User name'),
'email': Text('Email'),
'number': Text('Phone number'),
'streetName': Text('Street name'),
'city': Text('City'),
'zipCode': Text('Zip code'),
'country': Text('Country'),
},
);
}
}
```
Вот как это работает:
Подробнее об аутентификации, list view и таблицах данных — [в документации по flutterfire\_ui](https://firebase.flutter.dev/docs/ui/overview/). Это предварительный релиз, и мы добавим в него новые фичи. Если у вас есть вопрос или вы знаете, какую фичу нужно добавить, перейдите [в репозиторий на GitHub и сообщить о баге или задать вопросы в разделе обсуждений](https://github.com/FirebaseExtended/flutterfire/discussions/6978).
> **Комментарий Евгения Сатурова**
>
> Если вы рассматриваете Flutter в первую очередь как инструмент для прототипирования или быстрой сборки MVP, значимость flutterfire\_ui трудно переоценить.
>
> В наших проектах пакету вряд ли найдётся широкое применение. Чем компоненты более верхнеуровневые, тем больше они несут на борту различных ограничений. А мы любим Flutter совсем не за это, а как раз наоборот — за свободу и гибкость.
>
>
### Firestore Object/Document Mapping
И последняя, но от того не менее важная фича для интеграции Firebase с Flutter — это релиз [Firestore Object/Document Mapper](https://firebase.flutter.dev/docs/firestore-odm/overview/) в альфа-канале. Цель Firestore ODM – повысить продуктивность Flutter-разработчиков, упростив работу с Firestore с помощью уже знакомых структурно упорядоченных объектов и методов из безопасной системы типов. С помощью кодогенерации Firestore ODM дорабатывает синтаксис, необходимый для взаимодействия с документами и коллекциями. Это позволяет разработчику моделировать данные типобезопасным способом:
```
@JsonSerializable()
class Person {
Person({required this.name, required this.age});
final String name;
final int age;
}
@Collection(‘/persons’)
final personsRef = PersonCollectionReference();
```
С помощью данных типов можно делать запросы типобезопасным способом:
```
personsRef.whereName(isEqualTo: 'Bob');
personsRef.whereAge(isGreaterThan: 42);
```
Помимо этого, ODM поддерживает возможность описания строго типизированных подколлекций. С его помощью можно оптимизировать пересборку виджетов, используя фичу `select`. Об этом и многом другом — в [документации к Firestore ODM](https://firebase.flutter.dev/docs/firestore-odm/overview/).
Будем рады вашим отзывам. Чтобы оставить отзыв или задать вопрос, [присоединяйтесь к треду о Firestore ODM](https://github.com/FirebaseExtended/flutterfire/discussions/7475) в обсуждении FlutterFire.
Десктопная версия
-----------------
В релизе Flutter 2.8 мы сделали ещё один большой шаг на пути к стабильному релизу для Windows, macOS и Linux. Задали высокую планку качества: в том числе поддерживаем интернационализацию и локализацию, как в случае с недавно вышедшей [поддержкой ввода китайских иероглифов](https://github.com/flutter/engine/pull/29620), [корейских иероглифов](https://github.com/flutter/engine/pull/24713), и [кандзи](https://github.com/flutter/engine/pull/29761). Или как в случае с тесной интеграцией со [специальными возможностями в Windows](https://github.com/flutter/flutter/issues/77838).
Мы считаем, что для Flutter недостаточно работать на десктопных устройствах в стабильном канале (что уже возможно [в бета-версии, если открыть доступ фиче-флагом](https://docs.flutter.dev/desktop#beta-snapshot-in-stable-channel)). Он должен подходить для разных языков и культур мира, а также для людей с разными возможностями. Пока что мы не добились нужного результата, но идём к цели!
Мы не прекращаем работать над стабильной десктопной версией. Например, [чтобы добиться синхронного отклика, мы полностью пересмотрели архитектуру взаимодействия Flutter с событиями, которые он получает от клавиатуры](http://flutter.dev/go/handling-synchronous-keyboard-events). Благодаря этому виджет теперь может распознавать нажатие на клавишу и останавливать прохождение сигнала дальше по дереву.
[Благодаря работе, проделанной](https://github.com/flutter/flutter/issues/33521) во Flutter 2.5 и Flutter 2.8, мы пофиксили баги и регрессионные ошибки. Продолжаем реорганизовывать [обработку данных с клавиатуры на различных устройствах](https://github.com/flutter/flutter/issues/44918) и [рефакторить процесс форматирования текста во Flutter](https://github.com/flutter/flutter/pull/86736): это необходимо для десктопных приложений, где информация в основном вводится с помощью клавиатуры.
Кроме того, [продолжаем расширять поддержку visualDensity во Flutter](https://github.com/flutter/flutter/pull/89353) и [применяем выравнивание к диалогам](https://github.com/flutter/flutter/pull/88984), чтобы сделать UI удобнее для десктопных устройств.
Команда Flutter — не единственная, кто работает над десктопной версией Flutter. Команда разработчиков для десктопов в Canonical в сотрудничестве с Invertase занимается реализацией наиболее популярных плагинов Firebase для Flutter на Linux и Windows. И это только один из примеров.
Подробнее [о предварительном релизе — в блоге Invertase](https://invertase.io/blog/announcing-flutterfire-desktop).
DartPad
-------
Рассказ о релизе Flutter будет неполным, если не упомянуть, как мы усовершенствовали инструментарий. В этом посте сконцентрируемся на улучшениях в DartPad. Крупнейшее из них — расширение поддержки пакетов: теперь можно импортировать 23 пакета. Помимо ряда сервисов Firebase, в список вошли популярные пакеты: `bloc`, `characters`, `collection`, `google_fonts` и `flutter_riverpod`. Команда DartPad продолжает добавлять новые пакеты. Чтобы посмотреть, какие пакеты поддерживает DartPad, щёлкните по иконке информации в нижнем правом углу.
Чтобы посмотреть, какие пакеты мы планируем добавить в DartPad в будущем, переходите на [статью в Dart wiki](https://github.com/dart-lang/dart-pad/wiki/Adding-support-for-a-new-package).
Мы добавили в DartPad ещё одну удобную фичу. Раньше он всегда запускал последнюю стабильную версию. Теперь можно выбрать свежие релизы в бета-канале или предыдущий стабильный релиз (который называется «old channel») в новом пункте меню «Channel» в строке состояния.
Эта фича пригодится, если вы, например, пишете пост в блоге о свежем релизе, и последняя стабильная версия для него недостаточно свежая.
> **Комментарий Евгения Сатурова**
>
> Я долго не понимал смысл существования DartPad, но сейчас из невнятного блокнота с возможностью выполнить несложный код, он постепенно превращается в весьма функциональный инструмент. Мы уже используем его на собеседованиях, для проверки гипотез в ходе брейн-штормов и сессий технического проектирования.
>
>
Прощаемся с каналом dev
-----------------------
Во Flutter «каналы» отличаются тем, насколько быстро в фреймворк и движок вносятся изменения: канал «stable» претерпевает минимум изменений, а канал «master» меняется максимально часто.
Недавно мы прекратили обновлять канал `dev`. Оказалось, что им пользуется 3% Flutter-разработчиков. Наши ресурсы ограничены, поэтому мы официально начинаем его сворачивать. Если вы всё время проводите в стабильном канале (как и более 90% Flutter-разработчиков), разницы вы не заметите.
Выбрать, какой канал вы хотите использовать, можно с помощью команды `flutter channel`. Вот что думает о каждом канале команда Flutter:
* Канал `stable` представляет самые качественные из имеющихся сборок. Новые сборки выходят (примерно) раз в квартал, а в промежутках мы выпускаем hotfix критических ошибок. Этот канал – «медленный»: предлагаемые решения безопасны, проработаны и прослужат долго.
* Канал `beta` – динамичная альтернатива стабильному каналу для тех, кто чувствует себя комфортно в часто меняющейся обстановке. На данный момент релизы выходят раз в месяц, а перед релизом канал стабилизируется. Этот канал – «быстрый». Если мы поймём, что канал `dev` удовлетворял потребностям, которым не отвечает beta-канал, мы возможно изменим свой подход к beta-каналу. Например, будем выпускать обновления в beta-канале чаще или сократим число тестов и hot fix.
* Канал `master` – канал активной разработки. На нём нет поддержки, но мы прогоняем его через обширный набор модульных тестов. Этот канал подходит для контрибьюторов и продвинутых пользователей, которых не пугают нестабильные сборки. На этом канале мы постоянно что-то делаем и ломаем. И чиним тоже постоянно.
В течение ближайших месяцев мы свернём канал `dev`. Рекомендуем присмотреться к каналам `beta` и `master` и выбрать подходящий.
> **Комментарий Евгения Сатурова**
>
> Еще полтора-два года назад некоторые наши проекты действительно «сидели» на dev-канале. В те времена Flutter был сыроват, а квартальный релизный цикл стабильного канала никак не позволял быстро получить исправления некоторых неприятных багов фреймворка (за хотфиксы респект, но спасали они не всегда).
>
> Мы уже давно официально не рекомендуем использовать dev, просто потому что это больше не имеет особого смысла. Теперь dev-каналу официально пришёл конец.
>
>
Критические изменения
---------------------
Мы стремимся свести число критических изменений к минимум в каждом релизе. В релизе Flutter 2.8 критических изменений нет, кроме устаревших API, которые получили статус «deprecated» и были удалены в соответствии с [нашей политикой критических изменений](https://github.com/flutter/flutter/wiki/Tree-hygiene#handling-breaking-changes).
* [90292](https://github.com/flutter/flutter/pull/90292) Удалены autovalidate
* [90293](https://github.com/flutter/flutter/pull/90293) Удалён FloatingHeaderSnapConfiguration.vsync
* [90294](https://github.com/flutter/flutter/pull/90294) Удалён AndroidViewController.id
* [90295](https://github.com/flutter/flutter/pull/90295) Удалён BottomNavigationBarItem.title
* [90296](https://github.com/flutter/flutter/pull/90296) Удалены классы для форматирования вводимого текста
Если вы ещё пользуетесь этими API и хотите узнать, как обновить свой код, [прочитайте гайд по миграции на flutter.dev](https://docs.flutter.dev/release/breaking-changes/2-5-deprecations). Мы очень благодарны сообществу за [тесты](https://github.com/flutter/tests/blob/master/README.md), с помощью которых мы находим критические изменения.
Подведём итоги
--------------
Провожая 2021 год, наша команда Flutter хотела бы искренне поблагодарить Flutter-сообщество за труд и поддержку. И хотя мы безусловно развиваем Flutter для того, чтобы с каждым годом им пользовалось всё больше разработчиков по всему миру, не будет преувеличением, если я скажу, что мы бы никогда не справились с задачей без вашей помощи. Сообщество Flutter — уникальные люди, и мы благодарны вам за ваши старания. Чудесных вам праздников! Увидимся в новом году! | https://habr.com/ru/post/596405/ | null | ru | null |
# Проверяем формы по стандартам с Validation API
В свое время мне почти всем нравился Angular 2+, это хорошо спроектированный фреймворк, который на голову выше остальных популярных фронтенд фреймворков по инженерному уровню исполнения. Но были у него и весьма странные недоработки. Одна из них это невозможность ручного вызова валидации или ревалидации формы, которая наблюдалась как минимум, до 8ой версии. Нельзя сказать чтобы там сильно увлекаются реактивностью, но вот в этой подсистеме похоже какие-то реактивные соображения побудили разработчиков реализовать валидацию только через привязку, вынудив разработчиков прикладных решений обращаться к костылям навроде установки состояния “нетронуто” для полей и вообще усложняя написание сложных валидаторов с продвинутой логикой и участием нескольких полей сразу. Опыт борьбы с ангуляровским валидатором и некоторыми другими особенностями фреймворка усилил мое впечатление от того насколько элегантным и простым оказалось после этого использование HTML5 API для валидации форм, которое “просто работает” в любом современном браузере даже без подключения фреймворков и библиотек.
Базой для работы валидаторов являются атрибуты элементов. С помощью атрибутов мы сразу можем задать следующие ограничения:
**required** — поле обязательное, т.е. требует заполнения
**min** **max** **step** — минимально и максимально допустимые значения, а также шаг изменения
**minlength** и **maxlength** — ограничители по количеству допустимых символов ввода
**pattern** — регулярное выражение
Вроде бы не густо, однако, pattern дает нам довольно богатые возможности по проверке значений, легко нагугливаются регулярки позволяющие сходу проверять номера телефонов, емейл адреса и урлы и многое другое востребованное.
Расставленные на элементы формы эти атрибуты автоматически не позволят сработать кнопке из той же формы выполняющей submit значений на сервер, правда сегодня такой кейс может показаться многим анахроничным. Но это еще не беда, т.к. с помощью клиентского кода на JavaScript мы можем точно также и даже лучше пользоваться всеми этими валидаторами. Поэтому мы не будем использовать input type=email, а попробуем сделать свое поле с проверкой вводимого на соответствие правилам формирования адресов электронной почты. Сделаем простую форму:
```
```
Валидатор сразу работает и на попытку нажимать кнопку выдает предупреждение на языке локали браузера.
Соответственно ввод mail@example.com дает успешный сабмит формы.
Чтобы развить свое поведение надо получить доступ к инстансу формы, это можно сделать через глобальный document по имени, индексу (id) или порядковому номеру начиная с нуля.
```
document.forms.myform.onsubmit = (event) => {
console.log('validate');
return false;
};
```
или по селектору одним из методов, таким как **document.getElementById()** или **document.querySelector()**
для проверки результатов запустим http-server
```
npx http-server
```
после того как команда отработает, в браузере можно открывать [127.0.0.1](http://127.0.0.1):8080/ или тот адрес, что он напишет вам в консоли и отлаживать результаты.
Заменим сабмит на обычную кнопку, и будем вызывать проверку формы вручную, немного изменив пример.
```
;
myform.subm.onclick = (event) => {
console.log(form.checkValidity());
return false;
};
```
В данном примере видно, что мапинг объектов формы по их id и name работает и для дочерних по отношению к форме элементов, что выглядит очень изящно. Теперь наш код выводит в консоль состояние валидности формы.
Наличие методов ручного запуска валидации, не означает, что она не осуществляется без их вызова.
Результаты ввода и других изменений на форме сразу отражаются на ее состоянии, что проявляется в наличии псевдоклассов стилей **valid** и **invalid**. Если добавить выделение цветом, то можно заметить как сразу срабатывает валидация.
```
:valid {
border: 1px solid green;
}
:invalid {
border: 1px solid red;
}
```
Для того, чтобы форма не мозолила глаза красным до того как пользователь попробовал что-то в нее вводить, можно использовать лайфхак с плейсхолдером:
```
input:valid {
border: 1px solid green;
}
input:not(:placeholder-shown):invalid {
border: 1px solid red;
}
```
На элементы формы можно навесить внешние обработчики для событий валидации.
```
myform.email.oninvalid = (event) => {
alert('Wrong email !!11');
};
myform.subm.onclick = (event) => {
console.log(form.checkValidity());
return false;
};
```
В данном случае используется механизм хуков по имени события, если есть какое-то событие поддерживаемое элементом, то присвоив ему функцию с именем on + <имя\_эвента> мы можем быть уверены, что она будет вызвана когда он сработает.
И еще один замечательный момент тут в том, что они будут вызываться уже не при вводе данных, а только при программном дергании валидации, т.е. вызове метода checkValidity().
Соответственно мы можем, обработать это поведение:
```
myform.subm.onclick = (event) => {
if (myform.checkValidity()) {
alert('Valid !');
} else {
alert('Invalid !')
}
return false;
};
```
В реальной жизни нам может потребоваться также вызов **event.preventDefault()** если валидация не пройдена, чтобы прервать процедуру сабмита формы.
У **checkValidity()** есть аналог **reportValidity()**, который возвращает результат не вызывая при этом повторной валидации.
А как узнать какое поле неправильное?
Свойство .validity есть у каждого элемента ввода формы как и возможность вызвать на нем методы валидации, свойство имеет следующую структуру:
ValueState: {
valid — общий признак корректности значения
valueMissing — значение требуется, но не задано
typeMismatch — введено неправильное по типу значение
patternMismatch — введен не соответствующее шаблону значение
tooLong — значение больше чем maxlength
tooShort — значение меньше чем minlength
rangeUnderflow — значение меньше min
rangeOverflow — значение больше max
stepMismatch — значение не соответствует шагу
badInput — ввод не может быть приведен к значению
customError — произвольная ошибка
}
В основном представлены, как мы видим, свойства ошибок соответствующие стандартным атрибутам валидации, тогда как **.customError** это наш задел для расширения.
Вызвав метод **.setCustomValidity()** с аргументом в виде строки с текстом ошибки мы можем обозначить элемент формы как невалидный. Установить или получить текст ошибки можно также через свойство **.validationMessage**.
Чтобы не задавливать браузерные валидации можно использовать свойство **.willValidate**, которое сообщает будут ли вызваны стандартные валидации на поле.
Передав пустую строку в качестве аргумента **.setCustomValidity()** мы можем вернуть его состояние к валидному.
Давайте добавим поддержку собственного атрибута **my-pattern**, который для наглядности будет точно так же проверять значение на соответствие регулярному выражению.
В случае ошибки сообщение, помимо того как это предусмотрено в браузере, будет выводиться рядом с полем
Валидация будет срабатывать на изменении значения нашего альтернативного поля и при нажатии кнопки.
```
OK
input:valid {
border: 1px solid green;
}
input:not(:placeholder-shown):invalid {
border: 1px solid red;
}
myform.customInput.oninvalid = (event) => {
let el = event.target;
let msg = el.parentElement.querySelector('.msg');
msg.innerText = el.validationMessage;
console.log('oninvalid, id: ', el.id);
};
myform.customInput.oninput = (event) => {
let el = event.currentTarget;
validateWithMyPattern(el);
markValidity(el);
};
function markValidity(el) {
el.checkValidity();
let msg = el.parentElement.querySelector('.msg');
if (el.validity.valid) {
msg.innerText = '';
} else {
msg.innerText = el.validationMessage;
}
}
function validateWithMyPattern(field) {
if (field.value) {
if (field.hasAttribute('my-pattern') &&
field.value.match(field.getAttribute('my-pattern'))) {
field.setCustomValidity('');
} else {
field.setCustomValidity('My pattern error');
}
}
}
myform.subm.onclick = (event) => {
for (let formEl of myform.querySelectorAll('input')) {
validateWithMyPattern(formEl);
markValidity(formEl);
}
if (myform.reportValidity()) {
alert('Valid !');
} else {
alert('Invalid !')
}
return false;
};
```
Теперь у нас два подобных поля проверяющих значение стандартным валидатором и собственноручно написанным.
Возможности могут показаться не богатыми, однако, с помощью них вы можете реализовать любые валидации в т.ч. групп полей не сильно спотыкаясь об технические ограничения как с популярными фреймворками.
Из ограничений Validation API мне более запомнилось только исходная невалидность полей. Для ее кроме хитрости с placeholder или специальными состояниями a-la untouched можно производить всю валидацию программно на событиях input и submit сочетая собственные валидаторы со стандартными.
Решая свои задачи, я пришел к необходимости создать свой компонент, выполняющий задачи формы заодно для поддержки собственных элементов ввода, позволяющий задавать разное поведение валидации и уведомлений и вешать любые валидаторы и использующий при этом стандартизированный Validation API. Посмотреть на него можно вот тут: <https://bitbucket.org/techminded/skinny-widgets/src/master/src/form/>
а код примера из этой статьи найти вот тут:
<https://bitbucket.org/techminded/myform/> | https://habr.com/ru/post/520104/ | null | ru | null |
# Молниеносный JSON в Ruby on Rails
Вывод результата в JSON достаточно прост в Rails:
```
render json: @statuses
```
Это работает отлично, если нужно вывести небольшое количество записей. Но что случится, если нам потребуется вывести сразу 10'000 записей? Производительность серьезно просядет, а самыми затратными по времени окажутся сериализация JSON и операции с базой данных.
#### Включайте только необходимые атрибуты
Первое очевидное решение — генерировать JSON только с необходимыми нам атрибутами, т.е.:
```
render json: @statuses, methods: [:latitude, :longitude, :timestamp, :virtual_odometer]
```
Отфильтрованный JSON даст нам более 20% прироста производительности:
```
default 5.940000 0.080000 6.020000 ( 6.094221)
attrs 4.820000 0.010000 4.830000 ( 4.932337)
```
#### Делайте выборку только необходимых полей
Второе решение — забирать из базы не все, а только необходимые нам поля.
```
render json: @statuses.select([:latitude, :longitude, :timestamp, :virtual_odometer])
```
Это поможет нам избежать передачи огромного количества лишних данных из базы в приложение и даст нам 2х прирост скорости:
```
default 5.940000 0.080000 6.020000 ( 6.094221)
attrs 4.820000 0.010000 4.830000 ( 4.932337)
select 2.170000 0.020000 2.190000 ( 2.222277)
```
#### Не инициализируйте объекты ActiveRecord, если это возможно
Давайте реализуем метод, который будет возвращать «молниеносный» массив хэшей вместо объектов ActiveRecord:
```
def self.lightning
connection.select_all(select([:latitude, :longitude, :timestamp, :virtual_odometer]).arel).each do |attrs|
attrs.each_key do |attr|
attrs[attr] = type_cast_attribute(attr, attrs)
end
end
end
```
Это работает также как метод [pluck](https://github.com/rails/rails/blob/f8f4ac91203506c94d547ee0ef530bd60faf97ed/activerecord/lib/active_record/relation/calculations.rb#L169-184), но возвращает массив хэшей, а не массив значений одного поля. Вызовем наш новый метод в контроллере:
```
render json: @statuses.lightning
```
Использование легковесных хэшей ускоряет создание JSON еще в 2 раза:
```
default 5.940000 0.080000 6.020000 ( 6.094221)
attrs 4.820000 0.010000 4.830000 ( 4.932337)
select 2.170000 0.020000 2.190000 ( 2.222277)
lightning 1.120000 0.010000 1.130000 ( 1.148763)
```
#### Используйте самый быстрый дампер JSON
На текущий момент доступно несколько библиотек JSON:
* [JSON](https://github.com/flori/json) — gem JSON по-умолчанию (+ C-расширения, поставляется вместе с Ruby 1.9)
* [Yajl](https://github.com/brianmario/yajl-ruby) — Yet Another JSON Library (автор Brian Lopez)
* [Oj](https://github.com/ohler55/oj) — Optimized JSON (автор Peter Ohler)
Хорошая идея использовать самую быструю из них:
```
json 0.810000 0.020000 0.830000 ( 0.841307)
yajl 0.760000 0.020000 0.780000 ( 0.809903)
oj 0.640000 0.010000 0.650000 ( 0.666230)
```
Так что мы выбираем Oj дампер:
```
render json: Oj.dump(@statuses.lightning, mode: :compat)
```
Обобщенные результаты [теста](https://gist.github.com/a012d50e817373c08f79):
```
user system total real
default 5.940000 0.080000 6.020000 ( 6.094221)
attrs 4.820000 0.010000 4.830000 ( 4.932337)
select 2.170000 0.020000 2.190000 ( 2.222277)
lightning 1.120000 0.010000 1.130000 ( 1.148763)
json 0.810000 0.020000 0.830000 ( 0.841307)
yajl 0.760000 0.020000 0.780000 ( 0.809903)
oj 0.640000 0.010000 0.650000 ( 0.666230)
``` | https://habr.com/ru/post/152719/ | null | ru | null |
# Вышел GitLab 9.0: Подгруппы и Deploy Boards
Недавно мы выпустили **GitLab 9.0**, через 18 месяцев после [выпуска версии 8.0](https://about.gitlab.com/2015/09/22/gitlab-8-0-released/). За это время мы сделали [множество значительных изменений в GitLab](https://about.gitlab.com/release-list/), выпуская новую версию 22 числа каждого месяца. Давайте кратко подведем итоги, к которым мы пришли с выпуска 8.0, и посмотрим, как старые фичи соотносятся с новыми из 9 версии. Или вы можете [перейти](#podgruppy-ce-ee) к фичам, появившимся в 9.0.
### От идеи к производству
Своими последними релизами GitLab изменил подходы команд к разработке продуктов. Всего за несколько минут вы можете развернуть GitLab в планировщике контейнеров (container scheduler), добавить CI/CD с автоматически развернутыми review apps, использовать ChatOps и проанализировать время вашего цикла (cycle time). В версии 9.0 вы сможете просматривать ваши деплои на deploy boards и отслеживать производительность приложений с помощью Prometheus. Основываясь на нашем [Мастер-Плане](https://about.gitlab.com/2016/09/14/gitlab-live-event-recap/), GitLab 9.0 предоставляет огромный набор DevOps-инструментов для разработчиков. Давайте посмотрим, как он работает.
### Юзабилити и дизайн
В версии [8.0](https://about.gitlab.com/2015/09/22/gitlab-8-0-released/), мы освежили интерфейс GitLab, изменив почти каждый элемент UI и значительно улучшив юзабилити (мы даже обновили логотип несколько месяцев назад.) С тех пор мы продолжаем инвестировать в дизайн, наращивая нашу [команду](https://about.gitlab.com/team/) UX дизайнеров и исследователей, которые с энтузиазмом работают над улучшением юзабилити, находят и лечат основные болевые точки во всех сферах от небольших твиков CSS до изменения главных потоков UX. В каждом релизе 8.x мы постепенно развивали дизайн. А в GitLab 9.0 мы достигли существенных успехов в [упрощении нашей общей, групповой и проектной навигации](#obnovlennaya-navigaciya-ce-ee). Это ключевое изменение, с помощью которого набор функций GitLab становится все более мощным.
В целях продолжения улучшения UX у нас появилась [исследовательская группа (research panel)](https://about.gitlab.com/researchpanel), в которой вы можете повлиять на будущее GitLab. Присоединившись к этой группе, вы первыми опробуете новые фичи, и ваши мысли по поводу них мы учтем в улучшениях продукта.
[Присоединяйтесь к нашей исследовательской группе](https://about.gitlab.com/researchpanel/).
### Совместная цифровая работа (Digital Work)
GitLab помогает вам объединяться для совместной цифровой работы. Мы сделали множество изменений в задачах (issues), основе совместной работы в GitLab. Например, веса задач ([8.3](https://about.gitlab.com/2015/12/22/gitlab-8-3-released/#issue-weight-ee-only)), связывание их с мерж-реквестами ([8.3](https://about.gitlab.com/2015/12/22/gitlab-8-3-released/#merge-request-references-in-issues)), перемещение задачи в другой проект ([8.6](https://about.gitlab.com/2016/03/22/gitlab-8-6-released/#move-issues-to-other-projects)), и мощный интерфейс фильтра и поиска ([8.16](https://about.gitlab.com/2017/01/22/gitlab-8-16-released/#new-issues-search-and-filter-interface)). Также мы выпустили доски задач (issue boards) ([8.11](https://about.gitlab.com/2016/08/22/gitlab-8-11-released/#issue-board)), предоставляющие простой механизм для управления потоком задач с использованием разных этапов («списков» ("lists"), на языке GitLab). GitLab 9.0 продолжает и дальше совершенствовать доски, [улучшая интеграцию с майлстоунами](#doski-s-maylstounami-ees).
Мы рады представить [**подгруппы** в GitLab 9.0](#podgruppy-ce-ee), еще один большой шаг в улучшении совместной работы в GitLab. Эта новая мощная парадигма групп в группах помогает совместной работе по принципам team-based и team-first даже в больших организациях с большим количеством разных отделов. Наша [миссия](https://about.gitlab.com/strategy/#mission) — позволить **каждому делать вклад**. Версия 9.0 помогает упрощать процессы, где бы вы ни работали, поэтому и в самом деле каждый человек в вашей организации может сделать вклад в общую задачу.
### Ревью и совместная работа над кодом
Мы продолжаем улучшать ревью и совместное написание кода в GitLab с версии 8.0, включая такие функции, как мерж после успешного выполнения конвейера ([8.3](https://about.gitlab.com/2015/12/22/gitlab-8-3-released/#auto-merge-on-build-success)), диффы (code diffs, [8.4](https://about.gitlab.com/2016/01/22/gitlab-8-4-released/#code-highlighting-in-diffs), [8.5](https://about.gitlab.com/2016/02/22/gitlab-8-5-released/#render-svgs-in-diffs), [8.7](https://about.gitlab.com/2016/04/22/gitlab-8-7-released/#better-diffs), [8.10](https://about.gitlab.com/2016/07/22/gitlab-8-10-released/#improved-diffs), [8.15](https://about.gitlab.com/2016/12/22/gitlab-8-15-released/#diff-in-notification-emails)), редактор конфликтов ([8.11](https://about.gitlab.com/2016/08/22/gitlab-8-11-released/#merge-conflict-resolution), [8.13](https://about.gitlab.com/2016/10/22/gitlab-8-13-released/#merge-conflict-editor)), версии мерж-реквестов ([8.12](https://about.gitlab.com/2016/09/22/gitlab-8-12-released/#merge-request-versions)), блокировка мержа до решения дискуссий ([8.14](https://about.gitlab.com/2016/11/22/gitlab-8-14-released/#prevent-merge-until-review-is-done)), переключение разрешений ([8.16](https://about.gitlab.com/2017/01/22/gitlab-8-16-released/#removing-your-approval-in-ee-merge-requests)), так же как сквош и мерж ([8.17](https://about.gitlab.com/2017/02/22/gitlab-8-17-released/#squash-and-merge-ee)). Многие эти и другие функции включают виджет мерж-реквеста. Поэтому в GitLab 9.0 мы [поправили его дизайн](https://about.gitlab.com/2017/03/22/gitlab-9-0-released/#merge-request-widget-usability-ce-ee), чтобы согласовать с многими существующими и будущими фичами, которые взаимодействуют с ним.
### Непрерывная интеграция
Начиная с версии [8.0](https://about.gitlab.com/2015/09/22/gitlab-8-0-released/#continuous-integration-in-gitlab) в GitLab была добавлена непрерывная интеграция (continuous integration, CI). После этого в API была добавлена новая функциональность CI ([8.4](https://about.gitlab.com/2016/01/22/gitlab-8-4-released/#new-ci-features-in-api)), а события конвейеров стали доступны через веб-хуки ([8.11](https://about.gitlab.com/2016/08/22/gitlab-8-11-released/#pipelines-web-hooks)). Также была произведена интеграция конвейеров в мерж-реквесты ([8.11](https://about.gitlab.com/2016/08/22/gitlab-8-11-released/#pipelines-in-mrs), [8.17](https://about.gitlab.com/2017/02/22/gitlab-8-17-released/#additional-pipeline-details-included-in-merge-request-workflow)) и коммиты ([8.13](https://about.gitlab.com/2016/10/22/gitlab-8-13-released/#pipelines-for-commits)), к тому же было добавлено графическое отображение конвейеров ([8.11](https://about.gitlab.com/2016/08/22/gitlab-8-11-released/#pipelines-graph)). В каждом релизе [начиная с 8.10 и до 8.17](https://about.gitlab.com/release-list/) добавлялись улучшения GitLab runner. Мы запустили review apps ([8.12](https://about.gitlab.com/2016/09/22/gitlab-8-12-released/#review-apps-experimental), [8.13](https://about.gitlab.com/2016/10/22/gitlab-8-13-released/#ability-to-stop-review-apps), [8.14](https://about.gitlab.com/2016/11/22/gitlab-8-14-released/#review-apps)) и auto deploy ([8.15](https://about.gitlab.com/2016/12/22/gitlab-8-15-released/#auto-deploy)) для автоматического развертывания кода в автоматически создаваемые среды. А с выходом GitLab 9.0 мы запускаем [deploy boards](#deploy-boards-eep), что позволит следить за развертыванием ваших приложений на различные серверы.
### Анализ и мониторинг
GitLab предоставляет инструменты для анализа и мониторинга вашего кода и процесса разработки. В версии ([8.3](https://about.gitlab.com/2015/12/22/gitlab-8-3-released/#contribution-analytics-ee-only)) было добавлено отображение вклада участников проекта в разработку, а также аналитика цикла разработки ([8.12](https://about.gitlab.com/2016/09/22/gitlab-8-12-released/#cycle-analytics), [8.13](https://about.gitlab.com/2016/10/22/gitlab-8-13-released/#cycle-analytics-improvements), [8.14](https://about.gitlab.com/2016/11/22/gitlab-8-14-released/#cycle-analytics-events)). Была добавлена функциональность учета времени ([8.14](https://about.gitlab.com/2016/11/22/gitlab-8-14-released/#time-tracking-beta-ee), [8.16](https://about.gitlab.com/2017/01/22/gitlab-8-16-released/#time-tracking-in-ce-and-api)). В версиях [8.16](https://about.gitlab.com/2017/01/22/gitlab-8-16-released/#monitoring-gitlab-with-prometheus) и [8.17](https://about.gitlab.com/2017/02/22/gitlab-8-17-released/#monitoring-gitlab-with-prometheus) был добавлен open source [Prometheus](https://prometheus.io), благодаря чему появилась возможность мониторинга сервера, на котором запущен инстанс GitLab через консоль Prometheus. В GitLab 9.0 был добавлен [интегрированный мониторинг](#integrirovannyy-monitoring-ce-ee) на основе Prometheus, встроенный в пользовательский интерфейс GitLab.
### Благодарности
Мы очень благодарны нашему сообществу, участники которого создают и комментируют множество задач, а также напрямую добавляют исходный код. [В версии 9.0 более 130 мерж-реквестов созданы членами сообщества](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests?label_name%5B%5D=Community+Contribution&milestone_title=9.0&scope=all&state=merged), многие из которых [внесли значительный вклад в развитие проекта](https://about.gitlab.com/2017/03/22/gitlab-9-0-released/#notable-community-contributions-ce).
В GitLab CE, который является open source проектом, сделано уже более [47000 коммитов](https://gitlab.com/gitlab-org/gitlab-ce/commits/master), что более чем в два раза превышает количество коммитов в версии 8.1 — [20000](https://about.gitlab.com/2015/10/22/gitlab-8-1-released/). На данный момент [более 1500](http://contributors.gitlab.com) участников внесли свой вклад в развитие GitLab. Спасибо вам!
### Рост
Наша команда тоже серьезно выросла за это время. На момент выхода версии 8.0 в GitLab работало менее 25 человек из семи стран. Сегодня нас [больше 150 человек из 37 стран](https://about.gitlab.com/team/). Такой рост позволил нам выпускать три различные версии GitLab: [Community Edition (CE), Enterprise Edition Starter (EES) и Enterprise Edition Premium (EEP)](https://about.gitlab.com/products/).
### Уникальная платформа
В последнее время, инструменты управления жизненным циклом приложения (application lifecycle management — ALM) развиваются в направлении единого интегрированного подхода. GitLab всецело поддерживает такой вектор развития и, как следствие, в данной версии функциональность мониторинга поставляется по умолчанию, как и [планировалось](https://about.gitlab.com/direction/#scope). Отныне вы можете заниматься разработкой, написанием кода, сборкой, развертыванием и мониторингом вашего приложения прямо из GitLab.
GitLab является полноценным и самодостаточным инструментом управления жизненным циклом приложения с единым интерфейсом и хранилищем данных. Благодаря такому интегрированному подходу сокращается время разработки (измеряемо при помощи аналитики ее цикла), повышается ее эффективность, а также нормализуется процесс разработки.
Пользуйтесь версией 9.0 с удовольствием!
[Зарегистрируйтесь, чтобы просмотреть презентацию релиза](http://get.gitlab.com/gitlab-9/)
### Встречи по выходу GitLab 9.0
Митапы по поводу выхода GitLab 9.0 пройдут в Сан-Франциско, Денвере, Бостоне, Амстердаме, Лондоне и Новом Орлеане.
[Присоединяйтесь!](https://about.gitlab.com/events/)
[MVP](https://about.gitlab.com/mvp/) этого месяца — [Jacopo Beschi](https://gitlab.com/jacopo-beschi).
------------------------------------------------------------------------------------------------------
Благодаря ему появилась возможность [убирать у элемента списка todo ранее присвоенный статус ‘завершенный’](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/8691), что позволяет вернуть todo-задачу, которую вы отметили завершённой по ошибке и, как следствие, повышает продуктивность разработки. Спасибо, Jacopo!
Подгруппы (CE, EE)
------------------
Использование GitLab всегда было самым простым способом совместной работы над кодом на всех этапах существования проекта, начиная с идеи и заканчивая релизом. *Также* от пользователей поступали запросы на реализацию совместной работы, основанной на иерархии команд разработчиков с отдельными репозиториями. В Gitlab 9.0 мы с радостью представляем новую версию групп GitLab, поддерживающую создание групп внутри групп, то есть «подгрупп».
Любая подгруппа на любом уровне иерархии является полноценной группой GitLab, которой может принадлежать несколько проектов (репозиториев). Таким образом, новая версия групп позволяет создавать иерархию вплоть до 20 уровней вложенности.
В данном примере организация (представленная группой `gitlab-nested`) включает в себя команды по дизайну, бэкэнду и фронтэнду, у каждой из которых есть своя группа, содержащаяся в `gitlab-nested`. Группы `design` и `backend` имеют собственные подгруппы.
Посмотреть на текущий процесс дальнейшей разработки функциональности групп и оставить свои пожелания можно [здесь](https://gitlab.com/gitlab-org/gitlab-ce/issues?label_name%5B%5D=subgroups).
[Более детальная документация по подгруппам](https://docs.gitlab.com/ce/user/group/subgroups/)
Deploy Boards (EEP)
-------------------
GitLab поддерживает мощную систему CI/CD, в которой только для проектов на GitLab.com есть больше тысячи обработчиков (runners). Выполняемые на них конвейеры (pipelines) компилируют и собирают ПО, запускают автоматические тесты, создают review apps и даже могут проводить развертывание в staging и production. Ранее по результатам развертывания приходил отчет, в котором указывалось, было ли обновление среды успешным. Но что если требуется больше деталей? Или, скажем, единый интерфейс для просмотра информации по всем развертываниям во всех средах? Для крупных организаций ответы на эти вопросы становятся особенно важными.
С выходом GitLab 9.0 мы рады представить Deploy Boards для сред, использующих Kubernetes. Вкладка Pipelines -> Environments предоставляет единый интерфейс для просмотра информации о текущем состоянии и статусе развертывания для каждой среды, вплоть до каждого пода (pod). Разработчики и другие члены команды могут просматривать прогресс и состояние развертывания для каждого пода по отдельности в привычной среде разработки, не нуждаясь в доступе к Kubernetes.
В честь запуска Deploy Boards будут доступны в версии 9.0 бесплатно для пользователей Enterprise Edition Starter.
[Документация по Deploy Boards](https://docs.gitlab.com/ee/user/project/deploy_boards.html)
Экспорт задач (EES)
-------------------
В GitLab уже реализована функциональность фильтрации и поиска по задачам. Однако, существуют ситуации, в которых необходимо получить список задач для внешнего использования. Например, для анализа оффлайн или для работы с командами, не использующими GitLab. В версии 9.0 EES при нажатии на кнопку download в правом верхнем углу экрана на странице просмотра задач вам будет отправлено письмо со списком задач в формате CSV.
Поскольку данная функциональность интегрирована прямо в окно просмотра задач, вы можете использовать механизмы фильтрации и поиска для того, чтобы скачать список именно тех задач, которые вам нужны. Обработка такого запроса и отправление письма происходят асинхронно в фоновом режиме, так что вы можете продолжать пользоваться GitLab сразу после подтверждения запроса.
Более подробную информацию об экспорте задач можно найти [здесь](https://docs.gitlab.com/ee/user/project/issues/csv_export.html)
Интегрированный мониторинг (CE, EE)
-----------------------------------
Наличие крепкой инфраструктуры мониторинга является ключевым условием для успешного управления приложением. Она позволяет оперативно реагировать на изменения, отслеживать их последствия и проводить отладку в случае возникновения проблем. Однако, создание такой инфраструктуры зачастую имеет низкий приоритет, особенно в тестовых средах. Как следствие, нередки случаи, когда система мониторинга не интегрирована в проект.
С выходом GitLab 9.0 мы с гордостью представляем первую систему мониторинга, полностью интегрированную в конвейеры CI/CD и репозиторий исходного кода. Отныне в тестовых средах разработки GitLab, таких как staging и review apps, используются те же технологии мониторинга, что и в итоговой «боевой» среде. Данная система реализована с использованием [Prometheus](https://prometheus.io).
В данной версии отслеживается использование ресурсов процессора и памяти вашим приложением, запущенном в каждой среде Kubernetes, и это только начало. В ближайшем будущем планируется добавить оценку влияния мержа на производительность, поддержку более широкого набора анализируемых данных, а также передачу данных мониторинга в Deploy Boards.
Примите участие в обсуждении дальнейшего развития системы мониторинга GitLab [здесь](https://gitlab.com/gitlab-org/gitlab-ce/issues?scope=all&utf8=✓&state=opened&label_name[]=Prometheus&label_name[]=feature%20proposal).
[Документация об интеграции проектов с Prometheus](https://docs.gitlab.com/ce/user/project/integrations/prometheus.html)
Улучшения производительности (CE, EE)
-------------------------------------
Как обычно, мы усердно работаем над повышением производительности GitLab. В версию 9.0 внесен целый ряд изменений направленных на значительное ускорение работы системы. В GitLab EE 9.0 в Elasticsearch (ES) внесен ряд исправлений, а также поддержка версии ES 5.1. Следуя философии "cloud native", мы добавили поддержку [AWS-hosted](https://aws.amazon.com/elasticsearch-service/) и HTTPS кластеров Elasticsearch. Улучшения в процессе первичной индексации ускорят работу крупномасштабных проектов на GitLab EE. Кроме того, ряд небольших изменений был внесен в процесс индексации репозиториев.
Был [улучшен алгоритм поиска по автору и исполнителю задачи](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/9030), а также [удалены ненужные запросы](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/9006). Эти изменения должны быть заметны большинству пользователей, поскольку просмотр задач и мерж-реквестов, назначенных на себя, является довольно частой процедурой. На GitLab.com уже наблюдается значительное снижение времени транзакций в связи с этими изменениями.
[Взгляните](https://gitlab.com/gitlab-org/gitlab-ce/issues?label_name%5B%5D=performance&milestone_title=9.0&scope=all&state=closed) на полный список улучшений производительности в версии 9.0 и не забывайте следить за дальнейшими улучшениями в предстоящих релизах. GitLab продолжает становиться быстрее, особенно при работе с крупномасштабными проектами.
Известно ли вам, что [GitLab.com](https://gitlab.com) это «всего лишь» крупномасштабная имплементация GitLab EE с сотнями тысяч пользователей? Это позволяет оценить масштаб, на котором можно работать с GitLab EE, а вышеупомянутые улучшения производительности заметно повысят скорость и надежность работы GitLab.com.
*Transaction timings dropping significantly for issues dashboard*
*Transaction timings dropping significantly for merge requests dashboard*
Распределение нагрузки на базы данных (EE)
------------------------------------------
Балансировка загрузки запросов к базам данных позволяет рассредоточить объем запросов и нагрузку на серверы. Как правило, для этого требуется использование стороннего ПО, например [pgpool](http://www.pgpool.net/). Начиная с версии 9.0 GitLab Enterprise Edition поддерживает распределение запросов при использовании PostgreSQL.
У такого подхода много плюсов, например, уменьшение нагрузки и использования памяти основной базы данных, а также сокращение времени ответа на запросы. Кроме того, благодаря распределению нагрузки, излишне ресурсоемкие запросы никак не влияют на запросы к базам данных на других серверах, что уменьшает вероятность их негативного влияния на функционирование GitLab.
Балансировщик запросов GitLab также реагирует на отказы баз данных. В случаях, когда основная база данных не отвечает, либо произошло переключение на вторичную, балансировщик повторяет операцию после небольшой паузы. А в случаях, когда не отвечают вторичные базы данных, распределитель игнорирует их до тех пор, пока они снова не станут доступными. Для наиболее прозрачного функционирования такой системы необходимо использовать балансировщик запросов (например, HAProxy) для каждого хоста.
Стоит обратить внимание на то, что при использовании системы распределения запросов возникает проблема задержки копирования. Например, при записи и последующем чтении из вторичной базы данных возможна ситуация, при которой данных на этой базе еще нет. Одним из способов решения данной проблемы является применение синхронного копирования. Однако, при таком способе возможно существенное увеличение времени обработки запросов из-за задержки копирования. Более того, если по каким-то причинам копия данных становится недоступной, вся система может остановиться.
Для решения этой проблемы используется подход “sticky sessions”: когда пользователь инициирует запись в основную базу данных, сессия этого пользователя продолжает использовать именно основную базу. Это продолжается до истечения таймаута (30 секунд), либо до того момента, когда записываемые данные становятся доступными на всех вторичных базах.
Больше информации о настройке балансировщика базы данных есть в документации ["Database Load Balancing"](http://docs.gitlab.com/ee/administration/database_load_balancing.html).
Обновленная навигация (CE, EE)
------------------------------
В компании GitLab большая часть бизнес-процессов (а не только разработка продукта) происходит в самом GitLab.com. Поэтому мы точно знаем, насколько важна навигация. Мы хотим сделать ее плавной, интуитивной и эффективной для ваших ежедневных задач, особенно тем людям, кто использует GitLab по несколько часов каждый день.
Дизайн навигации — ключевое место в достижении этой цели, поэтому в 9.0 мы изменили интерфейс, подключив лучшие практики от наших дизайнеров и обратную связь от пользователей. На первый взгляд ничего не изменилось. Это специально. Мы кропотливо анализировали, что уже работает хорошо, и меняли только проблемные места.
Мы перегруппировали (а в некоторых случаях объединили и переименовали) вкладки первого и второго уровня в меню навигации. Вкладка активностей теперь вложена во вкладку проекта. Главные вкладки репозитория, задач, мерж-реквестов и конвейеров теперь расположены соответственно слева направо, по смыслу «от идеи к производству». Вкладки второго уровня из вкладки Graph мы перегруппировали и перенесли в другие места. Мы придумывали, где каждый пункт меню должен находиться, используя данные аналитики и ваших пожеланий. [Узнайте подробнее о деталях изменения.](https://gitlab.com/gitlab-org/gitlab-ce/issues/26348)
Еще одно существенное изменение — всплывающая боковая панель. Ее заменило менее навязчивое выпадающее меню слева вверху, которое перекрывает не так много содержимого экрана. Раньше мы использовали выпадающее меню для настроек: оно появлялось по клику на шестеренку справа вверху на страницах проекта или группы. Теперь настройки переехали в интерфейс навигации с вкладками, что внесло гармонию и упростило их использование.
В 9.0 мы упростили настройки конфигурации вида проекта, поэтому теперь вы можете выбрать, что показывать на «домашней странице» каждого проекта: список файлов и README или текущую активность. (Это настройка профиля, применяемая ко всем проектам, которые вы просматриваете.) Первая опция используется по умолчанию. Раньше по умолчанию показывался только README, но мы хотели чего-то, что помогло бы и новым, и существующим пользователям. Поэтому мы изучили обратную связь и пользовательские исследования и остановились на этом варианте.
Еще мы вернули возможность быстро создавать новые проекты, просто нажав кнопку `+` справа вверху.
Изменение порядка задач в списке доски (CE, EE)
-----------------------------------------------
[Issue Boards](https://about.gitlab.com/solutions/issueboard/) — отличный способ управлять задачами, перемещающимся по разным стадиям («спискам» ("lists") в GitLab), чтобы быстро перейти от идеи к производству. Но пользователи часто хотят изменять порядок или приоритет задач даже внутри одного списка. В версии 9.0 вы можете изменять порядок задач в списке доски задач, воспользовавшись простым перетаскиванием.
[Узнайте больше об Issue Boards для Community Edition в нашей документации](https://docs.gitlab.com/ce/user/project/issue_board.html).
Доски с майлстоунами (EES)
--------------------------
Доска задач GitLab позволяет вам управлять группами задач в одном майлстоуне (milestone), но требует выбирать связанный фильтр майлстоунов каждый раз, когда вы к нему переходите. В GitLab 9.0 EES вы сможете создавать доску задач, связанную с конкретным майлстоуном. Это позволит вам создавать уникальные доски для отдельных майлстоунов.
Поскольку вы планируете и выполняете задачи в каждом новом майлстоуне, мы предполагаем, что вам пригодятся новые доски. Это позволит удобно переключаться между майлстоунами, и при этом по-прежнему можно сохранять и смотреть на предыдущие законченные майлстоуны.
[Больше об Issue Boards для Enterprise Edition в нашей документации](https://docs.gitlab.com/ee/user/project/issue_board.html).
API v4 (CE, EE)
---------------
Наш [API](https://docs.gitlab.com/ce/api/) — отличное средство для автоматизации задач и управления GitLab. Мы постоянно улучшаем наш API, чтобы он поддерживал новые фичи, которые мы добавляем каждый месяц, чтобы сделать GitLab лучшей средой разработки от начала до завершения проекта.
Постоянные итерации привели к нескольким несоответствиям в существующем API. В этом релизе мы представляем четвертую версию нашего API. Мы постарались сделать его более консистентным и соответствующим стандарту RESTful API.
Мы продолжим поддерживать третью версию API только до августа 2017 и предлагаем вам внести все необходимые изменения в приложения, использующие эту версию.
[Посмотрите изменения 4 версии, чтобы узнать, что стало другим](https://docs.gitlab.com/ee/api/v3_to_v4.html)
Аварийное восстановление (альфа-версия) (EEP)
---------------------------------------------
Вне зависимости от размера вашей компании вы должны быть уверены в устойчивости инфраструктуры к любым природным катаклизмам или влиянию человеческого фактора. Одна из лучших практик для этой задачи — хранить данные на, как минимум, двух серверах (один главный, один второстепенный), расположенных в разных местах: если с одним сервером что-то случится, второй будет в сохранности. Это необходимо реализовать для того, чтобы уменьшить время простоя и риск потери данных. Мы получили множество запросов на встроенное в GitLab аварийное восстановление. Сегодня мы представляем первый шаг к его поддержке.
С версии [GitLab 8.5](https://about.gitlab.com/2016/02/22/gitlab-8-5-released/), GitLab поставляется с [Geo](https://about.gitlab.com/features/gitlab-geo/). Это фича, которая позволяет заводить один или несколько дополнительных инстансов GitLab, которые зеркалируют (mirror) ваш главный инстанс. Основная цель Geo — кардинально ускорить клонирование и получение (`git fetch`) проектов на больших расстояниях. С этим сценарием Geo справляется отлично, но у нее есть один недостаток, из-за которого мы не используем эту технологию для полной поддержки аварийного восстановления: файлы, сохраненные на диске, не реплицируются.
[Мы активно работаем над исправлением этого недостатка](https://gitlab.com/gitlab-org/gitlab-ee/issues/846), а в GitLab 9.0 мы выпускаем первый этап поддержки сценариев аварийного восстановления. Несколько важных изменений Geo появилось уже в этом релизе:
* Если вы используете LFS, объекты LFS будут автоматически дублироваться в дополнительные ноды ([мерж-реквест](https://gitlab.com/gitlab-org/gitlab-ee/merge_requests/1237)).
* Все загрузки файлов теперь записываются в базу данных ([мерж-реквест](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/8893)).
Это позволит нам реплицировать эти файлы в последующей итерации.
* Появился новый процесс автоматического заполнения репозиториев
([мерж-реквест](https://gitlab.com/gitlab-org/gitlab-ee/merge_requests/1197)).
* Теперь вы можете отключить дополнительный нод в пользовательском интерфейсе.
* А пока все описанные выше фичи есть только в альфа-версии, [главная фича Geo](https://about.gitlab.com/features/gitlab-geo/), используемая для клонирования и получения проектов на больших расстояниях, по-прежнему пригодна для коммерческого использования (production-ready).
[Документация](https://docs.gitlab.com/ee/gitlab-geo/configuration.html) расскажет вам, как включить альфа-версию аварийного восстановления.
Аварийное восстановление доступно всем клиентам Enterprise Edition Premium как часть GitLab Geo.
На заметку: благодаря [обновлению PostgreSQL's](https://about.gitlab.com/2017/03/22/gitlab-9-0-released/#postgresql-version-upgrade), произошедшему в GitLab 9.0, GitLab Geo 8.x стал несовместим с GitLab Geo 9.0, поэтому обновляться нужно вручную. Если вы уже используете Geo, прочитайте [инструкции для обновления](https://docs.gitlab.com/ee/gitlab-geo/updating_the_geo_nodes.html) перед обновлением до GitLab 9.0.
---
Подробные release notes и инструкции по обновлению/установке можно прочитать в оригинальном англоязычном посте: <https://about.gitlab.com/2017/03/22/gitlab-9-0-released/>
Перевод с английского выполнен переводческой артелью «Надмозг и партнеры», <http://nadmosq.ru>. Над переводом работали [nick\_volynkin](https://habr.com/ru/users/nick_volynkin/), [rishavant](https://habr.com/ru/users/rishavant/) и [sgnl\_05](https://habr.com/ru/users/sgnl_05/) . | https://habr.com/ru/post/326456/ | null | ru | null |
# Автоматизированное создание отчета по тестированию
#### Введение
Так уж сложилось, что у нас в компании ведется учет работ по тестированию в небезызвестных GoogleDocs. Поскольку таким учетом занимаюсь я один, то это идеальный вариант. Плюс еще есть возможность без труда поделиться наработками с коллегами и не нужно заботиться об актуальности версий — все сохраняется моментально.
Это основные причины выбранного варианта работы. Но, как известно, у любой монеты две стороны. Минус такого подхода состоит в том, что большие проекты трудно обрабатывать и составлять вменяемые отчеты по тестированию (для этих целей, безусловно, подходят системы управления тестами).
Совсем недавно я столкнулся с Google Script. Это инструмент, позволяющий намного эффективнее работать с документами в облаке. Я решил, что он подойдет для задачи автоматизированного составления отчетов по тестированию. И вот что получилось.
##### Структура
В документе в виде таблицы я веду описания пользовательских сценариев для тестирования приложений. Не претендую на подробное описание, однако самая критичная информация там имеется, а именно: раздел, к которому относится сценарий, название самого сценария, шаги сценария, статус пройденного сценария, комментарии и ссылка на страницу с описанием ошибки в баг-трекере. Набор статусов у нас обычно ограничен «Реализовано», «Дефект», «Отложено». На некоторых проектах могут добавляться и другие, но не суть. Выглядит это следующим образом:
Очевидно, что такие сценарии не удобно вести на одной странице — есть смысл разбить на несколько листов (например, по этапам или релизам).
##### Задача
Необходимо максимально упростить жизнь тестировщика при составлении отчетов тестирования. Идеальным будет вариант, где можно посмотреть сводку по разделам и проекту целиком, а так же не только получить список ошибок и ссылки на них, но и посмотреть на общую картину.
##### Решение
В качестве решения я выбрал таблицу, разделенную по разделам. Каждая строка соответствует сценарию тестирования и окрашена в соответствующий цвет (для дефектов — красный, для готовых задач — зеленый, для остального — желтый). При этом подводится статистика для каждого из разделов отдельно (сколько ошибок, сколько успешных сценариев, сколько других, то же самое в процентах) и для всего проекта целиком.
Вот такой вид отчета для сценариев:
Вот что получилось для статистики:
##### Как же это делать?
Для начала нам нужно создать скрипт внутри документа. Делается это буквально за несколько минут.
Сначала необходимо создать таблицу на диске Google.
Затем перейти в меню «Инструменты» и выбрать пункт «Редактор скриптов»
После этого выбираем пункт меню «Пустой проект», стираем код и начинаем писать свой.
Для начала напишем функцию onOpen:
```
function onOpen() {
var spreadsheet = SpreadsheetApp.getActive();
var menuItems = [
{name: 'Сгенерировать отчет по тестированию', functionName: 'generateReport_'}
];
spreadsheet.addMenu('Отчет', menuItems);
}
```
Это поможет нам добавить пункт меню в панель инструментов:
Далее пишем функцию, которая будет вызываться при выборе этого пункта меню:
```
function generateReport_() {
//Список интересующих колонок на странице сценариев
var columns = ['Раздел', 'Название сценария', 'Статус', 'Комментарии', 'Тикет'];
//Список колонок для страницы отчета
var reportColumns = ['Название сценария', 'Статус', 'Комментарии', 'Тикет'];
//Функция для формирования массива с информацией о сценариях
var Data = getAllCases(columns);
//Функция создания листа с отчетом
CreateNewSheet();
//Функция сбора и вывода статистики
var stat = FormReport(Data, reportColumns);
ShowStat(stat);
}
```
Ну а теперь по порядку.
Функция пробегает по всем листам открытого файла и считывает всю информацию для отчета:
```
function getAllCases(columns)
{
var sheets = SpreadsheetApp.getActive().getSheets();
var data = new Array();
for (q=0; q
```
Функция формирует массив для вывода в удобочитабельном виде. Тут есть одна особенность — если вы поменяли местами поля на разных листах, то ничего страшного не случится. Массив parts содержит списки разделов, по которым сгруппированы сценарии, а его элементы — имя раздела и список сценариев в виде массива:
```
function getCases(columns)
{
var range = SpreadsheetApp.getActiveSheet().getDataRange().getValues();
var fields = FindFields(range[0], columns);
var parts = new Array();
for (i=1; i
```
Собственно, это и есть функция, благодаря которой не так страшно путать местами колонки на страницах сценариев:
```
function FindFields (data, columns)
{
var fields = new Array();
for (i=0; i
```
Для создания нового листа с отчетом:
```
function CreateNewSheet()
{
SpreadsheetApp.getActive().insertSheet('Отчет');
SpreadsheetApp.setActiveSheet(SpreadsheetApp.getActive().getSheetByName('Отчет'));
}
```
Формирование самого отчета, сбор статистики и немного оформления:
```
function FormReport(data, columns)
{
var doc = SpreadsheetApp.getActive();
var stat = [0, 0, 0, 0];
doc.appendRow(columns);
doc.setColumnWidth(1, 300);
doc.setColumnWidth(2, 200);
doc.setColumnWidth(3, 300);
doc.setColumnWidth(4, 300);
for (i=0; i
```
Функция вывода в отчет информации по одному разделу и формирование статистики по нему, а так же оформления для более приятного чтения:
```
function WritePart(data, columns)
{
SpreadsheetApp.getActive().appendRow([data['name']]).set;
var line = SpreadsheetApp.getActive().getLastRow();
SpreadsheetApp.getActive().getRange("A"+line).setFontSize(20);
var defects = 0;
var done = 0;
var skipped = 0;
var other = 0;
for (k=0; k
```
И, наконец, финальная статистика и много оформления:
```
function ShowStat(stat)
{
SpreadsheetApp.getActive().appendRow(['Всего по проекту:']);
var line = SpreadsheetApp.getActive().getLastRow();
SpreadsheetApp.getActive().getRange("A"+line).setFontSize(20);
SpreadsheetApp.getActive().appendRow(['Реализовано:', stat[1], (stat[1]/(stat[0]+stat[1]+stat[2]+stat[3])*100).toFixed(2) + "%"]);
line = SpreadsheetApp.getActive().getLastRow();
SpreadsheetApp.getActive().getRange("A"+line+":C"+line).setBackground('green');
SpreadsheetApp.getActive().appendRow(['Дефектов:', stat[0], (stat[0]/(stat[0]+stat[1]+stat[2]+stat[3])*100).toFixed(2) + "%"]);
line = SpreadsheetApp.getActive().getLastRow();
SpreadsheetApp.getActive().getRange("A"+line+":C"+line).setBackground('red');
SpreadsheetApp.getActive().appendRow(['Отложено:', stat[2], (stat[2]/(stat[0]+stat[1]+stat[2]+stat[3])*100).toFixed(2) + "%"]);
line = SpreadsheetApp.getActive().getLastRow();
SpreadsheetApp.getActive().getRange("A"+line+":C"+line).setBackground('yellow');
SpreadsheetApp.getActive().appendRow(['Другое:', stat[3], (stat[3]/(stat[0]+stat[1]+stat[2]+stat[3])*100).toFixed(2) + "%"]);
line = SpreadsheetApp.getActive().getLastRow();
SpreadsheetApp.getActive().getRange("A"+line+":C"+line).setBackground('yellow');
}
```
Для полноценной сборки нужны все эти функции в любой последовательности в файле скрипта.
Код не идеален — есть над чем работать, однако если кому-то это пригодится, буду рад ответить на вопросы.
##### Заключение
Я привел один из примеров использования скриптов от Google. Стоит признать, что это довольно мощный инструмент для работы с документами. По крайней мере, он хорошо справился с этой задачей. Есть еще примеры использования скриптов для помощи в работе, например, [вот эта интересная статья](http://habrahabr.ru/post/193376/). Судя по всему, Google Script может стать отличным помощником в повседневной жизни IT'шника. | https://habr.com/ru/post/195820/ | null | ru | null |
# Алгоритм жевания для тачскрина
Не так давно вышла моя первая личная игра для мобильных. Суть заключается в том, что врагов надо пережевывать пальцами. Алгоритм не уникальный, но встречается редко. На первый взгляд, нужно только прослушать зум-движение двух пальцев, вроде ничего сложного, однако в процессе разработки игры выявляются различные подводные камни.
* Вычисление времени на сжатие челюстей;
* Сочетание жевания с управлением персонажем;
* Изменение параметров по ходу тестов.
Весь код написан на языке с# для движка Unity3D, для 2Д игры. Перейдем непосредственно к коду. В методе Update вычисляем кол-во тачей, и производим соответствующие действия. Двигаем персонажа в случае одного прикосновения:
```
//Если одно прикосновение
if (Input.touchCount == 1) {
//Если челюсти не сжимаются или не разжимаются, персонаж двигается к месту прикосновения
if (!compressing && !decompressing) {
Touch singleTouch = Input.GetTouch(0);
Vector3 targetPoint = Camera.main.ScreenToWorldPoint (singleTouch.position);
targetPoint = new Vector3 (targetPoint.x, targetPoint.y, 0);
transform.position = Vector3.MoveTowards (transform.position, targetPoint, movementSpeed * Time.deltaTime);
}
}
```
Тут ничего сложного, можно двигаться дальше. Код обработки двух касаний. Если нет сжимания/разжимания челюстей, то персонаж перемещается между двух пальцев.
```
if (Input.touchCount > 1) {
//Работа с двумя первыми касаниями.
Touch touch1 = Input.GetTouch(0);
Touch touch2 = Input.GetTouch(1);
//Если челюсти не работают, передвигаем персонажа между пальцами
if (!compressing && !decompressing) {
Vector3 targetPoint = Camera.main.ScreenToWorldPoint ((touch1.position + touch2.position) / 2);
targetPoint = new Vector3 (targetPoint.x, targetPoint.y, 0);
transform.position = Vector3.MoveTowards (transform.position, targetPoint, movementSpeed * Time.deltaTime);
}
float currentDistance = Vector2.Distance(touch1.position, touch2.position);
if(pastFingersDistance == 0) {
//Обнуление прошлого расстояния, если первый раз засечено два тача
pastFingersDistance = currentDistance;
}else if(currentDistance < pastFingersDistance - fingersMunchDetectionMin) {
//Метод включения сжатия челюстей. Управление графикой, у каждого индивидуально.
SetCompression();
}else if(currentDistance > pastFingersDistance + fingersMunchDetectionMin) {
//Метод включения разжатия челюстей. Управление графикой, у каждого индивидуально.
SetDecompression();
}
}
//Обнуление переменной, для того чтоб вычислять необходимость жевания относительно новой позиции пальцев.
if(Input.touchCount < 2) pastFingersDistance = 0;
//Если касаний стало меньше двух, а челюсти сжаты - они автоматически разжимаются.
if(Input.touchCount < 2 && isCompressed) SetDecompression();
```
*fingersMunchDetectionMin* — переменная, определяющая какое расстояние достаточно для того, чтобы начать жевание. Достаточно долго настраивал с помощью нескольких друзей. У каждого оказалось разное восприятие, вывел нечто среднее. В ходе тестов также выяснилось, что постоянно жевать пальцами пользователю попросту неудобно. Возникла необходимость сделать сжимание челюстей по простому тапу и метод, изложенный выше, приобрел следующий вид:
```
if (Input.touchCount > 1) {
//Работа с двумя первыми касаниями.
Touch touch1 = Input.GetTouch(0);
Touch touch2 = Input.GetTouch(1);
//Проверка если челюсти не работают
if (!compressing && !decompressing) {
float touch1Time = 0;
float touch2Time = 0;
//Вычисляется сколько времени активен тач 1
if (tapsHash.Contains (touch1.fingerId)) {
float startTouch1Time = (float) tapsHash [touch1.fingerId];
touch1Time = Time.time - startTouch1Time;
}
//Вычисляется сколько времени активен тач 2
if (tapsHash.Contains (touch2.fingerId)) {
float startTouch2Time = (float) tapsHash [touch2.fingerId];
touch2Time = Time.time - startTouch2Time;
}
//Если время отведенное на тап уже превышено для двух пальцев, персонаж передвигается между пальцами.
if (touch1Time > SECONDS_FOR_TAP && touch2Time > SECONDS_FOR_TAP) {
Vector3 targetPoint = Camera.main.ScreenToWorldPoint ((touch1.position + touch2.position) / 2);
targetPoint = new Vector3 (targetPoint.x, targetPoint.y, 0);
transform.position = Vector3.MoveTowards (transform.position, targetPoint, movementSpeed * Time.deltaTime);
}
}
float currentDistance = Vector2.Distance(touch1.position, touch2.position);
if(pastFingersDistance == 0) {
//Обнуление прошлого расстояния, если первый раз засечено два тача
pastFingersDistance = currentDistance;
}else if(currentDistance < pastFingersDistance - fingersMunchDetectionMin) {
//Метод включения сжатия челюстей. Управление графикой, у каждого индивидуально.
SetCompression();
}else if(currentDistance > pastFingersDistance + fingersMunchDetectionMin) {
//Метод включения разжатия челюстей. Управление графикой, у каждого индивидуально.
SetDecompression();
}
}
//Обнуление переменной, для того чтоб вычислять необходимость жевания относительно новой позиции пальцев.
if(Input.touchCount < 2) pastFingersDistance = 0;
//Если касаний стало меньше двух, а челюсти сжаты - они автоматически разжимаются.
if(Input.touchCount < 2 && isCompressed) SetDecompression();
//Метод который отвечает за осуществление жевания по тапу.
SetTapAttackListener ();
```
Константа SECONDS\_FOR\_TAP — время, отведенное на тап, как и расстояние на жевание, достаточно долго тестировалась и настраивалась. Ну и собственно последние методы, которые осуществляют жевание по простому тапу:
```
void SetTapAttackListener() {
if (Input.touchCount > 0) {
foreach (Touch touch in Input.touches) {
//Обработка активного тача
DetectOneTouchTap (touch);
}
}
}
void DetectOneTouchTap(Touch touch) {
if (touch.phase == TouchPhase.Began) {
//В случае если тач только начался, он записывается в хэш-таблицу для обработки.
//Ключ - ид тача, значение - начало прикосновения.
tapsHash.Add (touch.fingerId, Time.time);
} else if(touch.phase == TouchPhase.Ended) {
float startTouchTime = (float) tapsHash [touch.fingerId];
float timeOfTouch = Time.time - startTouchTime;
//Осуществление сжатия и разжатия челюстей, если тач был тапом
if (timeOfTouch <= SECONDS_FOR_TAP) {
SetCompression();
SetDecompression();
}
tapsHash.Remove (touch.fingerId);
}
}
```
В начале пытался найти сей алгоритм на просторах интернета, не для копипаста, а для проверки своего хода мыслей. Однако ничего не нашел и решил выложить его в помощь коллегам. Сейчас очень хорошо вижу, что код несколько хаотичен, ну а в остальном — жду комментариев.
Update 1:
Демонстрация работы алгоритма:
Update 2:
[Статья о разработке игры](https://habrahabr.ru/post/283060/) | https://habr.com/ru/post/282752/ | null | ru | null |
# Риски, связанные с наследованием
Эта статья расскажет о рисках, связанных с наследованием классов. Здесь будет показана альтернатива наследованию классов – композиция. После прочтения вы поймете, почему Kotlin по умолчанию делает все классы конечными. Статья объяснит, почему не следует делать класс Kotlin open (открытый), если на то нет веских причин.
Предположим, что у нас есть следующий интерфейс:
```
interface Insertable {
fun insert(item: T)
fun insertAll(vararg items: T)
val items: List
}
```
*Интерфейс Insertable (вставляемый)*
Также, BaseInsert является имплементацией интерфейса `Insertable`. `BaseInsert` `open` (открыт). Поэтому мы можем его расширять.
Пусть `CountingInsert` будет расширением `BaseInsert`. Каждый раз, когда код вставляет `Number`, он должен увеличивать переменную count на единицу. Итак, получаем:
```
class CountingInsert : BaseInsert() {
var count: Int = 0
private set
override fun insert(item: Number) {
super.insert(item)
count++
}
override fun insertAll(vararg items: Number) {
super.insertAll(*items)
count += items.size
}
}
```
*Алгоритм подсчета, реализованный через наследование*
Данная имплементация должна работать. Строка 8 увеличивает `count` на единицу; строка 13 - на количество аргументов переменной.
Код работает не так, как ожидалось. См. строку 7 ниже.
```
fun main(args: Array) {
CountingInsert().apply {
insert(1)
insert(2)
insertAll(3, 4)
println(count) // prints 6, the incorrect value; should be 4
println(items) // prints [1 2 3 4]
}
}
```
`CountingInsert()` *выдает неверный результат*
Ошибка в строке 10 ниже:
```
open class BaseInsert : Insertable {
private val numberList = mutableListOf()
override fun insert(item: Number) {
numberList.add(item)
}
override fun insertAll(vararg items: Number) {
items.forEach { number -> insert(number) }
}
override val items: List
get() = numberList
}
```
*Имплементация BaseInsert*
`BaseInsert.insertAll` является функцией удобства. Функция `insertAll` вызывает `insert` для каждого элемента в списке `vararg`. Класс `CountingInsert` повторно подсчитал вставку чисел 3 и 4. `CountingInsert.insertAll` дважды выполнил оператор `count++`; один раз - оператор `count += items.size`. Функция `CountingInsert.insertAll` увеличила `count` на четыре вместо двух.
Существуют ли альтернативы? Да. Мы можем изменить код или использовать композицию.
Изменение кода кажется очевидным решением. Предположим, нам разрешено изменить базовый класс. Можно изменить реализацию `BaseInsert.insertAll` на:
```
override fun insertAll(vararg items: Number) {
numberList += items.toList()
}
```
*Обновленная имплементация* `BaseInsert.insertAll`
Такая имплементация позволяет избежать вызова `BaseInsert.insert()`, источника наших проблем.
Предположим, что у нас нет доступа к классу `BaseInsert`. Тогда можно удалить переопределение `insertAll()`:
```
class CountingInsert : BaseInsert() {
var count: Int = 0
private set
override fun insert(item: Number) {
super.insert(item)
count++
}
}
```
*Класс* `CountingInsert` *без переопределения* `insertAll`
Решение проблемы путем изменения кода достаточно уязвимо. Класс `CountingInsert` зависит от тонкостей имплементации `BaseInsert`. Есть ли более эффективный способ? Да, давайте воспользуемся композицией.
Здесь показана имплементация с помощью композиции:
```
class CompositionInsert(private val insertable: Insertable = BaseInsert())
: Insertable by insertable {
var count: Int = 0
private set
override fun insert(item: Number) {
insertable.insert(item)
count++
}
override fun insertAll(vararg items: Number) {
insertable.insertAll(\*items)
count += items.size
}
}
```
*Имплементация с помощью композиции*
Предположим, что класс `BaseInsert` использует имплементацию с рис. 4. После тестирования класса `InsertDelegation` результат будет правильным. См. строку 15:
```
fun main(args: Array) {
CountingInsert().apply {
insert(1)
insert(2)
insertAll(3, 4)
println(count) // prints 6, the incorrect value; should be 4
println(items) // prints [1 2 3 4]
}
CompositionInsert().apply {
insert(1)
insert(2)
insertAll(3, 4)
println(count) // prints 4, which is correct
println(items) // prints [1 2 3 4]
}
}
```
*Результаты тестирования для CompositionInsert*
Сравнивая фрагменты кода 2 и 7, можно сказать, что имплементации `insert` и `insertAll` похожи. См ниже:
```
// By inheritance
override fun insert(item: Number) {
super.insert(item)
count++
}
override fun insertAll(vararg items: Number) {
super.insertAll(*items)
count += items.size
}
// By delegation
override fun insert(item: Number) {
insertable.insert(item)
count++
}
override fun insertAll(vararg items: Number) {
insertable.insertAll(*items)
count += items.size
}
```
*Сравнение наследования и композиции*
Сравниваемые методы одинаковы за одним исключением. В наследовании используется `super`, а в композиции – `insertable`. Сравните строки 3 и 12; а также 7 и 16 на рис. 8. Шаблон делегирования передает выполнение задачи по вставке на `insertable`. Класс `CompositionInsert` увеличивает переменную `count`. Наследование, напротив, нарушает инкапсуляцию класса `BaseInsert`.
Какова первопричина проблемы? Предположим, что `BaseInsert` не open (открыт). См. строку 1 во фрагменте кода 4. Если бы `BaseInsert` был final (конечный), то компилятор Kotlin отметил бы код на фрагменте 2 и 5 как ошибку. Только решение на фрагменте 7 оказалось бы работоспособным. Когда мы делаем класс `BaseInsert final`, инкапсуляция `BaseInsert` не нарушается.
Kotlin понимает риски, связанные с наследованием. Kotlin запрещает наследование, если только разработчик не пометит класс как `open`. Вывод: в целом, классы Kotlin должны быть `final`, если только нет веской причины сделать класс `open`.
---
Приглашаем на открытое занятие «Основы бизнес-логики и разработка библиотеки для шаблона CoR». На этом открытом уроке:
– поговорим про общие принципы построения бизнес-логики приложения,
– рассмотрим фреймворки для разработки бизнес-логики,
– узнаем про такие шаблоны проектирования, как фасад и цепочка обязанностей,
– разработаем библиотеку для шаблона "Цепочка обязанностей" с использованием DSL и coroutines.
Регистрация на урок открыта [на странице онлайн-курса](https://otus.pw/lPX1/) "Kotlin Backend Developer. Professional". | https://habr.com/ru/post/713608/ | null | ru | null |
# Python в Visual Studio Code — июльский релиз
Мы рады сообщить, что июльский выпуск расширения Python уже доступен для Visual Studio Code. Вы можете [загрузить](https://marketplace.visualstudio.com/items?itemName=ms-python.python) расширение Python из Marketplace или установить его прямо из галереи расширений в Visual Studio Code. Если у вас уже установлено расширение Python, вы также можете получить последнее обновление, перезапустив Visual Studio Code. Вы можете узнать больше о поддержке Python в Visual Studio Code в [документации](https://code.visualstudio.com/docs/python/python-tutorial).
В этом выпуске мы сделали 51 улучшение, в том числе:
* Добавлена поддержка нового языкового сервера: Pylance
* Gather Extension
* Экспорт записных книжек (notebooks) в HTML и PDF
* Обратное соединение для отладчика
Если вы заинтересованы, вы можете изучить полный список улучшений в нашем [списке](https://github.com/Microsoft/vscode-python/blob/master/CHANGELOG.md) изменений.
Поддержка нашего нового языкового сервера: Pylance
--------------------------------------------------
Пару недель назад мы объявили о выпуске Pylance, нашего нового языкового сервера, основанного на инструменте проверки статического типа [Pyright](https://github.com/microsoft/pyright) от Microsoft.
Pylance — это быстрый языковой сервер, который предоставляет множество функций, которые помогут вам написать лучший код, включая автоматический импорт, обнаружение мертвого кода, информацию о параметрах и типах возвращаемых данных, поддержку рабочей среды с несколькими корневыми системами и многое другое. Вы можете прочитать [пост](https://devblogs.microsoft.com/python/announcing-pylance-fast-feature-rich-language-support-for-python-in-visual-studio-code/) в блоге Pylance, чтобы узнать больше об этом.
Недавно в Pylance была добавлена функция контекстной подсветки, которая помогает быстро определить, где символы используются в определенном файле.
Вы можете установить расширение Pylance из [маркетплейса](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance). Если у вас установлено расширение Pyright, вы должны удалить его в пользу расширения Pylance, чтобы избежать конфликтов установки и дублирования ошибок и предупреждений, поскольку все функции Pyright включены в Pylance.
Если вы являетесь пользователем Microsoft Python Language Server, мы рекомендуем вам попробовать Pylance. Новый языковой сервер значительно улучшает Python IntelliSense в VSCode. Из-за этого долгосрочный план состоит в том, чтобы в конечном итоге отказаться от Microsoft Python Language Server в качестве поддерживаемой опции в расширении Python.
Gather Extension
----------------
Мы рады объявить, что этот релиз добавляет поддержку нашему новому экспериментальному расширению, Gather. Gather постоянно повторяется, и мы с нетерпением ждем отзывов от сообщества, чтобы улучшить точность Gather! Этот инструмент анализирует и определяет необходимые зависимости кода в блокноте и выполняет очистку кода, тем самым автоматизируя эту сложную и трудоемкую задачу.
Вы можете установить Gather сегодня в [маркетплейсе](https://marketplace.visualstudio.com/items?itemName=ms-python.gather). Мы будем рады услышать ваши отзывы! Если у вас есть какие-либо проблемы, не стесняйтесь регистрировать их в [репозитории](https://github.com/microsoft/vscode-python/issues) vscode-python GitHub.
Экспорт notebooks в HTML и PDF
------------------------------
Этот выпуск включает в себя поддержку экспорта записных книжек в HTML и PDF, облегчая совместное использование и представление записных книжек одним нажатием кнопки!
Обратите внимание, что экспорт в PDF требует установки TeX.
Обратное соединение для отладчика
---------------------------------
В этом выпуске теперь вы можете более легко запускать сеансы удаленного отладчика, используя обратные соединения.
При подключении ptvsd — нашего отладчика Python в VS Code — к процессу Python или к удаленной машине, вам необходимо настроить удаленный процесс Python так, чтобы он прослушивал запросы на присоединение, а затем запускал сеанс отладчика в VS Code для подключения к этому.
Однако подключение может быть непростым делом, если вы не укажете правильное время — возможно, процесс занял много времени для запуска на удаленной машине, или, возможно, истекло время ожидания подключения VS Code к нему.
В этом выпуске мы добавили поддержку для настройки отладчика для обратного соединения. Теперь вы можете настроить удаленный процесс Python для подключения по определенному адресу (номер порта или хост и кортеж порта) и запустить конфигурацию присоединения в VS Code, чтобы начать прослушивание по тому же адресу, чтобы он мог подключиться к процессу.
Например, вы можете запустить следующий скрипт:
```
import debugpy
debugpy.connect(('localhost',5678))
debugpy.breakpoint()
print("debugger stops here")
```
А затем добавьте конфигурацию launch.json в VS Code со следующим содержимым:
```
{
"name": "Python: Attach using listen",
"type": "python",
"request": "attach",
"listen": {
"host": "127.0.0.1",
"port": 5678
},
},
```
Теперь вы можете запустить отладчик в VS Code, чтобы он начал прослушивать запрос на соединение. Когда вы запускаете процесс Python, он останавливается на определенной точке останова.
Обязательно [загрузите](https://marketplace.visualstudio.com/items?itemName=ms-python.python) расширение Python для кода Visual Studio прямо сейчас, чтобы опробовать вышеуказанные улучшения. Если у вас возникнут какие-либо проблемы или у вас есть предложения, пожалуйста, [сообщите](https://github.com/microsoft/vscode-python/issues/new/choose) об этом на [странице](https://github.com/Microsoft/vscode-python) Python VS Code GitHub. | https://habr.com/ru/post/511762/ | null | ru | null |
# Нагрузочное тестирование на фреймворке Gatling
*Статья публикуется от имени Масленникова Сергея,* [sergeymasle](https://habr.com/users/sergeymasle/)
*UPD. Добавлен раздел "Реализация расширения для Gatling"*
Продолжаем цикл статей про нагрузочное тестирование на фреймворке gatling.io. В этой статье расскажем про основные приемы использования Gatling DSL, которые в большинстве случаев используются при разработке любых скриптов нагрузочного тестирования. Итак, прошу под кат.
Структура Gatling'a
-------------------
В предыдущей нашей [статье](https://habrahabr.ru/company/tinkoff/blog/323316/) мы писали про установку SBT и настройку окружения для фреймворка Gatling. После выполнения всех действий у вас должен появится проект(1), структура которого представлена на изображении ниже.
В файле plugins.sbt(2) должен быть подключен плагин gatling для sbt, если файл не был создан, то создайте его вручную. Обратите внимание, что необходимо указывать свежую версию плагина, на момент написания статьи она является 2.2.2. Код файла ниже.
```
//plugins.sbt
addSbtPlugin("io.gatling" % "gatling-sbt" % "2.2.2")
```
Далее в каталоге src/test необходимо создать каталог resources(3). В нем располагаются файлы настроек, а также тестовые данные. Файл gatling.conf содержит основные настройки, logback.xml отвечает за уровень логирования и интерфейсы вывода логов. Эти файлы можно взять бандла <https://gatling.io/download/>.
Директория scala содержит пакеты с тестами. Имена пакетов можно называть как угодно, но как правило компании используют свое инвертированное имя ru.tcsbank.load.
Файл BasicSimulation основной файл тестов и является точкой входа запуска скриптов.
В директории target\gatling(6) генерируются отчеты по логу запуска (тот что вы видите в консоли). Следует заглядывать туда чаще — она очень быстро растет.
Главный файл проекта — build.sbt(7). Содержит зависимости на все библиотеки, что вы подключаете. Именно в нем указывается ссылка на фреймворк Gatling, его код ниже.
```
//build.sbt
/*
Подключаем плагин Gatling. Сам плагин должен быть указан в plugins.sbt
*/
enablePlugins(GatlingPlugin)
/*
Имя вашего проекта
*/
name := "GatlingForArticle"
/*
Версия проекта
*/
version := "0.1"
/*
Указываем версию Scala
*/
scalaVersion := "2.12.4"
/*
Библиотеки фреймворка
*/
libraryDependencies += "io.gatling.highcharts" % "gatling-charts-highcharts" % "2.3.0" % "test,it"
libraryDependencies += "io.gatling" % "gatling-test-framework" % "2.3.0" % "test,it"
/*
Параметры, с которыми будет запущена JVM
*/
javaOptions in Gatling := overrideDefaultJavaOptions("-Xss10m", "-Xms2G", "-Xmx8G")
```
Последний важный файл — это gatling.log. именно в нем можно увидеть отправляемые запросы и ответы. Чтобы видеть все запросы не забудьте раскомментировать строчку "ALL HTTP" в файле logback.xml.
Основная идея Gatling
---------------------
На первый взгляд скрипты и DSL Gatling могут показаться сложными, но если понять идею построения скриптов, то все станет довольно просто.
Gatling представляет виртуального пользователя в виде сценария `scenario()`. Для сценария указывается количество пользователей через метод `inject`, модель нагрузки, а также настройки протокола http и различные условия эмуляции. Все это указывается в конструкции `setUp()`. Для примера, при проведении нагрузки интернет магазина для покупателя и администратора будут несколько сценариев:
1. Покупатель совершает покупку
2. Покупатель только складывает в корзину
3. Покупатель только смотрит товары
Такое разделение позволяет легко корректировать нагрузку увеличивая количество виртуальных пользователей для конкретных сценариев.
Сценарий представляет собой цепочку выполнений именно в эту цепочку внутри функции `exec()` помещаются запросы.
```
-сценарий
+-выполнение(запрос1)
+-выполнение(запрос2)
+-выполнение(запрос3)
+-Если(<условие>){
выполнение(запрос4)
} иначе {
выполнение(запрос5)
}
```
Цепочка выполнений начинается с выражения `scenario()` и далее собирается путем вызова функции `exec()`.
```
#1
val scn2 = scenario("ChainScenario")
.exec(http().get())
.exec(http().get())
.exec(http().get())
.doIfOrElse(true) {
exec(http().get())
} {
exec(http().get())
}
```
Если проводить сравнения эмуляции виртуальных пользователей JMeter и Gatling, то можно выделить некоторую особенность. В JMeter пользователи помещаются в катушку ThreadGroup, где задается их количество и именно она(катушка) многократно воспроизводит скрипт виртуальных пользователей по циклу. Т.е. при "поднятии" двух виртуальных пользователей они будут выполнять один и тот же сценарий пока не закончится время теста.
Gatling управляет виртуальными пользователями несколько иначе. При поднятии двух виртуальных пользователей они выполнят свой сценарий и на этом закончат свою работу. Для того, чтобы пользователи выполняли сценарий в цикле необходимо помещать цепочку в блок цикла. Рассмотрим простой скрипт теста, который представлен на сайте <https://gatling.io/docs/current/quickstart/#gatling-scenario-explained>, его можно взять за основу.
```
//BasicSimulation.scala
package ru.tcsbank.gatling
/*
Необходимые библиотеки для работы:
io.gatling.core.Predef._ - функции ядра
import io.gatling.http.Predef._ - функции HTTP
import scala.concurrent.duration._ - функции для временных интервалов, чтобы можно было писать `4 minutes`, `15 seconds`
*/
import io.gatling.core.Predef._
import io.gatling.http.Predef._
import scala.concurrent.duration._
/*
Основной класс теста.
Именно этот класс, расширяемый от Simulation, ищет фреймворк во время запуска.
*/
class BasicSimulation extends Simulation {
/*
Настройки для HTTP
*/
val httpConf = http
.baseURL("http://computer-database.gatling.io")
.acceptHeader("text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8")
.doNotTrackHeader("1")
.acceptLanguageHeader("en-US,en;q=0.5")
.acceptEncodingHeader("gzip, deflate")
.userAgentHeader("Mozilla/5.0 (Windows NT 5.1; rv:31.0) Gecko/20100101 Firefox/31.0")
/*
Сценарий скриптов. Здесь в виде "цепочки" пишем запросы, таймеры, отчеты (pacing) и все остальное связанное со сценарием скриптов.
*/
val scn = scenario("BasicSimulation")
.exec(
http("request_1")
.get("/")
)
.pause(5)
/*
Сценарий нагрузки. Здесь указываем характер генерируемой нагрузки, модель поднятия пользователей, их количество и длительность нагрузки.
*/
setUp(
scn.inject(atOnceUsers(1))
).protocols(httpConf)
}
```
Сценарий скриптов на первый взгляд может выглядеть сложно, но если разобраться, то DSL Gatling довольно простой и для написания нагрузочных тестов углубленное знание Scala не требуется.
Сценарий скриптов начинается с присвоения константе функции `scenario()`. Имя сценария должно быть уникальным! Далее вызывается функция `exec()`, которая принимает на вход другие функции, реализующие тестовые сценарий: http и websocket. Именно в ней выполняются все действия для эмуляции запросов.
Когда сценарий скриптов написан, в функции `setUp()` мы указываем какое количество пользователей будет его выполнять и как эти пользователи будут выходить на нагрузку. Далее разберем подробно, как с этим всем работать.
HTTP
----
Фреймворк по умолчанию поддерживает следующие методы GET, POST, PUT, PATCH, DELETE, OPTIONS. Рассмотрим в качестве примера написание запросов GET и POST. Для начала присвоим константе `scn` функцию сценария и напишем в `exec()` простой GET-запрос:
```
val scn = scenario("GetScenario")
.exec(
http("GETRequest")
/*
.get("/foo.php") или можно указать полный путь
*/
.get("http://bar.com/foo.php")
)
```
Если же необходимо установить headers, то добавляем следующее:
```
val scn = scenario("GetScenario")
.exec(
http("GETRequest")
.get("http://bar.com/foo.php")
/*
.headers("foo","bar") или через Map
*/
.headers(
Map(
"foo1" -> "bar1",
"foo2" -> "bar2"
)
)
)
```
Передаем параметры в запрос:
```
val scn = scenario("GetScenario")
.exec(
http("GETRequest")
.get("http://bar.com/foo.php")
.headers(
Map(
"foo1" -> "bar1",
"foo2" -> "bar2"
)
)
/*
.queryParam("param","value") или через Map
*/
.queryParamMap(
Map(
"param1" -> "value1",
"param2" -> "value2"
)
)
```
Переметры также можно передавать непосредственно через функцию `.get("http://bar.com/foo.php?param=value")`. Если есть загрузка статических ресурсов, то используем `resources()` для параллельной загрузки.
```
val scn = scenario("GetScenario")
.exec(
http("GETRequest")
.get("http://bar.com/foo.php")
.headers(
Map(
"foo1" -> "bar1",
"foo2" -> "bar2"
)
)
.queryParamMap(
Map(
"param1" -> "value1",
"param2" -> "value2"
)
)
.resources(
http("css").get("/main.css"),
http("js").get("http://bar.com/main.js")
)
```
Для метода POST при передаче параметров используются функция `formParam()`.
```
val scn = scenario("PostScenario")
.exec(
http("GETRequest")
.post("http://bar.com/foo.php")
.headers(
Map(
"foo1" -> "bar1",
"foo2" -> "bar2"
)
)
/*
.formParam("param","value") или через Map
*/
.formParamMap(
"param1" -> "value",
"param2" -> "value2"
)
```
Чтобы передать данные напрямую через тело запроса необходимо использовать `body()`.
```
val scn = scenario("PostScenario")
.exec(
http("GETRequest")
.post("http://bar.com/foo.php")
.headers(
Map(
"foo1" -> "bar1",
"foo2" -> "bar2"
)
)
.body(
/*
В тройных кавычках можно не экранировать одинарные. Функция stripMargin
удаляет символы вертикальный черты, которые служат для сохранения отступов
*/
StringBody(
"""
|{
| "login": "password"
|}""".stripMargin
)
)
```
Проверки
--------
При эмуляции запросов требуется проверять код ответа или наличие какого-либо текста в теле ответа. Также нередко требуется извлечь данные из ответа. Все это может выполнить с помощью функции `check()`. Проверки необходимо производить после функции http-метода.
```
val scn = scenario("CheckScenario")
.exec(
http("ForChecks")
.get("/check.php")
/*
Проверяем, что код ответа равен 200
*/
.check(status.is(200))
/*
Проверяем код ответа, который может принимать 200 или 500
*/
.check(status.in(200, 500))
/*
Проверяем тело на наличие строки foo_bar
*/
.check(substring("foo_bar"))
/*
Проверяем тело на наличие строки удовлетворяющей регулярному выражению
*/
.check(regex(""" \d{4} – \d{4}"""))
/*
Находим строку удовлетворяющую регулярному выражению и сохраняем в переменную
*/
.check(regex("""key=(\d{4}-\w{4})""").saveAs("AuthKey"))
/*
На случай, когда данные могут быть, а могут не быть.
В этой конструкции checkIf()() принимает анонимную функцию с параметрами Response и Session.
Затем в Response тело ответа проверяем на наличие "id=" и если есть, то сохраняет в параметр
"id_some_value"
*/
.check(
checkIf(
(r: Response, s: Session) => r.body.string.contains("id=")
)(
regex("""id=(\d+)""").saveAs("id_some_value")
)
)
)
```
Сессия
------
В Session хранятся все данные виртуального пользователя и переменные. Если вы хотите что-то предать в рамках сценария, то это нужно делать через сессию.
```
val scn = scenario("SessionScenario")
/*
Задаем через лямбда-выражение значение для переменной password_param
Только через лямбду. Нет, по-другому нельзя.
*/
.exec(
session => session.set("password_param","anyPassword")
)
.exec(
http("param")
.get("/anything.php")
/*
Через конструкцию "${}" получаем значение переменной
*/
.queryParam("login","${password_param}")
)
```
Динамические значения нельзя напрямую передать в DSL-функции, так как Scala использует CallByValue они будут получены при компиляции и далее всегда использоваться без получения новых.
```
exec(
http("timestamp")
.get("/")
/*
Скомпилируется, но при каждом вызове будет возвращать первое
полученное значение
*/
.queryParam("timestamp", System.currentTimeMillis() )
/*
Получаем значение из Session, которое сохранили ранее
*/
.queryParam("timestamp", session => { session("var").as[String] } )
/*
Just magic!
Получаем через анонимную функцию. X - просто константа
*/
.queryParam("timestamp", x => { System.currentTimeMillis() } )
)
```
Логические конструкции
----------------------
Как и в других инструментах тестирования нередко применяются логические конструкции, чтобы выполнять запросы в зависимости от каких-либо условий.
```
val scn = scenario("doIfSimulation")
/*
Устанавливаем для переменной foo значение bar
*/
.exec(
session => session.set("foo","bar")
)
/*
Выполняется проверка, что переменная foo содержит значение bar.
Если значение содержится, то выполняется запрос.
*/
.doIf(session => session("cond").as[String].startsWith("bar")){ //
exec(
http("IFrequest")
.get("/")
)
}
```
Тестовые данные
---------------
Для проведения качественной нагрузки и тестирования системы, а не ее кэша необходимо отправлять данные в запросах, которые меняются динамически во время теста. Для хранения и получения таких данных самым простым способом является чтение из файла. Файл должен содержать данные разделенные символом. Gatling имеет функции для чтения таких данных.
csv("foo.csv") // данные, разделенные запятой
tsv("foo.tsv") // данные, разделенные табуляцией
ssv("foo.ssv") // данные, разделенные точкой с запятой
separatedValues("foo.txt", '#') // данные разделенные другим символом
На примере небольшого csv файла покажем работу с тестовыми данными:
```
//csv файл
model,
Macbook,
MacBook Pro,
ASUS Eee PC,
Acer,
Asus,
Sony Vaio,
Chromebook
```
Gatling при чтении файла использует первую строку как имена параметров, и в последствии при чтении значений сохраняет их под этими именами. Таким образом, в параметр `${model}` будут подставляться значения с именами ноутбуков, описанных в csv файле.
Чтобы читать csv-файл, необходимо вызвать функцию `csv()`.
```
/*
Функции чтения файлов имеют также стратегии выборки данных
.queue // последовательное чтение данных
.random // чтение случайным образом
.shuffle // сначала перемешивает данные, затем читает последовательно
.circular // при достижении конца файла чтение производится с начала
*/
val feeder = csv("data.csv").circular
val scn = scenario("doIfSimulation").feed(feeder) //#1
.repeat(5)(
exec(
http("request")
.get("/")
)
// .feed(feeder) #2
.exec(http("search").get("/computers?f=${model}"))
)
```
Итак, мы создали переменную feeder и указали имя файла, который лежит в `src\test\resources\data.csv`. В сценарии мы вызываем функцию `feed()` и указываем константу `feeder`. Чтение нового значения происходит каждый раз, когда вызывается функция `feed()`.
При варианте #1 функция `feed()` вызывается до `repeat()`, таким образом, в переменной `${model}` будет использоваться первое считанное значение на 5 итераций.
При варианте #2 значение будет считываться перед каждым запросом.
Модели нагрузки
---------------
Gatling поддерживает различные модели нагрузки. Эти модели отвечают за "подъем" пользователей и генерируемую интенсивность.
**nothingFor(duration)** — указывается длительность паузы duration перед стартом нагрузки
**atOnceUsers(nbUsers)** — виртуальные пользователи в количестве `nbUsers` будут “подниматься” сразу (по готовности).
**rampUsers(nbUsers) over(duration)** — в течение времени `duration` будут "подниматься" виртуальные пользователи в количестве nbUsers через равные временные интервалы.
**constantUsersPerSec(rate) during(duration)** — указывается частота “поднятия” виртуальных пользователей `rate` (вирт. польз. в секунду) и временной интервал `duration`. В течении `duration` количество виртуальных пользователей будет увеличиваться на rate каждую секунду.
**constantUsersPerSec(rate) during(duration) randomized** — аналогично верхней конструкции только временные интервалы между "поднятием" виртуальных пользователей будут случайными.
**rampUsersPerSec(rate1) to (rate2) during(duration)** — в течение времени `duration` виртуальные пользователи будут увеличиваться с частоты `rate1` до частоты `rate2`.
**rampUsersPerSec(rate1) to(rate2) during(duration) randomized** — аналогично верхней конструкции только временные интервалы между "поднятиями" виртуальных пользователей будут случайными.
**splitUsers(nbUsers) into(injectionStep) separatedBy(duration)** — через каждый временной интервал `duration` будут добавляться виртуальные пользователи по модели `injectionStep`, пока их количество не достигнет `nbUsers`. В `injectionStep` можно указать модели описанные выше.
**splitUsers(nbUsers) into(injectionStep1) separatedBy(injectionStep2)** — аналогично верхней конструкции только разделителем модель `injectionStep2`.
**heavisideUsers(nbUsers) over(duration)** — виртуальные пользователи в количестве nbUsers будут подниматься ступенями за время `duration`.
Запуск нагрузки
---------------
### Вариант 1
Для запуска нагрузки самый простой способ — это использовать bundle. Необходимо поместить файл скрипта в `gatling-charts-highcharts-bundle-2.3.0\user-files\simulations\` и далее запустить `gatling-charts-highcharts-bundle-2.3.0\bin\gatling.bat`. В консоли будет предложен выбор скрипта для запуска.
Наш скрипт под вариантом 6. После выбора произойдет генерация нагрузки с выводом информации в консоль.
### Вариант 2
Этот вариант предполагает запуск нагрузки непосредственно из IDE IntelliJ IDEA Community.
После того, как произвели все действия по настройке библиотек, нажимаем ALT+F12 и открываем терминал. В терминале набираем команду `sbt`.
После загрузки всех компонентов производим запуск скриптов командой `gatling:testOnly`.
В консоли будет отображаться текущее состояние нагрузки.
Чтобы производить запуск из панели запуска IDEA, необходимо добавить нашу команду на запуск в SBT Task.
Реализация расширения для Gatling
---------------------------------
В документации по Gatling написано, что из коробки существует поддержка протоколов только для HTTP/1.1 и WebSocket. Также имеются официальные и неофициальные расширения для Gatling, которые доступны по ссылке(<https://gatling.io/docs/2.3/extensions/>).
Нередко случаются задачи, когда необходимо протестировать под нагрузкой систему у которой протокол прикладного уровня отличный от HTTP или WebSocks. В таком случае для Gatling можно написать свое расширение и реализовать необходимый функционал.
И так, нам необходимо реализовать вот такую возможность:
```
val scn = scenario("BasicSimulation")
.exec(
new ExampleActionBuilder("MyAction")
)
```
Так как функция `exec()` может принимать тип `ActionBuilder` необходимо написать свой класс и расширить его типом `ActionBuilder`.
```
class ExampleActionBuilder(myNameAction: String) extends ActionBuilder {
override def build(ctx: ScenarioContext, next: Action): Action = {
new ExampleChainableAction(myNameAction, next, ctx)
}
}
```
В переопределенной функции `build` нужно создать экземпляр класса, который будет реализовывать необходимый код. Данный класс необходимо расширить от `ChainableAction`.
```
class ExampleChainableAction(myNameAction: String, myNextAction: Action, ctx: ScenarioContext) extends ChainableAction {
override def next: Action = myNextAction
override def name: String = myNameAction
override def execute(mySession: Session): Unit = {
/*
Здесь реализуем наш код
*/
}
}
```
Ниже рабочий пример данного подхода. Важно отметить, что такой способ не является лучшим решением, но оно максимально "простое" для реализации.
**Код расширения**
```
package ru.tcsbank.load
/*
Необходимые библиотеки для работы:
io.gatling.core.Predef._ - функции ядра
import io.gatling.http.Predef._ - функции HTTP
import scala.concurrent.duration._ - функции для временных интервалов, чтобы можно было писать `4 minutes`, `15 seconds`
*/
import io.gatling.commons.stats.{KO, OK}
import io.gatling.core.Predef._
import io.gatling.core.action.builder.ActionBuilder
import io.gatling.core.action.{Action, ChainableAction}
import io.gatling.core.stats.message.ResponseTimings
import io.gatling.core.structure.ScenarioContext
import io.gatling.http.Predef._
import scala.concurrent.duration._
/*
Основной класс теста.
Именно этот класс, расширяемый от Simulation, ищет фреймворк во время запуска.
*/
class ExampleProtocolScript extends Simulation {
/*
Настройки для HTTP
*/
val httpConf = http
.baseURL("http://computer-database.gatling.io")
.acceptHeader("text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8")
.doNotTrackHeader("1")
.acceptLanguageHeader("en-US,en;q=0.5")
.acceptEncodingHeader("gzip, deflate")
.userAgentHeader("Mozilla/5.0 (Windows NT 5.1; rv:31.0) Gecko/20100101 Firefox/31.0")
/*
Сценарий скриптов. Здесь в виде "цепочки" пишем запросы, таймеры, отчеты(pacing) и все остальное, связанное со сценарием скриптов.
*/
val scn = scenario("BasicSimulation")
.exec(
/*
Выполняем свою релизацию Action
*/
new ExampleActionBuilder("MyAction")
)
/*
Сценарий нагрузки. Здесь указываем характер генерируемой нагрузки, модель поднятия пользователей, их количество и длительность нагрузки.
*/
setUp(
scn.inject(atOnceUsers(1)).protocols(httpConf)
)
}
/*
Точка входа для exec().
Парметров ExampleActionBuilder() может быть любое количество,
перебрасывать их можно напряму в ExampleChainableAction()
*/
class ExampleActionBuilder(myNameAction: String) extends ActionBuilder {
override def build(ctx: ScenarioContext, next: Action): Action = {
new ExampleChainableAction(myNameAction, next, ctx)
}
}
/*
Здесь выполняется наш Action.
Парметров ExampleChainableAction() также может быть любое количетво.
*/
class ExampleChainableAction(myNameAction: String, myNextAction: Action, ctx: ScenarioContext) extends ChainableAction {
/*
Отдаем управление следующему актору.
В нашей реализации просто прокидываем параметр.
*/
override def next: Action = myNextAction
/*
Наменование Action.
То, что будет отбражаться в консоли и в отчетах.
Можно сравнить с http(<Наименование>).get(...)
*/
override def name: String = myNameAction
/*
В этом методе происходит вся работа нашего Action.
*/
override def execute(mySession: Session): Unit = {
/*
Время начала выполнения нашего Action
*/
val startTime = System.currentTimeMillis()
try {
/*
НАЧАЛО кода Action
*/
System.out.println(myNameAction+" Hello world!")
/*
КОНЕЦ кода Action
*/
/*
Время завершения выполнения нашего Action
*/
val stopTime = System.currentTimeMillis()
/*
Заполняем метрические данные при успешном выполнении Action
*/
ctx.coreComponents.statsEngine.logResponse(
session = mySession,
requestName = name,
timings = new ResponseTimings(startTime, stopTime),
status = OK,
None,
None,
Nil
)
/*
При успешном выполнении передаем актору сообщением нашу сессию.
Изменять этот код не требуется.
*/
myNextAction ! mySession
} catch {
/*
Если при выполнении кода произошла ошибка, обрабатываем ее здесь.
*/
case e: Exception => {
/*
Время завершения выполнения нашего Action
*/
val stopTime = System.currentTimeMillis()
/*
Заполняем метрические данные при ошибке в выполнении Action
*/
ctx.coreComponents.statsEngine.logResponse(
session = mySession,
requestName = name,
timings = new ResponseTimings(startTime, stopTime),
status = KO,
None,
Some(e.getMessage), //отправляем сообщение об ошибке, появится в логе /target/.../simulation.log
Nil
)
/*
При получении ошибки также передаем актору сообщением нашу сессию.
Изменять этот код не требуется.
*/
myNextAction ! mySession
}
}
}
}
```
В этой статье были описаны основные моменты, которые помогут самостоятельно разработать скрипты для проведения нагрузки на фреймворке Gatling. Если возникли вопросы, то с удовольствием ответим на них в комментариях. | https://habr.com/ru/post/344818/ | null | ru | null |
# CIFS over SSH штатными средствами Windows 10
*Я ленивый и потому люблю когда все организовано удобно, без лишних телодвижений. Иногда перебарываю лень, для того чтобы сделать удобно.*
Однажды потребовалось мне организовать доступ к серверу по протоколу SMB и в поиске решения я наткнулся на следующую статью: [Mounting your Nikhef home directory using SSH for Windows 8](https://www.nikhef.nl/~janjust/CifsOverSSH/Win8Loopback.html). Это было простое и удобное решение, которое использовало Putty. Чуть позже мне пришлось настраивать это решение на другом компьютере и я понял, что Putty тут лишний с тех пор как в Windows 10 появился встроенный ssh-клиент на основе OpenSSH.
Под катом — идентичная схема, только с использованием OpenSSH под Windows 10.
У меня схема организована следующим образом:
1. На сервере запущена Samba, от имени пользователя www-data расшарена корневая папка с сайтами. Доступ к серверу только через ssh с авторизацией по ключу. Сервер за NATом, порт проброшен только для ssh.
2. В процессе входа в аккаунт на домашней машине на Windows 10 через встроенный в систему OpenSSH устанавливается соединение с сервером с авторизацией по ключу.
3. Туннелируется порт 445 удаленной машины на локальный порт 44445 сетевого loopback-адаптера доступного по адресу 10.255.255.1
4. На loopback-адаптере 10.255.255.1 порт 44445 проксируется на локальный 445. Таким образом при подключении к \\10.255.255.1\ открывается удаленная шара с файлами (которая, при необходимости монтируется как сетевой диск).
Всё это автоматом – лень торжествует. Безопасно, быстро и нативно выглядит. Любым редактором могу открывать и править файлы на удаленном сервере как у себя на локальном — без проблем с загрузкой правленых файлов и установкой им необходимых разрешений. При этом нет проблем с безопасностью Samba.
Итак – сперва по шагам:
### На стороне WINDOWS
Должен быть установлены OpenSSH. В Windows 10 и Windows Server 2019 появился встроенный SSH клиент на основе OpenSSH. Им мы и воспользуемся. Сначала убедимся что он установлен – наберем в командной строке
```
ssh
```
Если видим исполнение команды — все "Ок", клиент присутствует в системе.
#### Шаг 1. Настройка сетевого адаптера
Устанавливаем loopback-адаптер в системе. Мы будем обращаться по адресу к локальному адаптеру.
```
hdwwiz.exe
```
Запустится «Мастер установки оборудования» (Здесь я пользуюсь русской Windows 10 Pro).
«Далее» -> «Установка оборудования, выбранного из списка вручную» -> «Сетевые адаптеры» -> «Microsoft –> Адаптер замыкания на себя Microsoft KM-Test» -> «Далее»
Уверен, что эти шаги можно сделать из командной строки, но не нашел способ установки драйвера без devcon.exe, потому и не стал заморачиваться с автоматизацией этого шага.
Далее уже в CMD (от имени Администратора).
```
netsh interface show interface
```
Видим появился второй адаптер. У меня он называется Ethernet 2.
Теперь настроим адрес для этого адаптера
Или из командной строки:
```
netsh interface ip set address name="Ethernet 2" source=static address=10.255.255.1 mask=255.255.255.0
```
В результате у нас появился адаптер локально доступный по адресу 10.255.255.1
Теперь проблема в том, что нам необходимо получить доступ к общей папке через TCP-порт 445, но при загрузке Windows этот порт захватывается системным драйвером lanmanserver для всех интерфейсов. Отложив запуск драйвера lanmanserver и установив правило portproxy, мы можем обойти это.
Далее в командной строке от имени администратора меняем режим запуска сетевых служб (пробел после «start=» обязателен!!!):
```
sc config lanmanserver start= demand
sc config iphlpsvc start= auto
```
и настраиваем для адаптера с адресом 10.255.255.1 проксирование порта 44445 на локальный порт 445
```
netsh interface portproxy add v4tov4 listenaddress=10.255.255.1 listenport=445 connectaddress=10.255.255.1 connectport=44445
```
Теперь необходимо перезагрузиться, чтобы схема перехвата порта у службы lanmanserver сработала.
Проверяем что прослушивание порта осуществляется нашим loopback-адаптером, просмотрев открытые в системе порты
```
netstat -an | find ":445 "
```
Если мы видим
```
TCP 10.255.255.1:445 0.0.0.0:0 LISTENING
```
значит все в порядке и порт прослушивается на нужном адресе. Если же мы видим "0.0.0.0:445" — значит в нашей схеме что-то не сработало правильно. Проверить правила переадресации портов можно командой
```
netsh interface portproxy show v4tov4
```
#### Шаг 2. Ключ и рабочий скрипт
Создаем папку для вспомогательных файлов. Встроим, так сказать в систему наш способ.
```
mkdir %APPDATA%\CIFSoverSSH
cd %APPDATA%\CIFSoverSSH
```
Генерируем ключ для ssh-авторизации (назовем его, например: cifsoversshkey)
```
ssh-keygen -t rsa -N "" -f cifsoversshkey
```
В результате будет сгенерирована пара открытого и закрытого ключа. Для того, чтобы OpenSSH не выдавал сообщение UNPROTECTED PRIVATE KEY FILE! нужно изменить права на файл ключа. Задачу мы будем запускать для одного пользователя, от имени которого мы собираемся работать в Windows. Можно через GUI, но мне показалось что картинок уже достаточно. В Windows это сделаем следующей командой:
```
icacls cifsoversshkey /RESET
icacls cifsoversshkey /grant Имя_Пользователя:F /inheritance:r
```
В результате текущий пользователь будет назначен владельцем, отключено наследование и удалены унаследованные права. Проверить мы это сможем командой
```
icacls cifsoversshkey
```
*Должны быть права только для текущего пользователя, иначе файл ключа не будет принят программой OpenSSH и соединение не будет подниматься!*
Создадим в текущей папке пакетный файл cifsoverssh.cmd следующего содержания:
```
call cmd /c start "" /B C:\Windows\System32\OpenSSH\ssh.exe user@111.111.111.111 -p remoteport -i %APPDATA%\CIFSoverSSH\cifsoversshkey -L 10.255.255.1:44445:localhost:445 -N -o "StrictHostKeyChecking=no"
```
Где:
***user***@**111.111.111.111** – ***пользователь на стороне linux сервера*** @ **адрес удаленного сервера**
#### Шаг 3. Ярлык или задача в планировщике
Создаем ярлык для следующей команды: **powershell -nologo -noninteractive -windowStyle hidden -command "%APPDATA%\CIFSoverSSH\cifsoversshkey.cmd"**
Это позволит запускать наш пакетный файл через powershell без открытия окна. Если запускать его через CMD будет открываться черное окно терминала и будет висеть все время, пока соединение будет установлено, а это неудобно и некрасиво.
Для автоматизации запуска при входе в систему можно создать задачу в планировщике:
```
schtasks /CREATE /RU %username% /TN "CIFS over SSH" /TR "powershell.exe -nologo -noninteractive -windowStyle hidden -command %APPDATA%\CIFSoverSSH\cifsoversshkey.cmd" /SC ONLOGON /DELAY 0000:10 /IT /RL highest
```
На стороне клиентского компьютера Windows все приготовления были закончены.
### Настройка Linux сервера
*Предполагается, что ssh-сервер был предварительно настроен и включена авторизация по ключу.*
Подключаемся по ssh из командной строки на windows-машине
```
C:\Windows\System32\OpenSSH\ssh.exe user@111.111.111.111 -p remoteport
```
В домашней папке пользователя, от имени которого мы будем авторизовываться при создании туннеля ищем файл ~/.ssh/authorized\_keys (если файл отсутствует – создадим его).
```
mkdir ~/.ssh && touch ~/.ssh/authorized_keys
```
Теперь необходимо в этот файл вставить содержимое нашего файла публичного ключа, созданного на нашей windows-машине (файл %APPDATA%\CIFSoverSSH\cifsoversshkey.pub). Откроем его в любом редакторе и вставим цепочку ключа с новой строки. Если есть другие ключи, просто вставим его с новой строки.
Устанавливаем Samba (на примере Debian)
```
apt update && apt install samba
```
Переименовываем старый файл настроек и создаем новый файл
```
mv /etc/samba/smb.conf /etc/samba/smb.conf.old
touch /etc/samba/smb.conf
```
Открываем пустой файл настроек и приводим его к следующему виду:
```
[global]
realm = webserver
server string = Web server
workgroup = WORKGROUP
# Setup charsets
dos charset = cp1251
unix charset = utf8
# Disable printers
load printers = No
show add printer wizard = no
printcap name = /dev/null
disable spoolss = yes
# Setup logging
log file = /var/log/smbd.log
max log size = 50
max xmit = 65536
debug level = 1
# Setup daemon settings
domain master = No
preferred master = Yes
socket options = IPTOS_LOWDELAY TCP_NODELAY SO_SNDBUF=65536 SO_RCVBUF=65536 SO_KEEPALIVE
os level = 65
use sendfile = Yes
dns proxy = No
dont descend = /proc,/dev,/etc
deadtime = 15
# Enable symlinks
unix extensions = No
wide links = yes
follow symlinks = yes
# Securtity settings
security = user
map to guest = Bad Password
guest account = nobody
create mask = 0664
directory mask = 0775
hide dot files = yes
client min protocol = SMB2
client max protocol = SMB3
[ShareName]
comment = Sites folder
path = /home/web
force user = www-data
force group = www-data
read only = No
guest ok = Yes
writable = yes
create mask = 0664
directory mask = 2775
```
В последней секции мы настраиваем непосредственно шару. В названии секции указываем имя шары ShareName. Path = путь к файлам, которые мы хотим расшарить. В параметрах force user и force group указываем linux-пользователя, от имени которого будут сохраняться файлы при изменении и создании в шаре. Так как у меня там лежат файлы для веб-сервера – у меня пользователь www-data
Перезапускаем Samba
```
systemctl restart smbd
```
Отключаемся и выходим в командную строку Windows
```
exit
```
Всё готово. Теперь остается только запустить наш ярлык или выйти из профиля пользователя windows и снова войти (если вы создали задачу в планировщике).
После этого ваша удаленная шара будет доступна по адресу \\10.255.255.1\**ShareName** — Можно даже монтировать её как сетевой диск. | https://habr.com/ru/post/528414/ | null | ru | null |
# AppCode 2020.2: поддержка Swift Package Manager, улучшенное быстродействие, Change Signature для Swift и многое другое
КПДВ — это **Change Signature**, уже пятый рефакторинг для Swift. Обо всем остальном в новом AppCode 2020.2 — под катом.
Поддержка Swift Package Manager
-------------------------------
Мы сделали начальную поддержку SPM-зависимостей в проектах для Xcode, а именно:
* Отображение зависимостей в окне проекта:
* Автодополнение, подсветку и навигацию для них, плюс некоторые специфичные для SPM-зависимостей возможности, такие как автодополнение таргетов в Package.swift:
Быстродействие
--------------
Мы постоянно работаем над улучшением быстродействия IDE — к примеру, в [прошлом релизе](https://habr.com/ru/company/JetBrains/blog/498524/) получилось ускорить повторное открытие проектов. В версии 2020.2 мы закончили большой кусок работы, переработав механизм индексации. В результате IDE должна стать в целом отзывчивее, а подвисания при открытии проекта или его перезагрузке (например, во время переключений бранчей) должны исчезнуть.
Change Signature
----------------
Изменение сигнатуры метода — частая операция. Обычно ее приходится делать с помощью нескольких последовательных рефакторингов переименования, после чего часть работы в любом случае придется делать руками (поменять область видимость, вручную переставить параметры местами и так далее). Теперь AppCode может выполнить все эти действия за один раз — достаточно вызвать рефакторинг **Change Signature** (`⌘F6`) на любом использовании метода. Если этот метод был перегружен, можно выбрать, необходимо ли выполнить рефакторинг на базовом методе и перегруженных или только на самом перегруженном методе:
В открывшемся диалоге можно переименовать метод, изменить внутренние и внешние имена параметров, а также добавить новые или удалить существующие параметры. При добавлении параметра можно выставить значение по умолчанию, а затем с помощью чекбокса **Optional** либо оставить значение в сигнатуре метода, либо вставить его во все вызовы метода:
Самое простое применение — просто поменять местами пару параметров (`⌥↑`/`⌥↓`):
Автодополнение
--------------
Одно из самых интересных изменений — это использование SourceKit в автодополнении. В прошлом релизе мы начали использовать его во время индексации, с этого релиза начинаем использовать и после нее, добавляя результаты SourceKit к результатам AppCode. В целом, это должно сделать автодополнение более корректным. Кроме этого, есть пачка небольших, но полезных улучшений:
* Автодополнение для `get`, `set`, `didSet`, и `willSet` теперь автоматически ставит курсор внутри тела выражения:
* В режиме Smart теперь показываются конструкторы:
* Заработало такое же, как в Objective-C, автодополнение имен шрифтов:
* Trailing closures стали отображаться в списке автодополнения при наборе `{`:
Инспекции
---------
На смену старому индикатору инспекций пришел новый доработанный виджет, который отображает количество ошибок и предупреждений в текущем файле и позволяет между ними переключаться. По клику на него открывается окно **Problems**, отображающее все ошибки и предупреждения в текущем файле списком:
Также в нем можно изменить текущий уровень подсветки файла с помощью выпадающего списка **Highlight...**
Пулл-реквесты GitHub
--------------------
Как и все IDE от JetBrains, AppCode получил полную поддержку пулл-реквестов GitHub, которая включает в себя следующие возможности:
* Отображение всей информации по пулл-реквесту (название, автор, переписка и др.) в отдельном окне
* Полная интеграция работы с ревью: теперь можно прямо из IDE начать или запросить ревью своих изменений, оставить комментарий или отправить изменения на ревью.
* Merge прямо из IDE.
На этом всё! Все вопросы и пожелания пишите прямо тут в комментариях — будем рады ответить!
*Команда AppCode* | https://habr.com/ru/post/512976/ | null | ru | null |
# 12 малоизвестных фактов о CSS (продолжение)
Больше года назад я опубликовал [12 малоизвестных фактов о CSS](http://www.sitepoint.com/12-little-known-css-facts/) ([перевод](http://habrahabr.ru/post/220237/) на хабре), и по сей день это была одна из самых популярных статей на SitePoint. С тех пор я собирал больше интересностей и маленьких советов по CSS для новой публикации. Мы же все знаем, что каждый успешный фильм должен способствовать выходу новомодного сиквела, верно?
[](http://habrahabr.ru/post/262783/)
Автор иллюстрации SitePoint/[Natalia Balska](http://scncf-lab.com/).
Итак, давайте посмотрим на подборку уже этого года дюжины малоизвестных фактов о CSS. Я уверен, что многим из вас известны, по крайней мере, некоторые из них, но вы можете дать мне знать в комментариях сколько из фактов оказались для вас новыми.
**Примечание переводчика**0. Да, я видел опубликованный пару часов назад перевод этой же статьи. Но мне совесть не позволит удалить многодневный труд из-за опоздания на пару часов :) в общем, на ваш суд.
1. Оригинальная статья изобилует рабочими демонстрациями с CodePen. Хабр, к сожалению, не поддерживает вставки с подобных ресурсов, а заменять рабочие динамические примеры статичными картинками, думаю, не имеет смысла. Поэтому статья получилась немного «лысой» простыней, но, я надеюсь, заинтересованные читатели будут открывать недостающие примеры по ссылкам в новом окне.
2. Хотя я имею непосредственное отношение к верстке, перевод получился большим и не таким простым, как показался поначалу. Замечания по ошибкам, опечаткам, терминологии и т.п. просьба присылать личным сообщением в хабрапочту.
1. В свойстве `border-radius` можно использовать «слэш» синтаксис
-----------------------------------------------------------------
Об этом я уже [писал](http://www.sitepoint.com/setting-css3-border-radius-with-slash-syntax/) на SitePoint больше четырех лет назад, но я думаю, что многие начинающие и даже некоторые опытные разработчики не знают о такой возможности.
Верьте или нет, но следующий код валидный:
```
.box {
border-radius: 35px 25px 30px 20px / 35px 25px 15px 30px;
}
```
Если вы никогда не видели подобного синтаксиса, он может показаться немного запутанным, поэтому приведу объяснение из спецификации:
> Если значения указаны до и после слэша, то значения перед слэшем устанавливают горизонтальный радиус, а значения после слеша — вертикальный. Если слэш не используется — значения обоих радиусов (и горизонтального и вертикального) считаются одинаковыми.
В спецификации также приведена следующая схема:
В пояснении к картинке сказано: «Два значения `border-top-left-radius: 55pt 25pt` определяют кривизну угла».
Таким образом, использование слэша в значениях свойства `border-radius` позволяет создавать несимметрично изогнутые углы (*прим. переводчика: скруглы*). Если вы хотите более подробно разобраться в этом, прочтите мою статью (ссылка на которую выше приводилась), или лучше посмотрите удобную [интерактивную демонстрацию от MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/Tools/Border-radius_generator).
Большинство `border-radius` генераторов не позволяют использовать эти необязательные значения. Из тех, что я нашел, генератор от MDN единственный поддерживает «слэш» синтаксис.
2. Свойство `font-weight` поддерживает ключевые слова относительности
---------------------------------------------------------------------
Обычно, когда вы видите описание свойства `font-weight`, значение в нем либо `normal`, либо `bold`. Вы также могли видеть целые значения с инкрементом в сотню: `100`, `200`, и т.д. вплоть до `900`.
Однако, есть два значения, о которых часто забывают: `bolder` и `lighter`.
Согласно спецификации, эти ключевые слова делают шрифт жирнее или тоньше относительно наследуемого значения. Самое главное — это действует, когда вы имеете дело со шрифтом, в котором поддерживаются несколько степеней «жирности», где поддерживается начертания толще, чем обычный `bold`, и тоньше, чем просто нормальный текст.
В синтаксисе, основанном на целых значениях, `700` означает `bold` и `400` значит `normal`. Итак, если ваш шрифт поддерживает толщину `300`, но не меньше, значение `lighter` будет использовать толщину `300`, если наследуемая толщина шрифта `400`. Если же шрифт не поддерживает более тонкого начертания (т.е. значение по умолчанию `400` является самым тонким), то толщина так и останется `400`, и значение `lighter` не произведет никакого эффекта на текст.
Посмотрите на следующий [пример](http://codepen.io/SitePoint/pen/domZLx).
В этом примере я использую шрифт [Exo 2](https://www.google.com/fonts/specimen/Exo+2), который поддерживает 18 разных начертаний. В моем демо не используются курсивные начертания, но шрифт их поддерживает для каждого значения от `100` до `900`.
Пример включает в себя 12 вложенных элементов «box» с различными значениями `font-weight`, включая `bolder` и `lighter`, чтобы вы могли видеть как это влияет на «жирность» текста в разных случаях наследования. Ниже под спойлером приведен CSS из примера. Обратите внимание на комментарии в коде, и помните, что каждый следующий элемент «box» вложен в предыдущий:
**CSS из примера**
```
.box {
font-weight: 100;
}
.box-2 {
font-weight: bolder; /* переключает на 400 */
}
.box-3 {
font-weight: bolder; /* переключает на 700 */
}
.box-4 {
font-weight: 400;
}
.box-5 {
font-weight: bolder; /* переключает на 700 */
}
.box-6 {
font-weight: bolder; /* переключает на 900 */
}
.box-7 {
font-weight: 700;
}
.box-8 {
font-weight: bolder; /* переключает на 900 */
}
.box-9 {
font-weight: bolder; /* переключает на 900 */
}
.box-10 {
font-weight: lighter; /* переключает на 700 */
}
.box-11 {
font-weight: lighter; /* переключает на 400 */
}
.box-12 {
font-weight: lighter; /* переключает на 100 */
}
```
В этом случае ключевые сова «bolder» и «lighter» устанавливают `font-weight` на значения `100`, `400`, `700` и `900`. С девятью разными стилями эти ключевые слова никогда не приведут к значениям `200`, `300`, `500`, `600` и `800`.
Так получается потому что вы говорите браузеру выбрать следующий шрифт в серии, который «жирнее» или «тоньше». Но браузер выбирает не просто следующий вариант жирнее или тоньше, а вариант начертания жирнее или толще относительно текущего. Однако, если самое тонкое начертание шрифта начинается со значения `300` (как у шрифта [Open Sans](https://www.google.com/fonts/specimen/Open+Sans)), а значение по умолчанию `400`, то использование ключевого слова «lighter» установит `font-weight` на значение `300`.
Это может показаться запутанным, но вы можете поиграться с примером, чтобы понять как работают эти ключевые слова.
3. Свойство `outline-offset`
----------------------------
Свойство `outline` хорошо известно благодаря своему удобству при отладке верстки ([контур элемента никак не влияет на окружающие его элементы](http://www.impressivewebs.com/css-things-that-dont-occupy-space/)). В спецификации, однако, также добавлено свойство `outline-offset`, которое осуществляет именно то, что следует из его названия — оно позволяет задать отступ контура от элемента.
[Пример работы `outline-offset`](http://codepen.io/SitePoint/pen/VLXyZw).
В этом примере подвигайте слайдер вправо/влево, чтобы увидеть как это влияет на отступ контура от элемента. В данном случае отступ меняется от `0px` до `30px`, но в CSS вы можете задать любой отступ. Следует помнить, что хоть `outline` и универсальное свойство (одновременно устанавливающее цвет, стиль и толщину внешней границы), оно не включает в себя `outline-offset`. Поэтому при необходимости `outline-offset` каждый раз нужно прописывать отдельно.
Единственный минус `outline-offset` — он поддерживается всеми браузерами, кроме Internet Explorer (не поддерживает даже IE 11).
4. В CSS есть свойство `table-layout`
-------------------------------------
Вы, наверное, скажете: «Ха, старо как мир. Я знаю о `display:table`. Простейший способ вертикального центрирования». Но это не то, о чем я хочу рассказать. Заметьте, я сказал свойство `table-layout`, а не `display`.
Свойство `table-layout` не самая простая CSS фича, чтобы объяснить как оно работает. Поэтому давайте заглянем в спецификацию, а потом рассмотрим пример. Спецификация гласит:
> При этом (быстром) алгоритме горизонтальная разбивка таблицы не зависит от контента в ячейках; зависит только от ширины таблицы, ширины колонок и бордюров или расстояния между ячейками.
Это, похоже, первый раз, когда в W3C спецификации что-то трудно понять… Хах, прост шутканул (*прим. переводчика: в оригинале «LOL JK»*).
А если серьезно, как всегда нам поможет [живой пример](http://codepen.io/SitePoint/pen/vORpYN). В этом демо таблице в CSS добавлено `table-layout: fixed`. Кликайте по кнопке, чтобы выключать/включать это свойство.
На этом примере вы можете видеть преимущество использования `table-layout: fixed` над `table-layout: auto`. Такой подход не всегда будет лучшим выбором и не всегда необходим, но не плохо бы о нем знать, когда речь идет о таблицах с клетками непостоянной ширины.
В прошлом году Крис Коер (Chris Coyier) написал [отличную статью о `table-layout`](https://css-tricks.com/fixing-tables-long-strings/), поэтому если вы хотите больше узнать об этом свойстве — советую почитать.
5. Свойство `vertical-align` в ячейках таблицы работает по-другому, нежели в других элементах
---------------------------------------------------------------------------------------------
Если вы занимались созданием сайтов в середине 2000-х и раньше или часто верстаете HTML письма для email рассылок, вы, наверное, предполагаете, что CSS свойство `vertical-align` является аналогом старого [HTML4 атрибута `valign`](http://www.w3.org/TR/html401/struct/tables.html#adef-valign), который в [HTML5 уже не поддерживается](http://www.w3.org/TR/html5/obsolete.html#non-conforming-features).
Но CSS свойство `vertical-align` работает не так же, особенно с таблицами. Это, на мой взгляд, странновато, но все же лучше, чем если бы свойство вообще не работало в таблицах.
Так в чем же разница между применением свойства к обычным элементам и к ячейкам таблиц?
Если `vertical-align` применяется не к ячейкам таблиц, то следует этим простым правилам:
* работает только с `inline` и `inline-block` элементами;
* не влияет на соседние элементы в контенте, но влияет на выравнивание элемента относительно соседних `inline` и `inline-block` элементов;
* на свойство влияют настройки шрифта, такие как `line-height`, и размер соседних `inline` и `inline-block` элементов.
В [этом примере](http://codepen.io/SitePoint/pen/zGWpxy) свойство `vertical-align` присвоено элементу `input`. Нажимая на кнопки вы можете устанавливать свойству значения, написанные на кнопках. Обратите внимание, как каждое значение меняет позицию элемента `input`.
В целом, это довольно простенькая демонстрация работы свойства. Для более глубокого анализа прочтите прошлогоднюю [статью Кристофера Оуе](http://christopheraue.net/2014/03/05/vertical-align/) (Christopher Aue).
Когда дело доходит до таблиц, `vertical-align` работает совсем по-другому. В этом случае вы применяете свойство к одной и более ячейкам, и выравнивание контента ячеек зависит от выбранного значения. Пример на [CodePen](http://codepen.io/SitePoint/pen/KpoZdo).
Как показано в примере, только 4 значения свойства `vertical-align` применимы к ячейкам таблиц. Кроме того, значение `baseline` влияет не только на ячейку, к которой проставляется, но и на соседние ячейки в строке таблицы.
6. Псевдоэлемент `::first-letter` умнее, чем вы думали
------------------------------------------------------
Псевдоэлемент `::first-letter` позволяет стилизовать первую букву любого элемента и дает возможность реализовать эффект [буквицы](https://ru.wikipedia.org/wiki/%D0%91%D1%83%D0%BA%D0%B2%D0%B8%D1%86%D0%B0) (*прим. переводчика: позволил себе сослаться на русскоязычную страницу wiki*), который был распространен в печати в течение многих лет.
Хорошая новость в том, что, похоже, браузеры имеют одинаковое представление о «первой букве» элемента. Впервые я прочел об этом в [твите Мэта Эндрюса](https://twitter.com/andrewsmatt/status/497704502167076864) (Matt Andrews), хотя, такое поведение браузеров ему явно не понравилось. Вы можете посмотреть его [пример на CodePen](http://codepen.io/SitePoint/pen/KpoZjE).
Мне кажется, что большая четверка браузеров работает с этим свойством одинаково, и это круто, так как я считаю, что это правильное поведение. Было бы немного странно, если бы открывающая скобка считалась первой буквой. В таком случае это было бы похоже на «first character» (первый символ), который мог бы стать самостоятельным псевдоклассом.
7. В HTML вы можете использовать недопустимые символы в качестве разделителя в списке классов элемента
------------------------------------------------------------------------------------------------------
Этот подход обсуждался [в 2013 году Бэном Эвардом](http://beneverard.co.uk/blog/using-slashes-within-the-html-class-attribute/) (Ben Everard), и, я думаю, стоит подробнее рассмотреть эту тему.
В публикации Бэна говорилось об использовании символа слэша ("/") для разделения в HTML списков классов на группы, чтобы сделать код легче для прочтения и понимания. Автор указывает на то, что хотя слеш является недопустимым символом, браузеры не споткнутся на нем, а просто его проигнорируют.
Предположим, у вас такой HTML:
```
```
Со слешами он будет выглядеть так:
```
```
В качестве разделителей вы можете использовать любые символы (и допустимые, и недопустимые):
```
```
Все подобные конструкции отлично работают, можете протестировать на [этом демо](http://codepen.io/SitePoint/pen/NqYyNe).
Конечно, эти разделители не могут быть использованы в качестве классов, поэтому я называю их «недопустимыми». Следующий код будет нерабочим и не применит стили к элементу:
```
./ {
color: blue;
}
```
Если вы хотите использовать подобные символы в именах классов, сохраняя их работоспособность, вы можете экранировать их, воспользовавшись [этим инструментом](https://mothereff.in/css-escapes). Предыдущий пример будет работать, только если CSS будет выглядеть так:
```
.\/ {
color: blue;
}
```
Углубляясь в подробности скажу, что символы юникода не нужно экранировать, поэтому вы можете использовать подобные безумные конструкции:
```
```
С таким CSS:
```
. {
color: hotpink;
}
.★ {
color: yellow;
}
```
Есть так же возможность экранировать и символы данного типа, вместо их непосредственной вставки. Следующий код эквивалентен предыдущему:
```
.\2665 {
color: hotpink;
}
.\2605 {
color: yellow;
}
```
8. Количество повторов анимации может принимать дробные значения
----------------------------------------------------------------
Вероятно вы в курсе, что при использовании keyframe-анимаций вы можете использовать свойство `animation-iteration-count`, чтобы установить количество повторов анимации:
```
.example {
animation-iteration-count: 3;
}
```
Целое значение в данном случае говорит о том, что анимацию нужно повторить 3 раза. Но, возможно, вы не в курсе, что можно устанавливать и дробные значения:
```
.example {
animation-iteration-count: .5;
}
```
В данном случае будет запущена только половина анимации (она остановится на половине первой итерации). Давайте [посмотрим на пример](http://codepen.io/SitePoint/pen/VLXQmM), в котором анимируются два шарика. У верхнего шарика счетчик повторов установлен на «1», у нижнего на «0.5».
Что интересно, счетчик повторов не зависит от свойства/значения, которые анимируются. Другими словами, если вы анимируете какие-то 100 пикселей, это не значит, что на половине повтора анимация остановится на 50 пикселях. Предыдущий пример использует тайминг-функцию `linear`, что гарантирует остановку второго мячика на половине пути.
Вот еще две анимации, но тут уже используется тайминг-функция `ease`: [пример](http://codepen.io/SitePoint/pen/PqRxov). Обратите внимание, что сейчас второй мячик также прошел до остановки половину анимации. Повторю, так получается из-за различных тайминг-функций.
Если вы понимаете тайминг-функции, вы поймете, почему при `ease-in-out` мячик остановится в той же позиции, что и при `linear`. Поиграйтесь с различными дробными значениями и тайминг-функциями чтобы увидеть, как это влияет на результат.
9. `Animation` может не работать из-за имени анимации
-----------------------------------------------------
Некоторые разработчики обнаружили это случайно на своем опыте, хотя в спецификации на этот счет есть предупреждение. Предположим, у вас есть следующий код анимации:
```
@keyframes reverse {
from {
left: 0;
}
to {
left: 300px;
}
}
.example {
animation: reverse 2s 1s;
}
```
Заметьте, для анимации я использую имя `reverse`. На первый взгляд код выглядит рабочим, но обратите внимание что произойдет, если мы используем его на живом [примере](http://codepen.io/SitePoint/pen/OVvayK).
Анимация не работает, так как «reverse» — это зарезервированное ключевое слово для свойства `animation-direction`. Это произойдет с любой анимацией, имя которой совпадает с зарезервированными ключевыми словами, используемыми в универсальном (кратком) способе записи. При подробной форме записи, с раздельным указанием `animation-name` и других параметров, анимация будет работать.
Имена анимации, которые могут сломать краткую форму записи, включают в себя [имена тайминг-функций](http://drafts.csswg.org/css-transitions-1/#single-transition-timing-function), таких как `infinite`, `alternate`, `running`, `paused` и т.д.
10. Вы можете выбирать диапазон элементов
-----------------------------------------
Не знаю кто первый использовал эту возможность, но я впервые узнал о ней из [этого примера](http://bittersmann.de/samples/08-15) от Гуннара Битерсманна ([Gunnar Bittersmann](https://twitter.com/g16n)). Скажем, у вас есть нумерованный список из 20 элементов и вы хотите выделить элементы с 7 по 14 включительно. Вот как это можно сделать одним селектором:
```
ol li:nth-child(n+7):nth-child(-n+14) {
background: lightpink;
}
```
Посмотрите [демо работы селектора](http://codepen.io/SitePoint/pen/wamQGv).
***Дополнение:** Как отметили в комментариях, в Safari есть баг, из-за которого эта техника не работает. К счастью, решение, предложенное Мэтом Помаски (Matt Pomaski), похоже работает: просто разверните цепочку псевдоклассов, чтобы получился такой селектор `ol li:nth-child(-n+14):nth-child(n+7)`. В ночных сборках WebKit такого бага нет, поэтому со временем и в Safari подобная конструкция будет работать нормально.*
Этот код использует связку псевдоклассов с выражениями. Хотя выражения могут показаться запутанными, вы можете видеть выделяемый диапазон элементов в числах, использованных в этих выражениях.
Как это работает: В первой части связки выражение говорит «выбрать 7-й элемент и каждый после него». Во второй части говорится «выбрать 14-й элемент и каждый до него». Но так как селекторы в связке — каждый ограничивает область выборки другого. Так вторая часть связки не дает первой выбраться за пределы 14-го элемента, а первая часть не дает второй опуститься в выборке ниже 7-го элемента.
Для более детального изучения этих типов селекторов и выражений вы можете прочитать [мой старый пост на эту тему](http://www.impressivewebs.com/css3-pseudo-class-expressions/).
11. Псевдоэлементы могут быть применены к некоторым одиночным тегам
-------------------------------------------------------------------
Возможно вы, как и я, в какой-то момент пытались применить псевдоэлементы к изображениям или элементам форм. Этого сделать не получится, потому что псевдоэлементы не работают с заменяемыми элементами. Я думаю, многие разработчики предполагают, что это касается всех одиночных тегов (не имеющих закрывающего тега). Но это не так.
Вы можете применить псевдоэлементы к [некоторым одиночным тегам](http://www.w3.org/TR/html5/syntax.html#void-elements), которые не являются заменяемыми элементами. Это касается и элемента `hr`, как видно из [этого примера](http://codepen.io/SitePoint/pen/ZGxmpK).
Закрашенная область в этом примере — это горизонтальный очерк (элемент `hr`), и к нему применены оба псевдоэлемента `::before` и `::after`. Интересно, но мне не удалось получить тот же результат с `br`, хотя он и является незаменяемым однотеговым элементом.
Вы также можете добавить псевдоэлементы к элементам `meta` и `link`, если вы достаточно ненормальны, чтобы сделать их блоковыми `display: block`, как показано в [следующем примере](http://codepen.io/SitePoint/pen/KporNg).
12. Некоторые значения в селекторах атрибутов регистронезависимы
----------------------------------------------------------------
В завершение рассмотрим одну небольшую неясность. Предположим, у вас следующий HTML:
```
```
Вы можете применить стили к каждому из этих элементов, используя селекторы атрибутов, как тут:
```
div[class="box"] {
color: blue;
}
input[type="email"] {
border: solid 1px red;
}
```
Такие стили сработают нормально. А что если сделать так?
```
div[class="BOX"] {
color: blue;
}
input[type="EMAIL"] {
border: solid 1px red;
}
```
Обратите внимание, что значения атрибутов указаны теперь в верхнем регистре. В этом случае к элементу `.box` стили не будут применены, так как атрибут `class` является регистрозависимым. С другой стороны, к полю email стили применятся, потому что значения атрибута `type` не чувствительны к регистру. Тут нет никакого открытия, но, возможно, вы не знали об этом.
Народ, пора закругляться
------------------------
В этот момент опускается занавес, и надеюсь-не-слишком-дрянной сиквел заканчивается.
Чувствуется, что каждую неделю я натыкаюсь на небольшие CSS интересности и изучаю их, и, я надеюсь, что что-то из описанного выше оказалось познавательным для большинства из вас. Какие у вас любимые малоизвестные CSS трюки или техника? Знаете ли вы свойства или возможности CSS, которые вы считаете малоизвестными, но хорошо поддерживаемыми браузерами? Поделитесь ими в комментариях. | https://habr.com/ru/post/262783/ | null | ru | null |
# DariaDB. Разработка базы данных для хранения временных рядов
Уже больше года, как у меня есть свой хобби-проект, в котором я разрабатываю движок базы данных для хранения временных рядов — dariadb. Задача довольно интересная — тут есть и сложные алгоритмы да и область для меня совершенно новая. За год был сделан сам движок, небольшой сервер для него и клиент. Написано все это на С++. И если клиент-сервер находится пока в достаточно сыром состоянии, то движок уже обрел некоторую стабильность.Задача хранения временных рядов достаточно распространена там, где есть хоть какие-то измерения (от SCADA-систем до мониторинга состояния серверов).
Для решения этой задачи есть некоторое количество решений разной степени навороченности:
* [InfluxDB](https://www.influxdata.com/)
* [RRDtool](http://oss.oetiker.ch/rrdtool/)
* [Akumuli](https://github.com/akumuli/Akumuli)
* энтерпрайз-решения на основе SQL-сервера
В качестве вводной статьи могу посоветовать широко известную в определенных кругах статью от FaceBook “[Gorilla: A Fast, Scalable, In-Memory Time Series Database](http://www.vldb.org/pvldb/vol8/p1816-teller.pdf)”.
Основной задачей же dariadb было создание встраиваемого решения, которое можно было бы (подобно SQLite) встроить в свое приложение и переложить на него хранение, обработку и анализ временных рядов. Из поставленных задач на данный момент выполнено приём, хранение и обработка измерений. Проект пока носит исследовательский характер, поэтому сейчас для использования в продакшене он не годится. Во всяком случае пока :)
Временной ряд измерений
-----------------------
Временной ряд измерений представляет из себя последовательность четверок {Time, Value, Id, Flag}, где
* Time, время измерения (8 байт)
* Value, сам замер (8 байт)
* Id, идентификатор временного ряда (4 байта)
* Flag, флаг замера (4 байта)
Флаг используется только при чтении. Есть специальный флаг “нет данных” (**\_NO\_DATA** = 0xffffffff), который проставляется для значений, которых или нет совсем или они не удовлетворяют фильтру. Если в запросе поле флаг указано не 0 (ноль), то для каждого измерения, которое подходит по времени для запроса, к его полю flag применяется операция "логическое И", если ответ равен фильтру, то измерение проходит. Значение поступают в порядке возрастания метки времени (но это не обязательно, иногда нужно записать значение “в прошлое”), по ним надо уметь делать срез и запрашивать интервалы.
Читаем срез
-----------
Срез значения для временного ряда на метку времени T, это значение, которые существует в момент времени T или “левее” этого времени.Мы всегда возвращаем левое ближайшее, но только если устраивает флаг. Если значения нет или флаг не подходит, то “нет данных”.
Тут важно понять, почему именно возвращается “нет данных” для значений, не попавших под флаг. Может так случиться, что ни одно из хранимых значений не попадает под флаг, тогда это приведет к чтению всего хранилища. Поэтому было принято решение, что если значение на момент среза есть, но флаг не совпал, то считаем, что значения нет.
Читаем интервал.
----------------
Тут все значительно проще: возвращаются все значения, которые попали во временной интервал. Т.е. должно выполняться условие from<=T<=to, где T — время замера.
Если измерение попадает в интервал, но не удовлетворяет флагу, то оно отбраковывается. Данные всегда отдаются пользователю в порядке возрастания метки времени.
МинМаксы, последние значения, статистика.
-----------------------------------------
Также есть возможность получить для каждого временного ряда его минимальное и максимальное время, которое записано в хранилище; последнее записанное значение; разную статистику на интервале.
Базовое устройство хранилища
============================
Получился проект со следующими характеристиками:
* Поддержка неотсортированных значений
* Значения, которые записаны в хранилище поменять уже нельзя.
* Различные стратегии записи.
* Хранение на диске в виде LSM-дерева (<https://ru.wikipedia.org/wiki/LSM-%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE>).
* Высокая скорость записи:2.5 — 3.5 миллиона записей в секунду, при записи на диск; 7-9 миллионов записей в секунду при записи в память.
* Восстановление после сбоев.
* CRC32 для всех сжатых значений.
* Два варианта запроса данных: Functor API (async) — для запроса передается колбек-функция, которая будет применяться для каждого значения, попавшего в запрос. Standard API — значения вернуться в виде списка или словаря.
* Статистика на интервале: время min/max; значения min/max количество измерений; сумма значений
Реализованы следующие слои: хранение в оперативной памяти, хранение на диске в лог файлах, хранение в сжатом виде.
Лог-файлы (\*.wal)
------------------
Это просто лог-файлы. В памяти держится небольшой буфер, при заполнении которого он сортируется и сбрасывается на диск. Максимальный размер буфера и файла регламентируется настройкам (см. ниже). При запросах весь файл вычитывается и значения попавшие в запрос отдаются пользователю. Никаких индексов и маркеров для ускорения поиска, просто лог-файл. Имя файла формируется из времени создания этого файла в микросекундах + расширение (wal).
Сжатые страницы (\*.page)
-------------------------
Страницы получают путем сжатия лог-файлов и их имя совпадает с лог-файлом из которого страница была получена. Если при старте у нас оказывается, что есть страницы с таким же именем (без учета расширения), что и лог файл, то мы делаем вывод, что хранилище не было остановлено нормальным способом, страница удаляется и сжатие повторяется вновь.Эти файлы уже лучше оптимизированы для чтения. Они состоят из наборов чанков, каждый чанк хранит отсортированные и сжатые значения для одного временного ряда, максимальный размер чанка ограничен настройками. В конце файла находится футер, который хранит минмаксы времени, фильтр блума для id попавших в файл временных рядов, статистику для хранимого временного ряда.
Для каждой страницы создается индексный файл. Индексный файл содержит набор минмаксов времени для каждого чанка в странице, id временного ряда, позицию в странице. Таким образом, при запросах за интервал или среза нам просто необходимо в индексном файле найти нужные чанки и вычитать их из страницы.В каждом чанке значения хранятся в сжатом виде. Для каждого поля измерения используется свой алгоритм (вдохновлялся знаменитой статьей “Gorilla: A Fast, Scalable, In-Memory Time Series Database”):
* DeltaDelta — для времени
* Xor — для самих значений
* LEB128 — для флагов
В результате на разных данных сжатие достигает до 3-х раз.
Футеры индексных файлов всегда лежат в кеше и используются для быстрого поиска нужных страниц, для выдачи результатов.
Хранение в памяти
-----------------
В памяти каждый временной ряд хранится в списке (простой std::list из stl) чанков, а для быстрого поиска над всем этим построено B+ дерево, построенное по максимальному времени каждого чанка. Таким образом, при запросах интервала или среза, мы просто находим чанки, которые содержат нужные нам данным, распаковываем их и отдаем. Хранилище в памяти ограничено по максимальному размеру, т.е. если мы слишком энергично будем писать в него, то лимит быстро кончится и дальше все пойдет по сценарию, который определяется стратегией хранения
Cтратегии хранения
------------------
1. WAL — данные пишутся только в лог файлы, пережатие в страницы автоматически не запускается, но есть возможность запустить сжатие всех лог-файлов вручную.
2. COMPRESSED — данные пишутся в лог файлы, но как только файл достигает предела (см настройки), рядом создается новый файл, а старый ставится в очередь на сжатие.
3. MEMORY — все пишется в память, как только достигаем лимит, самые старые чанки начинаем сбрасывать на диск.
4. CACHE — пишем и в память и на диск. данная стратегия дает скорость записи как у COMPRESSED, зато быстрый поиск для свежих недавно записанных данных. Для данной также актуален лимит по памяти, если мы его достигнем, то старые чанки просто удаляются.
Переупаковка и запись в прошлое.
--------------------------------
Возможна запись данных в любом порядке. Если стратегия MEMORY и мы пишем в прошлое, которое хранится еще в памяти, то мы просто добавим в существующий чанк новые данные. Если же мы пишем так далеко в прошлое, что это время уже не находится в памяти, или стратегия хранения у нас не MEMORY, то данные запишутся в текущий чанк, но при чтении данных будет использован алгоритм k-merge, что немного замедляет чтение, если таких чанков очень много. Чтобы такого не было, есть вызов repack, который переупаковывает страницы, убирая дубликаты и сортируя данные в порядке возрастания метки времени. При этом страницы схлопываются так, чтобы на каждом уровне было страниц не больше, чем задано настройками (LSM — дерево).
Создание временного ряда
------------------------
Выбор идентификатора для временного ряда можно реализовать самостоятельно, а можно возложить на dariadb — реализована возможность создания именованных временных рядов, затем по имени можно получить идентификатор, а его уже прописать в нужное измерение. Это проще чем кажется. В любом случае, если вы запишите измерение, но оно не описано в файле с временными рядами (создается автоматически при инициализации хранилища), то измерение будет записано без каких либо проблем.
Настройки
---------
Настройки можно задать через класс Settings(см пример ниже). доступны следующие настройки:
1. wal\_file\_size — максимальный размер лог файла в измерениях (не в байтах!).
2. wal\_cache\_size — размер буфера в памяти, в который пишутся измерения, перед тем как попасть в лог-файл.
3. chunk\_size — размер чанка в байтах strategy — стратегия хранения.
4. memory\_limit максимальный размер занимаемой памяти хранилищем в ОЗУ.
5. percent\_when\_start\_droping — процент заполнения памяти ОЗУ хранилищем, когда начнется сброс чанков.
6. percent\_to\_drop — сколько процентов памяти надо очистить, когда мы достигли предела по памяти.
7. max\_pages\_in\_level — максимальное количество страниц (.page) на каждом уровне.
Итоговые бенчмарки
==================
Приведу скоростные характеристики на типичных задачах.
Условия:
--------
2 потока пишут по 50 временных рядов, в каждом ряде измерения за 2-е суток. Частота замера — 2 измерения в сек. В итоге получаем 2000000 измерений. Машина Intel core i5 2.8 760 @ GHz, 8 Gb озу, жесткий диск WDC WD5000AAKS, Windows 7
### Средняя скорость записи в секунду:
| WAL, зап/сек | Compressed, зап/сек | MEMORY, зап/сек | CACHE, зап/сек |
| --- | --- | --- | --- |
| 2.600.000 | 420.000 | 5.000.000 | 420.000 |
### Чтение среза.
Выбирается N случайных временных рядов, для каждого находится время, на котором точно есть значения и запрашивается среза на случайный момент времени в этом интервале.
| WAL, сек | Compressed, сек | MEMORY, сек | CACHE, сек |
| --- | --- | --- | --- |
| 0.03 | 0.02 | 0.005 | 0.04 |
### Время чтение интервала за 2-е суток для всех значений:
| WAL, сек | Compressed, сек | MEMORY, сек | CACHE, сек |
| --- | --- | --- | --- |
| 13 | 13 | 0.5 | 5 |
### Чтение интервала за случайный промежуток времени
| WAL, зап/с | Compressed, зап/с | MEMORY, зап/с | CACHE, зап/с |
| --- | --- | --- | --- |
| 2.043.925 | 2.187.507 | 27.469.500 | 20.321.500 |
Как все собрать и попробовать.
==============================
Проект сразу задумывался как кроссплатформенный, разработка его идет на windows и ubuntu/linux. Поддерживаются компиляторы gcc-6 и msvc-14. Сборка через clang пока не поддерживается.
Зависимости
-----------
В Ubuntu 14.04 надо подключить ppa ubuntu-toolchain-r-test:
```
$ sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
$ sudo apt-get update
$ sudo apt-get install -y libboost-dev libboost-coroutine-dev libboost-context-dev libboost-filesystem-dev libboost-test-dev libboost-program-options-dev libasio-dev libboost-log-dev libboost-regex-dev libboost-date-time-dev cmake g++-6 gcc-6 cpp-6
$ export CC="gcc-6"
$ export CXX="g++-6"
```
### Пример использование в качестве встраиваемого проекта (<https://github.com/lysevi/dariadb-example>)
```
$ git clone https://github.com/lysevi/dariadb-example
$ cd dariadb-example
$ git submodule update --init --recursive
$ cmake .
```
Сборка проекта у разработчика
-----------------------------
```
$ git clone https://github.com/lysevi/dariadb.git
$ cd dariadb
$ git submodules init
$ git submodules update
$ cmake .
```
Запуск тестов
-------------
```
$ ctest --verbose .
```
Пример
======
Создание хранилища и наполнение значениями
------------------------------------------
```
#include
#include
#include
int main(int, char \*\*) {
const std::string storage\_path = "exampledb";
// удалим старое хранилище, если оно есть
if (dariadb::utils::fs::path\_exists(storage\_path)) {
dariadb::utils::fs::rm(storage\_path);
}
// инициализируем настройки. ничего менять не будем
auto settings = dariadb::storage::Settings::create(storage\_path);
settings->save();
//создадим два временных ряда. p1 и p2 содержат идентификаторы временных
//новых рядов
auto scheme = dariadb::scheme::Scheme::create(settings);
auto p1 = scheme->addParam("group.param1");
auto p2 = scheme->addParam("group.subgroup.param2");
scheme->save();
//создаем сам движок.
auto storage = std::make\_unique(settings);
auto m = dariadb::Meas();
auto start\_time = dariadb::timeutil::current\_time(); //текущее время в милисекундах
// пишем значения в оба временных ряда по очереди за интервал
// [currentTime:currentTime+10]
m.time = start\_time;
for (size\_t i = 0; i < 10; ++i) {
if (i % 2) {
m.id = p1;
} else {
m.id = p2;
}
m.time++;
m.value++;
m.flag = 100 + i % 2;
auto status = storage->append(m);
if (status.writed != 1) {
std::cerr << "Error: " << status.error\_message << std::endl;
}
}
}
```
Открытие хранилища и чтение интервала.
--------------------------------------
```
#include
#include
// функции для вывода измерения на экран
void print\_measurement(dariadb::Meas&measurement){
std::cout << " id: " << measurement.id
<< " timepoint: " << dariadb::timeutil::to\_string(measurement.time)
<< " value:" << measurement.value << std::endl;
}
void print\_measurement(dariadb::Meas&measurement, dariadb::scheme::DescriptionMap&dmap) {
std::cout << " param: " << dmap[measurement.id]
<< " timepoint: " << dariadb::timeutil::to\_string(measurement.time)
<< " value:" << measurement.value << std::endl;
}
class QuietLogger : public dariadb::utils::ILogger {
public:
void message(dariadb::utils::LOG\_MESSAGE\_KIND kind, const std::string &msg) override {}
};
class Callback : public dariadb::IReadCallback {
public:
Callback() {}
void apply(const dariadb::Meas &measurement) override {
std::cout << " id: " << measurement.id
<< " timepoint: " << dariadb::timeutil::to\_string(measurement.time)
<< " value:" << measurement.value << std::endl;
}
void is\_end() override {
std::cout << "calback end." << std::endl;
dariadb::IReadCallback::is\_end();
}
};
int main(int, char \*\*) {
const std::string storage\_path = "exampledb";
// заменяем стандартный логер. это нужно, чтобы не захламлять
// вывод консоли
dariadb::utils::ILogger\_ptr log\_ptr{new QuietLogger()};
dariadb::utils::LogManager::start(log\_ptr);
auto storage = dariadb::open\_storage(storage\_path);
auto scheme = dariadb::scheme::Scheme::create(storage->settings());
// получаем идентификаторы временных рядов.
auto all\_params = scheme->ls();
dariadb::IdArray all\_id;
all\_id.reserve(all\_params.size());
all\_id.push\_back(all\_params.idByParam("group.param1"));
all\_id.push\_back(all\_params.idByParam("group.subgroup.param2"));
dariadb::Time start\_time = dariadb::MIN\_TIME;
dariadb::Time cur\_time = dariadb::timeutil::current\_time();
// запрашиваем интервал
dariadb::QueryInterval qi(all\_id, dariadb::Flag(), start\_time, cur\_time);
dariadb::MeasList readed\_values = storage->readInterval(qi);
std::cout << "Readed: " << readed\_values.size() << std::endl;
for (auto measurement : readed\_values) {
print\_measurement(measurement, all\_params);
}
// применяем колбек к значениям в интервале
std::cout << "Callback in interval: " << std::endl;
std::unique\_ptr callback\_ptr{new Callback()};
storage->foreach (qi, callback\_ptr.get());
callback\_ptr->wait();
{ // статистика
auto stat = storage->stat(dariadb::Id(0), start\_time, cur\_time);
std::cout << "count: " << stat.count << std::endl;
std::cout << "time: [" << dariadb::timeutil::to\_string(stat.minTime) << " "
<< dariadb::timeutil::to\_string(stat.maxTime) << "]" << std::endl;
std::cout << "val: [" << stat.minValue << " " << stat.maxValue << "]" << std::endl;
std::cout << "sum: " << stat.sum << std::endl;
}
}
```
Чтение среза данных
-------------------
Тут открытие хранилища и получения идентификаторов ничем не отличается от предыдущего примера, поэтому приведу только пример получения среза
```
dariadb::Time cur_time = dariadb::timeutil::current_time();
// запрашиваем срез;
dariadb::QueryTimePoint qp(all_id, dariadb::Flag(), cur_time);
dariadb::Id2Meas timepoint = storage->readTimePoint(qp);
std::cout << "Timepoint: " << std::endl;
for (auto kv : timepoint) {
auto measurement = kv.second;
print_measurement(measurement, all_params);
}
// последние значения
dariadb::Id2Meas cur_values = storage->currentValue(all_id, dariadb::Flag());
std::cout << "Current: " << std::endl;
for (auto kv : timepoint) {
auto measurement = kv.second;
print_measurement(measurement, all_params);
}
// применяем функцию к каждому значению в срезе.
std::cout << "Callback in timepoint: " << std::endl;
std::unique_ptr callback\_ptr{new Callback()};
storage->foreach (qp, callback\_ptr.get());
callback\_ptr->wait();
```
Ссылки
======
* [dariadb](https://github.com/lysevi/dariadb)
* [пример](https://github.com/lysevi/dariadb-example)
* [akumuli](https://github.com/akumuli/Akumuli)
* [influxdb](https://www.influxdata.com/)
* [RRDtool](http://oss.oetiker.ch/rrdtool/)
* [facebook-gorilla](http://www.vldb.org/pvldb/vol8/p1816-teller.pdf) | https://habr.com/ru/post/323256/ | null | ru | null |
# JodaTime — учите матчасть, или важность существительных
Нашел у себя баг. Нужно было по некоторой логике получить временной интервал, причем без привязки к конкретным датам, то есть просто обертку вокруг количества милисекунд между некими событиями.
В моем коде я высчитывал startDate и endDate, и возвращал Duration вот таким образом:
```
return new Period(startDate, endDate).toDuration();
```
Выяснилось, что если startDate и endDate отстояли друг от друга больше, чем на месяц, JodaTime кидал исключение. Решение было найдено быстро:
```
return new Interval(startDate, endDate).toDuration();
```
Починил, и задумался, почему я допустил такой ляп. JodaTime имеет очень богатый набор классов для описания всего, что связано со временем, и мне некогда было разбираться в разнице между Period, Interval, Duration и т.д. И очень зря.
Когда я писал код, в голове вертелось «за отчетный период хлеборобы Кубани убрали и намолотили....». Я, хотя и свободно говорю по-английски, выбрал первый попавшийся класс, похожий на «отчетный период», т.е. Period.
К чему я это все? К тому, как важно правильно называть свои классы/методы/переменные. Почитал я (вовремя, ага, после того, как закончил проект) документацию к JodaTime и позавидовал белой завистью. Ребята приложили кучу усилий к тому, чтобы назвать каждый класс нужным существительным. Interval — это не Period, и понятно почему (ага, теперь понятно). У меня так, к сожалению, получается не всегда. А жаль. | https://habr.com/ru/post/126556/ | null | ru | null |
# Обзор Python-пакета Datatable
*«Пять экзабайт информации создано человечеством с момента зарождения цивилизации до 2003 года, но столько же сейчас создаётся каждые два дня». Эрик Шмидт*
[](https://habr.com/ru/company/ruvds/blog/455507/)
Datatable — это Python-библиотека для выполнения эффективной многопоточной обработки данных. Datatable поддерживает наборы данных, которые не помещаются в памяти.
Если вы пишете на R, то вы, вероятно, уже используете пакет `data.table`. [Data.table](https://cran.r-project.org/web/packages/data.table/data.table.pdf) — это расширение R-пакета [data.frame](https://www.rdocumentation.org/packages/base/versions/3.6.0/topics/data.frame). Кроме того, без этого пакета не обойтись тем, кто пользуется R для быстрой агрегации больших наборов данных (речь идёт, в частности, о 100 Гб данных в RAM).
Пакет `data.table` для R весьма гибок и производителен. Пользоваться им легко и удобно, программы, в которых он применяется, пишутся довольно быстро. Этот пакет широко известен в кругах R-программистов. Его загружают более 400 тысяч раз в месяц, он используется в почти 650 CRAN и Bioconductor-пакетах ([источник](https://github.com/Rdatatable/data.table/wiki)).
Какая от всего этого польза для тех, кто занимается анализом данных на Python? Всё дело в том, что существует Python-пакет `datatable`, являющийся аналогом `data.table` из мира R. Пакет `datatable` чётко ориентирован на обработку больших наборов данных. Он отличается высокой производительностью — как при работе с данными, которые полностью помещаются в оперативной памяти, так и при работе с данными, размер которых превышает объём доступной RAM. Он поддерживает и многопоточную обработку данных. В целом, пакет [datatable](https://datatable.readthedocs.io/en/latest/?badge=latest) вполне можно назвать младшим братом [data.table](https://github.com/Rdatatable/data.table).
Datatable
---------
Современным системам машинного обучения нужно обрабатывать чудовищные объёмы данных и генерировать множество признаков. Это нужно для построения как можно более точных моделей. Python-модуль `datatable` был создан для решения этой проблемы. Это — набор инструментов для выполнения операций с большими (до 100 Гб) объёмами данных на одиночном компьютере на максимально возможной скорости. Спонсором разработки `datatable` является [H2O.ai](https://www.h2o.ai/), а первым пользователем пакета — [Driverless.ai](https://www.h2o.ai/driverless-ai/).
Этот набор инструментов очень напоминает [pandas](https://github.com/pandas-dev/pandas), но он сильнее ориентирован на обеспечение высокой скорости обработки данных и на поддержку больших наборов данных. Разработчики пакета `datatable`, кроме того, стремятся к тому, чтобы пользователям было бы удобно с ним работать. Речь идёт, в частности, о мощном API и о продуманных сообщениях об ошибках. В этом материале мы поговорим о том, как пользоваться `datatable`, и о том, как он выглядит в сравнении с `pandas` при обработке больших наборов данных.
Установка
---------
В MacOS `datatable` можно легко установить с помощью `pip`:
```
pip install datatable
```
В Linux установка производится из бинарных дистрибутивов:
```
# Для Python 3.5
pip install https://s3.amazonaws.com/h2o-release/datatable/stable/datatable-0.8.0/datatable-0.8.0-cp35-cp35m-linux_x86_64.whl
# Для Python 3.6
pip install https://s3.amazonaws.com/h2o-release/datatable/stable/datatable-0.8.0/datatable-0.8.0-cp36-cp36m-linux_x86_64.whl
```
В настоящий момент `datatable` не работает под Windows, но сейчас ведётся работа в этом направлении, так что поддержка Windows — это лишь вопрос времени.
Подробности об установке `datatable` можно найти [здесь](https://datatable.readthedocs.io/en/latest/install.html).
Код, который будет использован в этом материале, можно найти в [этом](https://github.com/parulnith/An-Overview-of-Python-s-Datatable-package) GitHub-репозитории или [здесь](https://mybinder.org/v2/gh/parulnith/An-Overview-of-Python-s-Datatable-package/master?filepath=An%20Overview%20of%20Python%27s%20Datatable%20package.ipynb), на mybinder.org.
Чтение данных
-------------
Набор данных, с которым мы тут будем экспериментировать, взят с Kaggle ([Lending Club Loan Data Dataset](https://www.kaggle.com/wendykan/lending-club-loan-data#loan.csv)). Этот набор состоит из полных данных обо всех займах, выданных в 2007-2015 годах, включая текущее состояние займа (Current, Late, Fully Paid и так далее) и самые свежие сведения о платеже. Файл состоит из 2.26 миллиона строк и 145 столбцов. Размер этого набора данных идеально подходит для демонстрации возможностей библиотеки `datatable`.
```
# Импортируем необходимые библиотеки
import numpy as np
import pandas as pd
import datatable as dt
```
Давайте загрузим данные в объект `Frame`. Базовая единица анализа в `datatable` — это `Frame`. Это — то же самое, что `DataFrame` из `pandas` или SQL-таблица. А именно, речь идёт о данных, организованных в виде двумерного массива, в котором можно выделить строки и столбцы.
### ▍Загрузка данных с использованием datatable
```
%%time
datatable_df = dt.fread("data.csv")
____________________________________________________________________
CPU times: user 30 s, sys: 3.39 s, total: 33.4 s
Wall time: 23.6 s
```
Вышеприведённая функция `fread()` представляет собой мощный и очень быстрый механизм. Она может автоматически обнаруживать и обрабатывать параметры для подавляющего большинства текстовых файлов, загружать данные из .ZIP-архивов и из Excel-файлов, получать данные по URL и делать многое другое.
Кроме этого, парсер `datatable` обладает следующими возможностями:
* Он может автоматически обнаруживать разделители, заголовки, типы столбцов, правила экранирования символов и так далее.
* Он может читать данные из различных источников. Среди них — файловая система, URL, командная оболочка, необработанный текст, архивы.
* Он умеет выполнять многопоточное чтение данных для обеспечения максимальной производительности.
* Он отображает индикатор прогресса при чтении больших файлов.
* Он может читать файлы, соответствующие и не соответствующие [RFC4180](https://tools.ietf.org/html/rfc4180).
### ▍Загрузка данных с использованием pandas
Теперь посмотрим — сколько времени нужно `pandas` на то, чтобы прочитать тот же самый файл.
```
%%time
pandas_df= pd.read_csv("data.csv")
___________________________________________________________
CPU times: user 47.5 s, sys: 12.1 s, total: 59.6 s
Wall time: 1min 4s
```
Можно видеть, что `datatable` явно работает быстрее `pandas` при чтении больших наборов данных. `Pandas` в нашем эксперименте нужно больше минуты, а время, необходимое `datatable`, измеряется секундами.
Преобразование объекта Frame
----------------------------
Существующий объект `Frame` пакета `datatable` можно конвертировать в объект `DataFrame` `numpy` или `pandas`. Делается это так:
```
numpy_df = datatable_df.to_numpy()
pandas_df = datatable_df.to_pandas()
```
Попробуем преобразовать существующий объект `Frame` `datatable` в объект `DataFrame` `pandas` и посмотрим на то, сколько это займёт времени.
```
%%time
datatable_pandas = datatable_df.to_pandas()
___________________________________________________________________
CPU times: user 17.1 s, sys: 4 s, total: 21.1 s
Wall time: 21.4 s
```
Похоже, что чтение файла в объект `Frame` `datatable` и последующее преобразование этого объекта в объект `DataFrame` `pandas` занимает меньше времени, чем загрузка данных в `DataFrame` средствами `pandas`. Поэтому, возможно, если планируется обрабатывать большие объёмы данных с помощью `pandas`, лучше будет загружать их средствами `datatable`, а потом уже преобразовывать в `DataFrame`.
```
type(datatable_pandas)
___________________________________________________________________
pandas.core.frame.DataFrame
```
Основные свойства объекта Frame
-------------------------------
Рассмотрим основные свойства объекта `Frame` из `datatable`. Они очень похожи на аналогичные свойства объекта `DataFrame` из `pandas`:
```
print(datatable_df.shape) # (количество строк, количество столбцов)
print(datatable_df.names[:5]) # имена первых 5 столбцов
print(datatable_df.stypes[:5]) # типы первых 5 столбцов
______________________________________________________________
(2260668, 145)
('id', 'member_id', 'loan_amnt', 'funded_amnt', 'funded_amnt_inv')
(stype.bool8, stype.bool8, stype.int32, stype.int32, stype.float64)
```
Тут нам доступен и метод `head()`, выводящий `n` первых строк:
```
datatable_df.head(10)
```
*Первые 10 строк объекта Frame из datatable*
Цвета заголовков указывают на тип данных. Красным цветом обозначены строки, зелёным — целые числа, синим — числа с плавающей точкой.
Суммарная статистика
--------------------
Вычисление суммарной статистики в `pandas` — это операция, для выполнения которой требуется много памяти. В случае с `datatable` это не так. Вот команды, которые можно использовать для вычисления различных показателей в `datatable`:
```
datatable_df.sum() datatable_df.nunique()
datatable_df.sd() datatable_df.max()
datatable_df.mode() datatable_df.min()
datatable_df.nmodal() datatable_df.mean()
```
Вычислим среднее значение по столбцам с использованием `datatable` и `pandas` и проанализируем время, необходимое для выполнения этой операции.
### ▍Нахождение среднего значения с использованием datatable
```
%%time
datatable_df.mean()
_______________________________________________________________
CPU times: user 5.11 s, sys: 51.8 ms, total: 5.16 s
Wall time: 1.43 s
```
### ▍Нахождение среднего значения с использованием pandas
```
pandas_df.mean()
__________________________________________________________________
Throws memory error.
```
Как видно, в `pandas` нам не удалось получить результат — выдана ошибка, связанная с памятью.
Манипуляции с данными
---------------------
`Frame` и `DataFrame` — это структуры данных, представляющие собой таблицы. В `datatable` для выполнения манипуляций с данными используются квадратные скобки. Это напоминает то, как работают с обычными матрицами, но здесь при применении квадратных скобок можно пользоваться дополнительными возможностями.
*Работа с данными в datatable с использованием квадратных скобок*
В математике при работе с матрицами также используются конструкции вида `DT[i, j]`. Похожие структуры можно найти в языках C, C++ и R, в пакетах `pandas` и `numpy`, а так же во многих других технологиях. Рассмотрим выполнение распространённых манипуляций с данными в `datatable`.
### ▍Формирование выборок строк или столбцов
Следующий код выбирает все строки из столбца `funded_amnt`:
```
datatable_df[:,'funded_amnt']
```
*Выбор всех строк столбца funded\_amnt*
Вот как выбрать первые 5 строк и 3 столбца:
```
datatable_df[:5,:3]
```
*Выбор первых 5 строк и 3 столбцов*
### ▍Сортировка данных с использованием datatable
Отсортируем набор данных по выбранному столбцу:
```
%%time
datatable_df.sort('funded_amnt_inv')
_________________________________________________________________
CPU times: user 534 ms, sys: 67.9 ms, total: 602 ms
Wall time: 179 ms
```
### ▍Сортировка данных с использованием pandas
```
%%time
pandas_df.sort_values(by = 'funded_amnt_inv')
___________________________________________________________________
CPU times: user 8.76 s, sys: 2.87 s, total: 11.6 s
Wall time: 12.4 s
```
Обратите внимание на значительное различие во времени, необходимом на сортировку `datatable` и `pandas`.
### ▍Удаление строк и столбцов
Вот как удалить столбец с именем `member_id`:
```
del datatable_df[:, 'member_id']
```
Группировка
-----------
Datatable, как и `pandas`, поддерживает возможности по группировке данных. Посмотрим на то, как получить среднее по столбцу `funded_amound`, данные в котором сгруппированы по столбцу `grade`.
### ▍Группировка данных с использованием datatable
```
%%time
for i in range(100):
datatable_df[:, dt.sum(dt.f.funded_amnt), dt.by(dt.f.grade)]
____________________________________________________________________
CPU times: user 6.41 s, sys: 1.34 s, total: 7.76 s
Wall time: 2.42 s
```
Здесь вы можете видеть использование конструкции `.f`. Это — так называемый фрейм-прокси — простой механизм, позволяющий ссылаться на объект `Frame`, с которым в данный момент производятся какие-то действия. В нашем случае `dt.f` — это то же самое, что `datatable_df`.
### ▍Группировка данных с использованием pandas
```
%%time
for i in range(100):
pandas_df.groupby("grade")["funded_amnt"].sum()
____________________________________________________________________
CPU times: user 12.9 s, sys: 859 ms, total: 13.7 s
Wall time: 13.9 s
```
Фильтрация строк
----------------
Синтаксис фильтрации похож на синтаксис группировки. Отфильтруем те строки `loan_amnt`, для которых значение `loan_amnt` больше, чем `funded_amnt`.
```
datatable_df[dt.f.loan_amnt>dt.f.funded_amnt,"loan_amnt"]
```
Сохранение объекта Frame
------------------------
Содержимое объекта `Frame` можно записать в CSV-файл, что позволяет использовать данные в будущем. Делается это так:
```
datatable_df.to_csv('output.csv')
```
О других методах `datatable`, предназначенных для работы с данными, можно почитать [здесь](https://datatable.readthedocs.io/en/latest/using-datatable.html).
Итоги
-----
Python-модуль `datatable`, определённо, работает быстрее привычного многим `pandas`. Он, кроме того, прямо-таки находка для тех, кому нужно обрабатывать очень большие наборы данных. Пока единственный минус `datatable` в сравнении с `pandas` — это объём функционала. Однако сейчас ведётся активная работа над `datatable`, поэтому вполне возможно то, что в будущем `datatable` превзойдёт `pandas` по всем направлениям.
**Уважаемые читатели!** Планируете ли вы использовать пакет `datatable` в своих проектах?
[](https://ruvds.com/ru-rub/#order)
[](https://ruvds.com/ru-rub/news/read/104) | https://habr.com/ru/post/455507/ | null | ru | null |
# Laravel 7
Введение
--------
3 марта команда Laravel официально выпустила Laravel 7.0. Как указано в политике поддержки Laravel, это одно из основных обновлений. Хоть этот релиз и не обозначен как LTS, в нём всё равно представлено много новых замечательных функций и исправлений. Обновление будет предоставлять исправление ошибок до 3 сентября 2020 года, а исправления безопасности в течение 1 года до 3 марта 2021 года.
Новые Функции в Laravel 7
-------------------------
### X Blade
Laravel 7 доработали шаблонизатор Blade, добавив совершенно новые X функции. Этот пакет предоставляет простой способ рендеринга пользовательских компонентов HTML в ваших представлениях Blade.
Ранее вы должны были писать так:
```
@include('myAlert', ['type' => 'error', 'message' => $message])
```
Сейчас, используя x blade, это будет выглядеть так:
```
```
### Настраиваемые Заглушки
Для того, чтобы настроить файлы-заглушки, вам нужно опубликовать их:
`php artisan stub:publish`
После запуска этой команды в ваш проект будет добавлен новый каталог.
### Свободные Операции над Строками
Ранее множество полезных функций для работы со строками предоставлял класс llluminate\Support\str. Laravel 7 теперь предлагает более объектно-ориентированную, свободную библиотеку для работы со строками, построенную поверх этих функций.
Сейчас вы можете создать объект llluminate\Support\Striangable с помощью метода Str::of. Затем к объекту можно применить множество методов для манипулирования строкой:
```
return (string) Str::of(' Laravel Framework 6.x ')
->trim()
->replace('6.x', '7.x')
->slug();
```
### Zttp для HTTP-клиентов
Zttp — это простая обёртка вокруг Guzzle, задача которой обеспечить максимально приятный опыт разработки при наиболее распространённых сценариях использования. Zttp — новый пакет PHP, который представляет собой обёртку вокруг Guzzle, предназначенную для создания выразительного синтаксиса и упрощения общих случаев использования.
### Laravel Airlock
Laravel Airlock — это новый пакет, который обеспечивает лёгкую систему аутентификации для одностраничных приложений (SPA), мобильных приложений и простых API на основе токенов. C помощью пакета Airlock пользователь вашего приложения может создать несколько токенов API для своей учётной записи. Эти токены могут предоставлять способности/области действия, определяющие, какие действия разрешено выполнять токенам.
### Несколько Почтовых Драйверов
Laravel 7 позволяет настроить несколько почтовых драйверов для одного приложения. Каждый почтовый драйвер (mailer), настроенный в конфигурационном файле mail, может иметь свои собственные параметры и даже уникальный “транспорт”, позволяющий вашему приложению использовать различные почтовые службы для отправки определённых электронных сообщений.
### Кастомные Eloquent Касты (Custom Eloquent Casts)
Классы, которые реализуют этот интерфейс, должны определять методы get и set. Метод get отвечает за преобразование необработанного значения из базы данных в приведённое значение, тогда как метод set должен преобразовать приведённое значение в необработанное значение, которое можно сохранить в базе данных. В качестве примера, мы повторно реализуем встроенный каст json как пользовательский:
```
php
namespace App\Casts;
use Illuminate\Contracts\Database\Eloquent\CastsAttributes;
class Json implements CastsAttributes
{
/**
* Cast the given value.
*
* @param \Illuminate\Database\Eloquent\Model $model
* @param string $key
* @param mixed $value
* @param array $attributes
* @return array
*/
public function get($model, $key, $value, $attributes)
{
return json_decode($value, true);
}
/**
* Prepare the given value for storage.
*
* @param \Illuminate\Database\Eloquent\Model $model
* @param string $key
* @param array $value
* @param array $attributes
* @return string
*/
public function set($model, $key, $value, $attributes)
{
return json_encode($value);
}
}
</code
```
### Поддержка Общего Доступа к Ресурсам (CORS)
Laravel может автоматически отвечать на запросы CORS OPTION с настроенными вами значениями. Все параметры CORS могут быть настроены в вашем конфигурационном файле CORS, а запросы OPTIONS будут автоматически обрабатываться связующим программным обеспечением HandleCors, которое по умолчанию включено в ваш глобальный стек связующего ПО.
### Касты Времени в Запросах
Иногда нужно применить преобразование при выполнении запроса, например, при выборе необработанного значения из таблицы. Давайте рассмотрим следующий запрос:
```
$users = User::select([
'users.*',
'last_posted_at' => Post::selectRaw('MAX(created_at)')
->whereColumn('user_id', 'users.id')
])->withCasts([
'last_posted_at' => 'date'
])->get()
```
### Итоги
Должен сказать, что это обновление делает Laravel 7 ещё проще и приятнее в использовании. Так много долгожданных функций, наконец, реализованны и готовы к использованию.
Я думаю, что это отличный релиз, и с нетерпением жду следующие обновления. Надеюсь, что вы чувствуете то же самое! | https://habr.com/ru/post/502058/ | null | ru | null |
# То, что вам никто не говорил о z-index
Проблема z-index в том, что многие просто не понимают, как он работает.
Всё, описанное ниже, есть в спецификации W3C. К сожалению, не все её читают.
#### Описание проблемы:
Итак, пусть у нас есть HTML код, состоящий из 3 ```````элементов.
Каждый из них внутри себя содержит по одному . А каждый , в свою очередь, имеет свой фон: красный, зеленый и синий, соответственно. Плюс ко всему, каждый позиционирован абсолютно левого верхнего края документа таким образом, что он немного перекрывает собой следующий за ним . Первый имеет z-index`, равный 1, у остальных двух ``z-index` не задан.
Ниже представлен HTML код с базовым css оформлением.
```
Red
Green
Blue
```
```
.red, .green, .blue {
position: absolute;
}
.red {
background: red;
z-index: 1;
}
.green {
background: green;
}
.blue {
background: blue;
}
```
Пример на [jsfiddle](http://jsfiddle.net/n3VhG/)
**Задача:** сделать так, чтобы красный ``````
был позади синего и зеленого, при этом не нарушая ни одно из следующих правил:
* Нельзя менять HTML разметку
* Нельзя менять/добавлять z-index к элементам
* Нельзя менять/добавлять позиционирование к элементам
#### Решение:
Решение состоит в том, чтобы добавить прозрачность чуть меньше единицы первому (родителю красного ).
Вот css, иллюстрирующий это:
div:first-child {
opacity: .99;
}
```
Пример на [jsfiddle](http://jsfiddle.net/zB2Fb/)
Хм, что-то тут не так. Причем тут вообще прозрачность? Каким образом она может влиять на порядок перекрытия элементов? Вы думаете так же? Добро пожаловать в клуб!
Надеюсь, во второй части статьи всё встанет на свои места.
#### Порядок наложения элементов:
Z-index кажется очень простым: чем значение больше, тем ближе к нам будет элемент, т.е. элемент с z-index 5 будет перекрывать собой элемент с z-index 2, верно? На самом деле нет.
Это и есть проблема z-index. Всё кажется настолько очевидным, что большинство разработчиков не уделяют достаточно времени для изучения этого вопроса.
Любой элемент в HTML документе может быть либо на переднем, либо на заднем плане. Это известно всем. Правила, задающие этот порядок четко описаны в спецификации, но, как я уже говорил выше, не все в полной мере их понимают.
Если свойства z-index и позиционирование не заданы явно, всё просто: порядок наложения равен порядку следования элементов в HTML. (На самом деле [всё немного сложнее](http://www.w3.org/TR/CSS2/zindex.html), но пока вы не будете использовать отрицательные значения отступов для перекрытия строчных элементов, вы не будете сталкиваться с крайними случаями)
Если вы явно указываете позиционирование элементам (и их детям), то такие элементы будут перекрывать собой элементы без явно заданного свойства позиционирования. (Говоря «явно указываете позиционирование» – я имею ввиду любое значение, кроме статического, например: абсолютное, или относительное).
И наконец, случай, когда z-index задан. Для начала, вполне естественно предполагать, что элементы с большим z-index будут находиться выше элементов с меньшим z-index, а любой элемент с установленным z-index будет находится выше элемента без установленного z-index, но это не так. Во первых, z-index учитывается только на явно позиционированных элементах. Если вы попробуете установить z-index на не позиционированный элемент, то ничего не произойдет. Во вторых, значения z-index могут создавать контексты наложения. Хм, всё стало намного сложнее, не так ли?
#### Контекст наложения
Элементы с общими родителями, перемещающиеся на передний или задний план вместе известны как контекст наложения. Понимание контекста наложения является ключом к пониманию z-index и порядка наложения элементов.
Каждый контекст наложения имеет свой корневой элемент в HTML структуре. В момент формирования нового контекста на элементе, все дочерние элементы так же попадают в этот контекст и занимают своё место в порядке наложения. Если элемент располагается в самом низу одного контекста наложения, то никаким мыслимым и немыслимым образом не получится отобразить его над другим элементом в соседнем контексте наложения, располагающимся выше по иерархии, даже с установленным z-index равным миллиону.
Новый контекст может быть сформирован в следующих случаях:
* Если элемент – корневой элемент документа ( `элемент)`
Если элемент позиционирован не статически и его значение z-index не равно auto
Если элемент имеет прозрачность менее 1`````````` | https://habr.com/ru/post/166435/ | null | ru | null |
# Hg Init: Часть 1. Переобучение для пользователей Subversion
##### Hg Init: Учебное пособие по Mercurial.
Mercurial — это современная распределенная система контроля версий с открытым кодом. Эта система — заманчивая замена для более ранних систем вроде Subversion. В этом простом учебном пособии в шести частях Джоэль Спольски ([Joel Spolsky](http://www.joelonsoftware.com/)) рассказывает о ключевых принципах Mercurial.
Если вы использовали Subversion, то Mercurial будет непонятным. Эта часть рассказывает о главных отличиях при работе с Mercurial. Если вы никогда не использовали Subversion, то можете просто [пропустить эту часть](http://habrahabr.ru/blogs/development_tools/108658/).
#### Часть 1. Переобучение для пользователей Subversion
В каком же я был смятении, когда программисты в моей компании решили сменить Subversion на Mercurial!
Для начала, я начал приводить всевозможные тупые причины, по которым нам не надо ничего менять. «Мы должны хранить репозиторий на центральном сервере, так безопаснее», — сказал я. Знаете что? Я был неправ. При работе с Mercurial у каждого разработчика на жестком диске хранится полная копия репозитория. Это, на самом деле, *безопаснее*. В любом случае, почти в каждой команде, использующей Mercurial, центральный репозиторий тоже существует. И вы можете делать резервное копирование этого репозитория со всей необходимой одержимостью. А еще можете устроить трехступенчатую защиту с [Сайлонами](http://ru.wikipedia.org/wiki/%D0%A1%D0%B0%D0%B9%D0%BB%D0%BE%D0%BD%D1%8B), Штурмовиками и прелестными [лабрадудлами](http://en.wikipedia.org/wiki/Labradoodle) или что там требует ваш IT-отдел.
«Проблема с распределенными системами контроля версий в том, что они позволяют слишком легко делать ветки (branch)», — сказал я. «А ветки всегда приносят проблемы». Получается, что тут я тоже был неправ. Волна такая пошла. Ветки несут проблемы *при работе с Subversion*, потому что *Subversion* не хранит достаточно информации для того, чтобы *слияние* (merge) нормально работало. В Mercurial слияние безболезненно и легко, а потому ветвление распространено и безвредно.
Потом я сказал: «Хорошо, я буду использовать эту систему, но не ждите, что я смогу в ней разобраться». И я попросил Джейкоба сделать для меня шпаргалку, в которой будет все, что я обычно делал в Subversion, с указанием аналогов в Mercurial.
Я могу показать вам эту шпаргалку, но не буду, потому что она несколько месяцев мешала моим мозгам перестроиться.
Получается что, если вы использовали Subversion, то ваша голова немного… Э-э-э, как бы помягче сказать? Вы ранены во всю голову! Нет, не получилось. Вам нужно переобучение. Я ходил таким раненным полгода и думал, что Mercurial *более сложен*, чем Subversion. Но это потому, что я не понимал, как новая система на самом деле работала. Как только я понял, как она работает, оказалось — опа! да это достаточно просто.
Вот я и написал для вас это пособие, в котором очень старался *не* объяснять все в терминах Subversion, потому что хватит уже раненных во всю голову. Их и так достаточно. Вместо этого, для тех, кто переходит на Mercurial с Subversion, я написал эту часть в начале пособия, которая постарается аннулировать как можно больше вреда, чтобы вы могли изучить Mercurial с чистого листа.
**Если вы никогда не использовали Subversion, то можете перейти к следующей статье ([«Основы Mercurial»](http://habrahabr.ru/blogs/development_tools/108658/)) и ничего не упустите.**
Готовы? Хорошо, начнем с короткого опроса.
> **Вопрос первый:** Вы всегда с первого раза пишите идеальный код?
Если вы ответили «Да» на первый вопрос, то вы врун и жулик. Получите «банан» и приходите на пересдачу.
Новый код глючен. Требуется время, чтобы он начал прилично работать. А пока этот код может повредить остальным разработчикам в команде.
И вот, как работает Subversion:
* Когда вы вносите новый код в репозиторий, его получают все.
Так как весь новый код, который вы пишите, содержит баги, то у вас есть выбор.
* Вы можете вносить глючный код и сводить людей с ума, или
* Вы можете придерживать новый код до тех пор, пока полностью его не отладите.
Subversion постоянно ставит вас перед этим ужасным выбором. Или репозиторий полон глючного кода, потому что содержит новый код, который только что написан, *или* новый код, что только что написан, не добавлен в репозиторий.
Как пользователи Subversion, мы настолько привыкли к этой дилемме, что трудно представить себе систему, где эта дилемма не существует.
Команда, использующая Subversion, часто днями или неделями ничего не добавляет в репозиторий. В таких командах новички боятся залить что-то в репозиторий из-за опасения поломать билд, или разозлить Майка, ведущего разработчика, или по сходным причинам. Майк однажды так рассердился из-за изменений, которые поломали билд, что ворвался к практиканту, смахнул все с его стола и проорал: «Это твой последний день!». Этот день не был последним, но бедный практикант практически намочил штаны.
Все эти страхи и опасения означают, что люди пишут код неделя за неделей *не используя преимуществ системы контроля версий*, а затем ищут кого-нибудь опытного, чтобы внести код в репозиторий. И для чего репозиторий, если им нельзя пользоваться?
Вот простая иллюстрация жизни с Subversion:
При работе с Mercurial *у каждого разработчика свой собственный репозиторий, живущий у них на компьютере:*
Так что вы можете вносить изменения в свой репозиторий и пользоваться всеми благами системы контроля версий, когда захотите. Каждый раз, чуть улучшив код, вы можете вносить его в репозиторий.
Когда код надежен, и вы хотите дать другим его использовать, вы проталкиваете (push) ваши изменения из своего репозитория в центральный репозиторий. Из центрального репозитория каждый вытягивает (pull) общие изменения и рано или поздно все получат ваш новый код. Когда он готов.
*Mercurial разделяет момент внесения кода в репозиторий и момент получения этого кода всеми остальными.*
И это означает, что вы можете коммитить (`hg com`), но все остальные не получат ваши изменения. Когда у вас накопятся изменения, которые вас устраивают, которые стабильны и все круто, вы проталкиваете (`hg push`) их в главный репозиторий.
##### Еще одно большое концептуальное отличие
Вы знаете, что у каждой улицы есть название?
Ну, оказывается что в Японии это не совсем так. Японцы обычно просто [нумеруют кварталы](http://sivers.org/jadr) между улицами и только очень, очень важные улицы имеют названия.
У Subversion и Mercurial есть сходное различие.
В Subversion мыслят *ревизиями*. Ревизия — это то, как выглядит вся файловая система в определенный момент времени.
В Mercurial вы мыслите *наборами изменений (changesets)*. Набор изменений — это четкий список изменений между двумя соседними ревизиями.
Шесть того или полдюжины этого — в чем разница?
Вот в чем разница. Представьте, что вы и я вместе работаем над каким-то кодом. И мы сделали ветки этого кода, и каждый пошел на свое место и сделал много-много независимых изменений в коде, так что ветки достаточно сильно разошлись в разные стороны.
Когда нам нужно сделать слияние, Subversion смотрит на обе ревизии — мой измененный код и ваш измененный код — и пытается угадать, как слепить их вместе в один большой страшный бардак. Обычно Subversion это не удается, и получаются длинные списки конфликтов («merge conflicts»), которые на самом деле не конфликты, а просто места, в которых система не смогла разобраться в наших изменениях.
Для сравнения, если мы независимо работали в Mercurial, то система сохраняла *серии изменений*. Таким образом, когда мы хотим сделать слияние кода, у Mercurial на самом деле гораздо больше информации: система знает, *что каждый из нас изменил*, и может *заново применить эти изменения* вместо того, чтобы смотреть на конечный вариант и пытаться угадать, как все это собрать воедино.
Если, для примера, я немного изменил какую-то функцию и перенес ее куда-то, то Subversion на самом деле не помнит этого. Так что когда дело дойдет до слияния, она просто может решить, что в коде из ниоткуда появилась новая функция. В то же время, Mercurial запомнит: функция изменилась, функция переместилась. Это значит, что если вы тоже поменяли эту функцию, то вероятность того, что Mercurial успешно проведет слияние наших изменений, гораздо больше.
Так как Mercurial мыслит в терминах наборов изменений, вы можете делать интересные вещи с этими наборами изменений. Вы можете дать попробовать эти изменения другу вместо того, чтобы вносить эти изменения в центральный репозиторий и вынуждать всех ими пользоваться.
Если все это кажется вам немного запутанным — не переживайте. По мере чтения этого пособия все обретет ясный смысл. В данный момент самое главное, что вам нужно знать: из-за того, что Mercurial оперирует наборами изменений, а не ревизиями, *слияние кода в Mercurial работает гораздо лучше, чем в Subversion*.
И это значит, что *вы можете свободно делать ветки*, потому что слияние не будет кошмаром.
Хотите узнать кое-что забавное? Почти у каждой команды, использующей Subversion, с членами которой я разговаривал, есть некий вариант одной и той же истории. История настолько часто встречается, что я просто назову ее «Главной историей про Subversion». Вот эта история: в определенный момент они попробовали сделать ветку в развитии кода. Обычно для того, чтобы версия, которую отдали клиентами, была отделена от версии, с которой возятся разработчики. И все рассказывали мне, что когда они попробовали сделать это, то все было отлично *до момента, когда им нужно было сделать слияние*. И слияние было кошмаром. То, что должно было быть пятиминутным процессом, превратилось в шесть программистов вокруг одного компьютера, работавших две недели, пытаясь вручную внести каждый багфикс из стабильной ветки в ветку разработчиков.
И почти в каждой команде мне сказали, что они поклялись «больше никогда» и отказались от веток. И теперь они делают так: каждая новая фича в большом `#ifdef` блоке. Так они могут работать всегда в стволе репозитория, а клиенты никогда не получают новый код пока он не отлажен, и, откровенно говоря, это нелепо.
Отделять стабильный и разрабатываемый код — *это именно то, что система контроля версий должна позволять вам делать*.
С переходом на Mercurial, вы можете даже не осознать этого, но ветвление снова станет возможным и вам не нужно будет ничего опасаться.
Это означает, что у вас могут быть командные репозитории, где небольшая команда программистов работает над новой фичей, и, когда все готово, сливает свои изменения в главный репозиторий. И *это работает*!
Это означает, что у вас могут быть репозитории для службы тестирования, где команда тестеров пробует новый код. Если он работает, то служба тестирования вносит изменения в центральный репозиторий, что, в свою очередь, означает, что в центральном репозитории всегда надежный протестированный код. И *это работает*!
Это означает, что вы можете проводить эксперименты в отдельных репозиториях, и, если эксперименты удачны, сливать изменения в главный репозиторий, а если неудачны, то просто выбрасывать их. И *это работает*!
##### И последнее большое концептуальное отличие
Последнее важное концептуальное отличие между Subversion и Mercurial не такое уж и важное, но оно может поставить вас в неудобное положение, если вы не будете про него знать. Вот оно:
Subversion, по сути, система контроля изменений для *файлов*, а в Mercurial контроль изменений применяется ко всему каталогу, включая все подкаталоги.
Главным образом, это проявляется так: в Subversion, если вы находитесь в подкаталоге и вносите свои изменения в репозиторий, то вносятся только изменения из этого подкаталога и всех его подкаталогов. Это может привести к тому, что вы забудете внести изменения из другого подкаталога. А в Mercurial все команды всегда применяются ко всему дереву каталогов. Если ваш код находится в **c:\code**, то когда вы выполняете `hg commit`, то можете находиться в **c:\code** или *в любом подкаталоге* — результат будет одним и тем же.
Это не так уж важно, но если вы привыкли иметь один гигантский репозиторий на всю компанию, в котором некоторые люди работают только с определенными подкаталогами, которые их касаются, то знайте, что это не самый лучший метод при работе с Mercurial. Вам лучше иметь много меньших по размеру репозиториев на каждый проект.
##### И напоследок...
Теперь часть, где вы просто должны поверить мне на слово.
Mercurial лучше, чем Subversion.
Лучше, если работать над кодом в команде. Лучше, если работать над кодом в одиночку.
Просто *лучше*.
И, попомните мои слова, если вы поймете как работает Mercurial, и будете работать так, как работает Mercurial, и не будете бороться с этой системой, и не будете пытаться делать с Mercurial все так же, как делали в Subversion, а вместо этого научитесь работать так, как от вас ожидает Mercurial, то будете счастливы, успешны, упитаны и всегда сможете найти пульт от телевизора.
И поначалу вас будет искушать мысль — я знаю, будет, — бросить Mercurial и вернуться к Subversion. Потому что будет странно, словно вы живете в чужой стране, и вас будет тянуть на родину, и вы будете придумывать всевозможные оправдания вроде того, что будете заявлять, что в Mercurial рабочие копии занимают слишком много места, что есть туфта, так как на самом деле они занимают меньше места, чем в Subversion. Это правда!
И затем вы вернетесь к Subversion, потому что вы пробовали делать ветки так же, как в Subversion, и запутались, и получилось не очень, потому что вы на самом деле должны были делать ветки как в Mercurial, клонируя репозитории, не пытаться делать так, как работало в Subversion, а научиться принятому в Mercurial способу, который, поверьте мне, *работает*.
И после этого вы попросите Джейкоба, или кто там у вас эквивалент Джейкоба в вашем офисе, дать вам шпаргалку «От Subversion к Mercurial», и вы потратите три месяца, думая, что `hg fetch` это как `svn up`, не понимая, на самом деле, что делает `hg fetch`, и однажды все пойдет не так, и вы будете винить Mercurial, хотя вам стоило бы винить себя за непонимание того, как работает Mercurial.
Я знаю, вы так и сделаете, потому что это то, что я сделал.
Не делайте ту же ошибку. Изучите Mercurial, доверьтесь ему, разберитесь, как делать все в его стиле, и вы продвинетесь на целое поколение в области систем контроля версий. Пока ваши конкуренты тратят неделю на разрешение конфликтов, которые возникли после того, как поставщик обновил библиотеку, вы напечатаете `hg merge` и скажете себе «О, боже, это круто, это просто сработало.» И Майк расслабится и поделится косячком с практикантами, и наступит весна, и молодежь из соседнего колледжа сменит пуховики на коротенькие надорванные футболки, и жизнь будет хороша.
Продолжение здесь:
[Hg Init: Часть 2. Основы Mercurial](http://habrahabr.ru/blogs/development_tools/108658/) | https://habr.com/ru/post/108443/ | null | ru | null |
# Мониторинг Apache Ignite. Сделали правильно
Мы сделали 2 подсистемы внутри Apache Ignite.
В статье расскажу про их архитектуру:
* Как сделали подсистему метрик и подсистему system view.
* Что сделано и что собираемся сделать?
Всем привет! Меня зовут Николай Ижиков. Я работаю в Сбербанк Технологии над развитием Open Source продуктов.
**Замечание 1**: «сделано» означает, что эта функциональность доступна в [master Apache Ignite](https://github.com/apache/ignite/), можно собрать и посмотреть как все работает. Функционал попадёт в релиз 2.8 Apache Ignite, который будет выпущен в начале 2020 года.
**Замечание 2**: Статья про архитектуру, не будет конкретных чисел, которые понадобятся для мониторинга Apache Ignite.
**Замечание 3**: Функционал будет доступен в релизе 2.8, который случится скоро, а может-быть даже раньше.
[Apache Ignite](https://ignite.apache.org/) распределенная in-memory платформа. Предоставляет много API: для кеширования, распределённых вычислений, сервисов (построения микросервисной архитектуры), обеспечивает транзакционность.
Зачем
-----
Допустим, у вас есть система и она как-то работает в проде. К вам обязательно придут администраторы и спросят: "А как посмотреть что происходит внутри, как система себя ведёт? Мы хотим узнать о происходящих процессах, до того момента как они приведут к падению или изменению поведения, которое невозможно скрыть." По сути вопросы сводятся к следующим:
* *Что происходит?* — Что происходит внутри кластера, внутри каждой ноды, какие процессы и как они себя ведут.
* *Что внутри?* — прикладная система для администратора часто является чёрным ящиком, который выполняет действия, создаются объекты: кеши, таблицы, выполняются транзакции, выполняются распределенные задачи. Администратор хочет знать, что внутри системы.
* *Что тормозит?* — Какой запрос к системе самый ресурсоёмкий на данный момент.
* *Что будет тормозить?* — Если мы подадим "вот такую" нагрузку на систему — как она себя будет вести?
Для ответов на часть этих вопросов необходимо разработать подсистему мониторинга.
В случае распределенной системы мониторинг это:
* Наблюдение параметров ноды кластера.
* Отслеживание изменения во времени — графики, которые можно построить по данным с ноды.
* Данные о происходящих внутри процессах. Мы хотим их измерить: время работы, потребляемые ресурсы.
* Данные об объектах и их параметрах: Какие есть таблицы, кеши, сервисы, задачи, транзакции.
Подсистема мониторинга нужна, с этим определились. Но, перед тем как разрабатывать мы должны понять, что у нас есть уже. Получилось следующее:
* Есть много API и много подсистем: transaction manager, cache manager, etc.
* Существуют процессы без метрик ~~из-за лени разработчиков~~ по историческим причинам.
* Метрики выгружаются через различные API: JMX, SQL, Java. Нужна обратная совместимость с этими API.
Дизайн
------
Картина идеального мира:
* **Легко сделать новую метрику**: Почему так сложилось, что метрик в системе недостаточно? Причина в сложности кода. Чтобы сделать новую метрику надо поправить несколько интерфейсов, пробросить в нескольких местах переменные, завести новые методы, потом новую метрику где-то посчитать. Хочется этот процесс облегчить, чтобы разработчики могли легко добавить новую метрику в систему.
* **Ноль усилий по «доставке» до администратора**: после разработки метрики, администраторы могут анализировать ее через любой поддерживаемый API.
* **Интеграция с системами мониторинга**: Мы хотим поддержать протоколы jmx, sql, http(Prometheus) из коробки, а также интегрироваться с любыми системами мониторинга, которые использует конечный пользователь.
* **Минимум конфигурации**: никто не любит конфигурировать, ожидается что при установке из коробки все должно работать.
Необходимо уточнить как происходит работа в Open Source community над такими большими и объемными задачами. У нас есть процесс, который называется [Ignite Enhancement Proposal (IEP)](https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=112820392), автор формулирует предлагаемые изменения, мотивацию, API, фазы изменения.
Было предложено несколько важных и долгоиграющих решений по дизайну:
#### Локальные
Ignite распределённая система: есть глобальное состояние, поддерживаемое между нодами. В текущей реализации есть глобальные метрики, которые отражают состояние всего кластера. С моей точки зрения, это неверный подход. Если метрика должна быть глобальной это означает, что Ignite должен обеспечивать консистентность подсчета этой метрики по всему кластеру. Что ведет к тому, что Ignite выполняет не свойственные для себя функции — правильный подсчет метрик и поддержание их в актуальном состоянии. Мое глубокое убеждение — метрики должны быть локальными. После их сбора в системе агрегации метрик (prometheus, zabbix) мы можем вычислить глобальное состояние.
#### Иерархические
В Ignite много подсистем. Также Ignite должен предоставлять информацию о своём окружении: jvm, диск, памяти, версия ОС и др. Каждая из подсистем Ignite предоставляет свой набор метрик. Есть подсистемы, внутри которых так же есть иерархия.
Пример: кеши — хочется смотреть метрики по каждому кешу отдельно.
Так появляется несколько уровней иерархии: кеши, data region'ы, сетевые сообщения от конкретной ноды и т.д. Иерархическая структура отображена в названии метрики, слева направо идут уровни иерархии, разделенные точкой.
Пример: `io.dataregion.myregion.TotalAllocatedPages` — количество страниц выделенных для Data Region с именем "myregion".
Реализация
----------
В коде реализовано так:
* `Metric`, `Gauge` — конкретное число которое вычисляется при работе ноды.
* `MetricRegistry` — набор (группа, реестр) метрик.
* `MetricExporterSpi` — экспортер метрик во внешний мир.
* `ReadOnlyMetricRegistry` — интерфейс, который доступен для exporter’о-в. read only access + listeners.
* `GridMetricManager` — управление всем хозяйством.
Выделено несколько типов метрик:
* `Metric` — счётчик. Обновляется в процессе работы ноды.
Примеры: `LongAddterMetric`, `DoubleMetricImpl`, `ObjectMetricImpl`.
* `Gauge` — значение. Вычисляется в момент обращения, обертка над Supplier. Поддерживать актуальное состояние счетчика не всегда просто. Бывает, проще написать алгоритм, который вычисляет значение.
Примеры: `LongGauge`, `DoubleGauge`, `ObjectGauge`.
* `HistogramMetric` — интервалы + количество событий в интервале. Гистограмма считает количество событий, значение которых попало в определенный интервал.
Пример: количество запросов, обработанных быстрее 250 мсек, 500 мсек, 1 сек и все остальные.
* `HitRateMetric` — количество событий за последние X мсек.
Пример: количество страниц памяти, выделенных за последнюю минуту.
`MetricExporterSpi` — каждый из экспортеров работает независимо, по своему протоколу. Он выгружает в любую систему свои метрики, что обеспечивает универсальность и гибкость. Из коробки поддерживаются JMX, SQL, Log, [OpenCensus](https://opencensus.io/).
#### Простота заведения
```
GridMetricManager mmgr = ...;
MetricRegistry mreg = mmgr.registry("io.dataregion." + name);
LongAdderMetric replacedPages = mreg.longAdderMetric("PagesReplaced",
"Number of pages replaced from last restart.");
//....
replacedPages.increment();
```
#### Красивые картинки
**JMX**
**SQL**
Кажется, что на вопрос "Что происходит?" мы ответили.
Осталось ~~всего лишь~~ реализовать все нужные метрики.
System View — Что внутри?
-------------------------
При наличии опыта работы с реляционными БД все понимают идею — везде есть системные представления. Мы назвали сущность system view, но можем показывать ее не только с помощью SQL. Поддерживаются любые протоколы (из коробки еще JMX).
##### Дизайн
* `SystemView` — именованный список объектов (таблица). Примеры: кэши, сервисы, compute task'и, sql table и т. д.
* `SystemViewExporterSpi` — экспортер во внешний мир.
* `ReadOnlySystemViewRegistry` — интерфейс для exporter'ов. read only access + listeners.
* `GridSystemViewManager` — управление всем хозяйством
##### Реализация
Особенности:
* Данные уже внутри системы. Понятно, что если система работает с кешами, то она про них знает и где-то хранит. Мы должны пользователю это описание вернуть.
* Нужен минимальный overhead. Мы не должны нагружать систему отдавая внутренние данные.
* Нужен быстрый обход по строкам и столбцам. Работаем с табличными данными. Каждый протокол выгружает описание столбцов в собственном формате.
При экспорте нужно знать схему данных: столбцы и их типы. Эта информация есть в java-классе. Задача выгрузки схемы формулируется следующим образом:
> Есть пара десятков POJO. Их структура известна, новых классов не будет. Нужен быстрый проход по свойствам. Хочется поддерживать порядок обхода. Вопрос: Можно ли придумать более быстрый способ чем reflection?
Я сделал кодогенерацию:
* Вся информация есть в compile time.
* Генерируемый код очевидный и без условий.
* Можем задать порядок обхода.
* Запускаем генератор при сборке.
Что получилось:
Интерфейс([SystemViewRowAttributeWalker.java](https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/spi/systemview/view/SystemViewRowAttributeWalker.java)), который умеет обходить свойства объекта для формирования схемы и для выгрузки данных. Реализации интерфейса [генерируются](https://github.com/apache/ignite/blob/master/modules/codegen/src/main/java/org/apache/ignite/codegen/SystemViewRowAttributeWalkerGenerator.java) автоматически. Заведение system view становится очень простым. После заведения представление становится доступно всем экспортерам.
**Пример**
```
ctx.systemView().registerView(CACHES_VIEW, CACHES_VIEW_DESC,
new CacheViewWalker(),
registeredCaches.values(),
CacheView::new);
ctx.systemView().registerView(CACHE_GRPS_VIEW, CACHE_GRPS_VIEW_DESC,
new CacheGroupViewWalker(),
registeredCacheGrps.values(),
CacheGroupView::new);
```
Reflection тормозит — как не удивительно, но не для всех это очевидно. Для обсуждения на dev-list я написал [JMH benchmark](https://gist.github.com/nizhikov/fa1f005047c5396d93e547a210d06a94). Для reflection он берет список методов из класса. В случае walker он вызывает конкретные методы. Walker работает в 4 раза быстрее.
#### Красивые картинки
**SQL**
**JMX**
Кажется, что на вопрос "Что внутри?" мы ответили.
Осталось ~~всего лишь~~
-----------------------
* **Документация**: сейчас документации нет, разработчики не любят ее писать и откладывают ее на последний момент. ~~Я такой же~~.
* **Настройки** для взрослого мониторинга «из коробки» (prometheus, zabbix)
* **Трейсинг**. В случае мониторинга мы отслеживаем общие процессы, общее поведение ноды. В случае трейсинга — хотим получить информацию о параметрах единственного запроса в привязке к пользовательской активности.
* **Отчёт производительности**. Пользователи Oracle и других реляционных СУБД привыкли что есть возможность включить сбор статистики, подать нагрузку, и получить в удобном виде отчёт производительности: какие запросы выполнялись, сколько нагрузки они сгенерили, какие транзакции были, проблемы.
* **Контроль пользовательского кода** — в Ignite есть много мест, которые позволяют пользователю задать свой код для выполнения задач. Хочется предоставить возможность администратору контролировать как быстро работает пользовательский код. Задаётся некий threshold «compute задача не должна работать дольше 30 сек», и если она работает дольше, то вы получаете уведомление.
Полезные ссылки
---------------
* [исходники](https://github.com/apache/ignite)
* dev@ignite.apache.org
* user@ignite.apache.org
Приходите! У нас практически русскоязычное community, почти все контрибьютеры из России, поэтому вы можете легко влиться и сделать вклад в Open Source.
**Материал со звездочкой**
Сейчас на dev-листе идет очень интересная [дискуссия](http://apache-ignite-developers.2346864.n4.nabble.com/Internal-classes-are-exposed-in-public-API-tt45146.html) на тему "А правильно ли мы сделали?", а также по процессу [замены устаревшего API](http://apache-ignite-developers.2346864.n4.nabble.com/DISCUSS-Public-API-deprecation-rules-tt45647.html)
Презентация — <https://www.highload.ru/moscow/2019/abstracts/6111>
Видео: | https://habr.com/ru/post/486288/ | null | ru | null |
# Вышла Magento 1.7.0.0
24 апреля мир увидел очередную версию популярного движка для электронной коммерции — Magento 1.7.0.0
###### Основные улучшения по сравнению с предыдущими версиями:
* Оптимизирована слоистая навигация
* Добавлена поддержка CAPTCHA для администратора и пользователей
* Добавлены различные базовые цены для групп клиентов
* Добавлена автоматическая генерация купонов на скидки
* Улучшение резервного копирования и отката функциональности
* Добавлено валидация налога для Евросоюза
* Реализован DHL в Европе
* Добавлены REST API
* Улучшения мобильной темы
* Реализован интерфейс Cookie для ограничение функциональности
* Добавлены новые методы оплаты
Также доступны различные опции резервного копирования, поддержка memcached и многое другое.
Для быстрой установки через SSH подготовил необходимые команды:
`wget www.magentocommerce.com/downloads/assets/1.7.0.0/magento-1.7.0.0.tar.gz
tar -zxvf magento-1.7.0.0.tar.gz
mv magento/* magento/.htaccess magento/.htaccess.sample .
rmdir magento
chmod -R o+w media var
chmod o+w app/etc
mkdir media/catalog media/catalog/product media/catalog/category
chmod o+w media/catalog
chmod o+w media/catalog/product
chmod o+w media/catalog/category`
Полный перечень нововведений Вы сможете найти на [официальном сайте](http://www.magentocommerce.com/download/release_notes#Release%20Notes%20-%20Magento%201.7.0.0%20%28Apr%2024,%202012%29) Magento. | https://habr.com/ru/post/142764/ | null | ru | null |
# Стиль именования коммитов
Про многие моменты разработки есть очень много информации. Как писать комментарии, как именовать классы, методы, какие паттерны использовать и т.д. и т.п. Но есть одна область, в которой многие даже и не задумываются о том, что можно что-то улучшить — это написание коммитов.
Зачем это вообще нужно? Чтобы экономить время и нервы, не больше и не меньше. Это мы еще обсудим чуть позже, а пока рассмотрим как же вообще именуются коммиты.
#### Общий стиль
Если пройтись по тем же коммитам с GitHub, то можно увидеть довольно обширное количество вариантов написания коммитов. Основные рекомендации по написанию можно выделить такие:
##### Что сделать + для какой сущности + подробности (необязательно)
Старайтесь найти единый стиль для коммитов и придерживаться его. Для себя я нашел удобным такой стиль, когда я сначала указываю что я делаю. Например, `add`. После этого я указываю что-то, над чем я произвожу действие. Например, `ui-bootstrap.js dependency`. В большинстве случаев такой записи более чем достаточно. Если есть еще какая-то пояснительная надпись, то ее лучше вынести в отдельную большую запись, о чем мы еще поговорим. Если запись маленькая, но очень нужная, то можно дописать её прямо к коммиту. Но лучше еще раз задуматься, действительно ли нужна эта надпись, или она будет привлекать ненужное внимание.
Бывает так:
```
dependency for managing ui-bootstrap.js components was added here on 18.06.2013 by olegafx
```
Но лучше:
```
add ui-bootstrap.js dependency
```
##### Большие сообщения в коммите
Так что же делать с большими сообщениями? Конечно, писать. Например, это может быть важная информация с сообщением, что ваш коммит ломает предыдущую функциональность, заменяя её очень крутой и простой новой. Такое бывает даже в самых крупных проектах, поэтому очень важно рассказать людям как сделать так, чтобы всё заработало вновь.
Проще всего добавить пустую строку под основным сообщением коммита и начать вводить информацию уже там. Кстати, здесь уже можно писать глаголы в прошедшем времени, если очень хочется. Например:
```
replace twitter-bootstrap.css with pure.css
Made UI much cleaner.
BREAKING CHANGE. You need to use new class-names for grid-related elements.
```
##### Пишем сообщение с маленькой буквы
Нет никакого особого смысла писать первое слово с большой буквы. С маленькой читается гораздо проще.
Бывает так:
```
Add ui-bootstrap.js dependency
ADD ui-bootstrap.js dependency
```
Но лучше:
```
add ui-bootstrap.js dependency
```
##### НЕ используем прошедшее время
Чем проще, тем лучше. Прошедшее время слишком усложняет чтение сообщений. Предстаьте, что вы обращаетесь к Git: «Git, добавь», «Git, удали» и т.д.
Бывает так:
```
added ui-bootstrap.js dependency
```
Но лучше:
```
add ui-bootstrap.js dependency
```
##### Убираем лишние знаки препинания
Например, зачем вам точка в конце сообщения? Итак понятно, что оно закончено. То же самое относится к точке с запятой.
Бывает так:
```
add ui-bootstrap.js dependency;
```
Но лучше:
```
add ui-bootstrap.js dependency
```
#### Русский язык
Нет ничего постыдного в том, чтобы использовать русский язык в коммитах. Но делать это нужно только в том случае, если вы на 1000% уверены, что данный код будет интересен только русскоязычным людям. Например, у вас есть скрипт для VK, который указывает на карте всех фанатов Стаса Михайлова. Очевидно, что это будет мало кому интересно среди зарубежных граждан. Да и для россиян тоже, если честно.
#### Причесываем коммиты перед отправкой
Все коммиты в локальном репозитории можно именовать как угодно. Если вам проще запомнить, что «temp commit 1» — это первая рабочая версия какой-то функциональности, а «temp commit 2» — это ее исправленная и отрефакторенная версия, то пожалуйста, никто особо вас ругать не будет. Но. Огроменное НО. Перед отправкой приведите, пожалуйста, свои коммиты в самый лучший вид. Для большинства случаев подойдет замечательная команда:
```
git rebase -i
```
С помощью нее можно расставить коммиты в правильном порядке, объединить их, переименовать в соответствии со всеми правилами хорошего тона. Очень мощная и полезная команда, но не переусердствуйте, а то код финальной версии какой-то новой функциональности можно перекрыть кодом самой первой глючной версии. Ну и если вы уже отправили свой код в удаленный репозиторий, то rebase лучше не использовать, а то получится только хуже.
#### Находим свой любимый стиль
Я нашел такой в проекте AngularJS. У них есть даже отдельный [документ](https://docs.google.com/document/d/1QrDFcIiPjSLDn3EL15IJygNPiHORgU1_OOAqWjiDU5Y), посвященный оформлению коммитов. Все моменты, о которых я рассказал выше, есть в этом документе. И это прекрасно. Потому что мне приходилось искать эти моменты самому из разных источников, своего опыта, а здесь все лежит уже в одном месте и написано хорошим простым языком. Кратко рассмотрим основные моменты.
##### Указываем тип коммита
Есть несколько заранее определенных типов:
* feature — используется при добавлении новой функциональности уровня приложения
* fix — если исправили какую-то серьезную багу
* docs — всё, что касается документации
* style — исправляем опечатки, исправляем форматирование
* refactor — рефакторинг кода приложения
* test — всё, что связано с тестированием
* chore — обычное обслуживание кода
Не всегда эти типы можно легко различить при написании приложения (например, refactor и chore), поэтому можно придумать свои.
##### Указываем область действия (scope)
Сразу после типа коммита без всяких пробелов указываем в скобках область, на которую распространяется наш коммит. После этого пишем наш стандартный коммит.
Например, может быть область видимости модуля:
```
refactor(audio-controls) use common library for all controls
```
Или область видимости файла:
```
chore(Gruntfile.js) add watch task
```
##### Для чего всё это
Как я уже говорил в самом начале статьи, для сохранения времени и нервов! Путём упрощения следующих операций:
* Автоматическая генерация списка изменений (CHANGELOG.md и подобные). Даже если он не сформируется полностью, то будет хотя бы какя-то отправная точка для внесения небольших поправок.
* Игнорирование неподходящих коммитов при поиске места, где все сломалось (например, с помощью `git bisect`).Коммиты, улучшающие документацию, тесты, стиль кода и т.д. могут сразу быть пропущены. Если у вас сломался модуль audio-controls, то вы будете смотреть только те сообщения, где в scope указан данный модуль.
* Просто более насыщенная и понятная история развития проекта.
#### Заключение
Надеюсь, вы еще не заскучали. Пожалуйста, старайтесь использовать хороший стиль именования коммитов в своих проектах. Другие люди будут вам за это очень благодарны.
На этом всё. Если у вас есть интересные примеры именования из своих проектов, буду рад увидеть их в комментариях. Все ошибки в тексте можете присылать в личные сообщения.
Приятного кодинга! | https://habr.com/ru/post/183646/ | null | ru | null |
# Аккорды с применением высоких технологий
Задача заверстать аппликатуру весьма не тривиальна и от того довольно интересна. Я тоже не устоял перед искушением решить её так как считаю правильным.
Помимо стандартных требований типа кроссбраузерности, масштабираемости, печатаемости и компактности, хотелось бы добиться также и возможности просто тупо скопировать аппликатуру и вставить её, например, в текстовый документ. То есть в текстовом виде аккорд должен иметь примерно следующий вид:
```
Am
O - - -
O F - -
O - R -
O - M -
O - - -
X - - -
```
O — открытая струна, X — приглушённая, остальные буквы обозначают пальцы.
Чтобы добиться возможности копирования и обеспечить низкую связность между блоками, вёрстка получается несколько громоздкой: внутрь грифа помещаются струны, внутрь каждой — лады, а в ладах — блоки обозначающие либо прижатые пальцы, либо неприжатые. У всех блоков есть дополнительные параметры, задаваемые в виде [hiqus-строки](http://habrahabr.ru/blogs/webstandards/92300/) в аттрибуте class — это обеспечивает возможность привязывать к ним визуализацию, а также удобно модифицировать посредством яваскрипта используя соответствующую библиотеку.
Первым делом создадим [банк аккордов](http://sairi-na-tenshi.narod2.ru/chords/chords.xml).
> `DOCTYPE html>
> </fontxml-stylesheet type="text/xsl" href="styles.xsl?rev:123"?>
> <html xmlns:ch="urn:markup:chords">
> <head>
> <title>Все аккордыtitle>
> <link href="styles.css" type="text/css" rel="stylesheet" />
> head>
> <body>
>
> <ch:fingerboard id="Am">
> <ch:title>Amch:title>
> <br/>
> <ch:string class=" number=1 ">
> <ch:head> O ch:head>
> <ch:flet class=" number=1 ">
> <ch:clear> - ch:clear>
> ch:flet>
> <ch:flet class=" number=2 ">
> <ch:clear> - ch:clear>
> ch:flet>
> <ch:flet class=" number=3 ">
> <ch:clear> - ch:clear>
> ch:flet>
> ch:string>
> <br/>
> <ch:string class=" number=2 ">
> <ch:head> O ch:head>
> <ch:flet class=" number=1 ">
> <ch:finger class=" name=fore "> F ch:finger>
> ch:flet>
> <ch:flet class=" number=2 ">
> <ch:clear> - ch:clear>
> ch:flet>
> <ch:flet class=" number=3 ">
> <ch:clear> - ch:clear>
> ch:flet>
> ch:string>
> <br/>
> <ch:string class=" number=3 ">
> <ch:head> O ch:head>
> <ch:flet class=" number=1 ">
> <ch:clear> - ch:clear>
> ch:flet>
> <ch:flet class=" number=2 ">
> <ch:finger class=" name=ring "> R ch:finger>
> ch:flet>
> <ch:flet class=" number=3 ">
> <ch:clear> - ch:clear>
> ch:flet>
> <br/>
> ch:string>
> <ch:string class=" number=4 ">
> <ch:head> O ch:head>
> <ch:flet class=" number=1 ">
> <ch:clear> - ch:clear>
> ch:flet>
> <ch:flet class=" number=2 ">
> <ch:finger class=" name=middle "> M ch:finger>
> ch:flet>
> <ch:flet class=" number=3 ">
> <ch:clear> - ch:clear>
> ch:flet>
> <br/>
> ch:string>
> <ch:string class=" number=5 ">
> <ch:head> O ch:head>
> <ch:flet class=" number=1 ">
> <ch:clear> - ch:clear>
> ch:flet>
> <ch:flet class=" number=2 ">
> <ch:clear> - ch:clear>
> ch:flet>
> <ch:flet class=" number=3 ">
> <ch:clear> - ch:clear>
> ch:flet>
> <br/>
> ch:string>
> <ch:string class=" number=6 mute=true ">
> <ch:head> X ch:head>
> <ch:flet class=" number=1 ">
> <ch:clear> - ch:clear>
> ch:flet>
> <ch:flet class=" number=2 ">
> <ch:clear> - ch:clear>
> ch:flet>
> <ch:flet class=" number=3 ">
> <ch:clear> - ch:clear>
> ch:flet>
> <br/>
> ch:string>
> ch:fingerboard>
>
> body>
> html>` | https://habr.com/ru/post/94139/ | null | ru | null |
# Голосования и информационная безопасность
В этом посте я изложу свои мысли о голосованиях с точки зрения информационной безопасности… В первую очередь топик направлен на IT специалистов, которым хочется иметь стройную, понятную им, картину того, что такое честное голосование. Описанное применимо к выборам модератора, к голосованию жюри при вручении премий, к референдумам, к президентским «гонкам» и т.д. В подобных рассуждениях правильнее везде использовать слово «голосование», но для краткости и для борьбы с тавтологией я буду иногда писать «выборы».
Ниже мы взглянем на выборы по-итэшному, выделим основные принципы, цели, этапы, а также поговорим об уязвимостях систем голосований и об атаках на них.
Другими словами, выборы будем рассматривать как игру с определёнными правилами и ролями. Будем рассматривать также некоторую систему (программно-аппаратно-организационный комплекс) для проведения этой игры и продумаем защиту от читеров.
Замечу, что статья не про политику. Желающим обсудить что-нибудь политическое в контексте этой статьи настоятельно рекомендую заниматься этим не в комментариях, а [где-нибудь ещё.](http://goo.gl/HmoiCU)
#### Принципы
1. ##### Баланс целей
Почти всегда в сложных проектах есть несколько целей и много требований. И почти всегда они вступают в противоречие друг с другом. `Например, требование: «фальшивые пользователи недопустимы», если для их проверки требуется слишком много ресурсов сервера, конфликтует с целью «обеспечить высокую производительность», то есть мы легко можем устроить DOS сами себе`.
В идеале, мы должны достигать всех целей `(например, сделать качественную, но быструю проверку пользователей)`. Но не всегда можно обеспечить 100% по всем пунктам. В таких случаях нельзя впадать в крайности, вместо этого стоит проанализировать ситуацию, понять, что важнее, и **осознанно** снизить планку по одному из критериев, сделав соответствующее публичное заявление.
2. ##### Фальсифицируемость (проверяемость)
Система должна быть построена таким образом, чтобы можно было доказать ошибку в её работе, если такая ошибка произошла. Если это не так (то есть что бы ни произошло, организаторы заявят об успешном проведении голосования), то это уже не выборы, а религиозный культ с постоянно дополняемыми заповедями. Иными словами, при объявлении результатов организаторы должны выполнять чисто формальную роль: к моменту окончания работы системы голосования каждый должен иметь возможность однозначно, исходя из всех имеющихся данных, определить, состоялись выборы или нет и каков их результат.
3. ##### Презумпция «виновности»
Проектируя или эксплуатируя систему голосования, необходимо придерживаться научного метода, то есть, вместо того, чтобы непрерывно подтверждать успех организации голосования, необходимо исходить из обратного предположения и непрерывно проверять соответствующие гипотезы о том, что «что-то пошло не так». То есть каждая гипотеза о том, что «что-то пошло не так», считается верной до тех пор, пока не доказано обратное. Именно опровержением таких гипотез, одной за другой (но самые «опасные» в первую очередь), и занимаются организаторы. `Например, если кто-то оставил ноутбук с root-консолью сервера в открытом месте без присмотра, то система должна считаться полностью скомпрометированной, даже если «в логах ничего нет».`
4. ##### Прозрачность, открытость и гласность
Не думаю, что здесь нужно много слов. Скажу лишь, что, в каком-то смысле, это лентяйство. Трудно проверить всё и вся в одиночку или небольшой группой (организаторов). А тут — выложил все данные, и пусть люди проверяют гипотезы, которые им кажутся наиболее «опасными». Опубликовано должно быть достаточно информации для проверки любого этапа выборов, но в общем случае должна быть соблюдена тайна голосования. Также могут действовать ограничения, связанные с защитой персональных данных.
5. ##### «Мыслить как преступник»
Этот принцип означает, что при проектировании, изменении и использовании системы необходимо постоянно задавать себе вопросы: «А что здесь может пойти не так?», «Могу ли я изменить результаты голосования так, чтобы никто не узнал о моём вмешательстве?», «Есть ли у меня (или у кого-нибудь) возможность добавить или удалить кандидата без формальной процедуры?», `«Могу ли я сорвать выборы просто сорвав пару бумажек со штампом ОПЕЧАТАНО?»` и т.п.
6. ##### Непрерывное устранение уязвимостей
Полная аналогия с баг-треккингом. Разумеется, если найдена уязвимость, её нужно устранить, пофиксить баг. На сами проверки, поиски багов нужно выделить достаточно времени, не спешить «выкладывать релиз». Каждая жалоба на систему (баг-репорт) должна быть зарегистрирована (сохранена) и рассмотрена. По ней должно быть принято решение, включающее оценку влияния найденной уязвимости на ход (текущего) голосования. Если для устранения уязвимости требуется внесение изменений в систему, эти изменения должны быть запланированы. Всё описанное относится не только к программной части, но к полному комплексу, который может включать, скажем, курсы обучения операторов ввода данных в систему.
Все жалобы, в совокупности с принятыми по ним решениями, являются столь же важной частью итогового отчёта, как и результаты голосования.
Все эти принципы тесно связаны друг с другом. Отказ от одного делает бессмысленными остальные.
#### Роли
1. ##### Организаторы
Организаторы — это те, кто администрирует систему. Они же могут и должны её улучшать. И только они имеют на это право. Они объявляют начало избирательной компании, следят за тем, чтобы всё происходило в рамках оглашённых правил, публикуют результаты и отчёты. Теоретически роль Организаторов может быть полностью автоматизирована. На практике, в крупных голосованиях, она автоматизирована частично.
Автоматизация в случае голосований — это не панацея от обмана. Более того, машины могут врать гораздо лучше людей — они могут показывать, печатать и публиковать на сайтах любые непротиворечивые данные, но при этом игнорировать некоторые правила, играть полностью на стороне какого-либо заинтересованного лица, в том числе принимать от него команды через интернет или радиомодуль. Даже если исходный код системы опубликован, невозможно доказать, что именно этот код запущен на произвольно взятой машине. Практически невозможно доказать отсутствие аппаратных закладок.
2. ##### Номинируемые
Это те, кто может стать кандидатом. `Например, для конкурса кинофильмов это все фильмы, вышедшие в этом году, а для выборов мейнтейнера open-source проекта — это все активные разработчики.`
3. ##### Номинирующие
Те, кто имеет право выдвигать Кандидатов. Это могут быть некоторые представители жюри, сами Номинируемые (если это люди) или автомат.
4. ##### Кандидаты (соискатели)
Соответственно, те, кто получил номинацию. Из них будут выбирать одного или нескольких. В некоторых случаях, не публикуется (иногда до определения результатов, а иногда и вовсе) информация о том, кем именно являются Кандидаты: доступны только сведения о достижениях, количестве blame строк кода, доходах, характеристиках, параметрах (зачеркнуть лишнее).
5. ##### Имеющие право голоса
Право голоса могут иметь все жители планеты страны или города. В множество пользователей с этой ролью могут быть включены или не включены Организаторы, Номинирующие, Кандидаты. `В какой-нибудь высоконагруженной компьютерной системе при выборе мастер-сервера правом голоса обладать могут все компьютеры кластера.`
6. ##### Избиратели
Избиратели — это пользователи системы с правом голоса, которые решили этим правом воспользоваться. Речь идёт не о самом факте волеизъявления, а о принципиальном согласии стать Избирателем, то есть изучить профили Кандидатов и, если среди них будет достойный, отдать свой голос (или голоса). Часто факт принципиального согласия никак не фиксируется и не требуется, то есть все Избиратели = все Имеющие право голоса.
У избирателя может быть один голос, несколько `(например, при голосовании на собрании акционеров)` или даже дробное количество голосов. Можно даже придумать такие «выборы», где у одних избирателей будет положительное количество голосов, а у других — отрицательное.
7. ##### Проголосовавшие
Это Избиратели, которые отдали свой голос. Как правило, после этого они больше не могут проголосовать в текущем голосовании. `Исключением, например, является голосование на Евровидении и тому подобные средства относительно честного отъёма денег у населения.`
8. ##### Наблюдатели
В принципе, эта роль может и не требоваться. Это справедливо в том случае, если за любым этапом выборов может наблюдать вообще кто угодно (иногда это самый правильный подход). Заведение же отдельной роли в системе может потребоваться, если Наблюдателям даются дополнительные права, такие как право доступа к спискам Имеющих право голоса. Другой вариант — если Наблюдатели (или их часть) являются профессиональными аудиторами, обладающими правом вето на итоги голосования и несущие ответственность за некорректное использование этого права.
Когда речь заходит о ролях, естественно возникают задачи аутентификации и авторизации. Т.е. система должна заботиться о том, чтобы не впустить никого лишнего и не дать никому сделать ничего лишнего.
#### Цели
1. ##### Выборы должны состояться
Это может показаться слишком очевидным, но не указать эту цель нельзя. Иначе можно так сильно «закрутить гайки» в остальных целях, что выборы провести будет просто невозможно.
2. ##### У Номинирующих должно сформироваться намерение выдвинуть кандидатов
Организаторы должны:
* оповестить всех Номинирующих о предстоящих выборах;
* объяснить Номинирующим их права;
* представить всех Номинируемых Номинирующим (не обязательно каждого каждому. `А если Номинирующие и Номинируемые — одни и те же лица, этот пункт исчезает`);
* обеспечить Номинирующим возможность независимого объективного суждения без давления из вне.
3. ##### У Имеющих на это право должно сформироваться намерение проголосовать
Организаторы должны:
* оповестить всех Имеющих право голоса о предстоящих выборах;
* объяснить потенциальным Избирателям их права;
* обеспечить (потенциальным) Избирателям возможность независимого объективного суждения без давления из вне (как о необходимости становиться Избирателем, так и о том, за какого Кандидата голосовать).
4. ##### Каждый желающий избиратель должен проголосовать
Иными словами, намерение проголосовать должно «превратиться» в учтённый голос. (И ничто другое в голос «превратиться» не должно!) Это касается действительно всех Избирателей, даже если они в космосе, не могут ходить, не могут видеть или болеют.
5. ##### Должна быть обеспечена тайна голосования
Эта цель есть не всегда, а иногда она присутствует лишь частично. `Например, в технических системах она означает лишь требование независимости решений Избирателей-автоматов. А в случае голосования в парламентах, соответствие (избиратель-голос) может держаться в тайне не вечность, а, скажем, несколько лет.`
Существует две разновидности тайны голосования — сильная и слабая. Слабая оставляет избирателю возможность доказать, если он того захочет, что он проголосовал так или иначе. `(Например, если он запишет на видео весь процесс своего участия в голосовании.)` Сильная — не позволяет.
6. ##### Голоса должны быть правильно посчитаны
Это означает, что система должна каждый голос правильно распознать и учесть. `Например, при голосовании «в шапочку» ни одна бумажка (зафиксированный голос) не должна потеряться до окончания подсчёта и ведущий (Организатор) должен прочитать в закорючках на бумажках именно то, что написали Проголосовавшие.`
7. ##### Должны быть оглашены правильные результаты
Несмотря на открытые данные и независимые проверки Наблюдателей, большинство тех, кому интересны текущие выборы, узнают о результатах от Организаторов. Поэтому очень важно, чтобы итоговый отчёт полностью отражал результаты. Такой отчёт должен содержать как краткие ответы (кто победил, сколько денег потрачено, какова достоверность результатов), так и более подробные данные (за кого сколько голосов отдано, на что конкретно потрачены деньги, откуда эти деньги взялись, какие цели достигнуты, сколько было отражено атак, сошлись ли контрольные соотношения, какие найдены ошибки и как они обработаны).
8. ##### Затраты на организацию выборов должны уложиться в бюджет
Таковы суровые реалии. Бюджеты всегда ограничены, а педантичность и высокая достоверность стоят очень дорого. `Нет смысла тратить миллионы долларов для того, чтобы решить, кому доверить управление миллионами долларов (тем, что от них останется после выборов).` Хороший способ снижения затрат — кооперация с другими организаторами, использование совместных разработок.
#### Этапы
1. ##### Анализ ситуации и актуализация системы
На этом этапе организаторы должны понять, способны ли они провести голосование с текущей версией системы — будут ли достигнуты цели. Возможно, система требует доработки, и тогда эта доработка должна произойти до этапа регистрации.
2. ##### Предварительная агитация
Организаторы объявляют даты и время проведения голосования, сообщают за что/кого будет голосование. Публикуют правила (уточнённые принципы, цели, этапы), отчёты (что изменилось с прошлого голосования). Распространяют сведения о ролях и их правах, принимают меры для защиты этих прав. `В том числе, например, они должны «защитить» тех, кто имеет право голоса, но решил не становиться Избирателем, от насильственного посещения выборов.`
3. ##### Регистрация
Сначала регистрируются сами Организаторы, потом Номинирующие и Избиратели, затем Номинируемые.
4. ##### Номинация
Номинирующие выдвигают Кандидатов. `Например, жюри может собраться и коллективно определить, какие песни попадут в полуфинал музыкального конкурса. На этом этапе могут произойти ещё одни маленькие выборы внутри выборов основных.` Этот этап может быть совмещён с этапом регистрации.
5. ##### Объявление Кандидатов
Организаторы объявляют всем участникам список Кандидатов, предоставляют основную официальную достоверную информацию об этих Кандидатах, публикуют предварительный отчёт.
6. ##### Агитация
Это наиболее трудно формализуемый этап (и потому наиболее часто и успешно атакуемый).
В самом простом случае агитация может быть чисто виртуальной, то есть происходить только в головах или оперативной памяти Избирателей с использованием официальной информации.
Но чаще всего этого недостаточно для объективных суждений и честного голосования. В таком случае организаторы всё же пытаются формализовать процесс агитации: проще всего для этого вести контроль ресурсов, используемых Кандидатами или их представителями для агитации. `Такими ресурсами могут быть деньги, эфирное время в СМИ, количество полос в газетах, время аренды рекламных мест на улицах и др.` Изначально ресурсы могут принадлежать кому угодно: Организаторам, Избирателям, Кандидатам, их представителям. Представителями кандидатов могут быть даже те, кто не имеет какой-либо роли в системе. Распределение ресурсов не обязательно должно быть равномерным — какой-то кандидат может получить больше, а какой-то меньше, если Организаторы посчитают (и смогут доказать), что такое распределение сделает агитацию более честной. Главное, чтобы всё это было отражено в итоговом отчёте.
7. ##### Сбор голосов
Самый картинный этап любого голосования. Классификация сбора голосов может быть проведена по двум критериям:
* ###### Очный и заочный
В случае очного голосования избиратель отдаёт голос, находясь на определённой территории для голосования. В противовес этому существует заочное голосование, в том числе через интернет и по почте.
* ###### С доказательством и без
В случае голосования без доказательства голос избирателя сразу увеличивает некоторый счётчик, при этом невозможен, например, пересчёт голосов. В случае голосования с доказательством после волеизъявления избирателя у него на руках и/или у организаторов остаётся доказательство, `например, хэш-код (при криптоголосовании), талончик, бюллетень с отметкой)`.
Соответствующие доказательства должны быть хорошо защищены. Однако при этом не стоит забывать обо всех целях, включая тайну голосования и оптимальность затрат. `Например, бюллетени могут быть пронумерованы и спрятаны в конверте так, что только избиратель может узнать номер бюллетеня, но любой может убедиться, что изначально никаких отметок за кандидатов нет. Конверты в этом случае должны выдаваться случайно, например из лотерейного барабана. А в ящик для голосования можно опустить только конверт с бюллетенем, снова скрыв его номер.`
В конкретном голосовании может применяться один или несколько способов сбора голосов. Также могут применяться экстренные меры типа досрочного голосования. Естественно, соответствующие статистические данные должны быть включены в отчёт.
8. ##### Подсчёт голосов
Подсчёт голосов может происходить вручную, после сбора голосов и/или автоматически, в том числе во время сбора. Как отмечено выше, в общем случае машинам нельзя доверять. С другой стороны, ручной подсчёт всегда дороже, и люди чаще ошибаются. Так что хороший компромисс на этом этапе крайне важен. `Приведу пример такого компромисса.(Насколько мне известно, лучшего способа подсчёта голосов на крупных выборах до сих пор не придумали.) Голоса считаются дважды. В первый раз — автоматически, во время сбора голосов. После сбора на всех, уже перемешанных, бюллетенях ставят случайные номера. При втором, снова автоматическом, подсчёте создаётся таблица (номер, голоса). Понятно, что результаты обоих подсчётов должны совпасть. Но помимо этого, можно проверить любое количество (например, репрезентативную выборку) бюллетеней вручную на соответствие записи в таблице.`
9. ##### Анализ
На этом этапе происходят основные проверки по собранным данным, анализ логов. Люди, которые были заняты непосредственным наблюдением, должны теперь получить время для обдумывания и фиксации своих наблюдений. В конце этапа составляется итоговый отчёт.
10. ##### Объявление результатов
Итоговый отчёт публикуется, голосование считается завершённым.
11. ##### Улучшение системы
За время проведения голосования, особенно за время этапа анализа, могло накопиться много подтверждённых уязвимостей. На этом этапе, который постепенно переходит в этап 1, Организаторы меняют систему для защиты от соответствующих атак. Какие-то временные решения могу становиться постоянными, какие-то отвергаться в пользу более общих и т.д.
#### Человеческий фактор
Люди — не машины. Мы не всегда поступаем логично, пропускаем важный текст мелким шрифтом, боимся, на наши суждения легко повлиять. Если Избиратели, Организаторы или Наблюдатели — люди, то при организации выборов нужно минимизировать человеческий фактор.
1. ##### Юзабилити
Плохо составленный бюллетень или официальный сайт Организаторов, агитационный материал может привести к массовым ошибкам Избирателей. В общем-то, если бы не было человеческой психологии, страха высказать свою позицию открыто, то не было бы и такого понятия как тайна голосования.
2. ##### Давление
Даже если защита тайны голосования на высоте, избиратель, которому угрожают, может не прийти на выборы или прийти и проголосовать против своей воли. Особенно сложна ситуация с удалённым голосованием.
3. ##### Пропаганда
Большое количество однобокой информации в СМИ гарантированно повлияет на суждения избирателей, сделает их менее объективными.
4. ##### Восприятие данных
Человеку трудно делать правильные выводы, если исходная информация для них подана слишком быстро, или если два или более источника информации транслируют что-то одновременно. Поэтому в ручных операциях, таких как подсчёт голосов, важна последовательность действий и размеренность (недопустим параллелизм и спешка, если они могут привести к тому, что кто-то что-то не поймёт).
5. ##### Лень
Организаторы иногда допускают ошибки не из-за своей заинтересованности, а как раз наоборот — вполне возможно, им просто лень быть дотошными и проверять всё. Если организация выборов для человека обычная (а то и сверхурочная) работа, то всё что он хочет — побыстрее отделаться и пойти домой.
#### Цели атакующего
Истинных мотивов злоумышленника мы, конечно, не знаем, но можем считать, что его действия направлены на срыв наших целей, то есть:
1. ##### Срыв самих выборов
Если какие-то правила слишком суровы, что будет если их нарушить? Кто-то может получить выгоду от срыва выборов, переноса их на более поздний срок или от их повторного проведения.
2. ##### Исключение или неправомерное добавление Кандидатов
Кандидат или другие заинтересованные лица, имеющие влияние на Организаторов, могут попытаться не допустить конкурента до выборов. Аналогично, подделав учётную запись, злоумышленник может добиться неправомерной регистрации себя как кандидата.
3. ##### Создание препятствий при формировании намерения проголосовать
Злоумышленник может попытаться ограничить круг тех, кто Имеет право голоса, так, чтобы только сторонники продвигаемой злоумышленником идеи (кандидата) узнали и захотели принять участие в голосовании.
4. ##### Создание препятствий при голосовании
Выше даны примеры таких атак — давление и плохо оформленные бюллетени. Сюда же относятся подделка бюллетеней, ангажирование оборудования и др.
`Другой пример — подкуп избирателей и его частный случай: голосование по цепочке. Злоумышленник выносит бюллетень за пределы территории для голосования, ставит в нём «правильную» отметку и предлагает другим избирателям опустить этот бюллетень в урну и принести назад чистый — за деньги.`
5. ##### Публикация отметок избирателей
Наибольшая опасность этой атаки в том, что она сильно подрывает доверие к Организаторам, то есть задевает не одно голосование, а несколько, если не все последующие. Избиратели начинают голосовать с оглядкой на то, что их голос будет опубликован (или станет известен заинтересованным лицам), иногда даже не осознавая этого.
`Интересный пример — запись последовательности, в которой отдавались голоса (кандидат1, кандидат2, кандидат1). Зная дополнительно в каком порядке люди голосовали (избиратель1, избиратель2, избиратель3), злоумышленник может «проконтролировать волеизъявление» (избиратель1-кандидат1, избиратель2-кандидат2, избиратель3-кандидат1).`
6. ##### Подтасовка при подсчёте
К таким атакам относятся приписки, переделывания промежуточных протоколов, ненулевые счётчики, пересчёты голосов после фильтрации и др.
7. ##### Оглашение неверных результатов от имени организаторов
Как отмечено выше, большинство интересующихся проходящим голосованием не станет заниматься тщательной проверкой результатов, а воспользуются официальными данными из отчёта Организаторов. Подмена такого отчёта, особенно если она останется незамеченной, может де-факто изменить результат голосования.
8. ##### Манипуляции с целью неоптимального использования бюджета
Пример — атака-отвлечение, используется в сочетании с другими атаками. Злоумышленник имитирует или открыто заявляет о потенциальной угрозе безопасности, требующей ресурсоёмкой проверки. Цель состоит в том, чтобы ресурсов Организаторов не хватило на проверку защиты от действительно реализованных атак.
#### Классификация атак
1. ##### Изнутри и снаружи
Атака может происходить со стороны пользователя с любой ролью. Атакующий вообще может не быть зарегистрирован в системе. Однако, наиболее опасные атаки исходят со стороны злоумышленников, имеющих статус организатора. (Речь идёт не о взломе системы аутентификации или авторизации, а о заранее спланированном участии злоумышленника в организации голосования). Такие атаки со стороны Организаторов являются атаками изнутри. Прочие атаки — атаками снаружи. Система может и должна быть спроектирована так, чтобы даже атака изнутри была невозможной.
2. ##### Локальные и глобальные
Положим, будучи злоумышленником, я обнаружил уязвимость и решил ей воспользоваться. Как именно я смогу повлиять на ход голосования? Насколько масштабируема моя атака? Если я могу повлиять лишь на небольшое количество голосов (и общее количество скомпрометированных голосов линейно зависит от количества атакующих), то это локальная уязвимость и атака. Если уязвимость позволяет мне (возможно с малым количеством моих сторонников) полностью переписать результаты, то это глобальная уязвимость и атака.
3. ##### Обратимые и необратимые
Если в результате атаки нанесён необратимый ущерб, то такая атака считается необратимой. `Например, могут быть уничтожены доказательства другой атаки.` Если ущерб может быть возмещён, то такая атака — обратимая. `Например, кратковременный дефейс официального сайта организаторов.`
4. ##### Анонимные и «авторские»
Если атака с использованием некоторой уязвимости обязательно будет зафиксирована в логе с указанием пользователя и его роли, или если атакующий открыто заявляет о том, кто он такой, то такая атака — «авторская». Если установить личность атакующего невозможно, то это анонимная атака.
5. ##### Обнаружимые и необнаружимые
Если в результате атаки могут (должны) остаться доказательства `(пустые логи, нарушения контрольных соотношений, свидетельские показания)`, то такая атака обнаружима. Если в результате атаки не должно остаться никаких доказательств `(например при порче бюллетеней во время подсчёта голосов без свидетелей)`, то это необнаружимая атака.
6. ##### Дешёвые и дорогие
Любая атака требует каких-то ресурсов. Дешёвая атака требует существенно меньше ресурсов для реализации, чем то, что злоумышленник может получить от подделки результатов в своих интересах. Дорогая атака, соответственно, требует больше ресурсов, чем злоумышленник может при помощи неё заработать.
Очевидно, что наибольшую опасность представляют дешёвые анонимные необнаружимые необратимые глобальные атаки изнутри.
Уф. Много всего получилось. Конечно, невозможно перечислить все варианты событий, наверняка многие термины, классификации и примеры, что я здесь использовал, неудачны. Но в целом, надеюсь, что я донёс идею и каждый, кто прочитал статью, сможет теперь по-другому относиться к такой, на первый взгляд простой и далёкой от IT вещи, как голосования. | https://habr.com/ru/post/214023/ | null | ru | null |
# Нативный Masonry Layout в CSS Grid Level 3
*Приветствую. Представляю вашему вниманию перевод статьи*[*«Native CSS Masonry Layout In CSS Grid»*](https://www.smashingmagazine.com/native-css-masonry-layout-css-grid/)*, опубликованной 2 ноября 2020 года автором Rachel Andrew*
Недавно был опубликован черновик спецификации CSS Grid 3 уровня, в котором содержится описание способа создания Masonry-раскладки с помощью чистого CSS. В этой статье Rachel Andrew объясняет данную спецификацию с примерами, которые вы можете воспроизвести в браузере Firefox Nightly. И хотя данный функционал пока что нельзя использовать в реальных проектах, ваш отзыв может помочь убедиться, что текущая реализация соответствует или не соответствует требованиям разработчиков к этому типу раскладки. Итак, приступим.
Что такое Masonry-раскладка?
----------------------------
При masonry-раскладке элементы располагаются один за другим в строчном направлении. При переносе на новую строку они могут смещаться вверх, заполняя пространство, оставленное коротким элементом, расположенным на предыдущей строке текщей колонки. Это похоже на Grid-разметку с автоматическим расположением элементов, но строгого выравнивания по вертикали.
Наиболее известный пример masonry-раскладки – это [Pinterest](https://www.pinterest.co.uk/), и вы могли слышать, как её порой даже называют "Pinterest-раскладкой".
Существует множество JavaScript-инструментов, помогающих добиться такого эффекта. Например, [Masonry plugin](https://masonry.desandro.com/) от David DeSandro’s.
Разве сейчас это невозможно?
----------------------------
Приблизиться к Masonry можно с помощью нескольких способов. Самый простой из них – использовать Мультиколонки (раскладку в несколько столбцов). В примере ниже расположение элементов визуально напоминает Masonry. Однако, блоки располагаются в колонках один под другим. Из-за этого вверху такой раскладки будут располагаться элементы, расположенные не в начале списке. А это может быть критически важно, например, при отображении результатов поиска.
Второй способ - CSS Grid. Когда дизайнеры впервые видели Grid-раскладку, часто думали, с помощью автоматического расположения элементов в плотном (dense) режиме можно достичь вида, подобного Masonry. Но это по-прежнему сетка, следовательно не получится заставить элементы занимать свободное место по вертикали, оставленное другими короткими элементами.
Вывод – для получения Masonry всё ещё необходимо использовать JavaScript. А создание раскладки с помощью JavaScript, особенно при большом количестве элементов, не идёт на пользу производительности. Я сразу указала на то, что веб-разработчики просили этот функционал ещё в [Январе 2017 года](https://github.com/w3c/csswg-drafts/issues/945). И хотя у меня есть некоторые опасения касательно того, действительно ли следует делать Masonry частью CSS Grid, а также касательно проблем с доступностью из-за изменения порядка содержимого, я рада, что в этом направлении ведётся активная работа.
### Режим Masonry в CSS Grid
Это новая спецификация, поэтому некоторые моменты могут измениться, прежде чем начнут поддерживаться большинством браузеров. Но поскольку этот функционал уже реализован в Firefox, мы можем опробовать его уже сейчас. Для этого скачайте Firefox Nightly и в разделе `about:config` активируйте флаг `layout.css.grid-template-masonry-value.enabled`. После этого все демонстрации будут работать корректно.
Чтобы реализовать Masonry-раскладку, одна из осей Grid-контейнера должна иметь свойство `grid-template-*` со значением `masonry`. Она будет называться "masonry-осью". Строки и колонки на другой оси будут определены как обычно, это будет "grid-ось". Приведённый ниже CSS создаёт четырёхколоночную сетку, в которой строки установлены в значение `masonry`. Masonry-элементы будут отображаться в четырёх колонках grid-оси.
```
.container {
display: grid;
grid-template-columns: repeat(4, 1fr);
grid-template-rows: masonry;
}
```
Это всё, что нужно, чтобы получить простую masonry-раскладку. С помощью Firefox Nightly можно посмотреть реальный Codepen-пример ниже.
Собственно, на этом можно было и остановиться, но так как функционал Masonry становится частью CSS Grid, мы можем использовать и другие возможности данной спецификации, даже когда находимся в режиме "Masonry". Следовательно спецификация требует определения этих моментов.
### Поведение Grid-оси
Ось, на которой просто определяются треки, ведёт себя стандартно. Следовательно, можно задавать размер треков, имена линий и использовать выравнивание точно так же, как это делается в обычной сетке.
Также, с помощью линий на оси можно располагать элементы. Они будут добавлены на сетку перед добавлением masonry-элементов. Я добавила изображение с подписью "5" между линией `box-start` и линией `box-end`. Masonry-элементы расположились вокруг данного изображения.
Также можно изменять span - количество треков, которые охватывает элемент как на обычной grid-оси. В следующем примере нескольким элементам задан класс `landscape`. При размещении в режиме masonry-раскладки, эти элементы занимают два колоночных трека.
### Свойство "masonry-auto-flow"
Описание masonry в спецификации вводит дополнительные свойства в Grid-раскладку. Свойство `masonry-auto-flow` ещё не добавлено в Firefox. Но когда это произойдёт, оно даст контроль над потоком элементов в Masonry-раскладке.
Если задать `masonry-auto-flow: next`, каждый последующий элемент будет размещаться на следующей позиции grid-оси, а не в колонке с наибольшим количеством места, как происходит по умолчанию.
Свойство `masonry-auto-flow: ordered` приведёт к тому, что masonry будет игнорировать элементы, точно спозиционированные на сетке и вместо этого будет использовать обычный порядок элементов в документе (исключение - изменение номера элемента в последовательности с помощью свойства "order").
### Свойства "justify-tracks" и "align-tracks"
На момент написания статьи, данные свойства частично работают в Firefox Nightly. Это свойства дополнительного выравнивания masonry-раскладки. Если у вас masonry в блочном направлении, можно использовать `align-tracks`, если в строчном - `justify-tracks`.
Если в grid-контейнере остаётся дополнительное пространство в оси, в которой располагается masonry, вы можете обнаружить, что элементы выравниваются по начальной стороне контейнера. Начальным значением свойства `align-tracks` (в нашем случае с masonry, создаваемой для строк) является `start`.
Эти свойства работают вместе с `align-content` и `justify-content`. Как это происходит, продемонстрировано в следующем примере, где grid-контейнер имеет высоту, равную `200vh`. Для свойства `align-track` я устанавливаю значение `end`.
Если установлено значение `normal` (что будет, если я не задам свойство), то masonry-треки окажутся в конце контейнера.
Если я добавлю `align-content: start`, masonry-треки вернутся в начало контейнера. Однако, теперь «выступающие края» раскладки вверху, а не внизу потому что masonry-треки выровнены по конечной стороне.
**Примечание:** вы можете использовать любые значения, применяемые к свойствам `align-content`, `align-tracks` или `justify-tracks`. В спецификации есть несколько хороших примеров различных комбинаций.
Если задать `align-track: stretch`, любые элементы с автоматическим размером будут растянуты. Masonry-эффект сохранён, но все элементы данной оси, имеющие определённый размер, не будут растягиваться.
Свойства `align-tracks`и `justify-tracks` могут принимать несколько значений. По одному для каждого трека оси сетки. Это значит, что в нашей сетке с четырьмя треками, первый трек может быть растягивающимся, второй - выровненным по начальной стороне, третий - по конечной, четвёртый - по центру.
*На момент написания статьи в Firefox это не работало.*
В спецификации указано, что если значений меньше, чем треков, оставшиеся треки будут использовать последнее указанное значение. Если значений больше, чем треков, лишние значения будут проигнорированы.
### FALLBACK-поведение
Включение этого функционала в спецификацию CSS Grid имеет определённое преимущество, когда речь идёт о создания фолбэк-раскладки. Поскольку masonry ведёт себя так же, как автоматическое размещение, если браузер её не поддерживает, вместо неё может использоваться обычное автоматическое размещение. В раскладке может возникнуть незаполненное пространство, как показано в примере выше, но это не так страшно.
Увидеть этот эффект в действии можно в любом приведённом выше демо, если использовать браузер, не поддерживающий masonry. Вы всё ещё получаете раскладку. Если же нужно было сделать что-то абсолютно другое, проверить наличие поддержки masonry можно с помощью *feature queries*. Например, для браузеров, не поддерживающих masonry, можно сделать раскладку с помощью мультиколонок.
```
@supports (grid-template-rows: masonry) {
/* код masonry */
}
```
Если masonry-раскладка жизненно необходима, её поддержку можно проверить с помощью CSS.support и при необходимости использовать JavaScript-библиотеку. Это означало бы, что по мере внедрения браузерами поддержки masonry, решение на JavaScript уже не использовалось, но присутствовало бы в виде полифила.
### Потенциальные проблемы с совместимостью
Хотя masonry в CSS - это здорово, есть ещё одно место, где порядок содержимого в документе может отличаться от того, как оно в итоге выводится на экран. [Как я указывала](https://github.com/w3c/csswg-drafts/issues/5675#issuecomment-718070949) в недавнем issue, думаю, мы создаём потрясающием возможности для разметки, а потому должны донести до людей необходимость быть осторожными в их использовании.
Я писала об этой проблеме в статье [«Grid, content re-ordering and accessibility»](https://rachelandrew.co.uk/archives/2019/06/04/grid-content-re-ordering-and-accessibility/). Надеюсь, что по мере развития спецификации, также будут возобновлены усилия по улучшению способов работы с содержимым и порядком отображения.
Ваш мнение важно
----------------
Нам очень повезло не только с этой новой спецификацией, но и с тем, что есть возможность протестировать её в браузере. Если вы где-то используете masonry-раскладку, почему бы не попробовать заменить JavaScript-решение на CSS Grid и посмотреть, как оно будет работать? Если столкнётесь с проблемами или не сможете осуществить что-то, что могли до этого, сообщите об этом в CSSWG, создав issue. | https://habr.com/ru/post/526008/ | null | ru | null |
# Введение в написание тестов и знакомство с xUnit
Идея статьи возникла после нескольких лекций о том, как писать тесты и как использовать [xUnit](https://xunit.github.io/). Обо всём можно по отдельности почитать подробно. Здесь же я собрал общую информацию о том, как удачно на практике всё это применяется и сопроводил ссылками, для дальнейшего ознакомления. Обзор делался по версии 2.0.
#### Соглашения в коде
Распространённая практика помещать все тестовые проекты в отдельный фолдер. Это относится и к структуре фолдеров на диске, и к фолдерам в солюшене. Практика распространена именно благодаря удобству. Так же, имя проекта и пространство имен полностью повторяют тестируемый модуль с добавлением в конце слова Tests (обычно через точку). Для простоты поиска тестов все тесты, относящиеся к некоторому классу помещаются в его класс с тестами. Т.о. получается пара из оргигинального класса и класса с тестами. Разделение между юнит, интеграционными, нагрузочными происходит либо по категорям, либо по логике основной системы. Это значит, что если интеграционные тест нельзя отнести к одному классу (обычно, это так), то они выносятся в отдельную сборку, посвященную тестируемому функционалу. Или, например, нагрузочные тесты могут тестировать работу некоторого метода одного класса. В этом случае тест размещается в парном классе. Структура самих тестов любого типа соответствует стилю AAA. Систематизируем вышесказанное:
* Расположение проекта: в фолдере Tests
* Имя тестового проекта: [ProjectName].Tests
* Пространство имен: [Namespace].Tests
* Имя класса с тестами: [Class]Tests
* Пара 1-1 из тестируемого класса и класса с тестами
* Наименование юнит-тестов: BDD ([мануал](http://dannorth.net/introducing-bdd/))
* Стиль тестов: AAA (Arrange-Act-Assert)
#### Сравнение xUnit с другим фреймворками
xUnit является одним из популярных, нынче, фреймворков. На его описании останавливаться не буду, а приведу сухую выжимку. Если будут вопросы, пишите в коментах, отвечу.
Немного устаревшая информация, тем не менее, довольно полная, приведена в сравнении [xUnit с другими фреймворками (MSTest, NUnit)](http://xunit.github.io/docs/comparisons.html). Хочу отметить только важные отличия:
* Проверка исключений делается ассертами, вместо атрибутов, что больше соответствует стилю AAA (Assert.Throws, Record.Exception). Внутри исключения ловятся try-catch блоком.
* Замена специальных атрибутов естественными возможностями языка (конструктор, IDisposable, IClassFixture, ICollectionFixture)
В остальном возможности похожи. xUnit приписывают очень высокую гибкость по кастомизации, возможность расширить/изменить поведение, запуск тестов и пр. Но мне не приходилось на практике что-то такое делать.
##### Fact, Theory и другие понятия
Fact — это отдельный юнит-тест, не принимающий параметров. Theory — это тест, принимающий параметры, при этом может быть несколько сценариев. Fixture — класс для настройки и очистки некоторого контекста. Контекст присоединяется к классу с тестами либо с помощью интерфейса IClassFixture, либо с помощью коллекции и интерфейса ICollectionFixture. Коллеция может включать несколько классов с тестами.
Пример Fact и двух вариантов Theory:
```
public class TestSuite
{
[Fact]
public void Should_do_somthing(){...}
[Theory]
[InlineData(20, 180, 80, ”good”)]
[InlineData(20, 180, 50, ”bad”)]
public void Should_measure_weight(int age, int height, decimal weight, string expected){...}
[Theory]
[MemberData(“AgeHeightWeightData”)]
public void Should_measure_weight(int age, int height, decimal weight, string expected){...}
public static IEnumerable AgeHeightWeightData()
{
yield return new object[] {20, 180, 80, "good"};
yield return new object[] {20, 180, 50, "bad"};
}
}
```
Чуть больше деталей [тут](https://xunit.github.io/docs/getting-started.html) и [тут](http://binary-notes.ru/data-driven-test-with-xunit/).
##### Контексты и выполнение тестов
По умолчанию, тесты в одном классе и коллекции выполняются синхронно. Например, если при выполнении тестов у вас используется расшаренный ресурс и это вызывает проблемы (например, тесты падают, т.к. ресурс залочен), то можно поместить такие тесты в одну коллекцию и проблема уйдет, т.к. исчезнет параллелизм. В целом, стек вызовов и то, что происходит выглядит, примерно, так:
```
CollectionFixture: ctor - переменные этого контекста видны классам TestClass1 и TestClass2
ClassFixture: ctor - переменные этого контекста видны в TestClass1
TestClass1: ctor - переменные этого контекста видны только в одном тесте
Test1() - выполняется синхронно внутри одного класса и коллекции
TestClass1: disposed - все переменные контекста удаляются
TestClass1: ctor
Test2()
TestClass1: disposed
ClassFixture: disposed - все переменные контекста удаляются
TestClass2: ctor
Test3()
TestClass2: disposed
CollectionFixture: disposed
TestClass3: Test4() - этот тестовый класс не использует другие контексты и тесты выполняются параллельно с остальными
```
Стоит отметить, что при определении коллекции используется класс-маркер, который не создаётся вообще. Создаются только классы, присоединенные с помощью ICollectionFixture. Об этом подробнее читайте [тут](http://xunit.github.io/docs/shared-context.html), а о параллелизме — [тут](http://xunit.github.io/docs/running-tests-in-parallel.html).
#### Поддрежка CI
Она есть, правда, не везде из коробки. В моём любимом TeamCity всё отлично, т.к. делать ничего не надо. Хуже в Jenkins, т.к. надо заморочиться с установкой плагина. А вот в TFS темный лес. Мне не удалось найти вменяемого примера установки и запуска xUnit. Буду рад ссылкам. Остается запуск силами скриптов MSBuild и NAnt. | https://habr.com/ru/post/357648/ | null | ru | null |
# Генератор SQL запросов на PHP
Где-то полтора года назад я начал заниматься web разработкой. Начинал с функционального программирования. Примерно пол года назад я перешел на ООП и стал использовать MVC архитектуру проектирования. Недавно появилась задача оптимизировать работу с базой данных, т. к. вся связь и работа с базой осуществлялась через один класс. Это было неудобно потому, что все время приходилось вручную писать SQL — запросы. Задача была разбита на 2 этапа:
1. Написать класс для подключения к базе данных
2. Написать класс модели для работы с данными
Первая задача решилась очень быстро. Для ее реализации я воспользовался паттерном проектирования Singleton.
Для реализации второй задачи мне понадобилось немного больше времени. За основу был взят простой модуль управления новостями на сайте. Обязанности этого модуля включали в себя стандартный набор функций: выборка, создание, удаление и обновление записей. Класс модели наследует класс DataBase, который собственно и создает подключение к базе данных. Также этот класс отвечает за генерацию sql кода для [DML операций](http://ru.wikipedia.org/wiki/DML). Класс DataBase является абстрактным, что обязывает нас во всех дочерних классах реализовывать DML методы.
Ниже представлен набор абстрактных методов, которые отвечают за управление модулем «Новости».
```
//Получаем запись
abstract public function getRecords($what='*',$where=NULL, $limit=NULL, $order=NULL,$join=NULL,$debug=false);
//Добавляем запись
abstract function addRecord($data=array(),$debug=false);
//Удаляем запись(-и)
abstract function deleteRecords($table, $where=NULL,$debug=false);
//Обновляем запись(-и)
abstract function setRecords($table,$what,$where,$debug=false);
//Нестандартный запрос
abstract function query($sql);
```
Теперь подробнее о каждом абстрактном методе. Реализация этих методов будет представлена ниже, когда я буду описывать класс модели News.
Некоторые входные параметры повторяются, поэтому я не будут повторно их описывать за исключение тех случаев, когда это действительно потребуется.
##### Метод getRecords
Этот метод позволяет получить набор записей, которые подходят под условие нашего SQL.
* $what — передает массив полей, которые нужно выбрать из таблицы
* $where — передает ассоциативный массив ключей в виде array('Поле'=>array('знак','значение')). Это дает нам возможность более гибко использовать предикат WHERE
* $limit — передает ассоциативный массив ключей в виде array('начальная запись', 'количество записей'). Такая структура дает нам возможность реализовать постраничный вывод или вывод ограниченного количества записей
* $order — ассоциативный массив array('поле'=>'вид сортировки'). Дает возможность сортировки по любому количеству столбцов.
* $join — ассоциативный массив array('Тип связи', array('Таблица1', 'Таблица2'), array('Алиас1', 'Алиас2'), array('поле1','поле2')). Тип связи: LEFT, INNER, RIGHT, OUTER; Таблица1 и Таблица2: таблицы между которыми устанавливается связь; Аллиас1 и Аллиас2 — псевдонимы для таблицы; Поле1 и Поле2 — это соотв. PK и FK таблиц
* $degub — этот параметр нужен для сохранения в свойства класса уже созданного sql запроса, а также параметров, которые нужно если мы используем prepare statement в PDO
##### Метод addRecord
Этот метод позволяет добавить запись в таблицу.
* $data — ассоциативный массив параметров в виде: 'поле'=>'значение', которые будут вставляться в таблицу
##### Метод deleteRecords
Этот метод позволяет удалить запись (-и) из таблицы.
* $table — название таблицы из которой будут удаляться данные
##### Метод setRecords
Этот метод позволяет обновить запись (-и) в таблице по заданному условию.
* $what — В этом случает этот параметр передает массив в виде: 'поле'=>'значение', которые будут использоваться с оператором SET
##### Метод query
Этот метод позволяет выполнять нестандартные запросы. Для этого нужно просто передать нужный sql запрос в качестве параметра метода.
* $sql — sql запрос для выполнения
Думаю многие знают, что DML тип запросов состоит из 4 видов: SELECT, INSERT, UPDATE, DELETE. Для генерации эти запросов нам нужно их разделить условно на несколько частей.
1) SELECT запрос делится на: WHAT, JOIN, WHERE, ORDER, LIMIT, GROUP, HAVING.
2) INSERT запрос: WHAT
3) UPDATE запрос: WHAT, WHERE
4) DELETE запрос: WHERE.
Получается нам всего лишь нужно генерировать отдельно эти части запроса, а потом склеить их воедино. Для генерации этих частей в классе DataBase были созданы методы, которые являются едиными не только для модуля «Новости», как в нашем случае, но и для любого другого модуля.
Рассмотрим эти методы подробнее.
##### Метод checkWhat
Единственным входным параметром этого метода является ассоциативный массив значений, которые либо нужно выбрать с помощью SELECT или нужно обновить с помощью UPDATE.
Параметр $what описан [тут](#what)
```
protected function checkWhat($what)
{
if (is_array($what))
{
foreach ($what as $k=>$v)
{
if (!is_numeric($k)) // Проверяем является ли наш массив ассоциативным. Если да, то готовим prepare statement, а если нет, то перечисляем все столбцы через запятую для SELECT запроса
{
$result['column'][]=$k."=?";
$result['params'][]=$v;
}
else {
$result['column'][]=$v;
}
}
$result['column']=implode(",",$result['column']);
}
return $result;
}
```
Думаю тут все довольно ясно. Проверка на массив, обход всех элементов массива и построение части строки запроса.
##### Метод checkJoin
Параметр $join описан [тут](#join). Также предусмотрена ситуация, когда нужно объединить больше двух таблиц, тогда параметр $join может быть представлен в виде array($join1, $join2,.....,$joinN)
```
//Проверяем наличие Join составляющей запроса.
protected function checkJoin($join)
{
if (is_array($join) && count($join)>0)
{
if (!is_array($join[0])) // Если это массив, то генерируем только один join
{
$res[]=$this->addJoin($join[0],$join[1],$join[2],$join[3]);
}
else { // Если это массив массивов, то генерируем несколько join
$res=$this->addJoinArray($join);
}
return implode(" ",$res);
}
else {
return false;
}
}
//Генерация join
protected function addJoin($type=' INNER ',$tables,$pseudoName,$rows)
{
if ($type!=='' && is_array($tables) && is_array($rows))
{
$t0=$tables[0];
$t1=$tables[1];
if (is_array($pseudoName) && count($pseudoName)>0) // если есть аллиасы, то применяем их
{
$t0=$pseudoName[0];
$t1=$pseudoName[1];
}
return $type." JOIN `".$tables[1]."` `".$pseudoName[1]."` ON `".$t0."`.`".$rows[0]."`=`".$t1."`.`".$rows[1]."`";
}
else {
return false;
}
}
// Генерация массива join`ов
protected function addJoinArray($join)
{
if (is_array($join))
{
foreach ($join as $j)
{
$res[]=$this->addJoin($j[0],$j[1],$j[2],$j[3]);
}
}
return $res;
}
```
##### Метод checkWhere
Метод проверяет наличие параметров для WHERE составляющей запроса. Параметр $where описан [тут](#where)
```
protected function checkWhere($where)
{
if (!is_null($where) && is_array($where))
{
foreach ($where as $k=>$v)
{
$part=$k.$v[0]; // сначала соединяем часть запроса 'поле' и 'знак'
if (!is_array($v[1])) //если не массив, то готовим prepare statement
{
$part.="?";
$params[]=$v[1]; // добавляем параметры в массив
}
else { // если массив, то вероятно мы используем IN (array)
$part.="(".implode(",",$v[1]).")";
}
$res[]=$part;
}
$result['column']="WHERE ".implode(" AND ",$res);
$result['params']=$params;
}
return $result;
}
```
##### Метод checkLimit
Генерация предикаты LIMIT запроса. Тут все довольно просто.
```
protected function checkLimit($limit)
{
$res=false;
if (is_array($limit) && count($limit)>0)
{
$res=" LIMIT ".$limit['start'];
if (isset($limit['count']) && $limit['count']!=='') // проверяем наличие второго параметра для постраничного вывода
{
$res.=", ".$limit['count'];
}
}
return $res;
}
```
##### Метод checkOrder
Генерация предикаты ORDER.
```
protected function checkOrder($order)
{
if (is_array($order) && count($order)>0)
{
foreach ($order as $row=>$dir)
{
$res[]=$row." ".$dir;
}
return "ORDER BY ".implode(",",$res);
}
else {
return false;
}
}
```
Вот и все методы, которые нужны для генерации основных частей запроса. Но т.к. мы используем prepare statement в таких частях запроса как WHERE и WHAT, то нам нужно объединить параметры эти частей, чтобы передать в PDO. Для этой задачи я написал еще один метод
##### Метод checkParams
Входящими параметрами являются два массива. Массив параметров WHAT и WHERE.
```
protected function checkParams($what,$where)
{
if (!isset($what) || !is_array($what))
{
$params=$where;
}
else if (!isset($where) && !is_array($where))
{
$params=$what;
}
else {
$params=array_merge($what,$where);
}
return $params;
}
```
Следующим этапом построения SQL запросов является итоговая генерация sql кода. Для этого я создал 4 метода: prepareSelectSQL, prepareInsertSQL, prepareDeleteSQL, prepareUpdateSQL
Рассмотрим эти методы подробнее.
##### Метод prepareSelectSQL
Параметры этого метода совпадают с параметрами метода getRecords. Это $what, $where, $limit, $order, $join, $debug. Эти параметры описаны [тут](#params)
```
protected function prepareSelectSQL($what=array('*'),$where=NULL, $limit=NULL, $order=NULL,$join=NULL,$debug=false)
{
$what=$this->checkWhat($what);
$where=$this->checkWhere($where);
$limit=$this->checkLimit($limit);
$order=$this->checkOrder($order);
$j=$this->checkJoin($join);
$sql="SELECT ".$what['column']." FROM `".$this->table."` `tb` ".$j." ".$where['column']." ".$order." ".$limit;
$params=$this->checkParams($what['params'],$where['params']);
if ($debug) // если true, то передаем sql и его параметры в свойства класса.
{
$this->sql=$sql;
$this->params=$params;
}
return array('sql'=>$sql,'params'=>$params); // возвращаем готовый sql и его параметры.
}
```
##### Метод prepareInsertSQL
Этот метод проще, т.к. используется ограниченный набор предикат и параметров
```
protected function prepareInsertSQL($data,$table,$debug=false)
{
$params=$values=$column=array();
foreach ($data as $c=>$p)
{
$column[]=$c; // поля для вставки
$values[]="?"; // параметры для prepare statement
$params[]=$p; //массив реальных значений параметров
}
$sql=" INSERT INTO `".$table."` (".implode(",",$column).") VALUES (".implode(',',$values).")";
if ($debug)
{
$this->sql=$sql;
$this->params=$params;
}
return array('sql'=>$sql,'params'=>$params);
}
```
##### Метод prepareDeleteSQL
Запрос для удаления записей. Используем название таблицы и набор параметров для предикаты WHERE.
```
protected function prepareDeleteSQL($table,$where,$debug=false)
{
$where=$this->checkWhere($where);
$sql="DELETE FROM `".$table."` ".$where['column'];
$params=$this->checkParams($what,$where['params']);
if ($debug)
{
$this->sql=$sql;
$this->params=$params;
}
return array('sql'=>$sql,'params'=>$params);
}
```
##### Метод prepareUpdateSQL
Генерируем sql запрос для обновления записей в таблице.
```
protected function prepareUpdateSQL($table,$what,$where,$debug=false)
{
$what=$this->checkWhat($what);
$where=$this->checkWhere($where);
$sql="UPDATE `".$table."` SET ".$what['column']." ".$where['column'];
$params=$this->checkParams($what['params'],$where['params']);
if ($debug)
{
$this->sql=$sql;
$this->params=$params;
}
return array('sql'=>$sql,'params'=>$params);
}
```
Выше был описан класс DataBase, который отвечает за подключение к базе данных и генерацию DML sql запросов. Ниже приведен полный код этого класса.
**Abstract class DataBase**
```
abstract class DataBase {
static private $_db=NULL;
public $sql='';
public $params=array();
/*
* Блокируем __construct и __clone для того,
* чтобы невозможно было создать новый объект через new.
* */
private function __construct()
{
return false;
}
private function __clone()
{
return false;
}
//Получаем записи
abstract public function getRecords($what='*',$where=NULL, $limit=NULL, $order=NULL,$join=NULL,$debug=false);
//Добавляем запись
abstract function addRecord($data=array(),$debug=false);
//Удаляем запись(-и)
abstract function deleteRecords($table, $where=NULL,$debug=false);
//Обновляем запись(-и)
abstract function setRecords($table,$what,$where,$debug=false);
//Нестандартный запрос
abstract function query($sql);
/*
* Синглтон подключения к базе данных. Если объект уже создан,
* то просто возвращается экземпляр объекта, если нет,
* то создается новое подключение к базн данных.
* Можно напрямую пользоваться классом PDOChild
* */
public static function getInstance($registry)
{
if (is_null(self::$_db))
{
self::$_db=new PDOchild($registry);
}
return self::$_db;
}
/*
* Добавляем join к запросу.
* type - тип нужного join
* tables - массив таблиц которые будут связываться
* pseudoName - псевдонимы для таблиц
* row - поля по которым производится связь
* */
protected function addJoin($type=' INNER ',$tables,$pseudoName,$rows)
{
if ($type!=='' && is_array($tables) && is_array($rows))
{
$t0=$tables[0];
$t1=$tables[1];
if (is_array($pseudoName) && count($pseudoName)0)
{
$t0=$pseudoName[0];
$t1=$pseudoName[1];
}
return $type." JOIN `".$tables[1]."` `".$pseudoName[1]."` ON `".$t0."`.`".$rows[0]."`=`".$t1."`.`".$rows[1]."`";
}
else {
return false;
}
}
/*
* Добавляем несколько join к запросу
* join - массив массивов join array(join,join)
* */
protected function addJoinArray($join)
{
if (is_array($join))
{
foreach ($join as $j)
{
$res[]=$this->addJoin($j[0],$j[1],$j[2],$j[3]);
}
}
return $res;
}
/*
* Генерируем SELECT sql
* what- поля которые нужно выбрать в виде массива
* where- условие выбора в виде массива array(поле=>array(знак=,значение))
* limit-лимит записей в виде массива array(начальная запись, количество)
* order- сортировка array (поле=>направление)
* join- массив join
* debug- если true то в свойство класса sql записывается текущий sql запрос и в свойство params записываются параметры
* */
protected function prepareSelectSQL($what=array('*'),$where=NULL, $limit=NULL, $order=NULL,$join=NULL,$debug=false)
{
$what=$this->checkWhat($what);
$where=$this->checkWhere($where);
$limit=$this->checkLimit($limit);
$order=$this->checkOrder($order);
$j=$this->checkJoin($join);
$sql="SELECT ".$what['column']." FROM `".$this->table."` `tb` ".$j." ".$where['column']." ".$order." ".$limit;
$params=$this->checkParams($what['params'],$where['params']);
if ($debug)
{
$this->sql=$sql;
$this->params=$params;
}
return array('sql'=>$sql,'params'=>$params);
}
/*
* Генерируем Insert sql
* data- массив пар поле-значение для вставки
* table- таблица куда вставляется значение
* debug- если true то в свойство класса sql записывается текущий sql запрос и в свойство params записываются параметры
* */
protected function prepareInsertSQL($data,$table,$debug=false)
{
foreach ($data as $c=>$p)
{
$column[]=$c;
$values[]="?";
$params[]=$p;
}
$sql=" INSERT INTO `".$table."` (".implode(",",$column).") VALUES (".implode(',',$values).")";
if ($debug)
{
$this->sql=$sql;
$this->params=$params;
}
return array('sql'=>$sql,'params'=>$params);
}
/*
* Генерируем Delete sql
* where- Условие для удаления
* table- таблица из которой удаляются записи
* debug- если true то в свойство класса sql записывается текущий sql запрос и в свойство params записываются параметры
* */
protected function prepareDeleteSQL($table,$where,$debug=false)
{
$where=$this->checkWhere($where);
$sql="DELETE FROM `".$table."` ".$where['column'];
$params=$this->checkParams($what,$where['params']);
if ($debug)
{
$this->sql=$sql;
$this->params=$params;
}
return array('sql'=>$sql,'params'=>$params);
}
/*
* Генерируем Update sql
* table- таблица из которой удаляются записи
* what - массив поле значение для обновления
* where- Условие для обновления
* debug- если true то в свойство класса sql записывается текущий sql запрос и в свойство params записываются параметры
*/
protected function prepareUpdateSQL($table,$what,$where,$debug=false)
{
$what=$this->checkWhat($what);
$where=$this->checkWhere($where);
$sql="UPDATE `".$table."` SET ".$what['column']." ".$where['column'];
$params=$this->checkParams($what['params'],$where['params']);
if ($debug)
{
$this->sql=$sql;
$this->params=$params;
}
return array('sql'=>$sql,'params'=>$params);
}
/*
* Проверяем наличие параметра join
* Если он есть, то проверяем является ли он единственным, если да то addJoin
* если нет, то addJoinArray
* Если join нет, то ничего не возвращаем
* */
protected function checkJoin($join)
{
if (is_array($join) && count($join)>0)
{
if (!is_array($join[0]))
{
$res[]=$this->addJoin($join[0],$join[1],$join[2],$join[3]);
}
else {
$res=$this->addJoinArray($join);
}
return implode(" ",$res);
}
else {
return false;
}
}
/*
* Проверяем наличие параметра what
* Если этот параметр явл. массивом,
* то генерируем массив поле=>? и массив параметров для prepare SQL
* */
protected function checkWhat($what)
{
if (is_array($what))
{
foreach ($what as $k=>$v)
{
if (!is_numeric($k))
{
$result['column'][]=$k."=?";
$result['params'][]=$v;
}
else {
$result['column'][]=$v;
}
}
$result['column']=implode(",",$result['column']);
}
return $result;
}
/*
* Проверяем наличие параметра Where
* Если этот параметр явл массивом,
* то генерируем массив поле=>? и массив параметров для prepare SQL
* если v[0](sign)= IN и значение value это массив, то можно сгенерировать IN (array);
* Можно также генерировать условие LIKE, но не тестил.
* Возвращает массив полей и параметров для sql
* */
protected function checkWhere($where)
{
if (!is_null($where) && is_array($where))
{
foreach ($where as $k=>$v)
{
$part=$k.$v[0];
if (!is_array($v[1]))
{
$part.="?";
$params[]=$v[1];
}
else {
$part.="(".implode(",",$v[1]).")";
}
$res[]=$part;
}
$result['column']="WHERE ".implode(" AND ",$res);
$result['params']=$params;
}
return $result;
}
/*
* Проверяем наличие параметра Limit
* Если этот параметр явл массивом,
* то генерируем LIMIT для SQL
* Возвращает строку LIMIT с разбиением на страницы или без него
* */
protected function checkLimit($limit)
{
if (is_array($limit) && count($limit)>0)
{
$res=" LIMIT ".$limit['start'];
if (isset($limit['count']) && $limit['count']!=='')
{
$res.=", ".$limit['count'];
}
}
return $res;
}
/*
* Проверяем наличие параметра Order
* Если этот параметр явл массивом,
* то генерируем ORDER для SQL
* Возвращает массив ORDER
* */
protected function checkOrder($order)
{
if (is_array($order) && count($order)>0)
{
foreach ($order as $row=>$dir)
{
$res[]=$row." ".$dir;
}
return "ORDER BY ".implode(",",$res);
}
else {
return '';
}
}
/*
* Проверяем наличие параметров для prepare sql
* Параметры состоят из массива параметров WHAT и массива параметров WHERE.
* Это нужно для того, чтобы prepare sql
* работал и с update, select, delete, insert
* Объединяет два массива what и where
* */
protected function checkParams($what,$where)
{
if (!isset($what) || !is_array($what))
{
$params=$where;
}
else if (!isset($where) && !is_array($where))
{
$params=$what;
}
else {
$params=array_merge($what,$where);
}
return $params;
}
}
?>
```
Теперь настало время описать класс модели News. Этот класс реализует все абстрактные методы класса-родителя DataBase и статический метод getObject. Этот метод возвращает экземпляр объекта этого класс. Этот метод был создан для того, чтобы отпала необходимость в создании объекта класса News путем использования ключевого слова new. Вот как это выглядит:
```
$news=News::getObject()->getRecords(params);
```
Каждый метод этого класса вызывает нужный ему генератор sql запроса и передает итоговый запрос и параметры в PDO для выполнения запроса. Ниже приведен полный код класса модели News.
**class News**
```
class News extends DataBase
{
public $table='news'; //Главная талица
public $id_row='id'; // primary key
public function __construct()
{
$registry=new Registry(); //параметры подключения к базе данных
$this-db=parent::getInstance($registry);
}
// для доступа к классу через статический метод
public static function getObject()
{
return new News();
}
// получаем записи из таблицы.
public function getRecords($what=array('*'),$where=NULL, $limit=NULL, $order=NULL,$join=NULL,$debug=false)
{
$data=$this->prepareSelectSQL($what,$where, $limit, $order,$join,$debug);
$res=$this->db->prepare($data['sql']);
$res->execute($data['params']);
$result=$query->fetchAll(PDO::FETCH_OBJ);
return $result;
}
public function addRecord($data=array(),$debug=false)
{
$data=$this->prepareInsertSQL($data,$this->table,$debug);
$query=$this->db->prepare($data['sql']);
return $query->execute($data['params']));
}
public function deleteRecords($table, $where=NULL,$debug=false)
{
$data=$this->prepareDeleteSQL($table,$where,$debug);
$query=$this->db->prepare($data['sql']);
$result=$query->execute($data['params']);
return $result;
}
public function setRecords($table,$what,$where,$debug=false)
{
$data=$this->prepareUpdateSQL($table,$what,$where,$debug);
$query=$this->db->prepare($data['sql']);
$result=$query->execute($data['params']);
return $result;
}
public function query($sql)
{
$query=$this->db->prepare($sql);
$query->execute();
$result=$query->fetchAll(PDO::FETCH_OBJ);
return $result;
}
}
?>
```
В принципе на этом можно завершать. Конечно же, можно было еще добавить генерацию предикаты GROUP BY и HAVING, но я решил этого не делать. Думаю, что принцип построения запросов я изложил ясно и проблем с использованием не возникнет. В итоге мы получили механизм построения sql запросов, который не завязан на конкретной структуре таблицы в БД и может применяться к разным типам DML SQL запросов. Если нужно будет, могу создать репозиторий на github.
Буду рад услышать критику и предложения по улучшению метода. | https://habr.com/ru/post/154245/ | null | ru | null |
# Получаем i18n список стран, регионов, населенных пунктов из ВКонтакте
#### Получить базу данных стран, регионов, населенных пунктов с переводом названий и связями бесплатно и без регистрации? Это реально!
При разработке небольшого стартап-проекта с большими амбициями столкнулся с необходимостью в базе данных стран, регионов и городов, с переводом названий хотя бы на самые распространенные языки (английский, русский, испанский, немецкий и т. д.). Готовое решение найдено не было, поэтому стал искать источники, из которых можно спарсить необходимые данные. На ум сразу пришли известные социальные сети. В этой [статье](http://habrahabr.ru/sandbox/41451/) уже описывалось получение данных из ВКонтакте, но покопавшись в документации [API ВКонтакте](http://vk.com/dev/database), был приятно удивлен, найдя открытые документированные методы получения геоданных:
**database.getCountries** — Возвращает список стран.
**database.getRegions** — Возвращает список регионов.
**database.getCities** — Возвращает список населенных пунктов.
**database.getCountriesById** — Возвращает информацию о странах по их идентификаторам
**database.getCitiesById** — Возвращает информацию о городах по их идентификаторам.
Это основные, интересные нам методы, к тому же не требующие авторизации и использования токенов. Больше методов можно посмотреть в [разделе документации](http://vk.com/dev/database).
Пример url для обращения к методу получения списка стран представлен ниже (аналогично происходит обращение по протоколу https):
<http://api.vk.com/method/database.getCountries?v=5.5&need_all=1&count=10>
**Посмотреть результат**`{"response":{"count":234,"items":[{"id":19,"title":"Австралия"},{"id":20,"title":"Австрия"},{"id":5,"title":"Азербайджан"},{"id":21,"title":"Албания"},{"id":22,"title":"Алжир"},{"id":23,"title":"Американское Самоа"},{"id":24,"title":"Ангилья"},{"id":25,"title":"Ангола"},{"id":26,"title":"Андорра"},{"id":27,"title":"Антигуа и Барбуда"}]}}`
Параметры:
**v** — указывает на версию API. В разных версиях структура JSON будет разной. Например, начиная с версии 5.0 добавлено значение count, которое содержит общее количество элементов в выборке и при совместном использовании с параметром offset поможет получить все значения. По умолчанию данные возвращаются в старой версии (видимо для совместимости со старыми приложениями).
**count** — максимальное количество значений, возвращаемых методом. Максимальное значение параметра, которое можно задать, составляет 1000 элементов. Минимальное и значение по умолчанию для каждого метода может отличаться и следует сверяться с документацией.
**need\_all** — необязательный параметр, по умолчанию равен «0», указывает на то, что не следует производить выборку небольших регионов/стран/населенных пунктов
Остальные параметры для каждой функции расписывать нет смысла, так они есть в официальной документации, перейдем же к неофициальным возможностям:
#### Получаем список стран для различных языков
```
php
$lang = 0; // russian
$headerOptions = array(
'http' = array(
'method' => "GET",
'header' => "Accept-language: en\r\n" .
"Cookie: remixlang=$lang\r\n"
)
);
$methodUrl = 'http://api.vk.com/method/database.getCountries?v=5.5&need_all=1&count=1000';
$streamContext = stream_context_create($headerOptions);
$json = file_get_contents($methodUrl, false, $streamContext);
$arr = json_decode($json, true);
echo 'Total countries count: ' . $arr['response']['count'] . ' loaded: ' . count($arr['response']['items']);
print_r($arr['response']['items']);
```
Стоит обратить внимание, что метод пытается вернуть данные на языке, указанном в cookie параметре **remixlang**. Поэтому подставив числовое значение необходимого языка, получим данные на необходимом языке, если присутствует перевод. Страны переведены все, вроде бы на все языки, доступные в социальной сети. Для регионов и городов: если перевод отсутствует (мелкие населенные пункты, регионы небольших стран), то получим значение на популярном в данном регионе языке например в африканских странах, на английском, для стран СНГ — русском.
Вот краткий список идентификаторов языков:
| | |
| --- | --- |
| Язык | Значение remixlang |
| Русский | 0 |
| Украинский | 1 |
| Английский | 3 |
| Испанский | 4 |
| Португальский | 12 |
| Немецкий | 6 |
| Французский | 16 |
| Итальянский | 7 |
#### Получаем список регионов для различных языков
Пример url для обращения к методу получения списка регионов для страны заданной, параметром **country\_id** (обязательный параметр):
<http://api.vk.com/method/database.getRegions?v=5.5&need_all=1&offset=0&count=1000&country_id=>
```
php
$countryId = 1; // Russia
$lang = 0; // russian
$headerOptions = array(
'http' = array(
'method' => "GET",
'header' => "Accept-language: en\r\n" . // Вероятно этот параметр ни на что не влияет
"Cookie: remixlang=$lang\r\n"
)
);
$methodUrl = 'http://api.vk.com/method/database.getRegions?v=5.5&need_all=1&offset=0&count=1000&country_id=' . $countryId;
$streamContext = stream_context_create($headerOptions);
$json = file_get_contents($methodUrl, false, $streamContext);
$arr = json_decode($json, true);
echo 'Total regions count: ' . $arr['response']['count'] . ' loaded: ' . count($arr['response']['items']);
print_r($arr['response']['items']);
```
Перечень параметров, для метода и описание можно посмотреть в документации. Однако стоит заметить, что возвращенный JSON может быть пустым, т. е. не для всех стран могут быть заданы регионы, в таком случае, при получении списка городов параметр region\_id можно опустить.
#### Получаем список населенных пунктов
Пример url для обращения к методу получения списка городов для страны заданной, параметром **country\_id** (обязательный параметр) и региона **region\_id** (необязательный параметр):
[http://api.vk.com/method/database.getCities?v=5.5&country\_id=1®ion\_id=1045244&offset=0&need\_all=1&count=1000](http://api.vk.com/method/database.getCities?v=5.5&country_id=1®ion_id=1045244&offset=0&need_all=1&count=1000)
```
php
$regionId = 1045244;
$countryId = 1; // Russia
$lang = 0;
$headerOptions = array(
'http' = array(
'method' => "GET",
'header' => "Accept-language: en\r\n" .
"Cookie: remixlang=$lang\r\n"
)
);
$methodUrl = 'http://api.vk.com/method/database.getCities?v=5.5&country_id=' . $countryId . '®ion_id=' . $regionId . '&offset=0&need_all=1&count=1000';
$streamContext = stream_context_create($headerOptions);
$json = file_get_contents($methodUrl, false, $streamContext);
$arr = json_decode($json, true);
echo 'Total cities count: ' . $arr['response']['count'] . ' loaded: ' . count($arr['response']['items']);
print_r($arr['response']['items']);
```
Возвращаемые данные для каждого населенного пункта могут также содержать следующие параметры:
**area** — название района (провинции и т. д.)
**important** равное «1» — обозначение крупных городов, появляется только при использовании параметра need\_all
**Внимание!** Некоторые регионы могут не содержать населенных пунктов (или сами являться населенными пунктами, как я понял).
#### Коллизии
Некоторые полученные значения могут содержать спецсимволы, теги (например ``и`).` | https://habr.com/ru/post/204840/ | null | ru | null |
# Ускоряем сборку веб-приложения с webpack
По мере того как ваше приложение развивается и растёт, увеличивается и время его сборки — от нескольких минут при пересборке в development-режиме до десятков минут при «холодной» production-сборке. Это совершенно неприемлемо. Мы, разработчики, не любим переключать контекст в ожидании готовности бандла и хотим получать фидбек от приложения как можно раньше — в идеале за то время, пока переключаемся с IDE на браузер.
Как этого достичь? Что мы можем сделать, чтобы оптимизировать время сборки?
Эта статья — обзор существующих в экосистеме webpack инструментов для ускорения сборки, опыт их применения и советы.
Оптимизации размера бандла и производительности самого приложения в этой статье не рассматриваются.
Проект, отсылки к которому встречаются в тексте и относительно которого выполняются замеры скорости сборки, — это сравнительно небольшое приложение, написанное на стеке JS + Flow + React + Redux с использованием webpack, Babel, PostCSS, Sass и др. и состоящее из примерно 30 тысяч строк кода и 1500 модулей. Версии зависимостей актуальны на апрель 2019 года.
Исследования проводились на компьютере с Windows 10, Node.js 8, 4-ядерным процессором, 8 ГБ памяти и SSD.
Терминология
------------
* Сборка — процесс преобразования исходных файлов проекта в набор связанных ассетов, в совокупности составляющих веб-приложение.
* dev-режим — сборка с опцией `mode: 'development'`, обычно с использованием webpack-dev-server и watch-режима.
* prod-режим — сборка с опцией `mode: 'production'`, обычно с полным набором оптимизаций бандла.
* Инкрементальная сборка — в dev-режиме: пересборка только файлов с изменениями.
* «Холодная» сборка — сборка с нуля, без каких-либо кешей, но с установленными зависимостями.
Кеширование
-----------
Кеширование позволяет сохранять результаты вычислений для дальнейшего переиспользования. Первая сборка может быть немного медленнее обычной из-за накладных расходов на кеширование, однако последующие будут гораздо быстрее за счёт переиспользования результатов компиляции неизменившихся модулей.
По умолчанию webpack в watch-режиме [кеширует в памяти](https://webpack.js.org/configuration/other-options/#cache) промежуточные результаты сборки, чтобы не пересобирать весь проект при каждом изменении. Для обычной сборки (не в watch-режиме) эта настройка не имеет смысла. Также можно попробовать включить [кеш-резолвинг](https://webpack.js.org/configuration/resolve#resolveunsafecache), чтобы упростить webpack работу по поиску модулей и посмотреть, оказывает ли эта настройка заметный эффект на ваш проект.
Персистентного (сохраняемого на диск или в другое хранилище) кеша в webpack пока нет, хотя в 5-й версии его [обещают добавить](https://github.com/webpack/changelog-v5/blob/master/README.md#persistent-caching). А пока мы можем использовать следующие инструменты:
**— Кеширование в [настройках TerserWebpackPlugin](https://github.com/webpack-contrib/terser-webpack-plugin#cache)**
По умолчанию отключено. Даже в одиночку оказывает заметный положительный эффект: 60,7 с → 39 с (-36%), отлично сочетается с другими инструментами для кеширования.
Включить и использовать очень просто:
```
optimization: {
minimizer: [
new TerserJsPlugin({
terserOptions: { ... },
cache: true
})
]
}
```
**— [cache-loader](https://github.com/webpack-contrib/cache-loader)**
Cache-loader можно поместить в любую цепочку лоадеров и закешировать результаты работы предшествующих лоадеров.
По умолчанию сохраняет кеш в папку .cache-loader в корне проекта. С помощью опции `cacheDirectory` в настройках лоадера путь можно переопределить.
Пример использования:
```
{
test: /\.js$/,
use: [
{
loader: 'cache-loader',
options: {
cacheDirectory: path.resolve(
__dirname,
'node_modules/.cache/cache-loader'
),
},
},
'babel-loader'
]
}
```
Безопасное и надёжное решение. Без проблем работает практически с любыми лоадерами: для скриптов (babel-loader, ts-loader), стилей (scss-, less-, postcss-, css-loader), изображений и шрифтов (image-webpack-loader, react-svg-loader, file-loader) и др.
Обратите внимание:
* При использовании cache-loader совместно со style-loader или MiniCssExtractPlugin.loader он должен быть помещён *после* них:
`['style-loader', 'cache-loader', 'css-loader', ...]`.
* Вопреки рекомендациям документации использовать этот лоадер для кеширования результатов только трудоёмких вычислений, он вполне может дать хоть и небольшой, но измеримый прирост производительности и для более «лёгких» лоадеров — нужно пробовать и замерять.
Результаты:
* dev: 35,5 с → (включаем cache-loader) → 36,2 с (+2%) → (повторная сборка) → 7,9 с (-78%)
* prod: 60,6 с → (включаем cache-loader) → 61,5 с (+1,5%) → (повторная сборка) → 30,6 с (-49%) → (включаем кеш у Terser) → 15,4 с (-75%)
**— [HardSourceWebpackPlugin](https://github.com/mzgoddard/hard-source-webpack-plugin)**
Более массивное и «умное» решение для кеширования на уровне всего сборочного процесса, а не отдельных цепочек лоадеров. В базовом варианте использования достаточно добавить плагин в конфигурацию webpack, стандартных настроек должно быть достаточно для корректной работы. Подойдёт тем, кто хочет добиться максимальной производительности и не боится столкнуться с трудностями.
```
plugins: [
...,
new HardSourceWebpackPlugin()
]
```
В [документации](https://github.com/mzgoddard/hard-source-webpack-plugin/blob/master/README.md) есть примеры использования с расширенными настройками и советы по решению возможных проблем. Перед вводом плагина в эксплуатацию на постоянной основе стоит тщательно протестировать его работу в различных ситуациях и режимах сборки.
Результаты:
* dev: 35,5 с → (включаем плагин) → 36,5 с (+3%) → (повторная сборка) → 3,7 с (-90%)
* prod: 60,6 с → (включаем плагин) → 69,5 с (+15%) → (повторная сборка) → 25 с (-59%) → (включаем кеш у Terser) → 10 с (-83%)
Плюсы:
* по сравнению с cache-loader ещё больше ускоряет повторные сборки;
* не требует дублирования объявлений в разных местах конфигурации, как у cache-loader.
Минусы:
* по сравнению с cache-loader сильнее замедляет первую сборку (когда дисковый кеш отсутствует);
* может немного увеличивать время инкрементальной пересборки;
* может вызывать проблемы при использовании webpack-dev-server и требовать детальной настройки разделения и инвалидации кешей (см. [документацию](https://github.com/mzgoddard/hard-source-webpack-plugin#troubleshooting));
* достаточно много [issues](https://github.com/mzgoddard/hard-source-webpack-plugin/issues) с багами на GitHub.
**— Кеширование в [настройках babel-loader](https://github.com/babel/babel-loader#options)**. По умолчанию отключено. Эффект на несколько процентов хуже, чем от cache-loader.
**— Кеширование в [настройках eslint-loader](https://github.com/webpack-contrib/eslint-loader#cache-default-false)**. По умолчанию отключено. Если вы используете этот лоадер, кеш поможет не тратить время на линтинг неизменившихся файлов при повторной сборке.
---
При использовании cache-loader или HardSourceWebpackPlugin нужно отключить встроенные механизмы кеширования в других плагинах или лоадерах (кроме TerserWebpackPlugin), так как они перестанут приносить пользу при повторных и инкрементальных сборках, а «холодные» даже замедлят. То же относится к самому cache-loader, если уже используется HardSourceWebpackPlugin.
---
При настройке кеширования могут возникнуть следующие вопросы:
*Куда следует сохранять результаты кеширования?*
Кеши обычно хранятся в каталоге `node_modules/.cache/<название_кеша>/`. Большинство инструментов по умолчанию используют этот путь и позволяют его переопределить, если вы желаете хранить кеш в другом месте.
*Когда и как инвалидировать кеш?*
Очень важно сбрасывать кеш при изменениях конфигурации сборки, которые повлияют на выходной результат. Использование старого кеша в таких случаях вредно и может привести к возникновению ошибок неизвестной природы.
Факторы, которые нужно принимать во внимание:
* список зависимостей и их версии: package.json, package-lock.json, yarn.lock, .yarn-integrity;
* содержимое конфигурационных файлов webpack, Babel, PostCSS, browserslist и других, которые явно или неявно используются лоадерами и плагинами.
Если вы не используете cache-loader или HardSourceWebpackPlugin, которые позволяют переопределять список источников для формирования отпечатка сборки, немного облегчить жизнь вам помогут npm-скрипты, очищающие кеш при добавлении, обновлении или удалении зависимостей:
```
"prunecaches": "rimraf ./node_modules/.cache/",
"postinstall": "npm run prunecaches",
"postuninstall": "npm run prunecaches"
```
Также помогут [nodemon](https://github.com/remy/nodemon), настроенный на очистку кеша, и рестарт webpack-dev-server при обнаружении изменений в конфигурационных файлах:
```
"start": "cross-env NODE_ENV=development nodemon --exec \"webpack-dev-server --config webpack.config.dev.js\""
```
nodemon.json
```
{
"watch": [
"webpack.config.dev.js",
"babel.config.js",
"more configs...",
],
"events": {
"restart": "yarn prunecaches"
}
}
```
*Нужно ли сохранять кеш в репозитории проекта?*
Так как кеш является, по сути, артефактом сборки, в репозиторий его коммитить не нужно. Как раз с этим поможет расположение кеша внутри папки node\_modules, которая, как правило, внесена в .gitignore.
Стоит заметить, что при наличии системы кеширования, умеющей надёжно определять валидность кеша при любых условиях, включая смену ОС и версии Node.js, кеш можно было бы переиспользовать между машинами разработчиков или в CI, что позволило бы радикально сократить время даже самой первой сборки после переключения между ветками.
*В каких режимах сборки стоит, а в каких не стоит использовать кеш?*
Однозначного ответа здесь нет: всё зависит от того, как интенсивно вы пользуетесь при разработке dev- и prod-режимами и переключаетесь между ними. В целом, ничто не мешает включить кеширование везде, однако помните, что оно обычно делает медленнее первую сборку. В CI вам, вероятно, всегда нужна «чистая» сборка, и в этом случае кеширование можно отключить с помощью соответствующей переменной окружения.
---
Интересные материалы про кеширование в webpack:
* <https://github.com/webpack/webpack/issues/6527> — черновик и обсуждение спецификации по добавлению в webpack 5 системы кеширования от автора HardSourcePlugin
* <https://gist.github.com/mzgoddard/0b42ad50048f407c1f3ac434a874f8e1> — рассуждения автора HardSourcePlugin о том, как должна быть реализована система кеширования в webpack
* <https://github.com/webpack-contrib/cache-loader/issues/11> — мнения об использовании cache-loader совместно с HardSourcePlugin
* <https://github.com/webpack/webpack/issues/250> — обсуждение возможностей webpack по кешированию
* <https://github.com/mzgoddard/hard-source-webpack-plugin/issues/251> — мнения об использовании HardSourcePlugin совместно с AutoDllPlugin
Параллелизация
--------------
С помощью параллелизации можно получить прирост производительности, задействовав все доступные ядра процессора. Конечный эффект индивидуален для каждой машины.
Кстати, вот простой Node.js-код для получения количества доступных процессорных ядер (может пригодиться при настройке перечисленных ниже инструментов):
```
const os = require('os');
const cores = os.cpus().length;
```
**— Параллелизация в [настройках TerserWebpackPlugin](https://github.com/webpack-contrib/terser-webpack-plugin#parallel)**
По умолчанию отключена. Так же, как и собственное кеширование, легко включается и заметно ускоряет сборку.
```
optimization: {
minimizer: [
new TerserJsPlugin({
terserOptions: { ... },
parallel: true
})
]
}
```
**— [thread-loader](https://github.com/webpack-contrib/thread-loader)**
Thread-loader можно поместить в цепочку лоадеров, производящих тяжёлые вычисления, после чего предшествующие лоадеры будут использовать пул подпроцессов Node.js («воркеров»).
Имеет набор опций, которые позволяют достаточно тонко настроить работу пула воркеров, хотя и базовые значения выглядят вполне адекватно. Отдельного внимания заслуживают `poolTimeout` и `workers` — см. [пример](https://github.com/TypeStrong/ts-loader/blob/master/examples/thread-loader/webpack.config.js).
Может быть использован совместно с cache-loader следующим образом (порядок важен): `['cache-loader', 'thread-loader', 'babel-loader']`. Если для thread-loader включён «прогрев» (warmup), стоит перепроверить стабильность повторных сборок, использующих кеш — webpack может зависать и не завершать процесс после успешного окончания сборки. В этом случае достаточно отключить warmup.
Если вы столкнётесь с зависанием сборки после добавления thread-loader в цепочку компиляции Sass-стилей, вам может помочь [этот совет](https://webpack.js.org/guides/build-performance/#sass).
**— [HappyPack](https://github.com/amireh/happypack)**
Плагин, который перехватывает вызовы лоадеров и распределяет их работу по нескольким потокам. На данный момент находится в режиме поддержки (то есть развитие не планируется), а его создатель [рекомендует](https://github.com/amireh/happypack#is-it-necessary-for-webpack-4) thread-loader в качестве замены. Таким образом, если ваш проект идёт в ногу со временем, от использования HappyPack лучше воздержаться, хотя попробовать и сравнить результаты с thread-loader, безусловно, стоит.
HappyPack имеет понятную [документацию](https://github.com/amireh/happypack/blob/master/README.md) по настройке, которая, кстати, довольно необычна сама по себе: конфигурации лоадеров предлагается переместить в вызов конструктора плагина, а сами цепочки лоадеров заменить на собственный лоадер happypack. Такой нестандартный подход может стать причиной неудобств при создании кастомной конфигурации webpack «из кусочков».
HappyPack поддерживает [ограниченный список лоадеров](https://github.com/amireh/happypack/wiki/Loader-Compatibility-List); основные и наиболее широко используемые в этом списке присутствуют, а вот работоспособность других не гарантируется по причине возможной несовместимости API. Больше информации можно найти в [issues](https://github.com/amireh/happypack/issues) проекта.
Отказ от вычислений
-------------------
Любая работа занимает время. Чтобы тратить меньше времени, нужно избегать работы, которая приносит мало пользы, может быть отложена на потом или вообще не нужна в данной ситуации.
**— Применять лоадеры к минимально возможному числу модулей**
[Свойства test, exclude и include](https://webpack.js.org/configuration/module#condition) задают условия для включения модуля в процесс обработки лоадером. Смысл — избегать трансформации модулей, которые не нуждаются в этой трансформации.
Популярный пример — исключение node\_modules из транспиляции через Babel:
```
rules: [
{
test: /\.jsx?$/,
exclude: /node_modules/,
loader: 'babel-loader'
}
]
```
Другой пример — обычные CSS-файлы не требуется обрабатывать препроцессором:
```
rules: [
{
test: /\.scss$/,
use: ['style-loader', 'css-loader', 'sass-loader']
},
{
test: /\.css$/,
use: ['style-loader', 'css-loader']
}
]
```
**— Не включать оптимизации размера бандла в dev-режиме**
На мощной машине разработчика со стабильным интернетом развёрнутое локально приложение обычно запускается быстро, даже если весит несколько мегабайт. Оптимизация бандла при сборке может отнять гораздо больше драгоценного времени, чем сэкономить при загрузке.
Совет касается JS (Terser, Uglify [и др.](https://survivejs.com/webpack/optimizing/minifying/#other-ways-to-minify-javascript)), CSS (cssnano, optimize-css-assets-webpack-plugin), SVG и изображений (SVGO, Imagemin, image-webpack-loader), HTML (html-minifier, опция в html-webpack-plugin) и др.
**— Не включать полифиллы и трансформации в dev-режиме**
Если вы используете babel-preset-env, postcss-preset-env или Autoprefixer — добавьте [отдельную конфигурацию Browserslist](https://github.com/browserslist/browserslist#environments) для dev-режима, включающую только те браузеры, которые используются вами при разработке. Скорее всего, это последние версии Chrome или Firefox, отлично поддерживающие современные стандарты без полифиллов и трансформаций. Это позволит избегать ненужной работы.
Пример .browserslistrc:
```
[production]
your supported browsers go here...
[development]
last 2 Chrome versions
last 2 Firefox versions
last 1 Safari version
```
**— Пересмотреть использование source maps**
Генерирование наиболее точных и полных source maps занимает значительное время (на нашем проекте — около 30% времени prod-сборки с опцией `devtool: 'source-map'`). Подумайте, нужны ли вам source maps в prod-сборке (локально и в CI). Возможно, стоит генерировать их только при необходимости — например, на основе переменной окружения или тега у коммита.
В dev-режиме в большинстве случаев будет достаточно облегчённого варианта — `'cheap-eval-source-map'` или `'cheap-module-eval-source-map'`. Подробнее см. в [документации](https://webpack.js.org/configuration/devtool/) webpack.
**— Настроить сжатие в Terser**
Согласно [документации Terser](https://github.com/terser-js/terser#terser-fast-minify-mode) (то же самое относится и к Uglify), при минификации кода подавляющую часть времени «съедают» опции `mangle` и `compress`. Тонкой их настройкой можно добиться ускорения сборки ценой незначительного увеличения размера бандла. Есть [пример](https://github.com/vuejs/vue-cli/blob/dev/packages/%40vue/cli-service/lib/config/terserOptions.js) в исходниках vue-cli и [другой пример](https://gist.github.com/rowanoulton/44ec3424ac1e86b63316d522e1b99a16#file-webpack-config-js) от инженера из Slack. В нашем проекте тюнинг Terser по первому варианту сокращает время сборки примерно на 7% в обмен на 2,5-процентное увеличение размера бандла. Стоит ли игра свеч — решать вам.
**— Исключать внешние зависимости из парсинга**
С помощью опций [`module.noParse`](https://webpack.js.org/configuration/module#modulenoparse) и [`resolve.alias`](https://webpack.js.org/configuration/resolve/#resolvealias) можно перенаправить импортирование библиотечных модулей на уже скомпилированные версии и просто вставлять их в бандл, не тратя время на парсинг. В dev-режиме это должно значительно повысить скорость сборки, в том числе инкрементальной.
Алгоритм примерно следующий:
(1) Составить список модулей, которые нужно пропускать при парсинге.
В идеале это все runtime-зависимости, попадающие в бандл (или хотя бы самые массивные из них, такие как react-dom или lodash), причём не только собственные (первого уровня), но и транзитивные (зависимости зависимостей). Поддерживать этот список в дальнейшем придётся самостоятельно.
(2) Для выбранных модулей выписать пути к их скомпилированным версиям.
Вместо пропускаемых зависимостей нужно предоставить сборщику альтернативу, причём эта альтернатива не должна зависеть от окружения — иметь обращений к `module.exports`, `require`, `process`, `import` и т.д. На эту роль подходят заранее скомпилированные (не обязательно минифицированные) single-file модули, которые обычно лежат в папке dist внутри исходников зависимости. Чтобы найти их, придётся отправиться в node\_modules. Например, для axios путь к скомпилированному модулю выглядит так: `node_modules/axios/dist/axios.js`.
(3) В конфигурации webpack использовать опцию `resolve.alias` для замены импортов по названиям зависимостей на прямые импорты файлов, пути к которым были выписаны на предыдущем шаге.
Например:
```
{
resolve: {
alias: {
axios: path.resolve(
__dirname,
'node_modules/dist/axios.min.js'
),
...
}
}
}
```
Здесь кроется большой недостаток: если ваш код или код ваших зависимостей обращается не к стандартной точке входа (индексный файл, поле `main` в `package.json`), а к конкретному файлу внутри исходников зависимости, или если зависимость экспортируется как ES-модуль, или если в процесс резолвинга что-то вмешивается (например, babel-plugin-transform-imports), вся затея может провалиться. Бандл соберётся, однако приложение будет сломано.
(4) В конфигурации webpack использовать опцию `module.noParse`, чтобы с помощью регулярных выражений пропускать парсинг предкомпилированных модулей, запрашиваемых по путям из шага 2.
Например:
```
{
module: {
noParse: [
new RegExp('node_modules/dist/axios.min.js'),
...
]
}
}
```
Итого: на бумаге способ выглядит многообещающе, однако нетривиальная настройка с подводными камнями как минимум повышает затраты на внедрение, а как максимум — сводит пользу на нет.
Альтернативный вариант с похожим принципом работы — использование опции [`externals`](https://webpack.js.org/configuration/externals). В этом случае придётся самостоятельно вставлять в HTML-файл ссылки на внешние скрипты, да ещё и с нужными версиями зависимостей, соответствующими package.json.
**— Выделять редко изменяющийся код в отдельный бандл и компилировать его только один раз**
Наверняка вы слышали про [DllPlugin](https://webpack.js.org/plugins/dll-plugin/). С его помощью можно разнести по разным сборкам активно меняющийся код (ваше приложение) и редко меняющийся код (например, зависимости). Единожды собранный бандл с зависимостями (тот самый DLL) затем просто подключается к сборке приложения — получается экономия времени.
Выглядит это в общих чертах так:
1. Для сборки DLL создаётся отдельная конфигурация webpack, необходимые модули подключаются как точки входа.
2. Запускается сборка по этой конфигурации. DllPlugin генерирует DLL-бандл и файл-манифест с маппингами имён и путей к модулям.
3. В конфигурацию основной сборки добавляется DllReferencePlugin, в который передаётся манифест.
4. Импорты зависимостей, вынесенных в DLL, при сборке отображаются на уже скомпилированные модули с помощью манифеста.
Немного подробнее можно прочитать в статье по [ссылке](https://robertknight.me.uk/posts/webpack-dll-plugins/).
Начав использовать этот подход, вы довольно быстро обнаружите ряд недостатков:
* Сборка DLL обособлена от основной сборки, и ей нужно управлять отдельно: подготовить специальную конфигурацию, запускать заново каждый раз при переключении ветки или изменении в зависимостях.
* Так как DLL-библиотека не относится к артефактам основной сборки, её нужно будет вручную скопировать в папку с остальными ассетами и подключить в HTML-файле с помощью одного из этих плагинов: [1](https://github.com/SimenB/add-asset-html-webpack-plugin), [2](https://github.com/jharris4/html-webpack-include-assets-plugin).
* Нужно вручную поддерживать в актуальном состоянии список зависимостей, предназначенных для включения в DLL-бандл.
* Самое грустное: к DLL-бандлу не применяется tree-shaking. По идее, для этого предназначена опция [`entryOnly`](https://github.com/webpack/webpack/pull/7344), однако её забыли задокументировать.
Избавиться от бойлерплейта и решить первую проблему (а также вторую, если вы используете html-webpack-plugin v3 — с 4-й версией не работает) можно с помощью [AutoDllPlugin](https://github.com/asfktz/autodll-webpack-plugin). Однако в нём до сих пор не поддержана опция `entryOnly` для используемого «под капотом» DllPlugin, а сам автор плагина сомневается в целесообразности использования своего детища в свете скорого прихода webpack 5.
Разное
------
Регулярно обновляйте ваше ПО и зависимости. Более свежие версии Node.js, npm / yarn и инструментов для сборки (webpack, Babel и др.) часто содержат улучшения производительности. Разумеется, перед началом эксплуатации новой версии стоит внимательно ознакомиться с changelog, issues, отчётами по безопасности, убедиться в стабильности и провести тестирование.
При использовании PostCSS и [postcss-preset-env](https://github.com/csstools/postcss-preset-env) обратите внимание на настройку stage, которая отвечает за набор поддерживаемых фич. Например, в нашем проекте был установлен stage-3, из которого использовались только Custom Properties, и переключение на stage-4 сократило время сборки на 13%.
Если вы используете Sass (node-sass, sass-loader), попробуйте [Dart Sass](https://sass-lang.com/dart-sass) (реализация Sass на Dart, скомпилированная в JS) и [fast-sass-loader](https://github.com/yibn2008/fast-sass-loader). Возможно, на вашем проекте они дадут прирост производительности сборки. Но даже если не дадут — dart-sass хотя бы устанавливается быстрее, чем node-sass, потому что является чистым JS, а не биндингом для libsass.
Пример использования Dart Sass можно найти в [документации sass-loader](https://github.com/webpack-contrib/sass-loader#examples). Обратите внимание на явное указание конкретной имплементации препроцессора Sass и использование модуля fibers.
Если вы используете CSS-модули, попробуйте отключить добавление хешей в сгенерированные имена классов в dev-режиме. Генерирование уникальных идентификаторов занимает какое-то время, которое можно сэкономить, если включения путей к файлам в имена классов достаточно, чтобы избежать коллизий.
Пример:
```
{
loader: 'css-loader',
options: {
modules: true,
localIdentName: isDev
? '[path][name][local]'
: '[hash:base64:5]'
}
}
```
Выгода, тем не менее, невелика: на нашем проекте это менее полсекунды.
Возможно, вы когда-нибудь встречали в документации webpack таинственный [PrefetchPlugin](https://webpack.js.org/plugins/prefetch-plugin/), который вроде бы обещает ускорить сборку, но каким образом — неизвестно. Создатель webpack в [одном из issues](https://github.com/webpack/webpack/issues/1566#issuecomment-244728689) кратко рассказал о том, какую проблему решает этот плагин. Однако как же его использовать?
1. Выгрузить в файл статистику сборки. Это делается с помощью CLI-опции `--json`, подробнее см. в [документации](https://webpack.js.org/api/stats). Актуально, скорее всего, только для dev-режима сборки.
2. Загрузить полученный файл в специальный [онлайн-анализатор](https://webpack.github.io/analyse/) и перейти на вкладку Hints.
3. Найти секцию, озаглавленную “Long module build chains”. Если её нет, на этом можно закончить — PrefetchPlugin не понадобится.
4. Для найденных длинных цепочек использовать PrefetchPlugin. В качестве стартового примера см. [топик на StackOverflow](https://stackoverflow.com/questions/32923085/how-to-optimize-webpacks-build-time-using-prefetchplugin-analyse-tool).
Итого: слабо документированный способ без гарантии на заметный положительный результат.
В качестве заключения
---------------------
Если у вас есть дополнения, особенно с примерами на других технологиях (TypeScript, Angular и др.) — пишите в комментариях!
Источники
---------
Некоторые из них частично устарели, но, тем не менее, послужили основой для написания данной статьи.
* <https://webpack.js.org/guides/build-performance/>
* <https://survivejs.com/webpack/optimizing/performance/>
* <https://github.com/webpack/docs/wiki/build-performance>
* <https://slack.engineering/keep-webpack-fast-a-field-guide-for-better-build-performance-f56a5995e8f1>
* <https://medium.com/webpack/typescript-webpack-super-pursuit-mode-83cc568dea79>
* <https://medium.com/ottofellercom/0-100-in-two-seconds-speed-up-webpack-465de691ed4a>
* <https://medium.com/onfido-tech/speed-up-webpack-ff53c494b89c>
* <https://blog.box.com/blog/how-we-improved-webpack-build-performance-95>
* <https://engineering.bitnami.com/articles/optimizing-your-webpack-builds.html>
* <https://habr.com/ru/company/skbkontur/blog/351080/>
* <https://habr.com/ru/company/oleg-bunin/blog/433324/>
* <https://github.com/lcxfs1991/blog/issues/15>
* <https://github.com/FrendEr/webpack-optimize-example> | https://habr.com/ru/post/451146/ | null | ru | null |
# (Архив) Matreshka.js 1.1: еще больше крутостей
[](http://matreshka.io)
* [Matreshka.js: От простого к простому](http://habrahabr.ru/company/matreshka/blog/254889/)
* [10 причин попробовать Матрешку](http://habrahabr.ru/company/matreshka/blog/254927/)
* **Matreshka.js 1.1: еще больше крутостей**
* [Matreshka.js: события](http://habrahabr.ru/company/matreshka/blog/267513/)
[Документация на русском](http://ru.matreshka.io/)
[Github репозиторий](https://github.com/finom/matreshka)
Всем привет. Сегодня, 28 сентября исполняется два года с первого коммита в репозиторий Матрешки. Так совпало, что к этому времени подоспел новый релиз со всякими вкусностями для любого JavaScript разработчика (даже для тех, кто не хочет использовать Матрешку в качестве фреймворка).
Матрешка — это JavaScript фреймворк (или, если хотите, библиотека), основанный на акцессорах, и выжавшая из них невероятные, на первый взгляд, возможности. Помните, время, когда в JavaScript геттеры и сеттеры только-только появились? Сколько шума было вокруг них… Статьи, разговоры… Затем, всё затихло: многие не понимали, как этими возможностями воспользоваться, кроме как в простых примерах. Матрешка — это прекрасный ответ на вопрос, зачем нужны акцессоры в JavaScript.
По традиции, напомню о том, что умеет этот фреймворк с помощью маленького кусочка кода.
Раньше можно было делать только так:
```
// this - экземпляр Матрешки
// связываем свойство "x" с элементом на стрнице
this.bindNode('x', 'input.my-node');
// если изменилось, выводим alert
this.on('change:x', function() {
alert(this.x);
});
// меняем свойство, вызывается обработчик
// меняется и привязаннык к "x" элемент
this.x = 'Wow!';
```
Теперь можно еще и так:
```
var object = {};
// связываем свойство "x" с элементом на стрнице
MK.bindNode(object, 'x', 'input.my-node');
// если изменилось, выводим alert
MK.on(object, 'change:x', function() {
alert(object.x);
});
// меняем свойство, вызывается обработчик
// меняется и привязаннык к "x" элемент
object.x = 'Wow!';
```
Из-за того, что последние версии Chrome и NodeJS стали, наконец, поддерживать большинство элементов синтаксиса ES6, все примеры ниже в этом посте будут написаны на ES6. Таким нехитрым способом я хочу поздравить всех, кто считает эти нововведения невероятно крутыми и привлечь внимание к ES.next тех, кто с ними еще не знаком.
Поддержка нативных объектов
===========================
Самым главным нововведением стала поддержка Матрешкой произвольных объектов. Да-да, для того, чтоб объявить байндинг или сделать еще что-нибудь крутое, не обязательно создавать экземпляр Матрешки.
```
let object = {};
//связываем свойство "x” с элементом '.my-node'
MK.bindNode(object, 'x', '.my-node');
// "y” всегда будет суммой значений свойств x и z
MK.linkProps(object, 'y', 'x z', (x, z) => x + z);
//”z” - это всегда число, независимо то того, какой тип мы ему присвоим
MK.mediate(object, 'z', Number);
// ...
```
Как видно из примера, новые статичные методы полностью повторяют динамические с одним маленьким отличием: им нужно передать исходный объект в качестве первого аргумента:
```
//было
this.bindNode('x', '.my-node');
//стало
MK.bindNode(object, 'x', '.my-node');
```
Кроме этого, коллекции, умеющие сами себя рендерить, теперь не требуют указания [модели](http://ru.matreshka.io/#!Matreshka.Array-Model), которая раньше должна была наследоваться от класса [Matreshka](http://ru.matreshka.io/#!Matreshka).
```
class MyArray extends MK.Array {
itemRenderer() {
return '- ';
}
constructor() {
super().bindNode('sandbox', '.some-node');
}
}
let arr = new MyArr();
arr.push(someData);
```
Полный список новых статичных методов перечислен в разделе [MatreshkaMagic](http://ru.matreshka.io/#!matreshka-magic).
Библиотека [MatreshkaMagic](http://ru.matreshka.io/#!matreshka-magic)
=====================================================================
Благодаря поддержке нативных объектов появиласть возможность вынести все «магические» функции в отдельную, более компактную библиотеку, не включающую в себя классы [Matreshka](http://ru.matreshka.io/#!Matreshka), [Matreshka.Array](http://ru.matreshka.io/#!Matreshka.Array), [Matreshka.Object](http://ru.matreshka.io/#!Matreshka.Object) и функцию [Class](http://ru.matreshka.io/#!Class). Разработчику доступен объект `MatreshkaMagic` или более краткий вариант `magic`, содержащий все статичные методы класса `Matreshka`.
Библиотека находится в папке [magic/](https://github.com/finom/matreshka/tree/master/magic) репозитория.
```
magic.bindNode(object, 'x', '.my-node');
magic.linkProps(object, 'y', 'x z', (x, z) => x + z);
// и т. д.
```
Подробнее о библиотеке [в документации](http://ru.matreshka.io/#!matreshka-magic).
«Глубокое связывание»
=====================
Еще одна крутая фича, появившаяся благодаря поддержке нативных объектов — это так называемое «глубокое связывание». Имея объект произвольной вложенности, можно связать DOM ноду с любым свойством где-то в глубине этого объекта.
```
this.a = {b: {c: {d: 41}}}
this.bindNode('a.b.c.d', '.my-node');
```
Ядро Матрешки следит за всей веткой объектов и переустанавливает байндинг если один из объектов ветки переопределен
```
this.a.b = {c: {d: 42}};
```
«Глубокие ссылки»
=================
Матрешка давно включает в себя метод [linkProps](http://ru.matreshka.io/#!Matreshka.linkProps), позволяющий задать зависимость одних свойств от других.
Можно задать зависимость от собственных свойств:
```
this.linkProps('a', 'b c d', (b, c, d) => b + c + d);
this.b = 1;
this.c = 2;
this.d = 3;
alert(this.a); // 6
```
Можно задать зависимость от свойств других объектов:
```
this.linkProps('a', [
externalObject, 'b',
externalObject2, 'c',
this, 'd'
]);
externalObject.b = 1;
externalObject2.c = 2;
this.d = 3;
alert(this.a); // 6
```
Теперь `linkProps` поддерживает указание пути к свойству:
```
this.linkProps('a', 'b.c.d e.f', (d, f) => d + f);
this.b = {c: {d: 40}};
this.e = {f: 2};
alert(this.a); // 42
```
Когда в цепочке пути к свойству что-то меняется, Матрешка перехватывает это изменение, разрывает связь со старой подцепочкой и создаёт зависимость от новой цепочки.
```
this.b.c = {d: 1};
```
По-прежнему, можно создавать зависимость от свойств других объектов, при этом, как упоминалось выше, в качестве исходного объекта могут выступать любой объект:
```
let targetObject = {},
o1 = {b: {c: {d: 40}}},
o2 = {e: {f: 2}};
MK.linkProps(targetObject, 'a', [
o1, 'b.c.d',
o2, 'e.f'
], (d, f) => d + f);
alert(targetObject.a); // 42
```
Прозрачный синтаксис делегированных событий
===========================================
Напомню, что в предыдущих версиях можно было навешать событие не только на текущий объект (`this`), но и на объект произвольной вложенности. Но синтаксис заставлял желать лучшего. Приведу небольшой пример. Скажем, у экземпляра Матрешки есть или должно появиться некое свойство, которое, в свою очередь, так же является экземпляром Матрешки.
```
this.a = new Matreshka();
```
Вы могли до или после присваивания свойства создать обработчик любого события, которое относится к этому свойству. Для этого использовался синтаксис с «собачкой».
```
this.on('a@someevent', handler);
this.a.trigger('someevent');
```
Для [массивов](http://ru.matreshka.io/#!Matreshka.Array) и [объектов](http://ru.matreshka.io/#!Matreshka.Object) (которые в Матрешке являются коллекцями типа ключ-значение), можно было не указывать целевое свойство, так как событие слушается во всех элементах, входящих в коллекцию:
```
this.on('@someevent', handler);
this.push(new Matreshka());
this[0].trigger('someevent');
```
На первый взгляд, выглядит просто. Но что если наше дерево объектов немного сложнее? Например, свойство `"a"` содержит коллекцию:
```
this.a = new MK.Array();
this.a.push(new Matreshka());
```
Как отловить событие, внутри такой коллекции? Можно скомбинировать две собачки, которые говорят: «в объекте `"a"` словить событие `"@someevent"` -> в элементе массива словить событие `"someevent"`».
```
this.on('a@@someevent', handler);
this.a[0].trigger('someevent');
```
Это еще можно пережить (если выпить достаточное количество кофе). А что, если мы хотим пойти глубже? Тогда количество «собачек” увеличится и кофе уже не поможет…
Согласитесь, потенциал у этой фичи очень велик. Мы можем слушать события данных любой вложенности, например, узнать об изменении свойства объекта, содержащегося в массиве массивов и пр. Поэтому, было решено несколько изменить синтаксис делегированных событий. „Собачка” осталась, но в качестве единственного разделителя пути к объекту и имени события. Если событие касается вложенного объекта, собачки заменяются на точки. Если мы хотим узнать о чем-то в коллекции, вместо безликой собачки используем звездочку. Тут мне, наверное, нужно остановиться и привести пару примеров.
Если мы хотим навешать обработчик на свойство `"а"` то синтаксис остается прежним:
```
this.on('a@someevent', handler);
```
Если мы хотим отловить событие у элемента коллекции, то вместо такого:
```
this.on('@someevent', handler);
```
Пишем так:
```
this.on('*@someevent', handler);
```
Звездочка значит “любое свойство, отвечающее за данные в [MK.Object](http://matreshka.io/#!Matreshka.Object)” или „любой элемент коллекции [MK.Array](http://matreshka.io/#!Matreshka.Array)”.
Идем глубже. Нам нужно причесать следующий пример, описанный выше:
```
this.on('a@@someevent', handler);
```
Теперь пишем так:
```
this.on('a.*@someevent', handler);
```
Синтаксис стал намного чище. Вам нужно просто указать путь к объекту перед @, а после неё указать имя события.
[Подробная статья о событиях.](http://habrahabr.ru/company/matreshka/blog/267513/)
setClassFor
===========
[setClassFor](http://ru.matreshka.io/#!Matreshka-setClassFor) — это еще одна невероятно крутая функция. Она указывает на то, экземпляром какого класса должно являться заданное свойство. При попытке перезаписать свойство, внутренний перехватчик, вместо присваивания, обновляет его новыми данными. Разберемся на примере.
```
// задаём свойству изначальные данные (не обязательно)
this.x = {a: 41};
// устанавливаем класс для свойства
this.setClassFor('x', MyClass);
// проверяем, является ли свойство экземпляром класса MyClass
console.log(this.x instanceof MyClass); // true
// проверяем свойство "a” экземпляра
console.log(this.x.a); // 41
// теперь самое интересное
// сохраняем значение "x” в одноименную переменную
var x = this.x;
// пытаемся перезаписать свойство
this.x = {a: 42};
// проверяем, обновились ли данные
console.log(x.a); // 42
// проверяем, перезаписаось ли свойство на самом деле
console.log(x === this.x); // true
// Wow! Экземпляр класса не изменился, а данные обновились!
```
Если у вас есть глубокая структура объектов и во вложенных объектах тоже запущен `setClassFor`, можно делать интересные вещи. Например, сохранять представление многоуровневых данных в локальном хранилище.
```
localStorage.x = JSON.stringify(this.x);
```
А потом восстанавливать их взмахом волшебной палочки:
```
this.x = JSON.parse(localStorage.x);
```
Либо, гонять туда-сюда на сервер.
Случаев, где такая логика может понадобиться невероятно много. В качестве еще одного примера, приведу код из документации (для краткости используются [class properties](https://github.com/jeffmo/es-class-properties) из ECMAScript 7):
```
// app.js
class App extends MK {
constructor(appData) {
this.appData = appData;
this.setClassFor('appData', AppData);
}
}
// app-data.js
class AppData extends MK.Object {
constructor(data) {
super(data)
.setClassFor({
friends: Friends,
settins: Settings
});
}
}
// friend.js
class Friend extends MK.Object {
constructor(data) {
super(data);
}
}
// friends.js
class Friends extends MK.Array {
Model = Friend;
constructor(data) {
super(...data);
}
}
// settings.js
class Settings extends MK.Object {
constructor(data) {
super(data)
.setClassFor('credentials', Credentials);
}
}
// credentials.js
class Credentials extends MK.Object {
constructor(data) {
super(data);
}
}
// app-init.js
var app = new App({
settings: {
name: 'Vasiliy Vasiliev',
credentials: {
email: 'vasia.vasia@gmail.com'
}
},
friends: [{
name: 'Yulia Zuyeva',
id: 1
}, {
name: 'Konstantin Konstantinopolsky',
id: 2
}, {
name: 'nagibator3000',
id: 3
}]
});
// данные можно сериализировать и передать на сервер
JSON.stringify(app.appData);
// потом просто присвоить новые данные свойству appData
// при этом, структура классов не изменится
app.appData = {
settings: {
name: 'Petr Petrov',
credentials: {
email: 'petr.petrov@gmail.com'
}
},
friends: [{
name: 'Yulechka Zuyeva',
id: 1
}, {
name: 'Konstantin Konstantinopolsky',
id: 2
}]
};
```
Более подробно в [документации к методу](http://ru.matreshka.io/#!Matreshka-setClassFor).
DOM шаблонизатор
================
Матрешка — это фреймворк, который исповедует идею о том, что логика должна содержаться в JS файлах, в противовес фреймворкам, реализующим паттерн MVVM, принуждающим описывать логику в HTML коде.
Имплементация логики в JS файлах — это действительно очень удобно. Но, порой, возникают ситуации, когда описание всех байндингов слишком затратно в плане количества строк кода.
Поэтому, было решено улучшить и ускорить DOM шаблонизатор, отсутствующий до недавнего времени в официальном API. Что он делает? Он берет DOM узел, коллекцию DOM узлов, HTML код или песочницу текущего объекта, разбирает его, находя ангуляр-подобные конструкции типа `{{KEY}}` и создает привязки там, где эти конструкции найдены.
```
[Look at the {{info.title}}](http://{{website.domain}}/{{category}}/{{page}})
```
```
this.parseBindings();
this.website.domain = 'example.com';
this.category = 'foo';
this.page = 42;
this.info.title = 'cool stuff';
```
Подробнее метод описан [в документации](http://ru.matreshka.io/#!Matreshka-parseBindings).
Метод не противоречит идеологии Матрешки, так как логики (циклов, условий, обработчиков) в шаблоне быть не может.
Кроме публикации API самого метода, шаблонизатор для коллекций теперь включен по умолчанию (не нужно больше писать `useBindingsParser: true`).
```
class MyArray extends MK.Array {
itemRenderer = 'Hello, {{name}}';
...
}
```
Больше сахара для ECMAScript 2015
=================================
Из примера к `setClassFor` видно, что методы запускаются сразу после `super()`. Эта возможность стала реальной благодаря очень простому изменению: все три конструктора (`Matreshka`, `Matreshka.Array`, `Matreshka.Object`) возвращают `this` вместо `undefined`.
```
class MyObject extends MK.Object {
constructor(data) {
super(data)
.bindNode('x', '.my-node');
}
}
// создаст экземпляр MyObject со свойствами a и b,
// отвечающими за данные
myObject = new MyObject({a: 1, b: 2});
class MyCollection extends MK.Array {
constructor(data) {
super(...data)
.bindNode('x', '.my-node');
}
}
// создаст коллекцию, состоящую из 5 элементов
myCollection = new MyCollection([1,2,3,4,5]);
```
Поддержка объектов типа событие-обработчик в методах [on](http://ru.matreshka.io/#!Matreshka-on), [once](http://ru.matreshka.io/#!Matreshka-once), [onDebounce](http://ru.matreshka.io/#!Matreshka-onDebounce)
==============================================================================================================================================================================================================
В предыдущих версиях разработчику был доступен единственный синтаксис объявления обработчиков события.
```
this.on('eventname1', handler1);
this.on('eventname2', handler2);
```
Теперь же можно объявить несколько обработчиков, вызвав соответствующий метод лишь однажды:
```
this.on({
'eventname1': handler1,
'eventname2': handler2
});
```
Эта новость не упоминалась бы в этом посте, если бы не одно но: используя ECMAScript 2015 можно сильно укоротить код в микрозадачах.
```
this.on({
'eventname1': evt => this.x = 42,
'eventname2': evt => doSomethingElse()
});
```
Против “старого” синтаксиса:
```
this.on({
'eventname1': function(evt) {
this.x = 42
},
'eventname2': function(evt) {
doSomethingElse();
}
});
```
Переопределение [itemRenderer](http://ru.matreshka.io/#!Matreshka.Array-itemRenderer)
=====================================================================================
`itemRenderer` — это виртуальное свойство коллекции (`Matreshka.Array`), которое говорит о том, как отрисовывать элементы коллекции.
```
// для краткости, синтаксис ES7
class MyCollection extends MK.Array {
itemRenderer = "Hi there!";
constructor() {
super()
.bindNode('sandbox', '.array-sandbox')
.push({a: 1}, {a: 2});
}
}
```
Более подробно в [документации к itemRenderer](http://ru.matreshka.io/#!Matreshka.Array-itemRenderer).
Начиная с новой версии, при переопределении `itemRenderer`, коллекция автоматически перерисовывается.
```
//каждый элемент коллекции - span
this.itemRenderer = 'I'm a span';
//каждый элемент коллекции - div
this.itemRenderer = 'I'm a div';
```
Можно придумать несколько юз-кейсов: вы хотите одной кнопкой изменить дизайн коллекции либо же ваш шаблон находится на сервере (в примере ниже используется [Fetch API](http://habrahabr.ru/post/252941/)).
```
fetch('templates/my-template.html')
.then(resp => resp.text())
.then(text => this.itemRenderer = text);
```
Вы можете работать с коллекцией как обычно: вставлять, удалять, сортировать элементы, при этом, не нужно ждать пока сервер отдаст шаблон. По возвращении с сервера, коллекция сама отрисуется на странице.
Новые байндеры
==============
Напомню, байндер — это объект, который указывать на то, как связать свойство с элементом на странице. Байндер используется методом [bindNode](http://ru.matreshka.io/#!Matreshka-bindNode), реализующим одно или двух-сторонее связывание.
```
this.bindNode('x', '.my-node', binder);
this.x = 42; // элемент на странице тоже изменился
```
Подробное опсисание можно найти в [документации к методу](http://ru.matreshka.io/#!Matreshka-bindNode).
[MK.binders.progress](http://ru.matreshka.io/#!Matreshka.binders.progress) — связывает свойство с состоянием HTML5 элемента [progress](http://htmlbook.ru/html/progress). Байндер не нужно вызывать вручную, так как он входит в коллекцию стандартных байндеров.
```
this.bindNode('x', '.my-progress');
this.x = 42; // меняет значение прогресса на 42
```
[MK.binders.innerText](http://ru.matreshka.io/#!Matreshka.binders.innerText) — связывает свойство с текстовым значением любого элемента, у которого есть свойство `textContent` или `innerText`.
```
this.bindNode('x', '.my-node', MK.binders.innerText());
this.x = 'Some *Text*'; // задаст ноде содержимое "как есть”, в виде текста
```
[MK.binders.style](http://ru.matreshka.io/#!Matreshka.binders.style) — связывает свойство объекта со свойством объекта `style` элемента.
```
this.bindNode('x', '.my-node', MK.binders.style('color'));
this.x = 'red'; // изменит цвет текста на красный
```
И самое интересное: [MK.binders.file](http://ru.matreshka.io/#!Matreshka.binders.file). Этот новый байндер не только отловит изменение пользователем содрежимого `input[type=”file”]`, но и прочтет файл в том формате, который вам нужен:
```
this.bindNode('x', '.my-file', MK.binders.file('dataURL'));
// событие изменения генерируется, когда файл прочитан
this.on('change:x', function() {
console.log(this.x.readerResult); // "data:image/png;base64,iVBO..."
});
```
Подробнее в [документации к байндеру](http://ru.matreshka.io/#!Matreshka.binders.file).
getValue для байндеров [innerHTML](http://ru.matreshka.io/#!Matreshka.binders.innerHTML), [className](http://ru.matreshka.io/#!Matreshka.binders.className), [property](http://ru.matreshka.io/#!Matreshka.binders.property) и [attribute](http://ru.matreshka.io/#!Matreshka.binders.attribute)
================================================================================================================================================================================================================================================================================================
Теперь, при использовании вышеперечисленных байндеров, ядро Матрешки проверит, есть ли в текущем объекте соответствующее свойство и, если ответ отрицательный, извлечет значение из элемента и присвоит его свойству.
```
Some data
```
```
// скажем, что this.x не определен.
this.bindNode('x', '.my-div', MK.binders.innerHTML());
alert(this.x); //"Some data"
```
[onItemRender](http://ru.matreshka.io/#!Matreshka.Array-onItemRender)
=====================================================================
У `Matreshka.Array` появился новый виртуальный метод `onItemRender`. Он вызывается тогда, когда один из элементов коллекции был отрисован. Метод делает код более плоским, позволяя избежать прослушивания события `"render"`.
Событие `"render"` всегда было стандартным паттерном, позволяющим добавить необходимые привязки при рендеринге.
```
class MyCollection extends MK.Array {
Model: MyModel;
itemRenderer = '- ';
constructor() {
super()
.bindNode('sandbox', '.array-sandbox')
.on('\*@render', evt => {
evt.self.bindNode(...);
});
}
}
```
Теперь можно сделать так:
```
class MyCollection extends MK.Array {
Model: MyModel;
itemRenderer = '- ';
constructor() {
super()
.bindNode('sandbox', '.array-sandbox');
}
onItemRender(item, evt) {
item.bindNode(...);
}
}
```
У „моделей” появился похожий виртуальный метод: `onRender`.
Раньше было так:
```
class MyModel extends MK.Object {
constructor() {
super()
.on('render', evt => {
this.bindNode(...);
});
}
}
```
Теперь можно писать так:
```
class MyModel extends MK.Object {
constructor() {
super()
}
onRender() {
this.bindNode(...);
}
}
```
Свойства [nodes](http://ru.matreshka.io/#!Matreshka-nodes) и [$nodes](http://ru.matreshka.io/#!Matreshka-$nodes)
================================================================================================================
После объявления связывания данных и DOM ноды, разработчик мог получить доступ к связанным узлам с помощью методов [bound](http://ru.matreshka.io/#!Matreshka-bound) и [$bound](http://ru.matreshka.io/#!Matreshka-$bound). `bound` возвращает первый привязанный элемент, `$bound` — все элементы в виде коллекции jQuery или Balalaika.
```
this.bindNode('x', '.my-node');
var boundNode = this.bound('x');
var allBoundNodes = this.$bound('x');
```
Свойства `nodes` и `$nodes` позволяют делать то же самое, но практически бесплатно, с точки зрения производительности, так как эти свойства являются обычными объектами.
```
this.bindNode('x', '.my-node');
var boundNode = this.nodes.x;
var allBoundNodes = this.$nodes.x;
```
Еще немного новых методов
=========================
[Matreshka.to](http://ru.matreshka.io/#!Matreshka.to) конвертирует произвольный объект в экземпляры `MK.Object` и `MK.Array`.
[MK.Array.of](http://ru.matreshka.io/#!Matreshka.Array.of), работающий так же, как и [Array.of](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Array/of), но возвращающий экземпляр `MK.Array`.
[MK.Array.from](http://ru.matreshka.io/#!Matreshka.Array.from), работающий так же, как и [Array.from](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Array/from), но возвращающий экземпляр `MK.Array`.
[MK.trim](http://ru.matreshka.io/#!Matreshka.trim) для браузеров, которые не поддерживают [String.prototype.trim](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/String/Trim).
[MK.toArray](http://ru.matreshka.io/#!Matreshka.toArray), конвертирующий array-like массив в нативный `Array` в два раза быстрее, чем это делает [Array.prototype.slice](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Array/slice).
Увеличение производительности
=============================
С помощью микрооптимизаций (например, использования цикла `for..in` вместо функции `each`) и более крупных изменений, получилось добиться отличных результатов. Например, в бенчмарке с небольшими коллекциями (10 элементов), Матрешка отставала от React на 10-20 процентов в Хроме и Файерфоксе (хотя и обгоняла в бенчмарках с большим коичеством элементов коллекции). Теперь в этом же тесте, Матрешка быстрее Реакта на 50 процентов в Хроме, и быстрее в 3 раза в Файерфоксе.
Вот список бенчмарков, чтобы убедиться самостоятельно: [10 элементов](http://jsperf.com/angular-vs-knockout-vs-react-vs-matreshka/20), [50 элементов](http://jsperf.com/angular-vs-knockout-vs-react-vs-matreshka/21), [100 элементов](http://jsperf.com/angular-vs-knockout-vs-react-vs-matreshka/22), [500 элементов](http://jsperf.com/angular-vs-knockout-vs-react-vs-matreshka/23), [1000 элементов](http://jsperf.com/angular-vs-knockout-vs-react-vs-matreshka/24).
Работа над ошибками: тесты
==========================
Матрешка, наконец, тестируется автоматически. На момент написания этой статьи, реализовано 148 тестов, проверяющих работоспособность методов до того, как они попадут в бранч develop. Особенно скурпулезно оттестированы делегированные события, которые обязаны работать при самых разных разных обстоятельствах и ничего не ломать при этом.
Поддержка браузерами
====================
На сайте документации появилось предупреждение о том, что использование Матрешки в Internet Explorer 8 не рекомендуемо по причине наличия массы методов, которые невозможно реализовать для этой версии “осла». На деле, это лишь дисклеймер на случаи, когда разработчик пытается бездумно использовать такие методы. Следует помнить лишь одно: статичные методы, добавляющие «магию» в нативные объекты не работают в ИЕ8.
Такой код сработает в IE8, в случае, если `this` — экземпляр Матрешки.
```
this.bindNode('key', '.node');
```
И такой сработает:
```
var mk = new Matreshka();
mk.bindNode('key', '.node');
```
А этот код сработает только в IE9+ и в других браузерах (в том числе и в древних WebKit и Opera Mini):
```
var object = {};
MK.bindNode(object, 'key', '.node');
```
Если очень руки чешутся использовать статичные методы в восьмом осле, можете предварительно сконвертировать объект в экземпляр Матрешки:
```
var object = MK.to({});
MK.bindNode(object, 'key', '.node');
```
Таким образом [семантичное версионирование](http://semver.org/) соблюдено.
Другие изменения
================
— Синтаксис [bindNode](http://ru.matreshka.io/#!Matreshka-bindNode(2)) немного расширился.
— Ошибки об отсутствующих нодах, используя метод `bindNode` более информативны: теперь в тексте, кроме ключа, указывается селектор (если передан селектор).
— Исходный код разбит на мелкие составляющие.
— Из кода и из примеров на сайте убраны ненужные пробелы (`f(x)` вместо `f( x )`).
— Как уже писалось выше, Матрешка поддерживает Opera Mini и старые WebKit.
Об остальных изменениях и списке исправленных ошибок, можно узнать [в соответствующем разделе на сайте](http://ru.matreshka.io/#!whats-new).
И еще
=====
Посмотреть на то, что сделано и планируется сделать, можно в [Trello](https://trello.com/b/E5KcQESk/matreshka-js-features). Там же можно и проголовать, повышая приоритет карточек.
В [чате Gitter](https://gitter.im/finom/matreshka/ru) довольно часто происходят обсуждения новых фич. Из-за этого, вопросы, которые задают пользователи, и ответы на них теряются где-то в темных подвалах интенета. Поэтому, было принято решение запустить, в качестве эксперимента, форум на базе [Muut](http://muut.com) ([на русском](http://ru.matreshka.io/forum/) и [на английском](http://matreshka.io/forum/)). Если возникает вопрос, не стесняйтесь его задавать там (даже если вы думаете, что вопрос глупый).
Для примера, вот один из отличных вопросов [Rendol](https://habrahabr.ru/users/rendol/) с равернутым ответом на него:
> Приветствую!
>
> Снова тот же вопрос, который у меня ранее уже был, но ответ я на него так и не нашел красивый.
>
> Например переписка как в ВК:
>
>
> ```
> User = {
> id: 5,
> name: 'Fedor',
> online: true
> }
>
> ```
>
>
> Этого пользователя мы размещаем в разных комнатах: room1, room2, room3.
>
> Если User.online = false, то во всех 3х комнатах, должен измениться цвет например.
>
> Т.о. 3 коллекции, которые содержат один объект и при этом этот объект выводится в 3х местах.
>
> Примечание: не обязательно, что эти коллекции будут однотипными (не только комнаты), могут быть разного вида и представления.
>
> Есть ли возможность привязать один объект к нескольким представлениям?
Ответ:
> Да, коллекции, содержащие объект могут быть разными. Для этого у него должно быть установлено свойство `bindRenderedAsSandbox: false`, так как при вхождении в несколько коллекций, песочницей станет сразу несколько элементов (например, несколько разных строк из разных таблиц, а это сильно усложнит вам жизнь). Поэтому отключаем песочницу. При срабатывании события `render` можно определить, в какую именно коллекцию вставлена модель и, исходя из этого, объявить привязки.
>
> Вот небольшой пример накатал: [jsbin.com/cidise/12/edit](http://jsbin.com/cidise/12/edit). Объект `user` находится сразу в двух коллекциях (в таблице и списке ul), которые рендерятся по-разному. Можете написать в консоли `tableUsers[0].name = 'xxx'` и все узлы, привязанные к данному юзеру, изменятся. Получается, что не нужно создавать много отдельных объектов и синхронизировать их значения.
>
> ЗЫ. При поддержке IE 8, для проверки того, является ли объект инстансом класса, нужно использовать метод `.instanceOf`
>
>
> ```
> object.instanceOf( MyClass );
> // вместо
> object instanceof MyClass
>
> ```
>
>
>
Надеюсь, пост оказался полезным. Спасибо за внимание. | https://habr.com/ru/post/267483/ | null | ru | null |
# Bender: идейный борец за минимальность CSS / Javascript
Не так давно на Хабре уже была статья про комбинатор CSS / Javascript файлов: [плагин для Smarty — Combine](http://habrahabr.ru/post/193398/). Дело это полезное, поскольку позволяет ускорить загрузку страниц и снизить нагрузку на сервер. Тогда появилась идея создать свой комбинатор + минимизатор, который можно было бы использовать не только в проектах на Smarty, а вообще в любых. Идея превратилась в Bender. Он должен удовлетворять следующим требованиям:
* Простая и быстрая интеграция в любой готовый проект, с минимальными изменениями последнего
* Минимальный размер кода и количество файлов
* Универсальность и независимость от технологий и фреймворков — чтобы работал на любом хостинге, даже самом ограниченном
Изначально задача состояла в оптимизации загрузки CSS / Javascript одного проекта, основанного на [CS-Cart](http://www.cs-cart.com/) (он тоже использует Smarty). В проекте последовательно загружались 17 CSS файлов, и 15 Javascript, что конечно же, никуда не годится. Из них примерно половина приходилась на сам движок CS-Cart, а вторая — на установленные аддоны. Нужно было решение, которое бы позволило объединить CSS / Javascript и сделать это с минимальными изменениями оригинальных файлов проекта. Аддоны сами подгружают свои CSS и Javascript. Не хотелось лезть в логику самих аддонов, поэтому Bender позволяет делать очередь из CSS / Javascript, по той же схеме, что и Wordpress.
Bender не претендует на уникальность и широкие возможности (как например, [assetic](https://github.com/kriswallsmith/assetic)). Здесь другая задача: минимальность (вместе с упаковщиками это всего 3 файла), и простота подключения к существующему проекту.
#### Как это использовать?
В качестве примера возьмём кусок кода, который подключает CSS и Javascript, по ~~четыре штуки в ряд~~ две штуки каждого:
```
...
```
Теперь добавим Bender:
```
php
require\_once "Bender/Bender.class.php";
$bender = new Bender();
// Ставим в очередь наши файлы CSS и JS
$bender-enqueue("assets/css/bootstrap.css");
$bender->enqueue("assets/css/bootstrap-theme.css");
$bender->enqueue("assets/js/jquery-1.10.2.js");
$bender->enqueue("assets/js/bootstrap.js");
// В качестве альтернативы, вы можете добавить все файлы в виде массива: $bender->enqueue(array("assets/css/bootstrap.css", "assets/css/bootstrap-theme.css", ...));
// Вставляем ссылку на скомбинированный / упакованный CSS в секцию
echo $bender->output("cache/stylesheet.css");
?>
...
php
// вставляем ссыку на скомбинированный / упакованный JS <script src="..." перед (для распараллеливания загрузки)
echo $bender->output("cache/javascript.js");
?>
```
Результатом работы Bender будет следующий код:
```
...
```
Если результирующие файлы уже были созданы, то они не перезаписываются. Это поведение можно изменить через свойство **ttl** (см.ниже).
CSS / JS файлы на выходе ~~мимими~~ минимизируются. По умолчанию, для Javascript используется Dean Edwards' JavaScriptPacker, для CSS — Joe Scylla' CssMin. Они дают весьма неплохой результат, но в перспективе можно будет подключить и другие минимизаторы. Также, можно отключить минимизацию совсем — результатом будут скомбинированные, но не сжатые файлы.
#### Smarty
Bender включает плагин для Smarty. Для этого просто нужно поместить **function.bender.php** в директорию плагинов Smarty, не забыв заинклюдить сам класс Bender где-нибудь в скриптах инициализации проекта. Использование Bender в шаблоне Smarty:
```
{bender src="assets/css/bootstrap.css"}
{bender src="assets/css/bootstrap-theme.css"}
{bender src="assets/js/jquery-1.10.2.js"}
{bender src="assets/js/bootstrap.js"}
{bender output="cache/stylesheet.css"}
...
{bender output="cache/javascript.js"}
```
#### Свойства
У Bender пока что минимум свойств. Вот они:
```
$bender->cssmin: может принимать значения "cssmin" для использования минимизатора CssMin, любое другое значение отключит минимизацию CSS.
$bender->jsmin: "packer" для использования JavaScriptPacker, "jshrink" для JShrink, или любое другое значение отключит минимизацию JS.
$bender->ttl: время жизни скомбинированных файлов. По умолчанию это 3600 секунд, по истечении которых, результирующие файлы будут перезаписаны. 0 - всегда перезаписывать, -1 - никогда не перезаписывать.
```
#### В планах
* Плагины для Twig и Wordpress
* Добавить параметры для enqueue и output
* Свойство $dev — будет отдавать файлы «as is», без комбинирования — для режима отладки
[Скачать Bender с GitHub](https://github.com/esiteq/bender) | [Инструкции по использованию на английском](http://www.esiteq.com/projects/bender/)
Буду рад предложениям по улучшению, отзывам и даже критике в комментариях. Я думаю вы догадались, что название Bender не имеет ничего общего с Футурамой — оно происходит от слова «комбинатор». | https://habr.com/ru/post/199512/ | null | ru | null |
# Мониторинг IP в блэклистах с помощью Zabbix
#### Немного теории
Публичные спам-базы или «черные списки» IP адресов содержат информацию об IP, которые по каким-либо причинам были признаны недружественными по отношению к пользователям. Не будем углубляться в технологические тонкости; важно, что почтовые программы и сервисы используют информацию из этих и собственных баз для того, чтобы защищать электронные ящики получателей от нежелательной рассылки, от спама.
#### Суть проблемы
Если ваш IP адрес попал в черный список – адресаты не будут получать ваши электронные письма.
Попадание IP в публичные спам-базы грозит наступлением корпоративного почтового коллапса. Это неприятно, даже если e-mail адресов на домене всего 5 и всех пользователей можно временно «пересадить» на «обычную» почту на Яндексе или Mail.ru. Но, когда к внутреннему почтовому серверу «приколочены» более 50 ящиков, интегрированных с CRM-системой, проблема приобретает катастрофический характер.
#### Решение
«Знать, чтобы предвидеть; предвидеть, чтобы управлять». О. Конт
Вычислить надвигающуюся угрозу можно и нужно до того, как клиент ощутит на себе карательные меры почтовых серверов, а отдел продаж в панике совершит коллективное линчевание местного админа. Для этого мы создали скрипт автоматического мониторинга IP, оповещающий пользователя о возможных проблемах. В качестве платформы мониторинга выбрали Powershell, а для оповещения использовали zabbix 2.4.
#### Немного о создании скрипта
Наиболее очевидным вариантом казался парсинг веб страниц известных поисковых систем IP в базах mxtoolbox и 2ip.ru. Для решения этой задачи – использовались технологии .NET и XPATH – наиболее эффективное средство для парсинга XML и WEB, особенно для ненавистников регулярных выражений. Первый блин, в некотором роде, получился комом и после долгого и изнурительного тестирования мы решили отказаться от этого решения. Причиной послужила, прежде всего, зависимость от стороннего сервиса: если создатели площадки поменяют структуру кода, то в лучшем случае нужно будет заново тестировать ПО, в худшем – переписывать код.
После тщательного анализа существующих в данной области технологий и наработок мы пришли к более интересному и практичному решению. Разработка ПО на базе powershell 3.0, которое будет самостоятельно проверять наличие IP в публичных спам-базах.
#### Как работает?
Проверка IP адреса на факт наличия в черном списке (DNSBL) проводится следующим образом: указывается проверяемый IP в нотации DNS PTR (то есть наоборот «спереди назад») и добавляется имя домена DNSBL сервера. Если ответ от сервера получен, то проверяемый адрес заблокирован: то есть IP замечен в одном или нескольких черных списках. Вне зависимости от специфики ответа (он может быть любым), сам его факт говорит о том, что IP находится в спам-базе.
**Немного кода**Код скрипта:
```
<#
Функция zabbix для отправки данных. Данная функция принимает на вход параметры:
Key - имя ключа, который создается в элементе данных zabbix
Также необходимо задать переменные
$Zabbix_send = указать где находится утилита zabbix_sender
$zabbix_port = порт zabbix сервера
$zabbix_server = адрес zabbix сервера
$zabbix_host = Имя созданого узла сети в zabbix (чувствителен к регистру)
#>
Function Send_Zabbix {
param (
[parameter(mandatory=$true)]
$key,
[parameter(mandatory=$true)]
[int64]$value
)
$Zabbix_send = "C:\zabbix_sender.exe"
$zabbix_port = "10051"
$zabbix_server = "10.0.33.31"
$zabbix_host = "Blacklistcheck"
echo "$key : $value"
$cmd = "$Zabbix_send -z $zabbix_server -p $zabbix_port -s $zabbix_host -k `"$key`" -o $value"
echo "$cmd"
Invoke-Expression $cmd
}
# Место хранения списка адресов для проверки, в формате name,ip
$FilePath = "D:\powershell\blacklist.csv"
# импортируем список в текстовый массив
$iparr = Import-Csv $FilePath
foreach ($ipaddr in $iparr)
{
[string]$IP = $ipaddr.adress
[string]$organization = $ipaddr.organization
$reversedIP = ($IP -split '\.')[3..0] -join '.'
# заготовленый список спамбаз, по которым будет проходить проверка
$blacklistServers = @(
"b.barracudacentral.org";
"bl.deadbeef.com";
"bl.emailbasura.org";
"bl.spamcannibal.org";
"bl.spamcop.net";
"blackholes.five-ten-sg.com";
"blacklist.woody.ch";
"bogons.cymru.com";
"cbl.abuseat.org";
"cdl.anti-spam.org.cn";
"combined.abuse.ch";
"combined.rbl.msrbl.net";
"db.wpbl.info";
"dnsbl-1.uceprotect.net";
"dnsbl-2.uceprotect.net";
"dnsbl-3.uceprotect.net";
"dnsbl.cyberlogic.net";
"dnsbl.inps.de";
"dnsbl.njabl.org";
"dnsbl.sorbs.net";
"drone.abuse.ch";
"drone.abuse.ch";
"duinv.aupads.org";
"dul.dnsbl.sorbs.net";
"dul.ru";
"dyna.spamrats.com";
"dynip.rothen.com";
"http.dnsbl.sorbs.net";
"images.rbl.msrbl.net";
"ips.backscatterer.org";
"ix.dnsbl.manitu.net";
"korea.services.net";
"misc.dnsbl.sorbs.net";
"noptr.spamrats.com";
"ohps.dnsbl.net.au";
"omrs.dnsbl.net.au";
"orvedb.aupads.org";
"osps.dnsbl.net.au";
"osrs.dnsbl.net.au";
"owfs.dnsbl.net.au";
"owps.dnsbl.net.au";
"pbl.spamhaus.org";
"phishing.rbl.msrbl.net";
"probes.dnsbl.net.au";
"proxy.bl.gweep.ca";
"proxy.block.transip.nl";
"psbl.surriel.com";
"rbl.interserver.net";
"rdts.dnsbl.net.au";
"relays.bl.gweep.ca";
"relays.bl.kundenserver.de";
"relays.nether.net";
"residential.block.transip.nl";
"ricn.dnsbl.net.au";
"rmst.dnsbl.net.au";
"sbl.spamhaus.org";
"short.rbl.jp";
"smtp.dnsbl.sorbs.net";
"socks.dnsbl.sorbs.net";
"spam.abuse.ch";
"spam.dnsbl.sorbs.net";
"spam.rbl.msrbl.net";
"spam.spamrats.com";
"spamlist.or.kr";
"spamrbl.imp.ch";
"t3direct.dnsbl.net.au";
"tor.dnsbl.sectoor.de";
"torserver.tor.dnsbl.sectoor.de";
"ubl.lashback.com";
"ubl.unsubscore.com";
"virbl.bit.nl";
"virus.rbl.jp";
"virus.rbl.msrbl.net";
"web.dnsbl.sorbs.net";
"wormrbl.imp.ch";
"xbl.spamhaus.org";
"zen.spamhaus.org";
"zombie.dnsbl.sorbs.net"
)
$blacklistedOn = @()
foreach ($server in $blacklistServers)
{
$fqdn = "$reversedIP.$server"
try
{
$null = [System.Net.Dns]::GetHostEntry($fqdn)
$blacklistedOn += $server
}
catch { }
}
if ($blacklistedOn.Count -gt 0)
{
Write-Host "$organization is blacklisted on the following servers: $($blacklistedOn -join ', ')"
send_zabbix -key $organization -value 1
}
else
{
Write-Host "$organization is not currently blacklisted on any server."
send_zabbix -key $organization -value 0
}
}
```
В zabbix данные передаются через траппер. Для использования элемента данных траппера мы должны:
— иметь в Zabbix настроенный элемент данных траппер
— отправлять данные в Zabbix.
Создадим хост blacklistcheck:
Теперь необходимо настроить траппер:
Создаем элемент данных.
**Имя** – может быть любым
**Ключ** – основной элемент при создании траппера, данный элемент имеет зависимость от регистра. Ключ KEY и key это два разных ключа.
**Тип информации**: есть 3 варианта, подходящие под нашу задачу: число, символ или текст. Но, поскольку мы исключили регулярные выражения, то текстовым массивам предпочли целочисленное значение.
**Тип данных** – логический; нам важно 2 значения IP: присутствует (1), либо не присутствует в спам-листах (0).
**Отображение значений** можно оставить как есть, а можно создать свое преобразование, примерно следующего содержания: 1= ip is listing, 0 = ip isn`t listing – на работу скрипта данные значения не влияют, зато визуализация информации в zabbix получается интересной.
После этого элемент данных готов принимать значения. Можно выполнить проверку через программу zabbix\_sender.
В случае корректной работы будет получен подобный результат:
**Результат zabbix sender**C:\>zabbix\_sender.exe -z 10.0.33.31 -p 10051 -s Blacklistcheck -k fn -o 1 -vv
zabbix\_sender.exe [14276]: DEBUG: answer [{«response»:«success»,«info»:«processe
d: 1; failed: 0; total: 1; seconds spent: 0.000066»}]
info from server: «processed: 1; failed: 0; total: 1; seconds spent: 0.000066»
sent: 1; skipped: 0; total: 1
Для просмотра диагностических данных используется параметр –vv.
Скорость проверки одного IP составляет не более 3-х минут.
Далее необходимо настроить триггер для оповещения.
Имя можно задать любое. Выражение соответствует изменению состояния элемента данных с 0 на 1. В случае срабатывания триггера в основной панели zabbix появится оповещение.
#### Практика использования
Мы создали компактный, хорошо работающий скрипт, который автоматически оповещает клиента о возможных проблемах в работе почтовой системы. Согласитесь, что профилактика этого вопроса куда приятнее и спокойнее по сравнению с необходимостью решать задачу «отвалившейся» почты в условиях цейтнота.
Мы внедрили данное решение у наших клиентов, и оно хорошо себя показывает – особенно в компаниях, где отдел продаж работает через рассылку коммерческих. Данный скрипт позволяет быстро локализовать проблему, вызвавшую попадание IP в спам-базу, и без ущерба продолжить работу.
Желаем, чтобы количество взлётов электронных писем совпадало с количеством приземлений! | https://habr.com/ru/post/267189/ | null | ru | null |
# Сборка XGBoost для Python под Windows
*Windows is so evil that consumes extra energy to make the things running.*
Библиотека [XGBoost](https://github.com/dmlc/xgboost) гремит на всех соревнованиях по машинному обучению и помогает завоёвывать призовые места. Однако, стать обладателем этого пакета для Python под Windows не так просто.
Процесс установки скудно описан на [GitHub](https://github.com/dmlc/xgboost/tree/master/windows) и немногим шире на [форуме Kaggle](https://www.kaggle.com/c/otto-group-product-classification-challenge/forums/t/13043/run-xgboost-from-windows-and-python). Поэтому попробую описать пошагово и более подробно. Надеюсь это поможет сохранить много времени неопытным пользователям.
Допустим у вас уже установлен Python. В моём случае это сборка [Anaconda](https://www.continuum.io/downloads) с Python 3.4.
**1. Устанавливаем** [JDK](http://www.oracle.com/technetwork/java/javase/downloads/index.html) от Oracle. Потому что для компиляции нам потребуется библиотека JNI.
**2. Устанавливаем** [Visual Studio 2013](https://www.visualstudio.com/en-us/news/vs2013-community-vs.aspx) по ссылке выделенной на скриншоте. Более поздние версии просят править код решения, поэтому для простых людей не подходят. Само решение xgboost, опубликованное на GitHub, собрано в Visual Studio 2010.
**3. Скачиваем** всю библиотеку XGBoost c [GitHub](https://github.com/dmlc/xgboost):
**4. Распаковываем** архив, получаем папку *C:\xgboost-master*.
**5. Открываем** с помощью Visual Studio файл решения *C:\xgboost-master\windows\***xgboost.sln**. Выбираем Release и вариант платформы, под которую будем собирать. Далее Build -> Build Solution. В результате должны получить «4 succeeded»:
Уже на этом этапе можно собрать проблемы.
«Не удалось обнаружить CL.exe» — при установке не был выбран C#/Visual C++. Доустанавливаем компоненты.
«Cannot open include file: 'corecrt.h'» — ищете файл поиском, скорее всего он тут: *ProgramFiles(x86)\Windows Kits\10\Include\10.0.10150.0\ucrt* и добавляете директорию в $IncludePath, либо поступаете грубо и копируете все \*.h файлы куда-нибудь на видное место, например в *Program Files\Microsoft Visual Studio 12.0\VC\include*.
«Cannot open include file: 'jni.h'» — после установки JDK ошибки не должно быть.
Однако всё может пройти гладко и никаких проблем не будет. У меня получалось и так, и так, на разных ЭВМ.
Далее.
**6. Из папки** *C:\xgboost-master\windows\Release* нам нужны файлы **xgboost.exe** и **xgboost\_wrapper.dll**.
Копируем их в папку с пакетом для Python: C:\xgboost-master\python-package.
**7. Открываем** консоль (cmd), меняем директорию:
`cd "C:\xgboost-master\python-package"`
**8. Там же** запускаем установщик:
`python setup.py install`
Вот и всё. Запускаете удобную вам среду Python и пишете традиционное:
```
import xgboost as xgb
``` | https://habr.com/ru/post/273363/ | null | ru | null |
# Обработка POST запросов AngularJs в Symfony2
**Примечание***Давненько уже читал [пост](http://habrahabr.ru/post/181009/) на хабре, о сабже в контексте php, и все руки не доходили на Symfony2 привести это в какой-то красивый вид, а тут в недавнем [дайджесте](http://habrahabr.ru/company/zfort/blog/234411/) наткнулся на простое решение, которое здесь и представлено.*
Использование Symfony2 и AngularJs в связке является хорошей идеей, но есть одна проблема — решение из коробки обладает проблемой в коммуникации. В этом посте будет рассказано о том, как автоматически декодировать JSON-запросы и использовать полученные данные при помощи [Request](http://api.symfony.com/2.3/Symfony/Component/HttpFoundation/Request.html) Symfony используя библиотеку [symfony-json-request-transformer](https://github.com/qandidate-labs/symfony-json-request-transformer) (на самом деле всего-то один класс).
### Идея
[$http](https://docs.angularjs.org/api/ng/service/$http)-сервис AngularJs автоматически отправляет данные с заголовком `Content-Type: application/json` в POST запросе, а Symfony в свою очередь ожидает `application/x-www-form-urlencoded`.
Для примера, отправим из нашего angular-приложения простой JSON-объект:
```
{
"name": "John"
}
```
Теперь в контроллере получим эти данные:
```
public function postAction(Request $request)
{
$data = json_decode($request->getContent(), true);
echo $data['name']; // John
}
```
Довольно просто, верно? Но, к сожалению, мы не можем использовать [ParameterBag](http://api.symfony.com/2.3/Symfony/Component/HttpFoundation/ParameterBag.html) интерфейс в объекте [Request](http://api.symfony.com/2.3/Symfony/Component/HttpFoundation/Request.html) в данном случае.
Если `name` опционален и имеет значение по-умолчанию, хотелось бы получать данные вот так:
```
$name = $request->request->get('name', 'Ivan');
```
К счастью, используя метод [replace](http://api.symfony.com/2.3/Symfony/Component/HttpFoundation/ParameterBag.html#method_replace) мы можем заменить данные в ParameterBag на наш декодированный JSON.
```
public function postAction(Request $request)
{
$data = json_decode($request->getContent(), true);
$request->request->replace($data);
echo $request->request->get('name', 'Ivan'); // John
}
```
Отлично, работает так, как нам хотелось. Но, ведь это только один контроллер…
### Реализация
Но копирование кода в каждый контроллер нарушает DRY принцип, делая код [мокрым](https://ru.wikipedia.org/wiki/Don%E2%80%99t_repeat_yourself#DRY_.D0.B8_WET) (*игра слов аббревиатур DRY и WET*). Что если я скажу, что можно обрабатывать каждый JSON-запрос, совершенно не заботясь об этом? Используя [обработчик событий](http://symfony.com/doc/current/cookbook/service_container/event_listener.html), помеченный как `kernel.event_listener`, он:
1. Проверит запрос на наличие заголовка `Content-Type: application/json`
2. Если это так — декодирует его
3. Заполнит объект `Request::$request`
4. Вернет код ошибки `HTTP 400 Bad Request`, если что-то пошло не так
Можете увидеть полный код на [Github](https://github.com/qandidate-labs/symfony-json-request-transformer).
Зарегистрировать обработчик события очень просто, просто определив новый сервис:
```
```
### Выход через сувенирную лавку
Чтобы показать приведенный код в действии, было создано демо-приложение, его код также на [Github](https://github.com/qandidate-labs/symfony-json-request-transformer-example). На этом все, спасибо за внимание. | https://habr.com/ru/post/235081/ | null | ru | null |
# Как сверстать веб-страницу. Часть 1
Уважаемый читатель, этой статьей я открываю цикл статей, посвященных вёрстке.
В первой части будет описано, как это сделать с помощью стандартных средств на чистом HTML и CSS. В последующих частях рассмотрим как сделать тоже самое, но с помощью современных фреймворков и CMS.
#### Часть 1. Верстка стандартными средствами
Преимущество данной верстки состоит в том, что код получается более «чистым», а значит быстрее загружается и легче изменяется под специфические нужды. Недостаток такой верстки заключается в том, что она требует значительно больше времени, чем при использовании фреймворков.
Итак, давайте приступим. В качестве нашего подопытного мы возьмем бесплатный psd шаблон [Corporate Blue](http://www.pcklab.com/templates/corporate-blue) от студии Pcklaboratory.
##### Структура файлов
Первым шагом давайте создадим простую структуру файлов для наших файлов.
* Создаем папку с названием нашего проекта, например Whitesquare.
* В ней создаем пустой файл index.html.
* В папке проекта создаем папку css с пустым файлом styles.css.
* В папке проекта создаем пустую папку images.
##### Предварительный осмотр
После создания структуры файлов открываем psd файл в Photoshop. Важно внимательно осмотреть шаблон и оценить его. Нам нужно понять следующие вещи:
* Как будут нарезаться изображения?
* Какими будут основные стили?
* Какой макет у нас получится?
Только после того, как вы мысленно себе ответите на эти вопросы, можно переходить к нарезке изображений и написанию кода. Давайте рассмотрим эти вопросы по-порядку.
##### Общие изображения
На данном этапе нужно нарезать и сохранить только общие изображения, которые будут на всех страницах сайта и не относятся к контенту. В нашем случае это будет светло-серый фон страницы, фон заголовка, пустое изображение, два логотипа и кнопки социальных сетей.
Сохраним логотипы следующим образом:
/images/logo.png
/images/footer-logo.png
В качестве пустых картинок из макета будем использовать однопиксельное серое изображение, которое будем растягивать по необходимости
/images/ sample.png
Повторяющиеся фоновые изображения необходимо вырезать минимальным кусочком достаточным для образования полного изображения повторением по вертикали и горизонтали.
/images/bg.png
/images/h1-bg.png
Иконки социальных сетей с одинаковыми размерами удобно сохранить в один файл и использовать как спрайты для более быстрой загрузки. Для этого можно склеить картинки вручную в Photoshop, а можно сначала нарезать по одной, а затем склеить с помощью специально сервиса, например [http://ru.spritegen.website-performance.org](http://ru.spritegen.website-performance.org/). В итоге получится два файла:
/images/social.png
/images/social-small.png
Общее правило при именовании изображений заключается в том, что мелкие и простые картинки, такие, как иконки, логотипы и т.д. сохраняются в формате png, а фотографии в формате jpg.
##### Основные стили
И только теперь можно начинать писать код. Но начнем мы это делать не с привычного HTML, а с переноса правил в CSS.
На данном этапе желательно перенести все визуальные стили из дизайна в CSS, которые будут применяться по умолчанию для каждого тега.
Основной цвет фона примерно соответствует цвету #f8f8f8. Он будет показан в случае, если фоновая картинка не загрузится. Наверху страницы находится серая дизайнерская полоска. Применим ее через свойство border для body.
Основным шрифтом является тот шрифт, которым написан текст в области контента. Чтобы узнать его стили нужно выделить его в Photoshop’е и посмотреть свойства шрифта. В данном случае это Tahoma 12px с цветом #8f8f8f. Так же в этом макете параграфы имеют увеличенные отступы.
Прописываем все эти стили в styles.css:
```
body {
color: #8f8f8f;
font: 12px Tahoma, sans-serif;
background-color: #f8f8f8;
border-top: 5px solid #7e7e7e;
margin: 0;
}
input[type="text"] {
background-color: #f3f3f3;
border: 1px solid #e7e7e7;
height: 30px;
color: #b2b2b2;
padding: 0 10px;
vertical-align: top;
}
button {
color: #fff;
background-color: #29c5e6;
border: none;
height: 32px;
font-family: 'Oswald', sans-serif;
}
p {
margin: 20px 0;
}
```
В дальнейшем мы все стили будем писать в этот же файл, поэтому будем называть его просто «стили».
##### Каркас HTML
И вот, наконец, мы можем попрактиковаться в написании HTML кода. Запишем в index.html следующее:
```
Whitesquare
```
Здесь мы указываем, что используем разметку HTML5, кодировку utf-8, страница называется Whitesquare. Также подключаем наш файл стилей и внешний файл со стилями шрифтов.
В последнем блоке в секции head мы подключаем специальный скрипт, который позволяет поддерживать Html5 теги в браузерах Internet Explorer меньше 9 версии. Мета-тег X-UA-Compatible сообщает, что в случае использования браузера Internet Explorer, он должен отразить сайт самым современным способом.
Весь html код в дальнейшем будет относиться к этому же файлу, поэтому специально указывать куда прописывать html код автор больше не будет.
##### Макет
В данном случае, мы видим, что сайт состоит из двух колонок: основного контента и сайдбара. Над ними находится шапка (header), в которой располагаются три горизонтальных блока: логотип с поиском, меню и название страницы. В самом низу под колонками располагается серый горизонтальный блок футера (footer).
Опишем это в теге body:
```
```
Wrapper используется для объединения блоков и их выравнивания по центру страницы.
Затем укажем стили блоков:
```
#wrapper {
max-width: 960px;
margin: auto;
}
header {
padding: 20px 0;
}
```
##### Логотип
Вставляем логотип в тег header:
```
[![Whitesquare logo]()](/)
```
Дополнительных стилей не требуется.
##### Поиск
 | https://habr.com/ru/post/202408/ | null | ru | null |
# Собственное корпоративное облако ownCloud с NGINX во frontend и несколькими серверами backend
#### **1. Схема**
Имеем:
* Frontend — NGINX проксирующий сервер для принятия и распределения нагрузки (IP — 1.2.3.4 — внешний, IP — 192.168.5.10 — внутренний DMZ) *по хорошему он тоже должен стоять за firewall-ом, но тут схема для простоты понимания.*
* Два сервера с поднятыми ownCloud
* cloud-1 IP — 192.168.1.11
* cloud-2 IP — 192.168.1.12
* Хранилище файлов NFS-storage IP — 192.168.1.20 для размещения данных пользователей с доступом по NFS.
#### **2. Установка ownCloud**
Собственно все действия по мануалу и математика из репозиториев.
Система Ubuntu 12.03 LTS — LAMP (при установке LAMP не забудьте пароль root)
Для работы с LDAP необходимо доставить php5-ldap
```
$sudo apt-get install php5-ldap
```
Для хранения данных мы используем отдельный сервер с доступом по NFS.
**На сервере-хранилище NFS-storage** ставим nfs сервер
```
$ sudo apt-get install nfs-kernel-server
```
Правим /etc/exports добавляя строчку:
```
/var/owncloud 192.168.1.0/24(rw,sync,no_root_squash,no_subtree_check)
```
Создаем папку и меняем ей права:
```
$sudo mkdir -p /var/owncloud
$sudo chown root:www-data /var/owncloud
```
Перепускаем nfs сервер:
```
$sudo /etc/init.d/nfs-kernel-server restart
```
С хранилкой закончили.
**На серверах-клиентах** nfs ставим:
```
$ sudo apt-get istall nfs-common
```
Правим vim /etc/rc.local перед exit 0 добавляем строчку: (для монтирования NFS папки при загрузке системы, пишу в этот файл потому как использование /etc/fstab вызывало тяжело преодолимые проблемы)
```
/bin/mount -t nfs -o user,rw,hard 192.168.1.20:/var/owncloud /var/cloud
```
Создаем папку /var/cloud и меняем ей права:
```
$sudo mkdir -p /var/cloud
```
```
$sudo chown root:www-data /var/owncloud
```
Для проверки монтирования
```
$sudo mount.nfs 192.168.1.20:/var/owncloud /var/cloud
```
**Далее ставим собственно облако на два сервера.**
Скачиваем и ставим ключ:
```
$wget http://download.opensuse.org/repositories/isv:ownCloud:community/xUbuntu_12.04/Release.key
$sudo apt-key add - < Release.key
```
Добавляем репозитории и ставим облако.
```
$sudo sh -c "echo 'deb http://download.opensuse.org/repositories/isv:/ownCloud:/community/xUbuntu_12.04/ /' >> /etc/apt/sources.list.d/owncloud.list"
$sudo apt-get update
$sudo apt-get install owncloud
```
Заходим `you_ip/owncloud`
* Вписываем администратора “admin”
* Придумываем пароль “password”
* Путь где будут храниться файлы пользователей /var/cloud (эту папку мы подключаем по NFS с хранилища)
* Выбираем MySQL
* Пользователь MySQL “root” (или тот что завели сами)
* Пароль пользователя root (который вводили при установке LAMP или от созданного пользователя)
* Имя базы данных “cloud”
* Сервер баз данных “localhost”
Жмем FINISH
И заходим под созданным пользователем admin в веб интерфейс owncloud.
Я правил /var/www/index.html для перенаправления на страницу входа на облако.
```
```
**Все это проделываем на обоих серверах CLOUD-1 и CLOUD-2.**
#### **3. Установка и настройка NGINX**
На сервере NGINX
```
$sudo apt-get install nginx
```
Создаем файл конфигурации для сайта перенаправления
```
$ sudo vim /etc/nginx/sites-available/cloud
```
Правим до такого состояния.
```
upstream myCloud {
ip_hash; #что бы сохранялась сессия
server 192.168.1.11:80;
server 192.168.1.12:80;
}
server {
listen 1.2.3.4:443 ssl; # работаем через SSL
server_name owncloud.site.org;
ssl_certificate /etc/ssl/certs/site.pem; # сертификат
ssl_certificate_key /etc/ssl/private/site.key; # ключ сертификата
client_max_body_size 200G; # максимальный файл для загрузки
location / {
proxy_pass http://myCloud;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}
}
```
Создаем ссылку
```
$sudo ln -s /etc/nginx/sites-available/owncloud.site.org /etc/nginx/sites-enabled/owncloud.site.org
```
Правим страницу по умолчанию, перенаправляя все запросы на SSL.
```
$sudo vim /usr/share/nginx/www/index.html
```
```
```
Перпускаем nginx
```
$sudo /etc/init.d/nginx restart
```
Теперь при все запросы на `owncloud.site.org` будут перенаправлены на `owncloud.site.org/cloud`
Сессия SSL устанавливается между клиентом и NGINX, между NGINX и облачными серверами обычный HTTP.
На этом этапе можно зайти на `owncloud.site.org` и должны попасть на приглашение ввода логина-пароля одного из наших cloud1(2) серверов.
После всех настроек мы получаем кластер но:
Когда пользователь настраивает свой профиль и выполняя действия с приложениями на сервере cloud-1 все эти данные хранятся в базе MySQL сервера cloud-1. При следующем входе он попадет на другой сервер кластера cloud-2 где ни действий ни настроек нет.
Для устранения этого нем необходимо синхронизация баз MySQL между серверами cloud-1 и cloud-2. Причем стандартная конфигурация репликации MySQL это master — slave, т.е. изменения на master реплицируются на slave но не наоборот. Нам же необходимо два равноправных сервера master — master.
*Вариант: возможно настройка двух и более облаков на работу с одной MySQL базой на отдельном сервере баз данных, но в этом случае надо держать еще один сервер только для MySQL баз, что несколько усложняет схему и в случае введения еще одного облака необходимо делать бакап базы и востановление после установки (дабы не затереть данные). Каким путем пойти — Ваш выбор.*
#### 4. Настройка репликации master — master MySQL
**На cloud1**
```
# vim /etc/mysql/my.cnf
```
добавляем строчки
```
[mysqld]
#Replication
log-bin=mysql-bin
binlog_format=mixed
server-id = 1 /* для каждого сервера уникальный */
slave-compressed = 1
binlog-do-db = cloud /* название базы для репликации */
#bind-address = 127.0.0.1 /* что бы можно было подулючаться с других машин*/
```
**На cloud2**
```
# vim /etc/mysql/my.cnf
```
добавляем строчки
```
[mysqld]
#Replication
log-bin=mysql-bin
binlog_format=mixed
server-id = 2 /* для каждого сервера уникальный */
slave-compressed = 1
binlog-do-db = cloud /* название базы для репликации */
#bind-address = 127.0.0.1 /* что бы можно было подулючаться с других машин*/
```
Заводим пользователя для репликации на обоих серверах.
**На cloud1**
пользователь repl2 с доступом с IP 192.168.1.11 и паролем u\_pass (должны быть права на базу cloud и привелегии SELECT, RELOAD, SUPER, REPLICATION SLAVE)
```
mysql> grant replication slave on *.* to 'repl2'@192.168.1.12 identified by 'u_pass';
```
**На cloud2**
пользователь repl1 с доступом с IP 192.168.1.12 и паролем u\_pass (должны быть права на базу cloud и привелегии SELECT, RELOAD, SUPER, REPLICATION SLAVE)
```
mysql> grant replication slave on *.* to 'repl2'@192.168.1.11 identified by 'u_pass';
```
Далее приводим обе базы в идентичное состояние:
**На cloud1**
```
mysql> FLUSH TABLES WITH READ LOCK;
mysql> show master status;
+------------------+----------+--------------+------------------+
| File | Position | Binlog_Do_DB | Binlog_Ignore_DB |
+------------------+----------+--------------+------------------+
| mysql-bin.000009 | 107 | cloud | |
+------------------+----------+--------------+------------------+
1 row in set (0.00 sec)
```
Делаем дамп базы cloud
```
#mysqldump -u root -p cloud > /home/user/cloud.sql
mysql> UNLOCK TABLES;
```
Копируем на cloud-2
```
$scp /home/user/cloud.sql user@192.168.1.12:/home/user/cloud.sql
```
**На cloud2**
далее настраиваем slave;
```
mysql> USE cloud;
mysql> SOURCE /home/user/cloud.sql
mysql> CHANGE MASTER TO MASTER_LOG_FILE='mysql-bin.000009';
mysql> CHANGE MASTER TO MASTER_LOG_POS=107;
mysql> stop slave;
mysql> CHANGE MASTER TO MASTER_HOST='192.168.5.11', MASTER_USER='repl2', MASTER_PASSWORD='u_pass';
```
**заметка***(здесь надо заметить что эти «CHANGE MASTER TO MASTER\_HOST='192.168.5.11', MASTER\_USER='repl2', MASTER\_PASSWORD='u\_pass';» данные раньше писались в файл MySQL /etc/mysql/my.cnf
master-host = 192.168.1.11
master-user = repl2
master-password = <пароль>
но были вынесены в отдельную команду в консоли MySQL)*
```
mysql> start slave;
mysql> show slave status/G;
```
Должно быть что то типа этого:
**лог**\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* 1. row \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
Slave\_IO\_State: Waiting for master to send event
Master\_Host: 192.168.1.11
Master\_User: repl2
Master\_Port: 3306
Connect\_Retry: 60
Master\_Log\_File: mysql-bin.000014
Read\_Master\_Log\_Pos: 107
Relay\_Log\_File: mysqld-relay-bin.000017
Relay\_Log\_Pos: 210
Relay\_Master\_Log\_File: mysql-bin.000014
Slave\_IO\_Running: Yes
Slave\_SQL\_Running: Yes
Replicate\_Do\_DB:
Replicate\_Ignore\_DB:
Replicate\_Do\_Table:
Replicate\_Ignore\_Table:
Replicate\_Wild\_Do\_Table:
Replicate\_Wild\_Ignore\_Table:
Last\_Errno: 0
Last\_Error:
Skip\_Counter: 0
Exec\_Master\_Log\_Pos: 107
Relay\_Log\_Space: 513
Until\_Condition: None
Until\_Log\_File:
Until\_Log\_Pos: 0
Master\_SSL\_Allowed: No
Master\_SSL\_CA\_File:
Master\_SSL\_CA\_Path:
Master\_SSL\_Cert:
Master\_SSL\_Cipher:
Master\_SSL\_Key:
Seconds\_Behind\_Master: 0
Master\_SSL\_Verify\_Server\_Cert: No
Last\_IO\_Errno: 0
Last\_IO\_Error:
Last\_SQL\_Errno: 0
Last\_SQL\_Error:
Replicate\_Ignore\_Server\_Ids:
Master\_Server\_Id: 2
1 row in set (0.00 sec)
**На cloud1**
Поскольку базы сейчас одинаковые делать дамп и восстанавливать его нет необходимости.
Нам надо настроить cloud-1 как slave к cloud-2
```
mysql> USE cloud;
mysql> stop slave;
mysql> CHANGE MASTER TO MASTER_HOST='192.168.5.12', MASTER_USER='repl1', MASTER_PASSWORD='u_pass';
mysql> start slave;
mysql> show slave status/G;
```
Вывод должен быть подобен как на cloud-2
Параметры … должны быть YES на cloud-1 и cloud-2.
`Slave_IO_Running: Yes
Slave_SQL_Running: Yes`
**На этом этапе есть небольшая проблема**, вы можете зайти под локальным пользователем на сервер cloud-1 а cloud-2 говорит что пароль не верный (или наоборот) :(. Причина — СОЛЬ :)
Имеется файл /var/www/owncloud/config/config.php в котором есть переменная
```
'passwordsalt' => '6d84a4d8cb3cf5439c05647ceb45682a',
```
и у каждого сервера облака значение будет разное. Необходимо скопировать это значение с сервера на который вы зайти можете и вставить там где это невозможно.
Для проверки заходим на [192.168.1.11](http://192.168.1.11) и [192.168.1.12](http://192.168.1.12) под одним пользователем и создаем в календаре событие на сервере cloud-1 а на cloud-2 оно должно появиться автоматически (F5).
**Имеем на выходе:**
* NGINX во фронтэнде для динамического распределения нагрузки
* Несколько серверов в бакэнде для повышения скорости отдачи при наплыве пользователей
#### **5. Клиенты**
* Для Linux, Windows и MacOC — бесплатны (минус — нельзя указать несколько разных папок для синхронизации)
* Для Android и iPhon/iPad — 0.99$
Воткактотак :)
#### **6. Ссылки**
[www.opennet.ru/tips/info/1205.shtml](http://www.opennet.ru/tips/info/1205.shtml)
[www.mysql.ru/docs/man/Replication\_HOWTO.html](http://www.mysql.ru/docs/man/Replication_HOWTO.html)
[habrahabr.ru/post/86496](http://habrahabr.ru/post/86496/)
[google.com](http://google.com) | https://habr.com/ru/post/209432/ | null | ru | null |
# Laravel. Установка, настройка, создание и деплой приложения
Итак, у вас есть желание попробовать или узнать о фреймворке [Laravel](http://laravel.com/).
Если вы хорошо знакомы с другими `PHP` фреймворками — для вас это не составит особого труда, если же нет — это отличный выбор для первого фреймворка.
Статья очень большая. Рекомендую читать ее полностью во время выходных.
Для ленивых:
[GitHub](https://github.com/andrewdacenko/habrahabr)
[Приложение](http://habr.eu1.frbit.net/)
#### Установка
Для установки Laravel нам потребуется [Composer](http://getcomposer.org/)
> Composer является инструментом для управления зависимостями в `PHP`. Он позволяет объявлять зависимые библиотеки, необходимые для проекта, и устанавливать их в проект.
>
> — [Composer](http://getcomposer.org/doc/00-intro.md#introduction)
>
>
Установка окружения будет происходить в среде `*nix` (на сайте так же есть мануал по установке на [Windows](http://getcomposer.org/doc/00-intro.md#installation-windows), плюс к этому вам нужен будет сервер, например [WAMP](http://www.wampserver.com/ru/) и [Git](http://windows.github.com/)).
Предположим, что у Вас совсем чистенькая ОС. Тогда откройте терминал и ~~введите эти строчки~~ скопируйте и вставьте
```
# Установка недостающих компонентов
sudo apt-get update
sudo apt-get install -y build-essential
sudo apt-get install -y python-software-properties
# Добавление в репозиторий php 5.5
sudo add-apt-repository ppa:ondrej/php5
sudo apt-get update
# Установка сервера
sudo apt-get install -y php5
sudo apt-get install -y apache2
sudo apt-get install -y libapache2-mod-php5
sudo apt-get install -y mysql-server
sudo apt-get install -y php5-mysql
sudo apt-get install -y php5-curl
sudo apt-get install -y php5-gd
sudo apt-get install -y php5-mcrypt
sudo apt-get install -y git-core
sudo apt-get install -y phpmyadmin
# Хак для phpmyadmin
echo "Include /etc/phpmyadmin/apache.conf" | sudo tee -a /etc/apache2/apache2.conf
# Включение mod_rewrite
sudo a2enmod rewrite
# Перезапустим apache для принятия изменений
sudo /etc/init.d/apache2 restart
# Глобально установим Composer
curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer
```
Через некоторое время у вас будут установлены все необходимые инструменты.
Перейдем непосредственно к установке `Laravel`.
```
# Предпочитаемая мной структура папок
cd # перейдем в директорию /home/%user%
mkdir workspace #создадим папку workspace
cd workspace # перейдем в нее
mkdir php # создадим папку php
cd php # перейдем в папку php
```
Создадим проект `laravel` в папке *habr*
```
composer create-project laravel/laravel habr --prefer-dist
# .... тут будет долгий процес создания проекта ....
```
Перейдем в созданный проект и убедимся, что все работает, запустив команду `php artisan serve`
```
cd habr
php artisan serve
```
Локальный сервер будет доступен по адресу <http://localhost:8000>.
> На всякий случай **artisan** — это скрипт для командной строки, который есть в `Laravel`. Он предоставляет ряд полезных команд для использования при разработке. Он работает поверх компонента консоли `Symfony`. ([Artisan CLI](http://laravel.com/docs/artisan)). Есть много полезных команд, с помощью которых в командной строке можно создавать разные полезные вещи. Для списка команд введите `php artisan list` в командной сроке.
Перейдя по адресу <http://localhost:8000> вы должны увидеть красивую заставку как в начале поста.
#### Настройка
Для соединения с базой данных (далее БД) у `Laravel` есть конфигурационный файл *database.php*, находится он в папке *app/config/*.
Сначала создадим БД и пользователя в `MySQL`
```
mysql -u root -p
# Введите свой пароль
> CREATE DATABASE `habr` CHARACTER SET utf8 COLLATE utf8_general_ci;
> CREATE USER 'habr'@'localhost' IDENTIFIED BY 'my_password';
> GRANT ALL PRIVILEGES ON habr.* TO 'habr'@'localhost';
> exit
```
Отлично! У нас есть все данные для доступа к `MySQL`: пользователь **habr** с паролем **my\_password** и БД **habr** на хосте **localhost**. Перейдем в файл конфигурации БД и изменим наши настройки.
В `Laravel` есть отличные инструменты — [Миграции](http://laravel.com/docs/migrations) и [Построитель Схем](http://laravel.com/docs/schema).
> Миграции это тип управления версиями в базе данных. Они позволяют команде разработчиков изменять схему базы данных и оставаться в курсе о текущем состоянии схемы. Миграция, как правило, в паре с Построителем Схем позволют легко управлять схемой БД.
>
> — [Миграции](http://laravel.com/docs/migrations)
>
> Построитель Схем — это класс **Schema**. Он дает возможность манипулирования таблицами в БД. Он хорошо работает со всеми БД, которые поддерживаются `Laravel`, и имеет единый `API` для всех этих систем.
>
> — [Построитель Схем](http://laravel.com/docs/schema)
Во первых создадим таблицу миграций:
```
php artisan migrate:install
```
Если настройки соединения с БД правильны, то мы готовы создавать миграции и таблицы.
Но перед этим хочу вас познакомить с установкой дополнительных пакетов, которые можно использовать для более эффективного и быстрого создания веб приложения.
##### Laravel 4 Generators
Мега полезный инструмент — **generators** от **Jeffrey Way**. [GitHub](https://github.com/JeffreyWay/Laravel-4-Generators).
Он добавляет в список **artisan** много полезных команд, таких как:
* generate:model — создание моделей
* generate:controller — создание контроллеров
* generate:seed — создание файлов для наболнения БД конфигурационной / фейковой информацией
* generate:view — создание шаблонов
* generate:migration — создание миграций
* generate:resource — создание ресурсов
* generate:scaffold — создание прототипов (самое интересное, его рассмотрим подробнее чуть позже!)
* generate:form — создание форм
* generate:test — создание тестов
* generate:pivot — создание миграции сводной таблицы
###### Установка пакета
Установка пакетов с помощью `Composer` происходит достаточно просто. Нужно отредактировать файл **composer.json** в корне приложения, добавив строчку `"way/generators": "1.*"` в список `"require"`.
```
"require": {
"laravel/framework": "4.1.*",
"way/generators": "1.*"
},
```
После этого нужно обновить зависимости проекта. Введите в терминале
```
composer update
```
Последним штрихом будет занесение в кофигурационный файл **app/config/app.php** в список провайдеров приложения строки
```
'Way\Generators\GeneratorsServiceProvider'
```
Теперь список команд `php artisan` будет также содержать новые команды `generate`. В следующем разделе я покажу как использовать `generate` для создания приложения и ускорения разработки.
#### Создание приложения
Предположим, что мы создаем некий ~~блог~~ сайт со скидками. Для этого нам нужно:
* Таблица пользователей с имейлом, username и паролем
* Таблица ролей
* Таблица ролей пользователей
* Таблица городов
* Таблица компаний
* Таблица тегов
* Таблица скидок с полями: заголовок, описание, город, компания, % скидки, картинка и дата истечения скидки
* Таблица комментариев с оценками
* Таблица тегов скидок
Набросаем схему таблиц в БД. У меня получилось что-то такое:
За это спасибо **generator**'у. Так как все, что я сделал — это прописал 10 строк, кстати, вот и они:
```
php artisan generate:migration create_users_table --fields="email:string:unique, password:string[60], username:string:unique, remember_token:string:nullable"
php artisan generate:scaffold role --fields="role:string:unique"
php artisan generate:pivot users roles
php artisan generate:scaffold city --fields="name:string:unique"
php artisan generate:scaffold company --fields="title:string:unique"
php artisan generate:scaffold tag --fields="title:string:unique"
php artisan generate:scaffold offer --fields="title:string, description:text, city_id:integer:unsigned, company_id:integer:unsigned, off:integer:unsigned, image:string, expires:date"
php artisan generate:scaffold comment --fields="body:text, user_id:integer:unsigned, offer_id:integer:unsigned, mark:integer"
php artisan generate:pivot offers tags
# И сохраним схемы в БД
php artisan migrate
```
С помощью последней команды в БД будут занесены все миграции, которые еще не были записаны. Важно то, что все новые миграции будут запущены одним стэком. Для того, чтобы откатить миграцию есть команда `php artisan migrate:rollback`, а для того, чтобы откатить все миграции до нуля `migrate:reset`, чтобы скатить до нуля и запустить все миграции `migrate:refresh`.
> В `Laravel` версии выше **4.1.25** произошло обновление безопасности, где закрывали дыру с похищенными куками. Подробности обновления и инструкцию можно посмотреть тут: <http://laravel.com/docs/upgrade> для тех, у кого версия `Laravel` < **4.1.26**. Или просто прочтите коммент от [vlom88](https://habrahabr.ru/users/vlom88/) <http://habrahabr.ru/post/197454/#comment_7510479>.
Подробнее о командах генератора:
* **generate:migration** Принимает имя аргумент миграции, и создает соответсвующую схему. В имени схемы можно указать ключевые слова, например **create** — создание, далее идет **имя** таблицы и ключевое слово **table**. Так же можно указать какие поля добавить в таблицу через опцию **--fields=""**, в которой через запятую перечислить поля с ихним типом данных. [Создание миграции](https://github.com/JeffreyWay/Laravel-4-Generators#generating-schema), [Типы данных и прочее](http://laravel.com/docs/schema#adding-columns)
* **generate:scaffold** Принимает как агрумент ресурс (к примеру **role**), и создает такие файлы:
+ *app/models/Role.php* — клас модели, наследуемый от [Eloquent ORM](http://laravel.com/docs/eloquent) для работы с таблицей ролей (имя самой таблицы — это множественное число от имени ресурса)
+ *app/controllers/RolesController.php* — клас контроллера, который отвечает на запросы к сайту, так же является [REST](http://laravel.com/docs/controllers#resource-controllers) контроллером
| | | | |
| --- | --- | --- | --- |
| Метод HTTP | Путь (URL) | Действие | Имя маршрута |
| GET | /resource | index | resource.index |
| GET | /resource/create | create | resource.create |
| POST | /resource | store | resource.store |
| GET | /resource/{id} | show | resource.show |
| GET | /resource/{id}/edit | edit | resource.edit |
| PUT/PATCH | /resource/{id} | update | resource.update |
| DELETE | /resource/{id} | destroy | resource.destroy |
+ *app/views/roles/index.blade.php* — шаблон, который отвечает за список всех ресурсов (обычно генерируется при `GET` запросе по `URL` **/roles**), про сам шаблонизатор я расскажу чуть позже
+ *app/views/roles/show.blade.php* — шаблон, который отвечает за отображение конкретного ресурса (`GET` запрос на `URL` **/roles/{id}**)
+ *app/views/roles/create.blade.php* — шаблон, в котором находится форма для добавления ресурса (`GET` на `URL` **/roles/create**)
+ *app/views/roles/edit.blade.php* — шаблон, в котором находится форма для редактирования ресурса (`GET` на `URL` **/roles/{id}/edit}**)
+ *app/views/layouts/scaffold.blade.php* — основной лейаут приложения (содержит базовый html + bootstrap + контейнер для вставляемого контента)
+ *app/database/migrations/Create\_roles\_table.php* — миграция
+ *app/database/seeds/RolesTableSeeder.php* — файл для тестового наполнения таблицы данными
+ *app/tests/controllers/RolesTest.php* — различные тесты
а так же обновляет и добавляет данные в файлы
+ *app/database/seeds/DatabaseSeeder.php* — добавляет вызов RolesTableSeeder
+ *app/routes.php* — добавляет в регистр маршрутов все методы ресурса ([REST](http://laravel.com/docs/controllers#resource-controllers))
* **generate:pivot** Принимает 2 аргумента (имена таблиц). Создает сводную таблицу, которая содержит 2 `foreign key`
Я надеюсь этот пример использования генератора достаточно наглядно показал, каким образом его использовать и насколько он полезен.
Чего нам еще не хватает — так это некоторых связок между таблицами.
> **Важно знать!** При добавлении foreign key к колонке в таблице нужно убедится, что колонка является unsigned.
Что ж, добавим их:
```
php artisan generate:migration add_foreign_user_id_and_offer_id_to_comments_table
php artisan generate:migration add_foreign_city_id_and_company_id_to_offers_table
```
Теперь нам нужно прописать добавление индексов внутри самих файлов миграций, так как такие изменения автоматически не создаются.
```
...
class AddForeignUserIdAndOfferIdToCommentsTable extends Migration {
...
public function up()
{
Schema::table('comments', function(Blueprint $table) {
$table->index('user_id');
$table->index('offer_id');
$table->foreign('user_id')->references('id')->on('users')->onDelete('cascade');
$table->foreign('offer_id')->references('id')->on('offers')->onDelete('cascade');
});
}
...
public function down()
{
Schema::table('comments', function(Blueprint $table) {
$table->dropForeign('comments_user_id_foreign');
$table->dropForeign('comments_offer_id_foreign');
$table->dropIndex('comments_user_id_index');
$table->dropIndex('comments_offer_id_index');
});
}
}
...
class AddForeignCityIdAndCompanyIdToOffersTable extends Migration {
...
public function up()
{
Schema::table('offers', function(Blueprint $table) {
$table->index('city_id');
$table->index('company_id');
$table->foreign('city_id')->references('id')->on('cities')->onDelete('cascade');
$table->foreign('company_id')->references('id')->on('companies')->onDelete('cascade');
});
}
...
public function down()
{
Schema::table('offers', function(Blueprint $table) {
$table->dropForeign('offers_city_id_foreign');
$table->dropForeign('offers_company_id_foreign');
$table->dropIndex('offers_city_id_index');
$table->dropIndex('offers_company_id_index');
});
}
}
```
Взгянув на схему БД видим ситуацию по лучше
На данный момент все ссылки на ресурсы являются открытыми, и по ним можно переходить всем кому угодно.
Допустим, добавим роль admin. По ссылке <http://localhost:8000/roles> видим следующую картину:
Немного о шаблонах и шаблонизаторе [Blade](http://laravel.com/docs/templates#blade-templating) в Laravel.
Для файлов шаблонов используется раширение .blade.php. Заглянув в файл *app/views/layouts/scaffold.blade.php* мы видим
```
// app/views/layouts/scaffold.blade.php
table form { margin-bottom: 0; }
form ul { margin-left: 0; list-style: none; }
.error { color: red; font-style: italic; }
body { padding-top: 20px; }
@if (Session::has('message'))
{{ Session::get('message') }}
@endif
@yield('main')
```
Что здесь происходит? Сам файл является скелетом, лэйаутом, который можно расширить, добавив внутрь секции `main` какой-то контент, или еще один шаблон. Двойные фигурные скобки **{{ $var }}** являются аналогом **php echo $var; ?**. Класс [Session](http://laravel.com/docs/session) используется здесь для вывода сообщений пользователю, если мы передадим какое-то сообщение. Сообщение является временным, и при обновлении страницы пропадет. Если мы откроем только что созданный шаблон *app/views/roles/index.blade.php*
```
// app/views/roles/index.blade.php
@extends('layouts.scaffold')
@section('main')
All Roles
=========
{{ link\_to\_route('roles.create', 'Add new role') }}
@if ($roles->count())
| Role |
| --- |
@foreach ($roles as $role)
| {{{ $role->role }}} | {{ link\_to\_route('roles.edit', 'Edit', array($role->id), array('class' => 'btn btn-info')) }} |
{{ Form::open(array('method' => 'DELETE', 'route' => array('roles.destroy', $role->id))) }}
{{ Form::submit('Delete', array('class' => 'btn btn-danger')) }}
{{ Form::close() }}
|
@endforeach
@else
There are no roles
@endif
@stop
```
То нам станет ясно, что этот шаблон расширяет шаблон *app/views/layouts/scaffold.blade.php*, за это говорит код `@extends('layouts.scaffold')`. Заметьте, что тут для разделения между папками используется точка, хотя так же можно использовать и **/**.
Далее в секцию `main` будет записано все до первого появления `@stop`. Так же тут используются знакомые нам `if - else - endif` и `foreach - endforeach`, вспомогательная функция `link_to_route`, которую нам предоставляет Laravel (Helper Functions) и класс `Form` для создания форм (Предпочтительно нужно пользоваться им, хотя бы Form::open(), так как он создает дополнительный аттрибут формы [\_token](http://laravel.com/docs/html#csrf-protection) — защита от подделки кросс сайтовых запросов и [\_method](http://laravel.com/docs/html#opening-a-form) в случае PUT / PATCH или DELETE).
Первым делом подумаем о защите всех ресурсов. Для этого нам нужно ввести авторизацию.
Создадим новый контроллер `LoginContoller` в папке *app/controllers*
```
php artisan generate:controller LoginController
```
И добавим для него несколько шаблонов
```
mkdir app/views/login
php artisan generate:view index --path="app/views/login"
php artisan generate:view register --path="app/views/login"
php artisan generate:view dashboard --path="app/views/login"
```
Теперь изменим сам контроллер. Нам нужны 5 методов:
* index — отвечает за генерацию формы входа
* register — отвечает за генерацию форми регистрации
* store — отвечает за регистрацию нового пользователя
* login — отвечает за вход пользователя на сайт
* logout — отвечает за выход пользователя
Измененный контроллер LoginController будет выглядеть так:
```
// app/controllers/LoginController.php
class LoginController extends BaseController {
/**
* Login Form.
*
* @return Response
*/
public function index()
{
return View::make('login.index');
}
/**
* Registration form.
*
* @return Response
*/
public function register()
{
return View::make('login.register');
}
/**
* Registring new user and storing him to DB.
*
* @return Response
*/
public function store()
{
$rules = array(
'email' => 'required|email|unique:users,email',
'password' => 'required|alpha_num|between:4,50',
'username' => 'required|alpha_num|between:2,20|unique:users,username'
);
$validator = Validator::make(Input::all(), $rules);
if($validator->fails()){
return Redirect::back()->withInput()->withErrors($validator);
}
$user = new User;
$user->email = Input::get('email');
$user->username = Input::get('username');
$user->password = Hash::make(Input::get('password'));
$user->save();
Auth::loginUsingId($user->id);
return Redirect::home()->with('message', 'Thank you for registration, now you can comment on offers!');
}
/**
* Log in to site.
*
* @return Response
*/
public function login()
{
if (Auth::attempt(array('email' => Input::get('email'), 'password' => Input::get('password')), true) ||
Auth::attempt(array('username' => Input::get('email'), 'password' => Input::get('password')), true)) {
return Redirect::intended('dashboard');
}
return Redirect::back()->withInput(Input::except('password'))->with('message', 'Wrong creadentials!');
}
/**
* Log out from site.
*
* @return Response
*/
public function logout()
{
Auth::logout();
return Redirect::home()->with('message', 'See you again!');
}
}
```
Первые два метода генерируют из шаблонов HTML.
Метод `store` сохраняет в нашу БД нового пользователя, принимая все входящие через `POST` данные от `Input::all()`. ([Подробнее](http://laravel.com/docs/requests)).
В классе `Input` находятся данные, которые были отправлены при POST запросе. Он имеет ряд статичных методов, таких как `all()`, `get()`, `has()` и другие ([Basic Input](http://laravel.com/docs/requests#basic-input)).
`Hash` — это класс шифрования, который использует метод [bcrypt](http://ru.wikipedia.org/wiki/Bcrypt), чтобы пароли в БД хранились в зашифрованом виде ([Laravel Security](http://laravel.com/docs/security#storing-passwords)).
Но перед регистрацией нам нужно провести валидацию входящих данных.
Для этого в `Laravel` есть класс [Validator](http://laravel.com/docs/validation). Метод `Validation::make` принимает 2 или 3 аргумента:
1. `$input` — обязательный, массив входящих данных, которые нужно проверить
2. `$rules` — обязательный, массив с правилами к входящим данным
3. `$messages` — опциональный, массив с сообщениями об ошибках
Полный список доступных правил можно посмотреть тут [Available Validation Rules](http://laravel.com/docs/validation#available-validation-rules).
Метод `fails()` возвращает **true** или **false** в зависимости от того, прошли ли валидацию данные в соответствии с правилами, которые мы передали в метод `make`.
Класс [Redirect](http://laravel.com/docs/responses#redirects) используется для перенаправления. Его методы:
* back() — перенаправит на страницу, с которой был послан запрос
* intended('fallback') — перенаправит на страницу, с которой пользователь попал под фильтр авторизации, если таковой не было, то отправит на URL, который передан в `fallback`
* withInput() — передаст во временную сессию данные с Input
* withErrors($validator) — передаст в переменную **$errors** данные с `$validator` (! Важно знать, что переменная **$errors** создается на всех страницах при GET запросах, поэтому она всегда доступна на всех страницах).
* with('variable', 'Your message here') — передаст во временную сессию переменную 'variable' с сообщением, которое вы укажете
Класс `Auth` является классом авторизации, у него имется ряд методов, в том числе и `loginUsingId($id)`, который авторизирует пользователя по указанному идентификатору из БД ([Authenticating Users](http://laravel.com/docs/security#authenticating-users)). Так как после регисрации мы хотим автоматически авторизировать пользователя, то воспользуемся им.
Метод нашего Контроллера `login()` авторизирует пользователя по `email` или `username` и перенаправляет на страницу, с которой он попал под фильтр авторизации. В случае не совпадения данных, перенаправляет обратно с входящими данными, сообщением о ошибке, но без пароля.
Таким образом у нас есть Контроллер, который отвечает за авторизацию.
Следующим шагом для скрытия всех ресурсов от доступа будет изменение файла *app/routes.php*, который содержит маршруты приложения.
```
// app/routes.php
...
Route::get('/', array('as' => 'home', function()
{
return View::make('hello');
}));
Route::get('logout', array('as' => 'login.logout', 'uses' => 'LoginController@logout'));
Route::group(array('before' => 'un_auth'), function()
{
Route::get('login', array('as' => 'login.index', 'uses' => 'LoginController@index'));
Route::get('register', array('as' => 'login.register', 'uses' => 'LoginController@register'));
Route::post('login', array('uses' => 'LoginController@login'));
Route::post('register', array('uses' => 'LoginController@store'));
});
Route::group(array('before' => 'admin.auth'), function()
{
Route::get('dashboard', function()
{
return View::make('login.dashboard');
});
Route::resource('roles', 'RolesController');
Route::resource('cities', 'CitiesController');
Route::resource('companies', 'CompaniesController');
Route::resource('tags', 'TagsController');
Route::resource('offers', 'OffersController');
Route::resource('comments', 'CommentsController');
});
Route::filter('admin.auth', function()
{
if (Auth::guest()) {
return Redirect::to('login');
}
});
Route::filter('un_auth', function()
{
if (!Auth::guest()) {
Auth::logout();
}
});
```
Перейдя теперь по ссылке, к примеру **/roles** нас будет перенаправлено на страницу **/login**, на которой пока отображается только стандартный текст `"index.blade.php"`.
Ко всем маршрутам, заключенным в `Route::group(array('before' => 'admin.auth'))` будет применятся фильтр **admin.auth**, который проверяет, является ли пользователь гостем, или нет, и в случае, если является — отправит его на страницу входа. Про фильтры можно почитать [тут](http://laravel.com/docs/routing#route-filters), а про группировку маршрутов [тут](http://laravel.com/docs/routing#route-groups). Другой фильтр `Route::group(array('before' => 'un_auth'))` будет проверять, является ли пользователь вошедшим на сайт, и если проверка выполнятся — то он его разлогинивает.
Для нормальной работы изменим файлы логина и регистрации:
```
// app/views/login/index.blade.php
@extends('layouts.scaffold')
@section('main')
Login
=====
{{ link\_to\_route('login.register', 'Register') }}
{{ Form::open(array('route' => 'login.index')) }}
* {{ Form::label('email', 'Email or Username:') }}
{{ Form::text('email') }}
* {{ Form::label('password', 'Password:') }}
{{ Form::password('password') }}
* {{ Form::submit('Submit', array('class' => 'btn btn-info')) }}
{{ Form::close() }}
@include('partials.errors', $errors)
@stop
// app/views/login/register.blade.php
@extends('layouts.scaffold')
@section('main')
Register
========
{{ link\_to\_route('login.index', 'Login') }}
{{ Form::open(array('route' => 'login.register')) }}
* {{ Form::label('email', 'Email:') }}
{{ Form::text('email') }}
* {{ Form::label('username', 'Username:') }}
{{ Form::text('username') }}
* {{ Form::label('password', 'Password:') }}
{{ Form::password('password') }}
* {{ Form::submit('Submit', array('class' => 'btn btn-info')) }}
{{ Form::close() }}
@include('partials.errors', $errors)
@stop
// app/views/login/dashboard.blade.php
@extends('layouts.scaffold')
@section('main')
Administrative Dashboard
========================
Nice to see you, **{{{ Auth::user()->username }}}**
@stop
// app/views/partials/errors.blade.php
@if ($errors->any())
{{ implode('', $errors->all('* :message
')) }}
@endif
```
Как вы заметили, тут я использовал новый прием в шаблонизаторе `@include('view', $variable)`. В применении он весьма прост — передайте 2 аргумента:
1. view — шаблон, который нужно включить в конкретный шаблон
2. $variable — переменная, которую нужно передать для отрисовки шаблона
Зарегистрируйтесь на сайте, чтобы иметь доступ к сайту.
Что же, теперь можна заняться ресурсами. Начнем с городов. Первым делом изменим в Модели `City` правила валидации:
```
// app/models/City.php
class City extends Eloquent {
protected $guarded = array();
public static $rules = array(
'name' => 'required|alpha|min:2|max:200|unique:cities,name'
);
}
```
После нее изменим правила валидации так же и у Моделей `Company`, `Role` и `Tag`:
```
// app/models/Company.php
...
public static $rules = array(
'name' => 'required|alpha|min:2|max:200|unique:companies,name'
);
...
// app/models/Role.php
...
public static $rules = array(
'role' => 'required|alpha|min:2|max:200|unique:roles,role'
);
...
// app/models/Tag.php
...
public static $rules = array(
'name' => 'required|min:2|max:200|unique:tags,name'
);
...
```
Для удобства перехода между ссылками добавим меню в *app/views/layouts/scaffold.blade.php*, а так же добавим jQuery и jQuery-UI для будующих нужд
```
// app/views/layouts/scaffold.blade.php
table form { margin-bottom: 0; }
form ul { margin-left: 0; list-style: none; }
.error { color: red; font-style: italic; }
body { padding-top: 20px; }
input, textarea, .uneditable-input {width: 50%; min-width: 200px;}
@yield('styles')
* {{ link\_to\_route('offers.index', 'Offers') }}
* {{ link\_to\_route('tags.index', 'Tags') }}
* {{ link\_to\_route('roles.index', 'Roles') }}
* {{ link\_to\_route('cities.index', 'Cities') }}
* {{ link\_to\_route('comments.index', 'Comments') }}
* {{ link\_to\_route('companies.index', 'Companies') }}
* {{ link\_to\_route('login.logout', 'Logout') }}
@if (Session::has('message'))
{{ Session::get('message') }}
@endif
@yield('main')
@yield('scripts')
```
Далее перейдем к редактированию правил валидации в Модели `Offer`:
```
// app/models/Offer.php
...
public static $rules = array(
'title' => 'required|between:5,200',
'description' => 'required|min:10',
'city_id' => 'required|exists:cities,id',
'company_id' => 'required|exists:companies,id',
'off' => 'required|numeric|min:1|max:100',
'image' => 'required|regex:/\/images\/\d{4}\/\d{2}\/\d{2}\/([A-z0-9]){30}\.jpg/',
// matches /images/2012/12/21/ThisIsTheEndOfTheWorldMaya2112.jpg
'expires' => 'required|date'
);
```
Здесь я использовал сложный паттерн для поля `image`, так как хочу воспользоваться средствами `AJAX` для загрузки картинок, и в саму валидацию передавать только путь к картинке на сервере. Значит начнем с изменения шаблона *app/views/offers/create.blade.php* и создания отдельного файла для скриптов.
```
// app/views/offers/create.blade.php
...
{{ Form::label('file', 'Image:') }}
{{ Form::file('file')}}
![]()
{{ Form::hidden('image') }}
...
@section('scripts')
@include('offers.scripts')
@stop
// app/views/offers/scripts.blade.php
$(document).ready(function(){
// Добавим красивый выбор даты
$('#expires').datepicker({dateFormat: "yy-mm-dd"});
var uploadInput = $('#file'), // Инпут с файлом
imageInput = $('[name="image"]'), // Инпут с URL картинки
thumb = document.getElementById('thumb'), // Превью картинки
error = $('div.error'); // Вывод ошибки при загрузке файла
uploadInput.on('change', function(){
// Создадим новый объект типа FormData
var data = new FormData();
// Добавим в новую форму файл
data.append('file', uploadInput[0].files[0]);
// Создадим асинхронный запрос
$.ajax({
// На какой URL будет послан запрос
url: '/upload',
// Тип запроса
type: 'POST',
// Какие данные нужно передать
data: data,
// Эта опция не разрешает jQuery изменять данные
processData: false,
// Эта опция не разрешает jQuery изменять типы данных
contentType: false,
// Формат данных ответа с сервера
dataType: 'json',
// Функция удачного ответа с сервера
success: function(result) {
// Получили ответ с сервера (ответ содержится в переменной result)
// Если в ответе есть объект filelink
if (result.filelink) {
// Зададим сообтветсвующий URL нашему мини изображению
thumb.setAttribute('src', result.filelink);
// Сохраним значение в input'е
imageInput.val(result.filelink);
// Скроем ошибку
error.hide();
} else {
// Выведет текст ошибки с сервера
error.text(result.message);
error.show();
}
},
// Что-то пошло не так
error: function (result) {
// Ошибка на стороне сервера
error.text("Upload impossible");
error.show();
}
});
});
});
```
Здесь мы будем добавлять картинку по нажатию на `input[name="file"]` и отправлять ее с помощью `AJAX` по `URL` /upload. Ответом с этого URL будет ссылка на загруженное изображение. Эту ссылку мы вставим в атрибут src у картинки #thumb и сохраним в скрытом инпуте `image`. Дальше нам нужно в файле *app/routes.php* добавить маршут `upload`:
```
// app/routes.php
...
Route::group(array('before' => 'admin.auth'), function(){
...
Route::resource('comments', 'CommentsController');
Route::post('upload', array('uses' => 'HomeController@uploadOfferImage'));
}
...
```
Отлично, URL мы зарегистрировали, осталось прописать логику в `HomeController`. Для этого в файле *app/controllers/HomeController.php* добавим метод `uploadOfferImage`
min:
```
// app/controllers/HomeController.php
class HomeController extends BaseController {
...
public function uploadOfferImage()
{
$rules = array('file' => 'mimes:jpeg,png');
$validator = Validator::make(Input::all(), $rules);
if ($validator->fails()) {
return Response::json(array('message' => $validator->messages()->first('file')));
}
$dir = '/images'.date('/Y/m/d/');
do {
$filename = str_random(30).'.jpg';
} while (File::exists(public_path().$dir.$filename));
Input::file('file')->move(public_path().$dir, $filename);
return Response::json(array('filelink' => $dir.$filename));
}
}
```
Все достаточно просто: правила, валидация, ошибки, ответ. Что бы сохранить для начала мы зададим папку, в которую будем его сохранять — это *public\_path()/images/текущий год/месяц/дата/* (`public_path()` — это вспомогательная функция `Laravel` для пути к публичным файлам), далее создадим рандомное имя файла `str_random(30)` длиною 30 символов и расширением `jpg`. После этого воспользуемся классом `Input` и его методом `file('file')->move('destination_path', 'filename')`, где: 'file' — входящий файл, 'destination\_path' — папка, в которую перемещаем файл, 'filename' — имя для файла, который будет сохранен.
`Response::json` выдаст ответ в формате `json`.
Отлично! Файлы у нас теперь загружаются с помощью `AJAX`.
 | https://habr.com/ru/post/197454/ | null | ru | null |
# Настройка аккаунта GTalk в Kopete (KDE4)
Сегодня поставил на своём лаптопе **Kubuntu KDE4** и столкнулся с проблемой при настройке GTalk в Kopete. При соединении выдавалась ошибка «SSL support could not be initialized for account user@example.com. This is most likely because the QCA TLS plugin os not installed on your system».
Первым делом я, естественно, попытался решить эту проблему путём установки этого самого **QCA TLS**, довольно логично, не правда ли? Тем более, что и пакетик в репозиториях нашёлся одноименный.
`sudo apt-get install qca-tls`
После этого перезапускаю Kopete и… вылетает та же самая ошибка. Перечитываю сообщение об ошибке, вижу замечание о *плагине* и после непродолжительного поиска по пакетам, выполняю
`sudo apt-get install libqca2-plugin-ossl`
После этого перезапускаю Kopete и… вуаля, всё заработало!
Кстати, не лишним будет напомнить, что для общения с вашего аккаунта GTalk из Копете необходимо выставить следующие настройки:
1. При создании аккаунта выбрать протокол **Jabber**
2. В качестве Jabber ID ввести ваше имя пользователя, вместе с доменным именем, то есть username@gmail.com или username@example.com если вы используете Google Apps на домене вашей организации и т. п.
3. В параметрах соединения (Вкладка Connection) поставить все три галочки: Use protocol encryption (SSL); Allow plain-text password authentication; Override default server information
4. Выставить в качестве имени сервера **talk.google.com**, порт **5223**.
Этих настроек должно быть вполне достаточно для комфортной работы. Не забудьте установить поддержку QCA TLS, если выскочит ошибка. Одной командой это делается так:
`sudo apt-get install qca-tls libqca2-plugin-ossl` | https://habr.com/ru/post/39929/ | null | ru | null |
# Нейронная сеть Хопфилда на пальцах
Статья посвящена введению в нейронные сети и примеру их реализации. В первой части дано небольшое теоретическое введение в нейронные сети на примере нейронной сети Хопфилда. Показано, как осуществляется обучение сети и как описывается ее динамика. Во второй части показано, как можно реализовать алгоритмы, описанные в первой части при помощи языка С++. Разработанная программа наглядно показывает способность нейронной сети очищать от шума ключевой образ. В конце статьи есть ссылка на исходный код проекта.
Теоретическое описание
======================
Введение
--------
Для начала, необходимо определить, что такое нейрон. В биологии нейрон — специализированная клетка, из которой состоит нервная система. Биологический нейрон имеет строение, показанное на рис.1.
Рис.1 Схема нейрона
Нейронную сеть можно ввести как совокупность нейронов и их взаимосвязей. Следовательно, для того, чтобы определить искусственную (не биологическую) нейронную сеть необходимо:
1. Задать архитектуру сети;
2. Определить динамику отдельных элементов сети — нейронов;
3. Определить правила, по которым нейроны будут взаимодействовать между собой;
4. Описать алгоритм обучения, т.е. формирования связей для решения поставленной задачи.
В качестве архитектуры нейронной сети будет использоваться сеть Хопфилда. Данная модель, видимо, является наиболее распространенной математической моделью в нейронауке. Это обусловлено ее простотой и наглядность. Сеть Хопфилда показывает, каким образом может быть организована память в сети из элементов, которые не являются очень надежными. Экспериментальные данные показывают, что при увеличении количества вышедших из строя нейронов до 50%, вероятность правильного ответа крайне близка к 100%. Даже поверхностное сопоставление нейронной сети (например, мозга) и Фон-Неймановской ЭВМ показывает, насколько сильно различаются эти объекты: к примеру, частота изменения состояний нейронов («тактовая частота») не превышает 200Гц, тогда как частота изменения состояния элементов современного процессора может достигать нескольких ГГц (Гц).
Формальное описание сети Хопфилда
Сеть состоит из N искусственных нейронов, аксон каждого нейрона связан с дендритами остальных нейронов, образуя обратную связь. Архитектура сети изображена на рис. 2.
Рис.2 Архитектура нейронной сети Хопфилда
Каждый нейрон может находиться в одном из 2-х состояний:
)%5Cin%5C%7B-1%3B%2B1%5C%7D)
где ) — состояние нейрона в момент . «Возбуждению» нейрона соответствует , а «торможению» . Дискретность состояний нейрона отражает нелинейный, пороговый характер его функционирования и известный в нейрофизиологи как принцип «все или ничего».
Динамика состояния во времени -ого нейрона в сети из  нейронов описывается дискретной динамической системой:
)![S_{i}(t+1)=sign[\sum\limits_{j=1}^N J_{i,j}S_{i}(t)],\quad i,j\in1,..,N](https://tex.s2cms.ru/svg/S_%7Bi%7D(t%2B1)%3Dsign%5B%5Csum%5Climits_%7Bj%3D1%7D%5EN%20J_%7Bi%2Cj%7DS_%7Bi%7D(t)%5D%2C%5Cquad%20i%2Cj%5Cin1%2C..%2CN)
где  — матрица весовых коэффициентов, описывающих взаимодействие дендритов -ого нейрона с аксонами -ого нейрона.
Стоит отметить, что  и случай %3D0) не рассматриваются.
Обучение и устойчивость к шуму
------------------------------
Обучение сети Хопфилда выходным образам  сводится к вычислению значений элементов матрицы . Формально можно описать процесс обучения следующим образом: пусть необходимо обучить нейронную сеть распознавать  образов, обозначенных . Входной образ  представляет собой:  где  — шум, наложенный на исходный образ .
Фактически, обучение нейронной сети — определение нормы в пространстве образов . Тогда, очистка входного образа от шума можно описать как минимизацию этого выражения.
Важной характеристикой нейронной сети является отношение числа ключевых образов , которые могут быть запомнены, к числу нейронов сети : . Для сети Хопфилда значение  не больше 0.14.
Вычисление квадратной матрицы размера для ключевых образов производится по правилу Хебба:
)![J_{i,j} = {1 \over N} \cdot \sum\limits_{\mu=1}^{M}\big[\zeta_{i,\mu}^{in} \cdot \zeta_{j,\mu}^{in} \big]}](https://tex.s2cms.ru/svg/J_%7Bi%2Cj%7D%20%3D%20%7B1%20%5Cover%20N%7D%20%5Ccdot%20%5Csum%5Climits_%7B%5Cmu%3D1%7D%5E%7BM%7D%5Cbig%5B%5Czeta_%7Bi%2C%5Cmu%7D%5E%7Bin%7D%20%5Ccdot%20%5Czeta_%7Bj%2C%5Cmu%7D%5E%7Bin%7D%20%5Cbig%5D%7D)
где  означает  -ый элемент образа .
Стоит отметить, что в силу коммутативности операции умножения, соблюдается равенство
Входной образ, который предъявляется для распознавания соответствует начальным данным для системы, служащий начальным условием для динамической системы (2):
)
Уравнений (1), (2), (3), (4) достаточно для определения искусственной нейронной сети Хопфилда и можно перейти к ее реализации.
Реализация нейронной сети Хопфилда
==================================
Реализация нейронной сети Хопфилда, определенной выше будет производиться на языке C++. Для упрощения экспериментов, добавим основные определения типов, напрямую связанных с видом нейрона и его передаточной функции в класс *simple\_neuron*, а производные определим далее.
Самыми основными типами, напрямую связанными с нейроном являются:
1. тип весовых коэффициентов (выбран *float*);
2. тип, описывающий состояния нейрона (введен перечислимый тип с 2 допустимыми значениями).
На основе этих типов можно ввести остальные базовые типы:
1. тип, описывающий состояние сети в момент  (выбран стандартный контейнер *vector*);
2. тип, описывающий матрицу весовых коэффициентов связей нейронов (выбран контейнер *vector* контейнеров *vector*).
**Листинг 1. Определение новых типов**
```
struct simple_neuron {
enum state {LOWER_STATE=-1, UPPER_STATE=1};
typedef float coeff_t; <<(1)
typedef state state_t; <<(2)
...
};
typedef simple_neuron neuron_t;
typedef neuron_t::state_t state_t;
typedef vector neurons\_line; <<(3)
typedef vector> link\_coeffs; <<(4)
```
Обучение сети, или, вычисление элементов матрицы  в соответствии с (3) производится функцией *learn\_neuro\_net*, принимающей на вход список обучающих образов и возвращающей объект типа *link\_coeffs\_t*. Значения  вычисляются только для нижнетреугольных элементов. Значения верхнетреугольных элементов вычисляются в соответствии с (4). Общий вид метода *learn\_neuro\_net* показан в листинге 2.
**Листинг 2. Обучение нейронной сети**
```
link_coeffs learn_neuro_net(const list &src\_images) {
link\_coeffs result\_coeffs;
size\_t neurons\_count = src\_images.front().size();
result\_coeffs.resize(neurons\_count);
for (size\_t i = 0; i < neurons\_count; ++i) {
result\_coeffs[i].resize(neurons\_count, 0);
}
for (size\_t i = 0; i < neurons\_count; ++i) {
for (size\_t j = 0; j < i; ++j) {
neuron\_t::coeff\_t val = 0;
val = std::accumulate(
begin(src\_images),
end(src\_images),
neuron\_t::coeff\_t(0.0),
[i, j] (neuron\_t::coeff\_t old\_val, const neurons\_line ℑ) -> neuron\_t::coeff\_t{
return old\_val + (image[i] \* image[j]);
});
result\_coeffs[i][j] = val;
result\_coeffs[j][i] = val;
}
}
return result\_coeffs;
}
```
Обновление состояний нейронов реализовано с помощью функтора *neuro\_net\_system*. Аргументом метода *\_do* функтора является начальное состояние ), являющееся распознаваемых образом (в соответствии с (5)) — ссылка на объект типа *neurons\_line*.
Метод функтора модифицирует передаваемый объект типа neurons\_line до состояния нейронной сети в момент времени . Значение жестко не фиксировано и определяется выражением:
)%3DS_%7Bi%7D(T))
т.е., когда состояние каждого нейрона не изменилось за 1 «такт».
Для вычисления (2) применены 2 алгоритма STL:
1. *std::inner\_product* для вычисления суммы произведений весовых коэффициентов и состояний нейронов (т.е. вычисление (2) для определенного );
2. *std::transform* для вычисления новых значений для каждого нейрона (т.е. вычисление пункта выше для каждого возможного )
Исходный код функтора *neurons\_net\_system* и метода *calculate* класса *simple\_neuron* показан в листинге 3.
**Листинг 3. Функтор, реализующий работу нейронной сети**
```
struct simple_neuron {
...
template
static state\_t calculate(\_Iv val\_b, \_Iv val\_e, \_Ic coeff\_b) {
auto value = std::inner\_product(
val\_b,
val\_e,
coeff\_b,
coeff\_t(0)
);
return value > 0 ? UPPER\_STATE : LOWER\_STATE;
}
};
struct neuro\_net\_system {
const link\_coeffs &\_coeffs;
neuro\_net\_system(const link\_coeffs &coeffs): \_coeffs(coeffs) {}
bool do\_step(neurons\_line& line) {
bool value\_changed = false;
neurons\_line old\_values(begin(line), end(line));
link\_coeffs::const\_iterator it\_coeffs = begin(\_coeffs);
std::transform(
begin(line),
end(line),
begin(line),
[&old\_values, \_coeffs, &value\_changed] (state\_t old\_value) -> state\_t {
auto new\_value = neuron\_t::calculate(
begin(old\_values),
end(old\_values),
begin(\*it\_coeffs++)
);
value\_changed = (new\_value != old\_value) || value\_changed;
return new\_value;
});
return value\_changed;
}
size\_t \_do(neurons\_line& line) {
bool need\_continue = true;
size\_t steps\_done = 0;
while (need\_continue) {
need\_continue = do\_step(line);
++steps\_done;
}
return steps\_done;
}
};
```
Для вывода в консоль входных и выходных образов создан тип *neurons\_line\_print\_descriptor*, который хранит ссылку на образ и формат форматирования (ширину и высоту прямоугольника, в который будет вписан образ). Для этого типа переопределен оператор *<<*. Исходный код типа *neurons\_line\_print\_descriptor* и оператора вывода в поток показан в листинге 4.
**Листинг 4. Вывод в поток состояния нейронной сети**
```
struct neurons_line_print_descriptor {
const neurons_line &_line;
const size_t _width;
const size_t _height;
neurons_line_print_descriptor (
const neurons_line &line,
size_t width,
size_t height
): _line(line),
_width(width),
_height(height)
{}
};
template
std::basic\_ostream&
operator << (std::basic\_ostream&stm, const neurons\_line\_print\_descriptor &line) {
neurons\_line::const\_iterator it = begin(line.\_line), it\_end = end(line.\_line);
for (size\_t i = 0; i < line.\_height; ++i) {
for (size\_t j = 0; j < line.\_width; ++j) {
stm << neuron\_t::write(\*it);
++it;
}
stm << endl;
}
return stm;
}
```
Пример работы нейронной сети
============================
Для проверки работоспособности реализации, нейронная сеть была обучена 2 ключевым образам:
Рис.3 Ключевые образы
На вход подавались искаженные образы. Нейронная сеть корректно распознала исходные образы. Искаженные образы и распознанные образы показаны на рис.4, 5
Рис.4 Распознавание образа 1
Рис.5 Распознавание образа 2
Запуск программы производится из командной строки строчкой вида: AppName WIDTH HEIGHT SOURCE\_FILE [LEARNE\_FILE\_N], где:
```
AppNaame - название исполняемого файла;
WIDTH, HEIGHT - ширина и высота прямоугольника, в который будут вписываться выходной и ключевые образы;
SOURCE_FILE - исходный файл с начальным образом;
[LEARNE_FILE_N] - один или несколько файлов с ключывыми образами (через пробел).
```
Исходный код выложен на GitHub -> <https://github.com/RainM/hopfield_neuro_net>
В репозитории проект CMake, из которого можно сгенерировать проект Visual Studio (VS2015 компилирует проект успешно) или обычные Unix Makefile’ы.
Использованная литература
1. Г.Г. Малинецкий. Математические основы синергетики. Москва, URSS, 2009.
2. Статья «Нейронная\_сеть\_Хопфилда» на Википедии. | https://habr.com/ru/post/301406/ | null | ru | null |
# Распознавание экомаркировок с использованием Azure Custom Vision из мобильного приложения
В этой статье я хочу рассказать об использовании сервиса Custom Vision, для распознавания фотографий экомаркировок из мобильного приложения.
Сервис CustomVision является частью облачного Cognitive Services на платформе Azure.
О том, какие технологии пришлось изучить, как работать с CustomVision, что он из себя представляет и что позволяет достичь — далее.
Задача распознавания экомаркировок появилась три года назад, когда мы с супругой стали обсуждать мобильное приложение, которое ее организация (НКО в сфере экологии) хотела сделать для распространения информации об экомаркировках.
### Что такое экомаркировка?
Экомаркировка – это сертификат и соответствующий логотип который выдают сертифицирующие организации, которые проверяют продукцию или услуги производителя-поставщика на соответствие определенным критериям связанным с жизненным циклом продукта-услуги и ориентированным на его экологичность. После сертификации производитель может размещать логотип экомаркировки на своей продукции.
Также к экомаркировкам можно отнести маркироку пластика по его составу для упрощения сорировки и переработки и другие подобные знаки.
Например, вот такой знак:
### Процесс выбора технологии распознавания
Двумя основными фичами приложения должны были стать поиск магазинов с экотоварами и распознавание экомаркировок. Если с поиском магазинов технологически все относительно просто, то с распознаванием не очень. Слово модное, но как его сделать было не понятно. И я начал изучать вопрос.
Логотипы маркировок стандартизированные и являются идеальными объектами для распознавания – навел телефон на изображение на упаковке товара, сфотографировал и приложение выдает, что за знак, что он обозначает и стоит-ли ему доверять.
Я начал думать как сделать распознавание и анализировать разные варианты – попробовал OpenCV с его алгоритмами распознавания (каскады Хаара, SWIFT, Template matching и т.д. ) но качество распознавания было не очень – не более 70% при объеме обучающего набора в несколько десятков изображений.
Возможно, я где-то что-то недопонял и сделал не так, но мы так-же попросили еще одного знакомого поисследовать эту тему и он тоже сказал что 70% на каскадах Хаара это максимум на таком датасете.
Параллельно с этим все чаще стали появляться материалы о различных фреймворках нейросетей и успешном использовании нейросетей для решения подобных задач. Но везде мелькали какие-то ужасающие размеры датасетов (сотни-тысячи изображений на каждый класс), незнакомые мне Python, TensorFlow, необходимость своего бэкенда — это все несколько пугало.
Как .NET разработчик я посмотрел на Accord.NET но тоже не нашел быстро чего-то такого, что сразу бы подошло.
В это время мы были заняты доделкой приложения и запуском в прод и я отложил разбирательства с распознаванием.
Где-то год назад мне попалась на глаза статья с описанием раннего preview Custom Vision от Microsoft – сервисе классификации изображений в облаке. Я его протестировал на 3х знаках и он мне понравился – понятный портал, где можно и обучать и тестировать классификатор не имея технических знаний, обучение сета из 100 изображений за 10-20 секунд, качество классификации выше 90% даже на 30 изображениях каждого знака – то что нужно.
Я поделился находкой с супругой и мы начали делать менее функциональную международную версию приложения, который не содержит информации о товарах и магазинах, но умеет распознавать экомаркировки.
Давайте перейдем к техническим деталям работающего приложения с распознаванием.
### Custom Vision
CV явлется частью Cognitive Services в Azure. Теперь его можно официально оформить, и он будет оплачивать с подписки Azure, хотя все еще числится в Preview.
Соответсвенно, как и любой другой продукт Azure, CognitiveServices отображаются и управляются на портале Azure.
CV предоставляет два REST API — один для тренировки (Training), другой – для распознавания (Prediction). Более детально я опишу взаимодействие с Prediction дальше
Кроме портала Azure и API пользователям CV доступен портал customvision.ai, где очень легко и наглядно можно загрузить изображения, расставить им метки, можно увидеть картинки и результаты распознаваний который проходили через API.
Порталом customvision.ai и API можно начать пользоваться без какой-либо привязки к Azure – для тестовых целей создается проект даже без Azure Subscription. Но если вы хотите сделать из своего тестового проекта в будущем продакшн проект, то лучше сделать это сразу, а то нам пришлось вручную копировать картинки из тестового проекта и заново размечать в продакшн.
Для того чтобы сделать проект в Azure, надо зарегистрироваться там и создать подписку. Это относительно легко, проблемы могут быть только с вводом и валидацией данных с банковской карты — иногда это случается.
После регистрации нужно создать инстанс ComputerVision через портал Azure
После создания ресурсов в Azure, они станут доступны в customvision.ai
На портале customvision.ai вы можете загрузить изображения и разметить их тегами – на одно изображение может быть несколько тегов, но без выделения областей. То есть изображение принадлежит нескольким классам, но на данном этапе развития сервиса нельзя выделить конкретный фрагмент на изображении и приписать его к классу.
После разметки нужно запустить тренировку, нажав кнопку Train – тренировка модели из 70 тегов и 3 тыс. изображений длится порядка 30 секунд.
Результаты тренировки сохраняются в сущности Iteration. Фактически через Iteration реализуется версионность.
Каждую Iteration можно использовать независимо – то есть можно создать Iteration, протестировать результат и удалить ее в случае, если не подходит или перевести в дефолтное и заменить текущее дефолтное Iteration и тогда все распознавания от приложений будут приходить в модель из этой Iteration.
Качество модели отображается в виде Precision и Recall (подробнее [тут](http://bazhenov.me/blog/2012/07/21/classification-performance-evaluation.html)) как для всех классов сразу, так и по отдельности.
Вот так выглядит проект с уже загруженными и прошедшими через обучение изображениями.
На портале можно запустить распознавание изображения с диска или по URL с помощью Quick Test и провести тестирование распознавания по одному изображению.
На закладке Predictions можно посмотреть результаты всех последних распознаваний – проценты принадлежности к тегам отображаются прям на картинке.
Возможность увидеть все результаты распознаваний и добавить их в обучающую выборку буквально парой кликов мышкой очень помогает – этим может заниматься кто угодно, без каких-либо знаний в AI или программировании.
### Использование API
Custom Vision Service обладает очень простым и интуитивно понятным REST API для обучения и распознавания.
В нашем приложении используется только API распознавания и я расскажу о его использовании
Url для распознавания вот такого вида:
[https://southcentralus.api.cognitive.microsoft.com/customvision/v2.0/Prediction/{Your](https://southcentralus.api.cognitive.microsoft.com/customvision/v2.0/Prediction/%7BYour) project GUID}/image
где
**southcentralus\*\*** – наименование Azure региона, где находится сервис. Пока сервис доступен только в South Central US регионе. Это не означает, что только там его можно использовать! Просто он там живет – использовать можно откуда угодно, где есть Интернет.
**{Your project GUID}\*\*** — идентификатор вашего проекта. Его можно посмотреть на портале customvision.ai
Для распознавания необходимо отослать изображение через POST. Так-же можно отослать публично доступный url изображения и сервис скачает его самостоятельно.
Дополнительно нужно в Headers добавить header "Prediction-Key” в который передать один из Access Key которые будут выданы при регистрации – они доступны как на портале customvision.ai так и на портале Azure.
Результат содержит следующее поле:
```
"Predictions":[
{"TagId":"35ac2ad0-e3ef-4e60-b81f-052a1057a1ca","Tag":"dog","Probability":0.102716163},
{"TagId":"28e1a872-3776-434c-8cf0-b612dd1a953c","Tag":"cat","Probability":0.02037274}
]
```
Где Probability указывает на вероятность того что изображение принадлежит указанному тегу (классу).
В С# это выглядит вот так
```
var client = new HttpClient();
client.DefaultRequestHeaders.Add("Prediction-Key", "{Acess key}");
string url = "https://southcentralus.api.cognitive.microsoft.com/customvision/v2.0/Prediction/{Your project GUID}/image";
HttpResponseMessage response;
List recognitions = new List();
using (var content = new ByteArrayContent(imageBytes))
{
content.Headers.ContentType = new MediaTypeHeaderValue
("application/octet-stream");
response = await client.PostAsync(url, content);
if (response.IsSuccessStatusCode)
{
string strRes = await response.Content.ReadAsStringAsync();
dynamic res = (dynamic) JsonConvert.DeserializeObject(strRes);
foreach (var pr in res.predictions)
{
recognitions.Add(
new RecognitionResult()
{ Tag = pr.tagName, RecognPercent = pr.probability });
}
}
else
{
Debug.WriteLine(
"Non successful response. " + response.ToString());
}
}
```
Как можно увидеть – абсолютно ничего сложного. Вся магия происходит на стороне сервиса.
### Приложение и некоторые подобранные параметры.
Приложение достаточно простое и состоит из списка Экомаркировок, информации о том что-такое экомаркировки, как они подразделяются и самого сканера.
Основная часть написана на Xamarin.Forms, но окно сканера работает с камерой и его пришлось делать как renders и реализовывать для каждой платформы отдельно
Уровень, когда приложение решает, что экомаркировка распознана точно >= 90% при этом почти все изображения распознаются если они более-менее приемлемого качества и нет других знаков на картинке.
Данное число было выведено эмпирически – мы начали с 80, но поняли что 90 снижает ложно-положительные срабатывания. А их случается достаточно много – многие маркировки похожи и содержат похожие элементы и цветовая гамма смещена к зеленому цвету.
Например вот это не самое качественное изображение распознается верно с точностью 91%
B при этом данный класс был обучен на 45 изображениях.
Надеюсь, статья была полезна и позволит заинтересованным читателям взглянуть на новые AI и ML инструменты. | https://habr.com/ru/post/424379/ | null | ru | null |
# Выходим за пределы JVM. Объясняем на крестиках-ноликах чем хорош Kotlin Multiplatform
Какой есть общий недостаток у мобильной, front-end и back-end разработки и иногда распила микросервисов? Дублирование логики. Очень часто я видел статьи или новости, где одна команда мобильных разработчиков ждет другую, чтобы выкатить релиз. И если с мобильными версиями более-менее все понятно и есть решения, то что делать с браузером? Очень часто логику работы приложения нужно поддержать и там.
Что делать, если хочется писать нативный код и при этом не иметь дублей реализации — на этот вопрос я постараюсь ответить подробно в данной статье. В процессе чтения можно будет познакомиться с технологией Kotlin Multiplatform и создать полноценный проект всем известной игры «Крестики-нолики» на трех самых популярных платформах Browser (JS), iOS (Swift) и Android (Java) с общей логикой на Kotlin.
### Содержание
* [Об авторе](#about)
* [Почему именно Kotlin Multiplatform](#why-kotlin)
* [Практика](#practice)
+ [Создание проекта](#create-project)
- [Окружение](#environment)
- [Создание проекта](#create-project-more)
- [Настройка сборки](#build-settings)
* [Написание кода](#write-code)
+ [Проектирование](#design)
+ [Реализация SDK](#sdk)
+ [Реализация использования SDK на платформах](#sdk-implements)
- [Реализация на JS](#js-implement)
- [Реализация на Swift](#swift-implement)
- [Реализация на Java](#java-implement)
* [Итог](#result)
### Об авторе
Для начала представлюсь и расскажу про некоторый мой опыт работы с технологией, о которой пишу. Меня зовут Устинов Тихон и я работаю в [Ростелеком ИТ](https://rtkit.ru/), а если быть точнее — на проекте «Интеграция [ЕПК](https://rtkit.ru/products/edinii-produktovii-katalog) (Единого продуктового каталога)».
С помощью этой core-системы в прошлом году Ростелеком запустил гибкие пакеты услуг. Для этого мы разработали SDK, который обрабатывает всю бизнес-логику: от конфигурирования до просчета цены.
Скриншот ниже — это пример того, как одна из витрин отображает работу этого SDK.
С работой SDK вы можете столкнуться в личном кабинете на сайте, в мобильном приложении или в офисе продаж, где человек, который будет настраивать вам что-либо, будет делать это средствами SDK.
### Почему именно Kotlin Multiplatform
Перед тем, как выбрать Kotlin Multiplatform, мы рассматривали все возможные варианты, позволяющие решить проблему запуска одного кода и в браузере, и на смартфонах. Возможность запуска кода на сервере оказалась итоговым приятным бонусом.
Если рассматривать проблему, ограничиваясь мобильными устройствами и браузером, то первое, что приходит в голову — это React Native и Progressive Web Applications (PWA). Однако, мы уже имели некоторую базу нативных приложений, от которых не хотелось отказываться, и webview выглядел тоже не лучшим вариантом. По этой же причине мы отмели идею писать на flutter, который помимо запуска на ios и android дает возможность скомпилировать код в js. Наличие нативных приложений сократило наш выбор до двух вариантов:
a) C/C++ библиотека с подключением к нативным приложениям и к js как WebAssembly
b) неизвестный тогда Kotlin Multiplatform.
По итогу отсутствие специалистов по C/C++ сократило наши варианты до одного, но сразу скажу, что мы ни разу не пожалели о своем выборе. Несмотря на то, что при выборе технологии мы не учитывали возможность работы кода на серверной стороне, её не стоит игнорировать при принятии решений. При разработке API зачастую тоже может быть использован код, дублирующий некоторые алгоритмы или структуры данных для сериализации и десериализации, одинаковый на всех платформах.
Например, вы проверяете на фронте сайта проверку корректности ввода номера телефона, после чего отправляете запрос на API для создания учетной записи. Но при этом вы можете обратиться к API в обход фронта, и тогда API тоже должен проверить корректность этого номера.
Думаю, с историей о том, как и почему мы выбрали Kotlin Multiplatform всё более-менее понятно. Для тех, кто не знаком, расскажу о технологии и о том, какие плюсы мы выделили для себя при работе с этой ней.
Если своими словами, то [Kotlin Multiplatform](https://kotlinlang.org/docs/multiplatform.html) — это технология, которая принадлежит компании JetBrains, она позволяет писать общий код на Kotlin и компилировать его в нативное представление более чем на [10 платформ](https://kotlinlang.org/docs/multiplatform-dsl-reference.html#targets). Это означает, что после компиляции мы будем иметь для JVM \*.jar файл, для JS — \*.js модуль с возможностью создания \*.d.ts, и, простите за тавтологию, фреймворк типа \*.framework для Swift. Для некоторых других платформ так же могут быть созданы нативные для платформы артефакты.
Стоит отметить хорошую документацию проекта, и как пример, хочу привести оттуда иллюстрацию, которая хорошо показывает идеологию общего кода:
Если вы откроете официальную документацию, то сразу увидите сообщение о том, что проект находится в состоянии альфа-версии. Но учитывая, что наш проект уже год как работает на тысячах (если не миллионах) устройств, могу заверить, что проект полностью жизнеспособен, и все возможные возникающие проблемы решаемы.
В процессе работы мы выявили для себя такие очевидные и не очень плюсы:
* **Один код, одна модель.** Мы больше не имеем проблем с тем, что одна команда ждет другую, чтобы реализовать то же самое — это существенно уменьшает количество затрат на разработку и, соответственно, повышает скорость доведения хотелок бизнеса до конечного потребителя;
* **Одна команда.** Вынесение логики в единый SDK позволило выделить команду разработки, которая занимается его развитием. Имея одну общую доменную модель разработчики, аналитики и продуктовые менеджеры лучше понимают друг друга. Не стоит упускать из виду немаловажный bus factor, который будет значительно ниже у трёх разработчиков, разрабатывающих один проект на одном языке, чем аналогичный проект у 3 разработчиков на 3 проектах на 3 языках;
* **Статическая типизация.** Очень актуально для JS. Конечно есть TypeScript, но учитывая, что типизация просто работает из коробки, однозначно записываем это в плюс;
* **Тестирование.** Когда вы просто пишете код без возможности посмотреть результат без компиляции, вы рано или поздно начнете писать тесты. С помощью теста вы, как минимум, сможете быстро проверять корректность кода, плюс тест будет поднимать покрытие функционала и повышать надежность кода. Написав один тест, вы покрываете сразу все ваши целевые платформы, что также экономит ресурс тестировщиков;
* **Язык.** Кто бы что ни говорил, но лично для меня Kotlin — лучший язык для разработки. По мере погружения в него возникает ощущение, что язык создавался людьми для людей. Это очень важно, когда вы имеете сложную бизнес-логику вам важно написать понятный код, чтобы её [бизнес-логику] можно было легко читать, а не в каком-нибудь условном (без обид) Go: открываешь метод, видишь кучу примитивных операций, но не можешь без скролла понять, что они должны делать в совокупности.
К сожалению, у технологии имеются и минусы, такие как:
* **Потеря производительности.** Это больше актуально для JS платформы, так как при компиляции не всегда создается идеальный код, который создает некоторый overhead. Однако потери не такие значительные, чтобы отказываться от этого;
* **Экспертиза разработчиков.** Хоть разработчики и будут писать на одном языке, но вероятно иногда придется разбираться с задачами на стыке нескольких платформ. Соответственно, для хорошей команды необходимо знать помимо Kotlin средства разработки платформ, под которые они компилируют;
* **Ограничения.** Когда вы пишете общий код, он должен работать везде одинаково. То, что может одна платформа, но не может другая, будет недоступно. Например, в Kotlin есть метод runBlocking, который может работать в коде Kotlin, Java и Swift, но он не работает в коде JS, потому что, [цитирую](https://github.com/Kotlin/kotlinx.coroutines/issues/195#issuecomment-354458878): «не может быть разумно реализован в JS. Реализация, перенесенная на JS, имеет слишком много ограничений, чтобы быть полезной». Тем не менее большинство уникального для конкретной платформы функционала можно реализовать через механизм [ожидаемого и фактического объявления](https://kotlinlang.org/docs/multiplatform-connect-to-apis.html) (expect/actual классы) при необходимости.
Думаю, на этом этапе общее описание технологии дано. И теперь вы можете понять, стоит ли читать статью дальше, добавить в закладки, чтобы вернуться позже, или, может быть, вам не интересно, как это выглядит это на практике, и не стоит на это тратить время.
### Практика
Далее я постараюсь продемонстрировать, как на практике можно применить эту технологию. Для этого я написал ядро игры крестики-нолики и реализовал отображение на трех языках JS (Browser), Swift (iOS), Java (Android). Весь изложенный код будет доступен в GitHub репозитории по [ссылке](https://github.com/Tihon-Ustinov/tictactoe).
#### Создание проекта
**Окружение**
Для начала работы с Kotlin Multiplatform желательно проверить все необходимое окружение с помощью утилиты [KDoctor](https://github.com/Kotlin/kdoctor). После того как мы проверили, что всё есть, можно смело начинать делать проект. Для корректной работы результат проверки должен быть приблизительно таким.
Вы можете использовать любое удобное для вас окружение. Помните, что для разработки под iOS с использованием Kotlin Multiplatform нужен Command Line Tools (обычно ставится при установке xcode), а по политике Apple данный набор инструментов можно установить только на продукцию Apple. Можно попробовать поставить на Hackintosh, хотя, честно говоря, я не пробовал.
Скачать Command Line Tools можно с [официального сайта Apple для разработчиков](https://developer.apple.com/download/all/).
**Создание проекта**
Для создания проекта воспользуемся [Kotlin Multiplatform Wizard](https://terrakok.github.io/kmp-web-wizard/). Выбираем следующие параметры:
* Выбираем текущую стабильную версию Kotlin;
* Для целевых сборок выбираем **JVM**, **JS**, **iOS** (при желании остальные можно будет добавить позже);
* Тесты включаем — в данной статье я не буду писать тесты, так как проект является демонстрацией работы технологии. Но если вы создаете реальный проект по этой статье, то тесты вам точно пригодятся.
Должна получиться приблизительно такая конфигурация:
Далее скачиваем и разархивируем в вашу рабочую область, и открываем в вашей любимой IDE, но лучше использовать IntelliJ IDEA, так как в ней есть некоторые вспомогательные функции для работы с Kotlin Multiplatform. Например, при реализации [ожидаемого и фактического объявления](https://kotlinlang.org/docs/multiplatform-connect-to-apis.html) классов IntelliJ IDEA поможет вам сгенерировать эти классы.
Kotlin Multiplatform Wizard по умолчанию сразу создает файлы с примерами классов и тестов: Platform.kt, CommonTest, PlatformTest. Нам они не понадобятся, поэтому эти файлы сразу удалим. По итогу должна получиться вот такая структура проекта:
**Настройка сборки**
Далее необходимо настроить параметры сборки gradle для корректной компиляции под выбранные нами платформы. Для этого немножко изменим три файла.
В первом файле ***./settings.gradle.kts*** явно укажем версию kotlin multiplatform.
Код ./settings.gradle.kts
```
pluginManagement {
repositories {
google()
gradlePluginPortal()
mavenCentral()
}
// Укажем явно, так как в боле ранних версиях есть была ошибка при создании *d.ts компилятором IR
plugins {
kotlin("multiplatform") version "1.7.10"
}
}
rootProject.name = "tictactoe"
include(":core")
```
Во втором — укажем версию и группу для того, чтобы после компиляции у нас были нормальные названия и версии соответственно
Код ./gradle.properties
```
# Добавляем группу и версию остальное оставляем без изменений
group=ru.tikhon.tictactoe
version=1.0.0
# Остальное можно оставить так как есть
#Gradle
org.gradle.jvmargs=-Xmx2048M -Dkotlin.daemon.jvm.options\="-Xmx2048M"
#Kotlin
kotlin.code.style=official
#MPP
kotlin.mpp.enableCInteropCommonization=true
```
B третьем файле ***./core/build.gradle.kts*** настроим параметры сборки для конкретных платформ.
Для jvm указываем версию java, с которой должен быть совместим полученный на выходе \*.jar-файл. Можно поставить и выше, это зависит от того где вы собираетесь подключать этот \*.jar-файл.
Для js ставим тип компилятора IR. IR нужен для того, чтобы после компиляции мы получили \*.d.ts, который необходим для поддержки типизации TypeScript. Он также нужен для того, чтобы ide проиндексировала его, и при написании кода вы могли импортировать классы автоматически средствами ide.
Укажем название фреймворка для iOS сборок, остальное оставляем без изменений.
Код ./core/build.gradle.kts
```
plugins {
kotlin("multiplatform")
}
kotlin {
/* JVM Target Configuration */
jvm {
compilations.all {
kotlinOptions.jvmTarget = "1.8"
}
withJava()
}
/* JS Target Configuration */
js(IR) {
binaries.executable()
browser()
}
/* iOS Target Configuration */
iosX64 {
binaries {
framework {
baseName = "GAMEFramework"
}
}
}
iosArm64 {
binaries {
framework {
baseName = "GAMEFramework"
}
}
}
iosSimulatorArm64 {
binaries {
framework {
baseName = "GAMEFramework"
}
}
}
sourceSets {
/* Main source sets */
val commonMain by getting
val jvmMain by getting
val jsMain by getting
val iosMain by creating
val iosX64Main by getting
val iosArm64Main by getting
val iosSimulatorArm64Main by getting
/* Main hierarchy */
jvmMain.dependsOn(commonMain)
jsMain.dependsOn(commonMain)
iosMain.dependsOn(commonMain)
iosX64Main.dependsOn(iosMain)
iosArm64Main.dependsOn(iosMain)
iosSimulatorArm64Main.dependsOn(iosMain)
/* Test source sets */
val commonTest by getting {
dependencies {
implementation(kotlin("test"))
}
}
val jvmTest by getting
val jsTest by getting
val iosTest by creating
val iosX64Test by getting
val iosArm64Test by getting
val iosSimulatorArm64Test by getting
/* Test hierarchy */
jvmTest.dependsOn(commonTest)
jsTest.dependsOn(commonTest)
iosTest.dependsOn(commonTest)
iosX64Test.dependsOn(iosTest)
iosArm64Test.dependsOn(iosTest)
iosSimulatorArm64Test.dependsOn(iosTest)
}
}
```
### Написание кода
Если вас не интересует разработка ядра игры, вы можете написать простой класс с выводом сообщения по пути *core/src/commonMain/kotlin/org/rubicon/game/SayHello.kt* с таким содержанием…
```
package org.rubicon.game
import kotlin.js.JsExport
@JsExport
class SayHello {
fun say() {
println("Hello from Kotlin Multiplatform")
}
}
```
…и перейти непосредственно к пункту «[Реализация использования SDK на платформах](#sdk-implements)», где описано, как скомпилировать код и добавить полученный в результате компиляции артефакт в нативные проекты платформ, которые мы ранее выбрали.
Либо вы можете рассмотреть пример реализации игры и заодно познакомиться с примерами взаимодействия SDK с платформами и некоторыми особенностями написания общего кода.
#### Проектирование
Для работы мультиплатформенности наш код должен удовлетворять следующим характеристикам:
* Должен быть полный набор классов необходимый для реализации игры;
* Этот набор классов не должен зависеть от какой-либо платформы.
Логика работы должна быть приблизительно такая:
1. Пользователь кликает кнопку «Играть»;
2. View создает экземпляр игры;
3. Подписывается на изменения игры;
4. Запускает игру;
5. Обновляет представление;
6. Начинается игра.
#### Реализация SDK
Все готово к написанию кода, можно приступать. В основном код будет создаваться в **commonMain** и там же будут располагаться классы, которые потом будут использоваться на платформах, где будет запускаться наша игра.
Далее вы увидите много кода, я не хотел весь его дублировать в статью и думал сделать проект, где меньше кода, но проект с условным hello world не показал бы кейса реального использования. Поэтому кто не хочет листать портянку лучше проследуйте на github в проект [tictactoe](https://github.com/Tihon-Ustinov/tictactoe).
По задуманной логике обновление представления должно происходить по событию, а это значит нужно создать класс, который будет уметь принимать слушателей и кидать события, назовем такой класс **EventEmitter,** а его интерфейс **IEventEmitter**.
События в нашей модели должны нести некоторую информацию. Например, если View подпишется на изменение состояния поля, то при срабатывании подписки оно должно знать где именно был поставлен крестик или нолик. Поэтому сначала объявим **IEvent** и реализуем его имплементацию **Event**.
interface core/src/commonMain/kotlin/org/rubicon/game/IEvent.kt
```
package org.rubicon.game
import kotlin.js.JsExport
/**
* Событие, которое получит пользователь при срабатывании подписки
* @property type Тип события
* @property source Источник события
*/
@JsExport
interface IEvent, S> {
val type: T
val source: S
/\*\*
\* Данный метод при деструктуризации вернет тип события
\* \*/
operator fun component1(): T = this.type
/\*\*
\* Данный метод при деструктуризации вернет источник события
\* \*/
operator fun component2(): S = this.source
}
```
В данном листинге кода мы можем наблюдать аннотацию **[@Throws](/users/Throws)[@JvmOverloads](/users/JvmOverloads)[@JsName](/users/JsName)[@JsExport](/users/JsExport)** — она нужна за тем, чтобы сущность, для которой указывается эта аннотация, была доступна на JS, и названия методов сохранялись. Так же наиболее часто можно встретить аннотацию **[@Throws](/users/Throws)[@JvmOverloads](/users/JvmOverloads)[@JsName](/users/JsName)**. Она нужна для указания наименования в случаях, когда оно не может произойти автоматически — в JS нет перегрузки, поэтому для перегружаемых методов нужно давать разные названия.
Также нередко можно заметить аннотацию **[@Throws](/users/Throws)[@JvmOverloads](/users/JvmOverloads)**, которая позволяет реализовать аргументы по умолчанию посредством перегрузки в Java. Плюс в приведенных ниже листингах кода можно встретить аннотацию **[@Throws](/users/Throws)** — она добавляет в целевую сборку информацию о том, что метод может быть завершен с ошибкой и стоит обработать исключение.
class core/src/commonMain/kotlin/org/rubicon/game/impl/events/Event.kt
```
package org.rubicon.game.impl.events
import org.rubicon.game.IEvent
import kotlin.js.JsExport
@JsExport
open class Event, S>(
override val type: T,
override val source: S
) : IEvent
```
После реализации события мы можем перейти к объявлению **IEventEmitter** и его реализации **EventEmitter**. Для более стандартизированной работы с данными объявим у **IEventEmitter** два обобщенных типа:
* T — это тип события, который может быть только перечисляемым типом;
* S — это источник события.
Interface ./core/src/commonMain/kotlin/org/rubicon/game/IEventEmitter.kt
```
package org.rubicon.game
import kotlin.js.JsExport
@JsExport
class DuplicateListenersException(override val message: String) : Throwable(message)
/**
* Тип подписки
* данная функция обратного вызова должна принимать на вход событие
* с которым она и будет работать
* */
typealias EventCallBack = (IEvent) -> Unit
/\*\*
\* Создает возможность подписываться на события объекта
\* \*/
@JsExport
interface IEventEmitter, S> {
/\*\*
\* Создать подписку
\* \*/
@Throws(DuplicateListenersException::class)
fun on(eventType: T, callBack: EventCallBack)
/\*\*
\* Удалить подписку
\* \*/
fun del(eventType: T, callBack: EventCallBack)
/\*\*
\* Создать подписку, которая будет удалена после срабатывания события
\* \*/
fun once(eventType: T, callBack: EventCallBack)
}
```
Class core/src/commonMain/kotlin/org/rubicon/game/impl/events/EventEmitter.kt
```
package org.rubicon.game.impl.events
import org.rubicon.game.DuplicateListenersException
import org.rubicon.game.EventCallBack
import org.rubicon.game.IEvent
import org.rubicon.game.IEventEmitter
import kotlin.js.JsExport
@JsExport
abstract class EventEmitter, S> : IEventEmitter {
private val listeners: LinkedHashMap>> = linkedMapOf()
override fun on(eventType: T, callBack: EventCallBack) {
val eventTypeCollection = listeners.getOrPut(eventType) {
arrayListOf()
}
if (callBack in eventTypeCollection) {
throw DuplicateListenersException("Данная подписка уже существует.")
}
eventTypeCollection.add(callBack)
}
override fun del(eventType: T, callBack: EventCallBack) {
listeners[eventType]?.remove(callBack)
}
override fun once(eventType: T, callBack: EventCallBack) {
this.on(eventType) {
this.del(eventType, callBack)
callBack(it)
}
}
protected fun emit(event: IEvent) {
listeners[event.type]?.forEach {
it(event)
}
}
}
```
Теперь простым наследованием мы можем научить любой класс кидать события, что позволяет нам перейти к созданию главного класса игры **Game**. Но для этого также нужно объявить типы событий, которые наш класс **Game** будет кидать.
Соответственно перечисляем события, которые могут возникнуть во время игры:
* GAME\_OVER — окончание игры. Будет кидаться в случаях, если какая-то сторона выиграла, или все доступные ходы закончились;
* CHANGE\_CELL — событие изменения состояния ячейки игрового поля (того квадрата, где рисуется крестик или нолик). Будет кидаться, когда в ячейку ставится крестик, нолик или сбросится состояние.
Enum core/src/commonMain/kotlin/org/rubicon/game/impl/events/GameEventType.kt
```
package org.rubicon.game.impl.events
import kotlin.js.JsExport
/**
* События, которые могут случиться во время игры
* */
@JsExport
enum class GameEventType {
/**
* Игра окончена
* */
GAME_OVER,
/**
* Изменилось состояние поля
* */
CHANGE_CELL
}
```
Теперь у нас есть достаточный набор классов и интерфейсов чтобы, чтобы объявить интерфейс **IGame** и указать методы, которые можно будет вызывать на стороне представления
Interface core/src/commonMain/kotlin/org/rubicon/game/IGame.kt
```
package org.rubicon.game
import org.rubicon.game.impl.events.GameEventType
import kotlin.js.JsExport
/**
* Игра
* Реализует главную логику игры кидает события по окончанию игры или при изменении состояния игрового поля
* */
@JsExport
interface IGame : IEventEmitter {
/\*\*
\* Запускает игру
\*
\* Кидает события об изменении каждой игровой ячейки для отрисовки поля
\* \*/
fun play()
/\*\*
\* Сбрасывает состояние игры
\* \*/
fun reset()
}
```
Но для непосредственной реализации самой имплементации **IGame** нам не хватает еще четырех сущностей:
1. **PlayerType** — перечисляемый класс, обозначающий игрока, крестик, нолик или его отсутствие.
Enum core/src/commonMain/kotlin/org/rubicon/game/impl/PlayerType.kt
```
package org.rubicon.game.impl
import kotlin.js.JsExport
/**
* Тип игрока
* */
@JsExport
enum class PlayerType {
/**
* Игрок отсутствует
* */
NONE,
/**
* Игрок, который играет крестиками
* */
CROSS,
/**
* Игрок, который играет ноликами
* */
ZERO
}
```
2. **IFieldCell** — ячейка игрового поля, которая будет отвечать за квадратик с крестиком или ноликом на игровом поле. Экземпляр реализации этого класса будет отдаваться представлению для отрисовки его состояния и для принятия клика.
Interface core/src/commonMain/kotlin/org/rubicon/game/IFieldCell.kt
```
package org.rubicon.game
import org.rubicon.game.impl.PlayerType
import kotlin.js.JsExport
/**
* Элемент игрового где должны отображаться крестики и нолики
* */
@JsExport
interface IFieldCell {
/**
* При клике меняется состояние кнопки на состояние активного игрока
* */
fun click()
/**
* Возвращает значение каким игроком было нажато
* */
fun getState(): PlayerType
/**
* Возвращает координату по оси X
* */
fun getX(): Int
/**
* Возвращает координату по оси Y
* */
fun getY(): Int
}
```
И, конечно же, реализуем имплементацию **FieldCell**.
Class core/src/commonMain/kotlin/org/rubicon/game/impl/FieldCell.kt
```
package org.rubicon.game.impl
import org.rubicon.game.IFieldCell
import org.rubicon.game.impl.events.Event
import org.rubicon.game.impl.events.EventEmitter
import kotlin.js.JsExport
@JsExport
enum class FieldCellEvents {
CLICK
}
@JsExport
class FieldCell(
private val x: Int,
private val y: Int,
private var state: PlayerType = PlayerType.NONE
) : EventEmitter(), IFieldCell {
/\*\*
\* Во время игры состояние может быть изменено либо сброшено
\* \*/
internal fun changeState(state: PlayerType) {
this.state = state
}
override fun click() {
// Мы кинем событие, что пользователь кликнул только если уже не кликнуто раньше
if (this.state == PlayerType.NONE) {
this.emit(Event(FieldCellEvents.CLICK, this))
}
}
override fun getState(): PlayerType = this.state
override fun getX(): Int = this.x
override fun getY(): Int = this.y
}
```
3. **GameCellEvent** — событие обозначающее изменения состояния ячейки игрового поля с указанием этой самой ячейки.
Class core/src/commonMain/kotlin/org/rubicon/game/impl/events/GameCellEvent.kt
```
package org.rubicon.game.impl.events
import org.rubicon.game.IGame
import org.rubicon.game.impl.FieldCell
import kotlin.js.JsExport
@JsExport
class GameCellEvent(
source: IGame,
// Ячейка игрового поля
val fieldCell: FieldCell
) : Event(GameEventType.CHANGE\_CELL, source)
```
4. **GameOverEvent** — событие, обозначающее окончание игры с информацией о победителе и выигрышной комбинации игровых ячеек.
Class core/src/commonMain/kotlin/org/rubicon/game/impl/events/GameOverEvent.kt
```
package org.rubicon.game.impl.events
import org.rubicon.game.IGame
import org.rubicon.game.impl.FieldCell
import org.rubicon.game.impl.PlayerType
import kotlin.js.JsExport
@JsExport
class GameOverEvent(
game: IGame,
winLine: List? = null
) : Event(GameEventType.GAME\_OVER, game) {
// Приводим к Array для того чтобы в JS этот метод вернул нативный массив
val winLine = winLine?.toTypedArray()
// Так как выигрышная конфигурация может быть только одной стороны мы можем получить победителя оттуда
val winner: PlayerType = winLine?.first()?.getState() ?: PlayerType.NONE
}
```
И последний, самый интересный класс в нашем SDK, но не последний в этой статье — это класс **Game**. Этот класс реализует основную логику игры, суть должна быть понятна всем, кто играл в крестики-нолики. У нас есть поле 3 x 3, выигрывает та сторона, которая поставит свои знаки в трёх клетках подряд.
Логика работы такая, что мы:
* создаем поле из ячеек;
* подписываемся на событие клика этих ячеек;
* при событии клика ставим им значение кто кликнул с уведомлением об этом;
* проверяем законченность игры;
* кидаем событие об окончании игры.
Class core/src/commonMain/kotlin/org/rubicon/game/impl/Game.kt
```
package org.rubicon.game.impl
import org.rubicon.game.IEvent
import org.rubicon.game.IGame
import org.rubicon.game.impl.events.EventEmitter
import org.rubicon.game.impl.events.GameCellEvent
import org.rubicon.game.impl.events.GameEventType
import org.rubicon.game.impl.events.GameOverEvent
import kotlin.js.JsExport
@JsExport
class Game : EventEmitter(), IGame {
// Сразу инициализируем поле 3 x 3 и подписываемся на событие клика
private val field: List> = List(3) { y ->
List(3) { x ->
FieldCell(x, y).also {
it.on(FieldCellEvents.CLICK, this::onClickFieldCell)
}
}
}
// Содержит информацию о том, кто в данный момент времени ходит
private var currentPlayer: PlayerType = PlayerType.CROSS
// Все возможные выигрышные позиции
private val winConditions: List> by lazy {
this.getAllWinConditions()
}
/\*\*
\* Обработчик события клика по ICell
\*
\* Проставляет ячейки кликнувшего игрока, переключает ход игрока и проверяет завершенность игры
\*
\* \*/
private fun onClickFieldCell(event: IEvent) {
if (this.currentPlayer != PlayerType.NONE) {
val fieldCell: FieldCell = event.source
this.changeFiledCellState(fieldCell, currentPlayer)
this.turnMove()
this.checkGameOver()
}
}
/\*\*
\* Меняет состояние ячейки и сообщает об этом событием
\* \*/
private fun changeFiledCellState(fieldCell: FieldCell, state: PlayerType) {
fieldCell.changeState(state)
this.emit(GameCellEvent(this, fieldCell))
}
/\*\*
\* Переключает текущего игрока на его противника или на сторону по умолчанию
\* \*/
private fun turnMove() {
this.currentPlayer = when (currentPlayer) {
PlayerType.CROSS -> PlayerType.ZERO
PlayerType.ZERO,
PlayerType.NONE -> PlayerType.CROSS
}
}
/\*\*
\* Проверяет статус окончания игры
\* \*/
private fun checkGameOver() {
val winLine = this.winConditions.find { this.isMatchLine(it) }
val event = when {
winLine != null -> GameOverEvent(this, winLine)
!hasFreeCells() -> GameOverEvent(this)
else -> null
}
if (event != null) {
this.currentPlayer = PlayerType.NONE
this.emit(event)
}
}
/\*\*
\* Проверяет наличие ячеек на которые еще не кликали
\* \*/
private fun hasFreeCells(): Boolean {
return this.field.any { row ->
row.any { it.getState() == PlayerType.NONE }
}
}
/\*\*
\* Проверяет что переданная комбинация ячеек выбрана одним игроком
\* \*/
private fun isMatchLine(row: List): Boolean {
if (row.isEmpty()) return false
val firstState = row.first().getState()
if (firstState == PlayerType.NONE) return false
return row.all { it.getState() == firstState }
}
/\*\*
\* Возвращает все возможные выигрышные комбинации
\* \*/
private fun getAllWinConditions(): List> {
val result: ArrayList> = arrayListOf()
val diagonal: ArrayList = arrayListOf()
val diagonalOpposite: ArrayList = arrayListOf()
for (i in 0..2) {
// Добавляем все строчки
result.add(
listOf(
this.field[i][0],
this.field[i][1],
this.field[i][2],
)
)
// Добавляем все колонки
result.add(
listOf(
this.field[0][i],
this.field[1][i],
this.field[2][i],
)
)
// Добавляем варианты по диагонали
diagonal.add(this.field[i][i])
diagonalOpposite.add(this.field[2 - i][i])
}
result.add(diagonal)
result.add(diagonalOpposite)
return result
}
/\*\*
\* Сбрасывает игру чтобы представление получило обновление состояний и отрисовало поле
\* \*/
override fun play() {
// Суть метода заключается в том чтобы отрисовать ячейки игрового поля
// Поэтому reset сюда подходит
this.reset()
}
/\*\*
\* Сбрасывает состояние ячеек на состояние ни кем не выбрано
\* \*/
override fun reset() {
this.currentPlayer = PlayerType.CROSS
for (y in 0 until this.field.size) {
for (x in 0 until this.field[y].size) {
this.changeFiledCellState(this.field[y][x], PlayerType.NONE)
}
}
}
}
```
Всё, SDK готов, а это значит, что мы можем начинать использовать его на всех платформах в которые может компилироваться Kotlin. Начнем с JS.
#### Реализация использования SDK на платформах
**Реализация на JS**
Чтобы получить итоговую сборку под платформу JS, нам нужно выполнить команду gradle **jsBrowserProductionWebpack**:
```
./gradlew jsBrowserProductionWebpack
```
После чего у вас должен появиться js-файл с названием модуля ***core/build/distributions/core.js***.
Или если вы хотите получить профит от типизации, то тогда нужно брать директорию по пути ***build/js/packages/tictactoe-core****,* которая по своей структуре является обычным npm пакетом c исходным кодом на JS, файлом package.json и \*.d.ts-файлом внутри.
Обе сборки будут содержать все написанные нами ранее классы только на js. Соответственно, мы можем добавить один из этих артефактов в любой js-проект. Что мы сейчас и сделаем.
Проект на js будет максимально простой — это одна **index.html** страница, к которой подключается собранный ранее SDK посредством добавления html-тега *script*. В этом же файле реализованы несложные стили игрового поля и процесс взаимодействия с SDK. Уверен, что можно было бы реализовать это красивее и чище, но это лишь демонстрация возможности работы с SDK, а не паттернов проектирования.
index.js
```
Tic Tac Toe
.field {
display: flex;
flex-wrap: wrap;
align-content: flex-start;
width: 900px;
height: 900px;
background-color: #e6e6e6;
border-radius: 10px;
padding: 10px 0 0 10px;
}
.field-cell {
color: black;
width: 290px;
height: 290px;
background-color: #a7c6c6;
margin: 0 10px 10px 0;
border-radius: 10px;
cursor: pointer;
}
#crossIcon, #circleIcon {
display: none;
}
/\*\*
\* Обращаемся к SDK и импортируем то что будем использовать для создания игры
\* \*/
const sdk = window.core.org.rubicon.game.impl
const {Game, PlayerType} = sdk
const {GameEventType} = sdk.events
// Иконки крестиков и ноликов которые будем выводить в ячейки
const crossSVG = document.getElementById("crossIcon").innerHTML;
const circleSymbol = document.getElementById("circleIcon").innerHTML;
// Сюда будем сохранять HTML кнопки
// чтобы при событии изменения состояния мы быстро нашли нашу кнопку
// и обновили представление
const buttonMap = new Map()
/\*\*
\* Обработчик события окончания игры
\*
\* Выводит результат на игры на страницу
\* \*/
function gameOver(event) {
// Достаем данные из события
const {winner, source} = event
const winnerText = document.createElement("H3")
// На основании типа игрока делаем сообщение о том кто выиграл
switch (winner) {
case PlayerType.NONE:
winnerText.innerText = "Ничья"
break
case PlayerType.CROSS:
winnerText.innerText = "Выиграли крестики"
break
case PlayerType.ZERO:
winnerText.innerText = "Выиграли нолики"
break
}
// Создаем кнопку для запуска игры сначала
const resultElement = document.getElementById("result")
const repeatButton = document.createElement("button")
repeatButton.innerText = "Играть еще раз"
repeatButton.addEventListener("click", () => {
source.reset()
resultElement.innerHTML = ""
})
// Выводи результат и кнопку
resultElement.appendChild(winnerText)
resultElement.appendChild(repeatButton)
}
/\*\*
\* Создает ячейку игрового поля создает подписку чтобы при клике по ui кнопке вызывался клик ячейки из SDK
\* \*/
function createUICell(hash, fieldCell) {
const htmlCell = document.createElement("div")
htmlCell.classList.add("field-cell")
htmlCell.addEventListener("mousedown", () => fieldCell.click())
document.getElementById("field").appendChild(htmlCell)
buttonMap.set(hash, htmlCell)
}
/\*\*
\* Обновляет состояние представления путем обработки изменения состояний ячеек
\* \*/
function updateView(event) {
// Получаем ячейку
const {fieldCell} = event
const cellHash = `${fieldCell.getY()}-${fieldCell.getX()}`
if (!buttonMap.has(cellHash)) {
// если ранее не обрабатывали данную ячейку создаем html кнопку для этой ячейки
createUICell(cellHash, fieldCell)
}
// Обновляем состояние html кнопки
const uiElement = buttonMap.get(cellHash)
switch (fieldCell.getState()) {
case PlayerType.NONE:
uiElement.innerHTML = ""
break
case PlayerType.CROSS:
uiElement.innerHTML = crossSVG
break
case PlayerType.ZERO:
uiElement.innerHTML = circleSymbol
break
}
}
/\*\*
\* Теперь просто создаем игру
\* \*/
const game = new Game()
/\*\*
\* Подписываемся на события
\* \*/
game.on(GameEventType.GAME\_OVER, gameOver)
game.on(GameEventType.CHANGE\_CELL, updateView)
/\*\*
\* И запускаем
\* \*/
game.play()
```
Вот так просто (с точки зрения потребителя SDK) мы интегрировали написанный на Kotlin код в JS и получили вот такой работающий результат.
Теперь сделаем то же самое для приложения под iOS.
**Реализация на Swift**
Как и для js нам нужно скомпилировать наш код на Kotlin в Framework, с которым будет дружить Xcode, прежде чем создавать приложение. Для этого нужно выполнить следующие команды:
```
./gradlew linkReleaseFrameworkIosArm64 linkReleaseFrameworkIosX64 &&
xcodebuild -create-xcframework
-framework ./core/build/bin/iosArm64/releaseFramework/GAMEFramework.framework
-framework ./core/build/bin/iosX64/releaseFramework/GAMEFramework.framework
-output ./core/build/bin/core.xcframework
```
Где `inkReleaseFrameworkIosArm64` и `linkReleaseFrameworkIosX64` — это команды компиляции кода под целевые архитектуры iOS, а `xcodebuild`— склейка полученных от первой команды *\*.framework* в один \**.xcframework*, который необходим нам для подключения его к проекту, чтобы получить возможность использовать классы написанные на kotlin в swift-приложении.
После того как получили .xcframework мы можем перейти к реализации приложения на swift. Для этого создадим простое iOS-приложение в Xcode.
Указываем название приложения, наименование организации и выбираем интерфейс SwiftUI.
После создания проекта нам необходимо добавить наш созданный ранее framework в этот проект. Для этого нужно выполнить следующие шаги:
1. Кликаем на название проекта, чтобы перейти к его настройкам;
2. Далее кликаем **+** в пункте **Frameworks, Libraries and Embedded content**. В открывшемся окне нажимаем **Add** **other** и выбираем созданную ранее папку ***./core/build/bin/core.xcframework***;
3. Если все было сделано правильно — наш framework появится в таблице.
После того как framework был успешно добавлен, мы можем импортировать его в swift коде. Название для импорта должно соответствовать baseName, который мы указали в ***./core/build.gradle.kts***. Далее нам осталось только написать код работы с SDK и отображением интерфейса, чтобы получить полноценное приложение под iOS. Для этого переходим в файл **ContentView**, который Xcode автоматически создал при создании проекта. Пишем в нём код:
ContentView.swift
```
import SwiftUI
// Импортируем наш SDK который мы написали на Kotlin
import GAMEFramework
// Создаем класс для работы с SDK и чтобы View обновляла данные смотря на него
class GameUI : ObservableObject {
// Переменные которые будут отображаться во view
@Published var isGameOver: Bool = false
@Published var isGameStarted: Bool = false
@Published var winnerName: String = ""
@Published var field: [[String]] = [
[" ", " ", " "],
[" ", " ", " "],
[" ", " ", " "]
]
// Игра
private let game: Game = Game()
// Ячейки поля
private var gameCells: [String: FieldCell] = [:]
// По нажатии кнопки играть вызывается этот метод
func start () {
do {
// Подписываемся на события обновления ячеек и окончания игры
try game.on(eventType: .changeCell, callBack: onChangeCell)
try game.on(eventType: .gameOver, callBack: onGameOver)
} catch {
print("Ошибка")
}
// Запускаем процесс игры
game.play()
isGameStarted = true
}
// Перезапуск игры
func playAgain() {
isGameOver = false
game.reset()
}
// view будет говорить какая кнопка была нажата,
// а этот метод будут уже вызывать соответствующий метод у ячеки поля из SDK
func clickButton(x: Int, y: Int) {
if (isGameOver || !isGameStarted) {
return
}
// Получаем FieldCell и вызываем у него click
gameCells[makeHash(x: x, y: y)]?.click()
}
// Обработчик событий изменения состояние ячейки игрового поля
private func onChangeCell(event: IEvent) {
// Получаем ячеку из события
let fieldCell = (event as! GameCellEvent).fieldCell
// Создаем хеш и сохраняем в мапу для более удобного поиска в дальнейшем
let hash = makeHash(x: Int(fieldCell.getX()), y: Int(fieldCell.getY()))
if (!gameCells.keys.contains(hash)) {
gameCells[hash] = fieldCell
}
// и обновляем состояние чтобы view обновлял ячейку которая изменилась
field[Int(fieldCell.getY())][Int(fieldCell.getX())] = stateToString(state: fieldCell.getState())
}
// Обработчик окончания игры
private func onGameOver(event: IEvent) {
// Ставим значения окончания игры чтобы игрок больше не мог кликать кнопки
isGameOver = true
// И записываем выигравшую сторону
switch ((event as! GameOverEvent).winner) {
case .zero:
winnerName = "O победили"
case .cross:
winnerName = "X победили"
default:
winnerName = "Ничья"
}
}
// Преобразуем состояние ячеки в строку которая будет выводиться в кнопке
private func stateToString(state: PlayerType) -> String {
switch state {
case .cross:
return "X"
case .zero:
return "O"
default:
return " "
}
}
private func makeHash(x: Int, y: Int) -> String {
return String(x) + "-" + String(y)
}
}
// Реализуем отображение
struct ContentView: View {
@ObservedObject var gameUI = GameUI()
var body: some View {
VStack(alignment: .center) {
// Блок ячеек игрового поля, выводим циклом в цикле поле 3 х 3
ForEach((0...2), id: \.self) { y in
HStack(spacing: 5) {
Group {
ForEach((0...2), id: \.self) { x in
Button(action: { gameUI.clickButton(x: x, y: y) }) {
// Отрисовываем состояние соответсвующее ячейки
Text(gameUI.field[y][x])
}
}
}
// Устанавливаем свойства отображения которое будет применено для всех кнопок
.frame(maxWidth:.infinity)
.padding()
.foregroundColor(Color.black)
.font(.system(size: 64, weight: .bold, design: .default))
.background(Color(red: 0.654, green: 0.654, blue: 0.776))
.cornerRadius(5)
}
}.opacity(gameUI.isGameStarted ? 1 : 0)
// Вывод результата игры с кнопкой перезапуска игры
Group {
Text(gameUI.winnerName)
Button("again", action: gameUI.playAgain)
}.opacity(gameUI.isGameOver ? 1 : 0)
// Кнопка запуска игры
Button("play", action: gameUI.start)
.font(.system(size: 32, weight: .bold, design: .default))
.opacity(gameUI.isGameStarted ? 0 : 1)
}
}
}
struct ContentView_Previews: PreviewProvider {
static var previews: some View {
ContentView()
}
}
```
Наверное, не стоило пихать всё в один файл: в реальной разработке нужно было бы это все разделить в соответствии с паттернами проектирования. Но сегодня мы смотрим демо, поэтому проект можно оставить как есть. В любом случае это работает и после запуска мы можем наблюдать такой результат:
**Реализация на Java**
Несложными махинациями мы уже получили реализации на js и swift, и сейчас сделаем последнюю в этой статье, но не последнюю из возможных, реализацию. Речь пойдет о мобильном приложении под Android, и по-хорошему нужно использовать Kotlin для разработки мобильных приложений под Android, как [объявил Google](https://developer.android.com/kotlin/first) в 2019 году, но мы напишем его на Java, чтобы продемонстрировать работоспособность нашего SDK c java.
Несложно догадаться, что для JVM проекта нам нужен .jar-файл, который мы могли бы подключить в проект. Чтобы его получить выполняем команду:
```
./gradlew jvmJar
```
После этого в папке ***core/libs*** будет файл ***core-jvm-1.0.0.jar***, который нужно будет в дальнейшем подключить в приложение. В ваших проектах название конечного файла может отличаться, но файл всегда будет содержать приставку «jvm».
Делать приложение под Android будем конечно же в Android Studio. При создании нового проекта выбираем создать **Empty** **Activity**:
Заполняем все необходимые данные, и выбираем язык Java.
Один из способов добавления зависимостей — напрямую записать эту зависимость в ***build.gradle***. В формате отображения как Android-проект нужный нам файл будет находиться в разделе ***Gradle Script*** → ***build.gradle (Module: TicTacToe.app)***.
Открываем этот файл и добавляем в него две зависимости в раздел dependencies. Зависимость на `kotlin-stdlib` необходима для того, чтобы мы из java подписывались на события. При компиляции kotlin лямбда функции превращается в интерфейс (в нашем случае это интерфейс `Function1`), поэтому нам необходимо создать экземпляр реализации этого интерфейса. Без `kotlin-stdlib` этот интерфейс будет недоступен, и, следовательно, подписаться мы не сможем, а без подписки наша игра работать не будет.
Если нет возможности добавить зависимость на `kotlin-stdlib`, то при реализации `IEventEmitter`стоит принимать не лямбду, а интерфейс, который будет реализован на каждой платформе.
build.gradle (Module: TicTacToe.app)
```
plugins {
id 'com.android.application'
}
android {
compileSdk 32
defaultConfig {
applicationId "com.example.tictactoe"
minSdk 29
targetSdk 32
versionCode 1
versionName "1.0"
testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
}
}
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
}
dependencies {
// Добавляем зависимость на наш SDK
implementation files('../../../core/build/libs/core-jvm-1.0.0.jar')
// Добавляем зависимость для совместимости Kotlin лямбд
implementation 'org.jetbrains.kotlin:kotlin-stdlib:1.7.10'
implementation 'androidx.appcompat:appcompat:1.3.0'
implementation 'com.google.android.material:material:1.4.0'
implementation 'androidx.constraintlayout:constraintlayout:2.0.4'
implementation files('../core/build/libs/')
testImplementation 'junit:junit:4.13.2'
androidTestImplementation 'androidx.test.ext:junit:1.1.3'
androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
}
```
Средствами ide или командой gradle обновляем зависимости, чтобы при написании кода ide понимала класс, которые находятся в наших зависимостях:
```
gradle --refresh-dependencies
```
Далее накидываем простой интерфейс с кнопками «играть», «перезапуск» и текстовым полем для вывода сообщений. Кнопки игрового поля создадим динамически:
Layout activity\_main.xml
```
xml version="1.0" encoding="utf-8"?
```
Далее мы создаем простую реализацию на Java, суть которой заключается в том же, в чем и на предыдущих платформах — создать мост между представлением и SDK. Если чуть подробнее, то данный класс реализует следующие функции:
* Создание поля из кнопок. Передача события клика по кнопкам соответствующей ячейке в SDK.
* Подписка на события SDK. Обновление представления в соответствии с этими событиями.
Class MainActivity.java
```
package com.example.tictactoe;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.util.TypedValue;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.TextView;
import org.rubicon.game.impl.FieldCell;
import org.rubicon.game.impl.Game;
import org.rubicon.game.impl.events.GameCellEvent;
import org.rubicon.game.impl.events.GameEventType;
import org.rubicon.game.impl.events.GameOverEvent;
import java.util.LinkedHashMap;
import kotlin.Unit;
import kotlin.jvm.functions.Function1;
public class MainActivity extends AppCompatActivity {
// Сразу создаем экземпляр игры при создании объекта
final private Game game = new Game();
// Здесь сохраним кнопки чтобы было удобнее к ним обращаться и менять значение
final private LinkedHashMap uiButtons = new LinkedHashMap<>();
// Точка входа в View
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity\_main);
// Создаем поле
this.createButtons();
// По клику запуска подписываемся на события игры и запускаем игру
final Button buttonPlay = findViewById(R.id.buttonPlay);
buttonPlay.setOnClickListener(v -> {
game.on(GameEventType.GAME\_OVER, onGameOver);
game.on(GameEventType.CHANGE\_CELL, onGameCellChange);
game.play();
buttonPlay.setVisibility(View.INVISIBLE);
findViewById(R.id.fieldLinearLayout).setVisibility(View.VISIBLE);
});
// По клику кнопки играть опять перезапускаем игру
final Button buttonPlayAgain = findViewById(R.id.buttonPlayAgain);
buttonPlayAgain.setOnClickListener(v -> {
findViewById(R.id.textWinner).setVisibility(View.INVISIBLE);
game.reset();
buttonPlayAgain.setVisibility(View.INVISIBLE);
});
}
// Подписка на окончание игры
private final Function1 onGameOver = o -> {
// Получаем информацию о победителе
final GameOverEvent event = (GameOverEvent) o;
String winnerMessage = "";
switch (event.getWinner()) {
case NONE:
winnerMessage = "Ничья";
break;
case ZERO:
winnerMessage = "Выиграли O";
break;
case CROSS:
winnerMessage = "Выиграли X";
break;
}
// Отображаем на экране
final TextView textView = findViewById(R.id.textWinner);
textView.setText(winnerMessage);
textView.setVisibility(View.VISIBLE);
findViewById(R.id.buttonPlayAgain).setVisibility(View.VISIBLE);
return Unit.INSTANCE;
};
// Подписка на изменение состояния ячейки игрового поля
private final Function1 onGameCellChange = o -> {
// Получаем информацию о ячейке
final GameCellEvent event = (GameCellEvent) o;
final FieldCell fieldCell = event.getFieldCell();
final String hash = makeHash(fieldCell.getX(), fieldCell.getY());
// Далее обновляем соответсвующую кнопку
final Button uiButton = this.uiButtons.get(hash);
if (uiButton == null) {
return Unit.INSTANCE;
}
if (!uiButton.hasOnClickListeners()) {
uiButton.setOnClickListener(view -> {
fieldCell.click();
});
}
switch (event.getFieldCell().getState()) {
case NONE:
uiButton.setText("");
break;
case ZERO:
uiButton.setText("O");
break;
case CROSS:
uiButton.setText("X");
break;
}
return Unit.INSTANCE;
};
@NonNull
private String makeHash(int x, int y) {
return String.format("%s-%s", x, y);
}
// Создаем игровое поле
private void createButtons() {
final LinearLayout rowLayout = findViewById(R.id.fieldLinearLayout);
for (int y = 0; y < 3; y++) {
final LinearLayout row = new LinearLayout(this);
for (int x = 0; x < 3; x++) {
final Button button = new Button(this);
button.setTextSize(TypedValue.COMPLEX\_UNIT\_SP, 64);
row.addView(button, new LinearLayout.LayoutParams(
ViewGroup.LayoutParams.WRAP\_CONTENT,
ViewGroup.LayoutParams.WRAP\_CONTENT,
1.0f
));
// Сохраняем ссылку на кнопку для более простого поиска в дальнейшем
uiButtons.put(makeHash(x, y), button);
}
rowLayout.addView(row, new LinearLayout.LayoutParams(
ViewGroup.LayoutParams.MATCH\_PARENT,
ViewGroup.LayoutParams.WRAP\_CONTENT
));
}
}
}
```
Запускаем наше приложение. Проверяем. Все работает.
### Итог
Мы реализовали три приложения с единой бизнес-логикой. При желании внести какие-то изменения в логику мы с легкостью это сможем сделать в общем коде. Все, что нам нужно будет сделать в самих приложениях, чтобы изменения появились — это просто обновить версию SDK и пересобрать. А если мы захотим реализовать еще одно приложение под какую-то платформу из перечисленных на [сайте](https://kotlinlang.org/docs/multiplatform-dsl-reference.html#targets), нам будет достаточно добавить параметры сборки под нужную нам платформу и реализовать представление на ней.
Общую логику можно вынести из практически любых приложений, реализованных на нескольких платформах: от доставки суши до социальной сети. Даже если у вас идеальный API, то все равно вы получите некоторый условный класс User, у которого должны быть некоторые характеристики и методы взаимодействия с другими классами. Плюс будет актуален вынос логики для проектов со сложной бизнес-логикой, которая считается на клиенте.
Надеюсь, я достаточно ввел вас в курс дела по Kotlin Multiplatform, и, прочтя эту статью + посмотрев пример работы, вы поймете, нужна ли вам эта технология или нет на вашем проекте.
P.S. Если остаются какие-то вопросы — пишите в комментарии, постараюсь ответить. | https://habr.com/ru/post/682160/ | null | ru | null |
# Как переехать с GKE на Deckhouse, чтобы разработчики этого даже не заметили. Кейс robota.ua
[Robota.ua](http://Robota.ua) — сервис для поиска вакансий и сотрудников в Украине. Включает в себя веб-сайт со средней посещаемостью [7 млн визитов в месяц](https://www.similarweb.com/site/rabota.ua/#traffic) и приложения для iOS и Android. Мы помогаем robota.ua поддерживать кластеры Kubernetes.
Кейс интересен тем, что за короткое время клиенту удалось бесшовно переехать с Google Kubernetes Engine (GKE) на другой managed-сервис. Расскажем о ключевых этапах проекта, немного об экономике и о том, какие возможности для развития и кастомизации инфраструктуры появились у robota.ua\*.
\* ПримечаниеЭто не технический, а бизнес-кейс. Упоминаемые технические детали помогают увидеть общую картину с точки зрения бизнеса.
Технологический стек
--------------------
Robota.ua используют в основном Open Source-решения. Для разработки большей части сервисов — .NET; в качестве хранилищ — реляционные и документные БД (в зависимости от решаемой задачи). Общение между сервисами обеспечивает Kafka, а доступ к ним организован через федеративный GraphQL. Фронтенд написан на Angular и размещается в большом монорепозитории.
Инфраструктура до перезда
-------------------------
До лета 2021 года основная часть инфраструктуры robota.ua размещалась в европейском дата-центре Google. Старые части системы — на собственных серверах в Украине. Большинство сервисов запускалось в GKE.
Почему использовался именно managed-сервис?
У ИТ-команды robota.ua не было опыта работы с Kubernetes, поэтому managed-сервис стал самым рациональным способом кубернетизировать приложения. И такой выбор оправдал себя: по словам CTO **Александра Марченко,** за все то время, что команда пользовалась GKE, с Kubernetes не было ни одного инцидента: он просто работал. Подход хорош и тем, что разработчики не вникали в сложности устройства Kubernetes, а фокусировались на своей основной деятельности — разработке.
Почему отказались от Google
---------------------------
Основная причина — в росте стоимости managed Kubernetes. В 2018-м, в самом начале кубернетизации, у robota.ua было меньше сервисов, небольшие prod- и тестовое окружения. Некоторое время ценник был приемлемым. Но со временем стоимость тестовых окружений стала обходиться в такую же сумму, что и prod. Количество сервисов, которые развернуты в managed K8s, увеличивалось. В итоге было решено мигрировать в частное облако украинского провайдера и найти альтернативу GKE.
У robota.ua был положительный опыт с managed Kubernetes от Google, и они хотели получать такую же услугу в другом облаке. Такая позиция совпадает с трендом индустрии: недавно [мы рассказывали](https://habr.com/ru/company/flant/blog/591475/) об исследованиях, которые подтверждают, что всё больше компаний выбирают managed Kubernetes у провайдеров или готовые платформы. Причины тренда детально разобрал Дмитрий Столяров в своем докладе [«Как правильно сделать Kubernetes»](https://habr.com/ru/company/flant/blog/562246/).
> *«Нам нужно было решение, которое бы, с одной стороны, не стоило, как крыло от самолета, а с другой, позволяло бы держать одинаковые кластеры».*
>
>
##### Александр Марченко
CTO robota.ua
Тогда robota.ua обратились к нам. С учетом того, что инфраструктура была уже в K8s, они увидели перспективу в [managed Kubernetes на базе платформы Deckhouse](https://deckhouse.io/ru/services/managed.html), которая предлагает готовые к работе кластеры Kubernetes. Большой бонус в том, что такой Kubernetes можно использовать, в частности, поверх любых виртуальных машин (ВМ).
На решение robota.ua повлияло и то, как работает техподдержка «Флант». Мы на связи 24х7 и всегда готовы помочь. Тем более в таком сложном деле, как переезд, который Бенджамин Франклин [сравнивал с пожаром](https://ru.wikiquote.org/wiki/%D0%91%D0%B5%D0%BD%D0%B4%D0%B6%D0%B0%D0%BC%D0%B8%D0%BD_%D0%A4%D1%80%D0%B0%D0%BD%D0%BA%D0%BB%D0%B8%D0%BD#cite_ref-%D0%94%D0%B1%D1%81_2-1).
Переезд
-------
Новую инфраструктуру было решено развернуть в частном облаке украинского провайдера [Colocall](https://www.colocall.net/ru/) (Киев). Kubernetes-кластеры запускались на базе платформы Deckhouse, которая работает поверх статических ВМ Colocall.
Нужно было перенести 100+ сервисов (deployment’ов), многие из которых работали под нагрузкой в production. Основную часть команда robota.ua перенесла за две недели; в целом же переезд занял полтора месяца.
Robota.ua используют отдельную continuous delivery-систему Octopus Deploy. Поэтому первым делом было настроено развертывание приложений через систему в новый кластер. При миграции проблем не возникло, так как кластеры Kubernetes под управлением Deckhouse — это, по сути, «ванильный» Kubernetes. Единственное, что нужно было сделать, — поменять `kubeconfig` в CI-системе.
Все приложения — stateless. Kafka и БД запущены не в Kubernetes и не затрагивались при переезде, настраивать миграцию данных не требовалось. Поэтому далее процесс выглядел достаточно просто и типично:
* выкатили приложение в новый кластер;
* проверили, что приложение работает;
* переключили DNS на новый кластер;
* проверили приложение на наличие ошибок и увидели в мониторинге, что запросы проходят корректно.
Перенос консьюмеров Kafka стал еще более простой задачей: достаточно было выкатить консьюмеры в новый кластер, и они сразу же взялись за работу.
Небольшие затруднения возникли с двумя старыми проектами, которые взаимодействовали внутри K8s, не выходя наружу — их нужно было переносить разом. Впрочем, они переносились в последнюю очередь. Поскольку к этому моменту процесс миграции был уже отработан, сервисы переезжали по десятку в день.
### Итог
Команда robota.ua самостоятельно и легко справилась с переездом. Мы лишь развернули и поддерживали кластеры, консультировали по вопросам работы с Deckhouse.
> *«Полет нормальный, Кубер живет своей жизнью. Любопытный факт: многие сервисы стали работать шустрее (теперь всё чуть ли не в соседних стойках живет)... В общем, очень круто. Честно говоря, думал, что переезд будет сильно дольше и больнее. Ведь по сути, мы тут за две-три недели из ничего сделали кластера и бесшовно переехали. Если бы не писал нашим ребятам, никто бы даже не заметил».*
>
>
##### Александр Марченко
CTO robota.ua
Как удалось сэкономить
----------------------
На момент миграции стоимость ресурсов в приватном облаке Colocall была в несколько раз ниже, чем у Google. Хотя сейчас по количеству worker-узлов и совокупной емкости CPU и RAM кластер больше того, что был в GKE, затраты на инфраструктуру и ее обслуживание снизились.
Чтобы измерить экономическую выгоду от переезда, нужно понять, как формируется итоговая стоимость кластера K8s с учетом затрат на ресурсы.
В GKE стоимость за сам Kubernetes символическая; основные затраты приходятся на виртуальные машины для кластера. Вот как распределяется бюджет:
* 73 USD в месяц — за сам кластер (здесь и далее все цены указаны без НДС);
* 255 USD — за один worker-узел с параметрами e2-standard-8 с 50 GiB Zonal standard PD в регионе europe-central2.
В расчет стоимости Managed Kubernetes от «Флант» включаем затраты на ВМ от Colocall. В общем получается:
* 1400 USD в месяц — [за базовый кластер](https://flant.com/services/managed-kubernetes-as-a-service/calculator?share=ba0093d14a4a6187dafb2c2fd22b9b9a) (production-кластер от Managed Deckhouse на статических ВМ без доступа к API облака);
* 153 USD — за три ВМ для управляющего слоя (Control Plane);
* 61 USD — за один worker-узел идентичной GKE конфигурации.
Теперь используем эти данные, чтобы показать, как меняются совокупные затраты на один Kubernetes-кластер с увеличением количества worker-узлов\*\*:
\*\* ПримечаниеЭто *ориентировочный* расчет. Его достаточно, чтобы оценить примерную разницу в затратах и динамику расходов при росте кластера. Мы не знаем *точные* затраты robota.ua на инфраструктуру, поэтому опирались на актуальные расценки Google и Colocall без учета нюансов тарификации и политики скидок провайдеров.
На графике видно, что стоимость кластера в GKE на старте ниже. Но чем больше worker-узлов в кластере, тем дороже становится managed-сервис в целом.
**Важная оговорка.** Понятно, что GKE — это лишь часть огромной экосистемы Google Cloud. Она дает широкие возможности, решает большой объем задач, у нее высокая отказоустойчивость. Разные проекты используют эти возможности по-разному. В случае robota.ua команде нужен был только «голый» GKE, без дополнительных managed-сервисов — например, БД или мониторинга от Google. Поэтому миграция на другое решение managed Kubernetes оказалась целесообразной и простой. Однако в других случаях при оценке экономической эффективности переезда стоит учитывать все нюансы.
Технические плюсы
-----------------
**1. Более низкая latency.** Сервисы robota.ua переехали из Европы в Украину, то есть ближе к основной аудитории. Это снизило задержку (latency) в общей сложности на 100 мс. Особенно явным эффект был у сервисов, время ответа у которых раньше составляло ~ 100 мс. В результате выиграли все — и пользователи, и сами сервисы.
**2. Более функциональный K8s.** По сравнению с KaaS-сервисами наш Managed Deckhouse подразумевает более широкую функциональность и гибкое управление кластером:
* Вместе с «ванильным» Kubernetes пользователь получает преднастроенные модули для мониторинга, автомасштабирования, балансировки трафика и безопасного доступа. В случае KaaS все эти модули нужно устанавливать и настраивать самому.
ПримерИзначально robota.ua хотели настроить сбор логов в Loki с помощью Promtail. Но мы предложили более удобное решение, реализованное в Deckhouse, — модуль [log-shipper](https://deckhouse.io/ru/documentation/v1/modules/460-log-shipper/). Сбор логов в модуле конфигурируется через создание Custom Resource с понятным и простым интерфейсом.
* Большинство провайдеров в рамках managed-услуги отвечают только за компоненты управляющего слоя и обновляют только его; обновление остальных компонентов — на пользователе. Deckhouse же полностью управляет кластером и автоматически обновляет все его компоненты. При этом доступны разные каналы обновления.
* Можно использовать внешнюю аутентификацию и авторизацию. Поддерживается OIDC.
[Подробнее о возможностях платформы](https://deckhouse.io/ru/deckhouse_vs_kaas.html).
**3. Независимость от поставщика ресурсов.** Применительно к robota.ua одно из главных преимуществ, которое дает Deckhouse, — независимость от провайдера. Клиент может развернуть те же самые кластеры в любом облаке или на собственных серверах.
Заключение
----------
Крупные зарубежные провайдеры отдают managed Kubernetes практически даром, основные расходы приходятся на ВМ. Когда кластер растет, можно сэкономить: например, переехать на более дешевые ВМ других провайдеров. Это позволяют платформы вроде Deckhouse. Пользователи такой платформы не занимаются низкоуровневым администрированием Kubernetes, а получают готовый API — по аналогии с тем, как это происходит в GKE, AKS или EKS. Такой вариант снижения затрат подходит, если нет другой привязки к сервисам крупного провайдера или когда понятно, как эту привязку преодолеть (пример — [кейс нашего клиента Adapty](https://habr.com/ru/company/flant/blog/587814/)).
В случае с robota.ua миграция прошла быстро и незаметно и для разработчиков, и для пользователей.
> *«Всегда, когда есть возможность использовать managed Kubernetes, именно его и нужно использовать».*
>
>
##### Александр Марченко
CTO robota.ua
P.S.
----
Читайте также в нашем блоге:
* «[Как мы помогли cybersport.ru справиться с The International 10](https://habr.com/ru/company/flant/blog/590975/)»;
* «[Переехать в Kubernetes и платить за инфраструктуру вдвое меньше? История Adapty](https://habr.com/ru/company/flant/blog/587814/)»;
* «[Опыт миграции инфраструктуры клиента из AWS в Яндекс.Облако](https://habr.com/ru/company/flant/blog/568624/)». | https://habr.com/ru/post/598399/ | null | ru | null |
# Возможно, первая игра на Dart + Box2D
На Хабре не слишком много статей, посвященных языку программирования Dart, зато полным полно статей о недоделанных или с трудом доделанных играх, а также о том, как из первых сделать вторые. Данная статья будет смесью этих двух тем.
Дело обстояло так: мы с моим старым другом уже не первый год занимаемся разработкой. Игра, о которой пойдет речь в статье, уже далеко не первая, которую мы пытались сделать, но первая, с которой это удалось. После почти десятка неудавшихся попыток сделать игру мы наконец-то смогли объективно оценить свои силы и решили сделать головоломку. Жанр игр сам по себе несложный, но то, что мы задумали, было куда сложнее и не похоже ни на одну из игр, представленных в каталогах ВК и ФБ в этом жанре. Для того, чтобы совсем не осталось шансов закончить игру, решили использовать те технологии, которые никогда в глаза не видели — Dart + Box2d.
Теперь о впечатлениях от разработки на дарте. Это очень отличается от разработки на java/c#/php как минимум тем, что ты не можешь нагуглить ответ на мало-мальски сложный вопрос, что одновременно злит и дает тебе ощущение первопроходца. Еще существенное отличие в сырости технологии в целом, а инструментов в частности.
#### Dart Language
Сразу скажу, что язык был выбран из-за строгой типизации и классического подхода к ООП. Наверное, больше всего язык похож на Java, в общем, код многих методов можно просто взять вставить в java и они без проблем отработают, иногда этот трюк может пройти даже с целым классом. Из отличий ключевое, на мой взгляд, это поддержка процедурной парадигмы, которая ~~несколько развращает код~~ иногда позволяет упростить код решения задачи. Следующим ~~ударом по безопасности~~ удивлением стало отсутствие модификаторов доступа для классов, методов и полей. Первое время я противился искушению, но потом такие возможности взяли свое и в результате я получил очень сильно связанный код, который вряд ли кто-то в этом мире признает хорошим, но это вряд ли проблема языка, а скорее недостаток опыта в целом и полное его отсутствие в отношении дарта, особенно в самом начале пути.
#### Dart Editor (DE)
DE был сделан на основе Eclipse, что само по себе еще не делает его плохим, но заставляет насторожиться. Через время использования DE начинает казаться, что корпорация добра в последний момент вырезала все приятные функции Eclipse. Благо, нашелся плагин для любимого PhpStorm, который тоже сыроват, но здесь хотя бы в IDE чувствуешь себя на родной земле.
#### Dart Pub
Стоит сказать, что в плане пакетов гугл очень постарались. Есть общий каталог пакетов, в один клик можно получить нужную библиотеку.
#### The Dartium binary expires after 12 weeks
Абсолютно невероятной особенностью разработки на этом чудном языке стало то, что Dartium (Chromium с виртуальной машиной для дарта) нужно заново скачивать и устанавливать каждые 12 недель, а если этого не сделать, то DartVM как будто исчезало, и то, что работало еще вчера, в миг переставало работать вообще.
#### Box2D
Box2d для Dart — сразу хочу сказать, что впервые работаю с этой библиотекой и в процессе ее изучения было несколько вещей, которые сильно удивляли, но со временем все улеглось в голове, и стало ясно, что Box в целом как раз то, что нужно, а порт, на удивление, хорош.
#### Dart2JS
Dart2JS — это утилита, поставляемая с пакетом для разработки на дарте, для построения из dart кода, понятного лишь крошечной кучке людей во вселенной, в js, который в том виде, в котором он получается, не понятен вообще никому, кроме браузера. Хотя, на самом деле, это один из приятных моментов разработки, хоть и что бы сбилдить проект, первый раз пришлось убить порядочное количество времени. Надо отметить, что пока не встретили ни одного бага связянного с неверным построением JS. кода. Он, кстати, получается, как и следовало ожидать, абсолютно нечитаемым.
#### Dart & JS
Конечно, используя дарт, возникает иногда желание или/и необходимость использовать JS код, там для этого предусмотрен в целом неплохой инструментарий, но им невозможно пользоваться. Сейчас попробую объяснить. Это лучшая библиотека, которая могла быть для работы с JS, но для настолько связанного с JS языка, я считаю эта поддержка должна была быть перенесена на уровень языка, синтаксис мог бы быть чем-то похож на использование asm из С
Сейчас это выглядит в лучшем случае примерно так:
```
static void getUser(Function callback) {
(context['Features'] as JsObject).callMethod('getUser', [new JsFunction.withThis((JsObject obj) {
callback();
})]);
}
```
#### Dart & External Api
Я всегда был влюблен в API VK, оно мне казалось и до сих пор кажется примером правильно реализованого API для веб-сервиса. Кроме всего прочего, ВК поставляет и js-библиотеку для удобного доступа к своему API. Разрабатывая другие приложения для соцсетей, мне всегда нравилось пользоваться этой библиотекой, но когда пришлось обращаться к ней из дарта, это превратило сказку в кошмар, потому я постарался его спрятать в самый дальний класс своего проекта и пореже его открывать. Все дело в том, что, как я и говорил, работа с JS в дарте реализована как библиотека и требует постоянных манипуляций с объектами т.о. львиную долю времени на обертки дарт-объектов в JsObject и выковыриванию из других JsObject тех немногих нужных мне данных, ради которых это все затевалось. Но после долгих мучений я смог уменьшить точки соприкосновения языков до минимума, вынеся все взаимодействия с VkApi в отдельный JS файл, который их обрабатывал и отдавал в специально обученый класс дарта.
#### Two Cubes
Разработка игры заняла намного больше времени, чем хотелось бы, как это часто и бывает. В любом случае, это первая игра, которую наконец удалось закончить. Главной проблемой ее доставки в массы скорее всего станет то, что она получилась довольно сложная, даже не в плане управления, а именно как головоломка. Например, из 2000 человек, которые сейчас в нее играют, потратив почти 15000 попыток, всего с десяток человек прошло обе главы, хотя, может, это и правильный процент?
**UPD:** Линк для тех кто хочет посмотреть что вышло в итоге: [vk.com/twocubes](http://vk.com/twocubes)
**UPD 2019:** В социальных сетях игру давно удалили из-за того, что мы про нее надолго забыли, но недавно появилось время и желание ее воскресить, хотя бы чтобы она где-крутилась и грела душу. Сейчас доступна на домене [twocubes.io](https://twocubes.io) | https://habr.com/ru/post/247809/ | null | ru | null |
# Фотографируем объекты в C#: хроника и сопоставление снимков, реконструкция состояния по снимку
При разработке приложений часто встречается следующий сценарий: имеется некоторый набор данных доступных для просмотра и редактирования, например, это могут быть бизнес-сущности или настройки приложения. В момент, когда пользователь решает что-либо отредактировать, ему обычно становится доступна специальная форма с нужными полями ввода-вывода и другими элементами управления. Если он вносит какие-либо корректировки в данные, то при обработке формы хорошим тоном является запрос-подтверждение перед окончательным применением внесённых правок. В случае согласия пользователя данные обновляются в источнике и на интерфейсе, а при отмене используются старые значения.
Данная задача включает две подзадачи:
1) когда пользователь уходит с формы редактирования, необходимо понимать, действительно ли он произвёл изменения, чтобы не задавать вопрос на подтверждение впустую и не перезаписывать идентичные данные;
2) если редактированию подвергается непосредственно исходная сущность, а не её копия, то в случае отмены необходимо сохранять возможность отката к исходным значениям.
В статье мы рассмотрим обобщённый и очень лаконичный [размером в несколько строк кода!] подход к решению подобного рода задач, основанный на использовании библиотеки [Replication Framework](https://www.nuget.org/packages/Art.ReplicationFramework.Trial/).
Рассмотрим [пример приложения](https://1drv.ms/u/s!AvvcPQX44tbIhc8tYEOIZjuocJ3srA). Пусть дан список сущностей, среди которых пользователь может выбрать любую и нажать на кнопку редактирования [в режиме оригинала либо копии].
В режиме редактирования оригинала при изменении сущности в диалоговом окне соответствующие значения немедленно обновляются и в главном, чего не происходит в режиме копии.
После подтверждения изменений выводится список всех найденных различий, если поднят флаг *Show detailed changes*, либо просто выводится сообщение об обнаружении хотя бы одного отличия [в реальных ситуациях иногда достаточно и такого поведения].
При отмене используются старые значения.
Теперь взглянем на код метода, который отвечает за данное поведение.
```
private void Edit(T sourceEntry, bool useCopy, bool showChanges, ReplicationProfile replicationProfile)
{
var cache = new ReconstructionCache();
var sourceSnapshot = sourceEntry.CreateSnapshot(cache, replicationProfile);
var editableEntry = useCopy ? sourceSnapshot.ReplicateGraph() : sourceEntry;
if (GetView(editableEntry).ShowDialog() == true)
{
var resultSnapshot = editableEntry.CreateSnapshot(null, replicationProfile);
var changes = sourceSnapshot.Juxtapose(resultSnapshot)
.Where(j => j.State != Etalon.State.Identical);
if (changes.Any())
{
MessageBox.Show(showChanges
? changes.Aggregate("", (x, y) => x + y + Environment.NewLine)
: "Any changes has been detected!");
UpdateSourceData(editableEntry);
UpdateUserInterface();
}
else MessageBox.Show("There are no any changes.");
}
else if (!useCopy) sourceSnapshot.ReconstructGraph(cache);
}
```
**Сущность Person**
```
public class Person : INotifyPropertyChanged
{
private int _id;
private string _name;
private string _birthday;
private string _phone;
private string _mail;
public event PropertyChangedEventHandler PropertyChanged = (o, e) => { };
private void Set(ref T target, T value, [CallerMemberName]string caller = "")
{
if (Equals(target, value)) return;
target = value;
PropertyChanged(this, new PropertyChangedEventArgs(caller));
}
public int Id
{
get => \_id;
set => Set(ref \_id, value);
}
public string Name
{
get => \_name;
set => Set(ref \_name, value);
}
public string Birthday
{
get => \_birthday;
set => Set(ref \_birthday, value);
}
public string Phone
{
get => \_phone;
set => Set(ref \_phone, value);
}
public string Mail
{
get => \_mail;
set => Set(ref \_mail, value);
}
}
```
**Профиль репликации для сущности Person**
```
private static readonly ReplicationProfile PersonRepicationProfile = new ReplicationProfile
{
MemberProviders = new List
{
new CoreMemberProviderForKeyValuePair(),
new CoreMemberProvider(BindingFlags.Public | BindingFlags.Instance, Member.CanReadWrite),
}
};
```
Как видим, метод достаточно обобщённый и его можно испольовать для сущностей других типов.
Теперь обратим внимание на ключевые моменты. Работа библиотеки Replication Framework основана на использовании мгновенных снимков объектов в произвольные моменты времени, то есть с помощью метода-расширения Snapshot можно запросто сделать хронику мутаций [историю изменений] произвольного объекта или графа.
```
var cache = new ReconstructionCache();
var sourceSnapshot = sourceEntry.CreateSnapshot(cache, replicationProfile);
...
var resultSnapshot = editableEntry.CreateSnapshot(null, replicationProfile);
```
Далее можно сопоставить два снимка, чтобы выявить различия в состоянии графа между двумя любыми контрольными точками.
```
var changes = sourceSnapshot.Juxtapose(resultSnapshot)
.Where(j => j.State != Etalon.State.Identical);
```
С помощью вызова метода ReplicateGraph можно воссоздать новую копию графа идентичную той, что зафиксирована на снимке, а с помощью ReconstructGraph при наличии кэша репликации совершить реконструкцию графа, то есть вернуть старый экземпляр к прежнему состоянию.
```
var editableEntry = useCopy ? sourceSnapshot.ReplicateGraph() : sourceEntry;
```
```
var cache = new ReconstructionCache();
var sourceSnapshot = sourceEntry.CreateSnapshot(cache, replicationProfile);
...
else if (!useCopy) sourceSnapshot.ReconstructGraph(cache);
```
Более подробную информацию об использовании библиотеки вы можете найти в предыдущих публикациях:
1) [Replication Framework • глубинное копирование и обобщённое сравнение связных графов объектов](https://habrahabr.ru/post/330294/)
2) [Обобщённое копирование связных графов объектов в C# и нюансы их сериализации](https://habrahabr.ru/post/332516/)
Библиотека является бесплатной для некоммерческих и учебных проектов, а на Nuget доступна [пробная версия](https://www.nuget.org/packages/Art.ReplicationFramework.Trial/), которая функциональна до конца лета. Для получения лицензионной версии с неограниченным сроком действия и доступа к исходным кодам необходимо отправить запрос на адрес [makeman@tut.by](http://makeman@tut.by).
За внешней простотой использования и хорошей функциональностью библиотеки кроется большая и кропотливая работа по её созданию и отладке, поэтому любая материальная поддержка и покупка коммерческой лицензии очень приветсвуются!
Вдохновения тебе, читатель! | https://habr.com/ru/post/333846/ | null | ru | null |
# Как обрабатывать состояния загрузки и ошибки с помощью StateNotifier и AsyncValue во Flutter
Состояния загрузки и ошибки очень часто встречаются в приложениях, работающих асинхронно.
Если мы не отобразим пользовательский интерфейс (UI) загрузки или ошибки, когда это необходимо, пользователи могут посчитать, что приложение не работает, и не определят, была ли операция, которую они пытаются выполнить, успешной.
Для примера, вот страница с кнопкой, которую мы можем использовать при оплате товара с помощью Stripe:
*Анимация: Пример страницы оплаты с помощью Stripe*
Как мы видим, при нажатии кнопки "Pay (Оплатить)" появляется индикатор загрузки. И сама платежная страница также показывает индикатор загрузки, до тех пор, пока не будут доступны способы оплаты.
Если платеж не проходит по какой-либо причине, надо показать пользователю UI с ошибкой, чтобы проинформировать его об этом.
Давайте попробует вникнуть в суть, чтобы узнать, как можно решить эти проблемы в наших приложениях Flutter.
Состояния загрузки и ошибки с использованием StatefulWidget
-----------------------------------------------------------
Состояния загрузки и ошибки очень распространены, и мы должны их обрабатывать на каждой странице или виджете, который работает асинхронно.
Для примера предположим, что у нас есть кнопка `PaymentButton`, которую можно использовать для совершения платежа:
```
class PaymentButton extends StatelessWidget {
@override
Widget build(BuildContext context) {
// note: this is a *custom* button class that takes an extra `isLoading` argument
return PrimaryButton(
text: 'Pay',
// this will show a spinner if loading is true
isLoading: false,
onPressed: () {
// use a service locator or provider to get the checkout service
// make the payment
},
);
}
}
```
Можно сделать этот виджет стейтфул и добавить две переменные состояния:
```
class _PaymentButtonState extends State {
// loading and error state variables
bool \_isLoading = false;
String \_errorMessage = '';
Future pay() async {
// make payment, update state variables, and show an alert on error
}
@override
Widget build(BuildContext context) {
// same as before,
return PrimaryButton(
text: 'Pay',
// use \_isLoading variable defined above
isLoading: \_isLoading,
onPressed: \_isLoading ? null : pay,
);
}
}
```
Этот подход будет работать, но он весьма рутинный и чреват ошибками.
В конце концов, мы же не хотим сделать все наши виджеты стейтфул и повсюду добавлять переменные состояния, верно?
Делаем состояния загрузки и ошибки все более DRY
------------------------------------------------
Что нам действительно нужно, так это последовательный способ управления состояниями загрузки и ошибки во всем приложении.
Для этого мы воспользуемся [AsyncValue](https://pub.dev/documentation/riverpod/latest/riverpod/AsyncValue-class.html) и [StateNotifier](https://pub.dev/documentation/state_notifier/latest/state_notifier/StateNotifier-class.html) из пакета [Riverpod](https://pub.dev/packages/riverpod).
Когда мы закончим, то сможем отображать любой UI загрузки и ошибки с помощью нескольких строк кода, как показано здесь:
```
class PaymentButton extends ConsumerWidget {
@override
Widget build(BuildContext context, WidgetRef ref) {
// error handling
ref.listen>(
paymentButtonControllerProvider,
(\_, state) => state.showSnackBarOnError(context),
);
final paymentState = ref.watch(paymentButtonControllerProvider);
// note: this is a \*custom\* button class that takes an extra `isLoading` argument
return PrimaryButton(
text: 'Pay',
// show a spinner if loading is true
isLoading: paymentState.isLoading,
// disable button if loading is true
onPressed: paymentState.isLoading
? null
: () => ref.read(paymentButtonControllerProvider.notifier).pay(),
);
}
}
```
Но давайте будем действовать поэтапно.
Базовая настройка: виджет PaymentButton
---------------------------------------
Начнем с базового виджета `PaymentButton`, который был представлен ранее:
```
import 'package:flutter_riverpod/flutter_riverpod.dart';
// note: this time we subclass from ConsumerWidget so that we can get a WidgetRef below
class PaymentButton extends ConsumerWidget {
@override
Widget build(BuildContext context, WidgetRef ref) {
// note: this is a custom button class that takes an extra `isLoading` argument
return PrimaryButton(
text: 'Pay',
isLoading: false,
onPressed: () => ref.read(checkoutServiceProvider).pay(),
);
}
}
```
Когда кнопка нажата, мы вызываем `ref.read()`, чтобы с помощью сервиса оформления заказа совершить оплату.
> Если вы не знакомы с `ConsumerWidget` и синтаксисом `ref.read()`, обратитесь к моему [Essential Guide to Riverpod](https://codewithandrea.com/articles/flutter-state-management-riverpod/).
>
>
Для справки, вот как можно имплементировать `CheckoutService` и соответствующий провайдер:
```
// sample interface for the checkout service
abstract class CheckoutService {
// this will succeed or throw an error
Future pay();
}
final checkoutServiceProvider = Provider((ref) {
// return some concrete implementation of CheckoutService
});
```
Это работает, но метод `pay()` может затянуться на несколько секунд, и у нас нет никакого UI загрузки или ошибки.
Давайте разберемся с этим.
Управление состояниями загрузки и ошибки с помощью AsyncValue
-------------------------------------------------------------
В нашем примере UI должен управлять тремя возможными состояниями:
* не загружается (по умолчанию)
* загрузка
* ошибка
Для представления этих состояний мы можем использовать класс [AsyncValue](https://pub.dev/documentation/riverpod/latest/riverpod/AsyncValue-class.html), поставляемый вместе с пакетом Riverpod.
Для справки, вот как определяется этот класс:
```
@sealed
@immutable
abstract class AsyncValue {
const factory AsyncValue.data(T value) = AsyncData;
const factory AsyncValue.loading() = AsyncLoading;
const factory AsyncValue.error(Object error, {StackTrace? stackTrace}) =
AsyncError;
}
```
Обратите внимание, что данный класс является абстрактным и что мы можем инстанцировать его только с помощью одного из существующих фабричных конструкторов.
А под капотом эти конструкторы реализованы с помощью следующих конкретных классов:
```
class AsyncData implements AsyncValue
class AsyncLoading implements AsyncValue
class AsyncError implements AsyncValue
```
Самое главное, что мы можем использовать `AsyncValue` для представления трех состояний, которые нас так интересуют:
**не загружено** → `AsyncValue.data`
**загрузка** → `AsyncValue.loading`
**ошибка** → `AsyncValue.error`
Но где мы должны разместить нашу логику?
Для этого необходимо определить подкласс `StateNotifier`, который будет использовать `AsyncValue` в качестве состояния.
Подкласс StateNotifier
----------------------
Сначала мы определим класс `PaymentButtonController`, который использует `CheckoutService` в качестве зависимости и устанавливает состояние по умолчанию:
```
class PaymentButtonController extends StateNotifier> {
PaymentButtonController({required this.checkoutService})
// initialize state
: super(const AsyncValue.data(null));
final CheckoutService checkoutService;
}
```
*Примечание:* `AsyncValue.data()` обычно используется для передачи некоторых данных с помощью обобщенного аргумента .
Но в нашем случае нет данных, поэтому можно использовать `AsyncValue` для определения нашего `StateNotifier` и `AsyncValue.data(null)` при установке начального значения.
Затем добавляем метод `pay()`, который будет вызываться из класса виджета:
```
Future pay() async {
try {
// set state to `loading` before starting the asynchronous work
state = const AsyncValue.loading();
// do the async work
await checkoutService.pay();
} catch (e) {
// if the payment failed, set the error state
state = const AsyncValue.error('Could not place order');
} finally {
// set state to `data(null)` at the end (both for success and failure)
state = const AsyncValue.data(null);
}
}
}
```
Обратите внимание, как состояние устанавливается несколько раз, чтобы наш виджет мог соответствующим образом перестраивать и обновлять UI.
Чтобы сделать `PaymentButtonController` доступным для нашего виджета, определяем `StateNotifierProvider` следующим образом:
```
final paymentButtonControllerProvider =
StateNotifierProvider>((ref) {
final checkoutService = ref.watch(checkoutServiceProvider);
return PaymentButtonController(checkoutService: checkoutService);
});
```
**Обновленный виджет PaymentButton**
Теперь, когда у нас есть `PaymentButtonController`, его можно использовать в нашем классе виджета:
```
class PaymentButton extends ConsumerWidget {
@override
Widget build(BuildContext context, WidgetRef ref) {
// 1. listen for errors
ref.listen>(
paymentButtonControllerProvider,
(\_, state) => state.whenOrNull(
error: (error) {
// show snackbar if an error occurred
ScaffoldMessenger.of(context).showSnackBar(
SnackBar(content: Text(error)),
);
},
),
);
// 2. use the loading state in the child widget
final paymentState = ref.watch(paymentButtonControllerProvider);
final isLoading = paymentState is AsyncLoading;
return PrimaryButton(
text: 'Pay',
isLoading: isLoading,
onPressed: isLoading
? null
// note: this was previously using the checkout service
: () => ref.read(paymentButtonControllerProvider.notifier).pay(),
);
}
}
```
Несколько замечаний:
* мы используем `ref.listen()` и `state.whenOrNull()` для показа снэкбара, если найдено состояние ошибки
* мы проверяем, является ли состояние платежа инстансом `AsyncLoading` (*помните:* `AsyncLoading` *является подклассом* `AsyncValue`)
* мы передаем переменную `isLoading` в `PrimaryButton`, который позаботится о демонстрации правильного UI.
Если вы не знакомы с листенерами в Riverpod, см. Раздел «[Прослушивание изменений состояния провайдера](https://codewithandrea.com/articles/flutter-state-management-riverpod/#listening-to-provider-state-changes)» в моем [основном руководстве по Riverpod](https://codewithandrea.com/articles/flutter-state-management-riverpod/).
Это работает, но можем ли мы получить такой же результат с меньшим количеством шаблонного кода?
Расширения Dart спешат на помощь
--------------------------------
Давайте определим расширение для `AsyncValue`, чтобы было легче проверять состояние загрузки и показывать снэкбар при ошибке:
```
extension AsyncValueUI on AsyncValue {
// isLoading shorthand (AsyncLoading is a subclass of AsycValue)
bool get isLoading => this is AsyncLoading;
// show a snackbar on error only
void showSnackBarOnError(BuildContext context) => whenOrNull(
error: (error, \_) {
ScaffoldMessenger.of(context).showSnackBar(
SnackBar(content: Text(error.toString())),
);
},
);
}
```
С помощью этих изменений упрощаем наш класс виджета:
```
class PaymentButton extends ConsumerWidget {
const PaymentButton({Key? key}) : super(key: key);
@override
Widget build(BuildContext context, WidgetRef ref) {
// 1. listen for errors
ref.listen>(
paymentButtonControllerProvider,
(\_, state) => state.showSnackBarOnError(context),
);
// 2. use the loading state in the child widget
final paymentState = ref.watch(paymentButtonControllerProvider);
return PrimaryButton(
text: 'Pay',
isLoading: paymentState.isLoading,
onPressed: paymentState.isLoading
? null
: () => ref.read(paymentButtonControllerProvider.notifier).pay(),
);
}
}
```
При этом, для данной страницы, состояния загрузки и ошибки обрабатываются надлежащим образом:
**Заключение**
Вот законченная имплементация для расширения `AsyncValueUI`:
```
import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
// Bonus: define AsyncValue as a typedef that we can
// reuse across multiple widgets and state notifiers
typedef VoidAsyncValue = AsyncValue;
extension AsyncValueUI on VoidAsyncValue {
bool get isLoading => this is AsyncLoading;
void showSnackBarOnError(BuildContext context) => whenOrNull(
error: (error, \_) {
ScaffoldMessenger.of(context).showSnackBar(
SnackBar(content: Text(error.toString())),
);
},
);
}
```
Благодаря методам расширения `AsyncValueUI` мы можем легко обрабатывать состояния загрузки и ошибки в нашем приложении.
Фактически, для каждой страницы, которая выполняется асинхронно, нам нужно сделать два шага:
* добавить подкласс `StateNotifier`, являющийся посредником между классом виджета и указанными выше классами сервиса или хранилища
* модифицировать метод `build()` виджета, обрабатывая состояние ошибки через `ref.listen()` и проверяя состояние загрузки по мере необходимости.
Хотя для того, чтобы настроить все подобным образом, потребуется немного предварительной работы, полученные преимущества оправдывают затраченное время:
* мы можем обрабатывать состояния загрузки и ошибки с помощью небольшого количества кода в наших виджетах;
* мы можем перенести всю логику управления состояниями из наших виджетов в отдельные классы контроллеров.
---
> Материал подготовлен в рамках курса [«Flutter Mobile Developer».](https://otus.pw/6WUu/)
>
> Всех желающих приглашаем на бесплатный двухдневный интенсив «Flutter engine, анимация и ее оптимизация». На этом интенсиве мы рассмотрим самые глубокие механизмы Flutter Engine и научимся создавать сложные и плавные анимации как на мобильных платформах, так и веб-версии, использовать инструменты профилирования для исключения "замерзания" интерфейса. Также мы затронем тему использования WebGL в веб-приложениях на Flutter для создания трехмерных сцен. Регистрация [**здесь.**](https://otus.pw/AQnU/)
>
> | https://habr.com/ru/post/599991/ | null | ru | null |
# Математика машинного обучения, основанного на теории решеток
Это третья статья серии работ (ссылки на [первую](https://habr.com/en/post/509338/) и [вторую](https://habr.com/en/post/510010/) работы), описывающих систему машинного обучения, основанного на теории решеток, озаглавленную "ВКФ-система". Она использует структурный (теоретико-решеточной) подход к представлению обучающих примеров и их фрагментов, рассматриваемых как причины целевого свойства. Система вычисляет эти фрагменты как сходства между некоторыми подмножествами обучающих примеров. Существует алгебраическая теория таких представлений, называемая Анализом формальных понятий (АФП).
Однако описываемая система использует вероятностные алгоритмы, чтобы устранить недостатки неограниченного подхода. Подробности ниже...
#### Введение
Мы начнем с демонстрации нашего подхода в применении к школьной задаче.
Она состоит в отыскании достаточных условий на выпуклый четырехугольник, чтобы вокруг него можно было описать окружность и предсказать это свойство у прямоугольника.
Следовательно, имеются два класса: позитивный (можно описать окружность вокруг четырехугольника) и негативный.
Обучающая выборка включает в себя квадрат, равнобедренную трапецию, ромб и дельтоид (смотри метки строчек в таблице).
Единственный тестовый пример — прямоугольник.
Мы представляем каждый четырехугольник множеством признаков, связанных с его симметриями:
"Есть центр симметрии" (**A**),
"Группа вращений тривиальна" (**B**),
"группа вращенией нетривиальна" (**C**),
"Есть диагональная ось симметрии" (**D**),
"Есть недиагональная ось симметрии" (**E**).
Они соответствуют именам столбцов в таблице.
| четырехугольник | цель | A | B | C | D | E |
| --- | --- | --- | --- | --- | --- | --- |
| квадрат | 1 | 1 | 0 | 1 | 1 | 1 |
| трапеция | 1 | 0 | 1 | 0 | 0 | 1 |
| ромб | 0 | 1 | 0 | 1 | 1 | 0 |
| дельтоид | 0 | 0 | 1 | 0 | 1 | 0 |
| прямоугольник | ? | 1 | 0 | 1 | 0 | 1 |
Чтобы обнаружить возможные причины (в териминах симметрий) программа вычисляет сходства (общие признаки) между обучающими примерами одного знака. Поэтому мы имеем
где первое подмножество содержит родителей (все обучающие примеры, сходство которых вычислялось), а второе — общий фрагмент этих примеров.
Так как общий фрагмент  является подмножеством описания прямоугольника , программа предскажет его целевое свойство положительным, т.е. прямоугольник описываем. Это соответствует процедуре доопределения по аналогии в ДСМ-методе. Аналогами прямоугольника будут родители (квадрат и равнобедренная трапеция), которые имеют общий фрагмент, встречающийся и в прямоугольнике.
Однако мы можем поменять знаки: сходством отрицательных примеров будет
Это наблюдение приводит к логикам Аргументации, но мы предпочтем не погружаться здесь в детали. Заинтересованный читатель отсылается к статьям автора из сборника
Финн В.К., Аншаков О.М., Виноградов Д.В. (Ред.). Многозначные логики и их применения. Том 2: Логики в системах искусственного интеллекта, M.: URSS, 2020, 238 с. ISBN 978-5-382-01977-2
Важно, что сходство отрицательных примеров позволяет нам продемонстрировать принцип "запрета контр-примеров", так как его фрагмент  вкладывается в описание  примера противоположного знака (квадрат).
#### 1. Анализ Формальных Понятий
Первоначально автор планировал излагать теорию в терминах ДСМ-метода автоматического порождения гипотез. Но его создатель выразил сомнение, что "можно изложить глубокие идеи ДСМ-метода популярным языком". Поэтому автор решил использовать язык АФП для этой статьи. Однако он будет использовать некоторые свои термины (наравне с оригинальными в скобках) там, где предпочтительнее сменить терминологию.
*Выборка* (=*формальный контекст*) — это тройка , где  и  — конечные множества, а . Элементы  и  называются *объектами* и *признаками*, соответственно. Как обычно, мы пишем  вместо , чтобы обозначить ситуацию, когда объект  обладает признаком .
Для  и  определим
так что  — это множество всех признаков, общих для всех объектов из , а  — это множество всех объектов, обладающих всеми признаками из . Отображения  и  называются *полярами* (=*операторами производной*) для выборки .
*Кандидатом* (=*формальным понятием*) для выборки  называется пара , где , ,  и . Первая компонента  кандидата  называется *списком родителей* (=*объемом*) кандидата, а вторая компонента  называется его *фрагментом* (=*содержанием*). Множество всех кандидатов для выборки  обозначается через .
Легким упражнением является проверка того, что  образует решетку с операциями
Мы используем специальный случай: для ,  и  определим
Мы называем эти операции CbO, так как первая из них использовалась в известном алгоритме "Замыкай-по-одному" (Close-by-One (CbO)), чтобы породить все элементы .
Наиболее важное свойство монотонности операций CbO составляет следующую лемму
Путь  — выборка, ,  и . Тогда
#### 2. Проблемы с АФП
К несчастью, автор и его коллеги обнаружили некоторые теоретические недостатки непосредственного применения АФП к машинному обучению:
1. Число гипотез может оказаться экспоненциально велико по отношению к размеру входных данных (обучающей выборки) в худшем случае.
2. Проблема обнаружения больших гипотез вычислительно (NP-)трудная.
3. Переобучение неизбежно и возникает на практике.
4. Существуют 'фантомные' сходства между обучающими примерами, где каждый такой родитель имеет альтернативную гипотезу о причине целевого свойства.
Чтобы продемонстрировать недостаток 1 нам нужна Булева алгебра с выборкой, задаваемой коатомами (как позитивными примерами):
| $M\\G$ | $m_{1}$ | $m_{2}$ | $\ldots$ | $m_{n}$ |
| --- | --- | --- | --- | --- |
| $g_{1}$ | 0 | 1 | $\ldots$ | 1 |
| $g_{2}$ | 1 | 0 | $\ldots$ | 1 |
| $\vdots$ | $\vdots$ | $\vdots$ | $\ddots$ | $\vdots$ |
| $g_{n}$ | 1 | 1 | $\ldots$ | 0 |
Легко проверить, что любая пара  является кандидатом. Поэтому существует  кандидатов.
Чтобы оценить экспоненциальный взрыв выхода от размера входа, оценим память, нужную для хранения выборки для , как 128 байт, а память для сохранения  кандидатов потребуется  бит, т.е. 16 Гигабайт!
Недостаток 2 был обнаружен проф. С.О. Кузнецовым (НИУ-ВШЭ Москва).
Недостатки 3 и 4 были открыты автором во время его работы над диссертацией. Он рассмотрел несколько вероятностных моделей, чтобы породить "фантомые" сходства вместе с контр-примерами, могущими их отвергнуть. Наиболее прозрачный результат — это асимптотическая теорема, которая утверждает, что вероятность порождения "фантомного" сходства двух родителей без контр-примеров стремится к
![$1-e^{-a}-a\cdot{e^{-a}}\cdot\left[1-e^{-c\cdot\sqrt{a}}\right], $](https://habrastorage.org/getpro/habr/formulas/771/671/154/77167115443eff74b4e58d85625b1960.svg)
когда вероятность появления каждого признака (рассматриваемого как н.о.р. переменные Бернулли) , число контр-примеров , а число признаков .
Отметим, что даже меньшее число  является положительным, так как совпадает с вероятностью того, что Пуассоновская величина со средним  примет значение >1.
Можно обратиться к [диссертации автора](http://www.frccsc.ru/diss-council/00207305/diss/list/vinogradov_dv) за дополнительными деталями и результатами.
#### 3. Вероятностные алгоритмы
Ключевая идея ВКФ-метода случайным образом породить малое подмножество решетки кандидатов и использовать его элементы как гипотетические причины целевого свойства. С помощью этого трюка мы избегаем экспоненциально высокой вычислительной сложности обычных алгоритмов АФП (и ДСМ-метода тоже).
Так что нам нужны алгоритмы, подобные случайным блужданиям на огромной решетке, с порождением кандидата только тогда, когда он нам потребуется.
Автор придумал и исследовал математические свойства нескольких таких алгоритмов (немонотонной, монотонной, спаренной, ленивой спаренной и рстановленной спаренной цепей Маркова). Детали могут найдены в [диссертации автора](http://www.frccsc.ru/diss-council/00207305/diss/list/vinogradov_dv).
Мы теперь представим алгоритм спаренной цепи Маркова, которая явлется основой вероятностного подхода к машинному обучени, онованному на АФП (ВКФ-метода).
```
input: выборка (G,M,I), внешние операции CbO( , )
result: случайный кандидат
X=G U M;
A = M'; B = M;
C = G; D = G';
while (A!=C || B!= D) {
выбрать случайный элемент x из X;
= CbO(,x);
= CbO(,x);
}
```
Существует ленивый вариант спаренной цепи Маркова. Автор доказал, что ленивые вычисления приводят к ускорению (по сравнению с классической схемой) до
раз, где  — число признаков, а  — число обучающих примеров.
Этот результат находится в замечательном соответствии с экспериментальными оценками, полученными бывшей студенткой РГГУ Л.А. Якимовой.
#### 4. Общая структура ВКФ-метода
В машинном обучении с учителем обычно имеются две выборки, называемые *обучающей* и *тестовой*, соответственно.
Из положительных примеров обучающей выборки образуют . Отрицательные обучающие примеры формируют множество  *контр-примеров* (препятствий для превращение в ВКФ-гипотезы).
Множество  тестов содержат все элементы тестовой выборки для предсказания целевого свойства.
Программа вызывает алгоритм ленивой спаренной цепи Маркова, чтобы породить случайного кандидата . Программа сохраняет его как ВКФ-гипотезу VKF-hypothesis , если не найдется такого контр-примера , что .
Основной алгоритм индуктивного обобщения таков
```
input: число N ВКФ-гипотез для порождения
result: случайная выборка S затребованных гипотез
while (i для (G,M,I);
hasObstacle = false;
for (o in O) {
if (B включается в {o}') hasObstacle = true;
}
if (hasObstacle == false) {
S = S U {};
i = i+1;
}
}
```
Условие  означает включение фрагмента  кандидата  во фрагмент (подмножество признаков) контр-примера .
Если кандидат избегает все такие препятствия, он добавляется к списку порожденных ВКФ-гипотез.
Мы заменили детерминистский потребляющий много времени алгоритм (например, хорошо известный алгоритм "Замыкай-по-одному") для порождения всех кандидатов на вероятностный, который порождает случайное подмножество ВКФ-гипотез заданного объема.
После этого система машинного обучения предсказывает целевое свойство у тестов и сравнивает результаты предсказания с оригинальными значениями целевого свойства. Вот алгоритм предсказания по аналогии
```
input: список T тестовых примеров для предсказания уелевого свойства
input: случайная выборка S порожденных индукцией ВКФ-гипотез
for (x in T) {
target(x) = false;
for ( in S) {
if (B is a part of {x}') target(x) = true;
}
}
```
Худшая ситуация случается, когда некоторый важный положительный тестовый пример пропустит все порожденные ВКФ-гипотезы и доопределится отрицательно.
Тестовый пример  называется -*важным*, если вероятность всех ВКФ-гипотез  с  превосходит .
Автор доказал теорему об оценке параметра  из алгоритма индуктивного обобщения, чтобы избежать худшего случая.
Для , для любого  и любого  случайная выборка  ВКФ-гипотез мощности
с вероятностью  имеет свойство, что каждый -важный объект $x$ содержит фрагмент некоторой ВКФ-гипотезы , т.е. .
Эта теорема является аналогом известных результатов проф. В.Н. Вапника и проф. А.Я. Червоненкиса из статистической теории обучения.
#### Заключение
Эта заметка описывает главные математические характеристики системы машинного обучения, основанной на теории решеток. Автор назвал ее "ВКФ-системой" в честь своего учителя проф. В.К. Финна.
Последняя статья цикла будет посвящена представлениям объектов с признаками различных типов для примения описываемой здесь машины обучения.
Дискретные признаки снова потребуют некоторую технику из АФП. Непрерывным признакам потребуется логистическая регрессия, энтропийные принципы разделения диапазонов на подынтервалы и представление, порождающее выпуклую оболочку интервалов, чье сходство вычисляется.
Автор рад возможности поблагодарить своих коллег и студентов за поддержку и стимулы. | https://habr.com/ru/post/510580/ | null | ru | null |
# Обзор исходного кода Quake 2
Около месяца свободного времени я уделил чтению исходного кода Quake II. Это был удивительный и поучительный опыт, потому что в движок idTech3 внесено большое изменение: Quake 1, Quake World и QuakeGL объединены в одну красивую архитектуру кода. Особенно был интересен способ, которым достигли модульности, несмотря на то, что язык программирования C не обеспечивает полиморфизма.
Quake II во многих отношениях является блестящим образцом программного обеспечения, потому что это был самый популярный (по количеству лицензий) трёхмерный движок всех времён. На его основе было создано более 30 игр. Кроме того, он ознаменовал переход игровой индустрии от программной/8-битной системы цветов к аппаратной/24-битной. Этот переход произошёл примерно в 1997 году.
Поэтому я крайне рекомендую всем, кто любит программирование, изучить этот движок. Как обычно, я вёл бесконечное количество заметок, затем подчистил их и опубликовал как статью, чтобы сэкономить вам несколько часов.
Процесс «подчистки» меня сильно увлёк: в статье теперь более 40 мегабайт видео, скриншотов и иллюстраций. Сейчас я не знаю, стоили ли мои труды того, и нужно ли публиковать в будущем необработанные заметки в ASCII, выскажите своё мнение.
### Первая встреча и компиляция
Исходный код свободно доступен на [ftp-сайте](ftp://ftp.idsoftware.com/idstuff/source/quake2.zip) id Software. Проект можно открыть в Visual Studio Express 2008, который тоже можно свободно скачать с веб-сайта Microsoft.
Первая проблема заключается в том, что рабочая среда в Visual Studio 6 создаёт не один, а пять проектов. Так происходит потому, что Quake2 разрабатывался модульным (подробнее я расскажу об этом позже). Вот что получается из проектов:
| | |
| --- | --- |
| **Проекты** | **Сборки** |
| ctf | gamex86.dll |
| game | gamex86.dll |
| quake2 | quake.exe |
| ref\_soft | ref\_soft.dll |
| ref\_gl | ref\_gl.dll |
**Примечание:** проекты «ctf» и «game» перезаписывают друг друга, подробнее об этом позже.
**Примечание 2:** сначала сборку не удаётся выполнить из-за отсутствия заголовка DirectX:
```
fatal error C1083: Cannot open include file: 'dsound.h': No such file or directory
```
Я установил Direct3D SDK и Microsoft SDK (для MFC), и всё нормально скомпилировалось.
**Эрозия программного обеспечения:** похоже, то, что случилось с базой кода Quake, начинает происходить и с Quake 2: невозможно открыть рабочую среду в Visual Studio 2010. Необходимо использовать VS 2008.
Примечание: если после компиляции возникает ошибка
`"Couldn't fall back to software refresh!"`,
это значит, что не удалось правильно загрузить DLL рендерера. Но это легко исправить:
ядро Quake2 загружает две своих DLL с помощью win32 API: LoadLibrary. Если DLL не та, которая ожидается, или невозможно разрешить зависимости DLL, то сбой происходит без показа сообщения об ошибке. Поэтому:
* Подключите все пять проектов с одной библиотекой — нажмите правой кнопкой мыши на каждом проекте -> properties -> C/C++: убедитесь, что «runtime library» = Multi-threaded Debug DLL (с конфигурацией «Debug», иначе используйте release).
Если вы используете версию quake2, выпущенную id Software, то это устранит ошибку.
* Если вы используете мою версию: я добавил в движок возможность сохранения скриншотов в PNG, поэтому нужно также собрать libpng и libz (они находятся в подкаталоге). Убедитесь, что выбрана конфигурация Debug DLL. При сборке не забудьте поместить DLL libpng и zlib в одну папку с quake2.exe.
### Архитектура Quake2
Когда я читал код Quake 1, разделил [статью](http://fabiensanglard.net/quakeSource/index.php) (её перевод находится [здесь](https://habrahabr.ru/post/324804/)) на три части: «Сеть», «Прогнозирование» и «Визуализация». Такой подход был бы уместен и для Quake 2, потому что в основе своей движок не сильно отличается, но усовершенствования проще заметить, если разделить статью на три основных типа проектов:
| | |
| --- | --- |
| **Тип проекта** | **Информация о проекте** |
| Основной движок (.exe) | Ядро, выполняющее вызов модулей и обмен информацией между клиентом и сервером. В рабочей среде это проект `quake2`. |
| Модуль рендерера (.dll) | Отвечает за визуализацию. В рабочей среде содержатся программный рендерер (`ref_soft`) и рендерер OpenGL (`ref_gl`). |
| Игровой модуль (.dll) | Отвечает за игровой процесс (контент игры, оружие, поведение монстров...). В рабочей среде содержатся однопользовательский модуль (`game`) и модуль Capture The Flag (`ctf`). |
Quake2 имеет однопоточную архитектуру, точка входа находится в `win32/sys_win.c`. Метод `WinMain` выполняет следующие задачи:
```
game_export_t *ge; // Содержит указатели функций на dll игры
refexport_t re; // Содержит указатели функций на dll рендерера
WinMain() //Из quake2.exe
{
Qcommon_Init (argc, argv);
while(1)
{
Qcommon_Frame
{
SV_Frame() // Серверный код
{
//В сетевом режиме не используется в качестве сервера
if (!svs.initialized)
return;
// Переход в game.dll через указатель функции
ge->RunFrame();
}
CL_Frame() // Клиентский код
{
// Если только сервер ничего не рендерит
if (dedicated->value)
return;
// Переход к renderer.dll через указатель функции
re.BeginFrame();
//[...]
re.EndFrame();
}
}
}
}
```
Полностью разобранный цикл можно найти в моих [заметках.](http://fabiensanglard.net/quake2/notes.html)
Вы можете спросить: «зачем нужны такие изменения в архитектуре?». Для ответа на этот вопрос давайте посмотрим на все версии Quake с 1996 по 1997 год:
* Quake.
* WinQuake.
* GLQuake.
* VQuake. (несколько слов от одного из разработчиков Стефана Поделла (Stefan Podell) о [сложностях V2200 в Z-буферинге](http://groups.google.com/group/comp.sys.ibm.pc.hardware.video/msg/4d9ce71f1e1f6484) ([зеркало](http://fabiensanglard.net/quake2/quake-v2x00_discussion.zip))).
* Quake World Server.
* Quake World Client.
Было создано множество исполняемых файлов, и каждый раз требовалось форкать или настраивать код через препроцессор `#ifdef`. Это был полный хаос, и чтобы избавиться от него, нужно было:
* Унифицировать клиент/сервер.
* Собрать ядро, способное загружать взаимозаменяемые модули.
Новый подход можно проиллюстрировать таким образом:
Два основных улучшения:
* **Клиент-серверная унификация:** больше не было одного exe для клиента и другого для сервера, основной исполняемый файл мог работать как сервер, клиент или то и другое одновременно. Даже в однопользовательском режиме всё равно были клиент и сервер, выполнявшиеся в одном исполняемом файле (хотя в этом случае обмен данными выполнялся через локальный буфер, а не через TCP IP/IPX).
* **Модульность:** благодаря динамическому подключению часть кода стала взаимозаменяемой. Код рендерера и игры стал модулями, которые можно было переключать без изменения ядра Quake2. Таким образом с помощью двух структур, содержащих указатели функций, был достигнут полиморфизм.
Эти два изменения сделали базу кода чрезвычайно элегантной и более удобной для чтения, чем у Quake 1, который страдал от энтропии кода.
С точки зрения реализации проекты DLL должны раскрывать только один метод `GetRefAPI` для рендереров и `GetGameAPI` для игры (посмотрите на файл .def в папке «Resource Files»):
`reg_gl/Resource Files/reg_soft.def`
```
EXPORTS
GetGameAPI
```
Когда ядру нужно загрузить модуль, он загружает DLL в пространство процесса, получает адрес `GetRefAPI` с `GetProcAddress`, получает нужные указатели функций и на этом всё.
**Интересный факт:** при локальной игре связь между клиентом и сервером не выполняется через сокеты. Вместо этого команды скидываются в «кольцевой» (loopback) буфер с помощью `NET_SendLoopPacket` в клиентской части кода. Сервер реконструирует команду из того же буфера с помощью `NET_GetLoopPacket`.
**Случайный факт:** если вы видели когда-нибудь эту фотографию, то наверно интересовались, что за гигантский дисплей использовал Джон Кармак примерно в 1996 году:
Это был 28-дюймовый монитор InterView 28hd96, изготовленный Intergraph. Эта зверюга обеспечивала разрешение до 1920x1080, что довольно впечатляюще для 1995 года (подробнее можно почитать [здесь](http://www.ceu-inc.com/intergr_6d.html) ([зеркало](http://fabiensanglard.net/quake2/monitor.zip))).
Ностальгическое видео с Youtube: [Рабочие станции Intergraph Computer Systems](http://www.youtube.com/watch?v=RUghjj0cxgU).
Дополнение: похоже, эта статья вдохновила кого-то на geek.com, потому что они написали статью [«Джон Кармак создавал Quake в 1995 году на 28-дюймовом мониторе 16:9 1080p»](http://www.geek.com/articles/games/john-carmack-coded-quake-on-a-28-inch-169-1080p-monitor-in-1995-20110920/) ([зеркало](http://fabiensanglard.net/quake2/geek.com.jpg)).
Дополнение: кажется, Джон Кармак всё ещё использовал этот монитор при разработке Doom 3.
### Визуализация
Модули программного рендерера (`ref_soft`) и рендерера с аппаратным ускорением (`ref_gl`) были настолько большими, что я написал про них отдельные разделы.
И снова здесь примечательно то, что ядро даже не знало, какой рендерер подключен: оно просто вызывало указатель функции в структуре. То есть конвейер визуализации был полностью абстрагирован: и кому нужен этот C++?
**Интересный факт:** id Software по-прежнему использует систему координат из игры Wolfenstein 3D 1992 года (по крайней мере, так было в Doom3). Это важно знать при чтении исходного кода рендерера:
В системе id:
* Ось X = лево/право
* Ось Y = перед/зад
* Ось Z = верх/низ
В системе координат OpenGL:
* Ось X = лево/право
* Ось Y = верх/низ
* Ось Z = перед/зад
Поэтому в рендерере OpenGL используется матрица `GL_MODELVIEW` для «исправления» системы координат в каждом кадре с помощью метода `R_SetupGL` (`glLoadIdentity` + `glRotatef`).
### Динамическое подключение
О взаимодействиях ядра/модуля можно сказать многое: я написал отдельный раздел о динамическом подключении.
### Моддинг: gamex86.dll
Чтение этой части проекта оказалось не таким интересным, но отказ от Quake-C для скомпилированного модуля привёл к двум хорошим и одному очень плохому последствию.
Плохое:
* В жертву принесена портируемость, игровой модуль необходимо перекомпилировать под разные платформы с определёнными параметрами компоновщика.
Хорошее:
* Скорость: язык Quake-C игры Quake1 был интерпретируемым кодом, но модуль динамической библиотеки Quake2 `gamex86.dll` является нативным.
* Свобода: моддеры получили доступ ко ВСЕМУ, а не только к тому, что было доступно через Quake-C.
Интересный факт: иронично, что id Software перешла в Quake3 обратно к использованию виртуальной машины (QVM) для игры, искусственного интеллекта и моддинга.
### Мой quake2
В процессе хакинга я немного изменил исходный код Quake2. Крайне рекомендую добавить консоль DOS, чтобы видеть выводимые `printf` данные в процессе, а не ставить игру на паузу для изучения консоли Quake:
Добавить консоль в стиле DOS в окно Win32 довольно просто:
```
// sys_win.c
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
AllocConsole();
freopen("conin$","r",stdin);
freopen("conout$","w",stdout);
freopen("conout$","w",stderr);
consoleHandle = GetConsoleWindow();
MoveWindow(consoleHandle,1,1,680,480,1);
printf("[sys_win.c] Console initialized.\n");
...
}
```
Поскольку я запускал Windows на Mac с помощью Parallels, было сложно нажимать «printscreen» при выполнении игры. Для создания скриншотов я задал клавишу "\*" с цифрового блока:
```
// keys.c
if (key == '*')
{
if (down) //Избегаем автоматического повтора!
Cmd_ExecuteString("screenshot");
}
```
И, наконец, я добавил множество комментариев и схем. Вот «мой» полный исходный код:
[архив](http://fabiensanglard.net/quake2/quake2-3.21.zip).
### Управление памятью
У Doom и Quake1 был собственный диспетчер памяти под названием «Zone Memory Allocation»: при запуске выполнялась `malloc` и блок памяти управлялся с помощью списка указателей. Зону памяти (Memory Zone) можно было пометить для быстрой очистки нужной категории памяти. Zone Memory Allocator (`common.c: Z_Malloc, Z_Free, Z_TagMalloc , Z_FreeTags`) остался в Quake2, но он довольно бесполезен:
* Пометки не используются и распределение/освобождение памяти выполняется поверх `malloc` и `free` (понятия не имею, почему в id Software решили доверить эту работу C Standard Library).
* Детектор переполнения (использующий константу `Z_MAGIC`) тоже никогда не используется
По-прежнему очень полезно измерять потребление памяти благодаря атрибуту `size` в заголовке, вставляемому перед распределением каждого блока памяти:
```
#define Z_MAGIC 0x1d1d
typedef struct zhead_s
{
struct zhead_s *prev, *next;
short magic;
short tag; // для групповой очистки
int size;
} zhead_t;
```
Система кэширования поверхностей имеет собственный диспетчер памяти. Объём распределённой памяти зависит от разрешения и определяется странной формулой, которая однако, очень эффективно защищает от мусора:
```
Первоначальная malloc кэширования поверхностей:
==============================
size = SURFCACHE_SIZE_AT_320X240; //1024*768
pix = vid.width*vid.height;
if (pix > 64000)
size += (pix-64000)*3;
```
«Hunk allocator» используется для загрузки ресурсов (изображений, звуков и текстур). Он довольно хорош, пытается использовать `virtualAlloc` и соотносить данные с размером страницы (8 КБ, несмотря на то, что в Win98 использовался 4 КБ?! Что за дела?!).
И, наконец, есть также множество стеков FIFO **(среди прочего, для хранения интервалов)**, и несмотря на очевидно ограниченные возможности, они работают очень хорошо.
### Управление памятью: трюк с упорядочиванием
Поскольку Quake2 управляет множеством обычных указателей, используется хороший трюк для размещения указателя в 32 битах (или размещения в 8 КБ для минимизации PAGE\_FAULT… несмотря на то, что Windows 98 использовала страницы по 4 КБ).
Расположение страниц (в 8 КБ):
```
int roundUpToPageSize(int size)
{
size = (size + 8191) & ~8191;
return size;
}
```
Расположение памяти (в 4 Б):
```
memLoc = (memLoc + 3) & ~3; // Располжоение в 4-байтном адресе.
```
### Подсистема консоли
Ядро Quake2 содержит мощную систему консоли, активно использующую списки указателей и линейный поиск.
В ней есть три типа объектов:
* Команды: дают указатель функции для заданного строкового значения.
* Cvar: хранят строковое значение для заданного имени строки.
* Псевдоним: предоставляет замену заданного строкового значения.
С точки зрения кода каждый тип объектов имеет список указателей:
```
cmd_function_t *cmd_functions // Список указателей, каждый элемент содержит имя строки и указатель функции: void (*)() .
cvar_t *cvar_vars // Список указателей, каждый элемент содержит имя строки и строковое значение.
cmdalias_t *cmd_alias // Список указателей, каждый элемент содержит имя строки и псевдоним строки.
```
При вводе каждой строки в консоль она сканируется, дополняется (с помощью псевдонимов и соответствующих cvar), а затем разбивается на токены, хранящиеся в двух глобальных переменных: `cmd_argc` и `cmd_argv`:
```
static int cmd_argc;
static char *cmd_argv[MAX_STRING_TOKENS];
```
Пример:
Каждый идентифицированный в буфере токен копируется `memcpy` в место, указанное `malloc` записью `cmd_argv`. Процесс довольно неэффективный и показывает, что этой подсистеме уделили мало внимания. И это, кстати, полностью оправданно: она редко используется и мало влияет на игру, так что оптимизация не стоила усилий. Лучшим подходом был бы патчинг исходной строки на месте и запись значения указателя для каждого токена:
Поскольку токены находятся в массиве аргументов, то `cmd_argv[0]` проверяется очень медленным и линейным способом на соответствие всем функциям, объявленным в списке указателей функций. Если соответствие находится, то вызывается указатель функции.
Если соответствие не находится, то список указателей псевдонимов линейно проверяется для определения того, является ли токен вызовом функции. Если псевдоним заменяет вызов функции, то она вызывается.
И, наконец, если ничего из вышеперечисленного не срабатывает, то Quake2 обрабатывает токен как объявление переменной (или как её обновление, если переменная уже находится в списке указателей).
Здесь выполняется множество линейных поисков в списке указателей: идеальным выходом было бы использование таблицы хэшей. Она позволила бы достичь сложности O(n) вместо O(n²).
**Интересный факт о парсинге 1**: таблица ASCII организована умно: при парсинге строки для создания токенов можно пропустить разделители и символы пробела, просто проверяя, меньше ли ли символ i символа ' ' (пробела).
```
char* returnNextToken(char* string)
{
while (string && *string < ' ')
string++;
return string;
}
```
**Интересный факт о парсинге 2**: таблица ASCII была организована очень умно: можно было преобразовать символ c в целое число следующим образом:
int value = c — '0';
```
int charToInt(char v)
{
return v - '0' ;
}
```
Кэширование значения cvar:
Поскольку поиск места cvar в памяти (`Cvar_Get`) в этой системе имеет сложность O(n²) (линейный поиск + `strcmp` для каждой записи), рендереры кэшируют место cvar в памяти:
```
//Кэширование переменной
cvar_t *crosshair;
// На этапе инициализации движка, здесь создаётся
// и возвращается место Cvar в памяти.
crosshair = Cvar_Get ("crosshair", "0", CVAR_ARCHIVE); //ЭТО МЕЕЕДЛЕННО
//В рендерере, при выполнении программы.
void SCR_DrawCrosshair (void)
{
if (!crosshair->value) //ЭТО БЫСТРО
return;
}
```
Доступ к этому значению затем можно получить за O(1).
### Защита от злодеев
Для защиты от читерства было вставлено несколько механизмов:
* Даже несмотря на то, что у UDP есть собственная CRC, для защиты от модифицирования к каждому пакету добавляется Quake CRC (`COM_BlockSequenceCRCByte`).
* Перед началом детматча уровни хэшируются с помощью MD4. Этот хэш отправляется серверу, чтобы он убедился, что клиент не использует модифицированные карты (`Com_BlockChecksumM`).
* Есть даже система, проверяющая количество команд в секунду от каждого игрока (`SV_ClientThink`), но я не знаю точно, насколько она была эффективна.
### Внутренний ассемблер
Как и в каждой версии Quake, часть полезных функций была оптимизирована с помощью ассемблера (однако здесь ещё нет следов знаменитого «быстрого обратного квадратного корня», который присутствовал в Quake3).
Быстрое абсолютное значение 32-битного числа с плавающей запятой (большинство компиляторов сегодня делает это автоматически):
```
float Q_fabs (float f)
{
int tmp = * ( int * ) &f
tmp &= 0x7FFFFFFF;
return * ( float * ) &tmp
}
```
Быстрое преобразование Float в Integer
```
__declspec( naked ) long Q_ftol( float f )
{
static int tmp;
__asm fld dword ptr [esp+4]
__asm fistp tmp
__asm mov eax, tmp
__asm ret
}
```
### Статистика кода
Анализ кода в Cloc показал, что всего в коде 138 240 строк. Как обычно, это число НЕ даёт представления о вложенных усилиях, потому что от многого отказались в итеративном цикле версий движка, но, как мне кажется, это хороший индикатор общей сложности движка.
```
$ cloc quake2-3.21/
338 text files.
319 unique files.
34 files ignored.
http://cloc.sourceforge.net v 1.53 T=3.0 s (96.0 files/s, 64515.7 lines/s)
-------------------------------------------------------------------------------
Language files blank comment code
-------------------------------------------------------------------------------
C 181 24072 19652 107757
C/C++ Header 72 2493 2521 14825
Assembly 22 2235 2170 8331
Objective C 6 1029 606 4290
make 2 436 67 1739
HTML 1 3 0 1240
Bourne Shell 2 17 6 54
Teamcenter def 2 0 0 4
-------------------------------------------------------------------------------
SUM: 288 30285 25022 138240
-------------------------------------------------------------------------------
```
**Примечание:** весь ассемблерный код предназначен для созданного вручную программного рендерера.
### Инструменты, рекомендуемые для работы над хакингом Quake2
* Visual Studio Express 2008.
* Бесплатное демо Quake2 с веб-сайта id.
* Написанный мной [Pak explorer](http://fd.fabiensanglard.net/quake2/MyPakExplorer.zip).
* [Wally](http://fd.fabiensanglard.net/quake2/wally1.55b.zip): средство просмотра формата изображений WAL.
* Знаменитый инструмент исследования pak ([PakExpl](http://fd.fabiensanglard.net/quake2/pakexplr.zip))
* [Статья о формате BSP](http://www.flipcode.com/archives/Quake_2_BSP_File_Format.shtml) ([зеркало](http://fd.fabiensanglard.net/quake2/quake2_bsp_format.zip)) с сайта FlipCode.
* Профайлеры C: VTune(intel), CodeAnalysis(AMD), Visual Studio Team Profiler (лучший, по-моему).
* Большой 24/30-дюймовый экран.
* Клавиатура IBM Model M.
Quake2 состоит из одного ядра и двух модулей, загружаемых в процессе выполнения: Game и Renderer. Очень интересно, что благодаря полиморфизму к ядру можно подключить всё что угодно.
Прежде чем продолжать чтение, рекомендую убедиться, что вы хорошо понимаете принцип работы виртуальной памяти с помощью этой [замечательной статьи](http://www.ualberta.ca/CNS/RESEARCH/LinuxClusters/mem.html) ([зеркало](http://web.archive.org/web/20120924094202/http://www.ualberta.ca/CNS/RESEARCH/LinuxClusters/mem.html)).
### Полиморфизм в C с динамическим подключением
Динамическое подключение даёт множество преимуществ:
* Рендерер:
+ Чистый код ядра Quake2, снижение энтропии кода, отсутствие повсюду безумных `#ifdef`.
+ Выпуск игры с несколькими рендерерами (программный, openGL).
+ Рендерер можно менять при выполнении игры.
+ Возможность создания нового рендерера для оборудования, созданного после выпуска игры (Glide, Verity).
* Моддинг игры:
+ Больше возможностей для авторов модов, игру можно полностью изменить через game.dll.
+ Полная скорость игры в модах, нет необходимости полагаться на QuakeC и Quake Virtual Machine.
+ Нет нужды изучать QuakeC, DLL были написаны на C.
Но Quake2 был написан на C, который не является объектно-ориентированным языком программирования, поэтому возник вопрос: «Как реализовать полиморфизм на языке, который не является ОО?»
Техника имитации ОО похожа на способ, применённый в JAVA и C++: использование структур, содержащих указатели функций.
Поэтому были использованы четыре структуры для обмена указателями функций: `refimport_t` и `refexport_t` действовали в качестве контейнера для обмена указателями функций при загрузке модуля рендерера. `game_import_t` и `game_export_t` использовались при загрузке модуля игры.
### Небольшая иллюстрация лучше долгой речи
Шаг 1: на начальном этапе:
* `quake2.exe` содержит структуру `ref_OpenGL_t` с указателями функций на `NULL` (серого цвета).
* Модуль DLL (`ref_opengl.dll`) также содержит структуру `kernel_fct_t` с указателями функций на `NULL` (серого цвета).
Задача процесса заключается в передаче адресов функций, чтобы каждая из частей могла вызывать другие.
Шаг 2: ядро, вызывающее функцию, заполняет структуру, содержащую указатели на её собственные функции, и отправляет эти значения DLL.
Шаг 3: принимающая DLL копирует указатели функций ядра и возвращает структуру, содержащую её собственные адреса функций.
Процесс с настоящими именами подробно описан в двух следующих разделах.
### Библиотека рендерера
Метод, получающий модуль рендерера, называется `VID_LoadRefresh`. Он вызывается каждый кадр, чтобы Quake мог переключаться между рендерерами (но из-за необходимой рендереру предварительной обработки уровень нужно будет перезапустить).
Вот что происходит на стороне ядра Quake2:
```
refexport_t re;
qboolean VID_LoadRefresh( char *name )
{
refimport_t ri;
GetRefAPI_t GetRefAPI;
ri.Sys_Error = VID_Error;
ri.FS_LoadFile = FS_LoadFile;
ri.FS_FreeFile = FS_FreeFile;
ri.FS_Gamedir = FS_Gamedir;
ri.Cvar_Get = Cvar_Get;
ri.Cvar_Set = Cvar_Set;
ri.Vid_GetModeInfo = VID_GetModeInfo;
ri.Vid_MenuInit = VID_MenuInit;
ri.Vid_NewWindow = VID_NewWindow;
GetRefAPI = (void *) GetProcAddress( reflib_library, "GetRefAPI" );
re = GetRefAPI( ri );
...
}
```
В представленном выше коде ядро Quake2 получает указатель функции метода `GetRefAPI` от DLL рендерера с помощью `GetProcAddress` (встроенный метод win32).
Вот что происходит в `GetRefAPI` внутри DLL рендерера:
```
refexport_t GetRefAPI (refimport_t rimp )
{
refexport_t re;
ri = rimp;
re.api_version = API_VERSION;
re.BeginRegistration = R_BeginRegistration;
re.RegisterModel = R_RegisterModel;
re.RegisterSkin = R_RegisterSkin;
re.EndRegistration = R_EndRegistration;
re.RenderFrame = R_RenderFrame;
re.DrawPic = Draw_Pic;
re.DrawChar = Draw_Char;
re.Init = R_Init;
re.Shutdown = R_Shutdown;
re.BeginFrame = R_BeginFrame;
re.EndFrame = GLimp_EndFrame;
re.AppActivate = GLimp_AppActivate;
return re;
}
```
В конце устанавливается двусторонний обмен данными между ядром и DLL. Он является полиморфным, потому что DLL рендерера возвращает внутри структуры свои собственные адреса функций и ядро Quake2 не видит разницы, оно всегда вызывает одинаковый указатель функции.
### Библиотека игры
Точно такой же процесс выполняется с библиотекой игры на стороне ядра:
```
game_export_t *ge;
void SV_InitGameProgs (void)
{
game_import_t import;
import.linkentity = SV_LinkEdict;
import.unlinkentity = SV_UnlinkEdict;
import.BoxEdicts = SV_AreaEdicts;
import.trace = SV_Trace;
import.pointcontents = SV_PointContents;
import.setmodel = PF_setmodel;
import.inPVS = PF_inPVS;
import.inPHS = PF_inPHS;
import.Pmove = Pmove;
// Пропущено назначение 30 указателей функций
ge = (game_export_t *)Sys_GetGameAPI (&import);
ge->Init ();
}
void *Sys_GetGameAPI (void *parms)
{
void *(*GetGameAPI) (void *);
//[...]
GetGameAPI = (void *)GetProcAddress (game_library, "GetGameAPI");
if (!GetGameAPI)
{
Sys_UnloadGame ();
return NULL;
}
return GetGameAPI (parms);
}
```
Вот что происходит на стороне DLL игры:
```
game_import_t gi;
game_export_t *GetGameAPI (game_import_t *import)
{
gi = *import;
globals.apiversion = GAME_API_VERSION;
globals.Init = InitGame;
globals.Shutdown = ShutdownGame;
globals.SpawnEntities = SpawnEntities;
globals.WriteGame = WriteGame;
globals.ReadGame = ReadGame;
globals.WriteLevel = WriteLevel;
globals.ReadLevel = ReadLevel;
globals.ClientThink = ClientThink;
globals.ClientConnect = ClientConnect;
globals.ClientDisconnect = ClientDisconnect;
globals.ClientBegin = ClientBegin;
globals.RunFrame = G_RunFrame;
globals.ServerCommand = ServerCommand;
globals.edict_size = sizeof(edict_t);
return &globals
}
```
### Использование указателей функций
После передачи указателей методов включается полиморфизм. Здесь в коде ядро «перепрыгивает» к разным модулям:
Рендерер «перепрыгивает» к `SCR_UpdateScreen`:
```
// это метод quake.exe, рендерер абстрагирован, поэтому quake2.exe не знает, какой рендерер используется.
SCR_UpdateScreen()
{
// re - это struct refexport_t, BeginFrame указывает на BeginFrame в DLL.
re.BeginFrame( separation[i] );
// С этого момента методы принадлежат DLL
SCR_CalcVrect()
SCR_TileClear()
V_RenderView()
SCR_DrawStats
SCR_DrawNet
SCR_CheckDrawCenterString
SCR_DrawPause
SCR_DrawConsole
M_Draw
SCR_DrawLoading
re.EndFrame();
// Возврат к методам quake.exe.
}
```
Игра «перепрыгивает» к `SV_RunGameFrame`:
```
void SV_RunGameFrame (void)
{
sv.framenum++;
sv.time = sv.framenum*100; // не выполняется, если игра поставлена на паузу
if (!sv_paused->value || maxclients->value > 1)
ge->RunFrame ();
....
}
}
```
### Программный рендерер
Программный рендерер Quake2 — это самый большой, наиболее сложный, а потому самый интересный модуль для исследований.
Здесь нет никаких скрытых механизмов, начиная с диска и заканчивая пикселями.
Весь код написан аккуратно и оптимизирован вручную. Он — последний в своём роде и ознаменовал конец эры. Позже индустрия полностью перешла исключительно к рендерингу с аппаратным ускорением.
Фундаментальное отличие программного рендеринга и рендеринга OpenGL — использование системы 256-цветной палитры вместо привычной сегодня системы 24-битного True Color RGB:
Если сравнивать рендерер с аппаратным ускорением и программный рендерер, то заметим два наиболее очевидных различия:
* Отсутствие цветного освещения
* Отсутствие билинейной фильтрации
Но за исключением этого движку удавалось выполнять потрясающую работу с помощью очень умного использования палитры, о котором я расскажу позже:
* Быстрый выбор цветовых градиентов (64 значения).
* Полноэкранное смешивание цветов постэффектов.
* Попиксельная просвечиваемость.
Сначала загружается палитра Quake2 из архивного файла PAK `pics/colormap.pcx`:
**Примечание:** значение чёрного цвета равно 0, белого — 15, зелёного — 208, красного — 240 (в левом нижнем углу), прозрачного — 255.
Первым делом выполняется перестановка этих 256 цветов в соответствии с `pics/colormap.pcx`:
Такая схема 256x320 используется как таблица поиска, и это необыкновенно умно, потому что даёт множество интересных возможностей:
* 64 линий для имитации цветовых градиентов: первая линия создана из 256 цветов «развёрнутой» палитры. Остальные 63 значения в каждом столбце представляют в вертикальном виде градиент исходного цвета, имитированного остальными 255 цветами. Это позволяет создать очень простой и быстрый механизм выбора градиентов:
+ Сначала выбирается цвет из палитры в диапазоне [0,255] (который получается из цветовой текстуры).
+ Затем прибавляется x\*256, где x находится в диапазоне [0,63] для получения затемнённой вариации выбранного изначально цвета (он берётся из текстуры карты освещения).
В результате получаем 64 оттенка 256 цветов. И всё это всего лишь из 256 цветов статичной палитры. Потрясающе.
* Оставшаяся часть изображения создаётся из квадратов 16x16, что позволяет использовать смешивание пикселей на основе палитры. Чётко видно, что все квадраты созданы из исходного цвета, конечного цвета и промежуточных цветов. Именно так в игре реализуется просвечиваемость воды. Например, в левом верхнем квадрате смешиваются чёрный и белый цвета.
**Интересный факт:** программный рендерер Quake2 изначально благодаря технологии MMX должен был быть основан на RGB, а не на палитре, о чём Джон Кармак заявил после выпуска Quake1 в этом видео (момент на 10 минуте 17 секунде):
MMX — это SIMD-технология, позволявшая работать со всеми тремя каналами RGB с затратой всего одного канала, обеспечивая таким образом смешивания с допустимым потреблением ресурсов ЦП. Я предполагаю, что от неё отказались по следующим причинам:
* Процессоры Pentium с поддержкой MMX были мало распространены в 1997 году, а программный рендерер предполагалось использовать на машинах с дешёвой конфигурацией.
* Передача цветов RGB (16 бит или 32 бит на пиксель) вместо цветов палитры (8 бит на пиксель) занимала слишком большую долю пропускной способности, и невозможно было достичь приемлемой частоты кадров.
### Общая архитектура
Определившись с основным ограничением (палитрой), можно перейти к общей архитектуре рендерера. Его философия использовала сильные стороны Pentium (вычисления с плавающей точкой) для снижения влияния слабых сторон: скорости шины, влиявшей на запись пикселей в память. Бóльшая часть пути рендеринга сосредоточена на достижении *нулевой* перерисовки. В сущности, путь программного рендеринга аналогичен способу программного рендеринга Quake 1. В нём для обхода карты активно использовались BSP и PVS (набор потенциально видимых полигонов) для получения набора полигонов, которые нужно рендерить. Каждый кадр рендерятся три различных элемента:
* Карта: с помощью алгоритма связного построчного построения изображения на основе BSP (подробнее о нём позже).
* Сущности: либо как «спрайты» (окна), либо как «объекты» (игроки, враги) с помощью простого алгоритма построчного построения изображения.
* Частицы.
Примечание: если вы не знакомы с этими «старыми» алгоритмами, крайне рекомендую прочитать главы 3.6 и 15.6 книги [Computer graphics: principles and practice](http://books.google.com/books?id=-4ngT05gmAQC&printsec=frontcover&source=gbs_ge_summary_r&cad=0#v=onepage&q&f=false) Джеймса Д. Фоли (James D. Foley). Также можно найти множество информации в главах 59-70 книги [Graphics programming black book](http://www.gamedev.net/page/resources/_/reference/programming/140/283/graphics-programming-black-book-r1698) Майкла Абраша (Michael Abrash).
Вот псевдокод высокого уровня:
1. Рендеринг карты
* Проход по предварительно обработанному дереву BSP для определения кластера, в котором мы находимся.
* Запрос в базу данных PVS об этом конкретном кластере: получение и распаковка PVS.
* С помощью битового вектора PVS: помечаем как видимый каждый полигон, принадлежащий к кластеру, считающемуся потенциально видимым.
* Повторный проход по BSP. В этот раз проверяется, воздействует ли на видимый кластер какое-нибудь динамическое освещение. Если воздействует, то помечаем его идентификационным номером источника освещения.
* Теперь у нас есть список потенциально видимых полигонов с информацией об освещении:
+ Снова используем BSP, проходим спереди назад:
- Проверяем на присутствие в пирамиде видимости и проецируем все полигоны на экран: строим глобальную таблицу рёбер.
- Рендеринг поверхности каждой грани (поверхность=текстура+карта освещения) для кэширования в ОЗУ.
- Вставка указателя поверхности в стек поверхностей (используется позже для связности).
+ Генерирование с помощью стека поверхности и глобальной таблицы рёбер таблицы активных рёбер и построчный рендеринг экрана сверху вниз. Использование кэша поверхностей в ОЗУ в качестве текстуры. Запись интервалов в закадровый буфер и заполнение Z-буфера.
2. Рендеринг сущностей, использование Z-буфера для определения видимых частей сущностей.
3. Рендеринг просвечивающих текстур с помощью остроумного трюка с палитрой для попиксельного вычисления индексов палитры просвечивания.
4. Рендеринг частиц.
5. Добавление постэффектов (полноэкранное смешивание с красным цветов в случае снижения здоровья).
**Визуализация экрана:** индексы палитры записываются в закадровый буфер. В зависимости от режима (полноэкранный/оконный) используется DirectDraw или GDI. После завершения закадрового буфера кадров он передаётся в экранный буфер видеокарты (GDI=>`rw_dib.c` DirectDraw=>`rw_ddraw.c`) с помощью либо `BitBlt` `WinGDI.h` или `BltFast` `ddraw.h`.
### DirectDraw или GDI
Те проблемы, с которыми программистам приходилось встречаться в 1997 году, просто удручали: Джон Кармак оставил в исходном коде забавный комментарий:
```
// может быть отрицательным для глупых DIB
```
Если Quake2 работал в полноэкранном режиме с DirectDraw, он должен был отрисовывать закадровый буфер сверху вниз: так он и отображался на экране. Но когда он выполнялся в оконном режиме с GDI, то нужно было отрисовывать закадровый буфер в буфере DIB… отражённым по вертикали, потому что большинство драйверов производителей видеокарт передавало образ DIB из ОЗУ в видеопамять в отражённом режиме (стоит задаться вопросом, действительно ли «I» в аббревиатуре GDI обозначает «Independent»).
Поэтому переход по закадровому буферу кадров должен был стать абстрактным. Нужны были структура и значения, инициализируемые по-разному для абстрагирования от этих различий. Это примитивный способ реализации полиморфизма в C.
```
typedef struct
{
pixel_t *buffer; // Закадровый буфер кадров
pixel_t *colormap; // Палитра цветового градиента: размер 256 * VID_GRADES
pixel_t *alphamap; // Палитра просвечиваемости: карта просвечиваемости 256 * 256
int rowbytes; // может быть больше ширины, если отображается в окне
// может быть отрицательным для глупых DIB
int width;
int height;
} viddef_t;
viddef_t vid ;
```
В зависимости от способа, необходимого для отрисовки буфера кадров, `vid.buffer` инициализировался как первый пиксель:
* Первой строки для DirectDraw
* Последней строки для WinGDI/DBI
Для перехода вверх или вниз `vid.rowbytes` инициализировался как `vid.width` или как `-vid.width`.
Теперь для перехода не важно, как выполняется отрисовка: нормально или с вертикальным отражением:
```
// Первый пиксель первой строки
byte* pixel = vid.buffer + vid.rowbytes * 0;
// Первый пиксель последней строки
pixel = vid.buffer + vid.rowbytes * (vid.height-1);
// Первый пиксель строки i (нумерация строк начинается с 0)
pixel = vid.buffer + vid.rowbytes * i;
// Очистка буфера кадров заливкой чёрным цветом
memset(vid.buffer,0,vid.height*vid.height) ; // <-- Это работает в полноэкранном режиме DirectDraw
// но вызывает сбой в оконном режиме!
```
Этот трюк позволяет конвейеру визуализации не беспокоиться о том, как выполняется передача на нижнем уровне, и я думаю, что это довольно примечательно.
### Предварительная обработка карты
Прежде чем глубже закапываться в код, нужно понять две важные базы данных, генерируемых при предварительной обработке карты:
* Двоичное разбиение пространства (BSP)/ набор потенциально видимых полигонов (PVS).
* Текстура карты освещения на основе излучения.
### Разрезание BSP, генерирование PVS
Рекомендую глубже изучить двоичное разбиение пространства:
* [Wikipedia](http://en.wikipedia.org/wiki/Binary_space_partitioning) ([на русском](https://ru.wikipedia.org/wiki/%D0%94%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D0%BE%D0%B5_%D1%80%D0%B0%D0%B7%D0%B1%D0%B8%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BF%D1%80%D0%BE%D1%81%D1%82%D1%80%D0%B0%D0%BD%D1%81%D1%82%D0%B2%D0%B0)).
* Статья [The Idea of BSP Trees](http://downloads.gamedev.net/pdf/gpbb/gpbb59.pdf) Майкла Абраша.
* Статья [Compiling BSP Trees](http://downloads.gamedev.net/pdf/gpbb/gpbb60.pdf) Майкла Абраша.
* Статья в ASCII-стиле, [старая библия](http://www.gamers.org/dhs/helpdocs/bsp_faq.html).
Как и в Quake1, карты Quake2 проходят серьёзную предварительную обработку: их объём рекурсивно разрезается как на рисунке ниже:
В конце концов карта полностью разрезается на выпуклые 3D-пространства (называемые кластерами). Как и в Doom с Quake1, их можно использовать для сортировки всех полигонов спереди назад и сзади вперёд.
Отличное дополнение — это PVS, набор битовых векторов (по одному на кластер). Рассматривайте его как базу данных, к которой можно осуществлять запросы и получать кластеры, потенциально видимые из любого кластера. Эта база данных огромна (5 МБ), но эффективно сжата до нескольких сотен килобайт и хорошо умещается в ОЗУ.
**Примечание:** для сжатия PVS используется компрессия, пропускающая только значения 0x00, этот процесс объяснён ниже.
### Излучение
Как и в Quake1, влияние освещения уровня рассчитывается предварительно и хранится в текстурах, которые называются картами освещения. Однако в отличие от Quake1 Quake2 использует в предварительных расчётах излучение и цветное освещение. Карты освещения затем сохраняются в архиве `PAK` и используются в процессе выполнения игры:
Пара слов от одного из создателей: Майкл Абраш в «Black Book of Programming» (глава «Quake: a post-mortem and a glimpse into the future»):
> Самые интересные изменения графики заключались в предварительных расчётах, куда Джон добавил поддержку излучаемого света...
> Обработка уровней Quake 2 занимала до часа времени.
>
>
>
> (Однако стоит заметить, что в него входило создание BSP, расчёт PVS и излучаемого света, который я рассмотрю позже.)
Если вы хотите узнать об излучаемом освещении, то прочитайте эту потрясающе хорошо иллюстрированную [статью](http://freespace.virgin.net/hugo.elias/radiosity/radiosity.htm) ([зеркало](http://fabiensanglard.net/quake2/radiosity.zip)): это просто шедевр.
Вот первый уровень с наложенной текстурой излучения: к сожалению, потрясающие цвета RGB необходимо было ресемплировать для программного рендерера в градации серого (подробнее об этом позже).
Низкое разрешение карты освещения здесь бросается в глаза, но поскольку она проходит билинейную фильтрацию (да, даже в программном рендерере), то конечный результат, соединённый с цветовой текстурой, очень хорош.
Интересный факт: карты освещения могут иметь любой размер от 2x2 до 17x17 (несмотря на заявленный максимальный размер 16 в [статье](http://www.flipcode.com/archives/Quake_2_BSP_File_Format.shtml) flipcode ([зеркало](http://fabiensanglard.net/quake2/flipcode.zip))) и не обязаны быть квадратными.
### Архитектура кода
Бóльшая часть кода программного рендерера находится в методе `R_RenderFrame`. Вот его краткое описание, более подробный анализ читайте в моих [предварительных заметках](http://fabiensanglard.net/quake2/softwareRenderer.notes.php).
* `R_SetupFrame`: получает текущую точку обзора обходом BSP (вызов `Mod_PointInLeaf`), сохраняет clusterID точки обзора в `r_viewcluster`.
* `R_MarkLeaves`: для текущего кластера обзора (`r_viewcluster`) получает и разархивирует PVS. Использует PVS, чтобы пометить видимые грани.
* `R_PushDlights`: снова использует BSP для обхода граней спереди назад. Если грань помечена как видимая, проверяет, воздействует ли на неё освещение.
* `R_EdgeDrawing`: визуализация уровня.
+ `R_RenderWorld`: обход BSP спереди назад
- Проецирование всех видимых полигонов в экранное пространство: построение глобальной таблицы рёбер.
- Отправка показателя каждой видимой поверхности в стек поверхностей (это выполняется для связности).
+ `R_ScanEdges`: рендеринг уровня строки за строкой, сверху вниз. Для каждой строки:
- `R_InsertNewEdges`: использование глобальной таблицы рёбер для инициализации таблицы активных рёбер, использование её в качестве набора событий.
- `(*pdrawfunc)()`: генерирование интервалов, но они не записываются в закадровый буфер. Вместо этого интервалы записываются в буфер стека интервалов. Причина будет объяснена ниже.
- `D_DrawSurfaces`: если буфер стека интервалов заполнен, рендеринг всех интервалов в закадровый буфер и очистка стека интервалов.
* `R_DrawEntitiesOnList`: рендеринг сущностей, не являющихся BModel (BModel — это элемент уровня). Рендеринг спрайтов и моделей объектов (игроков, врагов, боеприпасов)...
* `R_DrawAlphaSurfaces`: использование остроумного трюка для выполнения попиксельного смешивания
* `R_CalcPalette`: расчёт постэффектов, например, смешивания цветов (при получении урона, собирании предметов и т.п.)
```
R_RenderFrame
{
R_SetupFrame // Установка указателя функции pdrawfunc в зависимости от того, для чего делается рендеринг: GDI или DirectDraw
{
Mod_PointInLeaf // Определение того, что находится в текущем кластере обзора (обходом BSP-дерева) и сохранение этой информации в r_viewcluster
}
R_MarkLeaves // Получение и разархивация для текущего кластера обзора (r_viewcluster)
// набора PVS
R_PushDlights // Пометка полигонов, на которые воздействует освещение, для каждого dlight_t* прошедшего через r_newrefdef.dlights.
// Построение глобальной таблицы граней и их рендеринг через таблицу активных граней
R_EdgeDrawing // Рендеринг уровня
{
R_BeginEdgeFrame // Установка указателя функции pdrawfunc, используемого позже в этой функции
R_RenderWorld // Построение глобальной таблицы граней
// Также заполнение стека поверхностей и подсчёт количества поверхностей для рендеринга (surf_max - это максимальное значение)
R_DrawBEntitiesOnList// Понятия не имею, что делает этот фрагмент.
R_ScanEdges // Использование глобальной таблицы граней для сохранения таблицы активных граней: отрисовка мира как растровых строк
// Запись в Z-буфер (но не чтение)
{
for (iv=r_refdef.vrect.y ; ivpics/colormap.pcx.
R_SetLightLevel // Сохранение значение освещения для поиска сервером (БОЛЬШОЙ ХАК!)
R_CalcPalette // Изменение палитры (при потере здоровья или собирании предметов), для изменения всех цветов
}
```
### R\_SetupFrame: управление BSP
Обход дерева двоичного разбиения пространства выполняется повсюду в коде. Это мощный механизм со стабильной скоростью, позволяющий сортировать полигоны спереди назад или сзади вперёд. Чтобы его понять, нужно разобраться со структурой `cplane_t`:
```
typedef struct cplane_s
{
vec3_t normal;
float dist;
} cplane_t;
```
Для вычисления расстояния или точки от секущей плоскости в узле нужно просто вставить её координаты в уравнение плоскости:
```
int d = DotProduct (p,plane->normal) - plane->dist;
```
Благодаря знаку `d` мы узнаём, находимся ли мы перед или за плоскостью, и можем выполнить сортировку. Этот процесс использовался в движках начиная с Doom и заканчивая Quake3.
### R\_MarkLeaves: групповая разархивация PVS
То, как я понимал разархивацию PVS в моём [анализе исходного кода Quake 1](https://habrahabr.ru/post/324804/), было полностью неправильным: кодируется не расстояние между битами 1, а только количество записываемых байтов 0x00. В PVS выполняется только групповое сжатие 0x00: при считывании сжатого потока:
* Если из сжатого PVS считывается ненулевой байт, то он записывается в разархивированную версию.
* Если из сжатого PVS считывается байт 0x00, то следующий байт показывает, какое количество байтов нужно пропустить.
В первом случае ничего не сжимается. Групповое сжатие выполняется только во втором случае:
```
byte *Mod_DecompressVis (byte *in, model_t *model)
{
static byte decompressed[MAX_MAP_LEAFS/8]; // Лист = 1 бит, поэтому всего 65536 / 8 = 8 192 байт
// нужно для хранения полностью разархивированного PVS.
int c;
byte *out;
int row;
row = (model->vis->numclusters+7)>>3;
out = decompressed;
do
{
if (*in) // Это ненулевой байт, записываем его в том же виде и продолжаем и переходим к следующему сжатому байту.
{
*out++ = *in++;
continue;
}
c = in[1]; // Мы не "продолжили", поэтому это нулевой байт: считываем следующий байт (in[1]) и записываем
in += 2; // соответствующее количество байтов в разархивированный PVS.
while (c)
{
*out++ = 0;
c--;
}
} while (out - decompressed < row);
return decompressed;
}
```
Можно пропустить до 255 байт (255\*8 листьев), при необходимости после них нужно снова добавить ноль с числом, которое нужно пропустить у следующих 255 байт. То есть пропуск 511 байт (511\*8 листьев) занимает 4 байта: 0 — 255 — 0 — 255
Пример:
```
// Пример системы с 80 листьями, представленная в 10 байтах: видимый=1, невидимый=0
Двоичный разархивированный PVS
0000 0000 0000 0000 0000 0000 0000 0000 0011 1100 1011 1111 0000 0000 0000 0000 0000 0000 0000 0000
Десятичный разархивированный PVS
0x00 0x00 0x00 0x00 0x39 0xBF 0x00 0x00 0x00 0x00
// !! СЖАТИЕ!!
Двоичный сжатый PVS
0000 0000 0000 1000 0011 1100 1011 1111 0000 0000 0000 1000
Десятичный сжатый PVS
0x00 0x04 0x39 0xBF 0x00 0x04
```
После разархивирования PVS текущего кластера, каждая отдельная грань, принадлежащая кластеру, считающемуся в PVS видимым, тоже помечается как видимая:
В: как проверить видимость кластера с заданным идентификатором `i` с помощью разархивированной PVS?
О: битовым И между байтом i/8 PVS и 1 << (i % 8)
```
char isVisible(byte* pvs, int i)
{
// i>>3 = i/8
// i&7 = i%8
return pvs[i>>3] & (1<<(i&7))
}
```
Точно как и в Quake1, здесь есть хороший трюк, используемый для пометки полигона как видимого: вместо использования флагов и сброса каждого из них в начале каждого кадра применяется `int`. При начале каждого кадра счётчик кадров `r_visframecount` увеличивается на единицу в `R_MarkLeaves`. После разархивировании PVS все зоны помечаются как видимые присвоением полю `visframe` текущего значения `r_visframecount`.
Позже в коде видимость узла/кластера всегда проверяется следующим способом:
```
if (node->visframe == r_visframecount)
{
// Узел видимый
}
```
### R\_PushDlights: динамическое освещение
Для каждого идентификатора lightID источника активного динамического освещения выполняется рекурсивный обход BSP начиная с положения источника освещения. Вычисляется расстояние между источником и кластером, и если интенсивность освещения больше, чем расстояние от кластера, то все поверхности в кластере помечаются как подверженные воздействию этого идентификатора источника.
**Примечание:** поверхности помечаются с помощью двух полей:
* `dlightframe` — это флаг `int`, используемый так же, как в случае пометки видимости кластеров (вместо сброса всех флагов в каждом кадре увеличивается глобальная переменная `r_dlightframecount`. Чтобы свет воздействовал, `r_dlightframecount` должен быть равен `surf.dlightframe`.
* `dlightbits` — это битовый вектор `int`, используемый для хранения индексов различных массивов источников освещения, воздействующих на данную грань.
### R\_EdgeDrawing: визуализация уровня
`R_EdgeDrawing` — это монстр программного рендерера, наиболее сложный для понимания. Чтобы разобраться с ним, нужно посмотреть на основную структуру данных:
Стек `surf_t` (действующий в качестве прокси `m_surface_t`) размещается в стеке ЦП.
```
//Система стека поверхностей
surf_t *surfaces ; // Массив стека поверхностей
surf_t *surface_p ; // Вершина стека поверхностей
surf_t *surf_max ; // Верхний предел стека поверхностей
// поверхности генерируются bsp-деревом в порядке "сзади вперёд", поэтому если указатель
// больше другого, то должен отрисовываться перед
// surfaces[1] как фон, и используется как стек активных поверхностей
Note: первый элемент surfaces - это пустая поверхность
Note: второй элемент в surfaces - это фоновая поверхность
```
Этот стек заполняется при обходе BSP спереди назад. Каждый видимый полигон вставляется в стек как прокси поверхности. Позже, при обходе таблицы активных рёбер для генерирования строки экрана он позволяет очень быстро увидеть, какой полигон находится перед всеми остальными простым сравнением адреса в памяти (чем ниже в стеке, тем ближе к точке обзора). Именно так реализуется «связность» для алгоритма преобразования построчного построения изображения.
Примечание: каждый элемент стека также имеет список указателей (называемый цепочкой текстур), указывающий на элементы в стеке буфера интервалов (рассмотренном ниже). Интервалы хранятся в буфере и отрисовываются из цепочке текстур для потекстурной группировки интервалов и максимизации буфера предварительного кэширования ЦП.
Стек инициализируется в самом начале `R_EdgeDrawing`:
```
void R_EdgeDrawing (void)
{
// Общий размер: 64 КБ
surf_t lsurfs[NUMSTACKSURFACES +((CACHE_SIZE - 1) / sizeof(surf_t)) + 1];
surfaces = (surf_t *) (((long)&lsurfs[0] + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1));
surf_max = &surfaces[r_cnumsurfs];
// поверхность 0 на самом деле не существует; она пуста, потому что индекс 0
// используется для того, чтобы показать, что к поверхности не присоединены рёбра
surfaces--;
R_SurfacePatch ();
R_BeginEdgeFrame (); // surface_p = &surfaces[2];
// фон - это поверхность 1,
// поверхность 0 - это пустышка
R_RenderWorld
{
R_RenderFace
}
R_DrawBEntitiesOnList
R_ScanEdges // Запись Z-буфера (но без чтения)
{
for (iv=r_refdef.vrect.y ; iv
```
Вот подробности:
* `R_BeginEdgeFrame`: очистка глобальной таблицы рёбер с последнего кадра.
* `R_RenderWorld`: обход BSP (учтите, что он НЕ рендерит ничего на экране):
+ Каждая поверхность, считающаяся видимой, добавляется в стек с прокси `surf_t`.
+ Проецирование вершин всех полигонов в экранное пространство и заполнение глобальной таблицы рёбер.
+ Также генерирование значения 1/Z для всех вершин, чтобы можно было сгенерировать Z-буфер с интервалами.
* `R_DrawBEntitiesOnList`: понятия не имею, что делает этот фрагмент.
* `R_ScanEdges`: комбинирование всей полученной на данный момент информации для рендеринга уровня:
+ Инициализация таблицы активных рёбер.
+ Инициализация буфера интервалов (также является стеком):
```
// Система стека интервалов
espan_t *span_p; // Текущая вершина указателя стека интервалов
espan_t *max_span_p; // Макс. span_p за этим, переполнение стека
// Примечание: стек интервалов (basespans) размещается в стеке ЦП
void R_ScanEdges (void)
{
int iv, bottom;
byte basespans[MAXSPANS*sizeof(espan_t)+CACHE_SIZE];
...
}
```
+ Запуск алгоритма построчного построения изображений сверху вниз по экрану.
+ Для каждой строки:
- Обновление таблицы активных рёбер из глобальной таблицы рёбер.
- Запуск таблицы активных рёбер для всей строки:
* Определение видимого полигона с помощью адреса в стеке поверхностей.
* Передача интервала в буфер интервалов.
* Если буфер интервалов заполнен: отрисовка всех интервалов и сброс стека интервалов.
+ Проверка оставшегося в буфере интервалов. Если в нём что-то осталось: отрисовка всех интервалов и сброс стека интервалов.
### Видео работы R\_EdgeDrawing
В видео ниже движок работает с разрешением 1024x768. Также он замедлен с помощью специальной cvar `sw_drawflat 1`, что позволило рендерить полигоны без текстур, но разными цветами:
В этом видео можно заметить очень много интересного:
1. Экран генерируется сверху вниз, это типичный алгоритм построчного построения изображений.
2. Горизонтальный интервал пикселей не записывается так, как генерировался. Это выполняется для оптимизации кэша упреждающей выборки Pentium: интервалы группируются по textureId с помощью механизма, называемого «цепочками текстур». Интервалы сохраняются в буфер. Когда буфер заполнен, интервалы отрисовываются с цепочками текстур ОДНОЙ группой.
3. Момент заполнения буфера интервалов и запуска процесса рендеринга очевиден, потому что рендеринг полигонов останавливается примерно на пятидесятой строке пикселей.
4. Интервалы генерируются сверху вниз, но отрисовываются снизу вверх: поскольку интервалы вставляются в цепочку текстур наверху списка указателей, они отрисовываются в порядке обратном их созданию.
5. Последняя группа занимает 40% экрана, а первая занимала 10%. Так происходит потому, что здесь гораздо меньше полигонов, интервалы не обрезаны и они занимают гораздо большее пространство.
6. OMG, *нулевая перерисовка* на этапе визуализации сплошного мира.
### Предварительно вычисляемое излучение: карты освещения
К сожалению, красивые 24-битные карты освещения в RGB необходимо ресэмплировать в 6-битные градации серого (выбором самого яркого канала из R, G и B), чтобы уложиться в ограничения палитры:
Что хранится в архиве `PAK` (24 бита):
После загрузки с диска и ресэмплинга до 6-бит:
А потом всё вместе: текстура грани даёт цвет в диапазоне [0,255]. Это значение индексирует цвет в палитре из `pics/colormap.pcx`:
Карты освещения фильтруются: в результате мы получаем значение в диапазоне [0,63].
Теперь с помощью верхней части `pics/colormap.pcx` движок может выбрать нужную позицию палитры. Для получения окончательного результата он использует входное значение текстуры в качестве координаты X и освещённость\*63 как координату Y:
И вуаля:
Лично я считаю, что это потрясающе: имитация 64 градиентов 256 цветов… всего 256 цветами!
### Подсистема поверхностей
Из предыдущих скриншотов очевидно, что генерирование поверхностей — наиболее требовательная к ЦП часть Quake2 (это подтверждается результатами профайлера ниже). Приемлемое относительно скорости и потребления памяти генерирование поверхностей обеспечивают два механизма:
* MIP-текстурирование (mipmapping)
* Кэширование
### Подсистема поверхностей: MIP-текстурирование
При проецировании полигона в экранное пространство генерируется 1/Z его расстояния. Ближайшая вершина используется для определения того, какой нужно использовать уровень MIP-текстур. Вот пример карты освещения и того, как она фильтруется в соответствии с уровнем MIP-текстур:
Вот минипроект, над которым я работал для тестирования качества билинейной фильтрации Quake2 на случайных изображениях: [архив](http://BilinearFiltering.zip).
Ниже представлены результаты теста, выполненного для карты освещения размером 13x15 текселов:
Уровень 3 MIP-текстур: блок имеет размер 2x2 тексела.
Уровень 2 MIP-текстур: блок имеет размер 4x4 тексела.
Уровень 1 MIP-текстур: блок имеет размер 8x8 текселов.
Уровень 0 MIP-текстур: блок имеет размер 16x16 текселов.
Ключ к пониманию фильтрации заключается в том, то всё основано на размере полигонов в пространстве мира (ширина и высота называются `extent`):
* Препроцессор Quake2 убеждается, что размеры полигона (X или Y) меньше или равны 256, а также кратны 16.
* Из размеров полигона в пространстве мира мы можем вывести:
+ Размер карты освещения (в текселах): LmpDim = PolyDim / 16 + 1
+ Размер поверхности (в блоках): SurDim = LmpDim -1 = PolyDim / 16
На рисунке ниже размеры полигона (3,4), карты освещения — (4,5) текселов, а вырожденная поверхность *всегда* имеет размер (3,4) блока. Уровни MIP-текстур определяют размеры блока в текселах, а значит и общий размер поверхности в текселах.
Всё это выполняется в `R_DrawSurface`. Уровень MIP-текстур выбирается с помощью массива указателей функций (`surfmiptable`), выбирающего нужную функцию растеризации:
```
static void (*surfmiptable[4])(void) = {
R_DrawSurfaceBlock8_mip0,
R_DrawSurfaceBlock8_mip1,
R_DrawSurfaceBlock8_mip2,
R_DrawSurfaceBlock8_mip3
};
R_DrawSurface
{
pblockdrawer = surfmiptable[r_drawsurf.surfmip];
for (u=0 ; u
```
В изменённом движке ниже можно увидеть три уровня MIP-текстур: 0 — серого цвета, 1 — жёлтого и 2 — красного:
Фильтрация выполняется блоком при генерировании block[i][j] поверхности, фильтр использует значения карты освещения: lightmap[i][j],lightmap[i+1][j],lightmap[i][j+1] и lightmap[i+1][j+1]: в сущности, с помощью четырёх текселов непосредственно в координатах и трёх внизу и справа. Заметьте, что это выполняется не весовой интерполяцией, а скорее линейной интерполяцией, сначала вертикально, а затем горизонтально по сгенерированным значениям. Если вкратце, то это работает в точности так же, как в [статье Wikipedia](http://en.wikipedia.org/wiki/Bilinear_filtering) о билинейной фильтрации.
А теперь всё вместе:
Исходная карта освещения, 13x15 текселов.
Фильтрация, уровень 0 MIP-текстур (16x16 блоков)=192x224 тексела.
Результат:
### Подсистема поверхностей: кэширование
Даже несмотря на то, что движок активно использует для управления памятью `malloc` и `free`, он всё равно использует собственный диспетчер памяти для кэширования поверхностей. Блок памяти инициализируется сразу после того, как становится известно разрешение визуализации:
```
size = SURFCACHE_SIZE_AT_320X240;
pix = vid.width*vid.height;
if (pix > 64000)
size += (pix-64000)*3;
size = (size + 8191) & ~8191;
sc_base = (surfcache_t *)malloc(size);
sc_rover = sc_base;
```
Ровер `sc_rover` в самом начале располагается в блоке, чтобы отслеживать, что было занято. Когда ровер достигает конца памяти, он сворачивается, в сущности, заменяя старые поверхности. Объём зарезервированной памяти можно увидеть на графике:
Вот как новый фрагмент памяти выделяется из блока:
```
memLoc = (int)&((surfcache_t *)0)->data[size]; // Пропуск размера + обеспечение достаточного места для заголовка фрагмента памяти.
memLoc = (memLoc + 3) & ~3; // FCS: округление до числа, кратного 4
sc_rover = (surfcache_t *)( (byte *)new + size);
```
Примечание: трюк с быстрым назначением кэша (может перейти в систему памяти)
Примечание: заголовок размещается поверх запрошенного объёма памяти. Очень странная строка, использующая указатель NULL (`((surfcache_t *)0)`) (но с ней всё в порядке, потому что нет задержки).
### Перспективное проецирование для бедных?
В разных статьях в Интернете предполагается, что Quake2 использует «перспективное проецирование для бедных» с помощью простой формулы и без гомогенных координат или матриц (код ниже из `R_ClipAndDrawPoly`):
```
XscreenSpace = X / Z * XScale
YscreenSpace = Y / Z * YScale
```
Где XScale и YScale определяются по области обзора и соотношению сторон экрана.
Такое перспективное проецирование на самом деле аналогично тому, что происходит в OpenGL на этапе деления GL\_PROJECTION + W:
```
Перспективное проецирование:
=======================
Вектор координат глаза
| X
| Y
| Z
| 1
--------------------------------------------------
Матрица перспективного проецирования |
|
XScale 0 0 0 | XClip
0 YScale 0 0 | YClip
0 0 V1 V2 | ZClip
0 0 -1 0 | WClip
Координаты обрезки:
================ XClip = X * XScale
YClip = Y * YScale
ZClip = /
WClip = -Z
Координаты NDC с делением W:
=========
XNDC = XClip/WClip = X * XScale / -Z
YNDC = YClip/WClip = Y * YScale / -Z
```
Первое наивное доказательство: сравните наложенные скриншоты. Если мы посмотрим в код: проецирование для бедных? Нет!
### R\_DrawEntitiesOnList: спрайты и объекты
На этом этапе процесса визуализации уровень уже отрендерен на экране:
Движок также сгенерировал 16-битный z-буфер (он был записан, но ещё не считывался):
Примечание: мы видим, что чем ближе значения, тем они «ярче» (в противоположность OpenGL, где ближе — это «темнее»). Так происходит потому, что в Z-буфере вместо Z хранится 1/Z.
16-битный z-буфер хранится начиная с указателя `d_pzbuffer`:
```
short *d_pzbuffer;
```
Как сказано выше, 1/Z сохраняется с помощью прямого применения формулы, описанной в статье Майкла Абраша «Consider the Alternatives: Quake's Hidden-Surface Removal».
Она находится в `D_DrawZSpans`:
```
zi = d_ziorigin + dv*d_zistepv + du*d_zistepu;
```
Если вам интересно математическое доказательство того, что можно действительно интерполировать 1/Z, то вот статья Кок-Лим Ло (Kok-Lim Low): [PDF](http://fabiensanglard.net/quake2/Perspective-Correct%20Interpolation.pdf).
Z-буфер, выведенный на этапе визуализации уровня, теперь используется в качестве входных данных для правильной обрезки сущностей.
Немного об анимированных сущностях (игроках и врагах):
* Quake1 отрисовывал только ключевые кадры, но теперь все вершины подвергаются LERP (`R_AliasSetUpLerpData`) для плавной анимации.
* Quake1 для рендеринга рассматривал сущности как BLOB: это неточный, но очень быстрый способ визуализации. В Quake2 от этого отказались и сущности рендерятся нормально, после тестирования BoundingBox и тестирования передних граней векторным произведением.
В отношении освещения:
* Не все тени отрисовываются.
* Полигоны имеют затенение по Гуро с жёстко заданным направлением освещения (`{-1, 0, 0}` от `R_AliasSetupLighting`).
* Интенсивность освещения основана на интенсивности источника освещения поверхности, на который она направлена.
### Просвечиваемость в R\_DrawAlphaSurfaces
Просвечиваемость должна выполняться с помощью индексов палитры. Наверно, я уже десятый раз повторяю это в статье, но только так я могу выразить, насколько это мне кажется **потрясающим**.
Просвечивающий полигон рендерится следующим образом:
* Проецирование всех вершин в экранное простраство.
* Определение левого и правого ребра.
* Если поверхность не искажается (анимированная вода), то выполняется визуализация в систему кэширования в ОЗУ.
После этого, если поверхность не полностью непрозрачная, то её нужно смешать с закадровым буфером кадров.
Трюк выполняется с помощью второй части изображения `pics/colormap.pcx`, использованного как таблица поиска для смешивания исходного пикселя из кэша поверхностей с целевым пикселем (в закадровом буфере кадров):
Исходные входные данные генерируют координату X, а целевые — координату Y. Полученный пиксель загружается в закадровый буфер кадров:
В анимации ниже показан кадр до и после попиксельного смешивания палитры:
### R\_CalcPalette: операции постэффектов и гамма-коррекция
Движок способен выполнять не только «попиксельное смешивание палитры» и «выбор цветового градиента на основе палитры», он может также изменять целую палитру для передачи информации о снижении здоровья или собирании предметов:
Если «анализатору» в DLL игры на стороне сервера необходимо было смешать цвета в конце процесса визуализации, ему нужно было просто задать значение переменной RGBA `float player_state_t.blend[4]` для любого игрока в игре. Это значение передаётся по сети, копируется в `refdef.blend[4]`, а затем передаётся DLL рендерера (ну и путешествие!). При обнаружении оно смешивается с каждыми 256 элементами RGB в индексе палитры. После гамма-коррекции палитра снова загружается в видеокарту.
`R_CalcPalette` в `r_main.c`:
```
// newcolor = color * alpha + blend * (1 - alpha)
alpha = r_newrefdef.blend[3];
premult[0] = r_newrefdef.blend[0]*alpha*255;
premult[1] = r_newrefdef.blend[1]*alpha*255;
premult[2] = r_newrefdef.blend[2]*alpha*255;
one_minus_alpha = (1.0 - alpha);
in = (byte *)d_8to24table;
out = palette[0];
for (i=0 ; i<256 ; i++, in+=4, out+=4)
for (j=0 ; j<3 ; j++)
v = premult[j] + one_minus_alpha * in[j];
```
**Интересный факт:** после изменения палитры вышеуказанным способом для неё необходимо выполнить гамма-коррекцию (в `R_GammaCorrectAndSetPalette`):
Гамма-коррекция — это ресурсоёмкая операция, включающая в себя вызов `pow` и деление… к тому же, её нужно было выполнять для каждого из каналов R, G и B значения цвета!
```
int newValue = 255 * pow ( (value+0.5)/255.5 , gammaFactor ) + 0.5;
```
Всего получается три вызова `pow`, три операции деления, шесть операций суммирования и три умножения для каждого из 256 значений в индексе палитры — это *очень много*.
Но поскольку входные данные ограничены восемью битами на канал, полную коррекцию можно рассчитать заранее и кэширования в небольшой массив из 256 элементов:
```
void Draw_BuildGammaTable (void)
{
int i, inf;
float g;
g = vid_gamma->value;
if (g == 1.0)
{
for (i=0 ; i<256 ; i++)
sw_state.gammatable[i] = i;
return;
}
for (i=0 ; i<256 ; i++)
{
inf = 255 * pow ( (i+0.5)/255.5 , g ) + 0.5;
if (inf < 0)
inf = 0;
if (inf > 255)
inf = 255;
sw_state.gammatable[i] = inf;
}
}
```
Поэтому для этого трюка используется таблица поиска (`sw_state.gammatable`) и она сильно ускоряет процесс гамма-коррекции.
```
void R_GammaCorrectAndSetPalette( const unsigned char *palette )
{
int i;
for ( i = 0; i < 256; i++ )
{
sw_state.currentpalette[i*4+0] = sw_state.gammatable[palette[i*4+0]];
sw_state.currentpalette[i*4+1] = sw_state.gammatable[palette[i*4+1]];
sw_state.currentpalette[i*4+2] = sw_state.gammatable[palette[i*4+2]];
}
SWimp_SetPalette( sw_state.currentpalette );
}
```
**Примечание:** вы можете решить, что у ЖК-экранов нет таких проблем с гаммой, как у ЭЛТ… однако они обычно [имитируют поведение ЭЛТ-экранов](http://developer.nvidia.com/book/export/html/181)!
### Статистика кода
Немного анализа кода Cloc, чтобы закрыть тему программного рендерера: в этом модуле насчитывается 14 874 строк. Это немного больше 10% от общего количества, но не даёт представления о вложенных усилиях, потому что перед выбором этой схемы было протестировано несколько других.
```
$ cloc ref_soft/
39 text files.
38 unique files.
4 files ignored.
http://cloc.sourceforge.net v 1.53 T=0.5 s (68.0 files/s, 44420.0 lines/s)
-------------------------------------------------------------------------------
Language files blank comment code
-------------------------------------------------------------------------------
C 17 2459 2341 8976
Assembly 9 1020 880 3849
C/C++ Header 7 343 293 2047
Teamcenter def 1 0 0 2
-------------------------------------------------------------------------------
SUM: 34 3822 3514 14874
-------------------------------------------------------------------------------
```
Ассемблерная оптимизация в девяти файлах `r_*.asm` содержит 25% объёма всей базы кода, и это довольно впечатляющее соотношение. Думаю, оно достаточно наглядно показывает объём труда, вложенного в программный рендерер: бóльшая часть процедуры растеризации оптимизирована вручную для процессора x86 Майклом Абрашем. Бóльшая часть оптимизации под Pentium, рассмотренных в его книге «Graphics Programming Black Book», используется в этих файлах.
**Интересный факт:** некоторые названия методов в книге и в коде Quake2 совпадают (например, `ScanEdges`).
### Профайлинг
Я пробовал использовать разные профайлеры, все они интегрированы в Visual Studio 2008:
* AMD Code Analysis
* Intel VTune Amplifier XE 2011
* Visual Studio Team Profiler
Привязка к сэмплированию времени показала *очень* разные результаты. Например, Vtune учитывал затраты на передачу из ОЗУ в видеопамять (`BitBlit`), но другие профайлеры упустили их.
Профайлерами Intel и AMD не удалось проверить оборудование (и я не настолько мазохист, чтобы выяснять, почему так получилось), но профайлер VS 2008 Team справился… хотя я и не рекомендую его: игра работала с частотой три кадра в секунду, и на анализ 20-секундной игры потребовался целый час!
Профайлинг VS 2008 Team edition:
Результаты говорят сами за себя:
* Затраты на программный рендеринг ошеломляют: 89% времени тратится в DLL.
* Игровая логика едва заметна: 0%.
* На удивление много времени занимает звуковая DLL DirectX.
* В `libc` тратится больше времени, чем в ядре quake.exe.
Взглянем повнимательней на траты времени ref\_soft.dll:
* Как я упомянул выше, запись байта в память очень затратна:
+ Огромные затраты (33%) связаны с построением Z-буфера (`D_DrawZSpans`).
+ Огромные затраты (22%) связаны с записью интервалов в закадровый буфер (`D_DrawZSpans16`).
+ Огромные затраты (13%) связаны с генерированием поверхности пропуска кэша.
* Затраты на алгоритм построчного построения изображения очевидны:
+ `R_LeadingEdge`
+ `R_GenerateSpans`
+ `R_TrailingEdge`
Профайлинг Intel VTune:
Заметно следующее:
* 18% времени посвящено стандартной проблеме программных рендереров: затраты на перенос отрендеренного изображения из ОЗУ в видеопамять (`BitBlit`).
* 34% времени посвящено визуализации и кэшированию поверхностей (`D_DrawSurfaces`).
* 8% посвящено LERP вершин для анимации игроков/врагов (`R_AliasPreparePoints`).
А вот более [подробный профайлинг ref\_sof Quake2](http://fd.fabiensanglard.net/quake2/profiling_ref_sof.jpg) с помощью VTune.
Профайлинг AMD Code Analysis
Ядро [здесь](http://fd.fabiensanglard.net/quake2/AMD_Profiler_quake2_kernel.png) и ref\_sof [здесь](http://fd.fabiensanglard.net/quake2/AMD_Profiler_quake2_ref_sof.png).
### Фильтрация текстур
Я получил много вопросов о том, как можно улучшить фильтрацию текстур (перейти к билинейной фильтрации или дизерингу [похожему на используемый в Unreal](http://www.flipcode.com/archives/Texturing_As_In_Unreal.shtml) ([зеркало](http://fd.fabiensanglard.net/quake2/unreal_kernel_filtering.png))). Если вы хотите поэкспериментировать с этим аспектом, то изучите `D_DrawSpans16` в `ref_soft/r_scan.c`:
Начальные координаты (X,Y) экранного пространства находятся в `pspan->u` and `pspan->v`, также имеется ширина интервала в `spancount` для расчёта того, какой будет сгенерирован целевой экранный пиксель.
Что касается координат текстур: `s` и `t` инициализиуются в исходных координатах текстуры и увеличиваются на (соответственно) `sstep` и `tstep` для управления сэмплированием текстур.
У некоторых, например, у «Szilard Biro», получились неплохие результаты при использовании техники дизеринга Unreal I:
Исходный код программного рендерера с дизерингом можно найти в моём [форке Quake2 на github](https://github.com/fabiensanglard/Quake-2). Дизеринг активируется присвоением cvar sw\_texfilt значения 1.
Исходный дизеринг из программного рендерера Unreal 1:
### Рендерер OpenGL
Quake2 стал первым движком, выпущенным с нативной поддержкой рендеринга с аппаратным ускорением. Он демонстрировал несомненные улучшения благодаря билинейной фильтрации текстур, увеличению мультитекстурирования и 24-битному смешиванию цвета.
С **точки зрения пользователя** версия с аппаратным ускорением обеспечивала следующие улучшения:
* Билинейная фильтрация
* Цветное освещение
* Повышение частоты кадров на 30% в высоких разрешениях
Не могу удержаться от цитаты из «Masters of Doom» о том, как Джон Ромеро впервые увидел цветное освещение *[прим. пер.: до начала работы над Quake 2 он уже покинул id Software и создал собственную компанию Ion Storm]*:
> Затем Ромеро подошёл к стенду id [...].
>
>
>
> Он пробился сквозь толпу, чтобы посмотреть на демо Quake II. Его лицо стало жёлтым, а челюсть отвисла: **цветное освещение!** Ромеро не мог поверить в то, что он видит. На экране был похожий на подземелье военный уровень, но когда игрок стрелял из оружия, жёлтый луч выстрела отбрасывал такой же жёлтый свет на стены. Он был слабым, но Ромеро видел динамическое цветное освещение. В тот момент он ощутил те же чувства, которые испытал в Softdisk, когда впервые увидел Dangerous Dave in Copyright Infringement *[прим. пер.: созданное Кармаком в 1990 году демо первого платформера на PC с скроллингом экрана]*.
>
>
>
> «Твою мать», — пробормотал он. Кармаку снова удалось удивить его.
Эта особенность оказала сильное влияние на разработку Daikatana.
С **точки зрения кода** рендерер на 50% меньше, чем программный рендерер (см. «Статистику кода» в конце страницы). Это значило, что разработчикам требовалось меньше работы. Также такая реализация была гораздо проще и элегантнее, чем программная/оптимизированная на ассемблере версия:
* Z-буфер позволил избавиться от стека активных полигонов (такая зависимость от быстрого Z-буфера привела к проблемам при разработке VQuake для V2200
* Высокая скорость чипов растеризатора в сочетании со скоростью ОЗУ Z-буфера сделали ненужной задачу нулевой перерисовки.
* Встроенная процедура построчного построения изображения избавила от необходимости глобальной таблицы рёбер и таблицы активных рёбер.
* Фильтрация карт освещения выполнялась в видеопроцессоре (и в RGB вместо градаций серого): в ЦП эти вычисления вообще не попадали.
В конце концов, рендерер OpenGL больше является диспетчером ресурсов, чем рендерером: он передаёт вершины, на лету загружает атлас карт освещения и назначает состояния текстур.
**Интересный факт:** кадр Quake2 обычно содержит по 600-900 полигонов: разительное отличие от миллионов полигонов в любом современном движке.
### Глобальная архитектура кода
Фаза рендеринга очень проста и я не буду подробно её рассматривать, потому что она практически идентична программному рендерингу:
```
R_RenderView
{
R_PushDlights // Пометка полигона, на который воздействует динамическое освещение
R_SetupFrame
R_SetFrustum
R_SetupGL // Настройка GL_MODELVIEW и GL_PROJECTION
R_MarkLeaves // Разархивирование PVS и пометка потенциально видимых полигонов
R_DrawWorld // Рендеринг уровня, отсечение целых кластеров полигонов тестированием BoundingBox
{
}
R_DrawEntitiesOnList // Рендеринг сущностей
R_RenderDlights // Смешивание динамического освещения
R_DrawParticles // Отрисовка частиц
R_DrawAlphaSurfaces // Просвечивающие поверхности с смешиванием альфа-канала
R_Flash // Постэффекты (добавление красного цвета на весь экран при потере здоровья и т.п...)
}
```
Все этапы наглядно показаны в видео, в котором движок «замедлен»:
Порядок визуализации:
* Мир.
* Сущности (в Quake2 они называются «alias»).
* Частицы.
* Просвечивающие поверхности.
* Полноэкранные постэффекты.
Основная сложность кода возникает из-за разных путей в зависимости от того, поддерживает ли видеокарта мультитекстурирование и включён ли групповой рендеринг вершин. Например, если мультитекстурирование поддерживается, то `DrawTextureChains` и `R_BlendLightmaps` в следующем куске кода ничего не делают и только запутывают при чтении кода:
```
R_DrawWorld
{
//Отрисовка мира, выполняется на 100% при поддержке мультитекстурирования или только ПЕРВЫЙ проход (цвета) без мультитекстурирования
R_RecursiveWorldNode // Сохранение граней цепочкой текстур, чтобы избежать изменения назначенных текстур
{
// Рендеринг всех PVS с отсечением кластеров с помощью BBox/пирамиды видимости
// Здесь выполняется основное!
// Если видимо: рендеринг
GL_RenderLightmappedPoly
{
if ( is_dynamic )
{
}
else
{
}
}
}
// Только если не поддерживается мультитекстутирование (ВТОРОЙ проход)
DrawTextureChains // Отрисовка всех цепочек текстур, это позволяет избежать слишком большого числа вызовов bindTexture.
{
for ( i = 0, image=gltextures ; itexturechain)
R\_RenderBrushPoly (s)
{
}
}
// Только если не поддерживается мультитекстурирование (ВТОРОЙ проход: карты освещения)
R\_BlendLightmaps
{
// Рендеринг статичных карт освещения
// Загрузка и рендеринг динамических карт освещения
if ( gl\_dynamic->value )
{
LM\_InitBlock
GL\_Bind
for ( surf = gl\_lms.lightmap\_surfaces[0]; surf != 0; surf = surf->lightmapchain )
{
// Проверка заполненности блока. Если он заполнен, загрузить блок и отрисовать, в противном случае продолжать заполнять его
}
}
}
R\_DrawSkyBox
R\_DrawTriangleOutlines
}
```
### Визуализация мира
Рендеринг уровня выполняется в `R_DrawWorld`. Вершина имеет пять атрибутов:
* Положение.
* Идентификатор цветовой текстуры.
* Координаты цветовой текстуры.
* Идентификатор текстуры статичной карты освещения.
* Координаты текстуры статичной карты освещения.
В рендерере OpenGL нет «Surface»: цвета и карта освещения сочетаются на лету и никогда не кэшируются. Если видеокарта поддерживает мультитекстурирование, то необходим только один проход, указывающий идентификатор текстуры и её координаты:
1. Цветовая текстура привязывается к состоянию OpenGL GL\_TEXTURE0.
2. Текстура карты освещения привязывается к состоянию OpenGL GL\_TEXTURE1.
3. Передаются вершины с координатами цветовой текстуры и текстуры карты освещения.
Если видеокарта НЕ поддерживает мультитекстурирование, то выполняется два прохода:
1. Смешивание отключается.
2. Цветовая текстура привязывается к состоянию OpenGL GL\_TEXTURE0.
3. Вершины отправляются с координатами цветовой текстуры.
4. Смешивание включается.
5. Текстура карты освещения привязывается к состоянию OpenGL GL\_TEXTURE0.
6. Передаются вершины с координатами текстуры карты освещения.
### Управление текстурами
Поскольку вся растеризация выполняется в видеопроцессоре, в начале уровня все текстуры должны загружаться в видеопамять:
* Цветовые текстуры
* Предварительно рассчитанные текстуры карт освещения
С помощью отладчика OpenGL gDEBugger можно с лёгкостью покопаться в памяти видеопроцессора и получить статистику:
Как мы видим, у каждой цветовой текстуры есть собственный идентификатор текстуры (textureID). Статичные карты освещения загружаются как атлас текстур (называемый в quake2 «блоком») в таком виде:
Почему же цветовая текстура находится в отдельной текстуре, если карты освещения собраны в атлас текстур?
Причина заключается в **оптимизации цепочек текстур**:
Если вы хотите увеличить производительность при работе с видеопроцессором, то нужно стремиться к том, чтобы он менял своё состояние как можно реже. Это особенно справедливо для привязки текстур (`glBindTexture`). Вот плохой пример:
```
for(i=0 ; i < polys.num ; i++)
{
glBindTexture(polys[i].textureColorID , GL_TEXTURE0);
glBindTexture(polys[i].textureLightMapID , GL_TEXTURE1);
RenderPoly(polys[i].vertices);
}
```
Если каждый полигон имеет цветовую текстуру и текстуру карты освещения, то тут мало что можно сделать, но Quake2 собирает свои карты освещения в атласы, которые легко сгруппировать по идентификатору. Поэтому полигоны не рендерятся в порядке, возвращаемом из BSP. Вместо этого они группируются в цепочки текстур на основании того, к какому атласу текстур карт освещения они относятся:
```
glBindTexture(polys[textureChain[0]].textureLightMapID , GL_TEXTURE1);
for(i=0 ; i < textureChain.num ; i++)
{
glBindTexture(polys[textureChain[i]].textureColorID , GL_TEXTURE0);
RenderPoly(polys[textureChain[i]].vertices);
}
```
В видео ниже показан процесс визуализации «цепочек текстур»: полигоны рендерятся не в зависимости от расстояния, а на основании блока карт освещения, к которым они относятся:
**Примечание:** для достижения постоянной просвечиваемости в цепочку текстур попадают только полностью непрозрачные полигоны, а просвечиваемые полигоны по-прежнему рендерятся сзади вперёд.
### Динамическое освещение
В самом начале фазы визуализации все полигоны помечаются, чтобы показать, что они подвержены влиянию динамического освещения (`R_PushDlights`). Поэтому предварительно рассчитанная статичная карта освещения не используется. Вместо неё генерируется новая карта освещения, сочетающая в себе статичную карту освещения с добавлением света, проецируемого на плоскость полигона (`R_BuildLightMap`).
Поскольку карта освещения имеет максимальный размер 17x17, фаза генерирования карты динамического освещения не слишком затратна, но загрузка изменений в видеопроцессор с помощью `qglTexSubImage2D` **очень** медленная.
Для хранения всех динамических карт освещения используется блок карт освещения размером 128x128, его id=1024. См. в разделе «Управление картами освещения» объяснение того, как все динамические карты освещения комбинируются на лету в атлас текстур.
*1. Первоначальное состояние блока динамического освещения. 2. После первого кадра. 3. Через десять кадров.*
Примечание: если динамическая карта освещения заполнена, выполняется групповой рендеринг. Ровер отслеживает, выполнена ли очистка выделенного места, и генерирование динамических карт освещения возобновляется.
### Управление картами освещения
Как я сказал ранее, в OpenGL-версии рендерера нет концепции «поверхности» («surface»). Карта освещения и цветовая текстура комбинируются на лету и НЕ кэшируются.
Хота статичные карты освещения загружаются в видеопамять, они всё равно хранятся в ОЗУ: если на полигон воздействует динамическое освещение, генерируется новая карта освещения, сочетающая в себе статичную карту освещения со спроецированным на неё светом. Динамическая карта освещения затем загружается в textureId=1024 и используется для текстурирования.
Атласы текстур называются в Quake2 «блоками» («Block»), состоят из 128x128 текселов и управляются тремя функциями:
* `LM_InitBlock`: сброс отслеживания потребления памяти блоком.
* `LM_UploadBlock`: загрузка или обновление содержимого текстуры.
* `LM_AllocBlock`: поиск подходящего места для хранения карты освещения.
В видео ниже показано, как карты освещения соединяются в блоки. Здесь движок играет в «Тетрис»: сканирует слева направо и запоминает, куда карта освещения поместится полностью в самой верхней координате изображения.
Алгоритму стоит уделить внимание: ровер (`int gl_lms.allocated[BLOCK_WIDTH]`) отслеживает по всей ширине, какую высоту занял каждый столбец пикселей.
```
// Переменную "best" лучше было бы назвать "bestHeight"
// Переменную "best2" НУЖНО было бы назвать "tentativeHeight"
static qboolean LM_AllocBlock (int w, int h, int *x, int *y)
{
int i, j;
int best, best2;
//FCS: на этой высоте сохраняется новая карта освещения
best = BLOCK_HEIGHT;
for (i=0 ; i= best)
break;
if (gl\_lms.allocated[i+j] > best2)
best2 = gl\_lms.allocated[i+j];
}
if (j == w)
{ // это нужное место
\*x = i;
\*y = best = best2;
}
}
if (best + h > BLOCK\_HEIGHT)
return false;
for (i=0 ; i
```
Примечание: шаблон проектирования «ровер» («rover») очень элегантен и используется также в системе памяти кэширования поверхностей программного рендерера.
### Скорость заполнения пикселями и проходы рендеринга
Как видно из следующего видео, перерисовка может быть довольно значительной:
В худшем случае пиксель может перезаписываться 3-4 раза (не считая перерисовки):
* Мир: 1-2 прохода (в зависимости от поддержки мультитекстурирования).
* Смешивание частиц: 1 проход.
* Смешивание постэффектов: 1 проход.
### GL\_LINEAR
Билинейная фильтрация хорошо работала с цветовыми текстурами, но по-настоящему расцвела при фильтрации карт освещения:
Было:
Стало:
А теперь всё вместе:
*1. Текстура: динамическая/статическая карта освещения.*
*2. Текстура: цвет.*
*3. Результат смешивания: один или два прохода.*
### Визуализация сущностей
Сущности рендерятся группами: вершины, координаты текстур и указатели массивов цветов собираются и отправляются с помощью `glArrayElement`.
Перед визуализацией для вершин всех сущностей выполняется LERP для сглаживания анимации (в Quake1 использовались только ключевые кадры).
Используется модель освещения Гуро: массив цветов перехватывается Quake2 для хранения значения освещения. Перед визуализацией для каждой вершины выполняется расчёт значения освещения и сохраняется в массив цветов. Значение этого массива интерполируется в видеопроцессоре и получается хороший результат с освещением по Гуро.
```
R_DrawEntitiesOnList
{
if (!r_drawentities->value)
return;
// Непрозрачные сущности
for (i=0 ; i < r_newrefdef.num_entities ; i++)
{
R_DrawAliasModel
{
R_LightPoint /// Определение цвета освещения для применения к модели целиком
GL_Bind(skin->texnum); // Привязка текстуры сущности
GL_DrawAliasFrameLerp() // Отрисовка
{
GL_LerpVerts // Интерполяция LERP всех вершин
// Расчёт освещения для каждой вершины, сохранение в массиве цветов colorArray
for ( i = 0; i < paliashdr->num_xyz; i++ )
{
}
qglLockArraysEXT
qglArrayElement // ОТРИСОВКА!
qglUnlockArraysEXT
}
}
}
// Сущности с прозрачностью
for (i=0 ; i < r_newrefdef.num_entities ; i++)
{
R_DrawAliasModel
{
[...]
}
}
}
```
Отсечение задних граней выполняется в видеопроцессоре (ну, поскольку тесселяция и освещение выполнялись в то время в ЦП, думаю, можно сказать, что оно выполнялось на этапе драйвера).
**Примечание:** для ускорения расчётов направление света всегда принималось одинаковым (`{-1, 0, 0}` ), но это не отражено в движке. Цвет освещения точен и подбирается по текущему полигону, на котором основана сущность.
Это очень хорошо заметно на скриншоте ниже, где свет и тень имеют одно направление, несмотря на неправильное определение источника света.
**Примечание:** конечно, эта система не всегда идеальна, тень выдаётся в пустоту, а грани перезаписывают друг друга, приводя к разным уровням теней, но это всё равно довольно впечатляюще для 1997 года.
Подробнее о тенях:
Многим неизвестно, что Quake2 был способен вычислять приблизительные тени сущностей. Хотя по умолчанию эта функция отключена, её можно включить командой `gl_shadows 1`.
Тень всегда направлена в одну сторону (не зависит от ближайшего источника света), грани проецируются на плоскость уровня сущности. В коде `R_DrawAliasModel` генерирует вектор `shadevector`, используемый `GL_DrawAliasShadow` для проецирования граней на плоскость уровня сущности.
### Освещение визуализации сущностей: трюк с дискретизацией
Вы можете решить, что малое количество полигонов в модели позволяло вычислять нормальное и скалярное произведение нормалей/света в реальном времени… но нет. Все скалярные произведения вычисляются заранее и хранятся в `float r_avertexnormal_dots[SHADEDOT_QUANT][256]`, где `SHADEDOT_QUANT`=16.
Используется дискретизация: направление света всегда одинаково: {-1,0,0}.
Вычисляется всего одна из 16 различных нормалей, в зависимости от ориентации модели по оси Y.
После выбора одного из 16 направлений предварительно вычисляется скалярное произведение для 256 разных нормалей. Нормаль в формате модели MD2 — это ВСЕГДА индекс заранее вычисленного массива. Любое сочетание нормалей X,Y,Z попадает в одно из 256 направлений.
Из-за всех этих ограничений все скалярные произведения ищутся в `r_avertexnormal_dots` размером 16x256. Поскольку индекс нормали нельзя интерполировать в процессе анимации, для ключевого кадра используется ближайший индекс нормали.
Подробнее об этом: <http://www.quake-1.com/docs/quakesrc.org/97.html> ([зеркало](http://fabiensanglard.net/quake2/modQuantization.zip)).
### Старый добрый OpenGL...
Где моя glGenTextures?!:
Сегодня openGL-разработчики запрашивают textureID из видеопроцессора через `glGenTextures`. Quake2 не утруждался этим и выбирал идентификатор самостоятельно. Поэтому цветовые текстуры начинались с 0, текстура динамической карты освещения всегда имела идентификатор 1024, а статичная карта освещения с 1025 по 1036.
Печально известный режим Immediate mode:
Данные вершины передаются в видеокарту с помощью ImmediateMode. По два вызова функции на вершину (`glVertex3fv` и `glTexCoord2f`) для рендеринга мира (поскольку полигоны отсекались индивидуально, невозможно было собрать их в группы).
Групповая визуализация выполнялась для моделей (врагов, игроков) с помощью `glEnableClientState (GL_VERTEX_ARRAY)`. Вершины, передаваемые в `glVertexPointer` и `glColorPointer`, использовались для передачи значения освещения, вычисляемого в ЦП.
Мультитекстурирование:
Код усложнён тем, что стремится подстроиться к оборудованию поддерживающему и не поддерживающему новую технологию… мультитекстурирования.
Нет использования `GL_LIGHTING`:
Поскольку все вычисления выполнялись в ЦП (генерирование текстур для мира и значение освещённости вершин для сущностей), в коде нет следов `GL_LIGHTING`.
Поскольку OpenGL 1.0 всё равно выполнял затенение по Гуро (интерполируя цвета между вершинами) вместо затенения по Фонгу (где нормали интерполируются для реального «попиксельного освещения»), то использование `GL_LIGHTING` плохо бы выглядело для мира, потому что требовало бы создания вершин на лету.
Его «можно» было применить для сущностей, но при этом пришлось бы отправлять и векторы нормалей вершин. Похоже, это сочли неподходящим, поэтому вычисление значений освещения выполняется в ЦП. Значение освещения передаётся из массива цветов, значения интерполируются в ЦП для получения затенения по Гуро.
### Полноэкранные постэффекты
Программный рендерер на основе палитры выполнял элегантное полное смешивание цветов палитры и дополнительную гамма-коррекцию с помощью таблицы поиска. Но OpenGL-версии это не нужно, и в этом можно убедиться на примере метода «грубой силы» в `R_Flash`:
Проблема: нужно сделать экран немного более красным?
Решение: просто отрисуем на весь экран огромный красный прямоугольник GL\_QUAD со включенным смешиванием альфа-канала. Готово.
Примечание: сервер управлял клиентом так же, как программный рендерер: если серверу нужно было выполнить полноэкранное смешивание цветов для постэффекта, он просто присваивал значение переменной `float player_state_t.blend[4]` RGBA. Значение переменной затем передавалось благодаря ядру quake2 по сети и отправлялось в DLL рендерера.
### Профайлинг
Профайлер Visual Studio 2008 Team просто чудесен, вот что выяснилось для OpenGL Quake2:
Ничего удивительного: бóльшая часть времени тратится на OpenGL-драйвер NVidia и Win32 (`nvoglv32.dll` и `opengl32.dll`), всего около 30%. Визуализация выполняется в видеопроцессоре, но **куча времени** тратится на множественный вызов методов immediate mode, а также на копирование данных из ОЗУ в видеопамять.
Следующими идут модуль рендерера (`ref_gl.dll` 23%) и ядро quake2 (`quake2.exe` 15%).
Даже несмотря на то, что движок активно использует malloc, мы видим, что на него почти не тратится времени (`MSVCR90D.dll` и `msvcrt.dll`). Также несущественно время, потраченное на игровую логику (`gamex86.dll`).
Неожиданное количество времени тратится на звуковую библиотеку directX (`dsound.dll`): 12% от общего времени.
Рассмотрим подробнее dll рендерера OpenGL Quake2:
* Бóльшая часть времени тратится на рендеринг мира (`R_RecurseiveWorldNode`).
* Почти столько же — на рендеринг врагов (моделей alias): (`GL_DrawAliasFrameLerp` 2,5%). Затраты довольно высоки, несмотря на то, что скалярное произведение вычисляется заранее.
* Генерирование карт освещения (когда динамическое освещение не даёт использовать заранее вычисленную статичную карту освещения) тоже занимает 2,5% времени (`GL_RenderLightMappedPoly`).
В целом dll OpenGL хорошо сбалансирована, в ней НЕТ очевидных «бутылочных горлышек».
### Статистика кода
Анализ кода Cloc показывает, что всего насчитывается 7 265 строк кода.
```
$ cloc ref_gl
17 text files.
17 unique files.
1 file ignored.
http://cloc.sourceforge.net v 1.53 T=1.0 s (16.0 files/s, 10602.0 lines/s)
-------------------------------------------------------------------------------
Language files blank comment code
-------------------------------------------------------------------------------
C 9 1522 1403 6201
C/C++ Header 6 237 175 1062
Teamcenter def 1 0 0 2
-------------------------------------------------------------------------------
SUM: 16 1759 1578 7265
-------------------------------------------------------------------------------
```
По сравнению с программным рендерером разница поразительна: на 50% меньше кода, БЕЗ ассемблерной оптимизации, при этом скорость на 30% выше и присутствует цветное освещение и билинейная фильтрация. Легко понять, почему id Software не стала возиться с программным рендерером для Quake3. | https://habr.com/ru/post/328128/ | null | ru | null |
# ООП в картинках
ООП (Объектно-Ориентированное Программирование) стало неотъемлемой частью разработки многих современных проектов, но, не смотря на популярность, эта парадигма является далеко не единственной. Если вы уже умеете работать с другими парадигмами и хотели бы ознакомиться с оккультизмом ООП, то впереди вас ждет немного лонгрид и два мегабайта картинок и анимаций. В качестве примеров будут выступать трансформеры.
Прежде всего стоит ответить, зачем? Объектно-ориентированная идеология разрабатывалась как попытка связать поведение сущности с её данными и спроецировать объекты реального мира и бизнес-процессов в программный код. Задумывалось, что такой код проще читать и понимать человеком, т. к. людям свойственно воспринимать окружающий мир как множество взаимодействующих между собой объектов, поддающихся определенной классификации. Удалось ли идеологам достичь цели, однозначно ответить сложно, но де-факто мы имеем массу проектов, в которых с программиста будут требовать ООП.
Не следует думать, что ООП каким-то чудным образом ускорит написание программ, и ожидать ситуацию, когда жители Вилларибо уже выкатили ООП-проект в работу, а жители Виллабаджо все еще отмывают жирный спагетти-код. В большинстве случаев это не так, и время экономится не на стадии разработки, а на этапах поддержки (расширение, модификация, отладка и тестирование), то бишь в долгосрочной перспективе. Если вам требуется написать одноразовый скрипт, который не нуждается в последующей поддержке, то и ООП в этой задаче, вероятнее всего, не пригодится. Однако, значительную часть жизненного цикла большинства современных проектов составляют именно поддержка и расширение. Само по себе наличие ООП не делает вашу архитектуру безупречной, и может наоборот привести к излишним усложнениям.
Иногда можно столкнуться с критикой в адрес быстродействия ООП-программ. Это правда, незначительный оверхед присутствует, но настолько незначительный, что в большинстве случаев им можно пренебречь в пользу преимуществ. Тем не менее, в узких местах, где в одном потоке должны создаваться или обрабатываться миллионы объектов в секунду, стоит как минимум пересмотреть необходимость ООП, ибо даже минимальный оверхед в таких количествах может ощутимо повлиять на производительность. Профилирование поможет вам зафиксировать разницу и принять решение. В остальных же случаях, скажем, где львиная доля быстродействия упирается в IO, отказ от объектов будет преждевременной оптимизацией.
В силу своей природы, объектно-ориентированное программирование лучше всего объяснять на примерах. Как и обещал, нашими пациентами будут трансформеры. Я не трансформеролог, и комиксов не читал, посему в примерах буду руководствоваться википедией и фантазией.
Классы и объекты
----------------
Сразу лирическое отступление: объектно-ориентированный подход возможен и без классов, но мы будем рассматривать, извиняюсь за каламбур, классическую схему, где классы — наше всё.
Самое простое объяснение: класс — это чертеж трансформера, а экземпляры этого класса — конкретные трансформеры, например, Оптимус Прайм или Олег. И хотя они и собраны по одному чертежу, умеют одинаково ходить, трансформироваться и стрелять, они оба обладают собственным уникальным состоянием. Состояние — это ряд меняющихся свойств. Поэтому у двух разных объектов одного класса мы можем наблюдать разное имя, возраст, местоположение, уровень заряда, количество боеприпасов и т. д. Само наличие этих свойств и их типы описываются в классе.
Таким образом, класс — это описание того, какими свойствами и поведением будет обладать объект. А объект — это экземпляр с собственным состоянием этих свойств.
Мы говорим «свойства и поведение», но звучит это как-то абстрактно и непонятно. Привычнее для программиста будет звучать так: «переменные и функции». На самом деле «свойства» — это такие же обычные переменные, просто они являются атрибутами какого-то объекта (их называют полями объекта). Аналогично «поведение» — это функции объекта (их называют методами), которые тоже являются атрибутами объекта. Разница между методом объекта и обычной функцией лишь в том, что метод имеет доступ к собственному состоянию через поля.
Итого, имеем методы и свойства, которые являются атрибутами. Как работать с атрибутами? В большинстве ЯП оператор обращения к атрибуту — это точка (кроме PHP и Perl). Выглядит это примерно вот так (псевдокод):
```
// объявление класса с помощью ключевого слова class
class Transformer(){
// объявление поля x
int x
// объявление метода конструктора (сюда нам чуть ниже передадут 0)
function constructor(int x){
// инициализация поля x
// (переданный конструктору 0 превращается в свойство объекта)
this.x = x
}
// объявление метода run
function run(){
// обращение к собственному атрибуту через this
this.x += 1
}
}
// а теперь клиентский код:
// создаем новый экземпляр трансформера с начальной позицией 0
optimus = new Transformer(0)
optimus.run() // приказываем Оптимусу бежать
print optimus.x // выведет 1
optimus.run() // приказывает Оптимусу еще раз бежать
print optimus.x // выведет 2
```
В картинках я буду использовать такие обозначения:
Я не стал использовать UML-диаграммы, посчитав их недостаточно наглядными, хоть и более гибкими.
[*Анимация №1*](https://habrastorage.org/webt/vi/uy/h2/viuyh29qu7ln_eq4eqyn5slkk0a.gif)
Что мы видим из кода?
1. **this** — это специальная локальная переменная (внутри методов), которая позволяет объекту обращаться из своих методов к собственным атрибутам. Обращаю внимание, что только к собственным, то бишь, когда трансформер вызывает свой метод, либо меняет собственное состояние. Если снаружи обращение будет выглядеть так: **optimus.x**, то изнутри, если Оптимус захочет сам обратиться к своему полю x, в его методе обращение будет звучать так: **this.x**, то есть "*я (Оптимус) обращаюсь к своему атрибуту x*". В большинстве языков эта переменная называется this, но встречаются и исключения (например, self)
2. **constructor** — это специальный метод, который автоматически вызывается при создании объекта. Конструктор может принимать любые аргументы, как и любой другой метод. В каждом языке конструктор обозначается своим именем. Где-то это специально зарезервированные имена типа \_\_construct или \_\_init\_\_, а где-то имя конструктора должно совпадать с именем класса. Назначение конструкторов — произвести первоначальную инициализацию объекта, заполнить нужные поля.
3. **new** — это ключевое слово, которое необходимо использовать для создания нового экземпляра какого-либо класса. В этот момент создается объект и вызывается конструктор. В нашем примере, конструктору передается 0 в качестве стартовой позиции трансформера (это и есть вышеупомянутая инициализация). Ключевое слово new в некоторых языках отсутствует, и конструктор вызывается автоматически при попытке вызвать класс как функцию, например так: Transformer().
4. **Методы** constructor и run **работают с внутренним состоянием, а во всем остальном не отличаются от обычных функций**. Даже синтаксис объявления совпадает.
5. Классы могут обладать методами, которым не нужно состояние и, как следствие, создание объекта. В этом случае метод делают **статическим**.
### SRP
(Single Responsibility Principle / Принцип единственной ответственности / Первый принцип [SOLID](https://ru.wikipedia.org/wiki/SOLID_(%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5))). С ним вы, наверняка, уже знакомы из других парадигм: «одна функция должна выполнять только одно законченное действие». Этот принцип справедлив и для классов: «Один класс должен отвечать за какую-то одну задачу». К сожалению с классами сложнее определить грань, которую нужно пересечь, чтобы принцип нарушался.
Существуют попытки формализовать данный принцип с помощью описания назначения класса одним предложением без союзов, но это очень спорная методика, поэтому доверьтесь своей интуиции и не бросайтесь в крайности. Не нужно делать из класса швейцарский нож, но и плодить миллион классов с одним методом внутри — тоже глупо.
Ассоциация
----------
Традиционно в полях объекта могут храниться не только обычные переменные стандартных типов, но и другие объекты. А эти объекты могут в свою очередь хранить какие-то другие объекты и так далее, образуя дерево (иногда граф) объектов. Это отношение называется ассоциацией.
Предположим, что наш трансформер оборудован пушкой. Хотя нет, лучше двумя пушками. В каждой руке. Пушки одинаковые (принадлежат к одному классу, или, если будет угодно, выполненные по одному чертежу), обе одинаково умеют стрелять и перезаряжаться, но в каждой есть свое хранилище боеприпасов (собственное состояние). Как теперь это описать в ООП? С помощью ассоциации:
```
class Gun(){ // объявляем класс Пушка
int ammo_count // объявляем количество боеприпасов
function constructor(){ // конструктор
this.reload() // вызываем собственный метод "перезарядить"
}
function fire(){ // объявляем метод пушки "стрелять"
this.ammo_count -= 1 // расходуем боеприпас из собственного магазина
}
function reload(){ // объявляем метод "перезарядить"
this.ammo_count = 10 // забиваем собственный магазин боеприпасами
}
}
class Transformer(){ // объявляем класс Трансформер
Gun gun_left // объявляем поле "левая пушка" типа Пушка
Gun gun_right // объявляем поле "правая пушка" тоже типа Пушка
/*
теперь конструктор Трансформера принимает
в качестве аргументов две уже конкретные созданные пушки,
которые передаются извне
*/
function constructor(Gun gun_left, Gun gun_right){
this.gun_left = gun_left // устанавливаем левую пушку на борт
this.gun_right = gun_right // устанавливаем правую пушку на борт
}
// объявляем метод Трансформер "стрелять", который сначала стреляет...
function fire(){
// левой пушкой, вызывая ее метод "стрелять"
this.gun_left.fire()
// а затем правой пушкой, вызывая такой же метод "стрелять"
this.gun_right.fire()
}
}
gun1 = new Gun() // создаем первую пушку
gun2 = new Gun() // создаем вторую пушку
optimus = new Transformer(gun1, gun2) // создаем трансформера, передавая ему обе пушки
```
[*Анимация №2*](https://habrastorage.org/webt/-t/cv/aa/-tcvaa8gtnipg_ridjunpf9b1tu.gif)
this.gun\_left.fire() и this.gun\_right.fire() — это обращения к дочерним объектам, которые происходят так же через точки. По первой точке мы обращаемся к атрибуту себя (this.gun\_right), получая объект пушки, а по второй точке обращаемся к методу объекта пушки (this.gun\_right.fire()).
Итог: робота сделали, табельное оружие выдали, теперь разберемся, что тут происходит. В данном коде один объект стал составной частью другого объекта. Это и есть ассоциация. Она в свою очередь бывает двух видов:
1. **Композиция** — случай, когда на фабрике трансформеров, собирая Оптимуса, обе пушки ему намертво приколачивают к рукам гвоздями, и после смерти Оптимуса, пушки умирают вместе с ним. Другими словами, жизненный цикл дочернего объекта совпадает с жизненным циклом родительского.
2. **Агрегация** — случай, когда пушка выдается как пистолет в руку, и после смерти Оптимуса этот пистолет может подобрать его боевой товарищ Олег, а затем взять в свою руку, либо сдать в ломбард. То бишь жизненный цикл дочернего объекта не зависит от жизненного цикла родительского, и может использоваться другими объектами.
Ортодоксальная ООП-церковь проповедует нам фундаментальную троицу — **инкапсуляцию, полиморфизм и наследование**, на которых зиждется весь объектно-ориентированный подход. Разберем их по порядку.
Наследование
------------
Наследование — это механизм системы, который позволяет, как бы парадоксально это не звучало, наследовать одними классами свойства и поведение других классов для дальнейшего расширения или модификации.
Что если, мы не хотим штамповать одинаковых трансформеров, а хотим сделать общий каркас, но с разным обвесом? ООП позволяет нам такую шалость путем разделения логики на сходства и различия с последующим выносом сходств в родительский класс, а различий в классы-потомки. Как это выглядит?
Оптимус Прайм и Мегатрон — оба трансформеры, но один является автоботом, а второй десептиконом. Допустим, что различия между автоботами и десептиконами будут заключаться только в том, что автоботы трансформируются в автомобили, а десептиконы — в авиацию. Все остальные свойства и поведение не будут иметь никакой разницы. В таком случае можно спроектировать систему наследования так: общие черты (бег, стрельба) будут описаны в базовом классе «Трансформер», а различия (трансформация) в двух дочерних классах «Автобот» и «Десептикон».
```
class Transformer(){ // базовый класс
function run(){
// код, отвечающий за бег
}
function fire(){
// код, отвечающий за стрельбу
}
}
class Autobot(Transformer){ // дочерний класс, наследование от Transformer
function transform(){
// код, отвечающий за трансформацию в автомобиль
}
}
class Decepticon(Transformer){ // дочерний класс, наследование от Transformer
function transform(){
// код, отвечающий за трансформацию в самолет
}
}
optimus = new Autobot()
megatron = new Decepticon()
```
[*Анимация №3*](https://habrastorage.org/webt/qj/jo/mg/qjjomgocinjckd5kxjmubl1gzqc.gif)
Сей пример наглядно иллюстрирует, как наследование становится одним из способов дедуплицировать код ([DRY-принцип](https://ru.wikipedia.org/wiki/Don%E2%80%99t_repeat_yourself)) с помощью родительского класса, и одновременно предоставляет возможности для мутации в классах-потомках.
### Перегрузка
Если же в классе-потомке переопределить уже существующий метод в классе-родителе, то сработает перегрузка. Это позволяет не дополнять поведение родительского класса, а модифицировать. В момент вызова метода или обращения к полю объекта, поиск атрибута происходит от потомка к самому корню — родителю. То есть, если у автобота вызвать метод fire(), сначала поиск метода производится в классе-потомке — Autobot, а поскольку его там нет, поиск поднимается на ступень выше — в класс Transformer, где и будет обнаружен и вызван. Следует отметить, что модификация нарушает [LSP](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF_%D0%BF%D0%BE%D0%B4%D1%81%D1%82%D0%B0%D0%BD%D0%BE%D0%B2%D0%BA%D0%B8_%D0%91%D0%B0%D1%80%D0%B1%D0%B0%D1%80%D1%8B_%D0%9B%D0%B8%D1%81%D0%BA%D0%BE%D0%B2) из набора принципов [SOLID](https://ru.wikipedia.org/wiki/SOLID_(%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)), но мы рассматриваем только техническую возможность.
### Неуместное применение
Любопытно, что чрезмерно глубокая иерархия наследования может привести к обратному эффекту — усложнению при попытке разобраться, кто от кого наследуется, и какой метод в каком случае вызывается. К тому же, не все архитектурные требования можно реализовать с помощью наследования. Поэтому применять наследование следует без фанатизма. Существуют рекомендации, призывающие предпочитать композицию наследованию там, где это уместно. Любая критика наследования, которую я встречал, подкрепляется неудачными примерами, когда наследование используется в качестве [золотого молотка](https://ru.wikipedia.org/wiki/%D0%97%D0%BE%D0%BB%D0%BE%D1%82%D0%BE%D0%B9_%D0%BC%D0%BE%D0%BB%D0%BE%D1%82%D0%BE%D0%BA). Но это совершенно не означает, что наследование в принципе всегда вредит. Мой нарколог говорил, что первый шаг — это признать, что у тебя зависимость от наследования.
Как при описании отношений двух сущностей определить, когда уместно наследование, а когда — композиция? Можно воспользоваться популярной шпаргалкой: спросите себя, **сущность А является сущностью Б**? Если да, то скорее всего, тут подойдет наследование. Если же **сущность А является частью сущности Б**, то наш выбор — композиция.
Применительно к нашей ситуации это будет звучать так:
1. Автобот является Трансформером? Да, значит выбираем наследование.
2. Пушка является частью Трансформера? Да, значит — композиция.
Для самопроверки попробуйте обратную комбинацию, получится фигня. Эта шпаргалка помогает в большинстве случаев, но бывают и другие факторы, на которые стоит опираться при выборе между композицией и наследованием. Кроме того, эти методы можно комбинировать для решения разного типа задач.
### Наследование статично
Еще одно важное отличие наследования от композиции в том, что наследование имеет статическую природу и устанавливает отношения классов только на этапе интерпретации/компиляции. Композиция же, как мы видели в примерах, позволяет менять отношение сущностей на лету прямо в рантайме — иногда это очень важно, поэтому об этом нужно помнить при выборе отношений (если конечно нет желания использовать [метапрограммирование](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%B0%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)).
### Множественное наследование
Мы рассмотрели ситуацию, когда два класса унаследованы от общего потомка. Но в некоторых языках можно сделать и наоборот — унаследовать один класс от двух и более родителей, объединив их свойства и поведение. Возможность наследоваться от нескольких классов вместо одного — это множественное наследование.
Вообще, в кругах иллюминатов бытует мнение, что множественное наследование — это грех, оно несет за собой [ромбовидную проблему](https://ru.wikipedia.org/wiki/%D0%A0%D0%BE%D0%BC%D0%B1%D0%BE%D0%B2%D0%B8%D0%B4%D0%BD%D0%BE%D0%B5_%D0%BD%D0%B0%D1%81%D0%BB%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) и неразбериху с конструкторами. Кроме того, задачи, которые решаются множественным наследованием, можно решать другими механизмами, например, механизмом интерфейсов (о котором мы тоже поговорим). Но справедливости ради, следует отметить, что множественное наследование удобно использовать для реализации [примесей](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%BC%D0%B5%D1%81%D1%8C_(%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)).
### Абстрактные классы
Кроме обычных классов в некоторых языках существуют абстрактные классы. От обычных классов они отличаются тем, что нельзя создать объект такого класса. Зачем же нужен такой класс, спросит читатель? Он нужен для того, чтобы от него могли наследоваться потомки — обычные классы, объекты которых уже можно создавать.
Абстрактный класс наряду с обычными методами содержит в себе абстрактные методы без имплементации (с сигнатурой, но без кода), которые обязан имплементировать программист, задумавший создать класс-потомок. Абстрактные классы не обязательны, но они помогают установить контракт, обязующий имплементировать определенный набор методов, дабы уберечь программиста с плохой памятью от ошибки имплементации.
Полиморфизм
-----------
Полиморфизм — свойство системы, позволяющее иметь множество реализаций одного интерфейса. Ничего непонятно. Обратимся к трансформерам.
Положим, у нас есть три трансформера: Оптимус, Мегатрон и Олег. Трансформеры боевые, стало быть обладают методом attack(). Игрок, нажимая у себя на джойстике кнопку «воевать», сообщает игре, чтобы та вызвала метод attack() у трансформера, за которого играет игрок. Но поскольку трансформеры разные, а игра интересная, каждый из них будет атаковать каким-то своим способом. Скажем, Оптимус — объект класса Автобот, а Автоботы снабжаются пушками с плутониевыми боеголовками (да не прогневаются фанаты трансформеров). Мегатрон — Десептикон, и стреляет из плазменной пушки. Олег — басист, и он обзывается. А в чем польза?
Польза полиморфизма в данном примере заключается в том, что код игры ничего не знает о реализации его просьбы, кто как должен атаковать, его задача просто вызвать метод attack(), сигнатура которого одинакова для всех классов персонажей. Это позволяет добавлять новые классы персонажей, или менять методы существующих, не меняя код игры. Это удобно.
Инкапсуляция
------------
Инкапсуляция — это контроль доступа к полям и методам объекта. Под контролем доступа подразумевается не только можно/неможно, но и различные валидации, подгрузки, вычисления и прочее динамическое поведение.
Во многих языках частью инкапсуляции является сокрытие данных. Для этого существуют модификаторы доступа (опишем те, которые есть почти во всех ООП языках):
* publiс — к атрибуту может получить доступ любой желающий
* private — к атрибуту могут обращаться только методы данного класса
* protected — то же, что и private, только доступ получают и наследники класса в том числе
```
class Transformer(){
public function constructor(){ }
protected function setup(){ }
private function dance(){ }
}
```
Как правильно выбрать модификатор доступа? В простейшем случае так: если метод должен быть доступен внешнему коду, выбираем public. В противном случае — private. Если есть наследование, то может потребоваться protected в случае, когда метод не должен вызываться снаружи, но должен вызываться потомками.
Аксессоры (геттеры и сеттеры)
-----------------------------
Геттеры и сеттеры — это методы, задача которых контролировать доступ к полям. Геттер считывает и возвращают значение поля, а сеттер — наоборот, принимает в качестве аргумента значение и записывает в поле. Это дает возможность снабдить такие методы дополнительными обработками. Например, сеттер при записи значения в поле объекта, может проверить тип, или входит ли значение в диапазон допустимых (валидация). В геттер же можно добавить, ленивую инициализацию или кэширование, если актуальное значение на самом деле лежит в базе данных. Применений можно придумать множество.
В некоторых языках есть синтаксический сахар, позволяющий такие аксессоры маскировать под свойства, что делает доступ прозрачным для внешнего кода, который и не подозревает, что работает не с полем, а с методом, у которого под капотом выполняется SQL-запрос или чтение из файла. Так достигается абстракция и прозрачность.
Интерфейсы
----------
Задача интерфейса — снизить уровень зависимости сущностей друг от друга, добавив больше абстракции.
Не во всех языках присутствует этот механизм, но в ООП языках со статической типизацией без них было бы совсем худо. Выше мы рассматривали абстрактные классы, затрагивая тему контрактов, обязующих имплементировать какие-то абстрактные методы. Так вот интерфейс очень смахивает на абстрактный класс, но является не классом, а просто пустышкой с перечислением абстрактных методов (без имплементации). Другими словами, интерфейс имеет декларативную природу, то есть, чистый контракт без капельки кода.
Обычно в языках, в которых есть интерфейсы, нет множественного наследования классов, но есть множественное наследование интерфейсов. Это позволяет классу перечислить интерфейсы, которые он обязуется имплементировать.
Классы с интерфейсами состоят в отношении «многие ко многим»: один класс может имплементировать множество интерфейсов, и каждый интерфейс, в свою очередь, может имплементироваться многими классами.
У интерфейса двустороннее применение:
1. По одну сторону интерфейса — классы, имплементирующие данный интерфейс.
2. По другую сторону — потребители, которые используют этот интерфейс в качестве описания типа данных, с которым они (потребители) работают.
Например, если какой-то объект помимо основного поведения, может быть сериализован, то пускай он имплементирует интерфейс «Сериализуемый». А если объект можно склонировать, то пусть он имплементирует еще один интерфейс — «Клонируемый». И если у нас есть какой-то транспортный модуль, который передает объекты по сети, он будет принимать любые объекты, имплементирующие интерфейс «Сериализуемый».
Представим, что каркас трансформера оборудован тремя слотами: слот для оружия, для генератора энергии и для какого-нибудь сканера. Эти слоты обладают определенными интерфейсами: в каждый слот можно установить только подходящее оборудование. В слот для оружия можно установить ракетную установку или лазерную пушку, в слот для генератора энергии — ядерный реактор или РИТЭГ (радиоизотопный термоэлектрический генератор), а в слот для сканера — радар или лидар. Суть в том, что каждый слот имеет универсальный интерфейс подключения, а уже конкретные устройства должны соответствовать этому интерфейсу. К примеру, на материнских платах используется несколько типов слотов: слот для процессора позволяет подключать различные процессоры, подходящие под данный сокет, а слот SATA — любой SSD или HDD накопитель или даже CD/DVD.
Обращаю внимание, что получившаяся система слотов у трансформеров — это пример использования композиции. Если же оборудование в слотах будет сменным в ходе жизни трансформера, то тогда это уже агрегация. Для наглядности, мы будем называть интерфейсы, как принято в некоторых языках, добавляя заглавную «И» перед именем: IWeapon, IEnergyGenerator, IScanner.
```
// описания интерфейсов:
interface IWeapon{
function fire() {} // декларация метода без имплементации. Ниже аналогично
}
interface IEnergyGenerator{
// тут уже два метода, которые должны будут реализовать классы:
function generate_energy() {} // первый
function load_fuel() {} // второй
}
interface IScanner{
function scan() {}
}
// классы, реализующие интерфейсы:
class RocketLauncher() : IWeapon
{
function fire(){
// имплементация запуска ракеты
}
}
class LaserGun() : IWeapon
{
function fire(){
// имплементация выстрела лазером
}
}
class NuclearReactor() : IEnergyGenerator
{
function generate_energy(){
// имплементация генерации энергии ядерным реактором
}
function load_fuel(){
// имплементация загрузки урановых стержней
}
}
class RITEG() : IEnergyGenerator
{
function generate_energy(){
// имплементация генерации энергии РИТЭГ
}
function load_fuel(){
// имплементация загрузки РИТЭГ-пеллет
}
}
class Radar() : IScanner
{
function scan(){
// имплементация использования радиолокации
}
}
class Lidar() : IScanner
{
function scan(){
// имплементация использования оптической локации
}
}
// класс - потребитель:
class Transformer() {
// привет, композиция:
IWeapon slot_weapon // Интерфейсы указаны в качестве типов данных.
IEnergyGenerator slot_energy_generator // Они могут принимать любые объекты,
IScanner slot_scanner // которые имплементируют указанный интерфейс
/*
в параметрах методов интерфейс тоже указан как тип данных,
метод может принимать объект любого класса,
имплементирующий данный интерфейс:
*/
function install_weapon(IWeapon weapon){
this.slot_weapon = weapon
}
function install_energy_generator(IEnergyGenerator energy_generator){
this.slot_energy_generator = energy_generator
}
function install_scanner(IScanner scanner){
this.slot_scanner = scanner
}
}
// фабрика трансформеров
class TransformerFactory(){
function build_some_transformer() {
transformer = new Transformer()
laser_gun = new LaserGun()
nuclear_reactor = new NuclearReactor()
radar = new Radar()
transformer.install_weapon(laser_gun)
transformer.install_energy_generator(nuclear_reactor)
transformer.install_scanner(radar)
return transformer
}
}
// использование
transformer_factory = new TransformerFactory()
oleg = transformer_factory.build_some_transformer()
```
[*Анимация №4*](https://habrastorage.org/webt/0a/q0/lw/0aq0lwydujaw7eofdnbgi5e52ka.gif)
К сожалению, в картинку не влезла фабрика, но она все равно необязательна, трансформера можно собрать и во дворе.
Обозначенный на картинке слой абстракции в виде интерфейсов между слоем имплементации и слоем-потребителем дает возможность абстрагировать одних от других. Вы можете это наблюдать, посмотрев на каждый слой в отдельности: в слое имплементации (слева) нет ни слова про класс Transformer, а в слое-потребителе (справа) нет ни слова про конкретные имплементации (там нет слов Radar, RocketLauncher, NuclearReactor и т. д.)
В таком коде мы можем создавать новые комплектующие к трансформерам, не затрагивая чертежи самих трансформеров. В то же время и наоборот, мы можем создавать новых трансформеров, комбинируя уже существующие комплектующие, либо добавлять новые комплектующие, не меняя существующих.
### Утиная типизация
Явление, которое мы наблюдаем в получившейся архитектуре, называется **утиной типизацией**: *если что-то крякает как утка, плавает как утка, и выглядит как утка, то, скорее всего — это утка*.
Переводя это на язык трансформеров, звучать будет так: если что-то стреляет как пушка, и перезаряжается как пушка, скорее всего, это пушка. Если устройство генерирует энергию, скорее всего, это генератор энергии.
В отличие от иерархической типизации наследования, при утиной типизации трансформеру пофиг, какого класса пушку ему дали, и пушка ли это вообще. Главное, что эта штуковина умеет стрелять! Это не достоинство утиной типизации, а скорее компромисс. Может быть и обратная ситуация, как на этой картинке ниже:
### ISP
(Interface Segregation Principle / Принцип разделения интерфейса / Четвертый принцип SOLID) призывает не создавать жирные универсальные интерфейсы. Вместо этого интерфейсы нужно разделять на более мелкие и специализированные, это поможет гибче их комбинировать в имплементирующих классах, не заставляя имплементировать лишние методы.
Абстракция
----------
В ООП все крутится вокруг абстракции. Существуют фанатики, утверждающие, что абстракция должна быть частью ООП-троицы (инкапсуляция, полиморфизм, наследование). А мой инспектор по УДО говорил обратное: абстракция присуща для любого программирования, а не только для ООП, поэтому она должна стоять отдельно. С другой стороны, то же самое можно сказать и про остальные принципы, но из песни слов не выкинешь. Так или иначе, абстракция нужна, и особенно в ООП.
### Уровень абстракции
Тут нельзя не процитировать одну известную шутку:
*— любую архитектурную проблему можно решить добавлением дополнительного слоя абстракции, кроме проблемы большого количества абстракций.*
В нашем примере с интерфейсами мы внедрили слой абстракции между трансформерами и комплектующими, сделав архитектуру более гибкой. Но какой ценой? Нам пришлось усложнить архитектуру. Мой психотерапевт говорил, что умение балансировать между простотой архитектуры и гибкостью приложения — это искусство. Выбирая золотую середину, следует опираться не только на собственный опыт и интуицию, но и на контекст текущего проекта. Поскольку будущее человек видеть пока не научился, нужно аналитически прикинуть, какой уровень абстракции и с какой долей вероятности может пригодиться в данном проекте, сколько времени потребуется на проработку гибкой архитектуры, и окупится ли затраченное время в будущем.
Неверный выбор уровня абстракции ведет к одной из двух проблем:
1. если абстракции недостаточно, дальнейшие расширения проекта будут упираться в архитектурные ограничения, которые ведут либо к рефакторингу и смене архитектуры, либо к обилию костылей (оба варианта обычно несут за собой боль и финансовые потери)
2. если уровень абстракции слишком высок, это приведет к оверинжинирингу в виде чересчур сложной архитектуры, которую трудно поддерживать, и излишней гибкости, которая никогда в этом проекте не пригодится. В этой ситуации любые простейшие изменения в проекте будут сопровождаться дополнительной работой для удовлетворения требований архитектуры (это тоже порой несет определенную боль и финансовые потери)
Еще важно понимать, что уровень абстракции определяется не для всего проекта в целом, а отдельно для разных компонентов. В каких-то местах системы абстракции может быть недостаточно, а где-то наоборот — перебор. Однако, неверный выбор уровня абстракции можно исправить своевременным рефакторингом. Ключевое слово — **своевременным**. Запоздалый рефакторинг провести проблематично, когда на данном уровне абстракции реализовано уже множество механизмов. Проводить обряд рефакторинга в запущенных системах может сопрягаться с острой болью в труднодоступных местах программиста. Это примерно как поменять фундамент в доме — дешевле построить рядом дом с нуля.
Давайте рассмотрим определение уровня абстракции из возможных вариантов на примере гипотетической игры «трансформеры-онлайн». Уровни абстракции в данном случае будут выступать как слои, каждый последующий рассматриваемый слой будет ложиться поверх предыдущего, забирая из него часть функционала в себя.
**Первый слой.** В игре есть один класс трансформера, все свойства и поведение описаны в нем. Это совсем деревянный уровень абстракции, подходит для казуальной игры, которая не предполагает никакой особой гибкости.
**Второй уровень.** В игре есть базовый трансформер с основными способностями и классы трансформеров со своей специализацией (типа разведчик, штурмовик, саппорт), которая описывается дополнительными методами. Тем самым игроку предоставляется возможность выбора, а разработчикам упрощается добавление новых классов.
**Третий уровень.** Помимо классификации трансформеров вводится агрегация с помощью системы слотов и компонентов (как в нашем примере с реакторами, пушками и радарами). Теперь часть поведения будет определяться тем, какой стаф игрок установил в своего трансформера. Это дает игроку еще больше возможностей для кастомизации игровой механики персонажа, а разработчикам дает возможность добавлять эти самые модули расширения, что в свою очередь упрощает работу гейм-дизайнерам по выпуску нового контента.
**Четвертый уровень.** В компоненты можно тоже включить собственную агрегацию, предоставляющую возможность выбора материалов и деталей, из которого собираются эти компоненты. Такой подход даст игроку возможность не только набивать трансформеров нужными комплектующими, но и самостоятельно производить эти комплектующие из различных деталек. Признаться, такой уровень абстракции я в играх никогда не встречал, и не без резона! Ведь это сопровождается значительным усложнением архитектуры, а регулировка баланса в таких играх превращается в ад. Но не исключаю, что такие игры существуют.
Как видим, каждый описанный слой, в принципе, имеет право на жизнь. Все зависит от того, какую именно гибкость мы хотим заложить в проект. Если в техническом задании ничего об этом не сказано, или автор проекта сам не знает, что может потребовать бизнес, можно посмотреть на похожие проекты в этой сфере и ориентироваться на них.
Паттерны проектирования
-----------------------
Десятилетия разработки привели к тому, что сформировался список наиболее часто применяемых архитектурных решений, которые со временем были классифицированы сообществом, и стали называться [паттернами проектирования](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F). Именно поэтому, когда я прочитал впервые про паттерны, я с удивлением обнаружил, что оказывается, многие из них я уже использую на практике, просто не знал, что у этих решений есть название.
Паттерны проектирования, как и абстракция, свойственны не только ООП разработке, но и другим парадигмам. Вообще, тема паттернов выходит за рамки данной статьи, но здесь хотелось бы предостеречь молодого разработчика, который только намерен познакомиться с паттернами. Это ловушка! Сейчас объясню, почему.
Предназначение паттернов — помощь в решении архитектурных проблем, которые либо уже обнаружились, либо, вероятнее всего, обнаружатся в ходе развития проекта. Так вот, у новичка, который прочитал про паттерны, может появиться непреодолимый соблазн использовать паттерны не для решения проблем, а для их порождения. А поскольку разработчик в своих желаниях необуздан, он может начать не решать задачу при помощи паттернов, а подстраивать любые задачи под решения с помощью паттернов.
Еще одна ценность от паттернов — формализации терминологии. Гораздо проще коллеге сказать, что в этом месте используется «цепочка обязанностей», чем полчаса рисовать поведение и отношения объектов на бумажке.
Заключение
----------
В условиях современных требований наличие в вашем коде слова class не делает из вас ООП-программиста. Ибо если вы не используете описанные в статье механизмы (полиморфизм, композицию, наследование и т. д.), а вместо этого применяете классы лишь для группировки функций и данных, то это не ООП. То же самое можно решить какими-нибудь неймспейсами и структурами данных. Не путайте, иначе на собеседовании будет стыдно.
Хочется закончить свою песнь важными словами. Любые описанные механизмы, принципы и паттерны, как и ООП в целом не стоит применять там, где это бессмысленно или может навредить. Это ведет к появлению статей со странными заголовками типа «Наследование — причина преждевременного старения» или «Синглтон может приводить к онкологическим заболеваниям».
Я серьезно. Если рассмотреть случай с синглтоном, то его повсеместное применение без знания дела, стало причиной серьезных архитектурных проблем во многих проектах. И любители забивать гвозди микроскопом любезно его нарекли антипаттерном. Будьте благоразумны.
К сожалению, в проектировании не существует однозначных рецептов на все случаи жизни, где что применять уместно, а где неуместно. Это будет постепенно укладываться в голове с опытом. | https://habr.com/ru/post/463125/ | null | ru | null |
# В чем сущность дизайна? Нахожу ответ на вопрос рассматривая UI и UX, новые термины в области веб-дизайна
Давно размышляю о существе дизайна. И постепенно на протяжении продолжительного времени у меня сформировалось мнение, которое позже при изучении материалов для написания статьи получило подтверждение со стороны специалистов знающих о дизайне не понаслышке. Впрочем обо всем по порядку.
Разговор на эту тему мне удобнее начать с обсуждения положения в терминологии веб-дизайна. Именно оно стало побудительным мотивом писать.
*Марио Ботта. Церковь св. Иоанна Крестителя в Моньо. Швейцария. 1986-1998*
Активно развивающаяся в последние 10 лет сфера веб-дизайна быстро прошла этап хаотического творчества и примерно пять лет назад ее зрелость ознаменовалась появлением двух «новых» терминов UI и UX дизайны. Цифру пять лет я вывожу из следующего факта. [В статье Википедии «Веб-дизайн»](https://ru.wikipedia.org/wiki/%D0%92%D0%B5%D0%B1-%D0%B4%D0%B8%D0%B7%D0%B0%D0%B9%D0%BD) в графе «литература» самая свежая книга имеющая веб-тематику датируется 2012 годом. И термины UI и UX там еще отсутствую. «Новых» я взял в кавычки потому, что ничего нового описываемые этими терминами явления из себя не представляют. Те же тенденции присутствуют и в остальных направлениях дизайна, но отечественные люди часто не хотят, а западные, благодаря ущербности болонской системы образования и не могут знать большего и поэтому снова и снова изобретают очередной велосипед. Одним словом, термины подаются, как нечто принципиально свежее и нигде ранее не появлявшееся. Впрочем, это правда, термины действительно свежие, а вот явления ими описываемые стары как мир.
Пробел перед новым разделом
UI
--
**UI** — это область внешнего видимого, воспринимаемого зрением художественного оформления любых объектов. Иными словами UI-дизайнеры это старые добрые художники-оформители или декораторы.
[Один из специалистов](https://blog.adn.agency/chem-otlichaetsya-ux-dizajner-i-ui-dizajner/) на блоге компании ADN так охарактеризовал роль UI-дизайнера.
> "**UI**-дизайнер (user interface) — это дизайнер интерфейсов в идеальной среде, который рисует кнопочки, иконочки, формы, подбирает шрифты и делает из всего гармоничный и красивый макет. Сайта, приложения, хоть чего, с чем будет взаимодействовать пользователь — хоть экрана вокзального терминала. И больше ни о чем не думает".
Что тут сказать, звание UI-дизайнер звучит куда как солиднее, представительнее и звучнее, чем художник-оформитель, ассоциирующийся у многих со скромным по возможностям, незатейливым неудачником недоучкой, который и художником то полноценным стать не смог и поэтому вынужден зарабатывать на хлеб насущный вторичным ремеслом. Декоратор звучит не намного лучше.
```
Забавно, как ассоциации меняют восприятие профессии, ведь по сути это одно и тоже.
```
### Откуда и почему UI?
А откуда возникла потребность в появлении такого термина UI? Термин появился на Западе, а там очень давно существует тенденция готовить узких специалистов. Возможно имеют место и причины приведенные ниже.
Что касается Родной стороны, то в советское время художниками-оформителями стали называть выпускников ХПУ (художественно профессиональных училищ), чем сразу резко уронили рейтинг термина, который стал ассоциироваться с профессиональным, а не высшим образованием. В 2004 году на парламентских слушаниях посвященных развитию образования бывший тогда председателем сенатского комитета по науке, культуре, образованию, здравоохранению и экологии Виктор Шудегов даже назвал систему ПТУ социальным отстойником.
«Все ощутимее разделение отечественной системы образования на элитарную и массовую, что ведет к нарушению принципа общедоступности качественного образования. “Школы и ПТУ превращаются в социальный отстойник!” — [заключил Шудегов](http://www.solidarnost.org/thems/obshestvo/obshestvo_1364.html)».
Комментарии как говориться излишни. Мало кому захочется чувствовать себя частью осадка социального отстойника.
*Художница, мастер (МГХПТК) Татьяна Владимировна Будейко (вторая справа) со своими ученицами.*
> С председателем сенатского комитета согласиться не могу, так как сам до поступления в ВУЗ закончил ХПУ №42 в Екатеринбурге и не сколько не жалею об этом. Было интересно, новые знания, знакомство с неординарными личности, со многими из которых я учились потом в Академии.
Декораторское дело многими воспринимается как нечто чрезвычайно традиционное, древнее, тянущееся откуда то из старины и как следствие не модное, не востребованное и не креативное. А еще узко специализированное. Другими словами декораторы у нас умеют только стены орнаментами расписывать, куда им до дизайнеров, так или примерно так думают многие.
Но в действительности огромное количество поступивших на специальность дизайн, уверен, что большинство (особенно девочки) за время обучения наибольший интерес проявляют именно к художественной части преподаваемых знаний, да они им и легче даются. И как следствие в будущем могут очень красиво визуализировать свои идеи, но в процессе разработки проекта уделяют инженерной части наименьшее внимание, считая ее не своим делом. Что конечно же и грустно и смешно, в первую очередь тем, кто потом мучительно пытается воплотить плоды их творчества в жизнь. И сильно ругается при этом.
Эта ситуация делает очевидным неполноценность таких специалистов, но в дипломах у них написано, что они дизайнеры и они ни за что не согласятся переименовываться в каких-нибудь там декораторов или тем более художников-оформителей. Да и место им на рынке труда безусловно есть. Потому что некоторым из выпускников факультетов дизайна (о спасение) больше нравиться заниматься инженерными изысканиями или кроме них это просто некому на предприятии сделать и вся подобная работа падает на их плечи, а с красивыми картинками и девочки справятся.
*Красивые картинки и девушка UI дизайнер.*
Поэтому для российских дизайнеров как нельзя кстати появление нового термина, который с одной стороны преобразует конфуз профессиональной неполноценности выпускников вузов и курсов в понятие о специализации. А с другой в очередной раз делает очевидной двойственную природу полноценного дизайна с большой буквы.
Пробел перед новым разделом
UX
--
UX действительно всегда пишут с большой буквы. Что же это такое?
[Трактовка от Алексея Сегодина](https://habrahabr.ru/post/321312/) с блока «Хабрахабр». Алексей Сегодин ([Aleksei\_Segodin](https://habr.com/users/aleksei_segodin/)) арт-директор и дизайнер (очень) широкого профиля.
> "****UX**** — это **User Experience** (дословно: «опыт пользователя»). То есть это то, какой опыт/впечатление получает пользователь от работы с вашим интерфейсом. Удается ли ему достичь цели и на сколько просто или сложно это сделать".
Недавно я заглянул в Большую Советскую Энциклопедию. Как раз чтобы прояснить для себя выше означенный вопрос и обнаружил, что появился UX вместе с началом профессионального развития других отраслей дизайна на второй волне научно-технической революции, и оказывается на самом деле в 2017 году новомодному UX исполняется аж 77 лет!
Удивительно символично. 77 это число символизирующее бесконечное милосердие Божие и человеческое.
Так вот в статье [«Инженерная психология»](http://bse.sci-lib.com/article054686.html) я нашел то самое описание и те самые цели и задачи, которые теперь решает UX.
**Статья БСЭ «Инженерная психология»**Инженерная психология, одна из специальных дисциплин психологии. Инженерная психология решает следующие задачи:
1) рациональная организация деятельности людей в системах «человек и машина», предназначенных для управления и обработки информации;
2) целесообразное распределение функций между управляющим и обслуживающим персоналом и техническими средствами автоматизации;
3) оптимизация процессов информационного обеспечения и принятия решения. В решении этих задач Инженерная психология основывается на данных смежных наук, таких, как психология личности, психология труда и др., а также тесно взаимодействует с системотехникой и инженерными дисциплинами.
Инженерная психология возникла в 40-х гг. 20 в. и первоначально развивалась как направление традиционной психологии труда, основным объектом которой было исследование непосредственного взаимодействия человека с предметами и орудиями труда (инструменты, станок, конвейер, средства транспорта и т. п.). Задачи Инженерная психология сводились в основном к критическому анализу ошибок проектирования оборудования или подготовки операторов и выявлению факторов, влияющих на эффективность систем «человек и машина». Были выработаны полезные рекомендации по рациональному конструированию пультов управления, шкал приборов, средств индикации и т. п. Становление Инженерная психология как самостоятельной научной психологической дисциплины было обусловлено автоматизацией производства и развитием средств дистанционного контроля и управления. В 50-х гг. были определены в общих чертах закономерности приёма и переработки информации человеком, а в 60-х гг. — общие принципы организации взаимодействия человека и ЭВМ. Выработанные рекомендации нашли практическое применение при автоматизации процессов управления на производстве, в авиации, космонавтике и т. д. В конце 60-х гг. Инженерная психология перешла к синтезу, проектированию человеческой деятельности в больших системах, она вносит определённый вклад в разработку мероприятий по повышению эффективности их функционирования.
Задача рациональной организации деятельности людей в системах «человек и машина» включает анализ структуры коллектива и согласование её с выбранной структурой управления. При этом учитывается опосредствованный характер общения и связей между членами коллектива и предусматривается такое распределение функциональных обязанностей, которое в наибольшей степени отвечало бы поставленной цели. Важной проблемой является рациональное распределение ответственности за принимаемые решения и согласование интересов каждого члена коллектива. Для успешной деятельности малых групп (экипажи летательных аппаратов, персонал пунктов управления и т. п.) необходимо выявление критериев психологической совместимости членов группы, что очень важно при их комплектовании. Психологическая совместимость — важнейшее условие сохранения работоспособного коллектива, особенно изолированного на длительное время от привычного окружения.
При распределении функций в системе «человек и машина» исходят из того, что решение творческих задач, связанных с логическим анализом ситуации, оценкой и прогнозом её изменений, должно выполняться человеком; на машину возлагается выполнение рутинных, повторяющихся операций, в основном комбинаторно-вычислительного характера, а также хранение, обработка и оперативная выдача больших объёмов информации. Электронную вычислительную машину следует рассматривать как квалифицированного помощника и собеседника, способствующего усилению творческого мышления и интуиции человека.
Оптимизация процессов информационного обеспечения и принятия решения требует организации выборочного управления источниками информации на пунктах управления и сводится к выбору наилучших характеристик информационной модели: степени обобщения (детализации) информации, выводимой на устройства отображения; объёма и темпа её обновления; способов кодирования, обеспечивающих однозначное восприятие и запоминание информации. Основной принцип организации информационной подготовки принятия решения состоит в том, чтобы по требованию оператора ЭВМ могла производить все трудоёмкие и вспомогательные преобразования имеющейся информации, а результаты выдавать в виде, наиболее подходящем для решения оперативных задач. В автоматизированных системах оператор лишён возможности непосредственного воздействия на управляемый объект (предмет труда). В этих условиях возникла новая задача: согласование не только исполнительных двигательных актов человека с динамическими свойствами и характеристиками орудий и средств производства (эта задача решалась методами психологии труда), но главным образом способностей оператора по приёму, переработке и передаче информации с информационными характеристиками объекта управления.
Проектирование человеческой деятельности основывается на фундаментальных исследованиях высших психических функций человека — восприятия, памяти, мышления (образного и понятийного), которые являются внутренними психологическими инструментами и средствами деятельности человека. К числу таких внутренних средств относятся опыт, знания, программы, схемы и навыки оператора, составляющие в совокупности его профессиональный облик. На основе внутренних средств деятельности формируются постоянные и оперативные образно-концептуальные модели, определяющие деятельность оператора и процесс принятия им решения. Оператор, использующий арсенал внутренних средств деятельности, опирается на внешние средства, к которым относятся информационные модели, реализуемые на устройствах отображения информации или в форме документа, машинные алгоритмы и др. вспомогательные средства подготовки решения задач, органы управления и средства коммуникации. Можно сказать, что проектирование деятельности человека состоит в согласовании внутренних и внешних средств деятельности, проектировании согласованных концептуальных и информационных моделей, полностью использующих психологические возможности оператора по приёму и переработке информации.
В разных условиях центр тяжести этого проектирования может приходиться либо на внешние, либо на внутренние средства деятельности. Существует ряд информационных моделей, которые можно условно назвать моделями-изображениями реальной обстановки. К их числу относятся отображение воздушной обстановки на экране радиолокатора, аэрофотоснимки, снимки процессов в трековых камерах и др. Эти модели определяются имеющимися техническими возможностями сбора первичной информации. Инженерно-психологические рекомендации по работе с такими информационными моделями касаются условий освещённости, уровня контраста, режима работы и т. п. Основная задача психологов в этих случаях состоит в анализе деятельности и формирования её внутренних средств. Существуют и др. информационные модели, когда оператор имеет дело не с первичной, а с предварительно обработанной информацией, например поступающей на устройства отображения из ЭВМ. В этих случаях разработчики и специалисты по Инженерная психология имеют большой простор для технической реализации различных типов информационных моделей и основное внимание может быть обращено на создание адекватных внешних средств деятельности оператора.
К важнейшим проблемам Инженерная психология следует отнести: разработку методов профессионального отбора, обучения и тренировки операторов; выявление специфики деятельности операторов в конкретных системах и разработку рекомендаций, норм и стандартов по учёту человеческого фактора при создании и эксплуатации производственных, военных и организационных систем; проектирование рациональных информационных моделей и органов управления; формулирование требований к алгоритмам ЭВМ и способам решения задач оператором; разработку методов контроля функциональных состояний операторов (утомления, психической напряжённости, стресса); разработку принципов построения операторских пунктов в соответствии с требованиями технической эстетики и художественного конструирования.
Развиваясь как прикладная научная дисциплина, Инженерная психология в постановках задач, методах исследований и разработках использует достижения теоретической и экспериментальной психологии и вместе с тем открывает перед ними новые проблемы исследования. На современном этапе для Инженерная психология особенно важны данные, полученные при изучении индивидуальных психологических черт личности, особенно эмоциональной сферы, сферы потребностей и мотивов деятельности. Выявление собственно психологических критериев и методик исследования механизмов деятельности оператора является необходимым условием решения инженерно-психологических задач. Организации и лица, ведущие исследовательскую, консультативную и педагогическую деятельность в области Инженерная психология, объединяются за рубежом в общества: «Человеческие факторы и биотехнология» (США), «Эргономика» (Великобритания, Франция и Япония), «Антропотехника» (ФРГ). В СССР инженерно-психологические службы координируются соответствующими секциями Общества психологов СССР и Научного совета по комплексной проблеме «Кибернетика» при Президиуме АН СССР. См. также Эргономика.
Лит.: Инженерная психология. [Сб. ст.], М., 1964; Инженерная психология. Сб. ст., пер. с англ., М., 1964; Ломов Б. Ф., Человек и техника, М., 1966; Инженерно-психологические требования к системам управления, М., 1967; Вудсон У. Е., Коновер Д. В., Справочник по инженерной психологии для инженеров и художников-конструкторов, пер. с англ., М., 1968; Иванов С., Человек среди автоматов, М., 1969; Мейстер Д., Рабидо Дж., Инженерно-психологическая оценка при разработке систем управления, пер. с англ., М., 1970; Военная инженерная психология, М., 1970; Эргономика. Принципы и рекомендации, в. 1—4, М., 1970—72.
В. П. Зинченко, Г. Л. Смолян. [Читать дальше.](http://bse.sci-lib.com/article054686.html)
Ну что же поздравляю ветерана с 77-летием, хотя по сравнению с UI, он находится еще в зародышевом состоянии. Можно вспомнить [наскальные изображения в пещерах Альтами́ра](https://www.nkj.ru/archive/articles/31045/), Ласкó или Шове́ выполненные какими то доисторическими UI-специалистами.
*Рисунок бизона на стене пещеры Альтамира. Фото: Henri Brenil, Emile Cartailhac/Wikimedia Commons*
Возможно самое яркое произведение советского UX — центр управления полетами первых советских ракетоносителей.
*Подмосковный (СССР) ЦУП.*
Так же можно вспомнить [устройство пульта управления синхрофазотроном](http://www.krasfun.ru/2015/01/chto-takoe-sinxrofazotron/) в Объединенном институте ядерных исследований (ОИЯИ) расположенном в городе Дубна.
*Зал управления синхрофазотроном с пультом в центре.*
*Крупным планом часть пульта управления синхрофазотроном.*
И пульт управления элементами атомной станции в Курске.
А почему собственно психология?
-------------------------------
Может вызвать удивление, а почему собственно психология? Ведь круг поднимаемых вопросов, используемых отраслей знания при дизайн-проектировании значительно шире. Здесь можно назвать и анатомию, и биохимию и биомеханику человеческого тела. Они востребованы при формировании взаимоотношений между объектом дизайна и человеком. А далее, после того как человек прикоснулся к рассматриваемому объекту, взял его в руки или надел на себя, они вдвоем уже вступают во взаимоотношения с окружающим миром и это требует от разработчиков дополнительно знаний социологии, политологии, экономики, логики, логистики, материаловедения, сопротивления материалов и др. На что можно сказать, что инженерия как поприще и область человеческого знания чрезвычайно широка и даже напоминает мне природоведение, поэтому включает все вышеперечисленное.
А вот психология выделена особо потому, что при всех расчетах, предположениях, изысканиях и обоснованиях дизайнер всегда отталкивается от личности человека, как от печки. Человеческая душевность и духовность главные ориентиры.
Пробел перед новым разделом
О сущности дизайна
------------------
Ну вот, разобрался с тем, что такое UI в дизайне и что такое UX. А теперь можно обратиться к вопросу сущности дизайна как такового. Что он есть, если не делить его на части и подразделы?
Чтобы это понять нам нужно обратиться к архитектуре и архитекторам.
### Спросим у архитекторов
Говорят, что из них получаются отличные дизайнеры. И вообще, первыми дизайн в современном его понимании стали делать именно архитекторы. Почему бы это? А собственно, кто такой архитектор? Он строитель? Да! Он инженер? Конечно! Он творец и художник? Безусловно!
Последнее вспоминают наверно чаще чем все остальное. На лицо наличие выше рассмотренных явлений. Тут вам и UI, здесь же и UX!
Так, вот оно что!
Чтобы не быть голословным приведу [три цитаты](http://claw.ru/a-architect/main.html) из введения в книгу [«Архитектура. Энциклопедия» Глазычева Вячеслава Леонидовича](https://eknigi.org/nauka_i_ucheba/13927-arxitektura-yenciklopediya.html) выпущенную в 2002 году издательством «Астрель».
> «Вокруг больших городов великое множество „вилл“ и „коттеджей“, возведенных прорабами, так как по скупости и неразумию заказчики хотели сэкономить на гонораре архитектора. Эти „дворцы“ не только безобразны, но, как правило, еще и смешны...»
> «Иногда, очень редко, бывают исключения — в тех случаях, когда в душе строителя прячется нераскрытый, нереализованный художник. В этих случаях возникают некие архитектурные чудеса, обитать в которых сложно, но по крайней мере никто не останется к ним равнодушен».
> «Увы, массовая, наиболее распространенная архитектура жилища всегда была монотонной — дело спасали церкви, соборы, башни, дворцы. Иными словами, архитектура довольно редка, в известной мере аристократична как именно искусство, когда недостаточно относительного комфорта и безопасности, а гармоничность и красота или гармоничное величие изначально определяются как необходимое свойство результата»
Также приведу [слова архитектора Виктора Головина](https://www.youtube.com/watch?v=FkZFlXX1Tgs) автора интернет-проекта «Архитектурная экспертиза интернета».
> «Архитектор должен охватывать объект со всех его сторон! Должен устремляться в глубину, должен чувствовать дух архитектуры. А инженерия это мертвый продукт!»
Из видеоролика «Архитектор — Главный строитель, или соль лишенная силы?»
---
Можно, даже нужно, смело утверждать, что **архитектура это самая старейшая, состоявшаяся и опытнейшая отрасль настоящего дизайна!**
---
Отрасль уникальная. Нужда в ней появилась на самой заре развития человечества. С производством смартфонов, автомобилей и кнопочных интерфейсов люди решили подождать, а вот крыша над головой понадобилась сразу, крепкая, удобная и желательно красивая.
Поэтому по прошествии тысячелетий развития архитектуры мы совершенно органично воспринимаем архитектора как человека безусловно чрезвычайно творческого, настоящего художника, творца, который помимо этого в совершенстве разбирается в сопромате, начертательной геометрии, черчении, проектировании, расчетах и т. п. Для нас это естественно, само собой разумеется, а иначе какой же он архитектор!?
Неважно, что не все выпускники архитектурных вузов становятся именитыми мастерами и возглавляют свои фирмы или тем более школы. Я говорю не об этом, я рассматриваю культурный архетип. А он именно такой.
И проблемы с делением архитекторов на архитекторов-художников и архитекторов-инженеров не наблюдается. Подобная идея, будь она озвучена была бы воспринята как нонсенс, как нелепица и глупость.
Любишь рисовать и заниматься творчеством, но не хватает дарований или знаний провести правильные расчеты, составить грамотные чертежи и провести научные проектные изыскания, значит ты не архитектор и все. И нечего лапшу на уши вешать!
### Что такое настоящий дизайн?
Из вышесказанного следует, что настоящих дизайнеров не очень много, так как дизайн в любой сфере профессия сложная и не каждому по плечу. Для желающих глубоко погрузиться в тему могу посоветовать прочитать 1 и 2 части доклада сотрудника Национального исследовательского университета «МЭИ» Горнова Александра Олеговича [«Дизайн и инженерия. Проблемы взаимопроникновения»](http://dgng.pstu.ru/conf2012/papers/18/). В котором я нашел подтверждение своим размышлениям о существе дизайна.
Опершись на выше сказанное выведу два определение дизайна как такового, короткое и развернутое, на выбор.
---
Дизайн — **художественная инженерия**.
Дизайн — **ориентирующееся на человека инженерно-художественное проектирование**.
---
Из определений мне больше нравится первое, хотя они равнозначны по смыслу, и оба меня устраивают.
### Дизайн — как это по русски?
К слову сказать, художественная инженерия звучит длинно, хотя это словосочетание и может использоваться в текстах в тех случаях, когда нужно избежать тавтологии, но как всем известно длинные названия хуже запоминаются, труднее произносятся и меньше любятся. А что, разве нет в русском языке слова способного заменить английский термин дизайн? Как вы думаете? Я раньше думал, что нет, но в процессе написания этой статьи понял, что ошибался.
К счастью для нас есть исконно русский логос содержащий в себе все многочисленные смыслы и значения, вкладываемые в понятие **design**.
---
По русски это называется **домостроительство**.
Или коротко **домострой**.
---
Правда здорово? Вроде и слово до боли знакомое. Дело в том, что понятие [дом](http://www.symbolarium.ru/index.php/%D0%94%D0%BE%D0%BC), образующее корень термина имеет широкое философское значение.
> [**Дом**](http://htthttp://www.symbolarium.ru/index.php/%D0%94%D0%BE%D0%BCp://) в русском языке является древним образом или аллегорией мира, мироздания, в узком утилитарном смысле образом системы.
Вообще вопрос засилья английской лексики сейчас чрезвычайно актуален. Ведь мы не американские или британские или западноевропейские дизайнеры, простите, домостроители. **Мы русские!**
Правда это тоже здорово? И говорить должны по-русски, если хотим иметь свою уникальную школу, традицию, культуру, идею, веру, судьбу и в конце концом домострой.
Но это тема уже для отдельного большого разговора и другой статьи. | https://habr.com/ru/post/331136/ | null | ru | null |
# Тематическое моделирование репозиториев на GitHub
[Тематическое моделирование](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D0%BC%D0%BE%D0%B4%D0%B5%D0%BB%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) — подраздел машинного обучения, посвященный извлечению абстрактных «тем» из набора «документов». Каждый «документ» представлен [мешком слов](https://en.wikipedia.org/wiki/Bag-of-words_model), т.е. множеством слов вместе с их частотами. Введение в тематическое моделирование прекрасно описано проф. [К. В. Воронцовым](http://www.machinelearning.ru/wiki/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Vokov) в лекциях ШАД [[PDF](http://www.machinelearning.ru/wiki/images/e/e6/Voron-ML-TopicModeling-slides.pdf)]. Самая известная модель ТМ — это, конечно, [Латентное размещение Дирихле](https://ru.wikipedia.org/wiki/%D0%9B%D0%B0%D1%82%D0%B5%D0%BD%D1%82%D0%BD%D0%BE%D0%B5_%D1%80%D0%B0%D0%B7%D0%BC%D0%B5%D1%89%D0%B5%D0%BD%D0%B8%D0%B5_%D0%94%D0%B8%D1%80%D0%B8%D1%85%D0%BB%D0%B5) (LDA). Константину Вячеславовичу удалось обобщить все возможные тематические модели на основе мешка слов в виде [аддитивной регуляризации](http://link.springer.com/article/10.1007/s10994-014-5476-6) (ARTM). В частности, LDA тоже входит в множество моделей ARTM. Идеи ARTM воплощены в проекте [BigARTM](https://github.com/bigartm/bigartm).
Обычно тематическое моделирование применяют к текстовым документам. Мы в [source{d}](http://sourced.tech) (стартап в Испании) перевариваем биг дату, полученную из GitHub репозиториев (и скоро примемся за каждый публично доступный репозиторий в мире). Естественным образом возникла идея интерпретировать каждый репозиторий как мешок слов и натравить BigARTM. В этой статье пойдет речь о том как мы выполнили по сути первое в мире тематическое исследование крупнейшего хранилища open source проектов, что из этого получилось и как это повторить. **docker inside!**
TL;DR:
```
docker run srcd/github_topics apache/spark
```
(заменить `apache/spark` на любой GitHub реп по желанию).
» [Таблица OpenDocument с извлеченными темами.](https://storage.googleapis.com/github-repositories-topic-modeling/topics.ods)
» [JSON с извлеченными темами.](https://storage.googleapis.com/github-repositories-topic-modeling/topics.json)
» [Обученная модель](https://storage.googleapis.com/github-repositories-topic-modeling/repo_topic_modeling.pickle.gz) — 40МБ, gzipped pickle для Python 3.4+, Pandas 1.18+.
» [Dataset на data.world](https://data.world/vmarkovtsev/github-source-code-names).
Теория
------
Задана тематическая вероятностная модель на множестве документов  которая описывает частоту появления слова  в документе  с темами :
%20%3D%20%5Csum_%7Bt%5Cin%20T%7D%20p(w%7Ct)%20p(t%7Cd)%0A)
где ) — вероятность отношения слова  к теме , ) — вероятность отношения темы  к документу , т.о. формула выше это просто выражение [полной вероятности](https://ru.wikipedia.org/wiki/%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%BF%D0%BE%D0%BB%D0%BD%D0%BE%D0%B9_%D0%B2%D0%B5%D1%80%D0%BE%D1%8F%D1%82%D0%BD%D0%BE%D1%81%D1%82%D0%B8), при условии истинности гипотезы независимости случайных величин: %20%3D%20p(w%7Ct)). Слова берутся из словаря , темы принадлежат множеству  которое представляет собой просто серию индексов ![\inline [1, 2, \dots n_t]](https://tex.s2cms.ru/svg/%5Cinline%20%5B1%2C%202%2C%20%5Cdots%20n_t%5D).
Нам нужно восстановить ) и ) из заданного набора документов . Обычно считают что %20%3D%20%5Cfrac%7Bn_%7Bdw%7D%7D%7Bn_d%7D), где  — количество вхождений  в документ , однако это подразумевает что все слова одинаково важные что не всегда справедливо. Под «важностью» здесь имеется в виду мера, негативно скоррелированная с общей частотой появления слова в документах. Обозначим восстанавливаемые вероятности %20%3D%20%5Cphi_%7Bwt%7D) и %20%3D%20%5Ctheta_%7Btd%7D). Т.о. наша задача сводится к стохастическому матричному разложению, которая некорректно поставлена:
(S%5E%7B-1%7D%5CTheta)%20%3D%20%5CPhi'%20%5Ccdot%20%5CTheta'%0A)
В задачах машинного обучения обычно применяют [регуляризацию](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B3%D1%83%D0%BB%D1%8F%D1%80%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F_(%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0)) как способ улучшить характеристики модели на неизвестных данных (как следствие, уменьшается [переобучение](https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D0%B5%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5), сложность и т.д.); в нашем случае, она просто **необходима**.
Задачи наподобие описанной выше решаются с помощью [метода максимального правдоподобия](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%BC%D0%B0%D0%BA%D1%81%D0%B8%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BF%D1%80%D0%B0%D0%B2%D0%B4%D0%BE%D0%BF%D0%BE%D0%B4%D0%BE%D0%B1%D0%B8%D1%8F):
при условиях
Суть ARTM в том чтобы естественным образом добавить регуляризацию в виде дополнительных слагаемых:
%20%5Cto%20%5Cmax_%7B%5CPhi%2C%5CTheta%7D%0A)
Поскольку это простое сложение, мы можем комбинировать различные регуляризаторы в одной оптимизации, например, проредить матрицу и увеличить независимость тем. LDA формулируется в терминах ARTM так:
_%7BDirichlet%7D%20%3D%20%5Csum_%7Bt%2Cw%7D%20(%5Cbeta_w%20-%201)%5Cln%20%5Cphi_%7Bwt%7D%20%2B%20%5Csum_%7Bd%2Ct%7D%20(%5Calpha_t%20-%201)%5Cln%20%5Ctheta_%7Bt%2Cd%7D%0A)
Переменные  и  могут быть эффективно вычислены с помощью итеративного [EM-алгоритма](https://ru.wikipedia.org/wiki/EM-%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC). Десятки готовых ARTM регуляризаторов готовы к бою в составе [BigARTM](https://github.com/bigartm/bigartm).
На этом вынужденный рерайт лекции ШАДа заканчивается и начинается
Практика
--------
Для анализа на октябрь 2016 года были доступны около 18 миллионов репозиториев на GitHub. Их на самом деле гораздо больше, просто мы отбросили форки и «хард форки» (форк не отмечен GitHub-ом). Положим каждый репозиторий это , а каждое имя в исходниках это . Анализ исходников делался теми же инструментами, что и при глубоком обучении исходному коду в ранних экспериментах (см. наши презентации с последних конференций [RE·WORK](https://www.re-work.co/): [Берлин](https://goo.gl/4zq8g9) и [Лондон](https://goo.gl/wRQCLS)): первичная классификация [github/linguist](https://github.com/github/linguist)-ом и парсинг на основе [Pygments](http://pygments.org/). Текстовые файлы общего назначения отбрасывались, например [README.md](http://README.md).
Имена из исходников следует извлекать не «в лоб», например, `class FooBarBaz` добавляет 3 слова в мешок: `foo`, `bar` и `baz`, а `int wdSize` добавляет два: `wdsize` и `size`. Кроме того, имена стеммировались [Snowball](http://snowballstem.org/)-ом из [NLTK](http://www.nltk.org/), хотя специально мы не исследовали пользу от этого. Последний этап предобработки заключался в вычислении логарифмической версии [TF-IDF](https://en.wikipedia.org/wiki/Tf%E2%80%93idf) взвешивания (снова, специально не исследовали, просто копировали [решения](https://www.quora.com/Why-is-the-performance-improved-by-using-TFIDF-instead-of-bag-of-words-in-LDA-clustering) из обычного НЛП) и фильтрации слишком редких и общеупотребительных имен, в нашем случае, границы были 50 и 100000 соответственно.
После того как ARTM выдал результат, нужно было вручную дать имена темам, основываясь на ключевых словах и репозиториях-представителях. Число тем было выставлено в 200, и как потом оказалось, нужно было поставить больше, т.к. тем на Гитхабе очень много. Нудная работа отняла целую неделю.
Предобработка была выполнена на [Dataproc](https://cloud.google.com/dataproc/) aka Spark в облаке Google, а основные действия производились локально на мощном компьютере. Результирующая разреженная матрица имела размер около 20 GB, и ее пришлось преобразовать в текстовый формат Vowpal Wabbit, чтобы ее смог переварить BigARTM CLI. Данные были перемолоты довольно быстро, за пару часов:
```
bigartm -c dataset_vowpal_wabbit.txt -t 200 -p 10 --threads 10 --write-model-readable bigartm.txt --regularizer "0.05 SparsePhi" "0.05 SparseTheta"
Parsing text collection... OK.
Gathering dictionary from batches... OK.
Initializing random model from dictionary... OK.
Number of tokens in the model: 604989
================= Processing started.
Perplexity = 586350
SparsityPhi = 0.00214434
SparsityTheta = 0.422496
================= Iteration 1 took 00:11:57.116
Perplexity = 107901
SparsityPhi = 0.00613982
SparsityTheta = 0.552418
================= Iteration 2 took 00:12:03.001
Perplexity = 60701.5
SparsityPhi = 0.102947
SparsityTheta = 0.768934
================= Iteration 3 took 00:11:55.172
Perplexity = 20993.5
SparsityPhi = 0.458439
SparsityTheta = 0.902972
================= Iteration 4 took 00:11:56.804
...
```
`-p` задает число итераций. Уверенности в том, какие регуляризаторы использовать, не было, так что активирована только «sparsity». Сказалось отсутствие подробной документации (разработчики пообещали это исправить). Важно отметить, что объем оперативной памяти, который потребовался для работы на пике был не больше 30 GB, что очень круто на фоне [gensim](https://radimrehurek.com/gensim/) и, прости господи, [sklearn](http://scikit-learn.org/stable/).
Темы
----
В итоге, 200 тем можно поделить на следующие группы:
* **Понятия** — общие, широкие и абстрактные.
* **Человеческие языки** — оказалось, что по коду можно примерно определить родной язык программиста, наверное, отчасти благодаря смещению от стемминга.
* **Языки программирования** — не то чтобы интересные, т.к. эту информацию мы и так знаем. У ЯП обычно есть стандартная библиотека aka «батарейки» из классов и функций, которые импортируются/включаются в исходники, и соответствующие имена детектируются нашим тематическим моделированием. Некоторые темы оказались у́же чем ЯП.
* **Общий IT** — попали бы в *Понятия* если имели выразительный список ключевых слов. Репозитории часто ассоциируются с уникальным набором имен, например, говорим Рельсы, держим в уме ActiveObject и прочий Active. Частично перекликается с [Философия программирования 2 — Миф и язык](https://habrahabr.ru/post/247363/).
* **Сообщества** — посвященные конкретным, потенциально узким технологиям или продуктам.
* **Игры**.
* **Бред** — 2 темам так и не удалось найти разумное объяснение.
### Понятия
Пожалуй, самая интересная группа с кучей извлеченных фактов из повседневной жизни:
1. В пицце есть сыр, а еще ее упоминают многие репозитории.
2. Термины из математики, линейной алгебры, криптографии, машинного обучения, цифровой обработки сигналов, генной инженерии, физики элементарных частиц.
3. Дни недели. Monday, Tuesday и т.д.
4. Всевозможные факты и персонажи из RPG и других игр в жанре фэнтези.
5. В IRC есть псевдонимы.
6. Множество шаблонов проектирования (говорим за них спасибо Java и PHP).
7. Цвета. Включая некоторые экзотические (говорим за них спасибо [CSS](https://habrahabr.ru/company/ua-hosting/blog/269013/)).
8. В электронной почте есть CC, BCC, и ее посылают протоколом SMTP и получают POP/IMAP-ом.
9. Как создать хороший datetime picker. Кажется, это весьма типичный проект на GitHub, хе-хе.
10. Люди работают за деньги и тратят их на покупку домов и вождение (очевидно, из дома на работу и назад).
11. Всевозможное «железо».
12. Исчерпывающий список терминов HTTP, SSL, Internet, Bluetooth и WiFi.
13. Все что вы хотели бы узнать про управление памятью.
14. Что гуглить есть хочется сделать свою прошивку на основе Android.
15. Штрихкоды. Огромное число разных видов.
16. Люди. Они делятся на мужчин и женщин, они живут и занимаются сексом.
17. Отличный список текстовых редакторов.
18. Погода. Много типичных слов.
19. Открытые лицензии. Вообще говоря, они не должны были попасть в отдельную тему т.к. имена и тексты лицензий в теории не пересекаются. По опыта работы с Pygments, некоторые ЯП поддерживаются гораздо хуже чем другие и, судя по всему, некоторые были неправильно распарсены.
20. Коммерция. У магазины предлагают скидки и продают товары покупателям.
21. Биткоины и блокчейн.
### Человеческие языки
В список тем вошли испанский, португальский, французский и китайский. Русский в отдельную тему не сформировался, что свидетельствует скорее о более высоком уровне наших программистов на GitHub, пишущих сразу на английском, чем о малом количестве русских репозиториев. В этом смысле, китайские репозитории убивают.
### Языки программирования
Интересная находка в ЯП — это тема «Non-native English PHP», ассоциированная с проектами на PHP, написанными людьми, для которых английский не родной. Видимо, эти две группы программистов как-то принципиально по-разному пишут код. Кроме того, есть две темы, относящиеся к Java: JNI и байткод.
### Общий IT
Здесь не так интересно. Существует много репозиториев с ядрами ОС — большие, шумные и несмотря на наши старания они изгадили некоторые топики. Тем не менее, кое-что стоит упомянуть:
* Много информации о дронах. Они работают на Linux.
* Есть много реализаций Ruby. Часто встречаются «экстремальные форки», когда люди берут чужую кодовую базу и комиттят единым целым с потерей истории изменений.
* onmouseup, onmousedown и onmousemove — три гиганта, на которых стоит UI.
* Огромное число баззвордов и технологий из мира Javascript.
* Платформы для онлайн обучения. Особенно [Moodle](https://moodle.org/). Много, много Moodle.
* Все когда-либо созданные открытые CMS.
* Тема «Coursera Machine Learning» предоставляет отличный список репозиториев с домашней работой на курсах Coursera, посвященных машинному обучению.
### Сообщества
Самая большая по численности тем группа, почти 100. Много репозиториев оказались частными облачными хранилищами конфигураций для текстовых редакторов, особенно Vim и Emacs. Т.к. у Vim всего одна тема, в то время как у Emacs две, надеюсь, это поставит окончательную точку в споре какой редактор лучше!
Встретились сайты на всех известных веб движках, написанных на Python, Ruby, PHP, Java, Javascript и т.д. Сайты на PHP используют движки Wordpress, Joomla, Yii, VTiger, Drupal, Zend, Cake и Symphony почему-то обязательно с Doctrine (по теме на каждый). Python: Django, Flask, Google AppEngine. Ruby: Rails и только Rails. [Реееельсы](https://habrahabr.ru/post/301532/). Сайты на Java сколлапсировали в одну смешанную тему. И конечно же нашлось место сайтам на Node.js.
Оказалось, что много проектов используют [Tesseract](https://github.com/tesseract-ocr/tesseract) — открытый движок OCR. Кроме того, многие используют [Caffe](https://github.com/BVLC/caffe) (и ни разу не Tensorflow).
Quake 3 / idTech 3 настолько популярен в геймдеве что заслужил отдельную тему. У Unity3D их две, причем первая в основной массе это сборище студенческих проектов и домашних поделок.
Cocos2D также популярен и получил 2 темы. Наконец, нашлись 3 темы про OpenGL + WebGL. Наверное, разница в способе работы с API и используемой обвязке (GLUT и т.п.).
Неудивительно, что [Chef](https://github.com/chef/chef) — средство управления конфигурациями — поделил тему с готовкой еды (recipes, kitchen и т.п). Однако, WinAPI неожиданно оказался в одной теме с репозиториями про покемонов. Есть предположение, что стемминг сделал характерные имена WinAPI похожими на имена покемонов…
### Игры
Много тем связаны с [SDL](http://www.libsdl.org/), а также с Minecraft и RPG.
Что можно скачать
-----------------
Мы приготовили образ Docker, чтобы любой желающий мог запустить нашу обученную модель на произвольном репозитории с GitHub. Нужно просто выполнить
```
docker run srcd/github_topics apache/spark
```
и вы увидите топ 5. Внутри образа зашита сериализованная матрица тем и слов, она доступна отдельно: [link](https://storage.googleapis.com/github-repositories-topic-modeling/repo_topic_modeling.pickle.gz). Формат — [pickle 4-ой версии](https://docs.python.org/3/library/pickle.html#pickle-protocols) с кортежем длины 2, первый элемент это Pandas 1.8+ [SparseDataFrame](http://pandas.pydata.org/pandas-docs/stable/sparse.html?highlight=sparsedataframe), и второй — список с IDF. Кроме того, есть [таблица OpenDocument](https://storage.googleapis.com/github-repositories-topic-modeling/topics.ods) и [JSON](https://storage.googleapis.com/github-repositories-topic-modeling/topics.json) с извлеченными темами.
Выводы
------
Как уже было написано выше, 200 тем это слишком мало, много тем оказались двойственными, тройственными или слабо выраженными. При выполнении анализа «на чистовую» нам стоит выставить 500 или 1000, однако придется забыть о ручной маркировке тем. Трудно разобраться в бесконечном количестве тем PHP, если ты не в теме :). Мне определенно пригодилось многолетнее чтение статей на Хабре, и все равно я чувствовал себя некомфортно. Но все равно получилось интересно. Выдающееся достижение ARTM на мой взгляд — извлечение тем про людей, природу, науку и даже шаблоны проектирования всего лишь из имен в исходниках.
В планах добавить к модели файлы readme и возможно другие текстовые источники. Наверное, они усилят группу *Понятия*.
P.S.
----
Майнинг исходного кода в трактовке классического машинного обучения (а не тяп ляп собрали метрик из AST и в продакшен) — штука новая, пока что не очень популярная, научных статей практически нет. В перспективе, мы хотим и примерно представляем как заменить часть программистов глубокой нейронной сетью, которая будет транслировать описание бизнес задач на естественном языке в код. Звучит фантастически, но технологии на самом деле созрели и если получится, произойдет революция покруче индустриализации. Людей катастрофически не хватает! Мы хайрим!
Основная трудность в этом деле — получить доступ к данным. GitHub API лимитирует число запросов у зарегистрированных пользователей числом 5000 в час, что конечно же мало, если хотим заполучить 18кк. Есть проект [GHTorrent](http://ghtorrent.org/), но это лишь бледная тень тех данных, что собрали мы. Пришлось сделать особый конвейер на Go, который использует [Go-Git](https://github.com/src-d/go-git) для сверхэффективного клонирования. Насколько нам известно, полная реплика GitHub есть у трех компаний: GitHub, [SourceGraph](https://sourcegraph.com/) и source{d}. | https://habr.com/ru/post/312596/ | null | ru | null |
# Автоматизация по методологии BDD. Наш опыт успешного внедрения
*Статья публикуется от имени Трубанова Вадима,* [@vonaburt](https://habrahabr.ru/users/vonaburt/)
Методология BDD все чаще завоевывает внимание IT-индустрии как логически верная ступень развития традиционных подходов к тестированию проектов, в том числе подходов к автоматизации тестирования. Текущая эпоха информационных технологий диктует свои правила, и в этой гонке технологий выигрывает тот, кто умеет реагировать на любые изменения быстро и качественно. Особенно это касается компаний связанных с банковской деятельностью, например таких, как наш банк, где каждый отложенный час до релиза может повлиять на общую картину качества сервисов, составляемую нашими клиентами. При правильном использовании методология BDD позволяет сократить время, затрачиваемое на тестирование выпускаемых продуктов, повышать качество проводимого тестирования и делать сам процесс прозрачным и понятным для всех, что и подтолкнуло нас к её использованию. На данный момент методология BDD внедряется на двух наших web-продуктах, активно развивается и уже приносит свои плоды. Хочется поделиться нашим опытом внедрения BDD со стороны автоматизации тестирования и рассказать об основных принципах, которые позволят вам внедрить эту методологию безболезненно, быстро и, самое главное, сделать её использование эффективным.
### 1. Стройте хороший и удобный фреймворк
Фреймворк, на котором впоследствии будут писаться BDD-кейсы — это сердце всей методологии, её главный элемент. Именно поэтому фреймворку должно быть отведено повышенное внимание. Это ваша *стартовая точка*. Наше решение написано на Java и основывается на библиотеке jBehave. Так как BDD используется на web-проектах, без Selenium WebDriver никуда. При использовании PageObject-паттерн большая роль отводится работе с элементами и страницами. В качестве генератора отчетов выбран Serenity. Назовем три очевидных главных принципа, которые обязательно должен соблюдать ваш фреймворк. Во-первых, он должен быть *надежным*. Не пожалейте времени и напишите хорошее ядро проекта. Непотраченные 30 минут работы могут обернуться вам часами простоя вашей BDD-команды. Во-вторых, фреймворк должен быть максимально *удобен для использования*. Основные пользователи фреймворка не вы, и не команда автоматизаторов! Фреймворк должен быть дружелюбен, приятен и понятен тем, кто собирается писать на нем свои BDD-кейсы. В-третьих, фреймворк должен быть *гибок*. Возвращаясь к реагированию на быстрые изменения, понимаешь —неизвестно, как тестируемый проект изменится завтра. Изначально стройте свой BDD-фреймворк так, чтобы всегда сохранялась возможность перестроить основные механизмы работы фреймворка.
Хороший фреймворк BDD-автоматизации связан со следующими понятиями:
* механизм написания BDD-кейсов;
* механизм запуска BDD-кейсов;
* работа с тестовыми данными.
Все три перечисленных пункта должны быть максимально удобными для пользователей фреймворка. Помните, что пользователи — *не разработчики*, и очевидные для вас, разработчиков, вещи, могут быть далеко не очевидными для них.
Механизм написания BDD-кейсов довольно прост. Каждому пользователю фреймворка устанавливается IDEA Intellij CE, к ней устанавливается плагин, дающий пользователю возможность автодополнения имеющихся BDD-инструкций. Практически каждой инструкции прописаны свои алиасы, позволяющие пользователям писать свой кейс так, как им удобно.
Большинство инструкций имеют параметры: наименования страниц, элементов, сохраненные ранее значения, функции. Все они позволяют сделать кейсы гибкими и эффективными.
Наверняка многие задавались вопросом, как сделать работу с элементами, их локаторами, коллекциями элементов, страницами с элементами удобнее и прозрачнее. Мы остановились на описании *полной* иерархии страниц и их элементов. Такой подход должен быть знаком всем, кто использовал в своих проектах паттерн PageObject. Весь портал делится на страницы, внутри которых описываются все находящиеся на них элементы. Повторяющиеся блоки страниц вынесены в «виджеты» или «подстраницы», например, такие как «Меню» или «Правый борд». На данный момент мы храним более 2200 локаторов элементов главного портала банка и более 1000 элементов портала для юридических лиц, и эти цифры неугомонно растут с выходом все нового и нового функционала. Автоматизаторы и функциональные тестировщики, задействованные в методологии, задаются вопросом — как работать с таким большим количеством элементов? Выход был найден: написать свой плагин для IDEA Intellij, распарсивающий файл с данными в древовидную структуру и дающий возможность добавлять и редактировать новые страницы и элементы.
Инструкции построены таким образом, чтобы предварительно «загрузив» определенную страницу, пользователь мог работать со всеми элементами загруженной страницы. Благодаря этому пользователи нашего фреймворка избегают путаницы с выбором необходимого элемента, страницы или виджета.
Для увеличения возможностей BDD-инструкций нами реализован следующий функционал:
* возможность писать собственные маленькие вспомогательные скрипты (например, для получения рандомного значения, вычисления математических операций и тд.) как в теле инструкции, так и в переменных блока «Meta»;
* возможность сохранять необходимые значения в переменные и далее эти переменные использовать.
```
<!-- генерация рандомных значений и их сохранение в переменных >
Meta:
@profile #{AutoPayments}
@region г. Москва
@code 916
@phone #{random{1000000,9999999}}
@sum #{random{100,200}}
@sum2 #{random{100,200}}
@level 150
@level2 600
@limit #{random{650,999}}
@limit2 #{random{650,999}}
@dateStamp #{now(ddMMyy HHmmss)}
@preName EditMAP
<!--использование скрипта получения значения>
When в переменной "name" сохранено значение "#{script{ String temp = "#{preName}" + " " + "#{dateStamp}"; RESULT = temp}}"
<!-- использование сохраненных переменных>
When нажатием на кнопку "Наименование" загружена страница "Платеж"
When заполняются поля:
|field|value|
|Номер телефона с определенным провайдером|#{code} #{phone}|
|Название платежа|#{name}|
|Сумма|#{sum}|
|Нижний уровень баланса|#{level}|
|Месячный лимит|#{limit}|
```
Запуск BDD-кейсов реализован с помощью Apache Maven и доработанного стандартного StoryRunner`a, позволяющего запускать BDD-кейсы в многопоточном режиме. Функциональщики могут запустить необходимые тесты прямо со своих рабочих машин и просматривать ход выполнения тестов. Все автотесты запускаются через TeamCity, вручную — довольно редко.
Тестирование и автотестирование тесно связаны с тестовыми данными (ТД). Это один из фундаментальных столпов любого процесса обеспечения качества. Качественные тестовые данные и их грамотное использование позволит вывести тестирование на новый уровень. Возвращаясь к BDD-инструкциям: именно через них пользователь BDD-фреймворка будет передавать тестовые данные. «Хардкодить» тестовые данные прямо в инструкциях — моветон, обрекающий на сложности в актуализации ТД. В итоге, перед нами стояла задача:
— вынести хранение ТД в единое место хранения;
— реализовать возможность удобной работы с хранящимися ТД в BDD-инструкциях;
— реализовать возможность удобной актуализации ТД и контролем над ними;
Как мы ее решили:
— все тестовые данные занесли в БД;
— реализовали внутреннее тестовое API, позволяющее работать с данными в БД;
— реализовали механизм работы с тестовым API внутри BDD-фреймворка в формате инструкций;
— создали web-портал, дающий пользователям фреймворка интерфейс для непосредственной работы над актуализацией, пополнением и редактированием тестовых данных;
Web-портал для работы с тестовыми данными написан на скаловском Play, разделен на наши web-проекты, в которых применяется BDD-автоматизация. Также есть внутреннее деление по категориям тестовых данных: поля, значения, их параметры корректной/некорректной валидации, тестовые пользователи.
Тестовые пользователи пополняются за счет реализованного *механизма генерации тестовых данных*, о деталях которого, возможно, будет отдельная статья. Механизм позволяет проводить тестирование на клиентах с любым набором продуктов и с любыми необходимыми параметрами.
Именно так, на наш взгляд, выглядит краткое описание необходимых технических элементов удобного и эффективного BDD-фреймворка. Кратко резюмируя: не забывайте о том, для кого вы пишете BDD-фреймворк, как вы будете работать с элементами страниц, как пользователь будет взаимодействовать с инструкциями и тестовыми данными.
Возможно, мы расскажем подробнее о фреймворке отдельной статьей.
### 2. Настраивайте environment у сотрудников
После того, как фреймворк написан или находится в завершающей стадии написания, пора задуматься о том, как пользователи вашего BDD-фреймворка будут работать с ним. Выдача необходимых прав для установки ПО и сетевых доступов может обернуться эпопеей с туманным будущим во многих крупных компаниях. Благо, бюрократические проволочки в нашей компании минимальны, и мы смогли в быстрые сроки установить все необходимое ПО выбранной группе будущих BDD-автоматизаторов. Конечно, иногда возникали специфические проблемы, но и они быстро решались. Для коллег из аутстафа/аутсорса было найдено простое и эффективное решение в виде заранее подготовленных виртуальных машин с полным необходимым «боевым набором», которые к тому же быстро «размножались» при необходимости. При возникновении любых проблем всегда можно зайти на виртуальную машину и посмотреть, в чем дело.
Мораль этой краткой, но очень важной главы: заранее позаботьтесь о том, как будущие пользователи вашего BDD-фреймворка будут с ним работать, будь то полная установка необходимого ПО на локальных машинах или предварительная настройка и последующее копирование виртуальных машин с фреймворком. Чем быстрее ваши коллеги начнут пользоваться фреймворком, тем быстрее вы получите от них долгожданный фидбек, который будет особенно полезен в начале развития BDD-автоматизации.
### 3. Выстраивайте рабочие процессы. Варианты использования методологии
Без выстроенных рабочих процессов автоматизация по BDD-методологии вряд ли будет приносить пользу. Тут стоит рассказать о том, как вы можете встроить использование этой методологии у себя на проектах. Варианты довольно гибкие и зависят от того, насколько вы хотите вовлечь всех участников процессов разработки искомого продукта. Возможно, это будет начальный неполный вариант с привлечением только тестировщиков и автоматизаторов. В этом случае вы выиграете время за счет удаления «прослойки» между вашими автоматизаторами и функциональными тестировщиками в виде тест-кейсов на автоматизацию.
В этом процессе могут косвенно участвовать и менеджеры продукта с аналитиками, указывая какому функционалу необходимо уделить особое внимание и автоматизировать в первую очередь с точки зрения бизнес-значимости функционала.
Следующий вариант использования — полный. Этот вариант предполагает полноценное участие в BDD-методологии всех участников процесса разработки — от менеджеров продукта до тестировщиков и автоматизаторов. Каждый участник того или иного этапа разработки участвует в формировании конечных BDD-кейсов, которые в сумме дают полноценный автоматизированный регресс продукта. Также данный вариант плавно подводит вас к полноценному приемочному тестированию (ATDD), когда все критерии «приемки» продукта формируются не только тестировщиками, как это происходит зачастую, а всеми участниками процесса разработки. Данный подход наиболее полезен и эффективен с точки зрения автоматизации, он дает быстрое и очень качественное пополнение конечного авторегресса.
Мы начали с первого, неполного варианта, с привлечением к методологии только функциональных тестировщиков и автоматизаторов, во многом в виде эксперимента, который показал бы нам на практике слабые и сильные стороны методологии. Мы поняли, что такой подход к тестированию дает свои плоды, и начали думать, как нам привлечь к методологии всех участников разработки. Классический вариант {x}DD, когда изначально пишутся все тесты, и только потом начинается непосредственная разработка, в изначальных наших условиях сильно повлиял бы на наш быстрый релизный цикл, что для банковских сервисов непозволительная роскошь. К тому же установка, настройка и поддержка всего необходимого ПО для BDD-автоматизации всем участникам этапов разработки, не говоря об обучении работе с BDD-фреймворком, сильно замедлили бы нас в дальнейшем развитии методологии. Решение мы нашли в «корнях» BDD-методологии. Напомню, что в основе методологии лежит использование DSL-языка (Gherkin), человекочитаемого языка описания поведения системы, описывающего функционал с помощью бизнес-ситуаций (сценарии поведения, пользовательские истории). Благодаря несложным правилам составления сценариев, можно быстро привлечь большое количество сотрудников к постановке задач и их последующей детализации в формате языка Gherkin. Весь процесс также ведется в рамках используемого вами ПО для управления проектами и багтрекинга, в нашем случае это Atlassian Jira. Менеджеры и аналитики уходят от старого формата постановок задач и начинают ставить задачи в BDD-формате. Дизайнеры и разработчики получают описание задач в BDD-формате, однако могут и сами дополнить список пользовательских историй, исходя из особенностей интерфейса или используемых библиотек при разработке. В итоге, когда задача попадает в тестирование, тестировщик видит список пользовательских историй, проанализировав который, дополняет своими пользовательскими сценариями, исходя из позиции тестировщика. Каждая история — это законченный сценарий для тестирования. Это живая документация продукта. А самое главное — все сценарии из описания задачи быстро переносятся тестировщиками в BDD-фреймворк, становясь фактически готовыми автотестами.
В итоге это практически переход BDD-методологии к полноценному приемочному тестированию (ATDD), когда все этапы разработки участвуют в составлении критериев приемки продукта.
Это описание автоматизации по BDD-методологии на практике «издалека». А что происходит на более низком уровне, как построен процесс пополнения авторегресса? Чтобы ответить на этот вопрос, нужно вернуться к основе BDD-фреймворка. Механизм взаимодействия пользователя с BDD-фреймворком построен на инструкциях. Имеющийся в BDD-фреймворке список доступных инструкций и дерево описанных страниц и элементов позволяют автоматизировать большую часть пользовательских сценариев. Логично предположить, что список инструкций и дерево описанных страниц и элементов не всегда позволяют автоматизировать тот или иной сценарий. Особенно при автоматизации сценариев нового, еще не автоматизированного функционала, несмотря на то, что инструкции построены максимально атомарными, с минимальным уровнем абстракции, на уровне взаимодействия с элементами. Плюс ко всему, могут появиться новые страницы и их новые элементы, которые еще не описаны в нашей иерархии элементов и страниц. Таким образом, появляются BDD-кейсы, для автоматизации которых не хватает инструкций, страниц и их элементов. Тестировщика данная ситуация вводила в ступор из разряда «а что мне делать, если нужной инструкции еще нет?». Тут есть два варианта, как можно построить процесс. Первый — не писать новый BDD-кейс, оповещать автоматизаторов о том, что не всех инструкций хватает или не все элементы описаны. Сразу оценить, хватит ли всего для автоматизации кейса, довольно трудно. Либо второй, более рациональный вариант — давать пользователю писать свой кейс так, как ему хочется, несмотря на отсутствие инструкций, страниц и элементов. Мы дали тестировщикам *свободу в написании инструкции*, дали им возможность писать кейсы так, как им удобно и построили процесс таким образом, чтобы такие кейсы, имеющие нехватку инструкций или описания элементов, порождали задачи в Jira, которые попадут «на вход» автоматизаторам. Автоматизаторы реализуют недостающие инструкции, описывают недостающие элементы и задачи, и автотест тестировщика попадает в рабочую ветку авторегресса.
Для обеспечения качества новых BDD-кейсов настроен процесс обязательного прохождения код-ревью. Сформулированы конкретные правила, описывающие то, как должны выглядеть основные блоки BDD-кейсов, как они должны быть оформлены. Именно по этим правилам проводится проверка написанных кейсов силами коллег из функционального тестирования. Правила затрагивают соответствие местоположения кейса и его смыслового содержимого, наличие необходимых меток и другие важные моменты. Без этих правил процесс пополнения авторегресса будет хаотичным и непредсказуемым. Но об этом в следующих частях статьи.
### 4. Разделяйте роли
Данная часть является логическим продолжением предыдущей части.
Любая методология, любой подход к разработке, производству, любой организации труда сильно затрудняется, если участники этих процессов не знают свое место в этом процессе. Человек должен знать свою роль, должен знать конечный список обязанностей, которые данная роль предполагает. Причем чем более детализированы эти обязанности, тем понятнее и прозрачнее процесс будет как для самого участника процесса, так и для всех остальных. Эти тезисы не обходят стороной и такую сложную и трудоемкую методологию, как BDD.
Методология довольно гибкая, и часто многие останавливаются на привлечении в методологию только автоматизаторов и тестировщиков. Полноценное использование методологии предполагает привлечение всех участников разработки, именно её мы и будем рассматривать. Так кто же основные «действующие лица» методологии BDD? Конечно, это функциональные тестировщики, которых мы обозначим как «ФТ». ФТ делятся на «просто тестировщиков», пишущих и автоматизирующих BDD-кейсы, и на тех, кто вдобавок проводит код-ревью новых BDD-кейсов, которых мы обозначим аббревиатурой «КР». Это и автоматизаторы, которых мы назовем «АТ». Аналитиков, менеджеров и технологов всех других участников процесса мы объединим обозначением «АН». «Богоподобную» роль мы назовем «руководителем проекта», или сокращенно «РП». Это все выделенные роли методологии:
— «ФТ» (функциональные тестировщики);
— «КР» (код-ревьюверы);
— «АТ» (автоматизаторы);
— «АН» (аналитики, менеджеры, технологи etc);
— «РП» (руководитель проекта).
Теперь разберемся с основными возможными действиями в методологии. Это:
— написание BDD-кейсов в свободном формате на языке Gherkin;
— автоматизация BDD-кейсов в BDD-фреймворке;
— код-ревью автоматизированных BDD-кейсов, проверка на соответствие выделенным правилам составления новых BDD-кейсов;
— автоматизация недостающих инструкций, их поддержка; описание новых страниц и элементов, их поддержка;
— проведение код-ревью автоматизации недостающих инструкций, их поддержке, описания новых страниц и элементов;
Составим конечную матрицу ролей методологии и возможных действий:
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| **Действие/Роль** | **ФТ** | **КР** | **АТ** | **АН** | **РП** |
| Написание BDD-кейсов на языке Gherkin | X | X | X | X | X |
| Автоматизация BDD-кейсов в BDD-фреймворке | X | X | - | - | X |
| Код-ревью автоматизированных BDD-кейсов | - | X | - | - | X |
| Автоматизация инструкций, описание элементов и страниц, etc. | - | - | X | - | X |
| Проведение код-ревью автоматизации | - | - | X | - | X |
Таким образом, каждый в процессе выполняет свою роль и функции:
— новый функционал описывается менеджерами, аналитиками и технологами в удобном для них формате на языке Gherkin;
— функциональные тестировщики заняты написанием качественных с точки зрения тестирования кейсов, автоматизируют их и сами проводят код-ревью написанных кейсов;
— автоматизаторы заняты только чистой автоматизацией и сопутствующей автоматизации работой, а не написанием кейсов, как это часто бывает.
### 5. Обучайте сотрудников
Несмотря на то, что BDD-кейсы пишутся на человекоподобном языке, а автоматизация ведется в специально созданном фреймворке, придется отвести время на минимальное обучение всех участников методологии. Начнем с тестировщиков, без которых представить BDD-методологию очень трудно.
Роль тестировщиков в процессе — создать качественные BDD-кейсы и автоматизировать их в BDD-фреймворке, либо, как очень часто бывает, автоматизировать «сразу на месте», прямиком во фреймворке. Тестировщики должны понимать, как правильно составлять BDD-кейс, из чего он состоит, и как им с ним работать в дальнейшем. Тут необходимы знания о языке Gherkin. Донести до ребят информацию можно либо на встрече с презентацией, либо с помощью учебных материалов для самообучения в вашей корпоративной wiki, а лучше и тем, и другим.
Навыки работы тестировщиков с фреймворком лучше всего получать с практикой. Наш опыт показал, что эффективнее всего «задачи на обучение». Это типовые — с ними вероятнее всего столкнутся тестировщики при автоматизации — задачи по проекту, в котором внедряется BDD. Каждой задаче выдается определенный срок на выполнение, после чего проводятся коллективные встречи с обсуждением результатов выполнения задач и возникающих проблем.
Обучение менеджеров, аналитиков, технологов и других, участвующих только в написании BDD-кейсов, сводится к обучению языку Gherkin, который они будут применять при составлении описания задач на разработку функционала или его доработку/изменение. Обучение мало отличается от обучения тестировщиков: тут помогут хорошая презентация с интерактивом в виде обсуждения возникших вопросов и корпоративная wiki со всей необходимой информацией.
Автоматизаторы, как правило, не нуждаются в обучении: главное донести до них основные моменты процесса автоматизации, и дать понять им, что ограничивать полет фантазии тестировщиков нельзя, пусть и составленные ими кейсы выглядят для них странно и непонятно. У тестировщиков своя «кухня», у них свой уникальный взгляд на мир.
Стоит отметить, что в сформированном нами подходе к методологии возможна эволюция из одной роли в другую. Так, функциональный тестировщик, набравшись необходимого опыта в составлении BDD-кейсов и в их автоматизации, может перейти в роль код-ревьюера. Код-ревьюер, желая не только писать кейсы, но и полноценный код внутри BDD-фреймворка, может стать и автоматизатором, когда обучится всем необходимым навыкам. Прецедентов пока не было, но мы, автоматизаторы, начали курс обучения автоматизации среди наших BDD-тестировщиков и надеемся, что в скором времени «взрастим» своих автоматизаторов. Минимальные требования — навыки в любом ООП-языке и большое желание научиться чему-то новому.
Из всех поступающих «новеньких» сотрудников тестирования время от времени формируйте группы обучения BDD-автоматизации, выделяйте из уже обученных людей менторов, которые не только помогут новеньким хорошо понять методологию, но и сыграют важную роль во вливании новеньких в ваш коллектив. Это касается и всех остальных участников методологии.
Помните, что от грамотного систематизированного подхода к обучению сотрудников зависят результаты внедрения методологии.
### 6. Обсуждайте результаты и проблемы
Результаты пополнения авторегресса обсуждаются каждую неделю, когда мы подводим итоги так называемого «спринта» — недельного отрезка, во время которого фиксируем, как развивается автоматизация наших продуктов и обсуждаем возникающие проблемы. На встрече подводятся итоги прошедшей недели, оглашаются количественные показатели автоматизации. Для команды BDD-автоматизации это отличный мотивационный инструмент, который дает им понять, что их труды не остаются незамеченными. Также такая ретроспектива дает понять, есть ли деградация в автоматизации по сравнению с предыдущими «спринтами», и если она наметилась, возможно, понять причины её возникновения и разобраться, как ее устранить.
Как показала наша практика, основной проблемой при внедрении BDD-методологии и её дальнейшем развитии может стать банальное отсутствие времени у участников методологии и трудности при распределении затрачиваемого времени на «BDD-активность», её приоритет в потоке задач. Уделите этому особое внимание и будьте готовы, что, возможно, придется сократить время на тестирование задач и проведение регресса или увеличить длину релизного цикла. Время, затрачиваемое на BDD-активность среди всех участников процесса, можно гибко регулировать, начиная от выделения определенных дней в неделю и заканчивая выделением определенных часов рабочего дня для BDD-автоматизации. Однако, затраты на автоматизацию вернутся сторицей, когда авторегресс позволит сократить время, затрачиваемое на регресс выпускаемого функционала, и повысит качество регресса.
Остальные проблемы несущественны — как правило, это «просветы» либо в понимании процесса, либо в специфических знаниях о работе с BDD-фреймворком. Решаются такие проблемы просто: либо проведением повторных ликбезов, либо личной беседой для устранения всех «белых пятен».
Большой проблемой автоматизации всегда остается непосредственно использование автотестов, как бы печально это ни звучало. Автотесты могут стать неактуальными в виду изменений в автоматизированном продукте; могут использовать некорректные тестовые данные, наталкиваться на нерабочую тестовую среду, иметь проблемы в инфраструктуре прогона автотестов.
Неактуальность — наверное, самая распространенная проблема автотестов. Автотестам трудно успевать за постоянно увеличивающимся объемом нового или изменяемого функционала. Несмотря на то, что вышедшие изменения могут аффектить большую часть автотестов, правки в них могут потребоваться минимальные. У нас очень часто возникали ситуации, когда проблема в актуализации автотестов заключалась не в том, что требуется много правок из-за изменений, а в том, что эти изменения случились неожиданно для нас, автоматизаторов. Другими словами, *основная проблема в актуализации автотестов в том, что автоматизаторы не знают о грядущих изменениях*. Выход из этой ситуации следующий: как только становится понятен окончательный скоп задач, которые войдут в очередной релиз тестируемой системы, необходимо проанализировать, какие изменения аффектят авторегресс. В большинстве случаев это задачи, затрагивающие интерфейсную часть тестируемой системы. Найти такие задачи в скопе релизных задач довольно просто. А имея на руках тестируемую ветку релиза, автоматизаторы могут быстро внести необходимые правки в авторегресс, что и позволит вашему авторегрессу быть актуальным для регресса.
Некорректность тестовых данных является продолжением неактуальности автотестов. Тестовые данные, как правило, подбираются под конкретные проверки того или иного функционала, и терять свою актуальность они могут из-за грядущих изменений. Решение данной проблемы такое же, как и неактуальности автотестов в целом: необходим анализ релизной версии тестируемого продукта на предмет изменения входных данных. Для удобства и быстрой правки тестовых данных необходимо максимально отказываться от «хардкода» тестовых данных и переносить их в единое место хранения.
Нерабочие тестовые среды — настоящий бич тестирования и автоматизации тестирования. Проблемы с тестовыми средами могут привести как к трудностям в тестировании, так и к полноценному простою команд тестирования. Рабочие тестовые среды — еще один из столпов, без которого тестирование будет очень затруднительно. Благо существует множество инструментов, позволяющих держать ваши тестовые среды в стабильном состоянии. Плюс очень радует развитие инструментов для изолированного разворачивания тестовых контуров под нужды тестирования: это позволит прийти к процессу вроде «развернул тестовую среду — провел тестирование — свернул и почистил тестовую среду».
Нет ничего обиднее, чем автотесты, которые не смогли запуститься по каким-либо причинам.
Если у вас много автотестов, то, скорее всего, у вас развернута инфраструктура их запуска. С большой долей вероятности вы используете open-source решения. Заранее предусмотрите вопрос необходимых сетевых доступов и будьте готовы к тому, что Selenium или любой другой open-source инструмент имеет множество «открытых» проблем, на которые вы можете напороться. Будьте предельно внимательны и осторожны при обновлениях версий используемых инструментов. По нашей практике наиболее частыми проблемами были настройка и конфигурация CI-систем: где-то не хватило памяти, где-то потерялся доступ, где-то обновленный плагин перестал работать. Так же часто попадали на проблемы с драйверами браузеров: не всегда удавалось с первого раза найти работающую комбинацию версии браузера и его драйвера — все подбирается экспериментальным путем. Тем не менее, все перечисленные проблемы решаемы, однако требуют много времени и сил.
### 7. Будьте готовы к увеличению количества кейсов
Настроенный процесс автоматизации проекта по BDD-методологии позволит вам буквально поставить на поток пополнение вашего авторегресса BDD-кейсами. Переменные, которыми вы можете регулировать этот поток — это время, выделяемое участникам процессов разработки на «BDD-активность», и это задаваемый автоматизаторам баланс между задачами по актуализации BDD-кейсов и реализации новых инструкций. Следующие переменные будут влиять на процесс пополнения авторегресса автотестами, но они не всегда на 100% подчиняются вашей воле — это возможность пополнения BDD-кейсами тестируемого функционала в принципе (да-да, возможна ситуация, когда все автоматизировано), это стабильность инфраструктуры написания BDD-кейсов и их запуска, это состояние тестовой среды. Эту схему можно представить в следующем виде:
Время, выделяемое на BDD-активность, согласовывается, как правило, с менеджерами проекта, с этим все довольно понятно. Возможно, как упоминалось выше, вы придете к изначальному экспериментальному выделению нескольких часов в неделю. Баланс, задаваемый автоматизаторам на реализацию задач актуализации и реализации недостающих инструкций/описания элементов, следует задавать, исходя из текущей нагрузки по этим направлениям. Со временем, как показала практика, у вас установится примерное соотношение скорости реализации нового функционала тестируемого проекта к скорости написания новых BDD-кейсов функциональными тестировщиками. Не стоит откладывать реализацию недостающих инструкций BDD-кейсов в долгий ящик, делая упор только на актуализации: со временем это может привести к тому, что BDD-кейс потеряет свою актуальность и его придется актуализировать.
Оценить возможность пополнения регресса тестируемого функционала автотестами при полноценном внедрении BDD-методологии помогут BDD-истории, написанные менеджерами, аналитиками и технологами. Тогда оценкой возможности автоматизации функционала является оценка возможности автоматизации всех BDD-историй. При неполном внедрении BDD-методологии, с участием только тестировщиков и автоматизаторов, на плечи тестировщиков ложится составление полного списка возможных пользовательских сценариев. Удобным инструментом в данной ситуации является использование карты тестирования. Это документ, хранящий в идеале краткое описание всех возможных пользовательских сценариев взаимодействия с функционалом, проверяемых при регрессе. В этот документ добавляется поле о текущем статусе автоматизации кейса. Имея поле критичности кейса для функционала в целом, тестировщик представляет, какой функционал необходимо автоматизировать и в каком порядке. Возможное решение проблем со стабильностью фреймворка, инфраструктуры использования автотестов и тестовых стендов описано в предыдущих главах статьи.
При большом количестве BDD-кейсов, являющихся в тоже время и автотестами, рано или поздно появится вопрос о времени их «прогона», который тесно перекликается с возможностями распараллеливания автотестов. Никому не интересны автотесты, возможный результат которых ты получишь только через N часов. И если со стороны кода для распараллеливания имеются работающие проверенные решения, то о возможностях инфраструктуры использования автотестов придется подумать. В нашем случае пришлось увеличить технические мощности сборочных агентов TeamCity и виртуальных машин в системе распределенного запуска автотестов Selenium Grid.
Использование полного авторегресса тестируемой системы оправдано, как правило, при проведении полного регресса. Для возможности быстро и изолированно проверить необходимый функционал мы реализовали запуск авторегресса по меткам. Весь функционал системы бьется на иерархию меток в доступном для всех участников BDD-методологии виде. При написании нового кейса в обязательном порядке проставляются метки по затрагиваемому BDD-кейсом функционалу. Для запуска нужной части авторегресса нужно просто указать необходимые к запуску метки.
### Заключение
Автоматизация по методологии BDD при всей своей сложности и трудоемкости внедрения определенно приносит пользу качеству продукта. При правильной организации ключевых элементов автоматизации, таких как фреймворк, обучение сотрудников и рабочий процесс, автоматизация по методологии BDD может стать отправной точкой для полноценного внедрения BDD на всех этапах разработки продукта, развенчивая расхожее мнение о том, что методологию BDD можно внедрять только в полноценном её варианте с «верхних» этапов разработки продукта и невозможности успешного внедрения в крупных компаниях.
Помните, что автоматизация по методологии BDD не является волшебной таблеткой от всех ваших текущих бед с автоматизацией: данный подход к автоматизации отлично решает свои главные задачи — добиться максимального покрытия тестируемого функционала автотестами и сократить время, затрачиваемое на покрытие функционала автотестами. Не стоит внедрять автоматизацию по методологии BDD при явных проблемах со стабильностью инфраструктуры запуска автотестов, проблемах с тестовыми данными и тестовыми средами, которые не только оттянут внедрение на долгие сроки, но и, возможно, вовсе заставят вас отказаться от затеи.
И все же, при правильном подходе к основным пунктам, описанным в данной статье, умноженном на старание и самоотдачу всей команды, участвующей в методологии, вас должен ждать успех, и все ваши затраты на внедрение окупятся с лихвой. Надеемся, что наш опыт поможет вам, и эта статья станет полезным материалом в вашей непростой, но вполне выполнимой задаче. | https://habr.com/ru/post/322688/ | null | ru | null |
# Области видимости и замыкания в JavaScript
*Данная публикация представляет собой перевод материала «JavaScript Scope and Closures» под авторством Zell Liew, размещенного [здесь](https://css-tricks.com/javascript-scope-closures/).*
Области видимости и замыкания важны в JavaScript, однако они сбивали меня с толку, когда я только начинал их изучать. Ниже приведены объяснения этих терминов, которые помогут вам разобраться в них.
*Начнем с областей видимости*
Область видимости
-----------------
Область видимости в JavaScript определяет, какие переменные доступны вам. Существуют два типа областей видимости: **глобальная** и **локальная**.
### Глобальная область видимости
Если переменная объявлена вне всех функций или фигурных скобок (`{}`), то считается, что она определена в **глобальной области видимости**.
**Примечание:** это верно только для JavaScript в веб браузерах. В Node.js глобальные переменные объявляются иначе, но мы не будем касаться Node.js в этой статье.
```
const globalVariable = 'some value';
```
Как только происходит объявление глобальной переменной, можно использовать эту переменную везде в коде, даже в функциях.
```
const hello = 'Hello CSS-Tricks Reader!';
function sayHello () {
console.log(hello);
}
console.log(hello); // 'Hello CSS-Tricks Reader!'
sayHello(); // 'Hello CSS-Tricks Reader!'
```
Хотя можно объявлять переменные в глобальной области видимости, но не рекомендуется это делать. Всё из-за того, что существует вероятность пересечения имен, когда двум или более переменным присваивают одинаковое имя. Если переменные объявляются через `const` или `let`, то каждый раз, когда будет происходить пересечение имён, будет показываться сообщение об ошибке. Такое поведение нежелательно.
```
// Не делайте так!
let thing = 'something';
let thing = 'something else'; // Ошибка, thing уже была объявлена
```
Если объявлять переменные через `var`, то вторая переменная после объявления перепишет первую. Такое поведение тоже нежелательно, т.к. код усложняется в отладке.
```
// Не делайте так!
var thing = 'something';
var thing = 'something else'; // возможно где-то в коде у переменной совершенно другое значение
console.log(thing); // 'something else'
```
Итак, следует всегда объявлять локальные переменные, а не глобальные.
### Локальная область видимости
Переменные, которые используются только в определенной части кода, считаются помещенными в локальную область видимости. Такие переменные называются **локальными**.
В JavaScript выделяют два типа локальных областей видимости:
* **область видимости функции**
* **и область видимости блока**.
*Сначала рассмотрим **область видимости функции***
#### Область видимости функции
Переменная, объявленная внутри функции, доступна только внутри функции. Код снаружи функции не имеет к ней доступа.
В примере ниже, переменная `hello` находится внутри области видимости функции `sayHello`:
```
function sayHello () {
const hello = 'Hello CSS-Tricks Reader!';
console.log(hello);
}
sayHello(); // 'Hello CSS-Tricks Reader!'
console.log(hello); // Ошибка, hello не определена
```
#### Область видимости блока
Переменная, объявленная внутри фигурных скобок `{}` через `const` или `let`, доступна только внутри фигурных скобок.
В примере ниже, можно увидеть, что переменная `hello` находится внутри области видимости фигурных скобок:
```
{
const hello = 'Hello CSS-Tricks Reader!';
console.log(hello); // 'Hello CSS-Tricks Reader!'
}
console.log(hello); // Ошибка, hello не определена
```
**Блочная область видимости** является частным случаем **области видимости функции**, т.к. функции объявляются с фигурными скобками (кроме случаев использования стрелочных функций с неявным возвращением значения).
### Подъем функции в области видимости
Функции, объявленные как «**function declaration**» (прим. перев.: функция вида **function имя(параметры) {...}**), всегда поднимаются наверх в текущей области видимости. Так, два примера ниже эквивалентны:
```
// Тоже самое, что пример ниже
sayHello();
function sayHello () {
console.log('Hello CSS-Tricks Reader!');
}
// Тоже самое, что пример выше
function sayHello () {
console.log('Hello CSS-Tricks Reader!');
}
sayHello();
```
Если же функция объявляется как «**function** **expression**» (функциональное выражение) (прим. перев.: функция вида **`var f = function (параметры) {...}`**), то такая функция не поднимается в текущей области видимости.
```
sayHello(); // Ошибка, sayHello не определена
const sayHello = function () {
console.log(aFunction);
}
```
Из-за этих двух возможных вариантов подъем функции потенциально может сбить с толку, поэтому не рекомендуется применять на практике. Всегда сначала объявляйте функции перед тем, как их использовать.
### У функций нет доступа к областям видимости других функций
Функции не имеют доступа к областям видимости других функций, когда они объявляются раздельно, даже если одна функция используется в другой.
В примере ниже функция `second` не имеет доступа к переменной `firstFunctionVariable`.
```
function first () {
const firstFunctionVariable = `I'm part of first`;
}
function second () {
first();
console.log(firstFunctionVariable); // Ошибка, firstFunctionVariable не определена.
}
```
### Вложенные области видимости
Когда функция объявляется в другой функции, то внутренняя функция имеет доступ к переменным внешней функции. Такой поведение называется разграничением **лексических областей видимости**.
В тоже время внешняя функция не имеет доступа к переменным внутренней функции.
```
function outerFunction () {
const outer = `I'm the outer function!`;
function innerFunction() {
const inner = `I'm the inner function!`;
console.log(outer); // I'm the outer function!
}
console.log(inner); // Ошибка, inner не определена
}
```
Для визуализации того, как работают области видимости, можно представить одностороннее зеркало. Вы можете видеть тех, кто находится с другой стороны, но те, кто стоят с обратной стороны (зеркальной стороны), не могут видеть вас.
Если одни области видимости вложены в другие, то это можно представить как множество стеклянных поверхностей с принципом действия, описанным выше.
Если вы поняли все, что касается областей видимости, то можно сказать, что вы готовы к тому, чтобы разобраться с тем, что такое замыкания.
Замыкания
---------
Всякий раз, когда вы вызываете функцию внутри другой функции, вы создаете замыкание. Говорят, что внутренняя функция является замыканием. Результатом замыкания обычно является то, что в дальнейшем становятся доступными переменные внешней функции.
```
function outerFunction () {
const outer = `I see the outer variable!`;
function innerFunction() {
console.log(outer);
}
return innerFunction;
}
outerFunction()(); // I see the outer variable!
```
Так как внутренняя функция является возвращаемым значением внешней функции, то можно немного сократить код, совместив возврат значения с объявлением функции.
```
function outerFunction () {
const outer = `I see the outer variable!`;
return function innerFunction() {
console.log(outer);
}
}
outerFunction()(); // I see the outer variable!
```
Благодаря замыканиям появляется доступ к внешней функции, поэтому они обычно используются для двух целей:
1. контроля побочных эффектов;
2. создания приватных переменных.
### Контроль побочных эффектов с помощью замыканий
Побочные эффекты появляются, когда производятся какие-то дополнительные действия помимо возврата значения после вызова функции. Множество вещей может быть побочным эффектом, например, Ajax-запрос, таймер или даже console.log:
```
function (x) {
console.log('A console.log is a side effect!');
}
```
Когда замыкания используются для контроля побочных эффектов, то, как правило, обращают внимание на такие побочные эффекты, которые могут запутать код (например, Ajax-запросы или таймеры).
*Для пояснения рассмотрим пример*
Допустим, требуется приготовить торт ко дню рождения вашего друга. Приготовление торта займет секунду, так как написанная функция выводит «торт испечён» через секунду.
**Примечание:** для краткости и простоты далее используются стрелочные функции из ES6.
```
function makeCake() {
setTimeout(_ => console.log(`Made a cake`), 1000);
}
```
Как можно заметить, такая функция имеет побочный эффект в виде таймера.
Далее допустим, вашему другу нужно выбрать вкус торта. Для этого нужно дописать «добавить вкус» к функции `makeCake`.
```
function makeCake(flavor) {
setTimeout(_ => console.log(`Made a ${flavor} cake!`), 1000);
}
```
После вызова функции торт будет испечён ровно через секунду.
```
makeCake('banana'); // Made a banana cake!
```
Проблема в том, что, допустим, не нужно, чтобы торт был испечён сразу после уточнения вкуса, а необходимо, чтобы торт был испечён позже, когда это потребуется.
Для решения этой проблемы можно написать функцию `prepareCake`, которая будет хранить вкус торта. Затем передать замыкание в `makeCakeLater` через `prepareCake`.
С этого момента можно вызывать возвращенную функцию в любое время, когда это требуется, и торт будет приготовлен через секунду.
```
function prepareCake (flavor) {
return function () {
setTimeout(_ => console.log(`Made a ${flavor} cake!`), 1000);
}
}
const makeCakeLater = prepareCake('banana');
// Позже в вашем коде...
makeCakeLater(); // Made a banana cake!
```
Так замыкания используются для уменьшения побочных эффектов — вызывается функция, которая активирует внутреннее замыкание по вашему желанию.
### Приватные переменные с замыканиями
Как вы теперь знаете, переменные, созданные внутри функции, не могут быть доступны снаружи. Из-за того, что они не доступны, их также называют **приватными переменными**.
Однако иногда требуется доступ к такой приватной переменной, и для этого используются замыкания.
```
function secret (secretCode) {
return {
saySecretCode () {
console.log(secretCode);
}
}
}
const theSecret = secret('CSS Tricks is amazing');
theSecret.saySecretCode(); // 'CSS Tricks is amazing'
```
В примере выше `saySecretCode` — единственная функция (замыкание), которая выводит `secretCode` снаружи исходной функции secret. По этой причине такую функцию называют **привилегированной**.
Отладка областей видимости с помощью DevTools
---------------------------------------------
Инструменты разработчика (DevTools) Chrome и Firefox упрощают отлаживание переменных в текущей области видимости. Существует два способа применения этого функционала.
**Первый способ**: добавлять ключевое слово `debugger` в код, чтобы останавливать выполнение JavaScript кода в браузерах с целью дальнейшей отладки.
Ниже пример с `prepareCake`:
```
function prepareCake (flavor) {
// Добавляем debugger
debugger
return function () {
setTimeout(_ => console.log(`Made a ${flavor} cake!`), 1000);
}
}
const makeCakeLater = prepareCake('banana');
```
Если открыть DevTools и перейти во вкладку Sources в Chrome (или вкладку Debugger в Firefox), то можно увидеть доступные переменные.
Можно также переместить debugger внутрь замыкания. Обратите внимание, как переменные области видимости изменяться в этот раз:
```
function prepareCake (flavor) {
return function () {
// Добавляем debugger
debugger
setTimeout(_ => console.log(`Made a ${flavor} cake!`), 1000);
}
}
const makeCakeLater = prepareCake('banana');
```
**Второй способ:** добавлять брейкпоинт напрямую в код во вкладке Sources (или Debugger) путем клика на номер строки.
**Выводы:**
* Области видимости и замыкания не настолько сложны для понимания, как кажется. Они достаточно просты, если рассматривать их через принцип одностороннего зеркала.
* После объявления переменной в функции доступ к ней возможен только внутри функции. Такие переменные называют определенными в контексте этой функции.
* Если вы объявляете любую внутреннюю функцию внутри другой функции, то внутренняя функция называется замыканием, т.к. эта функция сохраняет доступ к переменным внешней функции. | https://habr.com/ru/post/338462/ | null | ru | null |
# Основы Linux от основателя Gentoo. Часть 2 (4/5): Обработка текста и перенаправления
В этом отрывке вы узнаете про множество интересных и полезных команд по работе с текстовыми данными в Linux. Также даны основы работы с потоками ввода-вывода в bash.
>
>
> [](http://www.gnu.org/graphics/3dbabygnutux.html)
>
> ##### **Навигация по основам Linux от основателя Gentoo:**
>
>
>
> ###### Часть I
>
> 1. [BASH: основы навигации](http://habrahabr.ru/blogs/linux/99041/) (вступление)
> 2. [Управление файлами и директориями](http://habrahabr.ru/blogs/linux/99291/)
> 3. [Ссылки, а также удаление файлов и директорий](http://habrahabr.ru/blogs/linux/99653/)
> 4. [Glob-подстановки](http://habrahabr.ru/blogs/linux/99827/) (итоги и ссылки)
>
>
>
> ###### Часть II
>
> 1. [Регулярные выражения](http://habrahabr.ru/blogs/linux/102442/) (вступление)
> 2. [Назначения папок, поиск файлов](http://habrahabr.ru/blogs/linux/105495/)
> 3. [Управление процессами](http://habrahabr.ru/blogs/linux/105657/)
> 4. **Обработка текста и перенаправления**
> 5. [Модули ядра](http://habrahabr.ru/blogs/linux/107981/) (итоги и ссылки)
>
>
>
>
Обработка текста
----------------
### Возвращаемся к перенаправлению
Ранее в этой серии руководств, мы видели пример использования >, оператора для перенаправления вывода команды в файл, как показано ниже:
`$ **echo "firstfile" > copyme**`
Помимо перенаправления вывода в файл, мы можем воспользоваться такой мощной фишкой оболочки как каналы (пайпы). Используя пайпы, мы можем передать вывод одной команды на вход другой. Рассмотрим следующий пример:
````
$ **echo "hi there" | wc**
1 2 9
````
Символ | используется для подключения выхода команды слева, ко входу команды справа от него. В примере выше, команда echo печатает в вывод «hi there» с символом перевода строки в конце. Этот вывод обычно появляется в терминале, но канал перенаправляет его на вход команде wc, которая показывает количество строк, слов и символов.
### Пример с каналами (пайпами)
Вот другой простой пример:
`$ **ls -s | sort -n**`
В этом случае, ls -s обычно вывела бы текущую директорию на терминал, с указанием размера перед каждым файлом. Однако вместо этого, мы передаем вывод программе sort -n, которая численно отсортирует его. Это очень удобно для поиска файлов, которые занимают в директории больше всего места.
Следующие примеры посложнее, они демонстрируют мощь и удобство, которые можно получить используя каналы. Далее мы используем команды, которые еще не были рассмотрены, однако не заостряйте на них свое внимание. Вместо это, сконцентрируйтесь на понимании того, как работают пайпы и как вы можете использовать их в своей повседневной работе с Linux.
### Распаковывающий канал
Для разархивации и распаковки файла, вы могли бы сделать следующее:
`$ **bzip2 -d linux-2.4.16.tar.bz2**
$ **tar xvf linux-2.4.16.tar**`
Недостаток такого метода — это создание промежуточного, разархивированного файла на диске. Поскольку tar может читать данные напрямую со своего входа (вместо указанного файла), мы можем получить тот же конечный результат используя пайп:
`$ **bzip2 -dc linux-2.4.16.tar.bz2 | tar xvf -**`
Вуухуу! Сжатый тарбол был распакован и мы обошлись без промежуточного файла.
### Канал подлиннее
Вот еще один пример пайпа:
`$ **cat myfile.txt | sort | uniq | wc -l**`
Мы используем cat для отправки содержимого myfile.txt команде sort. Когда sort получает данные на вход, она сортирует их построчно в алфавитном порядке, и отправляет в таком виде программе uniq. uniq удаляет повторяющиеся строки (кстати uniq, требует отсортированный список на входе) и отправляет результат на wc -l. Мы рассматривали команду wc ранее, но без ее опций. Когда указывается опция -l, то команда выводит только количество строк, количество слов и символов в этом случае не выводятся. Вы увидите, что такой пайп распечатает количество уникальных строк в текстовом файле.
Попробуйте создать пару файлов в вашем текстовом редакторе. Используйте на них данный пайп и посмотрите на результат который вы получите.
### Буря обработки текста начинается!
Теперь мы приступим к беглому осмотру команд Linux для стандартной обработки текстов. Поскольку сейчас мы рассмотрим множество программ, у нас не будет места для примеров по каждой из них. Вместо этого, мы призываем вас прочитать man-станицы приведенных команд (набрав man echo, например) и изучить каждую команду с ее опциями, потратив некоторое время на игру с ними. Как правило, эти команды печатают результат обработки на терминал, а не производят модификацию непосредственно файла. После этого беглого обзора, мы поглубже рассмотрим перенаправление ввода-вывода. Так что да, уже виден свет в конце тунеля. :)
**echo** печатает свои аргументы на терминал. Используйте опцию -e если хотите включить в вывод управляющие последовательности; например echo -e 'foo\nfoo' напечатает foo, затем перейдет на новую строку, затем снова напечатает foo. Используйте опцию -n чтобы запретить echo добавлять символ новой строки в конец вывода, как это сделано по-умолчанию.
**cat** напечатает содержимое указанного файла на терминал. Удобна как первая команда пайпа, например, cat foo.txt | blah.
**sort** выведет содержимое файла, указанного в командной строке, в алфавитном порядке. Естественно, sort также может принимать ввод из пайпа. Наберите man sort чтобы ознакомиться с опциями команды, которые управлют вариантами сортировки.
**uniq** принимает уже отсортированный файл или поток данных (через пайп) и удаляет повторяющиеся строки.
**wc** выводит количество строк, слов и символов в указанном файле или во входном потоке (из пайпа). Введите man wc чтобы узнать, как настроить вывод программы.
**head** выводит первые десять строк файла или потока. Используйте опцию -n, чтобы указать, сколько строк должно отображаться.
**tail** печатает последние десять строк файла или потока. Используйте опцию -n, чтобы указать, сколько строк должно отображаться.
**tac** похожа на *cat*, но печатает все строки в обратном порядке, другими словами, последняя строка печатается в первую очередь.
**expand** конвертирует входные символы табуляции в пробелы. Опция -t указывает размер табуляции.
**unexpand** конвертирует входные пробелы в символы табуляции. Опция -t указывает размер табуляции.
**cut** используется для извлечения из входного файла или потока, полей разделенных указанным символом. (попробуйте echo 'abc def ghi jkl' | cut -d ' ' -f2,2 прим. пер.)
Команда **nl** добавляет к каждой входной строке ее номер. Удобно для распечатки.
**pr** разбивает файл на страницы и нумерует их; обычно используется для печати.
**tr** — инструмент трансляции (преобразования) символов; используется для отображения определенных символов во входном потоке на заданные символы в выходной поток.
**sed** — мощный потоко-ориентированный текстовый редактор. Вы можете узнать больше о sed из следующих руководств на сайте Funtoo:
* **[Sed в примерах, Часть 1 (En)](http://www.funtoo.org/en/articles/linux/sed/1)**
* **[Sed в примерах, Часть 2 (En)](http://www.funtoo.org/en/articles/linux/sed/2)**
* **[Sed в примерах, Часть 3 (En)](http://www.funtoo.org/en/articles/linux/sed/3)**
Если вы планируете сдавать экзамен LPI, обязательно прочитайте первые две статьи этой серии.
**awk** — искуссный язык построчного разбора и обработки входного потока по заданным шаблонам. Чтобы узнать больше о awk прочитайте следующую серию руководств на сайте Funtoo:
* **[Awk в примерах, Часть 1 (En)](http://www.funtoo.org/en/articles/linux/awk/1)**
* **[Awk в примерах, Часть 2 (En)](http://www.funtoo.org/en/articles/linux/awk/2)**
* **[Awk в примерха, Часть 3 (En)](http://www.funtoo.org/en/articles/linux/awk/3)**
**od** разработан для представления входного потока в восьмеричном, шестнадцатеричном и т.д. формате.
**split** — эта команда используется для разделения больших файлов на несколько небольших, более управляемых частей.
**fmt** используется, чтобы выполнить «перенос» длинных строк текста. Сегодня она не очень полезна, поскольку эта возможность встроена в большинство текстовых редакторов, хотя команда достаточно хороша, чтобы ее знать.
**paste** принимает два или несколько файлов в качестве входных данных, объединяет построчно и выводит результат. Может быть удобно для создания таблиц или колонок текста.
**join** похожа на paste, эта утилита позволяет объединять два файла по общему полю (по-умолчанию первое поле в каждой строке).
**tee** печатает входные аргументы в файл и на экран одновременно. Это полезно, когда вы хотите создать лог для чего-либо, а также хотите видеть процесс на экране.
### Буря закончилась! Перенаправление
Как и > в командной строке, вы можете использовать < для перенаправления файла, но уже на вход команде. Для многих команд, можно просто указать имя файла. К сожалению некоторые программы работают только со стандартным потоком ввода.
Bash и другие шелы поддерживают концепцию «herefile». Это позволяет давать входные данные команде в виде набора строк с последующей командой, означающей окончание ввода последовательности значений. Проще всего это показать на примере:
`$ **sort** <
**apple
cranberry
banana
END**
apple
banana
cranberry`
В приведенном выше примере, мы вводим слова apple, cranberry и banana, с последующим «END» для указания окончания ввода. Затем программа sort возвращается наши слова в алфавитном порядке.
### Использование ">>"
Можно ожидать, >> будет в чем-то похожа на <<, но это не так. Она позволяет просто добавить вывод в файл, а не перезаписывать его каждый раз, как это делает >. Пример:
`$ **echo Hi > myfile**
$ **echo there. > myfile**
$ **cat myfile**
there.`
Уупс! Мы потеряли часть с «Hi»! А вот что мы имели ввиду:
`$ **echo Hi > myfile**
$ **echo there. >> myfile**
$ **cat myfile**
Hi
there.`
Так то лучше!
*Спасибо **Dmitry Minsky** (Dmitry.Minsky@gmail.com) за перевод.*
**[Продолжение...](http://habrahabr.ru/blogs/linux/107981/)**
---
Об авторах
----------
### Daniel Robbins
Дэниэль Роббинс — основатель сообщества Gentoo и создатель операционной системы Gentoo Linux. Дэниэль проживает в Нью-Мехико со свой женой Мэри и двумя энергичными дочерьми. Он также основатель и глава [Funtoo](http://www.funtoo.org/), написал множество технических статей для [IBM developerWorks](http://www.ibm.com/developerworks/), Intel Developer Services и C/C++ Users Journal.
### Chris Houser
Крис Хаусер был сторонником UNIX c 1994 года, когда присоединился к команде администраторов университета Тэйлора (Индиана, США), где получил степень бакалавра в компьютерных науках и математике. После он работал во множестве областей, включая веб-приложения, редактирование видео, драйвера для UNIX и криптографическую защиту. В настоящий момент работает в Sentry Data Systems. Крис также сделал вклад во множество свободных проектов, таких как Gentoo Linux и Clojure, стал соавтором книги [The Joy of Clojure](http://joyofclojure.com).
### Aron Griffis
Эйрон Гриффис живет на территории Бостона, где провел последнее десятилетие работая в Hewlett-Packard над такими проектами, как сетевые UNIX-драйвера для Tru64, сертификация безопасности Linux, Xen и KVM виртуализация, и самое последнее — платформа [HP ePrint](http://hpeprint.com/). В свободное от программирования время Эйрон предпочитает размыщлять над проблемами программирования катаясь на своем велосипеде, жонглируя битами, или болея за бостонскую профессиональную бейсбольную команду «Красные Носки». | https://habr.com/ru/post/105926/ | null | ru | null |
# MetricKit. Анализ производительности iOS приложений
### Новая игрушка
Мы продолжаем знакомиться с новым материалом от Apple, представленным на WWDC. На этот раз рассмотрим [MetricKit](https://developer.apple.com/documentation/metrickit), это абсолютно новый фреймворк, который служит инструментом для мониторинга производительности приложений.
Все знают, что измерение производительности приложения во время разработки — это просто. Xcode показывает количество используемой оперативной памяти и загруженность процессора, вы можете подключиться с помощью Instruments к симулятору или тестируемому устройству и даже написать собственные инструменты (более подробно об этом смотрите наши статьи о пользовательских пакетах инструментов: [часть 1](https://appspector.com/blog/building-custom-xcode-instruments-package)/[часть 2](https://appspector.com/blog/instruments-part-2)). Только лишь понимание важности настройки производительности не позволяет измерить практически все, что выполняет приложение. Но все стает более сложным, когда мы говорим о AppStore, если разрабатываемое приложение предназначается для реальных пользователей. Независимо от того, насколько тщательно вы тестируете свое приложение, в реальных условиях всегда появится куча сюрпризов, которые повлияют на производительность и пользовательский опыт. Конечно, существует множество инструментов для сбора различных параметров, но большинство из них ограничены **iOS SDK**, а также влиянием фактического мониторинга на поведение приложений.
В этом году Apple решила заполнить этот пробел и предоставила разработчикам инструмент, который помогает им собирать и анализировать показатели производительности приложений в реальной среде. Они анонсировали **MetricKit** (фреймворк, который предоставляет доступ к параметрам, которые предоставляет OS) отдельной вкладки в органайзере Xcode 11, где можно найти параметры приложений. Сделаем паузу в MetricKit, потому что отображение параметров в XCode будет работать только с приложениями, которые уже опубликованные в AppStore.
### MXMetricManager
Архитектура фреймворка довольно проста и понятна. Центральную часть занимает класс **MXMetricManager**, представляющий собой одно-элементную структуру, которая предоставляет разработчику большой набор APIs фреймворка.
В общем, рабочий процесс состоит из 3-х основных этапов:
1. Вы инициализируете MXMetricMnager и назначаете для него наблюдателя.
2. При желании вы можете реализовать собственные метрики в своем приложении, используя API Signpost
3. И, наконец, теперь мы имеем дело с полученными данными в методе didReceivePayloads, т.е. отправляем их в свой бэкэнд для дальнейшего анализа.
Параметры приходят в виде массива экземпляров [MXMetricPayload](https://developer.apple.com/documentation/metrickit/mxmetricpayload). Полезная нагрузка инкапсулирует наборы метаданных и временные метки. Metric payload — это простая оболочка для подкласса [MXMetric](https://developer.apple.com/documentation/metrickit/mxmetric). Для каждого типа параметров она отдельная.
Типы метрик довольно хорошо документированы Apple, поэтому не будем останавливаться на этом слишком долго. Тем не менее, следует остановиться, чтобы заметить одну интересную вещь — MXMetric предоставляет открытый API для сериализации его в NSDictionary или JSON, что, с моей точки зрения, немного необычно.
### Внутренние компоненты MetricKit.
Снаружи MetricKit выглядит довольно просто. Но всегда интересно увидеть, как все работает изнутри. Погружение во что-то более глубокое является всегда интригой, если перед вами стоит конкретная задача. Поэтому я решил, что хочу передать параметры с метками MetricKit, а затем заставить их предоставлять мне обновленные метрики в любое время. Конечно, вы можете использовать `*Debug -> Simulate MetricKit Payloads*` в Xcode, но id не позволяет отображать собственные данные. Правда, это не очень полезная команда, но она дает вам направление в ваших исследованиях, и это выглядит весьма забавно ;)
Чтобы начать выполнение задачи, нам, очевидно, необходим сам MetricKit. Можно подумать, что получить бинарный файл для фреймворка легко, потому что Xcode показывает его в списке фреймворков, как только вы добавите его через диалог «связать бинарный файл с библиотеками». Это весьма оптимистичная мысль. Потому что если вы откроете **MetricKit.framework**, вы увидите файл **MetricKit.tbd**. Его размер всего **4кб**. Очевидно, это не то, что мы ищем.
Так что же на самом деле здесь происходит?
**TBD** расшифровывается как «text-based dylib stub» и фактически является файлом YAML с описанием dylib, экспортирующим символы и путем к двоичному файлу dylib. Связывание с файлами tbd уменьшает размер двоичного файла. Позже, во время выполнения, настоящий бинарный файл dylib будет загружен из OS по пути, указанному в файле tbd. Вот как выглядит файл, когда вы открываете его в Xcode:
Используя путь из файла tbd, можно легко получить двоичный файл MetricKit для дальнейшего исследования, но существует еще более простой метод.
Наш двоичный файл приложения содержит путь к каждой динамически связанной библиотеке в разделе заголовка Mach-O. Эту информацию легко получить с помощью инструмента, используя флаг -l.
Вот вывод для тестового проекта, который я создал:
```
→ otool -l ./Metrics | grep -i metrickit
name /System/Library/Frameworks/MetricKit.framework/MetricKit (offset 24)
```
Можно увидеть тот же путь, который мы видели ранее в файле tbd. Имея бинарный файл фреймворка, можно взглянуть на внутренние элементы. Для этого я обычно использую [Hopper Disassemble](https://www.hopperapp.com). Он простой в использовании, но очень мощный инструмент для внимательного исследования двоичных файлов.
Как только откроется бинарный файл MetricKit — перейдем к вкладке ‘Proc.’ и развернем список ’Tags’. Здесь можно увидеть все экспортированные символы. Выбрав один из них (например, MXMetricManager), увидим все его методы и, выбрав метод, увидим его содержимое в правой части:
При просмотре списка методов MXMetricManager [ <https://gist.github.com/deszip/88a258ae21d33dc75d7cbac9569c6ec1> ] весьма легко заметить метод \_checkAndDeliverMetricReports. Похоже, это то, что необходимо вызвать, чтобы заставить MetricKit доставлять обновления подписчикам.
К сожалению, попытка вызвать его не привела к вызову абонента, что, вероятно, означает то, что данные параметры не будут доставлены. Рассматривая реализацию метода, заметим несколько интересных вещей: он выполняет перебор содержимого каталога /Library/Caches/MetricKit/Reports.
Затем он пытается разархивировать экземпляр MXMetricPayload для каждого элемента на диске. И, наконец, он перебирает зарегистрированных подписчиков и вызывает метод didReceive со списком данных.
Проблема, вероятно, в том, что в */Library/Caches/MetricKit/Reports* нет данных, но известно то, что нам необходимы некоторые заархивированные экземпляры MXMetricPayload. Итак, давайте создадим их и поместим на диск перед вызовом ‘*\_checkAndDeliverMetricReports*’. Опять же, план состоит в том, чтобы создать экземпляр MXMetricPayload, затем создать и добавить в него любой тип MXMetric, а затем заархивировать экземпляр данных на диске. После всего вызвать метод ‘*\_checkAndDeliverMetricReports*’, это должно привести к вызову нашего подписчика с stub в качестве аргумента.
Просматривая документы Apple по payload и метрикам, вы можете заметить, что у них нет общедоступных инициализаторов, и большинство свойств доступны только для чтения. Итак, каким же образом возможно создать экземпляр класса?
Снова вернемся к Hopper, чтобы посмотреть список методов **MXMetricPayload**:
Здесь видно его инициализаторы и методы для присваивания параметров. Вызывать закрытые методы легко, с помощью класса [NSInvocation](https://developer.apple.com/documentation/foundation/nsinvocation) и метода ‘performSelector’ из-за динамической природы Objective-C.
В качестве примера мы создадим метрики для CPU и добавим их в payload. Используя данную ссылку, можно найти полный фрагмент кода: [ <https://gist.github.com/deszip/a0cf877b07cc2877129e0aaef2fed1e4> ].
И в завершение архивируем все что мы создали и записываем данные в каталог */Library/Caches/MetricKit/Reports*.
Теперь пришло время вызвать метод '*\_checkAndDeliverMetricReports*', что в итоге должно привести к вызову абонента. На этот раз в качестве аргумента передаем данные с stubbed payload в качестве аргумента.
### Откуда берутся метрики
Получение отчетов довольно просто реализовать посредством **MetricKit**, но вам, вероятно, интересно узнать, как отчеты появляются в каталоге *app/Library*. Вот как.
Копая внутри двоичного файла MetricKit, я заметил этот метод: ' \_createXPCConnection’. Проверка его реализации проясняет ситуацию — он строит NSXPCConnection для обслуживания с именем *com.apple.metrickit.xpc* и двумя интерфейсами **MXXPCServer** и **MXXPCClient** для клиентской и серверной сторон. Если посмотреть на описание протокола:
### Заключение
**MetricKit** — это уникальный и незаменимый инструмент, для заботы о производительности своего приложения в реальных условиях в продакшене.
К сожалению, в настоящее время невозможно взглянуть на пользовательский интерфейс ‘Metric’ в Xcode, за исключением того, что было показано во время демонстрации на сессии WWDC.
Он может быть бесценным инструментом для перехода пользовательского опыта на новый уровень за счет устранения проблем с производительностью в вашем коде.
Один недостаток, который я вижу сейчас в данном инструменте — это отсутствие подробностей для каждого типа: только разделение — это версия приложения, и вы не можете видеть какие-либо метрики для определенной группы устройств/версий OS/регионов и т.д.
Но, естественно, всегда имеется возможность отправить данные себе для дальнейшей обработки вместе с важной информацией, которая вам необходима. Вы можете прикрепить ее к задачам в вашем трекере ошибок и многое другое. В [AppSpector](https://appspector.com) наша команда работает над расширением функциональности средств мониторинга производительности с помощью данных, полученных из **MetricKit**.
Оставаться в курсе событий! | https://habr.com/ru/post/468347/ | null | ru | null |
# Просмотр запросов к веб серверу apache в реальном времени
Нагрузка на сервер является важным звеном администрирования веб сервера, отслеживание запросов помогает быстро искать ошибочные запросы и устранять их раньше чем они вернуться к вам со статистикой вебмастера. По умолчанию в конфигурационном файле веб сервера апаче закоментрировано определение хоста в dns что в свою очередь еще больше усложняет понимание того, что приходит на сайте. Упростить все это удалось написанием скрипта отображающего все запросы к веб серверу в режиме реального времени. Сохраняя несколько сотен запросов удалось посчитать время загрузки. Это процент от реально прошедшего времени суммы времени потраченных на вывод ресурсов. Удобный вывод времени затраченного на выполнение каждой страницы сайта стал незаменим в поиске слабых мест. Небольшой массив со списком шаблонов поисковых систем позволил выделить их отдельным цветом в ленте запросов.
Запускается вывод с использованием консоли линукс пробросом по ssh вывода из логов. Плюсом стала минимальная нагрузка при этом на сервер, так как все вычисления происходят на локальной странице. Помогает в подсчетах небольшой php скрипт на вход которого поступает вывод данных из /var/log/apache2/access.log который в свое время подсвечивает важные части лога яркой подсветкой.
К сожалению стандартных уровней логирования подходящих под мои условия я не нашел, В моем случае важным параметром было имя хоста куда приходит запрос, но параметр %V который отвечает за вывод полного имени хоста в стандартных настройках отсутствовал. Пришлось дописать нужные параметры к common
```
LogFormat "%h %V %l %u %t \"%r\" %>s %O %D" common
```
Важно видеть в подобной ленте ботов, эту задачу помогла решить установка вывода в лог ДНС имени клиента. Эта настройка также выключена по умолчанию в конфигурационном файле.
```
HostnameLookups On
```
Сам скрипт представляет из себя небольшой php файл который разбирает все входящие на него данные по частям и подсвечивает обрабатывает важное для дальнейшего вывода. Выглядит это следующим образом. В целях безопасности все локальные хосты и адреса в видео заменены. Дополнительно возможно будет удобно внести в список интересных адресов важные для вас страницы. Скрипт подсветит эти адреса в ленте запросов. На видео во втором параметром выводится среднее количество запросов в секунду, третьим время затраченное на выдачу ресурсов с учетом последних тысячи запросов.
Ну и сам скрипт который отображает данный вывод.
```
/usr/local/bin/log.php
```
```
php
$colors = array(
"200"="[0;32m", "404"=>"[1;31m", "410"=>"[0;31m", "403"=>"[0;91m", "301"=>"[1;33m", "302"=>"[1;36m", "304"=>"[1;36m",
); # Цвета статусов
$bots = array("localhost", "googlebot", "yandex", "spider", "ahrefs", "mail.ru", "bot"); # Шаблон имен ботов, отображается более темным
$url = ["login", "admin"]; # Интересующие адреса будут подсвечиваться в ленте
require "/home/mpak2/www/idna_convert.class.inc";
$idna = new idna_convert();
$in = fopen('php://stdin', 'r');
$tm = []; $t = microtime(true); $nn = 0; $microtime = microtime(true);
while($str = fgets($in)){
if(!$ar = explode(" ", $str)){ print_r("Ошибка формирования массива элементов");
}elseif(!$n = number_format($nt = (100*(count($tm)-1)+($nn%100))/(microtime(true)-$t), 2)){ print_r("Ошибка форматирования времени генерации ресурса");
}elseif(!($percent = number_format((array_sum(array_column($tm, 'msec'))/1e6)/(microtime(true)-$t)*100, 2)) & false){ print_r("Ошибка вычисления процента загрузки");
}elseif(!$mtime = $ar[11]/1e6){ print_r("Ошибка вычисления время обработки ресурса");
}elseif(!$mtm = (($_tm = number_format($mtime, 3)) > 1 ? "\e[1;31m{$_tm}\e[0m" : $_tm)){ print_r("Ошибка форматирования микровремени");
}elseif(!$uri = urldecode($ar[7])){ mpre("Ошибка адрес не определен");
}elseif(!$uri = (array_filter(array_map(function($u) use($uri){ return strpos($uri, $u); }, $url)) ? "\e[1;37m". urldecode($ar[7]). "\e[0m" : urldecode($ar[7]))){ print_r("Локальный адрес не установлен");
# }elseif(!$uri = "/какой-то/адрес"){ mpre("Замена адреса");
}elseif(!$status = (array_key_exists($ar[9], $colors) ? "\e{$colors[$ar[9]]}{$ar[9]}\e[0m" : $ar[9])){ print_r("Ошибка раскрашивания статуса");
}elseif(!$host = "\e[1;34m". $idna->decode($ar[1]). "\e[0m"){ print_r("Ошибка определения хоста запроса");
# }elseif(!$host = "хабра-хабр.рф"){ print_r("Замена имени хоста на звездочки");
}elseif(!$bot = ((array_filter(array_map(function($b) use($ar){ return (strpos($ar[0], $b) !== false ? $b : false); }, $bots))) ? "\e[1;35m{$ar[0]}\e[0m" : "\e[1;32m{$ar[0]}\e[0m")){ print_r("Ошибка определения бота");
}elseif(!$size = number_format($ar[10]/1024, 2). "КБ"){ print_r("Ошибка определения размера запроса");
}else{// print_r($ar);
if(($nn++ % 100) == 0){
array_unshift($tm, ['msec'=>0, 'microtime'=>microtime(true)]);
if(count($tm) > 10){
$t = array_pop($tm)['microtime'];
}
} if(!($nn % 1000) && ($cmd = "echo '". strtr($n, ['.'=>' ']). "' | festival --tts --language russian &")){
passthru($cmd);
} $tm[0]['msec'] += $ar[10];
passthru("echo '{$nn} {$n} {$percent}% {$mtm}c {$status} http://{$host}{$uri} ({$bot}) {$size}'");
}
};
```
Запускается командой: ssh root@хабра-хабр.рф 'tail -f /var/log/apache2/access.log' | php -f /usr/local/bin/log.php | https://habr.com/ru/post/309446/ | null | ru | null |
# Таблица Менделеева на школьной информатике
*(Управляющие карты)
(Посвящается Международному году Периодической таблицы химических элементов)
(Последние дополнения сделаны 8 апреля 2019. Список дополнений сразу под катом)
*([Цветок Менделеева](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D1%8C%D1%82%D0%B5%D1%80%D0%BD%D0%B0%D1%82%D0%B8%D0%B2%D0%BD%D1%8B%D0%B5_%D0%BF%D0%B5%D1%80%D0%B8%D0%BE%D0%B4%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B5_%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D1%8B), [Источник](https://commons.wikimedia.org/wiki/File:Mendeleev_flower.jpg?uselang=ru))
> *Помнится, мы проходили утку. Это были сразу три урока: география, естествознание и русский. На уроке естествознания утка изучалась как утка какие у нее крылышки, какие лапки, как она плавает и так далее. На уроке географии та же утка изучалась как житель земного шара: нужно было на карте показать, где она живет и где ее нет. На русском Серафима Петровна учила нас писать «у-т-к-а» и читала что-нибудь об утках из Брема. Мимоходом она сообщала нам, что по-немецки утка так-то, а по-французски так-то. Кажется, это называлось тогда «комплексным методом». В общем, все выходило «мимоходом».
>
>
>
> Вениамин Каверин, Два капитана*
В приведенной цитате Вениамин Каверин мастерски показал недостатки комплексного метода обучения, однако в некоторых (может быть, довольно редких) случаях элементы этого метода бывают оправданы. Один из таких случаев — это Периодическая таблица Д.И.Менделеева на уроках школьной информатики. Задача программной автоматизации типовых действий с таблицей Менделеева наглядна для школьников, начавших изучать химию, и разбивается на многие типовые химические задачи. В то же время в рамках информатики эта задача позволяет в простой форме продемонстрировать способ управляющих карт, который можно отнести к графическому программированию, понимаемому в широком смысле слова как программирование с помощью графических элементов.
*(13 апреля 2019 сделаны дополнения:
[Дополнение 3: Химическая викторина](#A3)
[Дополнение 4: Интеграция нескольких задач в одной программе](#A4)
8 апреля 2019 сделаны дополнения:
[Дополнение 1: как работает химический калькулятор](#A1)
[Дополнение 2: примеры задач для фильтров)](#A2)*
Начнем с базовой задачи. В простейшем случае на экране в форме-окне должна отображаться Периодическая таблица, где в каждой клетке будет химическое обозначение элемента: H — водород, He — гелий и т.д. Если курсор мыши указывает на клетку, то в специальном поле на нашей форме отображается обозначение элемента и его номер. Если пользователь при этом нажмет ЛКМ, то в другом поле формы будет указаны обозначение и номер этого выбранного элемента.
Задачу можно решать на любом универсальном ЯП. Мы возмем простой старый Delpi-7, понятный почти всем. Но прежде чем программировать на ЯП, нарисуем две картинки, например, в Фотошопе. Во-первых, нарисуем Периодическую таблицу в том виде, как мы хотим ее видеть в программе. Сохраним результат в графическом файле *table01.bmp*.
Для второго рисунка используем первый. Будем последовательно заливать очищенные от всякой графики клетки таблицы уникальными цветами в цветовой модели RGB. R и G всегда будут 0, а B=1 для водорода, 2 для гелия и т. д. Этот рисунок и будет нашей управляющей картой, которую мы сохраним в файл под именем *table2.bmp*.
Первый этап графического программирования в Фотошопе закончен. Перейдем к графическому программированию GUI в IDE Delpi-7. Для этого открываем новый проект, где на главную форму помещаем кнопку вызова диалога (*tableDlg*), в котором будет проходить работа с таблицей. Далее работаем с формой *tableDlg*.
Помещаем на форму компонент класса *TImage*. Получаем *Image1*. Отметим, что в общем случае для больших проектов автоматически сгенерированные имена вида *ImageN*, где *N* может достигать нескольких десятков и более — не лучший стиль программирования, и следует давать более осмысленные имена. Но в нашем маленьком проекте, где *N* не будет превосходить 2, можно оставить как сгенерировалось.
В свойство *Image1.Picture* загружаем файл *table01.bmp*. Создаем *Image2* и загружаем туда нашу управляющую карту *table2.bmp*. При этом компонент делаем маленьким и невидимым пользователю, как показано в левом нижнем углу формы. Добавляем дополнительные элементы контроля, назначения которых очевидно. Второй этап графического программирования GUI в IDE Delpi-7 закончен.
Переходим к третьему этапу — написанию кода в IDE Delpi-7. Модуль состоит всего из пяти обработчиков событий: создание формы (*FormCreate*), движения курсора по *Image1* (*Image1MouseMove*), нажатие ЛКМ на клетку (*Image1Click*) и выхода из диалога с помощью кнопок OK (*OKBtnClick*) или Cancel (*CancelBtnClick*). Заголовки этих обработчиков генерируются стандартным образом с помощью IDE.
**Исходный код модуля:**
```
unit tableUnit;
// Периодическая таблица химических элементов Д.И.Менделеева
//
// third112
// https://habr.com/ru/users/third112/
//
// Оглавление
// 1) создание формы
// 2) работа с таблицей: указание и выбор
// 3) выход из диалога
interface
uses Windows, SysUtils, Classes, Graphics, Forms, Controls, StdCtrls,
Buttons, ExtCtrls;
const
size = 104; // число элементов
type
TtableDlg = class(TForm)
OKBtn: TButton;
CancelBtn: TButton;
Bevel1: TBevel;
Image1: TImage; //таблица химических элементов
Label1: TLabel;
Image2: TImage; //управляющая карта
Label2: TLabel;
Edit1: TEdit;
procedure FormCreate(Sender: TObject); // создание формы
procedure Image1MouseMove(Sender: TObject; Shift: TShiftState; X,
Y: Integer); // указание клетки
procedure Image1Click(Sender: TObject); // выбор клетки
procedure OKBtnClick(Sender: TObject); // OK
procedure CancelBtnClick(Sender: TObject); // Cancel
private
{ Private declarations }
TableSymbols : array [1..size] of string [2]; // массив обозначений элементов
public
{ Public declarations }
selectedElement : string; // выбранный элемент
currNo : integer; // текущий номер элемента
end;
var
tableDlg: TtableDlg;
implementation
{$R *.dfm}
const
PeriodicTableStr1=
'HHeLiBeBCNOFNeNaMgAlSiPSClArKCaScTiVCrMnFeCoNiCuZnGaGeAsSeBrKrRbSrYZrNbMoTcRuRhPdAgCdInSnSbTeIXeCsBaLa';
PeriodicTableStr2='CePrNdPmSmEuGdTbDyHoErTmYbLu';
PeriodicTableStr3='HfTaWReOsIrPtAuHgTlPbBiPoAtRnFrRaAc';
PeriodicTableStr4='ThPaUNpPuAmCmBkCfEsFmMdNoLrKu ';
// создание формы ==================================================
procedure TtableDlg.FormCreate(Sender: TObject);
// создание формы
var
s : string;
i,j : integer;
begin
currNo := 0;
// инициализация массива обозначений элементов:
s := PeriodicTableStr1+ PeriodicTableStr2+PeriodicTableStr3+PeriodicTableStr4;
j := 1;
for i :=1 to size do
begin
TableSymbols [i] := s[j];
inc (j);
if s [j] in ['a'..'z'] then
begin
TableSymbols [i] := TableSymbols [i]+ s [j];
inc (j);
end; // if s [j] in
end; // for i :=1
end; // FormCreate ____________________________________________________
// работа с таблицей: указание и выбор =========================================
procedure TtableDlg.Image1MouseMove(Sender: TObject; Shift: TShiftState;
X, Y: Integer);
// указание клетки
var
sl : integer;
begin
sl := GetBValue(Image2.Canvas.Pixels [x,y]);
if sl in [1..size] then
begin
Label1.Caption := intToStr (sl)+ ' '+TableSymbols [sl];
currNo := sl;
end
else
Label1.Caption := 'Select element:';
end; // Image1MouseMove ____________________________________________________
procedure TtableDlg.Image1Click(Sender: TObject);
begin
if currNo <> 0 then
begin
selectedElement := TableSymbols [currNo];
Label2.Caption := intToStr (currNo)+ ' '+selectedElement+ ' selected';
Edit1.Text := selectedElement;
end;
end; // Image1Click ____________________________________________________
// выход из диалога ==================================================
procedure TtableDlg.OKBtnClick(Sender: TObject);
begin
selectedElement := Edit1.Text;
hide;
end; // OKBtnClick ____________________________________________________
procedure TtableDlg.CancelBtnClick(Sender: TObject);
begin
hide;
end; // CancelBtnClick ____________________________________________________
end.
```
В нашей версии мы взяли таблицу размером 104 элемента (константа *size*). Очевидным образом этот размер может быть увеличен. Обозначения элементов (химические символы) записываются в массив *TableSymbols*. Однако по соображениям компактности исходного кода представляется целесообразным записать последовательность этих обозначений в виде строковых констант *PeriodicTableStr1*,…, *PeriodicTableStr4*, чтобы при событии создания формы программа сама раскидала эти обозначения по элементам массива. Каждое обозначение элемента состоит из одной или двух латинских букв, причем первая буква прописная, а вторая (если есть) строчная. Это несложное правило реализуется при загрузке массива. Таким образом, последовательность обозначений удается записать сжатым образом без пробелов. Разбивка последовательности на четыре части (константы *PeriodicTableStr1*,…, *PeriodicTableStr4*) обусловлена соображением удобства чтения исходного кода, т.к. слишком длинная строка может не уместиться целиком на экране.
При событии передвижения курсора мыши по *Image1* обработчик *Image1MouseMove* этого события определяет значение синей компоненты цвета пиксела управляющей карты *Image2* для текущих координат курсора. По построению *Image2* это значение равно номеру элемента, если курсор находится внутри клетки; нулю, если на границе, и 255 в других случаях. Остальные действия, производимые программой, тривиальны и не требуют пояснений.
В дополнение к отмеченным выше стилистическим приемам программирования стоит отметить стиль комментариев. Строго говоря, рассмотренный код настолько маленький и простой, что комментарии выглядят не особо нужными. Однако они были добавлены в том числе и по методическим соображениям — короткий код позволяет сделать нагляднее некоторые общие выводы. В представленном коде декларирован один класс (*TtableDlg*). Методы этого класса можно поменять местами и это никак не отразится на функционировании программы, но может сказаться на ее удобочитаемости. Например, представим последовательность:
```
OKBtnClick, Image1MouseMove, FormCreate, Image1Click, CancelBtnClick.
```
Может, и не очень заметно, но читать и разбираться станет чуточку сложнее. Если методов не пять, а в десятки раз больше и в секции *implementation* у них совершенно другой порядок следования, чем в описаниях классов, то хаос будет только возрастать. Поэтому, хотя строго доказать трудно и может быть даже невозможно, но можно надеяться, что наведение дополнительного порядка улучшит читаемость кода. Этому дополнительному порядку способствует логическая группировка нескольких методов, выполняющих близкие задачи. Каждой группе стоит дать заголовок, например:
```
// работа с таблицей: указание и выбор
```
Эти заголовки стоит скопировать в начало модуля и оформить как оглавление. В некоторых случаях достаточно длинных модулей такие оглавления предоставляют дополнительные возможности навигации. Аналогично в длинном теле одного метода, процедуры или функции стоит, во-первых, отметить конец этого тела:
```
end; // FormCreate
```
а, во-вторых, в развлетвленных операторах с программными скобками begin – end отметить оператор, к которому относится закрывающая скобка:
```
end; // if s [j] in
end; // for i :=1
end; // FormCreate
```
Для выделения заголовков групп и концов тел методов можно добавить строки, превышающие длину большинства операторов и состоящие, например, из символов «=» и «\_» соответственно.
Опять же нужно оговориться: у нас слишком простой пример. А когда код метода не помещается на один экран, в шести следующих друг за другом end разобраться, чтобы произвести изменения кода, бывает непросто. В некоторых старых компиляторах, например, Pascal 8000 для OS IBM 360/370 в листинге cлева печаталась служебная колонка вида
```
B5
…
E5
```
Это означало, что закрывающая программная скобка на строке E5 соответствует открывающей скобке на строке B5.
Конечно, стиль программирования очень неоднозначный вопрос, поэтому высказанные здесь идеи следует воспринимать не более чем информацию к размышлению. Двум достаточно опытным программистам, у которых за многие годы работы сложились и стали привычными разные стили, бывает очень трудно договориться. Другое дело учащийся программировать школьник, у которого еще не было времени обрести свой собственный стиль. Думаю, что в этом случае учитель должен по меньшей мере донести до своих учеников такую простую, но неочевидную им мысль, что успех программы во многом зависит от стиля, на котором написан ее исходный код. Ученик может не последовать рекомендуемому стилю, но пусть он хотя бы задумается о необходимости «лишних» действий для улучшения оформления исходного кода.
Возвращаясь к нашей базовой задаче по Периодической таблице: дальнейшее развитие может идти в разных направлениях. Одно из направлений справочное: при наведении курсора мыши на клетку таблицы выпадает информ-окно, содержащее дополнительные сведения по указанному элементу. Дальнейшее развитие — фильтры. Например, в зависимости от установки в информ-окне будет только: важнейшие физ-хим сведения, информация по истории открытия, информация о распространении в природе, список важнейших соединений (куда входит данный элемент), физиологические свойства, название на иностранном языке и т. д. Вспоминая «утку» Каверина, с которой начинается эта статья, можно сказать, что при таком развитии программы получим полный обучающий комплекс по естественным наукам: кроме информатики, физики и химии — биология, экономическая география, история науки и даже иностранные языки.
Но локальная база данных — это не предел. Программа естественным образом подключается к Интернету. При выборе элемента срабатывает ссылка, и в окне web-браузера раскрывается статья Википедии про данный элемент. Википедия, как известно, не является авторитетным источником. Можно задать ссылки на авторитетные источники, например, химическую энциклопедию, БСЭ, реферативные журналы, заказать запросы в поисковиках на данный элемент и т.д. Т.о. ученики смогут выполнять простые, но содержательные задания по темам СУБД и Интернет.
Кроме запросов по отдельному элементу, можно сделать функционал, который будет отмечать, например, разными цветами клетки в таблице, соответствующие определенным критериям. Например, металлы и неметаллы. Или клетки, которые сливает в водоемы местный химзавод.
Можно также реализовать функции записной книжки-органайзера. Например, выделить в таблице элементы, которые входят в экзамен. Потом выделять элементы, изученные/повторенные учеником при подготовке к экзамену.
А вот, например, одна из типовых задач школьной химии:
*Дано 10 г мела. Сколько соляной кислоты надо взять, чтобы растворить весь этот мел?*
Чтобы решить эту задачу, надо, записав хим. реакцию и расставив в ней коэффициенты, посчитать молекулярные веса карбоната кальция и хлористого водорода, потом составить и решить пропорцию. Посчитать и решить сможет калькулятор на основе нашей базовой программы. Правда, еще нужно будет учесть, что кислоту надо взять с разумным избытком и в разумной концентрации, но это уже химия, а не информатика.
**Дополнение 1: как работает химический калькулятор**Разберем работу калькулятора на примере приведенной выше задачи мела и “солянки”. Начнем с реакции:
CaCO3 + 2HCl = CaCl2 + H2O
Отсюда видим, что нам будут нужны атомные веса следующих элементов: кальция (Ca), углерода (С), кислорода (O), водорода (H) и хлора (Cl). В простейшем случае можем записать эти веса в одномерный массив, определенный как
```
AtomicMass : array [1..size] of real;
```
где индекс массива соответствует номеру элемента. Еще на свободное место формы *tableDlg* помещаем два поля. В первом поле первоначально написано: “Первый реагент дано”, во втором — “Второй реагент найти х”. Обозначим поля *reagent1*, *reagent2* соответственно. Другие дополнения в программу будут ясны из следующего примера работы калькулятора.
Набираем на клавиатуре компьютера: 10 г. Надпись в поле *reagent1* меняется: “Первый реагент дано 10 г”. Теперь вводим формулу этого реагента, а калькулятор будет считать и показывать его молекулярный вес по мере ввода.
Нажимаем ЛКМ на клетку таблицы с символом Ca. Надпись в поле *reagent1* меняется: “Первый реагент Ca 40.078 дано 10 г”.
Нажимаем ЛКМ на клетку таблицы с символом C. Надпись в поле *reagent1* меняется: “Первый реагент CaC 52.089 дано 10 г”. Т.е. калькулятор сложил атомные веса кальция и углерода.
Нажимаем ЛКМ на клетку таблицы с символом O. Надпись в поле *reagent1* меняется: “Первый реагент CaCO 68.088 дано 10 г”. Калькулятор добавил к сумме атомный вес кислорода.
Нажимаем ЛКМ на клетку таблицы с символом O. Надпись в поле *reagent1* меняется: “Первый реагент CaCO2 84.087 дано 10 г”. Калькулятор еще раз добавил к сумме атомный вес кислорода.
Нажимаем ЛКМ на клетку таблицы с символом O. Надпись в поле *reagent1* меняется: “Первый реагент CaCO3 100.086 дано 10 г”. Калькулятор снова добавил к сумме атомный вес кислорода.
Нажимаем Enter на клавиатуре компьютера. Ввод первого реагента закончен и переключается на поле *reagent2*. Отметим, что в этом примере мы приводим минимальную версию. При желании можно легко организовать множители атомов одного типа, чтобы, например, не нажимать по семь раз подряд на клетку кислорода при вводе формулы хромпика (K2Cr2O7).
Нажимаем ЛКМ на клетку таблицы с символом H. Надпись в поле *reagent2* меняется: “Второй реагент H 1.008 найти х”.
Нажимаем ЛКМ на клетку таблицы с символом Cl. Надпись в поле *reagent2* меняется: “Второй реагент HCl 36.458 найти х”. Калькулятор сложил атомные веса водорода и хлора. В приведенном выше уравнении реакции перед хлористым водородом стоит коэффициент 2. Поэтому нажимаем ЛКМ на поле *reagent2*. Молекулярный вес удваивается (при двойном нажатии утраивается и т.д.). Надпись в поле *reagent2* меняется: “Второй реагент 2HCl 72.916 найти х”.
Нажимаем Enter на клавиатуре компьютера. Ввод второго реагента закончен, и калькулятор находит x из пропорции
Что и требовалось найти.
*Примечание 1.* Смысл полученной пропорции: для растворения 100.086 [Da](https://ru.wikipedia.org/wiki/%D0%90%D1%82%D0%BE%D0%BC%D0%BD%D0%B0%D1%8F_%D0%B5%D0%B4%D0%B8%D0%BD%D0%B8%D1%86%D0%B0_%D0%BC%D0%B0%D1%81%D1%81%D1%8B) мела нужно 72.916 Da кислоты, а для растворения 10 г мела нужно х кислоты.
*Примечание 2.* Сборники похожих задач:
*Хомченко И. Г., Сборник задач и упражнений по химии 2009 г (8-11 класс).
Хомченко Г. П., Хомченко И. Г., Сборник задач по химии для поступающих в вузы, 2019.*
*Примечание 3.* Для упрощения задачи можно в начальной версии упростить ввод формулы и просто дописывать символ элемента в конец строки формулы. Тогда формула карбоната кальция будет иметь вид:
CaCOOO
Но такая запись вряд ли понравится учителю химии. Правильную запись сделать нетрудно — для этого нужно добавить массив:
```
formula : array [1..size] of integer;
```
где индекс – номер химического элемента, а значение по этому индексу – количество атомов (первоначально все элементы массива обнуляются). Следует учитывать порядок записи атомов в формуле, принятый в химии. Например, O3CaC тоже мало кому понравится. Переложим ответственность на пользователя. Делаем массив:
```
formulaOrder : array [1..size] of integer; // можно взять покороче
```
куда записываем номер химического элемента по индексу появления его в формуле. Добавление атома *currNo* в формулу:
```
if formula [currNo]=0 then //этот атом встретился первый раз
begin
orderIndex := orderIndex+1;//в начале ввода формулы orderIndex=0
formulaOrder [orderIndex] := currNo;
end;
formula [currNo]:=formula [currNo]+1;
```
Запись формулы в строку:
```
s := ''; // пустая строка для формулы
for i:=1 to orderIndex do // для всех хим.символов в формуле
begin
s:=s+TableSymbols [ formulaOrder[i]];// добавляем хим.символ
if formula [formulaOrder[i]]<>1 then //добавляем кол-во атомов
s:=s+ intToStr(formula [formulaOrder[i]]);
end;
```
*Примечание 4.* Имеет смысл обеспечить возможность альтернативного ввода формулы реагента с клавиатуры. В этом случае нужно будет реализовать простой синтаксический анализатор.
Стоит отметить, что:
> Сегодня существуют несколько сотен вариантов таблицы, при этом учёные предлагают всё новые варианты. ([Википедия](https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D0%B8%D0%BE%D0%B4%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D1%85%D0%B8%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D1%85_%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%BE%D0%B2#%D0%A1%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D0%B0))
Ученики могут проявить смекалку и в этом направлении, реализуя какой-нибудь из уже предложенных вариантов или попробовать сделать свой оригинальный. Может показаться, что это наименее полезное для уроков информатики направление. Однако в реализованной в этой статье форме Периодической таблицы некоторые ученики могут не разглядеть особых преимуществ управляющих карт перед альтернативным решением с помощью стандартных кнопок *TButton*. Спиральная форма таблицы (где клетки разной формы) нагляднее продемонстрирует преимущества предлагаемого здесь решения.
([Альтернативная система элементов Теодора Бенфея](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D1%8C%D1%82%D0%B5%D1%80%D0%BD%D0%B0%D1%82%D0%B8%D0%B2%D0%BD%D1%8B%D0%B5_%D0%BF%D0%B5%D1%80%D0%B8%D0%BE%D0%B4%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B5_%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D1%8B), [Источник](https://commons.wikimedia.org/wiki/File:Elementspiral.svg?uselang=ru))
Добавим также, что о ряде существующих на данный момент компьютерных программ для Таблицы Менделеева рассказано в недавно опубликованной на Хабре [статье](https://habr.com/ru/post/446094).
**Дополнение 2: примеры задач для фильтров**С помощью фильтров можно решать, например, такие задачи:
1) Выделить в таблице все элементы, известные в средние века.
2) Выделить все элементы, известные к моменту открытия Периодического закона.
3) Выделить семь элементов, которые алхимики считали металлами.
4) Выделить все элементы, которые находятся в газообразном состоянии при нормальных условиях (н.у.).
5) Выделить все элементы, которые находятся в жидком состоянии при н.у.
6) Выделить все элементы, которые находятся в твердом состоянии при н.у.
7) Выделить все элементы, которые могут долгое время находиться на воздухе без заметных изменений при н.у.
8) Выделить все металлы, которые растворяются в соляной кислоте.
9) Выделить все металлы, которые растворяются в серной кислоте при н.у.
10) Выделить все металлы, которые растворяются в серной кислоте при нагревании.
11) Выделить все металлы, которые растворяются в азотной кислоте.
12) Выделить все металлы, которые бурно реагируют с водой при н.у.
13) Выделить все металлы.
14) Выделить элементы, широко распространенные в природе.
15) Выделить элементы, которые встречаются в природе в свободном состоянии.
16) Выделить элементы, играющие важнейшую роль в организме человека и животных.
17) Выделить элементы, которые широко используются в быту (в свободном виде или в соединениях).
18) Выделить элементы, работы с которыми наиболее опасны и требуют специальных мер и средств защиты.
19) Выделить элементы, которые в свободном виде или в виде соединений представляют наибольшую угрозу для экологии.
20) Выделить драгоценные металлы.
21) Выделить элементы, стоящие дороже драгоценных металлов.
*Примечания*
1) Имеет смысл обеспечить работу нескольких фильтров. Например, если включить фильтр на решение задачи 1(все элементы, известные в средние века) и 20 (драгоценные металлы), то будут выделены (например, цветом) клетки с драгоценными металлами, известными в средние века (не будет выделен, например, палладий, открытый в 1803 г.).
2) Имеет смысл обеспечить работу нескольких фильтров в таком режиме, чтобы каждый фильтр выделял клетки своим цветом, но не удалял полностью выделение другого фильтра (часть клетки одним цветом, часть другим). Тогда в случае предыдущего примера будут видны элементы пересечения множеств открытых в средние века и драгоценных металлов, а также элементы, принадлежащие только первому и только второму множествам. Т.е. драгоценные металлы, неизвестные в средние века, и элементы, известные в средние века, но не являющиеся драгоценными металлами.
3) Имеет смысл после применения фильтра обеспечить возможность других работ с полученными результатами. Например, выделив элементы, известные в средние века, пользователь нажимает ЛКМ на выделенный элемент и попадает в статью Википедии про этот элемент.
4) Имеет смысл обеспечить возможность пользователю снимать выделение нажатием ЛКМ на выделенную клетку таблицы. Например, чтобы убрать уже просмотренные элементы.
5) Имеет смысл обеспечить сохранение списка выделенных клеток в файле и загрузку такого файла с автоматическим выделением клеток. Это даст пользователю возможность сделать перерыв в работе.
**Дополнение 3: Химическая викторина**В отличие от таблицы умножения, школьников не заставляют учить наизусть таблицу Менделеева, но те, кто интересуется химией, по мере ее изучения как-то само собой запоминают почти всю таблицу. Это обеспечивается пониманием сути Периодического закона: почему, например, инертные газы занимают крайний правый столбец, а соседний столбец занимают галогены. Вспомнить правильный порядок в ряду тех же галогенов помогает знание их химических свойств. Таким образом, если ученик помнит наизусть большую часть Периодической таблицы, то это свидетельствует о его хорошем знании химии. Поэтому имеют смысл соревнования в форме викторины на проверку такого необязательного, но желательного знания.
На свободное место формы *tableDlg* помещаем компонент «список выбора одного элемента». В этот список заносим все названия химических элементов в алфавитном порядке. В таблице очищаем все клетки. Участник викторины должен выбрать ЛКМ клетку таблицы и элемент в списке, который должен быть в этой клетке. Можно наоборот: выбрать элемент списка, а потом клетку. Если выбор сделан правильно, программа заносит химический символ элемента в указанную клетку и удаляет его их списка. В противном случае участник получает одно штрафное очко. Счетчик очков размещается на свободном месте *tableDlg*. Программа также снабжается таймером, который подсчитывает время, затраченное участником на заполнение всей таблицы. Можно предусмотреть облегченный вариант: не заполнять клетки лантаноидов и актиноидов. Победитель определяется по затраченному времени минус штрафные очки. Например, первый финишировавший получает 10 очков, из которых вычитаются штрафные очки, второй 8 очков, третий 5 очков.
**Дополнение 4: Интеграция нескольких задач в одной программе**Выше мы рассмотрели ряд возможных задач: справочник по химическим элементам, химический калькулятор, химическая викторина. Каждую из этих задач могут решать разные группы учеников (один или несколько человек). После того как все справятся со своими заданиями, имеет смысл поставить задачу объединения всех решений в одну программу (избегая дублирования кода), где выбор инструмента должен осуществляться из меню главной формы.
Мы использовали статичную наперед заданную управляющую карту, однако есть много важных задач, где могут использоваться динамические управляющие карты, изменяющиеся в ходе работы программы. Примером может быть редактор графов, в котором пользователь с помощью мыши указывает в окне положения вершин и рисует ребра между ними. Чтобы удалить вершину или ребро, пользователь должен указать на нее. Но если на вершину, обозначенную кружком, указать достаточно просто, то на ребро, прорисованное тонкой линией, указать будет сложнее. Здесь поможет управляющая карта, где вершины и ребра занимают окрестности более широкие, чем на видимом рисунке.
С затронутым методом комплексного обучения связан интересный побочный вопрос: может ли данный метод быть полезен при обучении ИИ? | https://habr.com/ru/post/446836/ | null | ru | null |
# Многоагентный умный дом
Начну свою первую статью с небольшой предыстории. К моменту когда все началось, я уже на протяжении 7 лет участвовал в научном проекте, целью которого была разработка [семантической технологии проектирования интеллектуальных систем](http://conf.ostis.net/images/8/85/%D0%93%D0%BE%D0%BB%D0%B5%D0%BD%D0%BA%D0%BE%D0%B2_%D0%92.%D0%92..2012%D1%81%D1%82-%D0%93%D1%80%D0%B0%D1%84%D0%BE%D0%9C%D0%9F%D0%9E%D0%97%D0%9F%D0%9F%D0%A0%D0%B8%D0%9F.pdf). А началось все с прочтения одной [замечетельной статьи](https://habrahabr.ru/post/259243/) (спасибо [vovochkin](https://habr.com/ru/users/vovochkin/)) во второй половине 2015 года. Именно тогда я понял, что разрабатываемая нами технология хорошо подходит под решение задач в области интернета вещей. Это был первый фактор который привел меня к текущему проекту. Вторым фактором было то, что мне сильно нравился фильм «Железный человек» и я сильно хотел иметь своего «Джарвиса» у себя дома.
Несколько месяцев планирования и чтения привели меня к следующим задачам, которые предстояло решить:
* [Доработать ядро для хранения и обработки базы знаний](#core)
* [Реализовать среду для визуальной отладки модели дома](#visual)
* [Реализовать голосовой ввод и вывод](#speech)
#### Немного теории
Приведу немного теории, которая позволит лучше понимать дальнейшее описание.
Вся система строится вокруг базы знаний (далее буду использовать сокращение БЗ). Знания в ней представлены в виде [семантической сети](https://ru.wikipedia.org/wiki/%D0%A1%D0%B5%D0%BC%D0%B0%D0%BD%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%81%D0%B5%D1%82%D1%8C) (более подробно про язык представления знаний можно почитать в [статье](http://conf.ostis.net/images/1/15/04._%D0%93%D0%BE%D0%BB%D0%B5%D0%BD%D0%BA%D0%BE%D0%B2_%D0%92.%D0%92.%2C_%D0%93%D1%83%D0%BB%D1%8F%D0%BA%D0%B8%D0%BD%D0%B0_%D0%9D.%D0%90._-_%D0%A1%D0%A1%D0%9F.pdf)). Я же приведу пару простых примеров. Которые просто позволят понимать дальнейший текст и изображения. В своих примерах я буду использовать два языка: графический — [SCg](https://drive.google.com/file/d/0B9nRd_434bwfNXNjS0t3dDc0Qnc/view?usp=sharing) и текстовый — [SCs](http://ostis-dev.github.io/sc-machine/other/scs/)
Для начала надо усвоить как задается отношение **«is a»**. Все достаточно просто. На изображении слева указан факт, что яблоко и ананас — это фрукты. Для этого мы просто создали узел обозначающий множество всех яблок — **apple** и добавили входящую дугу принадлежности из узла обозначающего множество всех фруктов — **fruit**. Тоже самое мы сделали и с ананасом.
В принципе на основе отношения **«is a»** строится все хранение в БЗ, включая и любые другие отношения. Для примера рассмотрим как в БЗ указывается изображение объекта или класса объектов. На данной картинке видно, что мы ввели множество обозначающее все экземпляры отношения **«быть изображением чего-то»** и в него добавляем все дуги обозначающие бинарные связки.
Теперь немного поговорим про то как происходит обработка хранимых в знаний. Для этого используется [агентно-ориентированный подход](https://ru.wikipedia.org/wiki/%D0%90%D0%B3%D0%B5%D0%BD%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D1%8B%D0%B9_%D0%BF%D0%BE%D0%B4%D1%85%D0%BE%D0%B4). Важный принцип, что агенты могут взаимодействовать между собой только через БЗ (меняя ее состояние). Сразу приведу ссылку на [документацию](http://ostis-dev.github.io/sc-machine/cpp/kpm/) по разработке агентов на языке C++. Взаимодействие между агентами реализовано с помощью специализированного языка команд-запросов (документация по нему в процессе разработки). Здесь я приведу один пример запроса (читайте данное изображение по примеру двух прошлых, используя **«is a»** отношение):
Это самый простой пример запроса, погоды в Минске. На данном изображении можно увидеть узел, который обозначет экземпляр запроса и входит во множество **command** и **command\_find\_weather**, где последний определяет тип запроса. По сути запрос — это множество элементами которого являются его аргументы.
Каждый агент в БЗ имеет свою спецификацию, где указан ожидаемый результат, условие инициирования и другие свойства агента. Одним из таких свойств является — событие при котором он инициируется. В данный момент доступны следующие виды таких событий: удаление(создание) входящей(выходящей) дуги, удаление элемента, изменение содержимого ссылки. Другими словами мы подписываем агента на событие в базе знаний и когда оно происходит агент инициируется. Для команд таким событием является добавление экземпляра запроса во множество **command\_initiated**. Когда это происходит все агенты подписанные на это событие инициируются. После этого лишь агенты, которые умеют обрабатывать данный тип запроса, продолжают работать.
На выходе каждый агент генерирует результат, который связан с экземпляром запроса, с помощью отношения **nrel\_result**.
Таким образом получается нечто типа форума, где разные агенты могут общаться между собой используя специализированный язык. При этом никто из них при формировании запроса, даже не знает будет на него ответ или нет и кто его даст. Это позволяет использовать различные реализации агентов и добавлять их в систему на ходу не прекращая ее работу.
Описание получилось достаточно большим хотя я старался его сделать минимальным и понятным. На любые вопросы по нему я готов ответить подробно в комментариях или же при необходимости сделать отдельную статью с детальным описанием и примерами. Но мы двигаемся дальше.
#### Доработки ядра
К моменту когда я начал работу над «Джарвисом» наше [ядро](https://github.com/ostis-dev/sc-machine) находилось в достаточно стабильном и рабочем состоянии, но разработка агентов была возможна лишь с использованием языка Си, в репозитории еще остались [примеры таких агентов](https://github.com/ostis-dev/sc-machine/tree/master/sc-kpm/search/agents).
**Первое** что необходимо было сделать — это упростить их разработку. Поэтому было решено написать С++ библиотеку, которая брала на себя множество рутинных задач. На тот момент я работал разработчиком игр на Unreal Engine 4 и поэтому решил, что удобно было бы использовать генератор кода и реализовал такую [возможность](http://ostis-dev.github.io/sc-machine/cpp/cpp-meta/).
Теперь описание агента начало сводиться к:
```
class AMyAgent : public ScAgentAction
{
SC_CLASS(Agent, CmdClass("command_my"))
SC_GENERATED_BODY()
};
```
Реализация этого агента заключалась в реализации одной функции:
```
SC_AGENT_ACTION_IMPLEMENTATION(AMyAgent)
{
// implement agent logic there
return SC_RESULT_OK;
}
```
Более детально о реализации агентов можно почитать в [документации](http://ostis-dev.github.io/sc-machine/cpp/kpm/#scagent). Примеры реализации агентов с новой библиотекой можно посмотреть [тут](https://github.com/ostis-dev/sc-machine/tree/77ad13259336424131ab74d22a52ec1188ab9fd4/sc-kpm/nl) (они временно переехали в мой закрытый репозиторий, но скоро они снова будут открыты).
**Второе** что необходимо было сделать — это многопоточный запуск агентов. Ранее для обработки событий в БЗ использовался один поток, который последовательно запускал агенты из очереди. Сейчас используются все доступные ядра в системе. Сразу скажу, что было очень сложно обеспечить асинхронный доступ к БЗ от множества агентов в разных потоках. Описание этого механизма наверное — это отдельная статья, которую я могу написать, если возникнет такая потребность. Тут я остановлюсь лишь на паре нюансов:
* работа с элементами, которые хранятся в памяти реализована с помощью [lock-free](https://ru.wikipedia.org/wiki/%D0%9D%D0%B5%D0%B1%D0%BB%D0%BE%D0%BA%D0%B8%D1%80%D1%83%D1%8E%D1%89%D0%B0%D1%8F_%D1%81%D0%B8%D0%BD%D1%85%D1%80%D0%BE%D0%BD%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F) подхода. Я не силен в классификации таких подходов, но думаю что у меня реализация **«Без блокировок»**, когда хотя бы один агент (чаще их больше одного или почти все) продвигается вперед;
* на текущий момент, агенты не могут гарантировать, что данные с которыми они собираются работать не будут удалены другим агентом. В будущем планируется ввести блокировки, которые будут заставлять хранить объект до тех пор пока он необходим агенту и в нужном контексте (пока идет обсуждение необходимых видов блокировок). Для текущей реализации агентов это не страшно, так как если элемент был удален, то агент вернет ошибку при попытке сделать что-то в памяти с этим элементом.
**Третье** на что я натолкнулся, что большинство сервисов Amazon, Google и т.д. имеют готовые API на разных языках, но не для С++. Поэтому было решено сделать возможность запускать Python код внутри С++. [Реализовано](https://github.com/ostis-dev/sc-machine/tree/master/sc-memory/cpp/python) это все с помощью Boost-Python (используя Python 3, вот тут я уже могу много кому помочь с этим).
Помимо описанных вещей была написана документация (ссылки давались уже). Вся библиотека с++ покрыта unit-тестами. На все это ушло около года и все это делалось параллельно с остальными вещами и делается до сих пор.
#### Визуальная модель
Визуальная модель разрабатывалась для отработки концепции и отладки базовых вещей. Видео небольшого Proof of concept в этой модели:
Эта модель помогла отладить систему очень здорово, так как ее можно было собрать и дать поиграться другим людям. Вдаваться в подробности ее реализации не буду, если кому будет интересно — отвечу в комментариях. На текущий момент данная штука не развивается, все перешло к реальным устройствам.
#### Голосовой интерфейс
В раннем прототипе я реализовал голосовой ввод с помощью Android API, а получаемый текст разбирал с помощью [api.ai](http://api.ai), который возвращал мне класс запроса для инициирования и его параметры. В таком или немного измененном виде он существует и сейчас. Но разговор мы поведем в другом русле — как этот механизм реализован с помощью агентов.
Если вспомнить про сравнение общения между агентами с форумом, то можно описать этот механизм следующим логом (где A<имя\_агента> — это агенты, решающие разные задачи; user — это пользователь):
```
user: яблоко это фрукт
ADialogueProcessMessage: сделайте анализ входного текста "яблоко это фрукт"
AApiAiParseUserTextAgent: что за объект "яблоко"?
AResolveAddr: адрес элемента "яблоко" - 3452
AApiAiParseUserTextAgent: что за объект "фрукт"?
AResolveAddr: адрес элемента "фрукт" - 3443
AApiAiParseUserTextAgent: нужно добавить элемент 3452 во множество 3443
AAddIntoSet: сделано
ADialogueProcessMessageAgent: сгенерируйте текст на языке пользователя для указанного запроса
AGenCmdTextResult: сгенерируйте текст на русском языке по шаблону "..."
AGenText: готово - "Теперь буду знать"
```
Вот что происходит под капотом, при решении такой простой задачи. Но это еще не все, далее нам необходимо ввести еще два понятия. Кроме агентов, которые я уже описал (реагируют на изменение БЗ и меняют ее состояние), есть еще два вида агентов:
* **эффекторные** — это агенты, которые на изменение в БЗ делают изменение во внешней среде. Другими словами отвечают за вывод информации: экран, манипулятор и т. д.
* **рецепторные** — это агенты, которые на изменения во внешней среде, делают изменения в БЗ. Отвечают за ввод информации: устройства ввода, датчики и т. д.
**Видео работы эффекторных агентов**
На видео можно увидеть, как лампа (куб) включается, когда узел, обозначающий её, добавляют во множество включенных устройств. И наоборот, когда её оттуда удаляют, то она выключается. Тоже самое происходит и с краном.
Когда агенты разобрали запрос пользователя и сформировали на него ответ на том же языке, то этот ответ добавляется в множество обозначающее диалог с ним (пользователем). В этот момент один из «эффекторных» агентов выводит этот ответ пользователю в виде строки. Вот пример работы на видео:
Отдельно, пользовательский интерфейс делает запрос на генерацию речи по тексту. Агент формирует ее в виде звукового файла (OGG) используя сервис ivona.
#### Что дальше?
Прошлый год был проведен за отладкой и новым функционалом ядра. Получен работающий прототип, который уже может решать интересные задачи. За прошлый год на разработку было потрачено около 750 часов свободного от основной работы времени.
У данного подхода есть потенциал:
* добавление нового функционала не затрагивает уже работающий. К примеру, когда мне понадобилось сделать планировщик задач (для запуска задач в определенное время или периодически), то для этого понадобился лишь 1 агент, который всего лишь добавляет уже сформированный запрос во множество инициированных в указанное время. Получается что любой запрос, который доступен на языке запросов может быть запланирован. Например: "*«напомни позвонить жене»*"; *«выключи свет в 10»*; *«включи телевизор в 11.05»*; ...;
* в данной статье я не описывал, но существует поиск [по шаблонам](http://ostis-dev.github.io/sc-machine/cpp/templates/), на базе которого можно делать логический вывод (и уже делали [тестовые решатели задач](http://conf.ostis.net/images/6/69/%D0%97%D0%B0%D0%BB%D0%B8%D0%B2%D0%B0%D0%BA%D0%BE_%D0%A1.%D0%A1..2012%D1%81%D1%82-%D0%A1%D0%B5%D0%BC%D0%B0%D0%BD%D0%A2%D0%9A%D0%9F%D0%98%D0%A0%D0%97.pdf) по геометрии и физике);
* в качестве анализатора входного текста планируется использовать [Cloud Natural Language API](https://cloud.google.com/natural-language/), что позволит увеличить качестве языкового интерфейса;
На этом наверное я закончу свою первую статью, в которой постарался описать основные принципы и что было сделано по моей реализации «умного дома», «умного дворецкого» или «Джарвиса» (кому как удобно). Не питаю иллюзий, что материал получился хорошим, поэтому надеюсь на обратную связь. Спасибо всем прочитавшим. | https://habr.com/ru/post/328238/ | null | ru | null |
# LAMP +Nginx на VPS стабильно и без лишней головной боли
Задача — на минимальных ресурсах VPS развернуть хостинг нескольких не нагруженных сайтов. Сделать это быстро и удобно с минимальными проблемами в будущем и не падать на пиковых нагрузках.
##### Основные принципы:
1. ОС — Centos-6 86\_x64 потому что стабильно, удобно и легко обновляемо.
2. Никакого самосборного софта. А то как говорится «командой make && make install любой дистрибутив превращается в Slackware.»
Маленькое уточнение, на данный момент я использую тарифный план v256 у хостинг провайдера flynet.pro (256Мб оперативки) и не рассчитываю на большую нагрузку так что большая часть относится именно к такому количеству оперативной памяти, но в целом решения легко переносимы фактически на все тарифные планы разных хостинг-провайдеров.
И еще одно уточнение — хостинг делается «для себя». Тут недостаточно описаны моменты, которые стоит учитывать, если вы даете доступ к администрированию сайтов посторонним людям.
Поехали.
1. Проверяем обновления.
Установочный образ у хостинг провайдера может оказаться не особо свежим.
`[root@test ~]# yum update`
Есть что обновлять — обновляем. Нет — радуемся.
2. Подключаем репозитарий EPEL (http://fedoraproject.org/wiki/EPEL) из которого будем ставить недостающий софт.
`[root@test ~]# rpm -ihv download.fedora.redhat.com/pub/epel/6/x86_64/epel-release-6-5.noarch.rpm`
3. Ставим нужный нам софт
`[root@test ~]# yum install httpd mysql-server php vsftpd mc phpMyAdmin php-eaccelerator sysstat crontabs tmpwatch`
Кратко о софте:
httpd — Apache штатная версия для Centos-6 — 2.2.15
mysql-server — Mysql 5.1.52
php — PHP 5.3.2
vsftpd — довольно удобный FTP сервер vsftpd 2.2.2
mc — некоторые вещи все-таки удобнее делать в mc чем в командной строке.
phpMyAdmin — аналогично с mc. управлять mysql базами в phpMyAdmin всетаки удобнее.
php-eaccelerator — акселератор для PHP. Заметно увеличивает скорость выполнения скриптов и снижает нагрузку на процессор. Да и на память.
sysstat — на случай если нам захочется посмотреть как поживает система.
crontabs — для выполнения заданий по расписанию.
tmpwatch — утилита для удаления устаревших файлов.
На самом деле установится несколько больше пакетов, к тем пакетам что мы попросили установить добавится все необходимое для их функционирования.
В результате получается:
`Install 44 Package(s)
Upgrade 0 Package(s)
Total download size: 37 M
Installed size: 118 M`
4. Командой free смотрим, есть ли у нас своп и если нет, то создаем его и подключаем. Если есть – радуемся и пропускаем этот пункт.
Тут важный момент — активное использование свопа — очень плохо. Если идет активный свопинг — значит нужно что-то оптимизировать или урезать. Если оптимизировать и урезать не получается — придется переходить на более дорогой тарифный план. Еще стоит учитывать что хостинг-провайдер может обидиться на слишком активное использование свопа.
Но совсем без свопа тоже не очень хорошо — oom killer — штука страшная. Может ненароком убить mysqld и вместо того чтобы просто тормозить ваши сайты будут совсем лежать.
Замечание — делать своп больше имеющейся оперативной памяти не нужно. Пользы от него не будет, а место он скушает.
Создаем своп следующим образом:
`[root@test /]# dd if=/dev/zero of=/swap bs=1M count=256
[root@test /]# mkswap /swap`
подключаем
`[root@test /]# swapon /swap`
ну и для того чтобы оно подключалось автоматически записываем эту команду в /etc/rc.local
Проверить наличие и занятость свопа можно командами top или free
5. Включаем и запускаем демонов
`[root@test /]# chkconfig httpd on
[root@test /]# chkconfig mysqld on
[root@test /]# chkconfig crond on
[root@test /]# service httpd restart
[root@test /]# service mysqld restart
[root@test /]# service crond restart`
6. Создаем пользователей для сайтов. Я предпочитаю чтобы имя пользователя было аналогично домену сайта.
`[root@test /]# adduser testsite.ru
[root@test /]# adduser mysite.ru
[root@test /]# adduser cfg.testsite.ru`
Далее создаем дополнительные в каталогах пользователей. html (в котором будет основное содержимое сайтов) и log в которую будут писаться логи для этого сайта и выставляем права. Права ставим: пользователю – полный доступ, группе apache чтение и листинг директорий, остальным – фикус.
Права можно выставить и руками, а можно и воспользоваться небольшим скриптиком:
`cd /home
for dir in `ls -1 `; do
mkdir /home/$dir/log
mkdir /home/$dir/html
chown -R $dir:apache $dir
chmod ug+rX $dir
done;`
7. Настраиваем веб сервер. Правим /etc/httpd/conf/httpd.conf
Из действительно нуждающегося в изменении — настраиваем модуль prefork так чтобы он изначально кушал поменьше памяти и ограничивал свои аппетиты.
Дело в том что Apache изначально настроен на запуск до 256 своих рабочих процессов, при том что один рабочий процесс запросто занимает 20-40Мб (256\*20=5Гб) это запросто может привести к проблемам, особенно на скромных VPS где есть всего 256Мб оперативки.
Поэтому мы ограничиваем их количество разумными цифрами изсходя из доступной нам оперативной памяти. Например 5 процессов апача при среднем размере 30Мб займут около 150Мб — что уже терпимо.
Было:
`StartServers 8
MinSpareServers 5
MaxSpareServers 20
ServerLimit 256
MaxClients 256
MaxRequestsPerChild 4000`
Стало:
`StartServers 2
MinSpareServers 2
MaxSpareServers 3
ServerLimit 5
MaxClients 5
MaxRequestsPerChild 1000`
Такая настройка не даст апачу расплодиться сверх меры и скушать всю оперативку. В зависимости от реальной нагрузки параметры, возможно, стоит пересмотреть.
Ну и раскомментируем строку
`NameVirtualHost *:80`
Для того чтобы на одном ip адресе иметь много сайтов.
Далее переходим в директорию /etc/httpd/conf.d/ и настраиваем наши сайты.
Там можно удалить welcome.conf который выключает индексы и выдает вместо нее страничку «Apache 2 Test Page».
Следует учесть, что конфиги виртуальных хостов в этой директории применяются по очереди в алфавитном порядке.
Для того чтобы пользователь зайдя по IP адресу на какой либо из наших сайтов не попал на совершенно другой (который будет первым по списку) в директорию conf.d стоит положить файл с именем например 000-default.conf и таким содержимым:
`ServerName localhost.local
DocumentRoot "/var/www/html"`
и положить в директорию /var/www/html/ файлик index.html с пожеланиями.
Далее для каждого из наших виртуальных хостов создаем конфиг файл по примерно такому шаблону:
`ServerName testsite.ru
ServerAlias www.testsite.ru
ServerAdmin webmaster@testsite.ru
ErrorLog /home/testsite.ru/log/error.log
CustomLog /home/testsite.ru/log/access.log combined
DocumentRoot /home/testsite.ru/html/
Order allow,deny
Allow from all`
В эти же файлы, по вкусу можно добавить индивидуальные настройки каких либо модулей.
Перезапускаем apache и смотрим все ли работает.
`[root@test /]# service httpd restart`
apache должен запуститься нормально. В директориях log сайтов должно создаться по 2 файла логов.
При обращении к серверу по IP адресу должен выводиться файл который вы положили в /var/www/html/, а при обращениях по именам сайтов вы должны видеть содержимое директории html (пустое скорее всего) и записи в файле access.log соответствующего сайта.
8. Настраиваем mysql. Первым делом удаляем базу test и задаем пароль пользователя root на mysql
`[root@test /]# mysql`
`mysql> DROP DATABASE test;
mysql> USE mysql;
mysql> UPDATE user SET Password=PASSWORD('MyMysqlPassword') WHERE user='root';
mysql> FLUSH PRIVILEGES;
mysql> quit`
С MySql проблема примерно такая же как с Apache — требовательность к оперативной памяти которая на VPS весьма дорога.
Для уменьшения объема используемой памяти sql сервером правим /etc/my.cnf следующим образом:
в секцию [mysqld] добавляем следующее:
`key_buffer = 16M
max_allowed_packet = 10M
table_cache = 400
sort_buffer_size = 1M
read_buffer_size = 4M
read_rnd_buffer_size = 2M
net_buffer_length = 20K
thread_stack = 640K
tmp_table_size = 10M
query_cache_limit = 1M
query_cache_size = 32M
skip-locking
skip-innodb
skip-networking`
и в конец файла добавляем эти строки:
`[mysqldump]
quick
max_allowed_packet = 16M
[mysql]
no-auto-rehash
[isamchk]
key_buffer = 8M
sort_buffer_size = 8M
[myisamchk]
key_buffer = 8M
sort_buffer_size = 8M
[mysqlhotcopy]
interactive-timeout`
перезапускаем mysqld чтобы убедиться что все нормально:
`[root@test ]# service mysqld restart`
Так же нужно заменить что опция «skip-networking» делает возможным обращение к серверу только с локальной машины через сокет. Если требуется сетевой доступ — эту опцию включать не нужно.
Такие настройки позволят минимизировать память используемую процессом mysql и нормально работать на незагруженном сайте. Но конечно же нужно смотреть на статистику работы mysql и в зависимости от потребностей увеличивать данные здесь лимиты.
Дальнейшее администрирование mysql удобнее производить через phpMyAdmin.
Теперь один нюанс — по умолчанию phpMyAdmin доступен по пути /phpMyAdmin на всех наших сайтах.
Чтобы этого не было создаем специализированный сайт для управления (например cfg.testsite.ru) и настраиваем его аналогично остальным.
Потом переносим все содержимое файла /etc/httpd/conf.d/phpMyAdmin.conf в конфиг этого сайта, а сам файл phpMyAdmin.conf удаляем или переносим куда-нибудь из дириктории conf.d.
После таких действий phpMyAdmin будет доступен по пути /phpMyAdmin/ только на специально выделенном сайте.
Ну и для того чтобы в него можно было войти в файле конфигурации сайта меняем
`Order Deny,Allow
Deny from All
Allow from 127.0.0.1
Allow from ::1`
Order Deny,Allow
Deny from All
Allow from 127.0.0.1
Allow from ::1
на
`Order Deny,Allow
Deny from All
Allow from 127.0.0.1
Allow from ваш.ип.адрес.
Allow from ::1`
Order Deny,Allow
Deny from All
Allow from 127.0.0.1
Allow from ваш.ип.адрес.
Allow from ::1
После этого phpMyAdmin будет доступен с вашего ip адреса.
Авторизуемся в нем как пользователь root с тем паролем что установили.
Чтобы создать пользователя идем в «Привелегии» — «Добавить нового пользователя»
имя пользователя — произвольное, я предпочитаю использовать имя сайта чтобы уменьшить путаницу.
Хост — локальный (мы же делаем его для сайта который будет крутиться тут же?)
Пароль — генерировать. (не забываем копировать пароль)
Ставим галочку — «Создать базу данных с именем пользователя в названии и предоставить на нее полные привилегии»
Применяем.
В итоге получаем пользователя с выбранными вами именем, паролем и базой данных с аналогичным названием.
9. Часто заливать файлы на хостинг удобнее через фтп. для этого мы и установили vsftpd
редактируем его конфиг /etc/vsftpd/vsftpd.conf
выключаем анонимный логин, меняем
`anonymous_enable=YES`
на
`anonymous_enable=NO`
и раскоментируем
`chroot_local_user=YES`
Теперь чтобы можно было зайти на фтп определенного сайта соответствующему пользователю нужно задать пароль
`[root@test /]# passwd testsite.ru`
И не забываем что по умолчанию этот пользователь с установленным паролем может зайти по SSH. Чтобы отключить эту возможность проще всего сменить шелл пользователя
`[root@test etc]# chsh -s /sbin/nologin testsite.ru`
Включаем и запускаем vsftpd
`[root@test /]# chkconfig vsftpd on
[root@test /]# service vsftpd start`
Проверяем, все ли работает.
Ну и на последок совсем простенький «оперативный бекап». По принципу «бекапов много не бывает».
Лучше бы использовать что-то более правильное, но плохой бекап все-таки лучше полного отсутствия.
Такой бекап может служить неплохим дополнением полному бекапу виртуальной машины у хостинг-провайдера. Но, ни в коем случае не его заменой.
Бекапим содержимое сайтов и баз данных, а так же настройки в каталоге /etc/.
Создаем директорию /backup/ и ставим на нее права «700»
`[root@test /]# mkdir /backup/
[root@test /]# chmod 700 /backup/`
В директории /etc/cron.daily/ создаем файл backup.sh и так же ставим на него права «700».
`[root@test /]# touch /etc/cron.daily/backup.sh
[root@test /]# chmod 700 /etc/cron.daily/backup.sh`
Файл имеет следующее содержание:
`#!/bin/sh
#Бекапим все директории html наших сайтов
tar -cf - /home/*/html/ | gzip > /backup/sites-`date +%Y-%m-%d`.tar.gz
#Бекапим все базы даных в один файл
mysqldump -u root --password=MyMysqlPassword --all-databases | gzip > /backup/mysql-`date +%Y-%m-%d`.dump.gz
#Бекапим конфигурационные файлы
tar -cf - /etc/ | gzip > /backup/etc-`date +%Y-%m-%d`.tar.gz
#Удаляем файлы бекапов старше 7 дней
tmpwatch -t -m 7d /backup/`
В принципе вместо бекапа всего в одну кучу может оказаться лучше бекапить все по отдельности, но тогда возникает возможность забыть настроить бекап чего-либо и пожалеть об этом когда он понадобится.
Ну или вариант бекапа «по раздельности» требующий чтобы имя пользователя сайта и имя базы данных совпадали:
`#!/bin/sh
for dir in `ls -1 /home/ `; do
tar -cf - /home/$dir/html/ | gzip > /backup/sites-$dir-`date +%Y-%m-%d`.tar.gz
mysqldump -u root --password=MyMysqlPassword $dir | gzip > /backup/mysql-$dir-`date +%Y-%m-%d`.dump.gz
done;
#Бекапим конфигурационные файлы
tar -cf - /etc/ | gzip > /backup/etc-`date +%Y-%m-%d`.tar.gz
#Удаляем файлы бекапов старше 7 дней
tmpwatch -t -m 7d /backup/`
10. Обновления.
Не забываем время от времени обновлять систему.
`[root@test ~]# yum update`
Благодаря политике RHEL/Centos в отношении к софту версии софта после обновления останутся теми же и нечаяно положить сервер из-за того что в конфиге что-то поменялось шансов очень мало.
Правда в этом подходе есть и минус — через три года в Centos-6 будут теже версии софта что и сейчас. Но если наша цель стабильность — это нам подходит.
11. Тестирование.
Очень рекомендую провести после настройки тестирование сайта.
Первый пункт тестирования — перезагрузка сервера и проверка того что все нужные демоны стартанули и все работает как ожидалось. Я бы вообще порекомендовал не гнаться за циферками аптайма а перезагружаться после установки или изменения версий любого серверного софта стартующего автоматом.
Лучше узнать, что Apache не стартует в автозапуске после собственноручного планового ребута, чем узнать, что у хостера были проблемы и в следствии ребута вашей виртуалки сайты на ней уже полдня как не работают.
Далее — нагрузочное тестирование при помощи утилиты ab (Apache HTTP server benchmarking tool).
В данном тестировании нас интересует не столько количество попугаев сколько поведение сервера под нагрузкой. На нем не должно быть умирающих процессов и активного свопинга.
Для тестирования нам потребуется сайт размещенный на этом сервере в рабочем состоянии. И «типичная» страница с этого сайта. Ну или можно использовать не типичную, а наиболее тяжелую.
Я для примера провожу тестирование на свежеустановленном Drupal 7.9
Из всего многообразия командной строки ab нам потребуются всего 2 параметра -n — количество http запросов -c — количество одновременных запросов (потоков).
Во время выполнения теста во второй ssh сессии с помощью top наблюдаем за тем как поживает сервер.
100 запросов в 2 потока.
`[root@test ~]# ab -n 100 -c 2 testsite.ru`
Из вывода ab мне особо интересны «Requests per second», «Time per request» и «Failed requests» которые дают общее представление о производительности сервера.
`Failed requests: 0
Requests per second: 6.20 [#/sec] (mean)
Time per request: 322.788 [ms] (mean)`
Видно, что сервер обрабатывает 6 с копейками запросов в секунду и тратит 322 миллисекунды на генерацию одной страницы.
Из вывода top интересно распределение памяти и загрузка процессора.
`Tasks: 62 total, 3 running, 59 sleeping, 0 stopped, 0 zombie
Cpu(s): 19.9%us, 5.3%sy, 0.0%ni, 0.0%id, 0.0%wa, 0.0%hi, 0.4%si, 74.5%st
Mem: 244856k total, 151624k used, 93232k free, 3752k buffers
Swap: 262136k total, 0k used, 262136k free, 76604k cached`
Swap: 0k used — ооочень хорошо.
93232k free + 76604k cached — фактически 170 мегабайт свободной памяти.
100 запросов 5 потоков.
`[root@test ~]# ab -n 100 -c 5 testsite.ru`
`Failed requests: 0
Requests per second: 6.21 [#/sec] (mean)
Time per request: 804.513 [ms] (mean)
Tasks: 63 total, 5 running, 58 sleeping, 0 stopped, 0 zombie
Cpu(s): 17.5%us, 6.2%sy, 0.0%ni, 0.0%id, 0.0%wa, 0.0%hi, 0.0%si, 76.3%st
Mem: 244856k total, 159756k used, 85100k free, 3812k buffers
Swap: 262136k total, 0k used, 262136k free, 76660k cached`
Количество запросов в секунду осталось тем же а вот время генерации выросло больше чем в 2 раза — уперлись в процессор.
Ну и наконец, хабраэффект или что-то близкое :-)
`[root@test ~]# ab -n 500 -c 50 testsite.ru`
`Failed requests: 0
Requests per second: 6.45 [#/sec] (mean)
Time per request: 7749.972 [ms] (mean)
Tasks: 63 total, 6 running, 57 sleeping, 0 stopped, 0 zombie
Cpu(s): 19.1%us, 5.3%sy, 0.0%ni, 0.0%id, 0.0%wa, 0.0%hi, 0.0%si, 75.6%st
Mem: 244856k total, 162740k used, 82116k free, 3884k buffers
Swap: 262136k total, 0k used, 262136k free, 76672k cached`
Опять-таки количество запросов в секунду относительно стабильно, а вот время генерации стало уже совсем грустным. Но в тоже время Failed requests — нулевое. Что значит что хоть и медленно, но все работает.
Ну и по поводу памяти — на данный момент Swap: 0k used, 82116k free, 76672k cached — потребление практически не выросло и в принципе можно увеличить некоторые лимиты, но учитывая отсутствие у меня наполнения сайта на данный момент, думаю, этого делать не стоит. А вот позже стоит прогнать тесты на заполненом сайте и в зависимости от результатов уже откорректировать настройки.
12. Установка nginx в качестве фронтенда.
Почему это нужно.
Основная проблема кроется в том как apache обрабатывает входящие соединение. На каждое входящее соединение создается новый процесс или берется один из запущенных и соединение передается ему на обслуживание. До тех пор пока соединение не закрыто этот процесс занимается только им.
В принципе все выглядит хорошо пока у нас много оперативки и/или очень быстрые клиенты (ab запущенный с локалхоста один из таких вариантов), но все становится куда грустнее если клиент сидит на медленном канале или просто никуда не спешит. В таком случае он на время забора реквеста фактически блокирует один из процессов который на это время выключается из работы сервера.
Таким образом в теории имея сервер на 100мбит канале и одного настойчивого клиента на диалапе с регетом мы можем получить нечто-вроде DOS — клиент в несколько потоков заблокирует фактически все наши процессы apache которых у нас в виду малого количества оперативной памяти весьма не много.
Решается данная проблема установкой какого-либо легкого http сервера в виде фронтенда. При наличии фронтенда все входящие соединения принимаются им, затем запрос передается apache и быстро получается ответ тем самым освобождая процесс apache для новых запросов. Фронтенд же не спеша и не растрачивая лишних ресурсов отдает полученный ответ уже запросившему ему клиенту.
Дополнительным бонусом фронтенд может сам отдавать статическое содержимое — например картинки, css и т.п. снимая нагрузку с тяжелого апача.
`[root@test ~]# rpm -ihv centos.alt.ru/pub/repository/centos/6/x86_64/centalt-release-6-1.noarch.rpm
[root@test ~]# yum install mod_realip2 nginx-stable`
Для того чтобы apache и наши скрипты в запросах видели реальный ip адрес клиента а не адрес фронтенда у нас будет установлен mod\_realip2.
редактируем /etc/httpd/conf.d/mod\_realip2.conf, раскоментируем
`RealIP On
RealIPProxy 127.0.0.1
RealIPHeader X-Real-IP`
редактируем httpd.conf и файлы в /etc/httpd/conf.d/
меняем все указания на порт 80 на порт 8080
Всего менять нужно три директивы:
`Listen 127.0.0.1:8080
NameVirtualHost *:8080`
редактируем /etc/nginx/nginx.conf
`user apache;
worker_processes 2;`
Я использую запуск nginx из под пользователя apache поскольку изначально мы давали все права с расчетом именно на него.
Так же не лишним будет закомментировать директиву access\_log в nginx.conf чтобы избежать двойного ведения лога.
error\_log лучше не трогать — ошибки у апача и nginx все-таки разные.
В секции server правим директиву listen и ставим:
`listen 80 default`
меняем:
`location / {
root /usr/share/nginx/html;
index index.html index.htm;
}`
на
`location / {
proxy_pass 127.0.0.1:8080/;
}`
В директории /etc/nginx/conf.d/ создаем файл proxy.conf со следующим содержанием
`proxy_redirect off;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
client_max_body_size 10m;
client_body_buffer_size 128k;
proxy_connect_timeout 90;
proxy_send_timeout 90;
proxy_read_timeout 90;
proxy_buffer_size 4k;
proxy_buffers 4 32k;
proxy_busy_buffers_size 64k;
proxy_temp_file_write_size 64k;`
перезапускаем apache и nginx
`service httpd restart
service nginx restart`
и проверяем все ли работает.
В целом все. Теперь nginx стоит фронтендом, принимает все входящие соединения и проксирует их апачу который их обрабатывает и быстро передает ответ обратно в nginx освобождая процесс для новых запросов.
Следующим шагом по увеличению быстродействия и снижения потребляемых ресурсов будет отдача статического содержимого напрямую через nginx.
Для этого придется в дополнение к виртуальным хостам apache завести виртуальные хосты nginx и указать что раздавать.
Для этого в каталоге /etc/nginx/conf.d/ создаем файл с именем нашего сайта и расширением .conf со следующим содержимым:
`server {
listen 80;
server_name testsite.ru www.testsite.ru;
location / {
proxy_pass 127.0.0.1:8080/;
}
location ~ /\.ht {
deny all;
}
location /sites/default/files {
root /home/testsite.ru/html;
access_log /home/testsite.ru/log/access_static.log combined;
}
}`
В этом примере для сайта на CMS Drupal статическое содержимое каталога /sites/default/files раздается через nginx, а за всем остальным мы уже идем к апачу.
Еще один варинт — заменить директиву location на:
`location ~ \.(jpg|gif|png|css|js|ico)$ {
root /home/testsite.ru/html;
access_log /home/testsite.ru/log/access_static.log combined;
}`
В таком случае все файлы с соответствующими расширениями будут отдаваться nginx'ом. Но в данном варианте есть маленький минус — nginx не умеет работать с файлами .htaccess поэтому если у вас там есть какое либо содержимое, закрытое от просмотра .htaccess'ом — от использования такого варианта стоит воздержаться.
Еще стоит заметить, что в данной ситуации мы получаем два лога на один сайт. Отдельно лог запросов, по которым отработал апач и отдельно лог содержимого отданного nginx.
Как вариант — перенести директиву access\_log из секции location в секцию server и отключить access\_log в виртуальном хосте апача. В таком случае лог будет вести только nginx.
Но для посмотреть «как же это работает» двойной лог может оказаться интересным — по ним сразу видно какая часть нагрузки на кого приходится.
Для проведения дальнейшей оптимизации стоит читать уже мануалы по оптимизации конкретных компонентов и делать ее с оглядкой на сложившуюся ситуацию.
**UPD:** Исправленно несколько опечаток
**UPD:** Исправлено подключение swap, спасибо [AngryAnonymous](https://habrahabr.ru/users/angryanonymous/)
**UPD:** Добавленно описание установки и настройки nginx, спасибо [masterbo](https://habrahabr.ru/users/masterbo/) за пинок в правильную сторону.
Еще вариант бекап скрипта от [odmin4eg](https://habrahabr.ru/users/odmin4eg/): [habrahabr.ru/blogs/s\_admin/132302/#comment\_4391784](http://habrahabr.ru/blogs/s_admin/132302/#comment_4391784)
Жду критики. | https://habr.com/ru/post/132302/ | null | ru | null |
# Использование handle и intrusive reference counter-ов в многопоточных средах в языке C
Доступ к одим и тем же данным в нескольких потоках считается плохой практикой, но во многих случаях это неизбежно, и это не тот вопрос, который обсуждается здесь. Вопрос который здесь обсуждается, это как организовать такой доступ наиболее безопасным способом. Также тут не обсуждаются атомарные операции, которые тут упоминаются: разные компиляторы предлагают различные средства для таких операций.
В многопоточной среде при использовании объекта или структуры данных, один из главных вопросов, помимо прочего, это гарантия того, что объект к которому производится доступ все еще жив и память, выделенная для структуры не освобождена.
Это может быть сделано несколькими способами, но мы будем говорить только о двух из них: хэндлы (handles) и встроенные счётчики ссылок (intrusive reference counters).
Хэндлы — это небольшие структуры, которые содержат указатель на объект данных и вспомогательные данные, чтобы гарантировать, что объект еще жив. Как правило для работы с хэндлами пишутся две функции: lock\_handle и unlock\_handle (имена выбраны произвольно, чтобы показать функциональность). Lock\_handle проверяет «живость» объекта, увеличивает атомарный счетчик ссылок и возвращает указатель на объект данных, если он ещё доступен. Если нет, то функция возвращает NULL, или с помощью другого способа даёт знать, что объект больше не доступен. Соответственно своему названию, unlock\_handle атомарно уменьшает счетчик ссылок и как только он достигает значения 0, удаляет объект.
Встроенные счетчики ссылок — это атомарные числовые переменные внутри объекта данных, которые считают количество ссылок в программе на указанный объект данных. Как только счетчик ссылок достигает значения 0, объект удаляется.
Теперь давайте взглянем на преимущества и распространенные ошибки обеих стратегий и определим, какую из них лучше использовать в конкретных случаях. Сперва давайте разберемся с встроенными счетчиками ссылок.
##### Встроенные счетчики ссылок
Встроенные счетчики ссылок, как понятно из названия, должны быть встроены в структуру данных: это атомарное целое число. В простой структуре, назовем ее data\_packet\_s, подобная модификация может выглядеть так:
```
struct data_packet_s {
void *data_buffer;
size_t data_buffer_size;
};
```
=>
```
struct data_packet_s {
void *data_buffer;
size_t data_buffer_size;
volatile int reference_count;
};
```
Именно это является главным недостатком этого подхода: он нуждается в модификации структуры данных, поэтому использовать его можно только для таких структур, которые мы можем изменить. Мы не можем использовать его с произвольным типом данных или структурами, например, библиотечными.
Любопытно, но это же факт является и преимуществом. Преимущество состоит в том, что нам не нужны никакие дополнительные структуры и дополнительное выделение памяти для подобных структур.
Еще один недостаток, или, скорее, специфика этого подхода заключается в следующем: доступность объекта должна быть гарантирована, когда происходит приращение счетчика ссылок. Другими словами, мы не можем просто хранить указатель на объект и дожидаться момента, когда мы хотим получить к нему доступ, и затем просто увеличить счетчик ссылок и далее работать с объектом, поскольку между моментом когда мы сохранили указатель и моментом когда мы начинаем использовать объект он может быть уничтожен, при этом уничтожается и счётчик ссылок. Давайте продемонстрируем простой случай такого события, используя простой условный язык.
В указанном случае, чтобы обеспечить целостность объекта, придется увеличить количество ссылок в потоке 1 и передать полученную ссылку в собственность потоку 2 (уменьшать reference\_count будет поток 2 после того как объект больше не нужен). Другими словами, эта схема может работать очень хорошо, если необходимо обработать объект в другом потоке, и забыть о нем. Это может быть продемонстрировано с помощью следующей иллюстрации:
Такая схема может быть использована любым количеством потоков при условии, что каждый поток, который увеличивает счетчик ссылок, уже владеет по крайней мере одним экземпляром-ссылкой (либо увеличил количество ссылок и не передал собственность, либо получил экземпляр-ссылку в собственность от другого потока). Таким образом, в последнем случае поток 1 может увеличить счетчик ссылок несколько раз (по одному для каждого потока) и лишь после этого он может запустить несколько потоков (столько, на сколько был увеличен счетчик ссылок.
Тут становится виден и второй недостаток: мы увеличивать и уменьшаем счетчик ссылок в разных потоках, что часто может приводить к различным ошибкам, начиная от утечек памяти когда ссылка не освобождается, заканчивая двойным освобождением ссылки и соответственно ложным освобождением объекта, что ведёт к его удалению во время того как он ещё используется в другом потоке или потоках.
Эта схема реализует так называемый «shared ownership», когда потоки совместно владеют объектом, и нить, уменьшающая счетчик ссылок до нуля, будет удалять объект.
И если вы хотите сохранить указатель на объект в одном из потоков, и использовать его при необходимости вы увидите, что память выделенная вашей программой будет расти с каждым хранящимся объектом, потому что поток никогда не освободит ссылку на объект, «живость» которого он хочет гарантировать.
Другая возможная ошибка в таком подходе это обращение к косвенно переданным объектам, то есть объектам, которые передаются по указателю, содержащемуся в одном из других, прямо или косвенно переданных объектов, которые ссылаются, но не владеют объектом. Все такие объекты должны быть известны, при этом должен быть обеспечен безопасный доступ ко всем подобным объектам, если они используются наряду с основным.
Итак, давайте просуммируем недостатки и преимущества встроенных счетчиков ссылок:
Недостатки:
* Встроенные счётчики требуют изменения структур данных
* Ссылка должна оставаться залоченной пока есть вероятность что объект будет использован
* Собственность ссылок передаётся между потоками
* Необходимо внимательное отношение к косвенно переданным объектам
Преимущества:
* Не требуются дополнительные структуры и операции с памятью
##### Хэндлы
Хэндлы — это легкие структуры, которые передаются по значению, они ссылаются на объект, управляют ссылками и обеспечивают целостность объекта.
Очевидно, что хэндлы, которые ссылаются на один и тот же объект, будут иметь указатель на один счетчик ссылок. Как правило, это означает, что счетчик ссылок должен быть выделен на куче динамически. Простейшая структура хэндла, которая первой приходит на ум, может выглядеть так:
```
struct handle_s {
volatile int *reference_count;
void *object;
};
```
Где reference\_count выделяется при создании первого хэндла на данный объект.
Первый недостаток такого подхода уже очевиден. Мы должны управлять еще одной дополнительной структурой, выделять еще одну область памяти для счетчика ссылок. Но это окупается, если вы хотите использовать подсчет ссылок со структурами, к которым вы не имеете доступа.
Типичное применение такого хэндла будет следующим:
```
struct some_struct_s *object = lock_handle(hdata);
if(object) {
use(object);
release_handle(hdata);
};
```
Давайте посмотрим, что происходит, когда последняя ссылка на объект удалена. Прежде всего, мы, очевидно, хотим, чтобы удалился управляемый объект. Если объект является простым куском выделенной памяти, мы просто хотим, чтобы память, используемая объектом была освобождена. Но в большинстве случаев это не так. Как и в вышеупомянутом примере data\_packet\_s, где мы хотели бы освободить также и память data\_buffer. Если мы используем хэндл для только одного типа объектов, это не создаёт большой проблемы. Но если мы хотим, чтобы хэндл мог обрабатывать разыличные типы, это привносит ещё один вопрос: как правильно удалить управляемый объект?
Мы можем добавить в хэндл ещё одно поле: указатель на функцию, которая будет использоваться для уничтожения/освобождения управляемого объекта. Теперь хэндл выглядит следующим образом:
```
struct handle_s {
volatile int *reference_count;
void *object;
void (*destroy_object)(void*);
};
```
Теперь release\_handle не обязательно знать специфику объекта, чтобы удалить его, он просто будет использовать функцию, которую мы сохранили в хэндле, так что давайте вернёмся к тому, что происходит, когда последняя ссылка будет освобождена.
После этого мы хотели бы освободить память, которая содержит reference\_count. Но не тут то было: сделать это будет ужасной ошибкой. Если другие хэндлы на этот же объект до сих пор хранятся в других потоках, после освобождения памяти они будут ссылаться на reference\_count, который уже удален. А на следующей попытке получить доступ к объекту, мы будем иметь попытку обращения к освобожденной памяти.
Есть ли решение, которое позволило бы не допустить утечки памяти но при этом избежать обращений к освобождённой памяти счетчиков ссылок? Такой способ есть. Это пул объектов, который будут управлять освобожденными счетчиками. И вот тут-то и появляется проблема, найти которую может быть довольно непросто, и которая известна как «проблема ABA». Представьте себе, ситуацию, когда у вас есть хэндл на объект. Один из потоков удаляет объект. Затем конструируется другой объект, и для него создается управляющих хэндл. Что при этом произойдет?
Когда объект уничтожен, reference\_count связанный с данным объектом (назовем его object1) освобождается обратно в пул объектов со значением 0. Пока что всё идёт по плану. Но когда выделяется другой хэндл для нового объекта (назовем его object2), то reference\_count, который будет связан с этим объектом берется из пула объектов, при этом данный reference\_count устанавливается в 1. Теперь представьте, что поток хранящий хэндл на object1 пытается получить указатель. Это удастся, потому что reference\_count на который указывает данный хэндл уже не 0, хотя он и принадлежит теперь object2. Функция блокировки вернет неверный указатель, программа (если повезёт) потерпит крушение, или (если не повезёт) повредит содержимое памяти обращением к освобожденному участку.
Решение, разумеется, существует, иначе я бы не писал всё это.
Мы хотим сделать структуру handle\_s настолько легкой, насколько это возможно, чтобы иметь возможность передать ее по значению, а не по указателю, так что сделаем следующее: создадим две структуры, одна из которых будет «слабым» хэндлом, то есть не ограничивать и не проверять объект, которым она управляет, а другой будет «сильным» хэндлом, т.е. таким, который будет иметь жесткую связь с конкретным управляемым объектом и вернет NULL, если «слабый» хэндл связанный с ним больше не ссылается на тот же объект.
Давайте определим их так:
```
struct weak_handle_s {
volatile int version;
volatile int reference_count;
void object;
void (*destroy_object)(void*);
};
struct strong_handle_s {
struct weak_handle_s *handle;
int version;
};
```
Итак, как вы видите, теперь обе ручки имеют поле «version», и strong\_handle\_s уже не имеет указателя на объект, так как он теперь хранится в общем для объекта weak\_handle\_s.
Давайте посмотрим, как он защищает нас от проблемы ABA, показанной выше.
В strong\_handle\_s и weak\_handle\_s, которые ссылаются на один и тот же объект имеются поля «version», которые равны друг другу.
Всякий раз, когда ручка освобождается и weak\_handle\_s помещается обратно в пул объектов, мы будем увеличивать номер версии в weak\_handle\_s.
В следующий раз, если освобожденный в пул weak\_handle\_s переиспользуется для обработки другого объекта, он будет иметь номер версии, отличный от номера версии который был у объекта, который был освобожден. Теперь в функции lock\_handle, сравнивая поля версии в обоих, «слабом» и «сильном» хэндле, мы можем сказать, ссылается ли weak\_handle\_s по-прежнему на тот объект, указатель которого мы пытаемся получить из strong\_handle\_s, и вернуть NULL, если это не так.
Так что, как мы видим, хэндлы приносят некоторые довольно сложные проблемы, но он также имеет и свои плюсы: хэндл может быть сохранен и забыт, пока нам не понадобится управляемый им объект; хэндл не является встроенным, что означает, что мы можем использовать его практически с любыми типами данных.
Кроме того, передача хэндла не обязательно означает передачу права собственности на объект, так что он может быть использован вместо указателя в качестве безопасной ссылки на объекты везде, где они не являются собственностью ссылающегося объекта (в структурах данных и т.д.).
Таким образом хэндлами сложнее управлять. Но и возможности их гораздо мощнее.
Недостатки:
* Нуждается в дополнительной структуре и памяти.
* Занимает дополнительное время процессора
* Добавляет некоторые неочевидные проблемы
Преимущества:
* Позволяет сохранять хэндлы и иметь к ним доступ по мере необходимости.
* Не требует того, чтобы объект постоянно находился в собственности.
##### Выводы
Встроенный счетчик ссылок реализует общие сильные ссылки (strong reference), которые должны удерживать счетчик ссылок, пока объект не будет гарантированно невостребован. Пока все ссылки не будут разлочены, объект не будет удален. Если ссылка разблокирована в потоке, который имел в собственности лишь одну ссылку, этот поток уже больше не сможет гарантированно безопасно получить еще одну ссылку.
Хэндл реализует общую слабую ссылку (weak reference). Если объект жив, функция lock\_handle вернет указатель на запрашиваемый объект, и объект гарантированно не будет удален, пока хэндл не будет разлочен. Это безопасно для блокировки и разблокировки сколько угодно раз, так как хэндл является отдельным объектом, и гарантированно является валидным участком памяти. Соответствующие меры должны быть приняты, чтобы гарантировать, что разделяемая память счетчика ссылок не освобождается, когда объект достигает счетчика ссылок 0, и что повторно используемый счетчик ссылок не используется, чтобы проверить количество ссылок на уже освобожденные объекты. | https://habr.com/ru/post/266901/ | null | ru | null |
# Терминальный доступ к СУБД Caché – теперь и в браузере
С развитием веб-технологий в окне браузера появляется всё больше полезных сервисов, приложений, программ и даже игр. Пришло время и для [терминала](http://intersystems-ru.github.io/webterminal) СУБД Caché.
Под катом вы найдете описание всех прелестей приложения и историю его разработки.
#### Функциональность
Веб-терминалу под силу следующее:
* Выполнение произвольного кода и команд Caché Object Script, терминальных утилит и программ
* Удобный SQL-режим для быстрого доступа к базе данных
* Автодополнение ключевых слов Caché Object Script: классов и их методов, свойств, параметров, глобалов и переменных в текущем пространстве имён
* Мониторинг изменений в глобалах и файлах (подобно tail -f)
* История команд
* Подсветка синтаксиса Caché Object Script
* Определение сокращений
* Многострочное редактирование
* Настройка поведения и тем оформления приложения
Все вышеперечисленное работает на любом сервере Caché, где присутствует поддержка WebSockets. Достаточно лишь пройти по ссылке на веб-приложение и начать работу.
Подробное описание всех возможностей вы можете найти на [странице проекта](http://intersystems-ru.github.io/webterminal/#showcase).
#### Безопасность
Естественно, главной целью любого веб-приложения должна быть его безопасность. Поскольку общение с сервером происходит через открытый порт, последний нуждается в защите. Первое, что потребует от вас терминальный порт на вход при установке подключения – ключ произвольной длины. Сервер, получая неверный ключ, тут же разрывает соединение. Сейчас используется GUID, который каждый раз генерируется при обращении к основной CSP странице или в случае неудачного присоединения к открытому порту. То есть каждый раз, когда случилась попытка подключиться к сокету с неверным ключом, будет сгенерирован новый, и так раз за разом, что делает невозможным его подбор. То же самое происходит и при вызове CSP страницы – только теперь ключ отдается клиенту и используется для установки соединения с сокетом.
Проще говоря, остается только установить авторизацию на CSP страницу, тем самым не дав возможности получить ключ нежеланным посетителям открытого порта.
#### История программной реализации
Если посмотреть на терминал со стороны, кому-то может показаться что его механика достаточно проста. Поначалу мне тоже так казалось. Разбираясь в поведении такого рода приложений, наряду со знакомством с Caché возникало немало интересных моментов и трудностей, о которых пойдёт речь дальше. Основной задачей оставалось сделать терминал привычным для гиков и одновременно дружественным для простых пользователей, предоставив новые возможности и наконец-то приукрасить черно-белый графический интерфейс обычного терминала, ведь за окном уже 2013-й!
Дальше я буду описывать в основном расправы с граблями, на которые мне приходилось натыкаться и те самые, по которым походили все знакомые с вебом или с Caché дизайнеры-программисты. Может, представленные ниже способы и решения можно сделать еще интереснее, и если вы знаете как — будет очень любопытно услышать.
Начиная создавать новый программный продукт нужно продумать, а как же все это должно работать. Поскольку я только знакомился с Caché, поначалу посещали мысли, что терминал функционирует достаточно просто – нужно лишь выполнять команды на сервере и читать с него ответ. За фронтэнд я совсем не переживал, так как с ним мне приходилось ранее работать. Но только лишь я стал все больше углубляться в разработку, выяснилось, что нужно не просто выполнять команды, а и всяческие терминальные утилиты, настроить чтение информации с клиента (например, при обработке команды read), добиться потокового ввода/вывода и решить еще ряд всяких мелких задачек.
Немного поразмыслив с коллегами, стало абсолютно понятно, что для передачи данных будет использоваться протокол WebSocket – относительно новый, стабильный и надёжный способ передавать данные через веб. А на стороне клиента, понятное дело, все прелести HTML5. Это и CSS-анимации, и чистый-прозрачный JavaScript.
Первым делом сев за клиентскую часть, мне не хотелось использовать уже готовые решения или применять какие-либо фреймворки, так как терминал в идеале – это лёгкое приложение, которому не нужен продвинутый доступ к DOM’у как у JQuery и разные волшебные JavaScript-анимации. Нет, на самом деле анимации может и были бы кстати, но в формате всего лишь пачки CSS3-свойств, не более. Приложение обещало выйти лёгким, как для браузера, так и для пользователя.
С отображением информации я долго не возился – это моноширинный шрифт, лёгкая блочная верстка и знакомые стили. А вот над полем для ввода информации пришлось подумать: нужно было реализовать подсветку синтаксиса. Множество решений с плагинами было отброшено, поэтому последний, как казалось, вариант – это лаконичный editable div в HTML5. Но и там нашлись свои прелести – контент нужно было переводить с HTML в plaintext и наоборот, устанавливать и получать позицию каретки, копировать в буфер оригинальный, не разукрашенный текст – эти задачки решаются далеко не в несколько строчек. В придачу нужно же еще вставлять в текст свою, мигающую терминальную каретку и реализовать обычный системный Ctrl-C, Ctrl-V, Right click + Paste, Insert, …
Вариант реализации “подсветки и каретки” в поле для ввода нашелся очень хитрый и простой. По сути, нам нужно только лишь подсветить текст, ну и каретку вставить. Предположим, что текст у нас есть обычный и подсвеченный. Первый содержится в самом типичном textarea, а подсвеченный – в блоке точно такого же размера. Улавливаете? Вот так просто с использованием нескольких CSS-трюков делаем поле для ввода прозрачным с прозрачным шрифтом, под которым располагаем блок с подсвеченным текстом. В результате получаем видимое выделение текста и полную свободу его редактирования. Тут только Internet Explorer, как всегда, отличился – каретка в нём всё равно остается видимой, когда в других браузерах она прозрачна. Потому от обычной мигающей каретки терминала в нём пришлось отказаться – пускай остаётся со своей, родной.
Интересный момент так же возник с обработкой нажатия клавиш – нужно было подсветить вводимые данные, а значит, по нажатию обработать содержимое поля ввода. Да, но получить содержание этого поля именно в момент нажатия не получится (точнее получится, но без последнего «нажатого» знака) – DOM не успевает обновится до выполнения событий keydown, keypress, а по keyup обновлять видимую часть ввода совсем не интересно, хотя это тоже еще один выход. Второй выход – добавлять символ в строку вручную. Но последний сразу отпадает в случае Ctrl+V. Сделаем третьим методом – вызовем функцию-обработчик нажатия через 1мс после самого нажатия. Да, теперь мы получили ввод, но пропала возможность управлять передаваемым в обработчик event’ом, например, чтобы запретить действие клавиши по умолчанию. Выходом стало разбивка нажатия на два события – по нажатию сама обработка события и сочетаний, а через 1мс – обновление введённого текста.
Парсинг ввода, подсветка синтаксиса и вставка туда каретки в виде было реализовать несложно – сперва нужно заменить то, что может испортить HTML-форматирование, а именно символы «<», «>» и «&» соответствующими «<», «>» и «&». Потом – выполнить саму подсветку синтаксиса по [ультра-регулярному](https://gist.github.com/ZitRos/6310513) выражению (которая, по сути, вставляет лишь теги в текст) и лишь потом вставить каретку, определив «настоящее» ее положение (без учёта тэгов и HTML-сущностей), для чего был написан еще один метод. Да, все вышеперечисленное выполняется только в этом порядке, иначе или сама каретка подсветится, или появится много битой HTML-разметки.
А вот с автодополнением было работать интересно. Я его трижды переписывал. А прогресс алгоритма был следующим:
1. Просто получаем кусок строки от каретки до ближайшего левого разделителя или пробела и ищем совпадения с имеющимися вариантами в массиве всех вариантов.
2. Тот же кусок строки, уже включая, возможно, символы «$», «%», «##» и прочие для определения типа дополнения ищем в специальном объекте, разбитом на «категории».
3. Парсим всю левую от каретки часть по «маскам» – обратным регулярным выражениям, которые содержатся в специально структурированном объекте «терминального словаря».
Не знаю, знакомым ли кому покажется третий метод, к которому я постепенно подошел, но именно он показал самые шикарные и быстрые результаты.
Итак, как же он устроен? Очень просто. Всё что нужно, чтобы создать практически любой тип автодополнения – это грамотно составленные регулярные выражения в объекте «словаря». Вот как он может выглядеть:
**Код**
```
language = {
"client": {
"!autocomplete": {
reversedRegExp: new RegExp("([a-z]*/)+")
},
"/help": 1,
"/clear": 1,
…
},
"commands": {
"!autocomplete": {
reversedRegExp: new RegExp("([a-zA-Z]+)\\s.*")
},
"SET": 0,
"KILL": 0,
"WRITE": 0,
…
},
"staticMethods": {
"!autocomplete": {
reversedRegExp: new RegExp("([a-zA-Z]*)##\\s.*")
},
"class": 0,
…
},
"class": {
"!autocomplete": {
reversedRegExp: new RegExp("(([a-zA-Z\\.]*[a-zA-Z])?%?)\\(ssalc##\\s.*"),
separator: ".",
child: {
reversedRegExp: new RegExp("([a-zA-Z]*)\\.\\)")
}
},
"EXAMPLE": {
"Method": 0,
"Property": 0,
"Parameter": 0
},
…
}
}
```
Каждый объект внутри language может иметь специальное свойство-объект «!autocomplete». Если оно присутствует, парсер автодополнения будет обращать на этот объект внимание, а именно читать его свойства reversedRegExp и child.
Как уже можно было догадаться, reversedRegExp составлен специальным образом, и именно он определяет, уместно ли использовать свойства текущего «словарного» объекта (далее – просто «словаря») для автодополнения. Запоминающие скобки в регулярном выражении служат для выделения части искомой строки, которая будет сверяться с именами свойств словаря («терминами»). Это позволяет найти в любой синтаксической структуре ключ, по которому и будет производится выбор доступных вариантов.
С классами же немного иная задачка – нужно получить имя класса и подсказать соответствующие ему свойства. Это решилось путём дополнения свойства-объекта «!autocomplete» подобным ему свойством-объектом «child», который тоже содержит reversedRegExp – префикс к родительскому регулярному выражению, который будет рассмотрен при совпадении последнего. Алгоритм проверки получается достаточно простым. Если интересно, как именно устроен этот алгоритм, его можно найти [внутри](https://github.com/intersystems-ru/webterminal/blob/master/csp/webTerminal/js/parser.js.xml#L217) репозитория проекта.
Преимущества такого подхода очевидны – это и наглядная структура словаря всех синтаксических конструкций, и достаточно шустрый способ автодополнения, который при желании можно всячески расширять. Да, число, идущее как значение свойства “термина” – это предполагаемая его «частота употребления». Именно по этой цифре и будут сортироваться предлагаемые варианты.
Со стороны сервера весь словарь автодополнения классов и методов текущего пространства имён, в свою очередь, генерируется и сохраняется в JSON-файл, содержащий объект объектов, которые при необходимости будут подгружены и «слиты» с имеющимся на клиенте объектом словаря классов внутри основного объекта словаря. Вот так вот.
Сам сервер ранее был научен отправлять весь write сразу на клиент, с использованием [этой](http://docs.intersystems.com/cache20131/csp/docbook/DocBook.UI.Page.cls?KEY=GIOD_tcp#GIOD_tcp_sendimmediate) штуки. Но для read, как оказалось, обойтись чем-то простым вида “+Т” не получится. Вся проблема в том, что когда пользователь пытался выполнить то ли терминальную утилиту, то ли сочинить сценарий с преподобным read — сервер, обрабатывая их в xecut’е просто зависал или портил вводимые данные.
Хорошо, допустим, поставим мы терминал в режим обработки стандартных терминаторов на входе (“+Т”), и будем их отправлять с клиента. Отлично, теперь read не зависает, но возникает другая ситуация — мы ведь читаем пакет, полученный от клиента, а не его тело. Сам пакет содержит немного “мусора” для нас — это первые несколько байтов, которые служат его заголовком. Их нужно было как-то отбросить.
Чтобы проще представить, что нужно и как это все должно происходить, рассмотрим предполагаемую последовательность выполнения команды “read a write a” на сервере.
* Получение команды от клиента
* Переход терминального приложения в режим выполнения — установка ввода/вывода «напрямую»
* Передача команды в xecute
* read **a**: читаем данные от клиента, заканчивающихся терминатором
* *Достаём тело считанного пакета и помещаем в **а***
* write **a**: отправляем клиенту значение **а**
* Завершение режима выполнения
Но как же так же достать это тело, чтобы в **a** не попадали лишние байты (шапка пакета WebSocket)? Логично, нужно сделать какой-то свой обработчик read. Да и не простой, а на системном уровне: ведь терминальные утилиты тоже используют read.
К счастью, опытные ребята форума [sql.ru](http://www.sql.ru/forum/cache) мне подсказали чудесную недокументированная возможность Caché — I/O redirection. С её помощью можно было сделать именно то, что нужно — обработать все прилетающие/улетающие данные по-своему. Перенаправление ввода осуществляется написанием семи подпрограмм, которые будут брать на себя функции примитивных команд read и write при включенном ##class(%Device).ReDirectIO. Если интересна детальная реализация этой прелести, вам может пригодится [этот](http://www.sql.ru/forum/1037610/websocket-i-read) тред.
Я надеюсь опыт, изложенный выше, кому-то обязательно пригодится и станет не менее полезным чем сам терминал. На пути от концепции к уже функциональному приложению появилось много новых идей, и это еще не предел — тут можно ограничиться лишь фантазией. [Следите](http://intersystems-ru.github.io/webterminal/#history) или участвуйте в развитии проекта на [GitHub](https://github.com/intersystems-ru/webterminal), предлагайте и обсуждайте идеи, будут полезны любые ваши отзывы. Приятного администрирования! | https://habr.com/ru/post/192242/ | null | ru | null |
# Рецепты по приготовлению офлайн-приложений
Доброго времени суток, друзья!
Представляю вашему вниманию перевод замечательной статьи Джейка Арчибальда «Offline Cookbook», посвященной различным вариантам использования сервис-воркера (ServiceWorker API, далее по тексту — просто воркер) и интерфейса кэширования (Cache API).
Предполагается, что вы знакомы с основами названных технологий, потому что кода будет много, а слов мало.
Если не знакомы, то начните с [MDN](https://developer.mozilla.org/ru/docs/Web/API/ServiceWorker), а затем возвращайтесь. Вот еще неплохая [статья про сервис-воркеры](https://habr.com/ru/post/491840/) специально для визуалов.
Без дальнейших предисловий.
### В какой момент сохранять ресурсы?
Воркер позволяет обрабатывать запросы независимо от кэша, поэтому будем рассматривать их по-отдельности.
Первый вопрос: когда следует кэшировать ресурсы?
##### При установке как зависимость
Одним из событий, возникающих при работе воркера, является событие install. Это событие можно использовать для подготовки к обработке других событий. При установке нового воркера старый продолжает обслуживать страницу, так что обработка события install не должна нарушить его работу.
**Подходит для** кэширования стилей, изображений, скриптов, шаблонов… в общем, для любых статических файлов, используемых на странице.
Речь идет о тех файлах, без которых приложение не сможет работать подобно файлам, включаемым в начальную загрузку нативных приложений.
```
self.addEventListener('install', event => {
event.waitUntil(
caches.open('mysite-static-v3')
.then(cache => cache.addAll([
'/css/whatever-v3.css',
'/css/imgs/sprites-v6.png',
'/css/fonts/whatever-v8.woff',
'/js/all-min-v4.js'
// и т.д.
]))
)
})
```
event.waitUntil принимает промис для определения продолжительности и результата установки. Если промис будет отклонен, воркер не будет установлен. caches.open и cache.addAll возвращают промисы. Если один из ресурсов не будет получен,
вызов cache.addAll будет отклонен.
##### При установке не как зависимость
Это похоже на предыдущий пример, но в данном случае мы не ожидаем завершения установки, поэтому это не приведет к ее отмене.
**Подходит для** больших ресурсов, которые не требуются прямо сейчас, например, ресурсы для поздних уровней игры.
```
self.addEventListener('install', event => {
event.waitUntil(
caches.open('mygame-core-v1')
.then(cache => {
cache.addAll(
// уровни 11-20
)
return cache.addAll(
// ключевые ресурсы и уровни 1-10
)
})
)
})
```
Мы не передаем промис cache.addAll в event.waitUntil для уровней 11-20, так что если он будет отклонен, то игра все равно будет работать оффлайн. Разумеется, вам следует позаботиться о решении возможных проблем с кэшированием первых уровней и, например, повторить попытку кэширования в случае провала.
Воркер может быть остановлен после обработки событий до того, как уровни 11-20 будут кэшированы. Это означает, что данные уровни не будут сохранены. В будущем в воркер планируется добавить интерфейс фоновой загрузки для решения названной проблемы, а также для загрузки больших файлов, таких как фильмы.
Прим. пер.: данный интерфейс был реализован в конце 2018 года и получил название [Background Fetch](https://developers.google.com/web/updates/2018/12/background-fetch), но пока работает только в Хроме и Опере (68% по данным [CanIUse](https://caniuse.com/#feat=mdn-api_backgroundfetchmanager)).
##### При активации
**Подходит для** удаления старого кэша и миграции.
После установки нового воркера и остановки старого, новый воркер активируется и мы получаем событие activate. Это отличная возможность для замены ресурсов и удаления старого кэша.
```
self.addEventListener('activate', event => {
event.waitUntil(
caches.keys()
.then(cacheNames => Promise.all(
cacheNames.filter(cacheName => {
// если true, значит, мы хотим удалить данный кэш,
// но помните, что он используется во всем источнике
}).map(cacheName => caches.delete(cacheName))
))
)
})
```
Во время активации другие события, такие как fetch помещаются в очередь, так что долгая активация теоретически может заблокировать страницу. Так что используйте эту стадию только для того, что не можете сделать при работе старого воркера.
##### При возникновении пользовательского события
**Подходит**, когда весь сайт не может быть переведен в оффлайн. В этом случае мы предоставляем пользователю возможность самому решать, что кэшировать. Например, видео на Youtube, страницу в Википедии или галлерею изображений на Flickr.
Предоставьте пользователю кнопку «Прочитать позже» или «Сохранить». При нажатии кнопки получите ресурс и запишите его в кэш.
```
document.querySelector('.cache-article').addEventListener('click', event => {
event.preventDefault()
const id = event.target.dataset.id
caches.open(`mysite-article ${id}`)
.then(cache => fetch(`/get-article-urls?id=${id}`)
.then(response => {
// get-article-urls возвращает массив в формате JSON
// с URL для данной статьи
return response.json()
}).then(urls => cache.addAll(urls)))
})
```
Интерфейс кэширования доступен на странице, как и сам воркер, поэтому нам не нужно вызывать последний для сохранения ресурсов.
##### Во время получения ответа
**Подходит для** часто обновляемых ресурсов, таких как почтовый ящик пользователя или содержимое статьи. Также подходит для незначительного контента, такого как аватары, но в этом случае следует проявлять осторожность.
Если запрашиваемого ресурса нет в кэше, получаем его из сети, отправляем клиенту и записываем в кэш.
Если вы запрашиваете несколько URL, таких как пути к аватарам, убедитесь, что это не приведет к переполнению хранилища источника (origin — протокол, хост и порт) — если пользователю потребуется освободить место на диске, вы не должны оказаться первыми. Позаботьтесь об удалении ненужных ресурсов.
```
self.addEventListener('fetch', event => {
event.respondWith(
caches.open('mysite-dynamic')
.then(cache => cache.match(event.request)
.then(response => response || fetch(event.request)
.then(response => {
cache.put(event.request, response.clone())
return response
})))
)
})
```
Для эффективного использования памяти мы читаем тело ответа только один раз. В приведенном примере метод clone используется для создания копии ответа. Это делается для того, чтобы одновременно отправить ответ клиенту и записать его в кэш.
##### Во время проверки на новизну
**Подходит для** обновления ресурсов, не требующих последних версий. Это может относиться и к аватарам.
Если ресурс имеется в кэше, используем его, но получаем обновление при следующем запросе.
```
self.addEventListener('fetch', event => {
event.respondWith(
caches.open('mysite-dynamic')
.then(cache => cache.match(event.request)
.then(response => {
const fetchPromise = fetch(event.request)
.then(networkResponse => {
cache.put(event.request, networkResponse.clone())
return networkResponse
})
return response || fetchPromise
}))
)
})
```
##### При получении пуш-уведомления
Интерфейс уведомлений (Push API) — это абстракция над воркером. Она позволяет воркеру запускаться в ответ на сообщение от операционной системы. Причем, это происходит независимо от пользователя (при закрытой вкладке браузера). Страница, как правило, отправляет пользователю запрос на предоставление разрешения для совершения определенных действий.
**Подходит для** контента, зависящего от уведомлений, такого как сообщения в чате, новости в ленте, письма в почте. Также используется для синхронизации контента, такого как задачи в списке или отметки в календаре.
Результатом является уведомление, при клике на которое открывается соответствующая страница. Однако, очень важно сохранить ресурсы до отправки уведомления. Пользователь находится онлайн во время получения уведомления, но он вполне может находится оффлайн при клике по нему, поэтому важно, чтобы в этот момент контент был доступен оффлайн. В мобильном приложении Twitter это реализовано немного неправильно.
Без подключения к сети Twitter не предоставляет контент, связанный с уведомлением. Тем не менее, клик по уведомлению приводит к его удалению. Не делайте так!
Следующий код обновляет кэш перед отправкой уведомления:
```
self.addEventListener('push', event => {
if (event.data.text() === 'new-email') {
event.waitUntil(
caches.open('mysite-dynamic')
.then(cache => fetch('/inbox.json')
.then(response => {
cache.put('/inbox.json', response.clone())
return response.json()
})).then(emails => {
registration.showNotification('New email', {
body: `From ${emails[0].from.name}`,
tag: 'new-email'
})
})
)
}
})
self.addEventListener('notificationclick', event => {
if (event.notification.tag === 'new-email') {
// предположим, что все ресурсы, необходимые для рендеринга /inbox/ были кэшированы,
// например, при установке воркера
new WindowClient('/inbox/')
}
})
```
##### При фоновой синхронизации
Фоновая синхронизация (Background Sync) — еще одна абстракция над воркером. Она позволяет запрашивать разовую или периодическую фоновую синхронизацию данных. Это также не зависит от пользователя. Однако, ему также оправляется запрос на разрешение.
**Подходит для** обновления незначительных ресурсов, регулярная отправка уведомлений о которых будет слишком частой и, следовательно, назойливой для пользователя, например, новые события в социальной сети или новые статьи в новостной ленте.
```
self.addEventListener('sync', event => {
if (event.id === 'update-leaderboard') {
event.waitUntil(
caches.open('mygame-dynamic')
.then(cache => cache.add('/leaderboard.json'))
)
}
})
```
### Сохранение кэша
Ваш источник предоставляет определенное количество свободного пространства. Это пространство распределяется между всеми хранилищами: локальным и сессионным, индексированной базой данных, файловой системой и, конечно, кэшем.
Размеры хранилищ не являются фиксированными и зависят от устройства, а также от условий хранения ресурсов. Это можно проверить так:
```
navigator.storageQuota.queryInfo('temporary').then(info => {
console.log(info.quota)
// результат: <квота в байтах>
console.log(info.usage)
// результат <размер хранящихся данных в байтах>
})
```
Когда размер того или иного хранилища достигает лимита, это хранилище очищается по определенным правилам, которые в настоящее время нельзя изменить.
Чтобы решить эту проблему был предложен интерфейс отправки запроса на разрешение (requestPersistent):
```
navigator.storage.requestPersistent().then(granted => {
if (granted) {
// ура, данные сохранятся за счет увеличения размера хранилища
}
})
```
Разумеется, пользователь должен предоставить на это разрешение. Пользователь должен быть частью этого процесса. Если память в устройстве пользователя заполнена, и удаление незначительных данных не помогло решить проблему, пользователь должен принять решение о том, какие данные сохранить, а какие удалить.
Для того, чтобы это работало операционная система должна рассматривать хранилища браузера как отдельные элементы.
### Ответы на запросы
Неважно, сколько ресурсов вы храните в кэше, воркер не будет его использовать, пока вы не скажете ему когда и что именно использовать. Вот несколько шаблонов для обработки запросов.
##### Только кэш
**Подходит для** любых статических ресурсов текущей версии страницы. Вы должны кэшировать эти ресурсы на этапе установки воркера, чтобы получить возможность отправлять их в ответ на запросы.
```
self.addEventListener('fetch', event => {
// если не будет найдено совпадение,
// ответ будет похож на ошибку соединения
event.respondWith(caches.match(event.request))
})
```
##### Только сеть
Подходит для ресурсов, которые не могут быть записаны в кэш, например, данные аналитики или не GET-запросы.
```
self.addEventListener('fetch', event => {
event.respondWith(fetch(event.request))
// или просто не вызывайте event.respondWith
// это приведет к стандартному поведению браузера
})
```
##### Сначала кэш, затем, при неудаче, сеть
**Подходит для** обработки большинства запросов в оффлайн-приложениях.
```
self.addEventListener('fetch', event => {
event.respondWith(
caches.match(event.request)
.then(response => response || fetch(event.request))
)
})
```
Сохраненные ресурсы возвращаются из кэша, несохраненные — из сети.
##### Кто успел, тот и съел
**Подходит для** небольших ресурсов в погоне за повышением производительности устройств с маленьким объемом памяти.
Сочетание старого жесткого диска, антивируса и быстрого соединения с Интернетом может привести к тому, что получение данных из сети окажется быстрее, чем получение данных из кэша. Тем не менее, получение данных из сети в то время, как эти данные хранятся в устройстве пользователя — это пустая трата ресурсов.
```
// Promise.race нам не подойдет, поскольку он отклоняется
// при отклонении любого из переданных ему промисов.
// Напишем собственную функцию
const promiseAny = promises => new Promise((resolve, reject) => {
// все promises должны быть промисами
promises = promises.map(p => Promise.resolve(p))
// выполняем текущий промис, как только он разрешается
promises.forEach(p => p.then(resolve))
// если все промисы были отклонены, останавливаем выполнение функции
promises.reduce((a, b) => a.catch(() => b))
.catch(() => reject(Error('Все промисы отклонены')))
})
self.addEventListener('fetch', event => {
event.respondWith(
promiseAny([
caches.match(event.request),
fetch(event.request)
])
)
})
```
Прим. пер.: сейчас для этой цели можно использовать Promise.allSettled, но его поддержка браузерами составляет 80%: -20% пользователей — это, пожалуй, слишком.
##### Сначала сеть, затем, при неудаче, кэш
**Подходит для** ресурсов, которые часто обновляются и не влияют на текущую версию сайта, например, статьи, аватары, новостные ленты в социальных сетях, рейтинг игроков и т.д.
Это означает, что вы предоставляете онлайн-пользователям новый контент, а оффлайн-пользователям — старый. Если запрос ресурса из сети завершился успешно, вероятно, следует обновить кэш.
У данного подхода есть один недостаток. Если у пользователя проблемы с соединением или оно медленное, он вынужден ждать завершения или провала запроса вместо того, чтобы моментально получить контент из кэша. Это ожидание может быть очень долгим, что приведет к ужасному пользовательскому опыту.
```
self.addEventListener('fetch', event => {
event.respondWith(
fetch(event.request).catch(() => caches.match(event.request))
)
})
```
##### Сначала кэш, затем сеть
**Подходит для** часто обновляемых ресурсов.
Это требует от страницы отправки двух запросов: одного для кэша, другого для сети. Идея состоит в том, чтобы вернуть данные из кэша, а затем обновить их при получении данных из сети.
Порой вы можете заменить текущие данные при получении новых (например, рейтинг игроков), но это проблематично сделать для больших частей контента. Это может привести к исчезновению того, что пользователь в данный момент читает или с чем взаимодействует.
Twitter добавляет новый контент над существующим, сохраняя прокрутку: пользователь видит уведомление о новых твитах в верхней части экрана. Это возможно благодаря линейному порядку контента. Я скопировал этот шаблон для максимально быстрого отображения контента из кэша и добавления нового контента при его получении из сети.
Код на странице:
```
const networkDataReceived = false
startSpinner()
// получаем свежие данные
const networkUpdate = fetch('/data.json')
.then(response => response.json())
.then(data => {
networkDataReceived = true
updatePage(data)
})
// получаем сохраненные данные
caches.match('/data.json')
.then(response => {
if (!response) throw Error('Данные отсутствуют')
return response.json()
}).then(data => {
// не перезаписывайте новые данные из сети
if (!networkDataReceived) {
updatePage(data)
}
}).catch(() => {
// мы не получили данные из кэша, сеть - наша последняя надежда
return networkUpdate
}).catch(showErrorMessage).then(stopSpinner)
```
Код воркера:
Мы обращаемся к сети и обновляем кэш.
```
self.addEventListener('fetch', event => {
event.respondWith(
caches.open('mysite-dynamic')
.then(cache => fetch(event.request)
.then(response => {
cache.put(event.request, response.clone())
return response
}))
)
})
```
##### Подстраховка
Если попытки получить ресурс из кэша и сети провалились, должен быть запасной вариант.
**Подходит для** местозаполнителей (замена изображений пустышками), неудачных POST-запросов, страниц «Недоступно при отсутствии подключения к сети».
```
self.addEventListener('fetch', event => {
event.respondWith(
// пробуем получить ресурс из кэша
// если не получилось, обращаемся к сети
caches.match(event.request)
.then(response => response || fetch(event.request))
.catch(() => {
// если оба запроса провалились, используем страховку
return caches.match('/offline.html')
// у вас может быть несколько запасных вариантов
// в зависимости от URL или заголовков запроса
})
)
})
```
Если ваша страница отправляет письмо, воркер может сохранить его в индексированной базе данных перед отправкой и уведомить страницу о том, что отправка провалилась, но письмо было сохранено.
##### Создание разметки на стороне воркера
**Подходит для** страниц, которые рендерятся на стороне сервера и не могут быть сохранены в кэше.
Рендеринг страниц на стороне сервера — очень быстрый процесс, но он делает сохранение динамического контента в кэше бессмысленным, поскольку он может быть разным для каждого рендеринга. Если ваша страница контролируется воркером, вы можете запрашивать ресурсы и рендерить страницу прямо в нем.
```
import './templating-engine.js'
self.addEventListener('fetch', event => {
const requestURL = new URL(event.request.url)
event.respondWith(
Promise.all([
caches.match('/article-template.html')
.then(response => response.text()),
caches.match(`${requestURL.path}.json`)
.then(response => response.json())
]).then(responses => {
const template = responses[0]
const data = responses[1]
return new Response(renderTemplate(template, data), {
headers: {
'Content-Type': 'text/html'
}
})
})
)
})
```
##### Все вместе
Вам не обязательно ограничиваться одним шаблоном. Скорее всего, вам придется их комбинировать в зависимости от запроса. Например, в [trained-to-thrill](https://jakearchibald.github.io/trained-to-thrill/) используется следующее:
* Кэширование при установке воркера для постоянных элементов пользовательского интерфейса
* Кэширование при получении ответа от сервера для изображений и данных Flickr
* Получение данных из кэша, а при неудаче из сети для большинства запросов
* Получение ресурсов из кэша, а затем из сети для результатов поиска Flick
Просто смотрите на запрос и решайте, что с ним делать:
```
self.addEventListener('fetch', event => {
// разбираем URL
const requestURL = new URL(event.request.url)
// обрабатываем запросы к определенному хосту особым образом
if (requestURL.hostname === 'api.example.com') {
event.respondWith(/* определенная комбинация шаблонов */)
return
}
// маршрутизация для относительных путей
if (requestURL.origin === location.origin) {
// обработка различных путей
if (/^\/article\//.test(requestURL.pathname)) {
event.respondWith(/* другая комбинация шаблонов */)
return
}
if (/\.webp$/.test(requestURL.pathname)) {
event.respondWith(/* другая комбинация шаблонов */)
return
}
if (request.method == 'POST') {
event.respondWith(/* другая комбинация шаблонов */)
return
}
if (/cheese/.test(requestURL.pathname)) {
event.respondWith(
// прим. пер.: не смог перевести - Вопиющая ошибка сыра?
new Response('Flagrant cheese error', {
// такого статуса не существует
status: 512
})
)
return
}
}
// общий паттерн
event.respondWith(
caches.match(event.request)
.then(response => response || fetch(event.request))
)
})
```
Надеюсь, статья была вам полезной. Благодарю за внимание. | https://habr.com/ru/post/517672/ | null | ru | null |
# Оживляем гексапода. Часть третья
Как показала практика, обилие кода в статье не очень хорошо сказывается на ее читабельности. Но для понимания того, как это все работает стоить иногда напрячь мозги. На что и была нацелена предыдущая публикация. Сегодня я постараюсь завершить цикл статей по программной начинке гексапода, сделав краткий обзор того, что с чем не успели познакомится.
#### Цикл предыдущих статей:
[Как мы печатали гексапода и что из этого получилось](https://habr.com/ru/post/485856/)
[Оживляем гексапода. Часть первая](https://habr.com/ru/post/488810/)
[Оживляем гексапода. Часть вторая](https://habr.com/ru/post/489672/)
#### Конфигурация
Физические характеристики робота определены в программе в виде набора конфигурационных параметров и вынесены в отдельный конфигурационный файл *config.h*. Среди этих параметров можно выделить следующие основные группы:
**Размеры конечностей и особенности их движения**
| Идентификатор | Описание характеристики |
| --- | --- |
| COXA\_LENGTH | Длина плеча (мм) |
| FEMORA\_LENGTH | Длина бедра (мм) |
| TIBIA\_LENGTH | Длина голени (мм) |
| TIBIA\_OFFSET | Смещение плеча относительно сустава (мм) |
| COXA\_ANGLE\_0 | Угол среднего (нулевого) положения плеча |
| FEMORA\_ANGLE\_0 | Угол среднего (нулевого) положения бедра |
| TIBIA\_ANGLE\_0 | Угол среднего (нулевого) положения голени |
| COXA\_ANGLE\_INVERSE | Признак инверсии направления вращения плечевого сервопривода |
| FEMORA\_ANGLE\_INVERSE | Признак инверсии направления вращения сервопривода бедра |
| TIBIA\_ANGLE\_INVERSE | Признак инверсии направления вращения сервопривода голени |
**Расположение и ориентация конечностей робота относительно его центра**
| Идентификатор | Описание характеристики |
| --- | --- |
| LEFT\_FRONT\_FOOT\_POSITION | Точка крепления левой передней лапы |
| LEFT\_MIDLE\_FOOT\_POSITION | Точка крепления левой средней лапы |
| LEFT\_BACK\_FOOT\_POSITION | Точка крепления левой задней лапы |
| RIGTH\_FRONT\_FOOT\_POSITION | Точка крепления правой передней лапы |
| RIGTH\_MIDLE\_FOOT\_POSITION | Точка крепления правой средней лапы |
| RIGTH\_BACK\_FOOT\_POSITION | Точка крепления правой задней лапы |
| LEFT\_FRONT\_FOOT\_ROTATION | Ориентация левой передней лапы |
| LEFT\_MIDLE\_FOOT\_ROTATION | Ориентация левой средней лапы |
| LEFT\_BACK\_FOOT\_ROTATION | Ориентация левой задней лапы |
| RIGTH\_FRONT\_FOOT\_ROTATION | Ориентация правой передней лапы |
| RIGTH\_MIDLE\_FOOT\_ROTATION | Ориентация правой средней лапы |
| RIGTH\_BACK\_FOOT\_ROTATION | Ориентация правой задней лапы |
**Допустимые диапазоны углов при работе сервоприводов**
| Идентификатор | Описание характеристики |
| --- | --- |
| COXA\_MIN\_ANGLE | Минимальное отклонение плеча от среднего положения |
| COXA\_MAX\_ANGLE | Максимальное отклонение плеча от среднего положения |
| FEMORA\_MIN\_ANGLE | Минимальное отклонение бедра от среднего положения |
| FEMORA\_MAX\_ANGLE | Максимальное отклонение бедра от среднего положения |
| TIBIA\_MIN\_ANGLE | Минимальное отклонение голени от среднего положения |
| TIBIA\_MAX\_ANGLE | Максимальное отклонение голени от среднего положения |
| COMPLEX\_ANGLE\_LIMITS\_1 | Предельные максимальные одновременные значения углов наклона бедра и голени |
| MIDLE\_COXA\_MIN\_ANGLE | Минимальное отклонение среднего плеча от среднего положения |
| MIDLE\_COXA\_MAX\_ANGLE | Максимальное отклонение среднего плеча от среднего положения |
**Характеристики движения робота**
| Идентификатор | Описание характеристики |
| --- | --- |
| MOTION\_JOB\_PERIOD | Периодичность пересчета положения конечностей (мсек) |
| MOVE\_STEP | Длина шага по прямой (мм) |
| ROTATE\_STEP | Длина шага по дуге при развороте (мм) |
#### Математика
Для расчета прямой и обратной кинематики робота требуется выполнять векторные и матричные вычисления. Это осуществляется с помощью классов *Vector3D* и *Matrix3D* объявленных в файле *3d\_math.h*
**struct Vector3D**
```
struct Vector3D {
float x,y,z;
Vector3D operator -(void) {
return {-x, -y ,-z};
}
Vector3D& operator=(const Vector3D a);
float len();
};
```
**struct Matrix3D**
```
struct Matrix3D {
float a[3][3];
Vector3D operator *(Vector3D& v) {
Vector3D p;
p.x = v.x*a[0][0] + v.y*a[0][1] + v.z*a[0][2];
p.y = v.x*a[1][0] + v.y*a[1][1] + v.z*a[1][2];
p.z = v.x*a[2][0] + v.y*a[2][1] + v.z*a[2][2];
return p;
};
Matrix3D operator *(Matrix3D m) {
Matrix3D r;
for(int i=0; i<3; i++) {
for(int j=0; j<3; j++) {
r.a[i][j] = 0;
for(int k=0; k<3; k++)
r.a[i][j] += a[i][k]*m.a[k][j];
}
}
return r;
};
};
```
**Перегрузка операторов и вспомогательные функции**
```
Vector3D operator +=(Vector3D left, const Vector3D right);
Vector3D operator -=(Vector3D left, const Vector3D right);
Vector3D operator- (Vector3D a, Vector3D b);
Vector3D operator+ (Vector3D a, Vector3D b);
Vector3D operator* (Vector3D a, Vector3D b);
Vector3D operator* (float a, Vector3D b);
Vector3D operator* (Vector3D a, float b);
Vector3D operator/ (Vector3D a, int b);
// возвращает матрицу поворота для углов вектора углов r = {rx, ry, rz}
Matrix3D rotMatrix(Vector3D r); // углы в радианах
Matrix3D rotMatrix2(Vector3D r); // углы в градусах
// арккотангенс угла
float arcctn(float);
```
#### Исходники
Все исходные файлы теперь доступны на [GitHub](https://github.com/kylikovskix/geksa). Там же можно найти проект приложения для Android и модели для 3D печати. Раздел **arduino** состоит из двух подразделов:
* **main** — основной набор файлов для контроллера Arduino
* **wifi** — прошивка для esp8622 необходимая для организации канала связи по Wi-Fi
#### Что дальше?
Несмотря на то, что данная статья имеет заключительный характер, вне поля зрения остались темы организации канала связи через Wi-Fi и управление через Android. Если данные темы вызывают интерес или остались другие не рассмотренные вопросы, пишите об этом в комментариях или личной переписке. Я обязательно постараюсь дать развернутый ответ или посвятить этому отдельную статью.
Проект Geksa продолжит свое развитие. В ближайшей перспективе планируется изменение состава электронных компонентов, расширение функционала, доработка корпуса робота, внесение дополнений ПО. Буду рад услышать от вас конструктивные замечания или предложения.
Спасибо! | https://habr.com/ru/post/490950/ | null | ru | null |
# Selectors API — IE8b1 и Webkit
IE8b1 представляет поддержку очень интересной спецификации — [Selectors API](http://www.w3.org/TR/selectors-api/). Пока что это W3C working draft, но бьюсь об заклад, что т.к. IE и Webkit уже реализовали спецификацию, Presto и Gecko не заставят себя ждать.
**UPDATE**: разработчики Firefox пояснили, что в релизе 3.0 ожидать поддержки Selectors API не приходится, однако в 3.5 оно, скорее всего, реализовано будет.
Итак, что мы имеем? [Cпецификация](http://www.w3.org/TR/selectors-api/) содержит два новых метода интерфейса IHTMLElement'a — `querySelector()` и `querySelectorAll()`, которые принимают в качестве параметра строку с любым корректным CSS-селектором. `querySelector` возвращает ссылку на первый HTMLElement, удовлетворяющий указанному CSS-селектору; `querySelectorAll` возвращает StaticNodeList с элементами, удовлетворяющими указанному CSS-селектору.
Таким образом, у нас появляется новый элегантный и удобный способ поиска документов в DOM'е.
Можно будет забыть об изобретениях вроде `document.getElementsByClassName` — нужно всего лишь выполнить `document.querySelectorAll(".myClass")` и получить все элементы с данным классом.
В данный момент эти методы есть почти [во](http://extjs.com) [всех](http://mootools.net/) [популярных](http://jquery.com) [js-фреймворках](http://www.prototypejs.org), но в браузерах, не поддерживающих Selectors API работают они по одному принципу — обходят DOM и ищут элементы, соответствующие заданному CSS-селектору.
Для того, чтобы сравнить производительность библиотек и родной поддержки Selectors API авторы Webkit создали [testcase](http://webkit.org/perf/slickspeed/). Результаты как Webkit'a, так и IE8b1 впечатляют.
Впрочем, необходимо помнить, что Selectors API ограничены уровнем поддержки браузером CSS-селекторов. Не поддерживает IE8b1 CSS3-селектор `:last-child`, и не вернёт `document.querySelectorAll("body:last-child")` ничего.
Не обошлось и без небольшой ложки дёгтя — IE8b1 поддерживает спецификацию [Selectors API](http://www.w3.org/TR/selectors-api/) лишь частично, вот цитата из [статьи в MSDN](http://msdn2.microsoft.com/en-us/library/cc288326(VS.85).aspx):
> Because Internet Explorer 8 does not formally support XHTML documents, it does not support the namespace features of the W3C Selectors API specification, such as the NSResolver parameter.
Но для сайтов, где namespaces не используются, эта ложка дёгтя бочку мёда не испортит.
Также интересный факт — реализация Selectors API открывает потенциальную угрозу кражи информации о посещённых страницах в случае успешного внедрения javascript'а на страницу-жертву можно отправить href'ы всех `document.querySelectorAll("a:visited")` и таким образом узнать, какие ссылки на данной странице пользователь уже посещал. [Спецификация оставляет разрешение этой проблемы производителю](http://www.w3.org/TR/selectors-api/), реализующему Selectors API.
В результате IE8b1 игнорирует псевдоклассы `:visited` и `:link` в качестве параметров querySelector/querySelectorAll.
А вот и [пример](http://sharovatov.ru/testcases/example.html)! | https://habr.com/ru/post/25561/ | null | ru | null |
# Асинхронное программирование в однопоточных средах JavaScript
Асинхронное программирование в однопоточных средах JavaScript
=============================================================
Моя прошлая обучающая статья [Введение в Redux & React-redux](https://habr.com/ru/post/498860/) набрала больше 100к просмотров. Что же это не может не радовать меня. И поэтому я решил порадовать и вас написав очередную статью по JavaScript. Хотя если честно я не хотел больше писать статьи поскольку это довольно сложно, занимает уйму времени и сил, а еще мне не платят за всю эту научную работу. Так что следующую статью я напишу только если эта наберет 150к просмотров.
Оглавление
----------
[1. Введение в асинхронное программирование](#01)
[2. Цикл событий](#02)
[3. Отложенное выполнение кода с помощью setTimeout setImmediate и process.nextTick](#03)
....[3.1 setTimeout](#031)
....[3.2 setImmediate](#032)
....[3.3 process.nextTick](#033)
[4. Устаревшие паттерны асинхронного программирования](#04)
[5. Promise](#05)
....[5.1 Основы Promise](#051)
....[5.2 Методы экземпляра Promise](#052)
........[5.2.1 Promise.prototype.then](#0521)
........[5.2.2 Promise.prototype.catch](#0522)
........[5.2.3 Promise.prototype.finally](#0523)
....[5.3 Композиция и цепочки промисов](#053)
........[5.3.1 Графы промисов](#0531)
........[5.3.2 Параллельная композиция промисов с Promise.all и Promise.race](#0532)
........[5.3.3 Серийная композиция промисов](#0533)
[6. Асинхронные функции](#06)
....[6.1 Остановка и возобновление выполнения](#061)
....[6.2 Стратегии для асинхронных функций](#062)
........[6.2.1 Реализация Sleep](#0621)
........[6.2.2 Максимизация распараллеливания](#0622)
........[6.2.3 Серийное выполнение промисов](#0623)
........[6.2.4 Трассировка стека и управление памятью](#0624)
1. Введение в асинхронное программирование
------------------------------------------
Двойственность между синхронным и асинхронным поведением является фундаментальной концепцией в computer science, особенно в однопоточной модели цикла событий, такой как JavaScript. Асинхронное поведение обусловлено необходимостью оптимизации для более высокой вычислительной пропускной способности в условиях операций с высокой задержкой. Это прагматично, если возможно выполнение других инструкций во время завершения вычислений и при этом поддерживается стабильное состояние системы.
Асинхронная операция необязательно является вычислительной операцией или операцией с высокой задержкой. Ее можно использовать везде, где нет смысла блокировать поток выполнения, чтобы дождаться возникновения асинхронного поведения.
Синхронное поведение аналогично последовательным инструкциям процессора в памяти. Каждая инструкция выполняется строго в том порядке, в котором она появляется, и каждая из них также способна немедленно извлекать информацию, которая хранится локально в системе (например, в регистре процессора или в системной памяти). В результате можно легко определить состояние программы (например, значение переменной) в любой заданной точке кода.
```
let x = 3;
x = x + 4;
```
На каждом шаге этой программы можно рассуждать о ее состоянии, потому что выполнение не будет продолжено, пока не будет выполнена предыдущая инструкция. Когда последняя инструкция завершается, вычисленное значение сразу становится доступным для использования.
И наоборот, асинхронное поведение аналогично прерываниям, когда объект, внешний по отношению к текущему процессу, может инициировать выполнение кода. Часто требуется асинхронная операция, потому что невозможно заставить процесс долго ждать завершения операции (как в случае синхронной операции). Это длительное ожидание может возникнуть из-за того, что код обращается к ресурсу с высокой задержкой, например, отправляет запрос на удаленный сервер и ожидает ответа.
Пример выполнение арифметической операции за время ожидания:
```
let x = 3
setTimeout(() => x = x + 4, 1000)
```
Эта программа в конечном итоге выполняет ту же работу, что и синхронная — складывая два числа вместе, — но этот поток выполнения не может точно знать, когда изменится значение x, потому что это зависит от того, когда обратный вызов будет исключен из очереди сообщений и выполнен.
В тот момент, когда прерывание будет запущено, это станет черным ящиком для среды выполнения JavaScript, поэтому невозможно точно знать, когда именно произойдет прерывание (хотя оно гарантированно произойдет после завершения текущего потока синхронного выполнения, поскольку обратный вызов еще не был снят с выполнения и утилизирован). Тем не менее обычно нельзя утверждать, когда именно состояние системы изменится после запланированного обратного вызова.
Чтобы значение x стало полезным, эта асинхронно выполняемая функция должна сообщить остальной части программы, что она обновила значение x. Однако если программе не нужно это значение, тогда она может продолжить и выполнять другую работу вместо ожидания результата.
Разработать систему, которая будет знать, когда можно прочитать значение x, на удивление сложно. Реализации такой системы в JavaScript прошли несколько итераций.
Представьте, например, сложный алгоритм преобразования изображения, который работает в браузере. Пока у стека вызовов есть функции для выполнения, браузер не может ничего сделать — он заблокирован. Это означает, что браузер не может рендерить, он не может запускать какой-либо другой код, он просто завис. И здесь возникает проблема — пользовательский интерфейс вашего приложения больше не эффективен, он больше не интерактивен, не приятен. Ваше приложение зависло.
В некоторых случаях это может быть не такой критической проблемой. Но как только ваш браузер начнет обрабатывать слишком много задач в стеке вызовов, он может перестать отвечать на запросы в течение длительного времени. В этот момент многие браузеры предпримут действия, выдав ошибку, спрашивая, должны ли они закрыть страницу:
2. Цикл событий
---------------
До ES6 сам JavaScript фактически никогда не имел прямого встроенного понятия асинхронности. Движок JavaScript никогда не делал ничего, кроме выполнения одного фрагмента вашей программы в любой момент времени.
Движок JavaScript (далее. JS Engine) — специализированная программа, обрабатывающая JavaScript. Самый популярный на сегодняшний день считается движок [V8](https://ru.wikipedia.org/wiki/V8_(%D0%B4%D0%B2%D0%B8%D0%B6%D0%BE%D0%BA_JavaScript)) он используется в браузерах Google Chrome и в Node Js.
На самом деле JS Engine не работает изолированно — он работает внутри среды хостинга, которая для большинства разработчиков является типичным веб-браузером или Node.js. На самом деле, в настоящее время JavaScript внедряется во все виды устройств, от роботов до лампочек и каждое отдельное устройство представляет отдельный тип среды выполнения для JS Engine.
Общим знаменателем во всех средах является встроенный механизм, называемый циклом событий, который обрабатывает выполнение нескольких фрагментов вашей программы с течением времени, каждый раз вызывая JS Engine.
Это означает, что JS Engine — это просто среда выполнения по требованию для любого произвольного кода JS. Это окружающая среда, которая планирует события (выполнение кода JS).
Более подробно о работе JS Engine вы можете узнать из серии книг [Вы не знаете JS](https://github.com/cyberspacedk/You_dont_know_JS).
Цикл событий выполняет одну простую задачу — отслеживает стек вызовов и очередь обратного вызова. Если стек вызовов пуст, цикл событий возьмет первое событие из очереди и поместит его в стек вызовов, который эффективно его запустит.
Такая итерация называется тиком в цикле событий. Каждое событие — это просто обратный вызов функции.
Давайте пошагово рассмотрим работу цикла событий, на этом простом примере:
```
console.log('Hi')
setTimeout(function cb1() {
console.log('cb1')
}, 5000)
console.log('Bye')
```
1. Состояние чисто. Консоль браузера чиста, а стек вызовов пуст.
2. console.log('Hi') добавляется в стек вызовов.
3. console.log('Hi') выполняется.
4. console.log('Hi') удаляется из стека вызовов.
5. setTimeout(function cb1() {… }) добавляется в стек вызовов.
6. Выполняется setTimeout(function cb1() {… }). Браузер создает таймер как часть веб-API и обрабатывает обратный отсчет.
7. Сам setTimeout(function cb1() {… }) завершен и удаляется из стека вызовов.
8. console.log('Bye') добавлен в стек вызовов.
9. console.log('Bye') выполняется.
10. console.log('Bye') удаляется из стека вызовов.
11. По прошествии не менее 5000 мс таймер завершает работу и отправляет обратный вызов cb1 в очередь обратных вызовов.
12. Цикл событий берет cb1 из очереди обратного вызова и помещает его в стек вызовов.
13. cb1 выполняется и добавляет console.log('cb1') в стек вызовов.
14. console.log('cb1') выполняется.
15. console.log('cb1') удаляется из стека вызовов.
16. cb1 удаляется из стека вызовов.
Краткий обзор:
Интересно отметить, что ES6 определяет, как должен работать цикл событий, а это означает, что технически это входит в сферу ответственности JS Engine, который больше не играет роль только среды выполнения. И одной из основных причин этого изменения является введение Promise в ES6, потому что они требуют доступа к прямому, детализированному контролю над операциями планирования в очереди цикла событий.
3. Отложенное выполнение кода с помощью setTimeout setImmediate и process.nextTick
----------------------------------------------------------------------------------
### 3.1 setTimeout
*setTimeout* не помещает автоматически ваш обратный вызов в очередь цикла обработки событий. Он устанавливает таймер. Когда таймер истекает, среда помещает ваш обратный вызов в цикл событий, чтобы какой-нибудь будущий тик подхватил его и выполнил.
Это не означает, что обратный вызов будет выполнен через указанное время, а скорее то, что через это время функция обратного вызова будет добавлена в очередь цикла событий. Однако в очереди могут быть и другие события, которые были добавлены ранее — тогда вашему обратному вызову придется подождать.
Передавая вторым аргументом в *setTimeout* в качестве задержки 0, вы можете подумать что в таком случае функция обратного вызова будет выполнена сразу, как будто *setTimeout* и вовсе не было. Но это не так. Взгляните на этот простой пример:
```
let x
setTimeout(() => x = 10, 0)
console.info(x) // undefined
```
На самом деле вызов *setTimeout* с 0 в качестве второго аргумента просто откладывает обратный вызов до тех пор, пока стек вызовов не будет очищен. В данном примере x = 10 не может выполнится до того, как вызов *console.info(x)* произойдет, потому что *console.info(x)* занимает стек вызовов, и *setTimeout* не может вызвать колбэк пока там есть что-то.
### 3.2 setImmediate
```
let x
setImmediate(() => x = 10)
console.info(x) // undefined
```
*setImmediate* и *setTimeout* похожи, но ведут себя по-разному в зависимости от того, когда они вызываются.
* *setImmediate* предназначен для выполнения скрипта после завершения текущей фазы опроса.
* *setTimeout* планирует запуск скрипта по истечении минимального порога в мс.
Порядок, в котором выполняются таймеры, зависит от контекста, в котором они вызываются. Если оба вызываются из основного модуля, то время будет зависеть от производительности процесса (на которую могут влиять другие приложения, работающие на машине).
Например, если мы запускаем следующий скрипт, который не находится в цикле ввода-вывода (т. е. в основном модуле), порядок, в котором выполняются два таймера, не детерминирован, поскольку он связан с производительностью процесса:
```
// timeout_vs_immediate.js
setTimeout(() => {
console.log('timeout')
}, 0)
setImmediate(() => {
console.log('immediate')
})
```
```
$ node timeout_vs_immediate.js
timeout
immediate
$ node timeout_vs_immediate.js
immediate
timeout
```
Однако, если вы перемещаете два вызова в пределах цикла ввода-вывода, обратный вызов *setImmediate* всегда выполняется первым:
```
// timeout_vs_immediate.js
const fs = require('fs')
fs.readFile(__filename, () => {
setTimeout(() => {
console.log('timeout')
}, 0)
setImmediate(() => {
console.log('immediate')
})
})
```
```
$ node timeout_vs_immediate.js
immediate
timeout
$ node timeout_vs_immediate.js
immediate
timeout
```
Основное преимущество использования *setImmediate* по сравнению с *setTimeout* заключается в том, что *setImmediate* всегда будет выполняться перед любыми таймерами, если они запланированы в цикле ввода-вывода, независимо от того, сколько таймеров присутствует.
*setTimeout* и *setImmediate* будут запущены в следующей итерации цикла обработки событий. Но *setImmediate* всегда будет выполняться перед любыми таймерами, если они запланированы в цикле ввода-вывода, независимо от того, сколько таймеров присутствует.
### 3.3 process.nextTick
*process.nextTick* является частью асинхронного API. Но технически он не является частью цикла обработки событий. Вместо этого nextTickQueue будет обработан после завершения текущей операции, независимо от текущей фазы цикла обработки событий. Здесь операция определяется как переход от базового обработчика C/C++ и обработка JavaScript, которой необходимо выполнить.
Каждый раз, когда вы вызываете *process.nextTick* на определенной фазе, все обратные вызовы, переданные в *process.nextTick*, будут разрешены до того, как цикл событий продолжится. Это может создать некоторые плохие ситуации, потому что позволяет «голодать» вашему процессу ввода-вывода, выполняя рекурсивные вызовы *process.nextTick*, которые не позволяют циклу обработки событий достичь фазы опроса.
Когда мы передаем функцию в *process.nextTick*, мы инструктируем движок вызывать эту функцию в конце текущей операции, прежде чем начнется следующий тик цикла событий.
Вызов *setTimeout(() => {}, 0)* или *setImmediate* выполнит функцию обратного вызова в конце следующего тика, намного позже, чем при использовании *nextTick*, который отдает приоритет вызову и выполняет его непосредственно перед началом следующего тика.
По сути, имена должны быть заменены местами. *process.nextTick* срабатывает быстрее, чем *setImmediate*, но это ошибки прошлого, которые вряд ли можно исправить. Выполнение этого переключения приведет к поломке большого процента пакетов в npm.
*process.nextTick* выполняется когда цикл событий завершит обработку текущего стека вызовов и операции завершатся, JS Engine запускает все функции, переданные в вызовы *nextTick* во время этой операции.
Таким образом мы можем указать движку JS обрабатывать функцию асинхронно (после текущей функции), но как можно скорее, а не ставить ее в очередь.
Главное отличие *process.nextTick* от *setTimeout* и *setImmediate* в том что *nextTick*, выполняет обратный вызов непосредственно перед началом следующего тика, а не в следующем тике.
Поэтому вам следует использовать *nextTick*, если вы хотите убедиться, что в следующей итерации цикла событий этот код будет уже выполнен.
Зачем нам вообще нужно что-то подобное? Частично это философия дизайна, согласно которой API всегда должен быть асинхронным, даже если это не обязательно. Возьмем, к примеру, этот фрагмент кода:
```
function apiCall(arg, callback) {
if (typeof arg !== 'string')
return process.nextTick(
callback,
new TypeError('argument should be string'),
)
}
```
Фрагмент проверяет аргумент и, если он неверен, передает ошибку обратному вызову. API обновлен совсем недавно, чтобы разрешить передачу аргументов в *process.nextTick*, что позволяет ему принимать любые аргументы, переданные после обратного вызова, для распространения в качестве аргументов обратного вызова, поэтому вам не нужно вкладывать функции.
Здесь мы возвращаем ошибку пользователю, но только после того, как разрешили выполнение остального кода пользователя. Используя *process.nextTick*, гарантируется, что *apiCall* всегда выполняет свой обратный вызов после остального кода пользователя и до того, как цикл обработки событий будет разрешен. Это позволяет выполнять рекурсивные вызовы *process.nextTick* без достижения *RangeError: Maximum call stack size exceeded from v8*.
Эта философия может привести к некоторым потенциально проблемным ситуациям. Возьмем, к примеру, этот фрагмент:
```
let bar
// someAsyncApiCall имеет асинхронную сигнатуру, но синхронно вызывает обратный вызов
function someAsyncApiCall(callback) {
callback()
}
// обратный вызов вызывается до завершения `someAsyncApiCall`
someAsyncApiCall(() => {
// так как someAsyncApiCall не завершился, bar не было присвоено никакого значения
console.log('bar', bar) // bar undefined
})
bar = 1
```
*someAsyncApiCall* имеет асинхронную сигнатуру, но на самом деле он работает синхронно. Когда он вызывается, обратный вызов, предоставленный *someAsyncApiCall*, вызывается в той же фазе цикла событий, потому что *someAsyncApiCall* на самом деле ничего не делает асинхронно. В результате обратный вызов пытается обратиться к полосе ссылок, даже если эта переменная еще не указана в области действия, поскольку сценарий не может быть выполнен до конца.
Поместив обратный вызов в *process.nextTick*, сценарий по-прежнему имеет возможность выполняться до завершения, позволяя инициализировать все переменные, функции и т. д. до вызова *callback*. Также это дает возможность, не продолжать цикл событий. Это может быть полезно, чтобы пользователь был предупрежден об ошибке до того, как цикл обработки событий будет разрешен. Вот предыдущий пример с использованием *process.nextTick*:
```
let bar
function someAsyncApiCall(callback) {
process.nextTick(callback)
}
someAsyncApiCall(() => {
console.log('bar', bar) // bar 1
})
bar = 1
```
Вот еще один пример из реальной жизни:
```
const server = net.createServer(() => {}).listen(8080)
server.on('listening', () => {})
```
Когда передается только порт, порт привязывается немедленно. Таким образом, обратный вызов «listening» может быть вызван немедленно. Проблема в том, что к этому времени обратный вызов. on('listening') не будет установлен.
Чтобы обойти это, событие «listening» ставится в очередь в *nextTick*, чтобы сценарий мог выполняться до завершения. Это позволяет устанавливать любые обработчики событий.
Зачем использовать *process.nextTick*?
Есть две основные причины:
* Иметь возможножность обрабатывать ошибки, очищать все ненужные ресурсы или, возможно, повторить запрос, прежде чем цикл обработки событий продолжится.
* Иногда необходимо выполнить обратный вызов после запуска стека вызовов, но до продолжения цикла обработки событий.
Одним из примеров является соответствие ожиданиям пользователя. Простой пример:
```
const server = net.createServer()
server.on('connection', (conn) => {})
server.listen(8080)
server.on('listening', () => {})
```
Предположим, что *listen* запускается в начале цикла событий, но обратный вызов прослушивания помещается в *setImmediate*. Если имя хоста не передано, привязка к порту произойдет немедленно. Чтобы цикл событий продолжался, он должен попасть в фазу опроса, что означает, что существует ненулевая вероятность того, что connection могло быть получено, что позволяет запустить событие connection до события прослушивания.
Другой пример — запуск конструктора функции, который должен был, скажем, наследоваться от *EventEmitter*, и он хотел вызвать событие внутри конструктора:
```
const EventEmitter = require('events')
const util = require('util')
function MyEmitter() {
EventEmitter.call(this)
this.emit('event')
}
util.inherits(MyEmitter, EventEmitter)
const myEmitter = new MyEmitter()
myEmitter.on('event', () => {
console.log('an event occurred!')
})
```
Вы не можете немедленно сгенерировать событие из конструктора, потому что сценарий не будет обработан до точки, в которой пользователь назначает обратный вызов этому событию. Таким образом, внутри самого конструктора вы можете использовать *process.nextTick* для установки обратного вызова для отправки события после завершения конструктора, что обеспечивает ожидаемые результаты:
```
const EventEmitter = require('events')
const util = require('util')
function MyEmitter() {
EventEmitter.call(this)
// использование nextTick для генерации события после назначения обработчика
process.nextTick(() => {
this.emit('event')
})
}
util.inherits(MyEmitter, EventEmitter)
const myEmitter = new MyEmitter()
myEmitter.on('event', () => {
console.log('an event occurred!')
})
```
Больше примеров смотрите в статье "[Цикл событий Node.js, таймеры и process.nextTick()](https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#:~:text=setImmediate()%20vs%20setTimeout(),threshold%20in%20ms%20has%20elapsed.)"
4. Устаревшие паттерны асинхронного программирования
----------------------------------------------------
Асинхронное поведение долгое время было важным, но ужасным краеугольным камнем JavaScript. В ранних версиях языка асинхронная операция поддерживала только определение функции обратного вызова для указания, что асинхронная операция завершена. Сериализация асинхронного поведения была распространенной проблемой, обычно решаемой с помощью кодовой базы, полной вложенных функций обратного вызова, в миру называемой «адом обратных вызовов».
Предположим, вы работали со следующей асинхронной функцией, которая использует *setTimeout* для выполнения некоторого поведения через одну секунду:
```
function double(value) {
setTimeout(() => setTimeout(() => console.log(value * 2), 0), 1000)
}
double(3)
// 6 (выводится примерно спустя 1000 мс)
```
*setTimeout* позволяет определить обратный вызов, который планируется выполнить по истечении заданного промежутка времени. Спустя 1000 мс во время выполнения JavaScript запланирует обратный вызов, поместив его в очередь цикла обработки событий. Этот обратный вызов снимается и выполняется способом, который полностью невидим для кода JavaScript. Более того, функция *double* завершается сразу после успешного выполнения операции планирования *setTimeout*.
Предположим, операция *setTimeout* вернула полезное значение. Как лучше всего вернуть значение туда, где оно необходимо? Широко используемая стратегия заключается в предоставлении обратного вызова для асинхронной операции, где обратный вызов содержит код, требующий доступ к вычисленному значению (предоставляется в качестве параметра).
```
function double(value, callback) {
setTimeout(() => callback(value * 2), 1000)
}
double(3, (x) => console.log(`I was given: ${x}`))
// I was given: 6 (выводится примерно спустя 1000 мс)
```
Здесь при вызове *setTimeout* команда помещает функцию в очередь сообщений по истечении 1000 мс. Эта функция будет удалена и асинхронно вычислена средой выполнения. Функция обратного вызова и ее параметры все еще доступны в асинхронном исполнении через замыкание функции.
Возможно, вы также хотели бы иметь возможность обработать ошибки в асинхронной функции, поэтому вероятность сбоя также должна быть включена в эту модель обратного вызова, так что обычно она принимает форму обратного вызова в случае успеха и неудачи.
```
function double(value, success, failure) {
setTimeout(() => {
try {
if (typeof value !== 'number')
throw new Error(`Unexpected argument. expected number but received: ${typeof value}`)
success(2 * value)
} catch (e) {
failure(e)
}
}, 1000)
}
const successCallback = (x) => console.log(`Success: ${x}`)
const failureCallback = (e) => console.log(`Failure: ${e}`)
double(3, successCallback, failureCallback) // Success: 6 (выводится примерно спустя 1000 мс)
double('b', successCallback, failureCallback) // Failure: Error: Unexpected argument. expected number but received: string
```
Этот формат уже нежелателен, так как обратные вызовы должны быть определены при инициализации асинхронной операции. Значение, возвращаемое из асинхронной функции, является временным, и поэтому только обратные вызовы, которые готовы принять это временное значение в качестве параметра, могут получить к нему доступ.
Ситуация с обратными вызовами еще более усложняется, когда доступ к асинхронным значениям зависит от других асинхронных значений. В мире обратных вызовов это требует вложения обратных вызовов.
```
function double(value, success, failure) {
setTimeout(() => {
try {
if (typeof value !== 'number')
throw new Error(`Unexpected argument. expected number but received: ${typeof value}`)
success(2 * value)
} catch (e) {
failure(e)
}
}, 1000)
}
const successCallback = (x) => double(x, (y) => console.log(`Success: ${y}`))
const failureCallback = (e) => console.log(`Failure: ${e}`)
double(3, successCallback, failureCallback)
// Success: 12 (выводится примерно спустя 1000 мс)
```
Неудивительно, что эта стратегия обратного вызова плохо масштабируется по мере роста сложности кода. Выражение «ад обратных вызовов» вполне заслужено, так как кодовые базы JavaScript, которые были поражены такой структурой, стали почти не поддерживаемыми.
5. Promise
----------
Promise (далее промис) — это суррогатная сущность, которая выступает в качестве замены для результата, который еще не существует. Термин «промис» был впервые предложен Дэниелом Фридманом и Дэвидом Уайзом в их статье 1976 г. «Влияние прикладного программирования на многопроцессорность (The Impact of Applicative Programming on Multiprocessing)», но концептуальное поведение промиса было формализовано лишь десятилетие спустя Барбарой Лисков и Любой Шрира в их статье 1988 г. «Промисы: лингвистическая поддержка эффективных асинхронных процедурных вызовов в распределенных системах (Promises: Linguistic Support for Efficient Asynchronous Procedure Calls in Distributed Systems)». Современные компьютерные ученые описали похожие понятия, такие как «возможное», «будущее», «задержка» или «отсроченное»; все они описаны в той или иной форме программным инструментом для синхронизации выполнения программы.
Ранние формы промисов появились в jQuery и Dojo Deferred API, а в 2010 г. растущая популярность привела к появлению спецификации Promises/A внутри проекта CommonJS. Сторонние библиотеки промисов JavaScript, такие как Q и Bluebird, продолжали завоевывать популярность, но каждая реализация немного отличалась от предыдущей. Чтобы устранить разногласия в пространстве промисов, в 2012 г. организация Promises/A + разветвила предложение CommonJS Promises/A и создала одноименную спецификацию промисов [Promises/A+](https://promisesaplus.com/). Эта спецификация в конечном итоге определила, то как промисы были реализованы в спецификации ECMAScript 6.
ECMAScript 6 представил первоклассную реализацию совместимого с Promise/A+ типа Promise. За время, прошедшее с момента его введения, промисы пользовались невероятно высоким уровнем поддержки. Все современные браузеры полностью поддерживают тип промисов ES6, и несколько API-интерфейсов браузера, таких как fetch() и Battery API, используют исключительно его.
### 5.1 Основы Promise
Интерфейс Promise (промис) представляет собой обёртку для значения, неизвестного на момент создания Promise. Он позволяет обрабатывать результаты асинхронных операций так, как если бы они были синхронными: вместо конечного результата асинхронного метода возвращается своего рода обещание (дословный перевод слова «промис») получить результат в некоторый момент в будущем.
Начиная с ECMAScript 6, Promise является поддерживаемым ссылочным типом и может быть создан с помощью оператора new.
```
let p = new Promise(() => {})
console.log(p) // Promise
```
При передаче экземпляра Promise в console.log выводы консоли (которые могут
различаться в разных браузерах) указывают, что этот экземпляр Promise находится
в состоянии ожидания (pending).
Промис — это объект с состоянием, который может существовать в одном из трех состояний:
* в ожидании (Pending) — начальное состояние;
* выполнен или решенным (Fulfilled) — операция завершена успешно;
* отклонен (Rejected) — операция завершена с ошибкой.
Состояние ожидания — это начальное состояние, с которого начинается промис. Из состояния ожидания промис может быть установлен путем перехода в выполненное состояние, указывающее на успех, или отклоненное, указывающее на отказ. Этот переход к установленному состоянию необратим; как только происходит переход к выполненному или отклоненному состоянию, состояние промиса уже не сможет измениться. Кроме того, не гарантируется, что промис когда-либо покинет состояние ожидания. Следовательно, хорошо структурированный код должен вести себя правильно, если промис успешно разрешается, если он отклоняется или никогда не выходит из состояния ожидания.
Состояние промиса является частным и не может быть напрямую проверено в JavaScript. Причина этого заключается прежде всего в том, чтобы предотвратить синхронную программную обработку объекта промиса на основе его состояния при чтении. Кроме того, состояние промиса не может быть изменено внешним JS-кодом по той же причине, по которой состояние не может быть прочитано: промис намеренно инкапсулирует блок асинхронного поведения, а внешний код, выполняющий синхронное определение его состояния, противоречит его цели.
Существуют две основные причины, по которым конструкция промисов полезна. Первая — это абстрактное представление блока асинхронного выполнения. Состояние промиса указывает на то, должен ли промис подождать с завершением выполнения. Состояние ожидания указывает, что выполнение еще не началось или все еще выполняется. Выполненное состояние является неспецифическим индикатором того, что выполнение успешно завершено. Отклоненное состояние является неспецифическим индикатором того, что выполнение не завершилось успешно.
В некоторых случаях внутренней машиной состояний является вся полезность, которую промис должен предоставить: одного лишь знания о том, что кусок асинхронного кода завершен, достаточно для информирования о ходе выполнения программы. Например, предположим, что промис отправляет HTTP-запрос на сервер. Запрос, возвращающийся со статусом не 200–299, может быть достаточным для перехода состояния обещания в выполненное. Точно так же запрос, возвращающийся со статусом, который не является 200–299, перевел бы состояние промиса в отклоненное.
В других случаях асинхронное выполнение, которое оборачивает промис, фактически генерирует значение, и поток программы будет ожидать, что это значение будет доступно, когда промис изменит состояние. С другой стороны, если промис отклоняется, поток программы ожидает причину отклонения после изменения состояния промиса. Например, предположим, что промис отправляет HTTP-запрос на сервер и ожидает его возврата в формате JSON. Запрос, возвращающийся со статусом 200–299, может быть достаточным для перевода промиса в выполненное состояние, и JSON-строка будет доступна внутри промиса. Точно так же запрос, возвращаемый со статусом, который не является 200–299, перевел бы состояние промиса в отклоненное, и причиной отклонения может быть объект Error, содержащий текст, сопровождающий HTTP-код статуса.
Для поддержки этих двух вариантов использования каждый промис, который переходит в выполненное состояние, имеет закрытое внутреннее значение. Точно так же каждый промис, который переходит в отклоненное состояние, имеет закрытую внутреннюю причину. И значение, и причина являются неизменной ссылкой на примитив или объект. Оба являются необязательными и по умолчанию будут иметь значение undefined. Асинхронный код, который планируется выполнить после того, как промис достигает определенного установленного состояния, всегда снабжается значением или причиной.
Поскольку состояние промиса является закрытым, им можно манипулировать только изнутри. Эта внутренняя манипуляция выполняется внутри функции-исполнителя промиса. Функция-исполнитель выполняет две основные обязанности: инициализирует асинхронное поведение промиса и контролирует любой возможный переход состояния. Управление переходом между состояниями осуществляется путем вызова одного из двух параметров функции, которые обычно называются resolve и reject. Вызов resolve изменит состояние на выполненное; вызов reject изменит состояние на отклоненное. Вызов rejected() также сгенерирует ошибку.
```
let p1 = new Promise((resolve, reject) => resolve())
setTimeout(() => console.log(p1), 0) // Promise {: undefined}
// [[PromiseState]]: "fulfilled"
// [[PromiseResult]]: undefined
let p2 = new Promise((resolve, reject) => reject())
setTimeout(() => console.log(p2), 0) // Promise {: undefined}
// [[PromiseState]]: "rejected"
// [[PromiseResult]]: undefined
// Uncaught error (in promise)
```
В этом примере асинхронное поведение на самом деле не происходит, потому что состояние каждого промиса уже изменяется к моменту выхода из функции-исполнителя. Сама функция-исполнитель будет выполняться синхронно, так как она действует как инициализатор для промиса.
```
let p = new Promise((resolve, reject) => {
resolve()
reject() // Безрезультатно
})
setTimeout(() => console.log(p), 0) // Promise {: undefined}
```
Вы можете избежать зависания промиса в состоянии ожидания, добавив запланированное поведение выхода. Например, можно установить тайм-аут, чтобы отклонить промис через 10 секунд:
```
let p = new Promise((resolve, reject) => {
setTimeout(reject, 100) // Вызов reject() спустя 1 секунду
// Код исполнителя
})
setTimeout(() => console.log(p), 0) // Promise
setTimeout(() => console.log(p), 200) // Проверка состояния спустя 2 секунды
// (Спустя 1 секунду) Uncaught error
// (Спустя 2 секунды) Promise
```
Поскольку промис может изменить состояние только один раз, такое поведение тайм-аута позволяет безопасно устанавливать максимальное количество времени, в течение которого промис может оставаться в состоянии ожидания. Если код внутри исполнителя должен был разрешить или отклонить промис до истечения времени ожидания, попытка обработчика времени ожидания отклонить промис будет игнорироваться.
Промис не обязательно должен начинаться с состояния ожидания и использовать функцию-исполнитель для достижения установленного состояния. Можно создать экземпляр промиса в состоянии «разрешено», вызвав статический метод *Promise.resolve*.
Следующие два экземпляра промисов фактически эквивалентны:
```
let p1 = new Promise((resolve, reject) => resolve())
let p2 = Promise.resolve()
```
Значение этого разрешенного промиса станет первым аргументом, переданным *Promise.resolve*. Таким образом можно эффективно «преобразовать» любое значение в промис:
```
const p1 = Promise.resolve()
console.info(p1) // Promise : undefined
const p2 = Promise.resolve(3)
console.info(p2) // Promise : 3
// Дополнительные аргументы игнорируются
const p3 = Promise.resolve(4, 5, 6)
console.info(p3) // Promise : 4
```
Возможно, наиболее важным аспектом этого статического метода является его способность действовать как переход, когда аргумент уже является промисом. В результате *Promise.resolve* является идемпотентным методом:
```
const p = Promise.resolve(7)
console.log(p === Promise.resolve(p)) // true
console.log(p === Promise.resolve(Promise.resolve(p))) // true
```
Эта идемпотентность будет учитывать состояние промиса, переданного ему.
```
let p = new Promise(() => {})
console.log(p) // Promise
console.log(Promise.resolve(p)) // Promise
console.log(p === Promise.resolve(p)) // true
```
Этот статический метод с радостью обернет любой не-промис, включая объект ошибки, как разрешенный промис, что может привести к непреднамеренному поведению.
```
let p = Promise.resolve(new Error('foo'))
console.log(p)
// Promise : Error: foo
```
В принципе, аналогично *Promise.resolve*, *Promise.reject* создает отклоненный промис и генерирует асинхронную ошибку (которая не будет перехвачена try/catch и может быть перехвачена только обработчиком отклонения).
Следующие два экземпляра промисов фактически эквивалентны.
```
let p1 = new Promise((resolve, reject) => reject())
let p2 = Promise.reject()
```
Поле «причины» этого разрешенного промиса будет первым аргументом, переданным *Promise.reject*. Оно также будет ошибкой, переданной обработчику отклонения:
```
let p = Promise.reject(3)
console.log(p) // Promise : 3
p.then(null, e => console.log(e)) // 3
```
*Promise.reject* не отражает поведение *Promise.resolve* в отношении идемпотентности. Если объект промиса передан, он с радостью использует этот промис в качестве поля «причины» отклоненного промиса:
```
console.log(Promise.reject(Promise.resolve()))
// Promise : Promise
```
Большая часть конструкции Promise заключается в создании совершенно отдельного режима вычислений в JavaScript. Это аккуратно инкапсулировано в следующем примере, который выдает ошибки двумя различными способами:
```
try {
throw new Error('foo')
}
catch(e) {
console.log(e) // Error: foo
}
try {
Promise.reject(new Error('bar'))
}
catch(e) {
console.log(e) // Uncaught (in promise) Error: bar
}
```
Первый блок try/catch генерирует ошибку и затем перехватывает ее, но второй блок try/catch генерирует ошибку, которая не перехватывается. Это может показаться нелогичным, поскольку кажется, что код синхронно создает отклоненный экземпляр промиса, который затем выдает ошибку при отклонении. Однако причина, по которой второй промис не был перехвачен, заключается в том, что код не пытается перехватить ошибку в соответствующем «асинхронном режиме». Такое поведение подчеркивает, как на самом деле ведут себя промисы: это синхронные объекты, используемые в синхронном режиме выполнения, выступающие в качестве моста к асинхронному режиму выполнения.
В предыдущем примере ошибка от отклоненного промиса выдается не в потоке синхронного выполнения, а в результате асинхронного выполнения очереди сообщений в среде исполнения. Следовательно, инкапсулирующего блока try/catch будет недостаточно, чтобы перехватить эту ошибку. Как только код начинает выполняться в этом асинхронном режиме, единственный способ взаимодействовать с ним — использование конструкций асинхронного режима, а именно методы промисов.
### 5.2 Методы экземпляра Promise
Методы, представленные в экземпляре промиса, служат для устранения разрыва между синхронным путем внешнего кода и асинхронным внутренним путем кода. Эти методы могут использоваться для доступа к данным, возвращаемым из асинхронной операции, обработки результатов успешного и неудачного выполнения промиса, последовательного вычисления промисов или добавления функций, которые выполняются только после того, как промис входит в состояние завершения.
Для целей асинхронных конструкций ECMAScript считается, что любой объект, который предоставляет метод *then()*, реализует интерфейс Thenable.
```
class MyThenable {
then () {}
}
```
Тип Promise в ECMAScript реализует интерфейс Thenable. Этот упрощенный интерфейс не следует путать с другими интерфейсами или определениями типов в таких пакетах, как TypeScript, которые представляют собой гораздо более конкретную форму интерфейса Thenable.
#### 5.2.1 Promise.prototype.then
Метод *Promise.prototype.then()* является основным методом, который используется для подключения обработчиков к экземпляру промиса. Метод *then()* принимает до двух аргументов: необязательную функцию-обработчик onResolved и необязательную функцию-обработчик onRejected. Каждая из них будет выполнена только тогда, когда промис, по которому они определены, достигнет соответствующего состояния «выполнен» или «отклонен».
```
function onResolved (id) {
console.log('resolved')
}
function onRejected (id) {
console.log('rejected')
}
let p1 = new Promise((resolve, reject) => setTimeout(resolve, 3000))
let p2 = new Promise((resolve, reject) => setTimeout(reject, 3000))
p1.then(() => onResolved('p1'), () => onRejected('p1')) // p1 resolved
p2.then(() => onResolved('p2'), () => onRejected('p2')) // p2 rejected
```
Поскольку промис может переходить в конечное состояние только один раз, гарантируется, что выполнение этих обработчиков является взаимоисключающим.
Оба аргумента обработчика являются полностью необязательными. Любой нефункциональный тип, предоставленный в качестве аргумента *then*, будет игнорироваться. Если нужно явно передать только обработчик onRejected, каноническим выбором будет передача undefined в качестве аргумента onResolved.
Это позволит избежать создания временного объекта в памяти, который будет игнорироваться интерпретатором, и также порадует системы, которые ожидают наличие необязательного функционального объекта в качестве аргумента.
```
function onResolved (id) {
console.log('resolved')
}
function onRejected (id) {
console.log('rejected')
}
let p1 = new Promise((resolve, reject) => setTimeout(resolve, 3000))
let p2 = new Promise((resolve, reject) => setTimeout(reject, 3000))
// Нефункциональные обработчики игнорируются, и их использование не рекомендуется
p1.then('gobbeltygook')
// Каноническая форма явного пропуска обработчика onResolved
p2.then(null, () => onRejected('p2'))
// p2 rejected (спустя 3 с)
```
Метод *Promise.prototype.then* возвращает новый экземпляр промиса:
```
let p1 = new Promise(() => {})
let p2 = p1.then()
console.log(p1) // Promise
console.log(p2) // Promise
console.log(p1 === p2) // false
```
Этот новый экземпляр промиса получен из возвращаемого значения обработчика onResolved. Возвращаемое значение обработчика помещается в *Promise.resolve()* для генерации нового промиса. Если никакой функции-обработчика не предоставлено, метод действует как проход для разрешенного значения исходного промиса.
Если явного возвращаемого выражения нет, возвращаемое значение записано как undefined и обернуто в *Promise.resolve()*.
```
let p1 = Promise.resolve('foo')
// Вызов then() без функций-обработчиков сработает как проход
let p2 = p1.then()
console.log(p2) // Promise : foo
// Эти варианты эквивалентны
let p3 = p1.then(() => undefined)
let p4 = p1.then(() => {})
let p5 = p1.then(() => Promise.resolve())
console.log(p3) // Promise : undefined
console.log(p4) // Promise : undefined
console.log(p5) // Promise : undefined
// Явные возвращаемые значения обернуты в Promise.resolve():
// Эти варианты эквивалентны:
let p6 = p1.then(() => 'bar')
let p7 = p1.then(() => Promise.resolve('bar'))
console.log(p6) // Promise : bar
console.log(p7) // Promise : bar
// Promise.resolve() сохраняет возвращенный промис
let p8 = p1.then(() => new Promise(() => {}))
let p9 = p1.then(() => Promise.reject())
// Uncaught (in promise): undefined
console.log(p8) // Promise
console.log(p9) // Promise : undefined
// Генерация ошибки вернет отклоненный промис:
let p10 = p1.then(() => { throw new Error('baz') })
// Uncaught (in promise) baz
console.log(p10) // Promise baz
// Возвращение ошибки не приведет к тому же поведению отклонения,
// а вместо этого обернет объект ошибки в разрешенный промис:
let p11 = p1.then(() => Error('qux'))
console.log(p11) // Promise : Error: qux
```
Обработчик onRejected ведет себя таким же образом: значения, возвращаемые из обработчика onRejected, переносятся в *Promise.resolve()*. Поначалу это может показаться нелогичным, но обработчик onRejected выполняет свою работу по обнаружению асинхронной ошибки. Следовательно, этот обработчик отклонения, завершающий выполнение без дополнительной ошибки, следует рассматривать как ожидаемое поведение промиса и возвращать разрешенный промис.
#### 5.2.2 Promise.prototype.catch
Метод *Promise.prototype.catch()* можно использовать для присоединения только обработчика отклонения к промису. Он принимает только один аргумент — функцию-обработчик onRejected. Метод является не более чем синтаксическим сахаром и ничем не отличается от использования *Promise.prototype.then (null, onRejected)*
```
let p = Promise.reject()
let onRejected = function () {
console.log('rejected')
}
// Эти обработчики отклонений эквивалентны:
p.then(null, onRejected) // rejected
p.catch(onRejected) // rejected
let p1 = new Promise(() => {})
let p2 = p1.catch()
setTimeout(console.log, 0, p1) // Promise
setTimeout(console.log, 0, p2) // Promise
setTimeout(console.log, 0, p1 === p2) // false
```
Что касается создания нового экземпляра промиса, *Promise.prototype.catch()* ведет себя идентично обработчику *onRejected* для *Promise.prototype.then()*.
#### 5.2.3 Promise.prototype.finally
Метод *Promise.protoype.finally()* можно использовать для подключения обработчика onFinally, который выполняется, когда промис достигает разрешенного или отклоненного состояния. Это полезно для избежания дублирования кода между обработчиками onResolved и onRejected. Важно отметить, что обработчик не имеет никакого способа определить, был ли промис разрешен или отклонен, поэтому этот метод предназначен только для вещей вроде очистки памяти.
```
let p1 = Promise.resolve()
let p2 = Promise.reject()
let onFinally = function () {
console.log('Finally!')
}
p1.finally(onFinally) // Finally
p2.finally(onFinally) // Finally
```
Метод *Promise.prototype.finally()* возвращает новый экземпляр промиса.
```
let p1 = new Promise(() => {})
let p2 = p1.finally()
console.log(p1) // Promise
console.log(p2) // Promise
console.log(p1 === p2) // false
```
Этот новый экземпляр промиса получен не так, как из *then()* или *catch()*. Поскольку onFinally предназначен для использования, независимого от состояния метода, в большинстве случаев он будет действовать как проход для родительского промиса. Это верно как для разрешенных, так и отклоненных состояний. Единственные исключения из этого правила — когда он возвращает ожидающий промис или выдает ошибку (через явную генерацию или возврат отклоненного промиса). В этих случаях соответствующий промис возвращается (ожидающий или отклоненный).
```
let p1 = Promise.resolve('foo')
// Все это сработает как проход
let p2 = p1.finally()
let p3 = p1.finally(() => undefined)
let p4 = p1.finally(() => {})
let p5 = p1.finally(() => Promise.resolve())
let p6 = p1.finally(() => 'bar')
let p7 = p1.finally(() => Promise.resolve('bar'))
let p8 = p1.finally(() => Error('qux'))
setImmediate(() => console.log(p2)) // Promise : foo
setImmediate(() => console.log(p3)) // Promise : foo
setImmediate(() => console.log(p4)) // Promise : foo
setImmediate(() => console.log(p5)) // Promise : foo
setImmediate(() => console.log(p6)) // Promise : foo
setImmediate(() => console.log(p7)) // Promise : foo
setImmediate(() => console.log(p8)) // Promise : foo
// Promise.resolve() сохраняет возвращенный промис
let p9 = p1.finally(() => new Promise(() => {}))
let p10 = p1.finally(() => Promise.reject()) // Uncaught (in promise): undefined
setImmediate(() => console.log(p9)) // Promise
setImmediate(() => console.log(p10)) // Promise : undefined
let p11 = p1.finally(() => { throw new Error('baz') })
// Uncaught (in promise) baz
setImmediate(() => console.log(p11)) // Promise : baz
```
Возврат ожидающего промиса — необычный случай, так как после разрешения промиса новый промис все равно будет действовать как проход для первоначального.
```
let p1 = Promise.resolve('foo')
// Возвращаемое значение игнорируется
let p2 = p1.finally(() => new Promise((resolve, reject) => setImmediate(() => resolve('bar'))))
setImmediate(() => console.log(p2)) // Promise
setImmediate(() => setImmediate(() => (console.log(p2)))) // Promise : foo
```
Когда промис достигает установленного состояния, выполнение обработчиков, связанных с этим состоянием, просто будет запланировано, а не выполнено немедленно. Синхронный код, следующий за вложением обработчика, гарантированно будет выполнен до его вызова. Это остается верным, даже если промис уже существует в состоянии, с которым связан новый присоединенный обработчик. Это свойство, называемое невозвратностью, гарантируется средой выполнения JavaScript.
```
// Создание разрешенного промиса
let p = Promise.resolve()
// Добавление обработчика разрешенного состояния.
// Интуитивно понятно, что это будет выполнено как можно скорее,
// поскольку p уже разрешен.
p.then(() => console.log('onResolved handler'))
// Синхронная запись, указывающая, что then() вернулся
console.log('then() returns')
// Действительный вывод:
// then() returns
// onResolved handler
```
Вызов *then()* для разрешенного промиса помещает обработчик onResolved в очередь сообщений. Этот обработчик не будет выполняться до тех пор, пока он не будет удален из системы после завершения текущего потока выполнения. Следовательно, синхронный код, следующий непосредственно за *then()*, гарантированно будет выполнен перед обработчиком.
Обратное поведение в этом сценарии дает тот же результат. Если обработчики уже присоединены к промису, который позже синхронно поменяет состояние, выполнение обработчика не повторяется при этом изменении состояния. Следующий пример демонстрирует, как, даже с уже подключенным обработчиком onResolved, синхронный вызов *resolve()* будет по-прежнему демонстрировать невозвратное поведение:
```
let synchronousResolve
// Создание промиса и сохранение функции разрешения в локальной переменной.
let p = new Promise((resolve) => {
synchronousResolve = function () {
console.log('1: invoking resolve()')
resolve()
console.log('2: resolve() returns')
}
})
p.then(() => console.log('4: then() handler executes'))
synchronousResolve()
console.log('3: synchronousResolve() returns')
// Действительный вывод:
// 1: invoking resolve()
// 2: resolve() returns
// 3: synchronousResolve() returns
// 4: then() handler executes
```
Даже если состояние промиса изменяется синхронно с обработчиками, подключенными к этому состоянию, выполнение обработчика все равно не будет начато до тех пор, пока он не будет удален из очереди сообщений среды выполнения.
Невозвратность гарантируется как для обработчиков onResolved, так и для onRejected, обработчиков *catch()* и *finally()*.
```
let p1 = Promise.resolve()
p1.then(() => console.log('p1.then() onResolved'))
console.log('p1.then() returns')
let p2 = Promise.reject()
p2.then(null, () => console.log('p2.then() onRejected'))
console.log('p2.then() returns')
let p3 = Promise.reject()
p3.catch(() => console.log('p3.catch() onRejected'))
console.log('p3.catch() returns')
let p4 = Promise.resolve()
p4.finally(() => console.log('p4.finally() onFinally'))
console.log('p4.finally() returns')
// p1.then() returns
// p2.then() returns
// p3.catch() returns
// p4.finally() returns
// p1.then() onResolved
// p2.then() onRejected
// p3.catch() onRejected
// p4.finally() onFinally
```
Если к промису прикреплено несколько обработчиков, когда промис переходит в установленное состояние, связанные обработчики будут выполняться в том порядке, в котором они были присоединены. Это верно для *then()*, *catch()* и *finally()*.
```
let p1 = Promise.resolve()
let p2 = Promise.reject()
p1.then(() => setImmediate(() => console.log(1)))
p1.then(() => setImmediate(() => console.log(2)))
// 1
// 2
p2.then(null, () => setImmediate(() => console.log(3)))
p2.then(null, () => setImmediate(() => console.log(4)))
// 3
// 4
p2.catch(() => setImmediate(() => console.log(5)))
p2.catch(() => setImmediate(() => console.log(6)))
// 5
// 6
p1.finally(() => setImmediate(() => console.log(7)))
p1.finally(() => setImmediate(() => console.log(8)))
// 7
// 8
```
При достижении установленного состояния промис предоставит свое разрешенное значение (если он был выполнен) или причину отклонения (если он был отклонен) любым обработчикам, которые присоединены к этому состоянию. Это особенно полезно в тех случаях, когда требуются последовательные блоки вычислений. Например, если для выполнения второго сетевого запроса требуется ответ JSON на первый сетевой запрос, ответ от первого запроса может быть передан в качестве разрешенного значения обработчику onResolved. С другой стороны, неудачный сетевой запрос может передать код состояния HTTP обработчику onRejected.
Разрешенные значения и причины отклонения присваиваются исполнителю в качестве первого аргумента функций *resolve()* или *reject()*. Эти значения предоставляются их соответствующим обработчикам onResolved или onRejected в качестве единственного параметра.
```
let p1 = new Promise((resolve, reject) => resolve('foo'))
p1.then(value => console.log(value)) // foo
let p2 = new Promise((resolve, reject) => reject('bar'))
p2.catch(reason => console.log(reason)) // bar
```
*Promise.resolve()* и *Promise.reject()* принимают аргумент значения/причины при вызове статического метода. Обработчикам onResolved и onRejected предоставляются значение или причина так же, как если бы они были переданы от исполнителя.
```
let p1 = Promise.resolve('foo')
p1.then(value => console.log(value)) // foo
let p2 = Promise.reject('bar')
p2.catch(reason => console.log(reason)) // bar
```
Отклонение промиса аналогично выражению throw в том смысле, что оба они представляют состояние программы, которое должно вызвать прекращение любых последующих операций. Сгенерировав ошибку в исполнителе или обработчике промиса, вы отклоните его; соответствующий объект ошибки будет причиной отклонения.
```
let p1 = new Promise((resolve, reject) => reject(Error('foo')))
let p2 = new Promise((resolve, reject) => { throw Error('foo') })
let p3 = Promise.resolve().then(() => { throw Error('foo') })
let p4 = Promise.reject(Error('foo'))
setImmediate(() => console.log(p1)) // Promise : Error: foo
setImmediate(() => console.log(p2)) // Promise : Error: foo
setImmediate(() => console.log(p3)) // Promise : Error: foo
setImmediate(() => console.log(p4)) // Promise : Error: foo
// Также были сгенерированы четыре необрабатываемые ошибки
```
Промисы могут быть отклонены с любым значением, включая undefined, но настоятельно рекомендуется постоянно использовать объект ошибки. Основной причиной является то, что создание объекта ошибки позволяет браузеру захватывать трассировку стека внутри объекта ошибки, что очень полезно при отладке. Например, трассировка стека для трех ошибок в предыдущем коде должна выглядеть примерно так:
`Uncaught (in promise) Error: foo
at Promise (test.html:5)
at new Promise (anonymous)
at test.html:5
Uncaught (in promise) Error: foo
at Promise (test.html:6)
at new Promise (anonymous)
at test.html:6
Uncaught (in promise) Error: foo
at test.html:8
Uncaught (in promise) Error: foo
at Promise.resolve.then (test.html:7)`
Все ошибки генерируются асинхронно и не обрабатываются, а трассировка стека, захваченная объектами ошибок, показывает путь, по которому прошел объект ошибки. Также обратите внимание на порядок ошибок: *Promise.resolve().then()* ошибка генерируется последней — она требует дополнительной записи в очереди сообщений среды выполнения, потому что создает один дополнительный промис до того, как в конечном итоге выдает необрабатываемую ошибку.
Этот пример также раскрывает интересный побочный эффект асинхронных ошибок. Обычно при выдаче ошибки с использованием ключевого слова throw поведение JavaScript во время выполнения будет отклоняться, чтобы выполнить любые инструкции, следующие за выданной ошибкой.
```
throw Error('foo')
console.log('bar') // Этот код никогда не выполнится
// Uncaught Error: foo
```
И даже сама IDE как бы намекает:
Тем не менее, когда ошибка появляется в промисе, поскольку ошибка фактически генерируется асинхронно из очереди сообщений, это не помешает среде выполнения продолжить выполнение синхронных инструкций.
```
Promise.reject(Error('foo'))
console.log('bar')
// bar
// Uncaught (in promise) Error: foo
```
Асинхронная ошибка может быть обнаружена только с помощью асинхронного обработчика onRejection.
```
// Правильно
Promise.reject(Error('foo')).catch((e) => {})
// Неправильно
try {
Promise.reject(Error('foo'))
} catch(e) {}
```
Это не относится к перехвату ошибки, пока она находится внутри исполнителя, где try/catch все равно будет достаточно, чтобы перехватить ошибку, прежде чем она отклонит промис.
```
let p = new Promise((resolve, reject) => {
try {
throw Error('foo')
} catch(e) {}
resolve('bar')
})
setImmediate(() => console.log(p)) // Promise : bar
```
Обработчик onRejected для *then()* и *catch()* аналогичен семантике try/catch в том, что перехват ошибки должен эффективно ее нейтрализовать и позволить продолжить нормальные вычисления.
Следовательно, нужно иметь в виду, что обработчик onRejected, которому поручено отлавливать асинхронную ошибку, на самом деле возвращает разрешенный промис. Синхронное/асинхронное сравнение демонстрируется в следующем примере:
```
console.log('begin synchronous execution')
try {
throw Error('foo')
} catch(e) {
console.log('caught error', e)
}
console.log('continue synchronous execution')
// begin synchronous execution
// caught error Error: foo
// continue synchronous execution
new Promise((resolve, reject) => {
console.log('begin asynchronous execution')
reject(Error('bar'))
}).catch((e) => {
console.log('caught error', e)
}).then(() => {
console.log('continue asynchronous execution')
})
// begin asynchronous execution
// caught error Error: bar
// continue asynchronous execution
```
### 5.3 Композиция и цепочки промисов
Объединение нескольких промисов вместе приводит к нескольким мощным паттернам кода. Такое поведение возможно с помощью двух основных способов: цепочка промисов, которая включает в себя строгую последовательность нескольких промисов, и композиция промисов, которая включает в себя объединение нескольких промисов в один.
Одним из наиболее полезных аспектов промисов в ECMAScript является их способность быть строго упорядоченными. Это добавляется через структуру *Promise API*: каждый из методов экземпляра промиса — *then()*, *catch()* и *finally()* — возвращает отдельный экземпляр промиса, у которого, в свою очередь, может быть вызван другой метод экземпляра. Последовательный вызов методов таким способом называется «цепочкой промисов».
```
let p = new Promise((resolve) => {
console.log('first')
resolve()
})
p.then(() => console.log('second'))
.then(() => console.log('third'))
.then(() => console.log('fourth'))
// first
// second
// third
// fourth
```
Эта реализация в конечном итоге выполняет цепные синхронные задачи. Из-за этого выполненная работа не очень полезна или интересна, потому что она примерно такая же, как и последовательный вызов четырех функций по очереди.
```
(() => console.log('first'))();
(() => console.log('second'))();
(() => console.log('third'))();
(() => console.log('fourth'))()
```
Чтобы связать асинхронные задачи, этот пример можно перенастроить, чтобы каждый исполнитель возвращал экземпляр промиса. Поскольку каждый последующий промис будет ожидать разрешения своего предшественника, такую стратегию можно использовать для сериализации асинхронных задач. Например, это можно использовать для последовательного выполнения нескольких промисов, которые разрешаются после истечения времени ожидания.
```
let p1 = new Promise((resolve) => {
console.log('p1 executor')
setTimeout(resolve, 1000)
})
p1.then(() => new Promise((resolve) => {
console.log('p2 executor')
setTimeout(resolve, 1000)
}))
.then(() => new Promise((resolve) => {
console.log('p3 executor')
setTimeout(resolve, 1000)
}))
.then(() => new Promise((resolve) => {
console.log('p4 executor')
setTimeout(resolve, 1000)
}))
// p1 executor (спустя 1 с)
// p2 executor (спустя 2 с)
// p3 executor (спустя 3 с)
// p4 executor (спустя 4 с)
```
Объединение генерации промисов в одну фабричную функцию делает следующее:
```
function delayedResolve (str) {
return new Promise((resolve) => {
console.log(str)
setTimeout(resolve, 1000)
})
}
delayedResolve('p1 executor')
.then(() => delayedResolve('p2 executor'))
.then(() => delayedResolve('p3 executor'))
.then(() => delayedResolve('p4 executor'))
// p1 executor (спустя 1 с)
// p2 executor (спустя 2 с)
// p3 executor (спустя 3 с)
// p4 executor (спустя 4 с)
```
Каждый последующий обработчик ожидает разрешения своего предшественника, создает новый экземпляр промиса и возвращает его. Такая структура способна аккуратно сериализовать асинхронный код без принудительного использования обратных вызовов. Без использования промисов предыдущий код будет выглядеть примерно так:
```
function delayedExecute (str, callback = null) {
setTimeout(() => {
console.log(str)
callback && callback()
}, 1000)
}
delayedExecute('p1 callback', () => {
delayedExecute('p2 callback', () => {
delayedExecute('p3 callback', () => {
delayedExecute('p4 callback')
})
})
})
// p1 callback (спустя 1 с)
// p2 callback (спустя 2 с)
// p3 callback (спустя 3 с)
// p4 callback (спустя 4 с)
```
Наблюдательный разработчик заметит, что это приводит к аду обратных вызовов, для обхода которых и были предназначены промисы.
Поскольку *then()*, *catch()* и *finally()* возвращают промис, объединить их в цепочку просто. Следующий пример включает в себя все три метода:
```
let p = new Promise((resolve, reject) => {
console.log('initial promise rejects')
reject()
})
p.catch(() => console.log('reject handler'))
.then(() => console.log('resolve handler'))
.finally(() => console.log('finally handler'))
// initial promise rejects
// reject handler
// resolve handler
// finally handler
```
#### 5.3.1 Графы промисов
Поскольку к одному промису может быть присоединено произвольное число обработчиков, также возможно формирование ориентированных ациклических графов связанных промисов. Каждый промис является узлом в графе, и присоединение обработчика с использованием метода экземпляра добавляет направленную вершину. Поскольку каждый узел в графе будет ожидать установления своего предшественника, гарантируется, что направление вершин графа будет указывать порядок выполнения промиса.
Пример одного возможного типа ориентированного графа промисов — бинарного дерева:
```
// A
// / \
// B C
// / \ / \
// D E F G
let A = new Promise((resolve, reject) => {
console.log('A')
resolve()
})
let B = A.then(() => console.log('B'))
let C = A.then(() => console.log('C'))
B.then(() => console.log('D'))
B.then(() => console.log('E'))
C.then(() => console.log('F'))
C.then(() => console.log('G'))
// A
// B
// C
// D
// E
// F
// G
```
Порядок записи выражений является обходом уровня этого бинарного дерева. Ожидается, что обработчики промисов будут выполняться в том порядке, в котором они были присоединены. Поскольку обработчики промиса охотно добавляются в очередь сообщений, но выполняются лениво, результатом такого поведения является обход уровня порядка.
Деревья являются лишь одним из проявлений графа промисов. Поскольку не обязательно существует один корневой узел промиса и поскольку несколько промисов можно объединить в один (с помощью *Promise.all()* или *Promise.race()*)), направленный ациклический граф является наиболее точной характеристикой вселенной возможностей цепочки промисов.
#### 5.3.2 Параллельная композиция промисов с Promise.all и Promise.race
Класс Promise предоставляет два статических метода, которые позволяют создавать новый экземпляр промиса из нескольких экземпляров. Поведение этого составного промиса основано на том, как ведут себя промисы внутри него.
Статический метод *Promise.all()* создает промис с принципом «все или ничего», который разрешается только один раз, когда разрешаются все промисы в коллекции. Статический метод принимает итерируемое значение и возвращает новый промис:
```
let p1 = Promise.all([
Promise.resolve(),
Promise.resolve(),
])
// Элементы в итерируемом параметре приводятся к промису
// с использованием Promise.resolve()
let p2 = Promise.all([3, 4])
// Пустой итерируемый параметр эквивалентен to Promise.resolve()
let p3 = Promise.all([])
// Неверный синтаксис
let p4 = Promise.all()
// TypeError: cannot read Symbol.iterator of undefined
// Составной промис разрешается только после разрешения каждого содержащегося в нем промиса:
let p = Promise.all([
Promise.resolve(),
new Promise(resolve => setTimeout(resolve, 1000)),
])
setImmediate(() => console.log(p)) // Promise
p.then(() => setImmediate(console.log('all() resolved!')))
// all() resolved! (Спустя ~1000 мс)
```
Если хотя бы один промис из коллекции остается в ожидании, составной промис также останется в ожидании. Если один промис из коллекции отклоняется, отклоняется составной промис:
```
// Навсегда останется в ожидании
let p1 = Promise.all([new Promise(() => {})])
setImmediate(() => console.log(p1)) // Promise
// Единственное отклонение вызывает отклонение составного промиса
let p2 = Promise.all([
Promise.resolve(),
Promise.reject(),
Promise.resolve(),
])
setImmediate(() => console.log(p2)) // Promise
// Uncaught (in promise) undefined
```
Если все промисы успешно разрешены, разрешенное значение составного промиса будет массивом всех разрешенных значений содержащихся промисов в порядке обхода:
```
let p1 = new Promise(resolve => resolve(1))
let p2 = new Promise(resolve => resolve(2))
let p3 = new Promise(resolve => resolve(3))
let all = Promise.all([p1, p2, p3])
all.then(e => console.info(e)) // [ 1, 2, 3 ]
```
Если один из промисов отклоняется, то тот, что будет отклонен первым, устанавливает причину отклонения составного промиса. Последующие отклонения не влияют на причину отклонения; однако на нормальное поведение отклонения этих содержащихся в нем экземпляров промисов это не влияет. Важно, что составной промис будет просто обрабатывать отклонение всех содержащихся промисов.
```
let p1 = new Promise(resolve => resolve(1))
let p2 = new Promise((resolve, reject) => reject(2))
let p3 = new Promise((resolve, reject) => reject(3))
let all = Promise.all([p1, p2, p3])
all.catch(e => console.info(e)) // 2
```
Метод *Promise.race(iterable)* возвращает выполненный или отклонённый промис, в зависимости от того, с каким результатом завершится первый из переданных промисов, со значением или причиной отклонения этого промиса.
Если аргумент *iterable* пуст или если ни одно из обещаний в iterable никогда не выполняется, то ожидающее обещание, возвращаемое этим методом, никогда не будет выполнено.
Статический метод *Promise.race()* создает промис, который будет отражать то, что промис в коллекции сначала достигает разрешенного или отклоненного состояния. Статический метод принимает итерируемый параметр и возвращает новый промис:
```
let p1 = Promise.race([
Promise.resolve(),
Promise.resolve(),
])
// Элементы в итерируемом параметре приводятся к промисам
// с использованием Promise.resolve()
let p2 = Promise.race([3, 4])
// Пустой итерируемый объект эквивалентен new Promise(() => {})
let p3 = Promise.race([])
// Неверный синтаксис
let p4 = Promise.race()
// TypeError: cannot read Symbol.iterator of undefined
```
Метод *Promise.race()* не предоставляет предпочтения разрешенному или отклоненному промису. Составной промис будет проходить через статус и значение/причину первого установленного промиса.
```
// Сначала происходит разрешение, отклонение по тайм-ауту игнорируется
let p1 = Promise.race([
Promise.resolve(3),
new Promise((resolve, reject) => reject()),
])
console.log(p1) // Promise : 3
// Сначала происходит отклонение, разрешение по тайм-ауту игнорируется
let p2 = Promise.race([
Promise.reject(4),
new Promise((resolve, reject) => resolve()),
])
console.log(p2) // Promise : 4
// Порядок обхода — значение для расчета
let p3 = Promise.race([
Promise.resolve(5),
Promise.resolve(6),
Promise.resolve(7),
])
console.log(p3) // Promise : 5
```
Если один из промисов отклоняется, то тот, что будет отклонен первым, устанавливает причину отклонения составного промиса. Последующие отклонения не влияют на причину отклонения; однако на нормальное поведение отклонения этих содержащихся в нем экземпляров промисов это не влияет. Как и в случае с *Promise.all()*, составной промис будет просто обрабатывать отклонение всех содержащихся промисов.
```
// Хотя только первая причина отклонения будет указана в
// обработчике отклонений, вторая причина отклонения будет просто
// обработана без ошибок
let p = Promise.race([
Promise.reject(3),
new Promise((resolve, reject) => setImmediate(reject)),
])
p.catch(reason => setImmediate(() => console.log(reason))) // 3
// Нет необработанных ошибок
```
#### 5.3.3 Серийная композиция промисов
До сих пор обсуждение цепочки промисов было сосредоточено на сериализации выполнения и в значительной степени игнорировало основную особенность промисов: их способность асинхронно создавать значение и предоставлять его обработчикам.
Цепочка промисов вместе с намерением каждого последующего промиса, использующего значение своего предшественника, является фундаментальной особенностью промисов. Это во многом аналогично композиции функций, где несколько функций объединены в новую функцию.
```
function addTwo (x) { return x + 2 }
function addThree (x) { return x + 3 }
function addFive (x) { return x + 5 }
function addTen (x) {
return addFive(addTwo(addThree(x)))
}
console.log(addTen(7)) // 17
```
В этом примере композиция функций используется для объединения этих трех функций в одну для работы с одним значением. Точно так же промисы могут быть составлены вместе, чтобы постепенно потреблять значение и производить один промис, содержащий результат.
```
function addTwo (x) { return x + 2 }
function addThree (x) { return x + 3 }
function addFive (x) { return x + 5 }
function addTen (x) {
return Promise.resolve(x)
.then(addTwo)
.then(addThree)
.then(addFive)
}
addTen(8).then(console.log) // 18
```
Это можно преобразовать в более лаконичную форму с помощью *Array.prototype.reduce()*
```
function addTwo (x) { return x + 2 }
function addThree (x) { return x + 3 }
function addFive (x) { return x + 5 }
function addTen (x) {
return [addTwo, addThree, addFive]
.reduce((promise, fn) => promise.then(fn), Promise.resolve(x))
}
addTen(8).then(console.log) // 18
```
Такая стратегия композиции промисов может быть обобщена в функцию, которая объединяет любое количество функций в цепочку промисов с передачей значений.
```
function addTwo (x) { return x + 2 }
function addThree (x) { return x + 3 }
function addFive (x) { return x + 5 }
let addTen = compose(addTwo, addThree, addFive)
addTen(8).then(console.log) // 18
function compose (...fns) {
return x => fns.reduce((promise, fn) => promise.then(fn), Promise.resolve(x))
}
```
6. Асинхронные функции
----------------------
Асинхронные функции, также называемые парой оперативных ключевых слов *async/await*, являются применением парадигмы ES6 Promise к функциям ECMAScript. Поддержка *async/await* была представлена в спецификации ES7. Это и поведенческое, и синтаксическое усовершенствование спецификации, которое допускает код JavaScript. Он написан синхронно, но на самом деле способен вести себя асинхронно. Простейший пример этого начинается с простого промиса, который разрешается значением после тайм-аута:
```
new Promise((resolve, reject) => setTimeout(() => resolve(10), 1000))
```
Этот промис будет разрешен со значением 10 спустя 1000 мс. Чтобы другие части программы могли получить доступ к этому значению, как только оно будет готово, оно должно существовать внутри обработчика разрешения:
```
let p = new Promise((resolve, reject) => setTimeout(() => resolve(10), 1000))
p.then(console.info) // 10
```
Это довольно неудобно, так как теперь остальная часть программы должна быть добавлена в обработчик промиса. Можно переместить обработчик в определение функции:
```
function handler (x) {
console.log(x)
}
let p = new Promise((resolve, reject) => setTimeout(() => resolve(10), 1000))
p.then(handler) // 10
```
Это ненамного исправило ситуацию. Но факт остается фактом: любой последующий код, который хочет получить доступ к значению, созданному промисом, должен быть передан этому значению через обработчик. Это означает, что его помещают в функцию-обработчик. ES7 предлагает *async/await* в качестве элегантного решения этой проблемы.
Асинхронную функцию можно объявить, добавив ключевое слово async. Это ключевое слово может использоваться в объявлениях функций, функциях-выражениях, стрелочных функциях и методах:
```
async function foo () {}
let bar = async function () {}
let baz = async () => {}
class Qux {
async qux () {}
}
```
Использование ключевого слова async создаст функцию, которая демонстрирует некоторые асинхронные характеристики, но в целом вычисляется синхронно. Во всех других отношениях, таких как аргументы и замыкания, она по-прежнему демонстрирует все нормальное поведение функции JavaScript.
Рассмотрим этот простой пример, показывающий, что функция foo() все еще вычисляется, прежде чем перейти к последующим инструкциям:
```
async function foo () {
console.log(1)
}
foo()
console.log(2)
// 1
// 2
```
В асинхронной функции любое значение, явно возвращаемое с ключевым словом return, будет эффективно преобразовано в объект промиса с помощью Promise.resolve(). Асинхронная функция всегда будет возвращать объект промиса. Вне функции вычисляемая функция будет объектом промиса:
```
async function foo () {
console.log(1)
return 3
}
// Добавление обработчика разрешения к возвращаемому промису
foo().then(console.log)
console.log(2)
// 1
// 2
// 3
```
Конечно, это означает, что возвращение объекта промиса покажет идентичное поведение:
```
async function foo () {
console.log(1)
return Promise.resolve(3)
}
// Добавление обработчика разрешения к возвращаемому промису
foo().then(console.log)
console.log(2)
// 1
// 2
// 3
```
Возвращаемое значение асинхронной функции ожидает, но на самом деле не требует доступного объекта: оно также будет работать с обычными значениями. Объект с возможностью последующего использования будет развернут через первый аргумент, предоставленный обратному вызову then(). Объект, недоступный для последующего просмотра, будет пропущен, как если бы это был уже разрешенный промис.
```
// Возврат примитива
async function foo () {
return 'foo'
}
foo().then(console.log) // foo
// Возврат объекта, недоступного для последующего просмотра
async function bar () {
return ['bar']
}
bar().then(console.log) // ['bar']
// Возврат доступного для последующего просмотра объекта (не промиса)
async function baz () {
const thenable = {
then (callback) { callback('baz') },
}
return thenable
}
baz().then(console.log) // baz
// Возврат промиса
async function qux () {
return Promise.resolve('qux')
}
qux().then(console.log) // qux
```
Как и в случае с функциями обработчика промисов, выдача значения ошибки будет возвращать отклоненный промис.
```
async function foo () {
console.log(1)
throw new Error(3)
}
// Прикрепление обработчика отклонения к возвращаемому промису
foo().catch(console.log)
console.log(2)
// 1
// 2
// Error: 3
```
Однако ошибки отклонения промисов не будут регистрироваться асинхронной функцией:
```
async function foo () {
console.log(1)
Promise.reject(3)
}
// Прикрепление обработчика отклонения к возвращаемому промису
foo().catch(console.log)
console.log(2)
// 1
// 2
// Uncaught (in promise): 3
```
Поскольку асинхронная функция указывает вызывающему ее коду, что не ожидается своевременного завершения, логическим расширением этого поведения является возможность приостановить и возобновить выполнение. Эта функция возможна с помощью ключевого слова await, которое используется для приостановки выполнения в ожидании разрешения промиса:
Рассмотрим пример из начала:
```
function handler (x) {
console.log(x)
}
let p = new Promise((resolve, reject) => setTimeout(() => resolve(10), 1000))
p.then(handler) // 10
```
Его можно переписать с помощью async/await следующим образом:
```
async function foo () {
let p = new Promise((resolve, reject) => setTimeout(() => resolve(10), 1000))
console.log(await p)
}
foo() // 3
```
Ключевое слово await приостанавливает выполнение асинхронной функции, освобождая поток выполнения во время выполнения JavaScript. Это поведение мало чем отличается от ключевого слова yield в функции генератора. Ключевое слово await попытается «развернуть» значение объекта, передать значение в выражение и асинхронно возобновить выполнение асинхронной функции.
Ключевое слово await используется так же, как унарный оператор JavaScript. Его можно использовать отдельно или внутри выражения.
```
// Асинхронно выводит "foo"
async function foo () {
console.log(await Promise.resolve('foo'))
}
foo() // foo
// Асинхронно выводит "bar"
async function bar () {
return await Promise.resolve('bar')
}
bar().then(console.log) // bar
// Асинхронно выводит "baz" спустя 1000 мс
async function baz () {
await new Promise((resolve, reject) => setTimeout(resolve, 1000))
console.log('baz')
}
baz() // baz <спустся 1000 мс
```
Ключевое слово await предвосхищает, но на самом деле не требует наличия доступного объекта: оно также будет работать с обычными значениями. Объект с возможностью последующего использования будет «развернут» через первый аргумент, предоставленный обратному вызову then(). Объект, недоступный для последующего просмотра, будет пропущен, как если бы это был уже разрешенный промис.
```
async function foo () {
console.log(await 'foo')
}
foo() // foo
// Ожидание объекта, недоступного для просмотра
async function bar () {
console.log(await ['bar'])
}
bar() // ['bar']
// Ожидание доступного для просмотра объекта (не промиса)
async function baz () {
const thenable = {
then (callback) { callback('baz') },
}
console.log(await thenable)
}
baz() // baz
// Ожидание промиса
async function qux () {
console.log(await Promise.resolve('qux'))
}
qux() // qux
```
Как и в случае с функциями обработчика промисов, выдача ошибки вместо этого возвратит отклоненный промис:
```
async function foo () {
console.log(1)
await (() => { throw new Error(3) })()
}
// Прикрепление обработчика отклонения к возвращаемому промису
foo().catch(console.log)
console.log(2)
// 1
// 2
// Error: 3
```
Как было показано ранее, автономный *Promise.reject()* не будет захвачен асинхронной функцией и будет выдаваться как необработанная ошибка. Однако использование await для отклоненного промиса развернет значение ошибки:
```
async function foo () {
console.log(1)
await Promise.reject(3)
console.log(4) // этот код никогда не выполнится
}
// Прикрепление обработчика отклонения к возвращаемому промису
foo().catch(console.log)
console.log(2)
// 1
// 2
// 3
```
Ключевое слово await должно использоваться внутри асинхронной функции; его нельзя использовать в контексте верхнего уровня, таком как тег сценария или модуль. Однако ничто не мешает вам немедленно вызывать асинхронную функцию.
```
async function foo () {
console.log(await Promise.resolve(1))
}
foo() // 1
// Немедленный вызов асинхронной функции-выражения
void async function () {
console.log(await Promise.resolve(2))
}() // 2
```
Кроме того, асинхронная природа функции не распространяется на вложенные функции. Поэтому ключевое слово await также может появляться только внутри определения асинхронной функции; попытка использовать await внутри синхронной функции вызовет ошибку SyntaxError.
```
// Недопустимо: 'await' внутри стрелочной функции
function foo () {
const syncFn = () => {
return await Promise.resolve('foo')
}
console.log(syncFn())
}
// Недопустимо: 'await' внутри объявления функции
function bar () {
function syncFn () {
return await Promise.resolve('bar')
}
console.log(syncFn())
// Недопустимо: 'await' внутри функции-выражения
function baz () {
const syncFn = function () {
return await Promise.resolve('baz')
}
console.log(syncFn())
}
}
// Недопустимо: использование функции-выражения или стрелочной функции с IIFE
function qux () {
(function () { console.log(await Promise.resolve('qux')) })();
(() => console.log(await Promise.resolve('qux')))()
}
```
### 6.1 Остановка и возобновление выполнения
Истинная природа использования ключевого слова await более тонка, чем может показаться на первый взгляд. Рассмотрим следующий пример, где три функции вызываются по порядку, но их выходные данные печатаются в обратном порядке:
```
async function foo () {
console.log(await Promise.resolve('foo'))
}
async function bar () {
console.log(await 'bar')
}
async function baz () {
console.log('baz')
}
foo()
bar()
baz()
// baz
// foo
// bar
```
В парадигме *async/await* ключевое слово *await* выполняет всю тяжелую работу. Ключевое слово *async* во многих отношениях является просто специальным индикатором для интерпретатора JavaScript. В конце концов, асинхронная функция, которая не содержит ключевое слово *await*, выполняется так же, как обычная функция.
```
async function foo () {
console.log(2)
}
console.log(1)
foo()
console.log(3)
// 1
// 2
// 3
```
Ключ к полному пониманию ключевого слова *await* заключается в том, что оно не просто ждет, пока значение станет доступным. При обнаружении ключевого слова await среда выполнения JavaScript может точно отслеживать, где было приостановлено выполнение. Когда значение справа от *await* будет готово, среда выполнения JavaScript вставит задачу в очередь сообщений, которая асинхронно возобновит выполнение этой функции.
Следовательно, даже когда *await* сопряжено с немедленно доступным значением, остальная часть функции все равно будет выполняться асинхронно. Это продемонстрировано в следующем примере:
```
async function foo () {
console.log(2)
await null
console.log(4)
}
console.log(1)
foo()
console.log(3)
// 1
// 2
// 3
// 4
```
Порядок вывода на консоль лучше всего объяснить с точки зрения того, как среда выполнения обрабатывает этот пример:
1. Вывод 1.
2. Вызов асинхронной функции foo.
3. (внутри foo) Вывод 2.
4. (внутри foo) Ключевое слово await приостанавливает выполнение и добавляет задачу в очередь сообщений для немедленно доступного значения null.
5. foo завершается.
6. Вывод 3.
7. Синхронный поток выполнения заканчивается.
8. Среда выполнения JavaScript удаляет задачу из очереди сообщений, чтобы возобновить выполнение.
9. 9. (внутри foo) Выполнение возобновляется; await предоставляется со значением null (которое здесь не используется).
10. 10. (внутри foo) Вывод 4.
11. 11. Возвращение foo.
Еще один пример, демонстрирующий обработку асинхронного кода (в этот раз с использованием промиса):
```
async function foo () {
console.log(2)
console.log(await Promise.resolve(6))
console.log(7)
}
async function bar () {
console.log(4)
console.log(await 8)
console.log(9)
}
console.log(1)
foo()
console.log(3)
bar()
console.log(5)
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 8
// 9
```
### 6.2 Стратегии для асинхронных функций
Из-за их удобства и полезности асинхронные функции все чаще повсеместно используются в кодовых базах JavaScript. Тем не менее при использовании асинхронных функций помните о некоторых особенностях.
#### 6.2.1 Реализация Sleep
При первом изучении JavaScript многие разработчики используют конструкцию, аналогичную *Thread.sleep()* в Java, пытаясь ввести неблокирующую задержку в программу. Раньше это был краеугольный педагогический способ представления, как setTimeout вписывается в поведение JavaScript во время выполнения.
С асинхронными функциями это уже не так! Построить утилиту, которая позволяет функции *sleep()* — «заснуть» — на миллисекунды, очень просто:
```
async function sleep(delay) {
return new Promise((resolve) => setTimeout(resolve, delay))
}
void async function foo() {
const t0 = Date.now()
await sleep(1500) // sleep for ~1500ms
console.log(Date.now() - t0)
}()
// 1502
```
#### 6.2.2 Максимизация распараллеливания
Если ключевое слово *await* не используется с осторожностью, программа может упустить возможные ускорения распараллеливания. Рассмотрим следующий пример, который ожидает пять случайных тайм-аутов последовательно:
```
async function randomDelay(id) {
// Задержка между 0 и 1000 мс
const delay = Math.random() * 1000
return new Promise((resolve) => setTimeout(() => {
console.log(`${id} finished`)
resolve()
}, delay))
}
void async function foo() {
const t0 = Date.now()
await randomDelay(0)
await randomDelay(1)
await randomDelay(2)
await randomDelay(3)
await randomDelay(4)
console.log(`${Date.now() - t0}ms elapsed`)
}()
// 0 finished
// 1 finished
// 2 finished
// 3 finished
// 4 finished
// 3341ms elapsed
```
После свертывания в цикл for получаем следующее:
```
async function randomDelay(id) {
// Задержка между 0 и 1000 мс
const delay = Math.random() * 1000
return new Promise((resolve) => setTimeout(() => {
console.log(`${id} finished`)
resolve()
}, delay))
}
void async function foo() {
const t0 = Date.now()
for (let i = 0; i < 5; ++i) {
await randomDelay(i)
}
console.log(`${Date.now() - t0}ms elapsed`)
}()
// 0 finished
// 1 finished
// 2 finished
// 3 finished
// 4 finished
// 2219ms elapsed
```
Даже если между промисами нет взаимозависимости, эта асинхронная функция будет приостанавливать работу и ждать завершения каждого из них, прежде чем запускать следующий. Это гарантирует сохранение порядка, но за счет общего времени выполнения.
Если сохранение порядка не требуется, лучше инициализировать промисы сразу и ожидать результатов по мере их появления.
```
async function randomDelay(id) {
// Задержка между 0 и 1000 мс
const delay = Math.random() * 1000
return new Promise((resolve) => setTimeout(() => {
setImmediate(() => console.log(`${id} finished`))
resolve()
}, delay))
}
void async function foo() {
const t0 = Date.now()
const p0 = randomDelay(0)
const p1 = randomDelay(1)
const p2 = randomDelay(2)
const p3 = randomDelay(3)
const p4 = randomDelay(4)
await p0
await p1
await p2
await p3
await p4
setImmediate(() => console.log(`${Date.now() - t0}ms elapsed`))
}()
// 1 finished
// 4 finished
// 3 finished
// 0 finished
// 2 finished
// 672ms elapsed
```
После свертывания в массив и цикла *for* получаем следующее:
```
async function randomDelay(id) {
// Задержка между 0 и 1000 мс
const delay = Math.random() * 1000
return new Promise((resolve) => setTimeout(() => {
console.log(`${id} finished`)
resolve()
}, delay))
}
void async function foo() {
const t0 = Date.now()
const promises = Array(5).fill(null).map((_, i) => randomDelay(i))
for (const p of promises)
await p
console.log(`${Date.now() - t0}ms elapsed`)
}()
// 4 finished
// 2 finished
// 1 finished
// 0 finished
// 3 finished
// 906ms elapsed
```
Обратите внимание, что, хотя выполнение промисов нарушило порядок, операторы промисов предоставляются разрешенным значениям в порядке:
```
async function randomDelay(id) {
// Задержка между 0 и 1000 мс
const delay = Math.random() * 1000
return new Promise((resolve) => setTimeout(() => {
console.log(`${id} finished`)
resolve(id)
}, delay))
}
void async function foo() {
const t0 = Date.now()
const promises = Array(5).fill(null).map((_, i) => randomDelay(i))
for (const p of promises)
console.log(`awaited ${await p}`)
console.log(`${Date.now() - t0}ms elapsed`)
}()
// 1 finished
// 2 finished
// 4 finished
// 3 finished
// 0 finished
// awaited 0
// awaited 1
// awaited 2
// awaited 3
// awaited 4
// 906ms elapsed
```
#### 6.2.3 Серийное выполнение промисов
Ранее уже обсуждалось, как составлять промисы, которые
выполняются последовательно и передают значения последующему промису.
С *async/await* цепочка промисов становится очень простой
```
function addTwo(x) {return x + 2}
function addThree(x) {return x + 3}
function addFive(x) {return x + 5}
async function addTen(x) {
for (const fn of [addTwo, addThree, addFive])
x = await fn(x)
return x
}
addTen(9).then(console.log) // 19
```
Здесь *await* напрямую передает возвращаемое значение каждой функции и результат выводится итеративно. Предыдущий пример не имеет дела с промисами, но его можно перенастроить на использование асинхронных функций — и, следовательно, промисов — вместо этого:
```
async function addTwo(x) {return x + 2}
async function addThree(x) {return x + 3}
async function addFive(x) {return x + 5}
async function addTen(x) {
for (const fn of [addTwo, addThree, addFive])
x = await fn(x)
return x
}
addTen(9).then(console.log) // 19
```
#### 6.2.4 Трассировка стека и управление памятью
Промисы и асинхронные функции имеют значительную степень совпадения с точки зрения функциональности, которую они предоставляют, но они значительно расходятся, когда дело доходит до того, как они представлены в памяти. Рассмотрим следующий пример, который показывает чтение трассировки стека для отклоненного промиса:
```
function fooPromiseExecutor(resolve, reject) {
setTimeout(reject, 1000, 'bar')
}
void function foo() {
new Promise(fooPromiseExecutor)
}()
// Uncaught (in promise) bar
// setTimeout
// setTimeout (async)
// fooPromiseExecutor
// foo
```
Если вы основываетесь на полученном ранее понимании промисов, это чтение трассировки стека должно вас озадачить. Трассировка стека должна в буквальном смысле, представлять вложенную природу вызовов функций, которая существует в настоящее время в стеке памяти движка JavaScript. Когда обработчик тайм-аута выполняет и отклоняет промис, показанное сообщение об ошибке идентифицирует вложенные функции, которые были вызваны для первоначального создания экземпляра промиса. Однако известно, что эти функции уже возвращены и, следовательно, не будут найдены в трассировке стека.
Ответ прост: движок JavaScript выполняет дополнительную работу по сохранению стека вызовов, в то время как это возможно при создании структуры промиса. Когда выдается ошибка, этот стек вызовов извлекается логикой обработки ошибок среды выполнения и поэтому доступен в трассировке стека. Это, конечно, означает, что он должен сохранять трассировку стека в памяти и потребуются затраты на вычисления и хранение.
Рассмотрим предыдущий пример, как если он был переработан с помощью асинхронных функций:
```
function fooPromiseExecutor(resolve, reject) {
setTimeout(reject, 1000, 'bar')
}
void async function foo() {
await new Promise(fooPromiseExecutor)
}()
// Uncaught (in promise) bar
// foo
// async function (async)
// foo
```
С этой структурой трассировка стека точно представляет текущий стек вызовов, потому что fooPromiseExecutor вернулась и больше не находится в стеке, но foo приостановлена и еще не завершена. Среда выполнения JavaScript может просто хранить указатель от вложенной функции на ее контейнерную функцию, как это было бы с синхронным стеком вызовов функций. Этот указатель эффективно сохраняется в памяти и может использоваться для генерации трассировки стека в случае ошибки. Такая стратегия не влечет за собой дополнительных затрат, как в случае с предыдущим примером, и поэтому должна быть предпочтительна, если производительность имеет решающее значение. | https://habr.com/ru/post/651037/ | null | ru | null |
# IronPython как движок для макросов в .NET приложениях
Подозреваю, многие из вас задумывались — как можно в .NET приложение добавить поддержку макросов — чтобы можно было расширять возможности программы без ее перекомпиляции и предоставить сторонним разработчикам возможность легко и просто получить доступ к API вашего приложения? В статье рассмотрено, как в качестве основы для выполнения макросов использовать IronPython — реализацию языка Python на платформе .NET.
Для начала, следует определится — что мы будем иметь в виду под словом «макрос» — это скрипт, который без перекомпиляции проекта позволял бы получить доступ к определенному API. Т.е. вытаскивать значения с формы, модифицировать их — и все это в режиме run-time, без модификации приложения.
Первым вариантом, который приходит на ум будет создание собственного интерпретатора для простенького скрипт-языка. Вторым — будет динамическая компиляция какого-нибудь .NET языка (того же C#) — с динамической же подгрузкой сборок и выполнением через Reflection. И третий — использование интерпретируемых .NET языков (DLR) — IronPython или IronRuby.
Создавать свой язык + интерпретор к нему с возможностью .NET interoperability — задача нетривиальная, оставим ее для энтузиастов.
Динамическая компиляция — слишком громоздко и тащит за собой использование Reflection. Однако, этот метод не лишен преимуществ — написанный макрос компилируется единожды и в дальшейшем может использоватся многократно — в виде полноценной .NET сборки. Итак — финалист — метод номер три — использование существующих DLR языков. В качестве такого языка выбираем IronPython (примите это как факт :). Текущая версия IPy — 2.0, взять можно на [codeplex.com/IronPython](http://codeplex.com/IronPython)
Перейдем непосредствено к кодированию.
Для начала, рассмотрим интерфейс тестового приложения «Notepad».
[](http://imageshack.us)
[](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fg.imageshack.us%2Fimg228%2Fnotepad1ed1.png%2F1%2F%22)
В меню «Сервис» и разместим пункт «Макросы». Для примера рассмотрим простейший вариант формирования списка макросов — в каталоге с программой создадим папку «Macroses» файлы из этой папки станут пунктами меню.
> `private void Main\_Load(object sender, EventArgs e)
>
> {
>
> MacrosToolStripMenuItem itm = null;
>
> string[] files = Directory.GetFiles(@".\Macroses");
>
> foreach (string file in files)
>
> {
>
> itm = new MacrosToolStripMenuItem(Path.GetFileNameWithoutExtension(file)) { MacrosFileName = file };
>
> itm.Click += new EventHandler(macroToolStripMenuItem\_Click);
>
> макросыToolStripMenuItem.DropDownItems.Add(itm);
>
> }
>
> }
>
>
>
> internal class MacrosToolStripMenuItem : ToolStripMenuItem
>
> {
>
> public MacrosToolStripMenuItem(string FileName) : base(FileName) { }
>
> public string MacrosFileName { get; set; }
>
> }
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
MacrosToolStripMenuItem — класс-наследник от ToolStripMenuItem отличающийся только свойством MacrosFileName
Для начала, создадим макрос, который просмотрит текст в textBox'е и найдет все e-mail адреса вида «vpupkin@mail.ru». В папке Macroses создаем файл SaveEmail.py, запускаем приложение — и смотрим, что в меню Макросы появился пункт SaveEmail.
Теперь собственно ключевой момент — выполнение IPy скрипта и доступ его к интерфейсу. Добавляем к проекту ссылку на сборку IronPython.dll. И создаем класс MacroRunner — выполняющий скрипт.
> `public class MacroRunner
>
> {
>
> public static Form CurrentForm;
>
>
>
> public string FileName { get; set; }
>
>
>
> public MacroRunner() { }
>
>
>
> public void Execute()
>
> {
>
> // собственно среда выполнения Python-скрипта
>
> IronPython.Hosting.PythonEngine pyEngine = new IronPython.Hosting.PythonEngine();
>
> // важный момент - к среде выполнения подключаем текушую выполняемую сборку, т.к.
>
> // в ней собственно и объявлена форма, к которой необходимо получит доступ
>
> pyEngine.LoadAssembly(System.Reflection.Assembly.GetExecutingAssembly());
>
>
>
> try
>
> {
>
> pyEngine.ExecuteFile(FileName);
>
> }
>
> catch (Exception exc)
>
> {
>
> MessageBox.Show(exc.Message);
>
> }
>
> }
>
> }
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Ключевой момент — подключение к выполняющей среде IPy текущей сборки — для доступа к форме. Когда сборка подключена, в IPy скрипте появится возможность использовать классы пространства имен Notepad. Так же, через LoadAssebmly можно добавить и другие необходимые сборки — типа System.Windows.Forms — чтобы работать с формами.
Класс готов, теперь модифицируем обработчик клика на пунктах подменю Макросы
> `protected void macroToolStripMenuItem\_Click(object sender, EventArgs e)
>
> {
>
> MacrosToolStripMenuItem item = sender as MacrosToolStripMenuItem;
>
>
>
> MacroRunner runner = new MacroRunner() { FileName = item.MacrosFileName };
>
> MacroRunner.CurrentForm = this;
>
> runner.Execute();
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Здесь следует отметить следующий момент — чтобы передать в IPy-скрипт форму, из которой собственно вызывается макрос — используется статическое поле CurrentForm. В скрипте форма будет доступна как Notepad.MacroRunner.CurrentForm. В идеале, скрипт, разумеется, не должен иметь полного доступа к интерфейсу формы — а должен пользоватся только предоставленным API — и ограничиваться только им. Но сейчас этим заморачиваться не будем — и просто сделаем textBox открытым (Modifier = Public). Ну и кроме текстового поля, разрешим скрипту доступ к пункту меню Сервис (Modifier = Public).
Работа с формой закончена, собираем проект и открываем файл SaveEmail.py — теперь работаем только с макросами.
Итак, первый макрос — SaveEmail.py:
> `from Notepad import \*
>
> import re
>
>
>
> text = MacroRunner.CurrentForm.textBox.Text
>
> links = re.findall("\w\*@\w\*\.\w{2,4}", text)
>
> file = open("emails.txt", "w")
>
> file.write("\n".join(links))
>
> file.close()
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Т.к. сборка подключена к среде выполнения — то доступно пространство имен Notepad — в котором объявлены классы приложения. Как раз сейчас потребуется статический метод класса MacroRunner — чтобы получить доступ к активной форме (еще раз оговорюсь — что правильнее было бы предоставить не прямой доступ, а через класс-посредник — которые ограничит доступ определенным API). Ну а дальше все просто — получаем текст, регулярным выражением вытаскиваем email — и сохраняем их в файл в текущем каталоге.
Можно запустить приложение, ввести произвольный текст, содежащий email — и убедиться, что после того, как макрос отработал — в папке с выполняемой программой появился файл emails.txt.
Теперь еще один пример, что может сделать макрос — чуть интереснее предыдущего. Итак, создаем в папке Macroses файл UIModifier.py. Как можно догадаться по названию — макрос будет изменять элементы интерфейса приложения. Конкретно — добавит новый пункт в меню Сервис. Для того, чтобы можно было работать с элементами управления WinForms необходимо в среде выполнения IPy подключить сборку System.Windows.Forms. Это можно сделать в момент запуска скрипта из приложения — добавить еще один вызов LoadAssembly. Но мы решили — никаких перекомпиляций, пусть IronPython обходится своими силами. Ну что ж, силы есть :). Чтобы подключить сборку используется метод AddReference класса clr.
> `from Notepad import \*
>
> main = MacroRunner.CurrentForm
>
>
>
> import clr
>
> clr.AddReference("System.Windows.Forms")
>
> from System.Windows.Forms import \*
>
>
>
> def pyHello(s,e):
>
> MessageBox.Show("Hello from IPy!")
>
>
>
> item = ToolStripMenuItem()
>
> item.Name = "pybtn"
>
> item.Text = "Python created!"
>
> item.Click += pyHello
>
>
>
> main.сервисToolStripMenuItem.DropDownItems.Add(item)
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Все просто — получаем текущую форму, подключаем сборку System.Windows.Forms и импортируем из пространства имен System.Windows.Forms все — пригодится.
pyHello — простенький обработчик события — при щелчке на созданном пункте меню — будет выводится сообщение.
Запускаем приложение, выполняем макрос. Смотрим пункт меню Сервис:
[](http://imageshack.us)
[](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fg.imageshack.us%2Fimg517%2Fnotepad2ht8.png%2F1%2F%22)
При щелчке на пункт меню «Python сreated!» появится стандартный MessageBox — собственно, чего и добивались.
Спасибо всем за внимание :) | https://habr.com/ru/post/48832/ | null | ru | null |
# ReSharper: Call Hierarchy
В ReSharper 5.0 появилась новая функция Call Hierarchy. В сущности, она представляет собой удобный UI для массовых Find Usages или Go To Declaration.
Первоначально в статье я хотел сделать сравнительный анализ этой фичи в R# и в VS 2010, но в процессе написания обнаружилось, что Call Hierarchy в VS 2010 не выдерживает никакой критики (не работает с events, интерфейсами, замыканиями и проч.) и на примерах из статьи вообще не показывает ничего полезного и разумного. Поэтому я просто расскажу об интересных штуках, которые умеет Call Hierarchy в R#.
Events
======
Попробуем искать исходящие вызовы из метода `Foo` (*R# -> Inspect -> Outgoing*):
> `using System;
>
>
>
> public class C2
>
> {
>
> public event EventHandler E = (sender, args) => Subscription\_In\_Initializer();
>
>
>
> static void Subscription\_In\_Initializer()
>
> {
>
> }
>
>
>
> void Foo()
>
> {
>
> E(this, EventArgs.Empty);
>
> }
>
> }
>
>
>
> class C3
>
> {
>
> void Bar()
>
> {
>
> new C2().E += Subscription\_In\_Method;
>
> }
>
>
>
> void Subscription\_In\_Method(object sender, EventArgs e)
>
> {
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Результат очевиден и понятен. R# благополучно находит все подписки на `event E` и показывает их как возможные варианты вызовов. Ничего сверхестественного, но очень удобно.
Generics
========
Рассмотрим простой пример кода:
> `public abstract class Base
>
> {
>
> public void Do(T value)
>
> {
>
> DoImplementation(value);
>
> }
>
>
>
> protected abstract void DoImplementation(T value);
>
> }
>
>
>
> public class Concrete1 : Base<int>
>
> {
>
> protected override void DoImplementation(int value)
>
> {
>
> }
>
> }
>
>
>
> public class Concrete2 : Base<string>
>
> {
>
> protected override void DoImplementation(string value)
>
> {
>
> }
>
> }
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь поищем исходящие вызовы из `Base.Foo`:
Все очевидно.
Теперь добавим такой класс `Main` и попробуем поискать исходящие вызовы из `Foo`:
> `class Main
>
> {
>
> void Foo()
>
> {
>
> Concrete2 c = null; // null, чтобы не загрязнять дерево вызовов
>
> c.Do("string");
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Вызова `Concrete1.DoImplementation` больше нет! Все потому, что R# посмотрел на параметры типа и сделал вывод, что `Base.Do` вызовется с `T->string` (см. вторую строчку результатов: `Base.Do` — `string` указывает на то, что мы вызываем метод с конкретной подстановкой), а соответственно отфильтровал `Concrete1`, т.к. в нем используется наследование с подстановкой `T->int`.
Теперь чуть более сложный, но еще более жизненный пример с паттерном Visitor. Найдем входящие (Incoming) вызовы метода `ConcreteVisitor1.VisitNode1` (*R# -> Inspect -> Incoming Calls*). Обратите внимание, что в этом примере мы идем уже в обратную сторону, как бы против вызовов методов:
> `public interface IVisitor
>
> {
>
> void VisitNode1(T data);
>
> }
>
>
>
> class Node1
>
> {
>
> public void Accept(IVisitor v, T data)
>
> {
>
> v.VisitNode1(data);
>
> }
>
> }
>
>
>
> public class ConcreteVisitor1 : IVisitor<int>
>
> {
>
> public void VisitNode1(int data)
>
> {
>
> }
>
> }
>
>
>
> public class ConcreteVisitor2 : IVisitor<string>
>
> {
>
> public void VisitNode1(string data)
>
> {
>
> }
>
> }
>
>
>
> public class C1
>
> {
>
> void Foo()
>
> {
>
> var v = new ConcreteVisitor1();
>
> new Node1().Accept(v, 1);
>
> }
>
>
>
> void Foo2()
>
> {
>
> var v = new ConcreteVisitor2();
>
> new Node1().Accept(v, "string");
>
> }
>
> }
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Результат будет таким:
Проходя через генерический визитор, R# не растерял информацию о подстановках параметров типа и смог отфильтровать лишний вызов из метода `Foo2`. В случаях, когда у вас создана развесистая иерархия и большое количество генеричесикх типов, подобная логика позволяет кардинально сократить область поиска.
Конструкторы
============
Теперь несколько искусственный пример с конструкторами и инициализаторами полей. Ищем исходящие вызовы из конструктора класса `Derived`:
> `class Base
>
> {
>
> public Base()
>
> {
>
> Base\_Bar();
>
> }
>
>
>
> void Base\_Bar()
>
> {
>
> }
>
> }
>
>
>
> class Derived : Base
>
> {
>
> int \_i = Foo();
>
>
>
> public Derived()
>
> {
>
> Bar();
>
> }
>
>
>
> void Bar()
>
> {
>
> }
>
>
>
> static int Foo()
>
> {
>
> return 0;
>
> }
>
> }
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Опять же ничего необычного. R# просто отображает натуральный порядок вызовов, не забывая про неявный вызов базового конструктора. Это позволит неопытному разработчику сэкономить массу времени на понимание кода, и будет полезным для усталого опытного.
Value Tracking. Вместо заключения.
==================================
И на закуску. Если вы посмотрите в меню *R# -> Inpect*, то обнаружите два очень интересных пункта “Value Origin” и “Value Destination”. Эти две функции реализуют Data Flow Analysys, т.е. позволяют отследить откуда пришло или куда уйдет значение переменной или параметра. Естественно, DFA работает с коллекциями и делегатами (отслеживает, что элемент был взят из коллекции и переходит к поиску обращений к коллекции) и совершенно незаменим при поиске причин `NullReferenceException`. К сожалению, это потребует от меня еще целой пачки скриншотов и примеров, поэтому подробнее я напишу об этом в следующей статье, а вы пока можете самостоятельно попробовать DFA и рассказать о том, что вам понравилось, а что нет. | https://habr.com/ru/post/83769/ | null | ru | null |
# Vue Storefront: оформление заказа
Пятый и завершающий пост о моём знакомстве с [Vue Storefront](https://www.vuestorefront.io/). IMHO, самым современным с технической точки зрения решением в сфере e-commerce на данный момент. Ссылки на предыдущие посты:
* [Vue Storefront: Второй подход к снаряду](https://habr.com/post/475940/)
* [Vue Storefront: Поднимаем backend](https://habr.com/post/476022/)
* [Vue Storefront: Заливаем данные в ES](https://habr.com/post/476316/)
* [Vue Storefront: Импорт каталога из Magento 2](https://habr.com/post/478544/)
Под катом краткое описание особенностей этого этапа и итоговое резюме.
Цель
====
Задачей на данном этапе являлось развёртывание компонентов приложения в максимально пригодном к использованию виде при условии его минимальной доработки. Т.е., я не изменял тему приложения и не добавлял собственных методов оплаты/доставок, а пользовался теми, что предлагали разработчики VSF. Успешным результатом являлось бы создание заказа в VSF и его просмотр в Magento (скриншот клиентского оповещения о создании заказа вынесен в шапку публикации).
Схема компонентов приложения
============================
Рабочее окружение
=================
В текущей итерации я опять использовал medium-версию сервера Linux Ubuntu 18.04 LTS 64-bit (2x 2198 MHz CPU, 4 GB RAM, 10GB disk) в облаке [Exoscale](https://www.exoscale.com/).
Развёртывание
=============
Скрипты по развёртыванию компонентов приложения для этого шага находятся в отдельной ветке: [flancer64/vsf\_mage2\_setup](https://github.com/flancer64/vsf_mage2_setup/tree/habr_05).
Шаги развёртывания и конфигурация аналогичны описанным в "[Импорт каталога из Magento 2](https://habr.com/ru/post/478544/)"
Что нового
==========
(по сравнению с предыдущими развёртываниями)
Web-сервер
----------
В этой развёртке я спрятал `vue-storefront` и `vue-storefront-api` за виртуальными хостами. По адресу [front.vsf.demo.com](http://front.vsf.demo.com/) находится прокси-сервер, пробрасывающий запросы на приложение `vue-storefront`, по адресу [api.vsf.demo.com](http://api.vsf.demo.com/) — прокси-сервер, пробрасывающий запросы на приложение `vue-storefront-api`. Таким образом, на плечи web-сервера можно переложить заботы по шифрованию траффика, сжатию контента, управлению инструкциями кэширования и т.п. На уровне web-сервера также можно организовать load balancing, если по каким-то причинам его нет желания делать на `pm2` (default опция для VSF).
Elasticsearch v 7.x
-------------------
Предыдущие развёртки, как и demo-версия самих VueStorefront, использовали сервер Elasticsearch версии 5.x. Но за то время, пока я разбирался с устройством VSF, разработчики [добавили](https://forum.vuestorefront.io/t/acceptable-elasticsearch-versions/826) возможность работы с версиями 7.x. При этом [изменилась](https://github.com/DivanteLtd/vue-storefront-api/tree/release/v1.11-rc1#elastic-7-support) структура данных, которую VSF использует с Elasticsearch 5.x и с Elasticsearch 7.x.
Локализация
-----------
В конфигурацию фронт- и api-приложений добавлены опции по их локализации (язык, страна, валюта, формат даты-времени и т.п.). Нужно отметить, что достаточное количество сообщений проскакивает на английском (видно на скриншоте в шапке).
Взаимодействие компонентов
==========================
Фронт-сервер отвечает за раздачу исходников самого PWA-приложения, API-сервер — за выдачу данных (в том числе и масштабированных изображений продуктов) по запросу PWA (из браузера клиента). Прямой связи между `vue-storefront` и `vue-storefront-api` я пока что не обнаружил (т.е., фронт-сервер:3100 не отправляет напрямую запросы на api-сервер:3130).
Для начала работы при помощи приложения `mage2vuestorefront` нужно залить данные в базу Elasticsearch. Процесс не очень быстрый, т.к. используется Magento REST API, но есть возможность сделать дамп импортированных данных из Elasticsearch и в следующий раз заливка данных будет происходить на порядок-два быстрее (можно использовать этот подход при развёртывании девелоперской и тестовой сред). Список сущностей, которые хранит Elasticsearch довольно невелик:
* ...\_attribute
* ...\_category
* ...\_cms\_block
* ...\_cms\_page
* ...\_product
* ...\_review
* ...\_taxrule
Изображения продуктов PWA тянет через API-сервер, который, в свою очередь, обращается к Magento-серверу, загружает изображение к себе, масштабирует его, а затем выдает браузеру клиента. Получается, что каждая картинка продукта опосредствованно подгружается с Magento-сервера. В PWA можно видеть, как изначально вместо изображений используются placeholder'ы, которые потом постепенно замещаются нормальными изображениями продуктов.
Аутентификация клиента в PWA прокидывается через API до Magento. Данные о клиентах (в том числе и пароли) VSF у себя не хранит (что видно и по списку сущностей в Elasticsearch чуть выше). Другими словами, в качестве самостоятельного e-commerce приложения VueStorefront использовать нельзя.
Создание заказа отработало вполне успешно, loader в PWA крутился до тех пор, пока заказ отправлялся в API, а затем, в несколько этапов (cart, items, addresses) переливался в Magento. Итого, процесс занял порядка 10 секунд, судя по API-логам (но у меня Magento-сервер стоит на другом континенте относительно тестовой среды для VSF). Вот скрин заказа из VSF в Magento:
Резюме
======
Самое современное с технической точки зрения решение в сфере e-commerce на данный момент не является самым совершенным. Более того, VueStorefront не может быть использовано как самостоятельное приложение (у него просто не предусмотрено хранилища для тех же клиентов). Зато VSF можно прикрутить к уже существующим e-commerce/ERP решениям ([платформам](https://github.com/DivanteLtd/vue-storefront-api/tree/master/src/platform/abstract) — в терминах VSF). Правда из идущих "в коробке" я [вижу](https://github.com/DivanteLtd/vue-storefront-api/tree/master/src/platform) только мосты к Magento 1 и Magento 2, но разработчики [утверждают](https://github.com/DivanteLtd/vue-storefront#integrations), что есть мосты и к другим решениям.
Также не очень волшебно дела обстоят с платёжными методами и методами доставки. О таком разнообразии методов, котрое предлагает на данный момент Magento, в VSF можно не мечтать ещё достаточно долго.
Тем не менее, само PWA приложение сделано качественно (особенно хорошо выглядит на смартфоне) и работает устойчиво (даже в условиях потери смартфоном соединения с интернетом). Виден огромный объём отличной работы, проделанной [авторами](https://github.com/DivanteLtd/vue-storefront/graphs/contributors). VueStorefront может использоваться в качестве реального интернет-магазина совместно с каким-либо backend'ом (Magento 1/2, Shopware6, Epi Server, Spree Commerce, Pimcore, Odoo ERP, BigCommerce, WooCommerce). В своё время я [задавался](https://habr.com/ru/post/310106/) вопросом "*Кто придёт на смену Magento?*" Я думаю, сейчас у меня уже есть ответ.
И напоследок скриншот того, как VSF выглядит в качестве desktop'ного приложения в Ubuntu:
 | https://habr.com/ru/post/485956/ | null | ru | null |
# Pintask — программируемый таск-трекер
Салют, Хабр!
По статистике, новый таск-трекер появляется раз в 2 недели. «Но мой умеет варить капучино!» — скажет вам разработчик. — «А другие трекеры делают чай такого же качества, как у проводницы поезда „Москва-Геленджик“, либо заваривают только Копи Лювак». Значит, если бы можно было перепилить краник, чтобы из него лилось капучино, вы бы не стали писать новый таск-трекер? «Ну конечно! Просто капучино — мой любимый напиток»…
О том, что общего между кофеварками и Оптимусом Праймом, зачем нам программируемый таск-трекер и как перепиливать краник — читайте под катом.
 В далеком 1969-м ситуация с микросхемами выглядела примерно так же, как текущая ситуация с трекерами. Хочешь выпустить калькулятор? Напечатай свою микросхему. Хочешь выпустить калькулятор с функцией умножения на 1000 (для бразильских бухгалтеров)? Напечатай еще одну микросхему. Именно этой логикой руководствовались японцы, заказавшие Intel аж 12 микросхем для своих калькуляторов. Штатная рок-звезда компании, Тед Хофф, окинул опытным взглядом чертежи и предложил рефакторинг. Затем, как и полагается рок-звезде, он скипнул сам процесс, поручив реализацию идеи Федерико Фаггину. Менеджмент благополучно забил на проект, так как в тот момент люто-бешено развивалось совсем другое направление, и заработать на Бентли можно было именно там. Это сильно ускорило разработку, и уже в 1971-м ~~программеры~~ электротехники закончили тесты и ~~выкатили на продакшн~~ запустили в серию. Intel с фанфарами выполнила заказ японцев и под шумок открыла новое направление бизнеса. Через несколько лет рынок микропроцессоров *внезапно* стал настолько прибыльным, что на Бентли зарабатывали уже там.
Перенесемся в наше время, где миром правит страсть к кофе и каждый день выходят новые таск-трекеры. Ситуация сама собой напрашивается на *рефакторинг*. Представляется логичным написать такой трекер, в котором можно «перепилить любой краник», открутить или, наоборот, закрутить посильнее каждую гайку, заменить термостат и поставить регулятор пара, чтобы в конце концов сварить любимый напиток. Именно такой — программируемый таск-трекер — и есть [Pintask](https://pintask.me/).
#### Немного сантехники
ЕСЛИ ЧЕСТНО, появление микропроцессора было теоретически возможным уже в начале 1960-х, когда стали массово производиться интегральные микросхемы. Однако, любого юного электротехника на этом пути подстерегали технологические препятствия 80-го уровня. Федерико Фаггин знал о них не понаслышке. Но и докторская степень по физике досталась ему не в переходе московского метрополитена, а в Падуанском университете. Поэтому в 1968-м году Федерико создал первый полевой транзистор на кремниевой основе, который работал быстрее других, биполярных, да еще и занимал меньше места, стоил дешевле, экономил электроэнергию. Теперь можно было ~~не выключать свет в туалете~~ не беспокоиться об оптимальности микросхем: калькуляторы на микропроцессорах складывали и умножали быстрее своих предшественников просто потому, что работали на полевых транзисторах. Ну и ценник на них был ниже, что при закупке устройств на всю бразильскую бухгалтерию весьма и весьма ощутимо.
За оценкой ситуации обратимся к мировому эксперту по инновациям:
— Господин Форд, как вы считаете, будет ли микропроцессорная технология развиваться дальше, или производители биполярных транзисторов найдут способ повернуть время вспять?
— Я убежден, что инновации на более низком уровне способны изменить существующую отрасль. На мой взгляд, речь идет именно об этом.
— Большое спасибо за комментарий. А теперь к новостям из мира науки. Астрономы сообщают о необычном космическом фоне…
[Pintask](https://pintask.me/) написан на [Meteor](https://www.meteor.com/). Этот фреймворк уже входит в число самых популярных репозиториев на Github в весовой категории JavaScript — и это еще до официального релиза (текущая версия: 0.8). Один только анонс на Hacker News собрал 1362 голоса. Выдержки из комментариев: «It's like the industrial revolution», «I can't upvote this enough» — ну, вы поняли. Даже скушав полпачки скептицина, можно смело утверждать, что Meteor открывает новую страницу в веб-разработке. Причем HTML-код на этой странице «живой»: получение новых данных от сервера приводит к автоматическому обновлению шаблона, вам не нужно следить за этим. Ах да, и забудьте про Ajax-запросы: изменение данных выполняется через полноценное MongoDB API на JavaScript, доступное прямо в браузере. В результате 90% вычислений выполняются на клиенте. Код на Meteor ~~занимает меньше места~~ имеет меньший объем, ~~стоит дешевле~~ пишется быстрее, ~~экономит электроэнергию~~ уменьшает объем передаваемых данных. Марти, ты опять играл с плутонием?
Давайте разберемся, что получается. Доступ к базе данных есть прямо в браузере, это раз. Шаблоны тоже в браузере, это два. Все работает на JS+HTML, это три. А что если дать пользователю возможность **подключить свои скрипты**? Ведь с их помощью можно и слушатели навесить, и шаблоны переопределить, и данные записать… и перепилить краник. И гайки закрутить. И термостат поставить.
#### Всем по капучино
Pintask — первый таск-трекер, написанный на Meteor. И первый таск-трекер, способный загружать ваши расширения прямо в браузере, предоставляя им полный доступ к API базы данных и шаблонам.
[Вот пример](https://github.com/DenisGorbachev/master-of-dialogue-pintask-plugin) одного такого расширения:
```
if !Cards
throw "Hey, where are my Cards?"
if !Comments
throw "Look, I need those Comments, too!"
Comments.after.insert (userId, comment) ->
cardId = comment.cardId
card = Cards.findOne(cardId)
if userId not in card.memberIds
Cards.update(cardId, {$addToSet: {memberIds: userId}})
```
*За последнее время я пристрастился к CoffeeScript… не мейнстрим, конечно, но разработку ускоряет.*
Эту нехитрую автоматизацию можно собрать-разобрать с завязанными глазами. В начале заметна пара проверок на случай ядерной войны (если наш скрипт призовут на другой сайт). Потом идет установка мины замедленного действия, срабатывающей при вставке комментария. В случае, если наступивший не является членом карточки, его забрасывает туда ударной волной.
Хотите посмотреть на работу с шаблонами? [Их есть у меня](https://github.com/DenisGorbachev/visionary-pintask-plugin). Тут замешан jQuery, на первый взгляд код напоминает итальянское блюдо. Но если приступить к его поглощению с нижнего края, то вкус раскроется более гармонично, и тогда… «Официант, повторите!»
Отдельно стоит упомянуть о подключении внешних источников данных. Белая магия позволяет создавать задачи из строк Google Spreadsheet. А черная магия с привлечением потустороннего API дает возможность призывать Github Issues прямо в Pintask и устраивать сеанс двунаправленной связи между комментариями внутреннего и внешнего трекера. Все это происходит через коллекции MongoDB. По сути, такое расширение является отдельным приложением, загружающим данные в Pintask при помощи специального скрипта.
#### За барной стойкой
Кстати, подключить собственное расширение можно через тот же Github. В простейшем случае достаточно опубликовать репозиторий на Github Pages, взять прямую ссылку на js-файл и вставить в Pintask. Получается сухо и комфортно (и обновляется при поступлении коммита).
А если нужно подключить целое приложение со своим блэкджеком, то можно выложить на бесплатный хостинг от того же Meteor, и вставить ссылку на него.
Для пользователя все выглядит еще проще. Достаточно зайти в [Магазин расширений](https://pintask.me/store), выбрать желаемое, нажать волшебную кнопку — и легким движением руки кофеварка превращается в Оптимуса Прайма.
Так как программисты — люди щедрые, то можно с уверенностью сказать: большинство приложений будут бесплатными. Но если жаба-таки задушит, или понадобится больше древесины (объемное файлохранилище, СМС-шлюз), то можно сделать пользователю приложение, от которого он не сможет отказаться. Мы сами так и зарабатываем.
#### Сверим часы
О! Вот и оно, платное приложение: [Учет времени на автопилоте](https://pintask.me/extension/hands-free-time-tracking). Всем известно, как сложно программистам дается тайм-трекинг. Побродив по извилинам нашего разума, можно встретить подобный внутренний диалог:
— Эй, сознание! Давай-ка подумаем над интеграцией с Яндекс.Маркетом.
— Погоди-погоди… А кнопочку «старт» нажать не забыл?
— Ах, точно. Вот, нажал.
— Молодец. Так что ты там говорил о Bitcoin?
— Какой Bitcoin? Я говорил о Яндекс.Маркете.
— Ах, да… постой, а ты нажимал кнопочку «старт» у предыдущей задачи?
— Кажется, да. Или нет. Сейчас проверю.
— Давай проверяй. А я тут пасьянс разложу.
Чтобы не ходить к психоаналитику, мы решили изменить привычный механизм учета времени и отказались от кнопки «Старт». Вместо нее мы поставили иконку «Включить учет времени» в заголовке каждого списка. Тайм-трекинг стартует автоматически при входе в систему и начинает слежение за первой задачей в отмеченном списке. Когда задача архивируется или переносится в другой список, тайм-трекинг переключается на следующую задачу по принципу обоймы. В результате программист даже не задумывается об учете времени. Он просто выполняет свою работу, а система автоматически фиксирует временные интервалы.
Техническая реализация использует стандартные механизмы Meteor и пакет user-status для мониторинга активности. Уже знакомые слушатели на коллекциях MongoDB позволяют определить отслеживаемую задачу. В коде не используются setTimeout (свят, свят), только события. В результате даже рестарт сервера не способен нарушить ход истории.
Хотите получать аккуратные отчеты? [Заходите, не стесняйтесь](https://pintask.me/extension/hands-free-time-tracking).
#### На десерт
Сколько же стоит базовая платформа? Pintask полностью бесплатен. У нас нет ограничений функционала, нет рекламы, нет абонентской платы. Зато есть [открытая вики](http://wiki.pintask.me/wiki/Main_Page), [добросовестная поддержка](http://wiki.pintask.me/wiki/Support) и овечки на фоне.
Ну и последнее: Pintask стремится к тому, чтобы стать полной заменой Trello (англ. «drop-in replacement»). Все базовые функции заморского сервиса уже реализованы. Есть моментальный [импорт из Trello](https://pintask.me/import/from/trello). Мы также собираемся сделать *двунаправленную синхронизацию*, чтобы обеспечить доступ к Pintask через мобильные приложения Trello (до того, как сделаем собственные).
В следующих статьях мы планируем рассказать о процессе разработки продукта и нюансах использования внутреннего API. Сейчас будет занавес, а нужно ли выходить на бис — решать вам.
Финальная ссылка: [**Pintask**](https://pintask.me/), программируемый таск-трекер.
*Статья опубликована мною по просьбе Дениса Горбачева ([starfall](http://habrahabr.ru/users/starfall/)), весь текст — полностью авторский.* | https://habr.com/ru/post/218091/ | null | ru | null |
# Splunk 7.0. Что нового?
Месяц назад компания Splunk на своей 8-ой ежегодной конференции [Splunk Conf 2017](http://conf.splunk.com) презентовала выпуск нового мажорного релиза Splunk 7.0. В этой статье мы расскажем об основных нововведениях и улучшениях платформы, а также покажем пару примеров.
Метрики
-------
В новом релизе Splunk вводит отдельный тип данных для индексации — метрики. Это в большинстве своем технологические данные, описывающие конкретный процесс или систему, а точнее их состояние. Это всем известные показатели, такие как: величина загрузки процессора, объем свободной оперативной памяти или места на диске, показатели AWS (Amazon Web Service), IoT и многое другое. Полный список доступен [здесь](http://docs.splunk.com/Documentation/Splunk/7.0.0/Metrics/Overview). Стоит сказать лишь одно, чтобы загрузить метрики в Splunk у них должно быть три обязательных поля: время, название метрики и значение, остальное опционально, см. картинку ниже.
Также, при создании нового индекса, теперь нужно указывать, что это данные с метриками а не просто логи. Из коробки доступны забор таких sourcetype, как [StatsD](http://docs.splunk.com/Documentation/Splunk/7.0.0/Metrics/GetMetricsInStatsd) и [collectD](http://docs.splunk.com/Documentation/Splunk/7.0.0/Metrics/GetMetricsInCollectd), для [остального](http://docs.splunk.com/Documentation/Splunk/7.0.0/Metrics/GetMetricsInOther) нужно будет конфигурировать [transforms.conf](http://docs.splunk.com/Documentation/Splunk/7.0.0/Admin/Transformsconf) и [props.conf](https://docs.splunk.com/Documentation/Splunk/latest/admin/Propsconf), но это не сложно.
Новые SPL команды для метрик
----------------------------
Для работы с метриками Splunk сделал новые команды [mstats](http://docs.splunk.com/Documentation/Splunk/7.0.0/SearchReference/Mstats) и [mcatalog](http://docs.splunk.com/Documentation/Splunk/7.0.0/SearchReference/Mcatalog). Правда *mcatalog* пока официально не поддержиается, поэтому мы покажем только примеры запросов с mstats, которая как вы уже поняли сильно похожа на *stats*, глбальным отличием от *stats* является то, что поиск начинается сразу с pipe line |, а не с фильтрации.
Посчитаем среднюю скорость:
```
| mstats avg(_value) WHERE metric_name="car.speed" AND driver_id="*" span=1m
```
Добавим разделение по car\_ip, для этого используем дополнительно timechart:
```
| mstats avg(_value) prestats=t WHERE metric_name="car.speed" AND driver_id="*" span=1m BY car_ip
| timechart avg(_value) AS speed span=30m BY car_ip
```
**Зачем все это нужно?**
Хороший вопрос, ведь раньше все тоже самое можно было делать с помощью обычной индексации, timechart и stats, и все работало. На самом деле ответ очевиден — это скорость. Для метрик, скорость обработки поисковых запросов, по заявлению разработчиков, возрастает в 20 раз и при этом уменьшается общая нагрузка на систему. Впечатляет, не правда ли?
Улучшение визуализации
----------------------
Теперь на графики можно добавлять аннотации, Splunk так и назвал эту фичу [Event Annotation](https://docs.splunk.com/Documentation/Splunk/7.0.0/Viz/ChartEventAnnotations). Правда стоит сразу отметить, что она работает только с *line charts, column charts, и area charts.*
Цвет можно выбирать, сообщение в аннотации может быть как статичным, так и формироваться из конкретного поля события, ну и понятно, что аннотация — это отдельный запрос в том же временном интервале что и главный запрос. Все это делается очень просто, стоит только дописать пару строчек в исходный xml дашборда. Ниже пример, ну а подробно об этом [здесь](https://docs.splunk.com/Documentation/Splunk/7.0.0/Viz/ChartEventAnnotations).
Обновленный Machine Learning Toolkit
------------------------------------
Основным обновлением ML Toolkit является добавление в него нового алгоритма — [ARIMA](http://docs.splunk.com/Documentation/MLApp/2.3.0/User/Algorithms#ARIMA), что очень сильно приближает его к реальному Machine Learning. Помимо этого была расширена ролевая модель, теперь каждый пользователь может сохранить свои наработки отдельно, а также расширен API, о нем подробно [здесь](http://docs.splunk.com/Documentation/MLApp/2.3.0/API/Introduction).
Итого
-----
Понятно, что в данном релизе есть еще масса различных фич, таких как: обновленная *Monitoring Console, Chart Enhancements, Report Action Enhancements*, общая оптимизация работы платформы и ускорение поиска и многое другое, но мы старались рассказть про наиболее важные и интересные нововведения.
Дополнительно
-------------
Для наиболее глубокого изучения вопроса стоит установить приложение [Splunk Enterprise 7.0 Overview](https://splunkbase.splunk.com/app/3691/), а также посмотреть официальное [видео](https://www.youtube.com/watch?v=j4nKdZgncF4) релиза.
Также, не забывайте, что по любым вопросом относительно Splunk: его внедрения, разработки на нем приложений, добавления новых, сложноиндексируемых событий и всего прочего вы можете [обращаться](https://tssolution.ru/splunk/) за помощью к нам через наш сайт. | https://habr.com/ru/post/340120/ | null | ru | null |
# Классические алгоритмы генерации лабиринтов. Часть 1: вступление
**Предисловие
-----------**
На написание статьи меня сподвигло практически полное отсутствие материалов на русском языке про алгоритмы генерации лабиринтов. На Хабре, из того, что вообще есть по теме, можно отметить две статьи: [раз](https://habrahabr.ru/post/176671/) и [два](https://habrahabr.ru/post/262345/). Ценность и пользу из которых несет лишь вторая. В первой – просто перевод формального алгоритма и небольшое его пояснение. Что, конечно, неплохо, но очень скудно и не вызывает желания изучать тему дальше.
Если моя статья Вам понравится, я продолжу писать о различных алгоритмах. Мы рассмотрим два самых примитивных и простых случая – генерация двоичного дерева и Сайдвиндер, который, по своей сути, просто чуть измененная версия двоичного дерева с одним заметным плюсом. **ОСТОРОЖНО ТРАФИК**.
Дам один совет – не подглядывайте в код до тех пор, пока вы не напишите свою реализацию. Вы получите гораздо больше удовольствия и пользы от исправления багов и поиска ошибок, чем если просто переведете с одного языка на другой.
Серьезно. Прислушайтесь к совету. Вы, верно, потратите больше времени, но оно стоит стоит. У меня, например, из-за пары ошибок появился очень забавный генератор «инопланетных» текстов, который можно использовать в различных Sci-Fi играх для создания текста. Надеюсь, Вы изучаете тему для себя и никуда не спешите.
**P.S.:**
Я буду использовать термин «**смещение**», предполагая английский bias. Т.е. пристрастие алгоритма к направленности в какую-либо сторону. Например, правое смещение – алгоритм генерирует лабиринты с длинными правыми проходами.
Раскраска лабиринтов происходит относительно расстояния от крайнего левого угла поля до некоторой клетки. Чем дальше от начальной координаты – тем темнее будет цвет.
**Идеальный лабиринт** – такой лабиринт, в котором одна клетка связана с другой одним единственным путем. Иначе говоря, остовное дерево.
**Про Lua**Когда я только начинал закапываться в тему лабиринтов, я не предполагал, что в итоге буду писать статью и выбрал язык, на котором у меня есть возможность не тратить слишком много времени на рендер и архитектуру и заниматься исключительно логикой. В итоге, между C++ и Lua, выбор пал на Lua и Love2D.
Не стоит переживать, если Вы с Луа незнакомы. Незнание языка никак не помешает Вам понять реализацию, благодаря простоте синтаксиса. Если Вы хотя бы немного умеете программировать, 80% кода не вызовет у Вас проблем с пониманием. Остальные 20% — language specific, про которые я всегда буду писать вначале статьи, объясняя их работу.
Первое, что мне следует сказать:
Lua имеет лишь одну структуру данных – таблицы – ассоциативный массив, при помощи которого мы создаем нужные нам структуры. К примеру, классы, множества, обычные массивы, стаки, очереди и тому подобное. Обращаться к ним мы может либо с помощью строчных-ключей, либо с помощью индексов.
Так же, таблицы не ограничивают нас в хранении только одного типа данных в одном объекте и работают подобно структурам в C/C++. Такой код абсолютно корректен:
```
ourStructure = {}
ourStructure[“BeautyKey”] = 42
ourStructure[42] = “UltimateAnswer”
ourStructure[1] = false
```
Присваивание nil удалит поле:
```
ourStructure[42] = nil
```
Второе:
Lua не имеет скрытого механизма копирования таблиц. Код, приведенный ниже, не будет копировать и создавать нового объекта SomeNewArray, он лишь скопирует в него ссылку на объект SomeArray, и, следовательно, будет изменять его точно так же, как если Вы передадите значение через неконстантную ссылку или указатель в C/C++:
```
someArray = {}
someArray[1] = 42
someArray[2] = “ReferencesTest”
someNewArray = someArray
someNewArray[1] = “42 Is Gone, Now Only the Garbage-String here”
```
И третье, для тех, кто хорошо знаком с Lua:
Да, я знаю, что в некоторых местах код избыточен. И то, что в некоторых местах всё можно было бы упростить метаметодами тоже. Следует учитывать то, что код писался в первую очередь для того, чтобы разобраться с алгоритмами, а не для использования в реальном проекте. К тому же, отсутствие избытка специфических для языка функций позволяет выкладывать код в том виде, в котором он есть, без нагромождений комментариев.
**Алгоритм двоичного дерева
-------------------------**
**Описание**:
Самый первый и самый простой алгоритм в понимании, который я рассмотрю. Его суть заключается в том, чтобы проложить путь в случайном направлении из каждой клетки поля: в моей реализации либо наверх, либо вправо (зависит от выбранного Вами смещения). Мы обрабатываем только 1 клетку за единицу времени, следовательно, мы можем генерировать лабиринты бесконечного размера, сохраняя лишь конечный результат (лабиринт) без необходимости хранить какую-либо побочную информацию.
Такой способ генерации имеет два побочных эффекта:
1. Лабиринты обладают сильным диагональным смещением и отсутствием тупиков в его направлении. Посмотрите на скриншоты выше и Вы увидите, что каждый из коридоров стремится к правой верхней клетке, и, как итог, имеет ровно один путь к ней, и нигде на пути нет тупика:
2. Два пустых коридора по сторонам лабиринта. Когда алгоритм «прокапывается» до конца строки/столбца, ему не остается выбора, кроме как продолжить путь в одном единственном направлении, создавая пустые «границы».
К слову, название не просто так совпадает со структурой данных. Результат его работы – случайное двоичное дерево, в котором из каждой клетки (вершины) есть ровно 1 путь по направлению к корню (родительской вершине), и, соответственно, ровно 1 путь к любой другой клетке. Как следствие, любая клетка имеет не более 3 соединений со своими соседями.
**Формальный алгоритм (для северо-восточного смещения):**
1. Выбрать начальную клетку;
2. Выбрать случайное направление для прокладывания пути. Если соседняя клетка в этом направлении выходит за границы поля, прокопать клетку в единственно возможном направлении;
3. Перейти к следующей клетке;
4. Повторять 2-3 до тех пор, пока не будут обработаны все клетки;
**Пример работы**Зеленое – текущая рассматриваемая клетка, красное – фронт, клетки, в которые можно переместиться.
Начинаем с координаты (0;0). Наверх в этом ряду пойти не можем, так как иначе выйдем за границы лабиринта. Идем вправо до упора, по пути снося все стены.
Всё, тупик. Идти некуда. Перемещаемся на следующий ряд и видим, что теперь есть возможность пойти наверх и вправо.
Кидаем монетку и выбираем… Верх. Убираем стену и переходим к следующей клетке.
Отлично. Случай подсказывает нам идти направо. Убираем стену и перемещаемся в следующую клетку.
Выбора у нас нет, налево пойти не можем, значит, убираем стену сверху и идем на следующий ряд.
Монета убеждает нас пойти направо. Что же, слушаемся. Убираем стену и переходим к слеудующей клетке.
Прокатившись метр, наш несчастный кусок металла падает и говорит, что пора идти наверх. Сносим стену, шагаем к следующей клетке, и, так как она крайняя в этом ряду, убираем стену сверху. Лабиринт закончен.
**Плюсы**:
* Простая реализация;
* Высокая скорость работы;
* Возможность генерировать бесконечные лабиринты;
**Минусы**:
* Низкая сложность рисунка;
* Сильное смещение по диагонали;
* Отсутствие тупиков по смещению;
* Однообразность сгенерированных лабиринтов;
**Реализация**
```
local mod = {}
local aux = {}
aux.width = false
aux.height = false
aux.sx = false
aux.sy = false
aux.grid = false
function aux.createGrid (rows, columns)
local MazeGrid = {}
for y = 1, rows do
MazeGrid[y] = {}
for x = 1, columns do
MazeGrid[y][x] = {bottom_wall = true, right_wall = true} -- Wall grid
end
end
return MazeGrid
end
-- Binary Tree North-East variant
function mod.createMaze(x1, y1, x2, y2, grid)
aux.width, aux.height, aux.sx, aux.sy = x2, y2, x1, y1
aux.grid = grid or aux.createGrid(aux.height, aux.width)
aux.binarytree()
return aux.grid
end
function aux.binarytree()
for y = aux.sy, aux.height do
for x = aux.sx, aux.width do
if y ~= aux.sy then
if math.random(0, 1) == 0 then
if x ~= aux.width then
aux.grid[y][x].right_wall = false
else
aux.grid[y-1][x].bottom_wall = false
end
else
aux.grid[y-1][x].bottom_wall = false
end
else
if x ~= aux.width then
aux.grid[y][x].right_wall = false
end
end
end
end
end
return mod
```
**Алгоритм «Sidewinder»
---------------------**
**Описание**:
Алгоритм с непереводимым названием Sidewinder по своей работе очень похож на алгоритм двоичного дерева, в том отличии, что в нём нет характерного смещения по диагонали, одного пустого коридора и клетки мы рассматриваем не по отдельности, а множествами. Лабиринты получаются с преимущественно вертикальным или горизонтальным смещением (в зависимости от реализации), с отсутствием тупиков в их направлении. В сравнении со своим более примитивным собратом, смещение не так заметно и больше похоже на «спираль», которая плавно сменяет вертикальные и горизонтальные коридоры.
Что касается побочных эффектов, то Sidewinder создает только один пустой коридор на одной стороне, вместо двух. Начиная создание множеств с первого ряда поля, у нас отсутствует возможность прокопать путь наверх, так как мы находимся в самом крайнем вертикальном положении и попытка пойти выше приведет к выходу за границы поля. Но и если мы будем организовывать множества без выхода по вертикали, мы создадим несколько изолированных друг от друга областей.
Для примера: 9 клеток первого ряда можно поделить на три множества, между которыми расположены стены. Каждое множество второго ряда будет прокапывать путь к одному из трех «блоков» выше. Третий ряд проложит путь к «блокам» второго. И так до конца поля. В итоге, у нас получатся 3 разветвленные, изолированные друг от друга вертикальные области, что не подходит для идеального лабиринта, в котором из каждой точки поля есть ровно 1 путь в любую другую.
**Формальный алгоритм (для стандартного смещения):**
1. Выбрать начальный ряд;
2. Выбрать начальную клетку ряда и сделать её текущей;
3. Инициализировать пустое множество;
4. Добавить текущую клетку в множество;
5. Решить, прокладывать ли путь направо;
6. Если проложили, то перейти к новой клетке и сделать её текущей. Повторить шаги 3-6;
7. Если не проложили, выбираем случайную клетку множества и прокладываем оттуда путь наверх. Переходим на следующий ряд и повторяем 2-7;
8. Продолжать, пока не будет обработан каждый ряд;
**Пример работы**Красные клетки – члены множества.
Мы начинаем с первого ряда и видим, что выше нас – выход за пределы поля. Сносим все стены и идем сразу во второй ряд, создаем пустое множество.
Так, а вот тут интереснее. Давайте добавим в множество первые две клетки ряда.
Выбираем одну из этих клеток и убираем относящуюся к ней верхнюю стенку в первый ряд.
Обнуляем множество, добавляем в нее следующую клетку ряда.
В этот раз ни с кем не объединяем, просто прокладываем путь наверх прямо из этой единственной клетки.
Повторяем наши действия. Обнуляем множество, переходим в следующую клетку, добавляем её… А так как она осталась последней в ряде, то так же убираем стену сверху и идем в ряд ниже.
А теперь сразу объединяем три первые клетки в одно множество.
Случайно выбираем клетку, в нашем случае, вторую и убираем стену сверху к предыдущему ряду.
Ну, тут у нас опять нет выбора, убираем стену наверху и идем на ряд ниже.
На этот раз, самую перваую клетку мы сделаем единственной. Убираем стену к предыдущему ряду и идем дальше, в следующую клетку.
Предположим, что захотели в конце объединить три клетки.
И снова нам приглянулась средняя клетка из множества, из которой и убираем стену наверх. Всё, наш лабиринт готов.
**Плюсы**:
* Возможность генерировать бесконечные лабиринты;
* Только 1 пустой коридор;
* Более сложный рисунок, в отличии от алгоритма двоичного дерева;
**Минусы**:
* Более запутанная реализация;
* Отсутствие тупиков по смещению;
* Сильное вертикальное смещение;
**Реализация**
```
local mod = {}
local aux = {}
aux.width = false
aux.height = false
aux.sx = false
aux.sy = false
aux.grid = false
function aux.createGrid (rows, columns)
local MazeGrid = {}
for y = 1, rows do
MazeGrid[y] = {}
for x = 1, columns do
MazeGrid[y][x] = {bottom_wall = true, right_wall = true}
end
end
return MazeGrid
end
function mod.createMaze(x1, y1, x2, y2, grid)
aux.height, aux.width, aux.sx, aux.sy = y2, x2, x1, y1
aux.grid = grid or aux.createGrid(y2, x2)
aux.sidewinder()
return aux.grid
end
function aux.sidewinder()
local cx = aux.sx --[[ cx – координата начала множества по x. У нас нет надобности создавать отдельный массив для сета, так как его элементы всегда располагаются строго в ряд ]]
for y = aux.sy, aux.height do
for x = aux.sx, aux.width do
if y ~= aux.sy then
if math.random(0, 1) == 0 and x ~= aux.width then
aux.grid[y][x].right_wall = false
else
aux.grid[y-1][math.random(cx, x)].bottom_wall = false
if x ~= aux.width then
cx = x+1
else
cx = aux.sx
end
end
else
if x ~= aux.width then
aux.grid[y][x].right_wall = false
end
end
end
end
end
return mod
```
**Эпилог
------**
Надеюсь, Вам понравилась статья и Вы почерпнули новые знания о примитивной процедурной генерации лабиринтов. Я выбрал два самых простых в реализации и работе алгоритма, чтобы новичкам было проще «пощупать» тему и понять, хотят ли они изучать её дальше. Мне важно знать, интересны ли такие статьи людям на Хабрахабре и стоит ли продолжать их писать. Для читателей у меня есть еще минимум 9 классических алгоритмов, которые стоит рассмотреть. Какие-то представляют из себя случайное блуждание по полю, как, например, алгоритм Прима или Уилсона, какие-то требуют больше ресурсов для работы, так как работают с графами, например, Эллер и Крускал, а какие-то выдерживают золотую середину. Но и это не конец – у меня в рукаве есть такие вещи, как: полярные (круглые) лабиринты, генерация лабиринтов на различной сетке (гексы, треугольник и пр.), маскинг лабиринтов в надписи и формы, 2.5Д лабиринты и 3Д, теория лабиринтов, статистическое сравнение алгоритмов, комбинированные алгоритмы генерации. В конце концов, у нас есть еще огромное множество вариаций типов лабиринтов. Например, сейчас мы рассматриваем идеальные алгоритмы, в которых из каждой точки есть ровно один путь в любую другую. Но ведь есть еще и те, которые позволяют одной клетке иметь несколько путей для любой другой! Например, Quake, Doom и прочие шутеры в только-только зарождающемся жанре использовали такие алгоритмы для генерации уровней, по некоторым слухам.
Поэтому, если Вам понравилась статья, тема, и Вы хотите видеть их дальше – то, пожалуйста, напишите об этом в комментарии. Так же, буду очень рад любой критике, как в техническом плане, так и в лингвистическом и стилистическом. | https://habr.com/ru/post/320140/ | null | ru | null |
# Перелистывающийся баннер с кнопками навигации и прогрессбаром: используем плагин Cycle2 для jQuery
При работе над веб-проектом поступило задание от заказчика сделать особый баннер на главной странице сайта.
Баннер должен удовлетворять таким требованиям:
1. Баннер представляет собой несколько изображений, они автоматически перелистываются спустя некоторый интервал времени. В нашем примере баннеров 5.
2. Каждая картинка-баннер является активной ссылкой на ту или иную страницу сайта (например, со специальными предложениями).
3. Под баннером расположены кнопки переключения баннеров. Кнопка, соответствующая текущему баннеру, выделена другим цветом (блок 1 на рисунке).
4. Под баннером и над кнопками располагается прогрессбар: цветная линия, плавно движущаяся слева направо по мере показа каждого баннера. По аналогии с прогрессбаром в программе-видеоплеере при воспроизведении ролика. Это блок 2 на рисунке.
Вот что нарисовал дизайнер, и требовалось реализовать:
Нашлась подходящая библиотека: это плагин Cycle2 для jQuery.
Ссылка на сайт плагина с подробной документацией и примерами: <http://jquery.malsup.com/cycle2/>.
Ссылка на страницу скачивания плагина: <http://jquery.malsup.com/cycle2/download/>.
**Реализация баннера**
Ознакомиться со всеми тонкостями и настройками при использовании плагина Cycle2 вы можете на странице документации: <http://jquery.malsup.com/cycle2/api/>, либо изучив примеры: <http://jquery.malsup.com/cycle2/demo/>. Мы же разберем решение только нашей задачи.
В секции head страницы добавим ссылки на jQuery и Cycle2. На нашем сайте они лежат в каталоге /js/:
```
```
HTML-код для пяти баннеров на странице выглядит так:
```
[](/page1.html)
[](/page2.html)
[](/page3.html)
[](/page4.html)
[](/page5.html)
```
Разберем html-код.
Блок баннера заключен в тег div c id= «content-ob». Этот id мы используем в css-файле для задания некоторых индивидуальных параметров расположения блока, не имеющих отношения к нашей статье.
* Атрибут
```
class= "cycle-slideshow"
```
отвечает за преобразование нашего блока в листающийся баннер. Этот атрибут важен, при его наличии библиотека Cycle2 преобразует блок.
* ```
data-cycle-fx= "scrollHorz"
```
— укажем способ перелистывания баннеров по горизонтали.
* ```
data-cycle-timeout= "10000"
```
— время показа каждого баннера в миллисекундах, т.е. у нас 10 секунд на показ баннера.
* ```
data-cycle-speed= "1000"
```
— время на анимацию перелистывания баннера, 1 секунда.
* ```
data-cycle-slides= "a"
```
— этот атрибут указывает, в каком вложенном теге содержатся перелистываемые блоки. Т.к. мы листаем блоки
```
[](/pageX.html)
```
, то указан тег a.
* ```
data-cycle-pager= ".custom-pager"
```
— селектор для блока навигационных кнопок. Мы используем нестандартный блок, т.к. стандартный блок нам не подходит по дизайну.
* ```
data-cycle-pager-template= " "
```
— шаблон кнопки навигации.
Как нетрудно догадаться, строки вида:
```
[](/page1.html)
[](/page2.html)
...
```
являются переключаемыми баннерами со ссылками на страницы сайта.
Код — блок для отрисовки прогрессбара.
Код — блок для отрисовки кнопок навигации.
**Рассмотрим CSS-стили для нашего баннера**
```
.custom-pager{
/*стиль блока навигации*/
margin-left:435px;
margin-top:5px;
overflow:hidden;
}
a.custom-pager-button{
/*стили неактивной кнопки навигации*/
display:block;
float:left;
margin-right:5px;
width:29px;
height:13px;
overflow:hidden;
background-image:url(/img/newdis/ob-in.png);
background-position:left top;
background-repeat:no-repeat;
cursor: pointer;
}
.custom-pager a.cycle-pager-active{
/*стили для активной кнопки навигации*/
background-image:url(/img/newdis/ob.png) !important;
cursor: pointer;
}
.custom-pager > * { cursor: pointer;} /*курсор при наведении на кнопки навигации - как у ссылки*/
#progress {
/*стиль для прогрессбара*/
margin-top:3px;
height: 3px;
width: 0px;
background: #860b70;
z-index: 500;
}
```
С этими параметрами у нас будет работать все, кроме прогрессбара.
Для реализации прогрессбара был доработан код из примера к Cycle2: <http://jquery.malsup.com/cycle2/demo/progress.php>.
**Реализация анимации прогрессбара**
В примере прогрессбар движется от 0 до 100% при показе каждого баннера. Нам же необходимо, чтобы прогрессбар был похож на воспроизведение видео в видеоплеере — двигался бы плавно от 0 до 100% по мере показа всех пяти баннеров.
Вот что получилось в результате:
```
var progress = $('#progress'),
slideshow = $( '.cycle-slideshow' );
/*перед переключением баннера - приостановим движение прогрессбара
в его текущем положении*/
slideshow.on( 'cycle-initialized cycle-before', function( e, opts ) {
if(opts.slideNum==undefined) number=1; /*на первом баннере вместо номера баннера
возвращается undefined, подставим первый номер*/
else number=opts.slideNum;
number--;
w=Math.round(100*number/opts.slideCount); /*вычислим текущее положение прогрессбара
в % относительно предыдущего баннера*/
progress.stop(true).css( 'width', w+'%' ); /*остановим анимацию прогрессбара
в найденном положении*/
});
/*
после переключения баннера - возобновим анимацию
от текущего положения прогрессбара к его положению относительно следующего баннера
*/
slideshow.on( 'cycle-initialized cycle-after', function( e, opts ) {
if(opts.slideNum==undefined) number=1;/*на первом баннере вместо номера баннера
возвращается undefined, подставим первый номер*/
else number=opts.slideNum;
w=Math.round(100*number/opts.slideCount); /*найдем положение прогрессбара в %
относительно текущего баннера*/
if(w>100) w=100; //заглушка на случай ошибки
/*возобновим анимацию прогрессбара с текущего положения до положения в %
относительно следующего баннера*/
progress.animate({ width: w+'%' }, opts.timeout, 'linear' );
});
```
Как видно из комментариев к коду, используются обработчики двух событий: начала анимации переключения баннера и конца анимации переключения баннера. В обработчики передается объект opts, содержащий свойства блока баннеров.
В обработчике начала переключения баннера мы останавливаем анимацию в положении предыдущего баннера, т.е. баннера, который был до переключения.
Затем, в обработчике конца переключения баннера мы возобновляем анимацию от текущего ее положения к положению относительно текущего баннера, т.е. баннера, который появился после переключения.
Индекс текущего баннера мы можем узнать с помощью свойства opts.slideNum объекта opts.
Общее число баннеров мы узнаем в свойстве opts.slideCount.
Наконец, указать интервал времени для анимации равным времени показа мы можем, узнав время показа в свойстве opts.timeout. Это значение мы задавали в html-коде с помощью атрибута data-cycle-timeout= «10000».
Задача решена! | https://habr.com/ru/post/269351/ | null | ru | null |
# Простой осциллограф за 1 день
Здрасьте!
Ну нет у меня денег на нормальный осциллограф(и на нормальную камеру). Так что сильно не деритесь.
Но было 500 рублей на экран и простой 8-битный микроконтроллер.
Небольшое описание под катом.
Началось все с того, что на руках у меня появился графический LCD экранчик WG12864B фирмы WINSTAR. 128x64 пикселя, монохромный. Никогда с ними не работал, было интересно в нем разобраться (люблю копаться в даташитах, особенно, по Cortex M4 контроллерам в 1400 страниц).
Управление оказалось очень простым, мне показалось проще, чем управление символьными LCD экранами. Основная первоначальная сложность возникла лишь в том что экран поделен на 2 независимые части 64x64, каждая из которых управляется собственным контроллером. Об управлении писать не буду, в интернете тьма статей разных и библиотек.
Дак вот. Вывел я картинку, порадовался, показал маме. Что же делать дальше, с экраном вроде разобрался, дальше картинки рисовать уже скучно. Решил сделать осциллограф, потому что у меня его нету, и, наверное, еще долго не будет. И тут сразу вспомнилась одна функция этого экрана «Стартовая линия дисплея». Она служит, так сказать, смещением памяти. Если записать в память пиксель в точке (0,0) и сделать стартовую линию, например 5, то точка будет видна на экране на 5 линии горизонтально. Мне показалось это решением проблемы сдвига изображения вместо его перерисовки.
Решил что одну половину экрана я буду сдвигать вместе с изображением сигнала, а на второй будет показываться различная информация: напряжение и все такое.
Логика проста. Стираем строчку(старую точку которая хочет вылезти справа при сдвиге более 64 точек), строим точку, эквивалентную напряжению, сдвигаем на 1 пиксель влево изображение. Эффект соединенных точек сначала думал сделать через алгоритм Брезенхема, но потом подумал, что сдвигаем ведь всего на 1 пиксель и линии будут вертикальные.
Амплитудное значение определяется по формуле:
**amp=63-(8-битное значение из АЦП) сдвинутое на 2 разряда вправо;**
Сделал все это в бесконечном цикле, запустил, и… ничего не увидел. добавил задержку 100мс и получил то изображение, которое видно в видео. При уменьшении задержки изображение становится слаборазличимым. Тут я взгрустнул, так как сигналы частотой выше 10 Гц становятся совсем неразличимы. Это все из за метода сдвига экрана. Если стирать экран и записывать информацию блоками, а не пикселями, как это делал я, качество изображения значительно улучшится и ускорится отрисовка. Но делать это было, честно, неохота, особенно в сессию. И я оставил все как есть.
На нижней части экрана я нарисовал шкалу времени, подписал отрезок. Шкалу напряжения пришлось делать на нижнем экране, так как на сдвигающемся экране сложновато сделать несдвигающуюся шкалу, тем более, чтобы её было нормально видно.
Вот картинка, чтоб удобней было ориентироваться:
На текущий момент имеем 3 Вольта. Кому интересно, синус делал на ЦАПе МК Cortex M4 с периодом чуть больше 3 секунд. На экране видно, что пару значений не досчитал на пике.
Воот. А место-то еще осталось и добавил я еще пару цифровых каналов. Работают они на прерываниях и чуть пошустрей аналогового, так как немного по другому принципу: отобразили сигнал слева-направо, стерли, отобразили снова. Тут уж можно просмотреть цифровой сигнал с частотой меньше 50 Герц. Например, проверить работоспособность какого-нибудь медленного интерфейса. Очень медленного:)
В общем все рассказал. Предложения и отзывы в комментариях. Только не разводите балаган, лучше купите мне осциллограф)
Счастья всем.
**UPDATE1: Спасибо всем за критику, после сессии попытаюсь более серьезно отнестись к программе и аппаратной части, опираясь на ваши замечания.**
**UPDATE2: вот код для atmel studio для микроконтроллера ATMega168, который содержит процедуры работы с графическим экраном, обработку прерываний таймера и цифровых входов.**
**Просмотреть код**
```
#include
#define F\_CPU 8000000
#include
#include
#define ClearBit(reg, bit) reg &= (~(1<<(bit)))
#define SetBit(reg, bit) reg |= (1<<(bit))
#define nCS1 0
#define nCS2 1
#define NRST 4
#define DI 5
#define E 4
#define RW 5
#define clrcs PORTD|=(1<=ff;k--) putpixel(100,k);
putpixel(101,ff);
putpixel(102,ff);
putpixel(103,ff);
putpixel(104,ff);
putpixel(105,ff);
pred=asd;
oldd=ff;
}
} else
{
if (pred==1)
{ if (ff=ff;k--) putpixel(105,k);
putpixel(101,ff);
putpixel(102,ff);
putpixel(103,ff);
putpixel(104,ff);
putpixel(100,ff);
pred=asd;
oldd=ff;
}
}
if (asd1==1)
{
if (pred1==0)
{
if (ff=ff;k--) putpixel(115,k);
putpixel(116,ff);
putpixel(117,ff);
putpixel(118,ff);
putpixel(119,ff);
putpixel(120,ff);
pred1=asd1;
oldd1=ff;
}
} else
{
if (pred1==1)
{ if (ff=ff;k--) putpixel(120,k);
putpixel(116,ff);
putpixel(117,ff);
putpixel(118,ff);
putpixel(119,ff);
putpixel(115,ff);
pred1=asd1;
oldd1=ff;
}
}
}
}
ISR(INT0\_vect)
{
if (PIND&0x04)
{
asd=1;
}
else
{
asd=0;
}
}
ISR(INT1\_vect)
{
if (PIND&0x08)
{
asd1=1;
}
else
{
asd1=0;
}
}
int main(void)
{
DDRC=0x3C;
DDRD=0x33;
DDRB=0xff;
PORTD=0x00;
initglcd();
clearglcd(1);
for (int j=0;j<=127;j++)
for(int i=0;i<=63;i++)
putpixel(j,i);
for (int j=0;j<=127;j++)
for(int i=0;i<=63;i++)
clearpixel(j,i);
ADCSRA|=(1<=6;k--) clearpixel(80,k);
for(int k=56;k>=6;k--) clearpixel(81,k);
adcc=ADCH;
news=63-adcc\*64/255;
news2=adcc\*50/255;
for(int k=56;k>=56-news2;k--) putpixel(80,k);
for(int k=56;k>=56-news2;k--) putpixel(81,k);
if (news<=old) for(int h=old;h>=news;h--) putpixel(h,y); else for(int h=old;h<=news;h++) putpixel(h,y);
old=news;
y--;
if (++x==4) {PORTC^=0x08; x=0;}
if (x%2==1) PORTC^=0x04;
if (y<0) y=63;
setcs1;
sendbyte(0xC0+i);
if (i==0) i=63; else i--;
\_delay\_ms(97);
}
}
``` | https://habr.com/ru/post/165611/ | null | ru | null |
# Домашний веб-сервер на солнечных батареях отработал 15 месяцев: аптайм 95,26%
[](https://habrastorage.org/webt/eh/th/2d/ehth2dv7ykrf9lj6lrozxqzmdei.jpeg)
*Первый прототип солнечного сервера с контроллером заряда. Фото: [solar.lowtechmagazine.com](https://solar.lowtechmagazine.com/power.html)*
В сентябре 2018 году энтузиаст из Low-tech Magazine [запустил проект «низкотехнологичного» веб-сервера](https://solar.lowtechmagazine.com/2018/09/how-to-build-a-lowtech-website/). Задача была снизить энергопотребление настолько, чтобы домашнему self-hosted серверу хватало одной солнечной панели. Это непросто, ведь сайт должен работать 24 часа в сутки. Посмотрим, что получилось в итоге.
Можете зайти на сервер [solar.lowtechmagazine.com](https://solar.lowtechmagazine.com/), проверить текущее энергопотребление и уровень заряда аккумулятора. Сайт оптимизирован на минимальное количество запросов со страницы и минимальный трафик, так что должен выдержать скачок посещаемости с Хабра. По расчётам разработчика, расход энергии на одного уникального посетителя составляет 0,021 Вт⋅ч.
Незадолго до рассвета 31 января 2020 года у него оставалось 42% заряда батареи. Рассвет в Барселоне в 8:04 по местному времени, после этого должен пойти ток с солнечной панели.
Зачем?
======
Десять лет назад эксперты [прогнозировали](https://www.bcg.com/publications/2012/energy-environment-technology-industries-smarter-2020-role-ict-driving-sustainable-future.aspx), что развитие интернета способствует «дематериализации» общества, всеобщей цифровизации — и, как следствие, снижению общего энергопотребления. Они ошиблись. На самом деле интернет сам потребовал [огромных объёмов энергопитания](https://solar.lowtechmagazine.com/2015/10/can-the-internet-run-on-renewable-energy.html), и эти объёмы продолжают расти.
IT-компании запустили инициативы по переходу на альтернативные источники питания, но это сейчас невозможно. Все дата-центры потребляют в три раза больше энергии, чем генерируют все солнечные и ветряные установки в мире. Хуже того, производство и регулярная замена солнечных панелей и ветряков [тоже требует энергии](https://solar.lowtechmagazine.com/2015/04/how-sustainable-is-pv-solar-power.html), поэтому отказаться от ископаемого топлифа (нефть, газ, уран) сегодня просто невозможно. Но этих запасов надолго не хватит, поэтому нам неизбежно придётся думать, как жить на возобновляемых источниках. Включая работу компьютерной инфраструктуры, в том числе веб-серверов.
Low-tech Magazine [считает проблемой](https://solar.lowtechmagazine.com/2018/09/how-to-build-a-lowtech-website/) слишком быстрое раздувание веб-страниц. С 2010 по 2018 годы средний размер страницы увеличился [с 0,45 МБ до 1,7 МБ](https://httparchive.org/reports/page-weight), а у мобильных сайтов — с 0,15 МБ до 1,6 МБ, по консервативной оценке.
Увеличение объёмов трафика [обгоняет прогресс в энергоэффективности](https://www.researchgate.net/publication/224224694/download) (энергия, необходимая для передачи 1 мегабайта информации), что вызывает постоянный рост энергопотребления интернета. Более тяжёлые и нагруженные сайты не только увеличивают нагрузку на сетевую инфраструктуру, но также сокращают «жизненный цикл» компьютеров и смартфонов, которые приходится чаще выбрасывать и производить новые, что тоже [весьма энергоёмкий процесс](https://solar.lowtechmagazine.com/2009/06/embodied-energy-of-digital-technology.html).
Ну и конечно, повышение нагрузки создаётся самим образом жизни: люди почти всё время проводят в интернете и во многом полагаются на различные веб-сервисы. Современное общество уже сложно представить без облачной IT-инфраструктуры (социальные сети, мессенджеры, почта и т.д.)
Конфигурация сервера и веб-сайта
================================
В [этой статье](https://homebrewserver.club/low-tech-website-howto.html#software) подробно описана аппаратная конфигурация и программный стек веб-сервера.
Одноплатный компьютер [Olimex Olinuxino A20 Lime 2](https://www.olimex.com/Products/OLinuXino/A20/A20-OLinuXino-LIME2/) выбран за низкое энергопотребление и полезные дополнительные функции, такие как наличие микросхемы управления энергопитанием [AXP209](http://dl.linux-sunxi.org/AXP/AXP209_Datasheet_v1.0en.pdf). Она позволяет запрашивать статистику по текущему напряжению и силе тока с платы и с батареи. Микросхема автоматически переключает питание между аккумулятором и разъёмом DC, куда течёт ток с солнечной панели. Таким образом, возможно бесперебойное питание сервера с поддержкой аккумулятора.
*Olimex Olinuxino A20 Lime 2*
Изначально в качестве аккумулятора выбрали литий-полимерную батарею ёмкостью 6600 мА⋅ч (около 24 Вт⋅ч), потом поставили кислотно-свинцовый аккумулятор на 84,4 Вт⋅ч.
Операционная система загружается с SD-карты. Хотя ОС занимает не более 1 ГБ, а статический веб-сайт около 30 МБ, но не было экономического смысла покупать карту меньше, чем Class 10 16 ГБ.
Сервер подключается к Сети через 100-мегабитное домашнее соединение в Барселоне и стандартный потребительский маршрутизатор. Для него зарезервирован статический IP-адрес. Практически каждый может поднять такой сайт у себя в квартире, нужно слегка изменить настройка файрвола для форвардинга портов на локальный IP:
```
Port 80 to 80 for HTTP
Port 443 to 443 for HTTPS
Port 22 to 22 for SSH
```
Операционная система [Armbian Stretch](https://www.armbian.com/olimex-lime-2/) на базе дистрибутива Debian и ядра [SUNXI](http://linux-sunxi.org/Main_Page), которое разработано для одноплатников с чипами AllWinner.
*50-ваттная солнечная панель для веб-сервера и 10-ваттная панель для освещения гостиной в квартире автора*
Статический сайт сгенерирован системой [Pelican](https://blog.getpelican.com/) (генератор сайтов на Python). Статические сайты загружаются быстрее и не создают нагрузки на CPU, поэтому они гораздо эффективнее, чем динамически генерируемые страницы, с точки энергопотребления. Исходный код темы оформления см. [здесь](https://github.com/lowtechmag/solar).
Очень важный момент — сжатие изображений, поскольку без этой оптимизации практически невозможно сделать веб-страницы меньше 1 мегабайта. Для оптимизации было решено перевести фотографии в полутоновые изображения. Для примера, вот фотография девушек-телефонисток на коммутаторе в прошлом веке, [253 КБ](https://upload.wikimedia.org/wikipedia/commons/2/21/Bell_System_switchboard.jpg).
А вот оптимизированное полутоновое изображение размером [36,5 КБ](https://homebrewserver.club/images/international-switchboard3.png) с тремя цветами (чёрный, белый, серый). За счёт оптической иллюзии зрителю кажется, что количество цветов больше трёх.
Полутоновые фотографии выбрали не только для оптимизации размера (решение довольно сомнительное), но и по эстетическим соображениям. Эта старая техника обработки изображений обладает определёнными стилевыми особенностями, так что у сайта получился в каком-то смысле уникальный дизайн.
623 иллюстрации на сайте журнала Low-tech Magazine после оптимизации уменьшились в размере со 194,2 МБ до 21,3 МБ, то есть на 89%.
Все старые статьи конвертировали в Markdown для простоты написания новых статей, а также для простоты резервного копирования через [git](https://git-scm.com/doc). С сайта удалили все скрипты и трекеры, а также логотипы. Используется шрифт по умолчанию в браузере клиента. В качестве «логотипа» — название журнала прописными буквами со стрелкой влево: LOW←TECH MAGAZINE. Всего 16 байт вместо картинки.
На случай даунтайма организована возможность «офлайнового чтения»: тексты и картинки экспортируются в RSS-фид. Включено кэширование 100% контента, включая HTML.
Ещё одна оптимизация — включение настройки HTTP2 в nginx, что немного уменьшает трафик и сокращает время загрузки страниц, по сравнению с HTTP/1.1. В таблице сравниваются результаты для пяти разных страниц.
```
| | FP | WE | HS | FW | CW |
|----------|-------|-------|-------|-------|-------|
| HTTP/1.1 | 1.46s | 1.87s | 1.54s | 1.86s | 1.89s |
| HTTP2 | 1.30s | 1.49s | 1.54s | 1.79s | 1.55s |
| Images | 9 | 21 | 11 | 19 | 23 |
| savings | 11% | 21% | 0% | 4% | 18% |
```
Полная конфигурация nginx:
```
root@solarserver:/var/log/nginx# cat /etc/nginx/sites-enabled/solar.lowtechmagazine.com
# Expires map
map $sent_http_content_type $expires {
default off;
text/html 7d;
text/css max;
application/javascript max;
~image/ max;
}
server {
listen 80;
server_name solar.lowtechmagazine.com;
location / {
return 301 https://$server_name$request_uri;
}
}
server{
listen 443 ssl http2;
server_name solar.lowtechmagazine.com;
charset UTF-8; #improve page speed by sending the charset with the first response.
location / {
root /var/www/html/;
index index.html;
autoindex off;
}
#Caching (save html pages for 7 days, rest as long as possible, no caching on frontpage)
expires $expires;
location @index {
add_header Last-Modified $date_gmt;
add_header Cache-Control 'no-cache, no-store';
etag off;
expires off;
}
#error_page 404 /404.html;
# redirect server error pages to the static page /50x.html
#error_page 500 502 503 504 /50x.html;
#location = /50x.html {
# root /var/www/;
#}
#Compression
gzip on;
gzip_disable "msie6";
gzip_vary on;
gzip_comp_level 6;
gzip_buffers 16 8k;
gzip_http_version 1.1;
gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;
#Caching (save html page for 7 days, rest as long as possible)
expires $expires;
# Logs
access_log /var/log/nginx/solar.lowtechmagazine.com_ssl.access.log;
error_log /var/log/nginx/solar.lowtechmagazine.com_ssl.error.log;
# SSL Settings:
ssl_certificate /etc/letsencrypt/live/solar.lowtechmagazine.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/solar.lowtechmagazine.com/privkey.pem;
# Improve HTTPS performance with session resumption
ssl_session_cache shared:SSL:10m;
ssl_session_timeout 5m;
# Enable server-side protection against BEAST attacks
ssl_prefer_server_ciphers on;
ssl_ciphers ECDH+AESGCM:ECDH+AES256:ECDH+AES128:DH+3DES:!ADH:!AECDH:!MD5;
# Disable SSLv3
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
# Lower the buffer size to increase TTFB
ssl_buffer_size 4k;
# Diffie-Hellman parameter for DHE ciphersuites
# $ sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 4096
ssl_dhparam /etc/ssl/certs/dhparam.pem;
# Enable HSTS (https://developer.mozilla.org/en-US/docs/Security/HTTP_Strict_Transport_Security)
add_header Strict-Transport-Security "max-age=63072000; includeSubdomains";
# Enable OCSP stapling (http://blog.mozilla.org/security/2013/07/29/ocsp-stapling-in-firefox)
ssl_stapling on;
ssl_stapling_verify on;
ssl_trusted_certificate /etc/letsencrypt/live/solar.lowtechmagazine.com/fullchain.pem;
resolver 87.98.175.85 193.183.98.66 valid=300s;
resolver_timeout 5s;
}
```
Итоги 15-ти месяцев работы
==========================
За период с 12 декабря 2018 года по 28 ноября 2019 года сервер показал [аптайм 95,26%](https://www.lowtechmagazine.com/2020/01/how-sustainable-is-a-solar-powered-website.html). Это означает, что из-за плохой погоды даунтайм за год составил 399 часов.
Но если не принимать во внимание последние два месяца, то время безотказной работы составило 98,2%, а время простоя — всего 152 часа, пишут разработчики. Время безотказной работы упало до 80% в течение последних двух месяцев, когда потребление энергии увеличилось из-за обновления программного обеспечения. Каждую ночь сайт отключался на несколько часов.
По статистике, за год (с 3 декабря 2018 года по 24 ноября 2019 года) потребление электроэнергии сервером составило 9,53 кВт⋅ч. Зафиксированы значительные потери в фотоэлектрической системе из-за преобразования напряжения и разряда батареи. Солнечный контроллер показал годовое потребление 18,10 кВт⋅ч, что означает эффективность системы порядка 50%.
*Упрощённая схема. На ней не показаны преобразователь напряжения с 12 на 5 вольт и батарейный счётчик ампер-часов*
За исследуемый период на сайт зашли 865 000 уникальных посетителей. Включая все потери энергии в солнечной установке, расход энергии на одного уникального посетителя составил 0,021 Вт⋅ч. Таким образом, одного киловатт-часа вырабатываемой солнечной энергии хватает на обслуживание почти 50 000 уникальных посетителей.
За время эксперимента испытывались солнечные панели разного размера. В таблице приведены расчёты, за какой время зарядятся аккумуляторы разной ёмкости при использовании солнечных панелей разного размера.
Средняя потребляемая мощность веб-сервера в течение первого года, включая все потери энергии, составила 1,97 Вт. Расчёт показывает, что для поддержания веб-сайта ночью в самую короткую ночь года (8 часов 50 минут, 21 июня) нужно 17,40 ватт-часа мощности хранения, а в самую длинную ночь (14 часов 49 минут, 21 декабря) нужно 29,19 Вт⋅ч.
Поскольку свинцово-кислотные батареи не должны разряжаться ниже половины ёмкости, серверу требуется батарея на 60 Вт⋅ч, чтобы пережить самую длинную ночь при оптимальной освещённости днём (2×29,19 Вт⋅ч). Бóльшую часть года система работала с аккумулятором 86,4 Вт⋅ч и 50-ваттной солнечной панелью, тогда и было достигнут вышеупомянутый аптайм 95-98%.
Аптайм 100%
===========
Для аптайма 100% требуется увеличить ёмкость аккумуляторов. Чтобы компенсировать один день очень плохой погоды (без значительной генерации электроэнергии), нужно 47,28 ватт-часа (24 часа × 1,97 ватта) хранилища.
С 1 декабря 2019 года по 12 января 2020 года в систему поставили 168-ваттную батарею, у которой практическая ёмкость хранения 84 ватт-часа. Этого хранилища достаточно, чтобы поддерживать работу сайта в течение двух ночей и одного дня. Конфигурацию тестировали в самый тёмный период года, но погода была относительно хорошей — и за указанный период время безотказной работы составило 100%.
Но чтобы гарантировать аптайм 100% в течение нескольких лет, придётся предусмотреть и самый худший сценарий, когда плохая погода сохраняется несколько дней. Расчёт показывает: чтобы поддерживать сайт в онлайне в течение четырёх дней с низкой или нулевой генерацией энергии, понадобится свинцово-кислотная батарея ёмкостью 440 ватт-часов, то есть размером с автомобильный аккумулятор.
На практике при хорошей погоде свинцово-кислотная батарея ёмкостью 48 Вт⋅ч будет поддерживать работу сервера в течение ночи с марта по сентябрь. Батарея на 24 Вт⋅ч продержит сервер максимум 6 часов, то есть он будет отключаться каждую ночь, хотя и в разное время, в зависимости от месяца.
По большому счёту, некоторым сайтам необязательно работать по ночам, когда количество посетителей минимально, считают ребята из Low-tech Magazine. Например, если это региональное городское издание, куда не заходят посетители из других часовых поясов, а только местные жители.
То есть для сайтов с разной посещаемостью и разным аптаймом нужны аккумуляторы разной ёмкости и солнечные батареи разного размера.
Автор приводит расчёт, сколько энергии требуется для *производства* самих солнечных панелей (embodied energy) и сколько получается, если поделить это количество на ожидаемый срок службы в 10 лет.
Таким образом, можно рассчитать аналог ископаемого топлива, которое израсходовано на производство и эксплуатацию панелей. У Low-tech Magazine получилось, что за первый год работы их система (панель 50 Вт, батарея 86,4 Вт⋅ч) «сгенерировала» примерно 9 кг выбросов или эквивалент сжигания 3 л бензина: примерно столько же, сколько легковой автомобиль за 50 км хода.
Если запитывать сервер не от солнечных батарей, а от общей энергосети, то эквивалент выбросов вроде получается в шесть раз ниже: 1,54 кг (в испанской энергетике высока доля альтернативной энергетики и АЭС). Но это не совсем корректное сравнение, пишет автор, потому что оно учитывает embodied energy солнечной инфраструктуры, но не учитывает этот показатель для общей энергосети, то есть затраты на её строительство и поддержку.
Дальнейшие улучшения
====================
За прошедшее время проведён ряд оптимизаций, которые снизили энергопотребление сервера. Например, в какой-то момент разработчик заметил, что 6,63 ТБ из общего объёма 11,15 ТБ трафика генерирует одна некорректная реализация RSS-фида, которая вытягивает контент каждые несколько минут. После исправления этого бага энергопотребление сервера (без учета потерь энергии) снизилось с 1,14 Вт до примерно 0,95 Вт. Выигрыш может показаться небольшим, но разница в 0,19 Вт означает 4,56 ватт-часа за сутки, что соответствует более 2,5 часов автономной работы сервера.
В течение первого года кпд составил всего 50%. Потери наблюдались при зарядке и разрядке аккумулятора (22%), а также при преобразовании напряжения с 12 В (солнечная фотоэлектрическая система) на 5 В (USB), где потери составляют до 28%. Разработчик признаёт, что у него неоптимальный преобразователь напряжения (контроллер без встроенного USB), поэтому можно оптимизировать этот момент или перейти на солнечную установку 5V.
Для повышения эффективности хранения энергии можно заменить свинцово-кислотные аккумуляторы более дорогими литий-ионными батареями, у которых меньшие потери заряда/разряда (<10%). Сейчас конструктор рассматривает компактную [систему хранения электроэнергии в виде сжатого воздуха](https://solar.lowtechmagazine.com/2018/05/ditch-the-batteries-off-grid-compressed-air-energy-storage.html) (CAES), у которой срок службы десятки лет, что означает меньший «углеродный отпечаток» на её производство.
*Компактный аккумулятор энергии на сжатом воздухе, [источник](https://www.ctc-n.org/technologies/compressed-air-energy-storage-caes)*
Рассматривается установка дополнительной ветряной турбины (её можно [изготовить из дерева](https://www.lowtechmagazine.com/2019/06/small-wooden-wind-turbines.html)) и установка солнечного трекера для поворота панелей к солнцу. Трекер позволяет увеличить выработку электроэнергии на 30%.
Ещё один способ повышения эффективности системы — её масштабирование. Поднимать на сервере больше веб-сайтов и запускать больше серверов. Тогда уменьшится расход энергии в расчёте на каждый сайт.
*Компания солнечного хостинга. Иллюстрация: Диего Мармолехо*
Если покрыть солнечными панелями весь балкон квартиры и открыть компанию солнечного веб-хостинга, то затраты на каждого клиента будут существенно ниже, чем на единственный веб-сайт: экономия от масштаба.
В целом, этот эксперимент демонстрирует, что при определённых ограничениях компьютерная инфраструктура вполне может работать на возобновляемых источниках энергии.
Теоретически, такой сервер может даже обойтись без аккумулятора, если зеркалировать его в других частях света. Например, поставить зеркала в Новой Зеландии и Чили. Там солнечные панели будут работать, когда в Барселоне ночь. | https://habr.com/ru/post/486378/ | null | ru | null |
# Возможности dapp, которые делают жизнь проще
В статье представлен (и продемонстрирован в коротких видеороликах) инструментарий, облегчающий разработку и отладку конфигураций с [dapp](https://github.com/flant/werf) — Open Source-утилитой, которую мы ежедневно используем при построении и сопровождении процессов CI/CD.
**Обновлено 13 августа 2019 г.:** в настоящее время проект dapp переименован в **[werf](https://werf.io)**, его код переписан на Go, а документация значительно улучшена.
***Примечание**: Недавно была анонсирована поддержка синтаксиса YAML в dapp, об особенностях которого можно прочитать в [этой публикации](https://habrahabr.ru/company/flant/blog/351838/). По умолчанию все описанные далее инструменты будут справедливы как для него, так и для конфигурации в Ruby DSL (используется в предыдущих версиях dapp), а если это не так — указано отдельно.*
Интроспекция стадий
===================
Написание конфигурации на первых шагах усложняется отсутствием понимания того, **что содержится в сборочном контейнере** при выполнении инструкций.
Сборка приложения и артефакта состоит из набора связанных **стадий**. Каждая стадия собирается в сборочном контейнере, за основу которого берётся образ предыдущей стадии (базовый образ в случае стадии `from`), а затем сохраняется в Docker-образ, кэш приложения. Все стадии выполняют определённую функцию и связаны с соответствующими директивами в конфигурации. *Подробнее узнать про природу стадий, их функции, особенности и возможные состояния можно в [документации](https://werf.io/documentation/reference/stages_and_images.html).*
В процессе сборки есть возможность получить **доступ к определённой стадии**, воспользовавшись [опциями интроспекции](https://werf.io/documentation/reference/development_and_debug/stage_introspection.html). При интроспекции сборочный контейнер, среда, содержит служебный инструментарий и переменные окружения. Инструментарий представляется в виде набора утилит, который необходим на время сборки. Его добавление осуществляется монтированием директорий из служебных контейнеров наших дистрибутивов `dappdeps` (в сборочном контейнере они доступны по пути `/.dapp/deps`). *Подробнее про идею этих дистрибутивов, процесс их сборки и состав можно почитать в [статье про dappdeps](https://habrahabr.ru/company/flant/blog/352432/).*
**При разработке** интроспекция позволяет прийти к необходимому результату в сборочном контейнере, а затем перенести все шаги, инструкции, в конфигурацию соответствующей стадии. Такой подход может быть полезен, когда поставленная задача ясна, но шаги для её решения не очевидны и требуют экспериментов.
Процесс написания конфигурации в режиме интроспекции (на примере приложения [symfony-demo](https://github.com/symfony/symfony-demo)) продемонстрирован в этом видео:
**При отладке** интроспекция позволяет посмотреть, почему сборка завершилась с ошибкой или результат не соответствует ожиданиям, проверить наличие зависимых файлов, состояние системы:
Наконец, при использовании интроспекции **с Ansible-сборщиком** *(подробнее о поддержке Ansible в dapp см. в [этой статье](https://habr.com/company/flant/blog/351838/))* появляется возможность отладки Ansible playbooks в сборочном контейнере с последующим переносом Ansible-задач в соответствующие стадии конфигурации:
При сборке поддерживаются следующие **опции интроспекции**:
```
# интроспекция до и после выполнения проблемного набора инструкций
dapp dimg build --introspect-error
dapp dimg build --introspect-before-error
# интроспекция собранной стадии STAGE
dapp dimg build --introspect-stage STAGE
dapp dimg build --introspect-artifact-stage STAGE
# интроспекция до выполнения инструкций стадии STAGE
dapp dimg build --introspect-before STAGE
dapp dimg build --introspect-artifact-before STAGE
```
Работа с локальным Git-репозиторием в dev-режиме
================================================
При разработке конфигурации в стандартном режиме сборки требуются формальные коммиты для того, чтобы dapp учитывал изменения в файлах при сборке. По аналогии с монтированием рабочей директории при сборке `Dockerfile` хочется работать с **текущим состоянием локального репозитория**.
Эта концепция реализована в dev-режиме сборки: при сборке учитываются некоммитнутые изменения локального Git-репозитория, соответствующие конфигурации. Если быть точным, учитываются пути из следующих поддиректив `git`: `add`, `includePaths`, `excludePaths`, `stageDependencies`.
При добавлении git-submodules и вложенных Git-репозиториев учитываются файлы `.gitignore` на всех уровнях.
```
dapp dimg build --dev
# удаление dev-кэша стадий всех проектов
dapp dimg mrproper --improper-dev-mode-cache
```
Альтернативная схема кэширования с директивой `asLayers`
========================================================
Стадии `before_install`, `install`, `before_setup`, `setup` зависят от соответствующих инструкций в конфигурации. Любое изменение инструкций приводит к пересборке соответствующей стадии со всеми инструкциями. Таким образом, при тяжеловесных, требовательных ко времени, инструкциях разработка может затянуться.
Добавим ко всему этому ситуацию, когда при выполнении команд сборка падает на одной из последних инструкций стадии. Помимо того, что сборку необходимо выполнять заново, нет возможности получить состояние среды до упавшей инструкции, проверить корректность выполнения предыдущих.
Для удобства разработки и отладки была введена директива `asLayers`, которая указывается для конкретного приложения или его артефакта в конфигурации (`dappfile.yaml`). При сборке **инструкции кэшируются по отдельности**, а пересборка осуществляется только при изменении их порядка.
При отсутствии директивы `asLayers` (или в случае `asLayers: false`) используется кэширование по умолчанию, т.е. один Docker-образ на все инструкции стадии, а если указать `asLayers: true`, то включится новый режим кэширования — один Docker-образ на одну команду для shell или один task для Ansible.
Переключение между режимами сборки регулируется только директивой `asLayers` — остальные инструкции конфигурации остаются неизменными. После того, как сборочные инструкции отлажены, `asLayers` необходимо выключить. Видеодемонстрация использования `asLayers` в dapp:
Директива `asLayers` позволяет кэшировать инструкции по отдельности. При использовании опций интроспекции `--introspect-error` и `--introspect-before-error` пользователь может получить среду до или после выполнения проблемной инструкции.
Важные примечания:
* Новые возможности dapp реализуются только в YAML-конфигурации, поэтому `asLayers` уже не поддерживается в вариантах с Ruby DSL.
* Важно не пользоваться этой инструкцией при штатной сборке образов: данный режим порождает избыточное количество Docker-образов и не рассчитан на инкрементальную сборку (т.к. увеличивается время ожидания и размер сборочного кэша).
Резюмируя
=========
Поскольку dapp остаётся одним из главных инструментов в ежедневной работе наших DevOps-инженеров, мы имеем высокую мотивацию делать его по-настоящему удобным, удовлетворяя все их потребности. В то же время это Open Source-проект, и мы рады также видеть [issues](https://github.com/flant/werf/issues) и от сторонних пользователей, сценарии работы которых могут отличаться от нашего опыта. Также готовы ответить на любые ваши вопросы по использованию dapp в комментариях к этой статье — welcome!
P.S.
====
Читайте также в нашем блоге:
* «[werf — наш инструмент для CI/CD в Kubernetes (обзор и видео доклада)](https://habr.com/ru/company/flant/blog/460351/)» *(Дмитрий Столяров; 27 мая 2019 на DevOpsConf)*;
* «[Дождались: поддержка YAML и Ansible (без коров) в dapp](https://habr.com/company/flant/blog/351838/)»;
* «[Linux-дистрибутив from scratch для сборки Docker-образов — наш опыт с dappdeps](https://habr.com/company/flant/blog/352432/)»;
* «[Сборка проектов с dapp. Часть 1: Java](https://habr.com/company/flant/blog/348436/)»;
* «[Практика с dapp. Часть 1: Сборка простых приложений](https://habr.com/company/flant/blog/336212/)»;
* «[Практика с dapp. Часть 2. Деплой Docker-образов в Kubernetes с помощью Helm](https://habr.com/company/flant/blog/336170/)»;
* «[Собираем Docker-образы для CI/CD быстро и удобно вместе с dapp (обзор и видео доклада)](https://habr.com/company/flant/blog/324274/)». | https://habr.com/ru/post/354866/ | null | ru | null |
# Кодогенерация в Dart. Часть 2. Аннотации, source_gen и build_runner
В [первой части](https://habr.com/post/445824/) мы выяснили зачем нужна кодогенерация и перечислили необходимые инструменты для кодогенерации в Dart. Во второй части мы узнаем как создавать и использовать аннотации в Dart, а также как использовать [source\_gen](https://github.com/dart-lang/source_gen) и [build\_runner](https://pub.dartlang.org/packages/build_runner), чтобы для запуска кодогенерации.
Аннотации в Dart
================
Аннотации — это синтаксические метаданные, которые могут быть добавлены к коду. Другими словами, это возможность добавить дополнительную информацию к любому компоненту кода, например, к классу или методу. Аннотации широко используются в Dart-коде: мы используем `@required`, чтобы указать, что именованный параметр является обязательным, и наш код не скомпилируется, если аннотированный параметр не указан. Также мы используем `@override`, чтобы указать, что данное API определенное в родительском классе реализовано в дочернем классе. Аннотации всегда начинаются с символа `@`.
### Как создать свою аннотацию?
Несмотря на то, что идея добавить метаданные к коду звучит немного экзотично и сложно, аннотации – это одна из самых простых вещей в языке Dart. Ранее было сказано, что *аннотации просто несут дополнительную информацию*. Они похожи на **PODO** (Plain Old Dart Objects). И *любой класс может служить аннотацией, если в нем определен `const` конструктор*:
```
class {
final String name;
final String todoUrl;
const Todo(this.name, {this.todoUrl}) : assert(name != null);
}
@Todo('hello first annotation', todoUrl: 'https://www.google.com')
class HelloAnnotations {}
```
Как вы можете заметить, аннотации очень просты. И основное значение имеет то, что мы будем делать с этими аннотациями. В этом нам помогут `source_gen` и `build_runner`.
### Как использовать build\_runner?
[`build_runner`](https://pub.dartlang.org/packages/build_runner) – это Dart пакет, который поможет нам сгенерировать файлы, используя Dart-код. Мы сконфигурируем `Builder` файлы, используя `build.yaml`. Когда он будет сконфигурирован, то `Builder` будет вызываться при каждой команде `build` или при изменении файла. У нас также есть возможность распарсить код, который был изменен или соответствует некоторым критериям.
### source\_gen для понимания Dart-кода
В некотором смысле, `build_runner` это механизм, который отвечает на вопрос «**Когда** нужно сгенерировать код?». Вместе с тем, `source_gen` отвечает на вопрос «**Какой** код должен быть сгенерирован?». `source_gen` предоставляет фреймворк, позволяющий создать *Builders*, для работы `build_runner`. Также `source_gen` предоставляет удобный API для парсинга и генерации кода.
Собираем все вместе: TODO-репорт
================================
В оставшейся части статьи мы будем разбирать проект **todo\_reporter.dart**, который может быть найден [здесь](https://github.com/jorgecoca/todo_reporter.dart).
Существует неписанное правило, которому следуют все проекты, использующие кодогенерацию: необходимо создать **пакет, содержащий аннотации**, и **отдельный пакет для генератора**, который использует эти аннотации. Информацию о том, как создать пакет-библиотеку в Dart/Flutter можно найти по [ссылке](https://www.dartlang.org/guides/libraries/create-library-packages).
Для начала нужно создать директорию `todo_reporter.dart`. Внутри этой директории нужно создать директорию `todo_reporter`, в которой будет находиться аннотация, директорию `todo_reporter_generator` для обработки аннотации и, наконец, директорию `example`, содержащую демонстрацию возможностей создаваемой библиотеки.
Суффикс `.dart` был добавлен к имени корневой директории для ясности. Конечно, это не обязательно, но мне нравится следовать этому правилу, чтобы точно обозначить тот факт, что данный пакет может быть использован в любом Dart-проекте. Напротив, если бы я хотел указать, что данный пакет – только для Flutter (как [ozzie.flutter](https://github.com/jorgecoca/ozzie.flutter)), я бы использовал другой суффикс. Делать это не обязательно, это просто соглашение об именовании, которого я стараюсь придерживаться.
### Создание todo\_reporter, нашего простого пакета с аннотацией
Мы собираемся создать `todo_reporter` внутри `todo_reporter.dart`. Для этого нужно создать файл `pubspec.yaml` и директорию `lib`.
`pubspec.yaml` очень прост:
```
name: todo_reporter
description: Keep track of all your TODOs.
version: 1.0.0
author: Jorge Coca
homepage: https://github.com/jorgecoca/todo\_reporter.dart
environment:
sdk: ">=2.0.0 <3.0.0"
dependencies:
dev\_dependencies:
test: 1.3.4
```
Тут нет зависимостей, кроме пакета `test`, используемого в процессе разработки.
В директории `lib` нужно сделать следующее:
* Нужно создать файл `todo_reporter.dart`, в котором, используя `export`, будут указаны все классы, имеющие публичный API. Это хорошая практика, так как любой класс в нашем пакете может быть импортирован при помощи `import 'package:todo_reporter/todo_reporter.dart';`. Вы можете видеть этот класс [здесь](https://github.com/jorgecoca/todo_reporter.dart/blob/master/todo_reporter/lib/todo_reporter.dart).
* Внутри директории `lib` мы создадим директорию `src`, содержащую весь код – публичный и непубличный.
В нашем случае, все, что нам нужно добавить, это аннотация. Давайте создадим файл `todo.dart` с нашей аннотацией:
```
class Todo {
final String name;
final String todoUrl;
const Todo(this.name, {this.todoUrl}) : assert(name != null);
}
```
Итак, это все, что нужно для аннотации. Я же говорил, что это будет просто. Но это еще не все. Давайте добавим unit-тесты в директорию `test`:
**todo\_test.dart**
```
import 'package:test/test.dart';
import 'package:todo_reporter/todo_reporter.dart';
void main() {
group('Todo annotation', () {
test('must have a non-null name', () {
expect(() => Todo(null), throwsA(TypeMatcher()));
});
test('does not need to have a todoUrl', () {
final todo = Todo('name');
expect(todo.todoUrl, null);
});
test('if it is a given a todoUrl, it will be part of the model', () {
final givenUrl = 'http://url.com';
final todo = Todo('name', todoUrl: givenUrl);
expect(todo.todoUrl, givenUrl);
});
});
}
```
Это все, что нам нужно для создания аннотации. Код вы можете найти по [ссылке](https://github.com/jorgecoca/todo_reporter.dart/tree/master/todo_reporter). Теперь мы можем перейти в генератору.
### Делаем классную работу: todo\_reporter\_generator
Теперь, когда мы знаем как создавать пакеты, давайте создадим пакет `todo_reporter_generator`. Внутри этого пакета должны быть файлы `pubspec.yaml` и `build.yaml` и директория `lib`. В директории `lib` должны быть директория `src` и файл `builder.dart`. Наш `todo_reporter_generator` считается отдельным пакетом, который будет добавлен как `dev_dependency` к другим проектам. Это сделано потому, что кодогенерация нужна только на этапе разработки, и ее не нужно добавлять в готовое приложение.
`pubspec.yaml` выглядит следующим образом:
```
name: todo_reporter_generator
description: An annotation processor for @Todo annotations.
version: 1.0.0
author: Jorge Coca
homepage: https://github.com/jorgecoca/todo\_reporter.dart
environment:
sdk: ">=2.0.0 <3.0.0"
dependencies:
build: '>=0.12.0 <2.0.0'
source\_gen: ^0.9.0
todo\_reporter:
path: ../todo\_reporter/
dev\_dependencies:
build\_test: ^0.10.0
build\_runner: '>=0.9.0 <0.11.0'
test: ^1.0.0
```
Теперь давайте создадим `build.yaml`. Этот файл содержит конфигурацию, необходимую для наших *Builders*. Более подробно можно почитать [здесь](https://github.com/dart-lang/build/blob/master/build_config/README.md). `build.yaml` выглядит следующим образом:
```
targets:
$default:
builders:
todo_reporter_generator|todo_reporter:
enabled: true
builders:
todo_reporter:
target: ":todo_reporter_generator"
import: "package:todo_reporter_generator/builder.dart"
builder_factories: ["todoReporter"]
build_extensions: {".dart": [".todo_reporter.g.part"]}
auto_apply: dependents
build_to: cache
applies_builders: ["source_gen|combining_builder"]
```
Свойство `import` указывает на файл, котором содержится `Builder`, а свойство `builder_factories` указывает на методы, которые будут генерировать код.
Теперь мы можем создать файл `builder.dart` в директории `lib`:
```
import 'package:build/build.dart';
import 'package:source_gen/source_gen.dart';
import 'package:todo_reporter_generator/src/todo_reporter_generator.dart';
Builder todoReporter(BuilderOptions options) =>
SharedPartBuilder([TodoReporterGenerator()], 'todo_reporter');
```
И файл `todo_reporter_generator.dart` в директории `src`:
```
import 'dart:async';
import 'package:analyzer/dart/element/element.dart';
import 'package:build/src/builder/build_step.dart';
import 'package:source_gen/source_gen.dart';
import 'package:todo_reporter/todo_reporter.dart';
class TodoReporterGenerator extends GeneratorForAnnotation {
@override
FutureOr generateForAnnotatedElement(
Element element, ConstantReader annotation, BuildStep buildStep) {
return "// Hey! Annotation found!";
}
}
```
Как вы можете видеть, в файле `builder.dart` мы определили метод `todoReporter`, который создает `Builder`. `Builder` создается с помощью `SharedPartBuilder`, который использует наш `TodoReporterGenerator`. Так `build_runner` и `source_gen` работают вместе.
Наш `TodoReporterGenerator` является подклассом `GeneratorForAnnotation`, поэтому метод `generateForAnnotatedElement` будет выполняться только когда данная аннотация (`@Todo` в нашем случае) будет найдена в коде.
Метод `generateForAnnotatedElement` возвращает строку, содержащую наш сгенерированный код. **Если сгенерированный код не скомпилируется, то вся фаза сборки потерпит неудачу**. Это очень полезно, так как позволяет избежать ошибок в будущем.
Таким образом, при каждой генерации кода наш `todo_repoter_generator` будет создавать `part` файл, с комментарием `// Hey! Annotation found!` В следующей статье мы узнаем, как обрабатывать аннотации.
Собираем все вместе: использование todo\_reporter
=================================================
Теперь можно продемонстрировать работу `todo_reporter.dart`. Это хорошая практика – добавить `example`-проект при работе с пакетами. Так другие разработчики смогут увидеть как API может быть использовано в реальном проекте.
Давайте создадим проект и добавим требуемые зависимости в `pubspec.yaml`. В нашем случае, мы создадим Flutter проект внутри директории [`example`](https://github.com/jorgecoca/todo_reporter.dart/tree/master/example) и добавим зависимости:
```
dependencies:
flutter:
sdk: flutter
todo_reporter:
path: ../todo_reporter/
dev_dependencies:
build_runner: 1.0.0
flutter_test:
sdk: flutter
todo_reporter_generator:
path: ../todo_reporter_generator/
```
После получения пакетов (`flutter packages get`) мы можем использовать нашу аннотацию:
```
import 'package:todo_reporter/todo_reporter.dart';
@Todo('Complete implementation of TestClass')
class TestClass {}
```
Теперь, когда все на своих местах, запустим наш генератор:
```
$ flutter packages pub run build_runner build
```
После завершения работы команды вы заметите новый файл в нашем проекте: `todo.g.dart`. Он будет содержать следующее:
```
// GENERATED CODE - DO NOT MODIFY BY HAND
part of 'todo.dart';
// *****************************************************************
// TodoReporterGenerator
// ********************************************************************
// Hey! Annotation found!
```
Мы добились чего хотели! Теперь мы можем генерировать корректный Dart-файл для каждой аннотации `@Todo` в нашем коде. Пробуйте и создавайте их сколько потребуется.
В следующей статье
==================
Теперь у нас есть корректные настройки для генерации файлов. В следующей статье мы узнаем как использовать аннотации, чтобы сгенерированный код мог делать по-настоящему классные вещи. Ведь тот код, который генерируется сейчас не имеет особого смысла. | https://habr.com/ru/post/446264/ | null | ru | null |
# Шпаргалка по JS-методам для работы с DOM
### Основные источники
* [DOM Living Standart](https://dom.spec.whatwg.org/)
* [HTML Living Standart](https://html.spec.whatwg.org/multipage/dom.html)
* [Document Object Model (DOM) Level 3 Core Specification](https://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/)
* [DOM Parsing and Serialization](https://w3c.github.io/DOM-Parsing/#extensions-to-the-element-interface)
Введение
--------
`JavaScript` предоставляет множество методов для работы с `Document Object Model` или сокращенно `DOM` (объектной моделью документа): одни из них являются более полезными, чем другие; одни используются часто, другие почти никогда; одни являются относительно новыми, другие признаны устаревшими.
Я постараюсь дать вам исчерпывающее представление об этих методах, а также покажу парочку полезных приемов, которые сделают вашу жизнь веб-разработчика немного легче.
Размышляя над подачей материала, я пришел к выводу, что оптимальным будет следование спецификациям с промежуточными и заключительными выводами, сопряженными с небольшими лирическими отступлениями.
Сильно погружаться в теорию мы не будем. Вместо этого, мы сосредоточимся на практической составляющей.
Для того, чтобы получить максимальную пользу от данной шпаргалки, пишите код вместе со мной и внимательно следите за тем, что происходит в консоли инструментов разработчика и на странице.
Вот как будет выглядеть наша начальная разметка:
```
* 1
* 2
* 3
```
У нас есть список (`ul`) с тремя элементами (`li`). Список и каждый элемент имеют идентификатор (`id`) и CSS-класс (`class`). `id` и `class` — это атрибуты элемента. Существует множество других атрибутов: одни из них являются глобальными, т.е. могут добавляться к любому элементу, другие — локальными, т.е. могут добавляться только к определенным элементам.
Мы часто будем выводить данные в консоль, поэтому создадим такую "утилиту":
```
const log = console.log
```
Миксин `NonElementParentNode`
-----------------------------
Данный миксин предназначен для обработки (браузером) родительских узлов, которые не являются элементами.
В чем разница между узлами (nodes) и элементами (elements)? Если кратко, то "узлы" — это более общее понятие, чем "элементы". Узел может быть представлен элементом, текстом, комментарием и т.д. Элемент — это узел, представленный разметкой (HTML-тегами (открывающим и закрывающим) или, соответственно, одним тегом).
У рассматриваемого миксина есть метод, наследуемый от объекта `Document`, с которого удобно начать разговор.
Небольшая оговорка: разумеется, мы могли бы создать список и элементы программным способом.
Для создания элементов используется метод `createElement(tag)` объекта `Document`:
```
const listEl = document.createElement('ul')
```
Такой способ создания элементов называется императивным. Он является не очень удобным и слишком многословным: создаем родительский элемент, добавляет к нему атрибуты по одному, внедряем его в `DOM`, создаем первый дочерний элемент и т.д. Следует отметить, что существует и другой, более изысканный способ создания элементов — шаблонные или строковые литералы (template literals), но о них мы поговорим позже.
Одним из основных способов получения элемента (точнее, ссылки на элемент) является метод `getElementById(id)` объекта `Document`:
```
// получаем ссылку на наш список
const listEl = document.getElementById('list')
log(listEl)
// ul#list.list - такая запись означает "элемент `ul` с `id === list`" и таким же `class`
```
Почему идентификаторы должны быть уникальными в пределах приложения (страницы)? Потому что элемент с `id` становится значением одноименного свойства глобального объекта `window`:
```
log(listEl === window.list) // true
```
Как мы знаем, при обращении к свойствам и методам `window`, слово `window` можно опускать, например, вместо `window.localStorage` можно писать просто `localStorage`. Следовательно, для доступа к элементу с `id` достаточно обратиться к соответствующему свойству `window`:
```
log(list) // ul#list.list
```
Обратите внимание, что это не работает в `React` и других фреймворках, абстрагирующих работу с `DOM`, например, с помощью `Virtual DOM`. Более того, там иногда невозможно обратиться к нативным свойствам и методам `window` без `window`.
Миксин `ParentNode`
-------------------
Данный миксин предназначен для обработки родительских элементов (предков), т.е. элементов, содержащих одного и более потомка (дочерних элементов).
* `children` — потомки элемента
```
const { children } = list // list.children
log(children)
/*
HTMLCollection(3)
0: li#item1.item
1: li#item2.item
2: li#item3.item
length: 3
*/
```
Такая структура называется [коллекцией HTML](https://dom.spec.whatwg.org/#interface-htmlcollection) и представляет собой массивоподобный объект (псевдомассив). Существует еще одна похожая структура — [`список узлов (NodeList`)](https://dom.spec.whatwg.org/#interface-nodelist).
Массивоподобные объекты имеют свойство `length` с количеством потомков, метод `forEach()` (`NodeList`), позволяющий перебирать узлы (делать по ним итерацию). Такие объекты позволяют получать элементы по индексу, по названию (`HTMLCollection`) и т.д. Однако, у них отсутствуют методы настоящих массивов, такие как `map()`, `filter()`, `reduce()` и др., что делает работу с ними не очень удобной. Поэтому массивоподобные объекты рекомендуется преобразовывать в массивы с помощью метода `Array.from()` или spread-оператора:
```
const children = Array.from(list.children)
// или
const children = [...list.children]
log(children) // [li#item1.item, li#item2.item, li#item3.item] - обычный массив
```
* `firstElementChild` — первый потомок — элемент
* `lastElementChild` — последний потомок — элемент
```
log(list.firstElementChild) // li#item1.item
log(list.lastElementChild) // li#item2.item
```
Для дальнейших манипуляций нам потребуется периодически создавать новые элементы, поэтому создадим еще одну утилиту:
```
const createEl = (id, text, tag = 'li', _class = 'item') => {
const el = document.createElement(tag)
el.id = id
el.className = _class
el.textContent = text
return el
}
```
Наша утилита принимает 4 аргумента: идентификатор, текст, название тега и CSS-класс. 2 аргумента (тег и класс) имеют значения по умолчанию. Функция возвращает готовый к работе элемент. Впоследствии, мы реализуем более универсальный вариант данной утилиты.
* `prepend(newNode)` — добавляет элемент в начало списка
* `append(newNode)` — добавляет элемент в конец списка
```
// создаем новый элемент
const newItem = createEl('item0', 0)
// и добавляем его в начало списка
list.prepend(newItem)
// создаем еще один элемент
const newItem2 = createEl('item4', 4)
// и добавляем его в конец списка
list.append(newItem2)
log(children)
/*
HTMLCollection(5)
0: li#item0.item
1: li#item1.item
2: li#item2.item
3: li#item3.item
4: li#item4.item
*/
```
Одной из интересных особенностей `HTMLCollection` является то, что она является "живой", т.е. элементы, возвращаемые по ссылке, и их количество обновляются автоматически. Однако, эту особенность нельзя использовать, например, для автоматического добавления обработчиков событий.
* `replaceChildren(nodes)` — заменяет потомков новыми элементами
```
const newItems = [newItem, newItem2]
// заменяем потомков новыми элементами
list.replaceChildren(...newItems) // list.replaceChildren(newItem, newItem2)
log(children) // 2
```
Наиболее универсальными способами получения ссылок на элементы являются методы `querySelector(selector)` и `querySelectorAll(selector)`. Причем, в отличие от `getElementById()`, они могут вызываться на любом родительском элементе, а не только на `document`. В качестве аргумента названным методам передается любой валидный CSS-селектор (`id`, `class`, `tag` и т.д.):
```
// получаем элемент `li` с `id === item0`
const itemWithId0 = list.querySelector('#item0')
log(itemWithId0) // li#item0.item
// получаем все элементы `li` с `class === item`
const allItems = list.querySelectorAll('.item')
log(allItems) // массивоподобный объект
/*
NodeList(2)
0: li#item0.item
1: li#item4.item
length: 2
*/
```
Создадим универсальную утилиту для получения элементов:
```
const getEl = (selector, parent = document, single = true) => single ? parent.querySelector(selector) : [...parent.querySelectorAll(selector)]
```
Наша утилита принимает 3 аргумента: CSS-селектор, родительский элемент и индикатор количества элементов (один или все). 2 аргумента (предок и индикатор) имеют значения по умолчанию. Функция возвращает либо один, либо все элементы (в виде обычного массива), совпадающие с селектором, в зависимости от значения индикатора:
```
const itemWithId0 = getEl('#item0', list)
log(itemWithId0) // li#item0.item
const allItems = getEl('.item', list, false)
log(allItems) // [li#item0.item, li#item4.item]
```
Миксин `NonDocumentTypeChildNode`
---------------------------------
Данный миксин предназначен для обработки дочерних узлов, которые не являются документом, т.е. всех узлов, кроме `document`.
* `previousElementSibling` — предыдущий элемент
* `nextElementSibling` — следующий элемент
```
log(itemWithId0.previousElementSibling) // null
log(itemWithId0.nextElementSibling) // #item4
```
Миксин `ChildNode`
------------------
Данный миксин предназначен для обработки дочерних элементов, т.е. элементов, являющихся потомками других элементов.
* `before(newNode)` — вставляет новый элемент перед текущим
* `after(newNode)` — вставляет новый элемент после текущего
```
// получаем `li` с `id === item4`
const itemWithId4 = getEl('#item4', list)
// создаем новый элемент
const newItem3 = createEl('item3', 3)
// и вставляем его перед `itemWithId4`
itemWithId4.before(newItem3)
// создаем еще один элемент
const newItem4 = createEl('item2', 2)
// и вставляем его после `itemWithId0`
itemWithId0.after(newItem4)
```
* `replaceWith(newNode)` — заменяет текущий элемент новым
```
// создаем новый элемент
const newItem5 = createEl('item1', 1)
// и заменяем им `itemWithId0`
itemWithId0.replaceWith(newItem5)
```
* `remove()` — удаляет текущий элемент
```
itemWithId4.remove()
```
Интерфейс `Node`
----------------
Данный интерфейс предназначен для обработки узлов.
* `nodeType` — тип узла
```
log(list.nodeType) // 1
// другие варианты
/*
1 -> ELEMENT_NODE (элемент)
3 -> TEXT_NODE (текст)
8 -> COMMENT_NODE (комментарий)
9 -> DOCUMENT_NODE (document)
10 -> DOCUMENT_TYPE_NODE (doctype)
11 -> DOCUMENT_FRAGMENT_NODE (фрагмент) и т.д.
*/
```
* `nodeName` — название узла
```
log(list.nodeName) // UL
// другие варианты
/*
- квалифицированное название HTML-элемента прописными (заглавными) буквами
- квалифицированное название атрибута
- #text
- #comment
- #document
- название doctype
- #document-fragment
*/
```
* `baseURI` — основной путь
```
log(list.baseURI) // .../dom/index.html
```
* `parentNode` — родительский узел
* `parentElement` — родительский элемент
```
const itemWithId1 = getEl('#item1', list)
log(itemWithId1.parentNode) // #list
log(itemWithId1.parentElement) // #list
```
* `hasChildNodes()` — возвращает `true`, если элемент имеет хотя бы одного потомка
* `childNodes` — дочерние узлы
```
log(list.hasChildNodes()) // true
log(list.childNodes)
/*
NodeList(3)
0: li#item1.item
1: li#item2.item
2: li#item3.item
*/
```
* `firstChild` — первый потомок — узел
* `lastChild` — последний потомок — узел
```
log(list.firstChild) // #item1
log(list.lastChild) // #item3
```
* `nextSibling` — следующий узел
* `previousSibling` — предыдущий узел
```
log(itemWithId1.nextSibling) // #item2
log(itemWithId1.previousSibling) // null
```
* `textContent` — геттер/сеттер для извлечения/записи текста
```
// получаем текст
log(itemWithId1.textContent) // 1
// меняем текст
itemWithId1.textContent = 'item1'
log(itemWithId1.textContent) // item1
// получаем текстовое содержимое всех потомков
log(list.textContent) // item123
```
Для извлечения/записи текста существует еще один (устаревший) геттер/сеттер — `innerText`.
* `cloneNode(deep)` — копирует узел. Принимает логическое значение, определяющее характер копирования: поверхностное — копируется только сам узел, глубокое — копируется сам узел и все его потомки
```
// создаем новый список посредством копирования существующего
const newList = list.cloneNode(false)
// удаляем у него `id` во избежание коллизий
newList.removeAttribute('id')
// меняем его текстовое содержимое
newList.textContent = 'new list'
// и вставляем его после существующего списка
list.after(newList)
// создаем еще один список
const newList2 = newList.cloneNode(true)
newList.after(newList2)
```
* `isEqualNode(node)` — сравнивает узлы
* `isSameNode(node)` — определяет идентичность узлов
```
log(newList.isEqualNode(newList2)) // true
log(newList.isSameNode(newList2)) // false
```
* `contains(node)` — возвращает `true`, если элемент содержит указанный узел
```
log(list.contains(itemWithId1)) // true
```
* `insertBefore(newNode, existingNode)` — добавляет новый узел (`newNode`) перед существующим (`existingNode`)
```
// создаем новый элемент
const itemWithIdA = createEl('#item_a', 'a')
// и вставляем его перед `itemWithId1`
list.insertBefore(itemWithIdA, itemWithId1)
```
* `appendChild(node)` — добавляет узел в конец списка
```
// создаем новый элемент
const itemWithIdC = createEl('#item_c', 'c')
// и добавляем его в конец списка
list.appendChild(itemWithIdC)
```
* `replaceChild(newNode, existingNode)` — заменяет существующий узел (`existingNode`) новым (`newNode`):
```
// создаем новый элемент
const itemWithIdB = createEl('item_b', 'b')
// и заменяем им `itemWithId1`
list.replaceChild(itemWithIdB, itemWithId1)
```
* `removeChild(node)` — удаляет указанный дочерний узел
```
// получаем `li` с `id === item2`
const itemWithId2 = getEl('#item2', list)
// и удаляем его
list.removeChild(itemWithId2)
```
Интерфейс `Document`
--------------------
Данный интерфейс предназначен для обработки объекта `Document`.
* `URL` и `documentURI` — адрес документа
```
log(document.URL) // .../dom/index.html
log(document.documentURI) // ^
```
* `documentElement`:
```
log(document.documentElement) // html
```
* `getElementsByTagName(tag)` — возвращает все элементы с указанным тегом
```
const itemsByTagName = document.getElementsByTagName('li')
log(itemsByTagName)
/*
HTMLCollection(4)
0: li##item_a.item
1: li#item_b.item
2: li#item3.item
3: li##item_c.item
*/
```
* `getElementsByClassName(className)` — возвращает все элементы с указанным CSS-классом
```
const itemsByClassName = list.getElementsByClassName('item')
log(itemsByClassName) // ^
```
* `createDocumentFragment()` — возвращает фрагмент документа:
```
// создаем фрагмент
const fragment = document.createDocumentFragment()
// создаем новый элемент
const itemWithIdD = createEl('item_d', 'd')
// добавляем элемент во фрагмент
fragment.append(itemWithIdD)
// добавляем фрагмент в список
list.append(fragment)
```
Фрагменты позволяют избежать создания лишних элементов. Они часто используются при работе с разметкой, скрытой от пользователя с помощью тега `template` (метод `cloneNode()` возвращает `DocumentFragment`).
* `createTextNode(data)` — создает текст
* `createComment(data)` — создает комментарий
* `importNode(existingNode, deep)` — создает новый узел на основе существующего
```
// создаем новый список на основе существующего
const newList3 = document.importNode(list, true)
// вставляем его перед существующим списком
list.before(newList3)
// и удаляем во избежание коллизий
newList3.remove()
```
* `createAttribute(attr)` — создает указанный атрибут
Интерфейсы `NodeIterator` и `TreeWalker`
----------------------------------------
Интерфейсы [`NodeIterator`](https://dom.spec.whatwg.org/#interface-nodeiterator) и [`TreeWalker`](https://dom.spec.whatwg.org/#interface-treewalker) предназначены для обхода (traverse) деревьев узлов. Я не сталкивался с примерами их практического использования, поэтому ограничусь парочкой примеров:
```
// createNodeIterator(root, referenceNode, pointerBeforeReferenceNode, whatToShow, filter)
const iterator = document.createNodeIterator(list)
log(iterator)
log(iterator.nextNode()) // #list
log(iterator.nextNode()) // #item_a
log(iterator.previousNode()) // #item_a
log(iterator.previousNode()) // #list
log(iterator.previousNode()) // null
// createTreeWalker(root, whatToShow, filter)
// применяем фильтры - https://dom.spec.whatwg.org/#interface-nodefilter
const walker = document.createTreeWalker(list, '0x1', { acceptNode: () => 1 })
log(walker)
log(walker.parentNode()) // null
log(walker.firstChild()) // #item_a
log(walker.lastChild()) // null
log(walker.previousSibling()) // null
log(walker.nextSibling()) // #item_b
log(walker.nextNode()) // #item3
log(walker.previousNode()) // #item_b
```
Интерфейс `Element`
-------------------
Данный интерфейс предназначен для обработки элементов.
* `localName` и `tagName` — название тега
```
log(list.localName) // ul
log(list.tagName) // UL
```
* `id` — геттер/сеттер для идентификатора
* `className` — геттер/сеттер для CSS-класса
```
log(list.id) // list
list.id = 'LIST'
log(LIST.className) // list
```
* `classList` — все CSS-классы элемента (объект `DOMTokenList`)
```
const button = createEl('button', 'Click me', 'my_button', 'btn btn-primary')
log(button.classList)
/*
DOMTokenList(2)
0: "btn"
1: "btn-primary"
length: 2
value: "btn btn-primary"
*/
```
### Работа с `classList`
* `classList.add(newClass)` — добавляет новый класс к существующим
* `classList.remove(existingClass)` — удаляет указанный класс
* `classList.toggle(className, force?)` — удаляет существующий класс или добавляет новый. Если опциональный аргумент `force` имеет значение `true`, данный метод только добавляет новый класс при отсутствии, но не удаляет существующий класс (в этом случае `toggle() === add()`). Если `force` имеет значение `false`, данный метод только удаляет существующий класс при наличии, но не добавляет отсутствующий класс (в этом случае `toggle() === remove()`)
* `classList.replace(existingClass, newClass)` — заменяет существующий класс (`existingClass`) на новый (`newClass`)
* `classList.contains(className)` — возвращает `true`, если указанный класс обнаружен в списке классов элемента (данный метод идентичен `className.includes(className)`)
```
// добавляем к кнопке новый класс
button.classList.add('btn-lg')
// удаляем существующий класс
button.classList.remove('btn-primary')
// у кнопки есть класс `btn-lg`, поэтому он удаляется
button.classList.toggle('btn-lg')
// заменяем существующий класс на новый
button.classList.replace('btn', 'btn-success')
log(button.className) // btn-success
log(button.classList.contains('btn')) // false
log(button.className.includes('btn-success')) // true
```
### Работа с атрибутами
* `hasAttributes()` — возвращает `true`, если у элемента имеются какие-либо атрибуты
* `getAttributesNames()` — возвращает названия атрибутов элемента
* `getAttribute(attrName)` — возвращает значение указанного атрибута
* `setAttribute(name, value)` — добавляет указанные атрибут и его значение к элементу
* `removeAttribute(attrName)` — удаляет указанный атрибут
* `hasAttribute(attrName)` — возвращает `true` при наличии у элемента указанного атрибута
* `toggleAttribute(name, force)` — добавляет новый атрибут при отсутствии или удаляет существующий атрибут. Аргумент `force` аналогичен одноименному атрибуту `classList.toggle()`
```
log(button.hasAttributes()) // true
log(button.getAttributeNames()) // ['id', 'class']
log(button.getAttribute('id')) // button
button.setAttribute('type', 'button')
button.removeAttribute('class')
log(button.hasAttribute('class')) // false
```
В использовании перечисленных методов для работы с атрибутами нет особой необходимости, поскольку многие атрибуты являются геттерами/сеттерами, т.е. позволяют извлекать/записывать значения напрямую. Единственным исключением является метод `removeAttribute()`, поскольку существуют атрибуты без значений: например, если кнопка имеет атрибут `disabled`, установка значения данного атрибута в `false` не приведет к снятию блокировки — для этого нужно полностью удалить атрибут `disabled` с помощью `removeAttribute()`.
Отдельного упоминания заслуживает атрибут `data-*`, где символ `*` означает любую строку. Он предназначен для определения пользовательских атрибутов. Например, в нашей начальной разметке для уникальной идентификации элементов используется атрибут `id`. Однако, это приводит к загрязнению глобального пространства имен, что чревато коллизиями между нашими переменными и, например, переменными используемой нами библиотеки — когда какой-либо объект библиотеки пытается записаться в свойство `window`, которое уже занято нашим `id`.
Вместо этого, мы могли бы использовать атрибут `data-id` и получать ссылки на элементы с помощью `getEl('[data-id="id"]')`.
Название data-атрибута после символа `-` становится одноименным свойством объекта `dataset`. Например, значение атрибута `data-id` можно получить через свойство `dataset.id`.
* `closest(selectors)` — возвращает первый родительский элемент, совпавший с селекторами
```
LIST.append(button)
log(button.closest('#LIST', 'document.body')) // #LIST
```
* `matches(selectors)` — возвращает `true`, если элемент совпадает хотя бы с одним селектором
```
log(button.matches('.btn', '[type="button"]'))
// у кнопки нет класса `btn`, но есть атрибут `type` со значением `button`,
// поэтому возвращается `true`
```
* `insertAdjacentElement(where, newElement)` — универсальный метод для вставки новых элементов перед/в начало/в конец/после текущего элемента. Аргумент `where` определяет место вставки. Возможные значения:
+ `beforebegin` — перед открывающим тегом
+ `afterbegin` — после открывающего тега
+ `beforeend` — перед закрывающим тегом
+ `afterend` — после закрывающего тега
* `insertAdjacentText(where, data)` — универсальный метод для вставки текста
* `Text` — конструктор для создания текста
* `Comment` — конструктор для создания комментария
```
const text = new Text('JavaScript')
log(text) // "JavaScript"
const part = text.splitText(4)
log(part) // "Script"
log(part.wholeText()) // Script
const comment = new Comment('TODO')
log(comment) //
```
Объект `Document`
-----------------
* `location` — объект с информацией о текущей локации документа
```
log(document.location)
```
Свойства объекта `location`:
* `hash` — хэш-часть URL (символ `#` и все, что следует за ним), например, `#top`
* `host` — название хоста и порт, например, `localhost:3000`
* `hostname` — название хоста, например, `localhost`
* `href` — полный путь
* `origin` — `protocol` + `host`
* `pathname` — путь без протокола
* `port` — порт, например, `3000`
* `protocol` — протокол, например, `https`
* `search` — строка запроса (символ `?` и все, что следует за ним), например, `?name=John&age=30`
Методы `location`:
* `reload()` — перезагружает текущую локацию
* `replace()` — заменяет текущую локацию на новую
* `title` — заголовок документа
```
log(document.title) // DOM
```
* `head` — метаданные документа
* `body` — тело документа
* `images` — псевдомассив (`HTMLCollection`), содержащий все изображения, имеющиеся в документе
```
const image = document.createElement('img')
image.className = 'my_image'
image.src = 'https://miro.medium.com/max/875/1*ZIH_wjqDfZn6NRKsDi9mvA.png'
image.alt = "V8's compiler pipeline"
image.width = 480
document.body.append(image)
log(document.images[0]) // .my_image
```
* `links` — псевдомассив, содержащий все ссылки, имеющиеся в документе
```
const link = document.createElement('a')
link.className = 'my_link'
link.href = 'https://github.com/azat-io/you-dont-know-js-ru'
link.target = '_blank'
link.rel = 'noopener noreferrer'
link.textContent = 'Вы не знаете JS'
document.body.append(link)
log(document.links[0]) // .my_link
```
* `forms` — псевдомассив, содержащий все формы, имеющиеся в документе
```
const form = document.createElement('form')
form.className = 'my_form'
document.body.append(form)
log(document.forms[0]) // .my_form
```
Следующие методы и свойство считаются устаревшими:
* `open()` — открывает документ для записи. При этом документ полностью очищается
* `close()` — закрывает документ для записи
* `write()` — записывает данные (текст, разметку) в документ
* `writeln()` — записывает данные в документ с переносом на новую строку
* `designMode` — управление режимом редактирования документа. Возможные значения: `on` и `off`. Наберите `document.designMode = 'on'` в консоли `DevTools` и нажмите `Enter`. Вуаля, страница стала редактируемой: можно удалять/добавлять текст, перетаскивать изображения и т.д.
* `execCommand()` — выполняет переданные команды. Со списоком доступных команд можно ознакомиться [здесь](https://developer.mozilla.org/ru/docs/Web/API/Document/execCommand). Раньше этот метод активно использовался для записи/извлечения данных из буфера обмена (команды `copy` и `paste`). Сейчас для этого используются методы `navigator.clipboard.writeText()`, `navigator.clipboard.readText()` и др.
Миксин `InnerHTML`
------------------
Геттер/сеттер `innerHTML` позволяет извлекать/записывать разметку в элемент. Для подготовки разметки удобно пользоваться шаблонными литералами:
```
const itemsTemplate = `
- 1
- 2
- 3
`
LIST.innerHTML = itemsTemplate
log(LIST.innerHTML)
/*
- 1
- 2
- 3
*/
```
Расширения интерфейса `Element`
-------------------------------
* `outerHTML` — геттер/сеттер для извлечения/записи внешней разметки элемента: то, что возвращает `innerHTML` + разметка самого элемента
```
log(LIST.outerHTML)
/*
* 1
* 2
* 3
*/
```
* `insertAdjacentHTML(where, string)` — универсальный метод для вставки разметки в виде строки. Аргумент `where` аналогичен одноименному аргументу метода `insertAdjacentElement()`
Метод `insertAdjacentHTML()` в сочетании с шаблонными литералами и их продвинутой версией — тегированными шаблонными литералами (tagged template literals) предоставляет много интересных возможностей по манипулированию разметкой документа. По сути, данный метод представляет собой движок шаблонов (template engine) на стороне клиента, похожий на `Pug`, `Handlebars` и др. серверные движки. С его помощью (при участии `History API`) можно, например, реализовать полноценное одностраничное приложение (`Single Page Application` или сокращенно `SPA`). Разумеется, для этого придется написать чуть больше кода, чем при использовании какого-либо фронтенд-фреймворка.
Вот несколько полезных ссылок, с которых можно начать изучение этих замечательных инструментов:
* [Element.insertAdjacentHTML() — MDN](https://developer.mozilla.org/ru/docs/Web/API/Element/insertAdjacentHTML)
* [Изменение документа — JSR](https://learn.javascript.ru/modifying-document#prepend-append-before-after)
* [Шаблонные строки — MDN](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Template_literals)
* [Template Literals — ECMAScript 2022](https://tc39.es/ecma262/#sec-template-literals)
Иногда требуется создать элемент на основе шаблонной строки. Как это можно сделать? Вот соответствующая утилита:
```
const createElFromStr = (str) => {
// создаем временный элемент
const el = document.createElement('div')
// записываем в него переданную строку - разметку
el.innerHTML = str
// извлекаем наш элемент
// если мы используем здесь метод `firstChild()`, может вернуться `#text`
// одна из проблем шаблонных строк заключается в большом количестве лишних пробелов
const child = el.fisrtElementChild
// удаляем временный элемент
el.remove()
// и возвращаем наш элемент
return child
}
// шаблон списка
const listTemplate = `
* 1
* 2
* 3
`
// создаем список на основе шаблона
const listEl = createElFromStr(listTemplate)
// и вставляем его в тело документа
document.body.append(listEl)
```
Существует более экзотический способ создания элемента на основе шаблонной строки. Он предполагает использование конструктора [`DOMParser()`](https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-parsing-and-serialization):
```
const createElFromStr = (str) => {
// создаем новый парсер
const parser = new DOMParser()
// парсер возвращает новый документ
const {
body: { children }
} = parser.parseFromString(str, 'text/html')
// нас интересует первый дочерний элемент тела нового документа
return children[0]
}
const listTemplate = `
* 1
* 2
* 3
`
const listEl = createElFromStr(listTemplate)
document.body.append(listEl)
```
Еще более экзотический, но при этом самый короткий способ предполагает использование [`расширения для объекта Range`](https://w3c.github.io/DOM-Parsing/#extensions-to-the-range-interface) — метода `createContextualFragment()`:
```
const createElFromStr = (str) => {
// создаем новый диапазон
const range = new Range()
// создаем фрагмент
const fragment = range.createContextualFragment(str)
// и возвращаем его
return fragment
}
// или в одну строку
const createFragment = (str) => new Range().createContextualFragment(str)
const listTemplate = `
* 1
* 2
* 3
`
document.body.append(createFragment(listTemplate))
```
В завершение, как и обещал, универсальная утилита для создания элементов:
```
// функция принимает название тега и объект с настройками
const createEl = (tag, opts) => {
const el = document.createElement(tag)
// перебираем ключи объекта и записывает соответствующие свойства в элемент
for (const key in opts) {
el[key] = opts[key]
}
// возвращаем готовый элемент
return el
}
const button = createEl('button', {
// настройками могут быть атрибуты
id: 'my_button',
className: 'btn btn-primary',
textContent: 'Click me',
title: 'My button',
autofocus: true,
// стили
style: 'color: red; cursor: pointer;',
// обработчики и т.д.
onmouseenter: function () {
this.style.color = 'green'
},
onmouseout: function () {
this.style.color = 'blue'
},
onclick: () => alert('Привет!')
})
document.body.append(button)
```
Заключение
----------
Современный `JS` предоставляет богатый арсенал методов для работы с `DOM`. Данных методов вполне достаточно для решения всего спектра задач, возникающих при разработке веб-приложений. Хорошее знание этих методов, а также умение их правильно применять гарантируют не только высокое качество (чистоту) кода, но также избавляют от необходимости использовать DOM-библиотеки (такие как `jQuery`), что в совокупности обусловливает производительность приложения, его поддерживаемость и масштабируемость.
Разумеется, шпаргалка — это всего лишь карманный справочник, памятка для быстрого восстановления забытого материала, предполагающая наличие определенного багажа знаний.
---
[VDS](https://macloud.ru/?partner=4189mjxpzx) от Маклауд быстрые и безопасные.
Зарегистрируйтесь по ссылке выше или кликнув на баннер и получите 10% скидку на первый месяц аренды сервера любой конфигурации!
[](https://macloud.ru/?partner=4189mjxpzx&utm_source=habr&utm_medium=original&utm_campaign=igor) | https://habr.com/ru/post/557422/ | null | ru | null |
# Перевод SDL Game Framework Series. Часть 4 — SDL Tutorial: Tic Tac Toe
В предыдущих уроках мы заложили основу для разработки игры. Мы создали базовый каркас с набором общих процедур, класс для обработки событий, а также класс для работы с поверхностями. В этом уроке мы будем использовать наши наработки и создадим первую игру — крестики-нолики (Tic Tac Toe). Не волнуйтесь, все будет довольно просто. За основу возьмем код написанный в предыдущих уроках.
В первую очередь (мы же собираемся стать серьезными разработчиками игр?) нужно составить небольшое ТЗ и определить составляющие будущих крестиков-ноликов. Как мы знаем, в крестиках-ноликах существует поле 3x3 клетки, в которые два игрока поочередно ставят *X* или *O*. Итак, нам нужно подготовить 3 изображения, одно для поля, и по одному для *X* и *O*. Заметьте, что нам не нужно создавать 9 картинок для *X* и *O*, а всего по одному (ведь мы можем использовать их столько раз сколько захотим). Да по существу то можно создать всего 1 изображение для *X* и *O* (помните про *SDL\_Rect* из второго урока? В переводе я буду придерживаться оригинального кода, но если вам будет интересно, то посмотрите также мою реализацию под *linux*). Мы готовы сделать первый шаг. Наше поле давайте создадим размером 300x300 пикселей, соответственно изображения *X* и *O* сделаем размером 100x100 пикселей, т.е. 1/9 поля. Я выбрал такие размеры неслучайно. Как вы наверное уже заметили, мои скриншоты не выделяются высоким разрешением, а всё потому что пишу я с нетбука =). Вы же можете использовать любые другие размеры (и создать Tic Tac Toe HD).
Изображение поля
Изображение с *X* и *O*
Итак, картинки есть, осталось запрограммировать их загрузку. Откройте *CApp.h* и внесите следующие изменения — удалите тестовую поверхность и объявите 3 новые:
**CApp.h**
```
#ifndef _CAPP_H_
#define _CAPP_H_
#include
#include "CEvent.h"
#include "CSurface.h"
class CApp : public CEvent {
private:
bool Running;
SDL\_Surface\* Surf\_Display;
private:
SDL\_Surface\* Surf\_Grid;
SDL\_Surface\* Surf\_X;
SDL\_Surface\* Surf\_O;
public:
CApp();
int OnExecute();
public:
bool OnInit();
void OnEvent(SDL\_Event\* Event);
void OnExit();
void OnLoop();
void OnRender();
void OnCleanup();
};
#endif
```
Практически аналогичные манипуляции нужно проделать и в *CApp.cpp*:
**CApp.cpp**
```
#include "CApp.h"
CApp::CApp() {
Surf_Grid = NULL;
Surf_X = NULL;
Surf_O = NULL;
Surf_Display = NULL;
Running = true;
}
int CApp::OnExecute() {
if(OnInit() == false) {
return -1;
}
SDL_Event Event;
while(Running) {
while(SDL_PollEvent(&Event)) {
OnEvent(&Event);
}
OnLoop();
OnRender();
}
OnCleanup();
return 0;
}
int main(int argc, char* argv[]) {
CApp theApp;
return theApp.OnExecute();
}
```
Вы уже наверное догадались, что очищать мы тоже будем все получившиеся поверхности, поэтому откройте *CApp\_OnCleanup.cpp* и напишите:
**CApp\_OnCleanup.cpp**
```
#include "CApp.h"
void CApp::OnCleanup() {
SDL_FreeSurface(Surf_Grid);
SDL_FreeSurface(Surf_X);
SDL_FreeSurface(Surf_O);
SDL_FreeSurface(Surf_Display);
SDL_Quit();
}
```
Итак, поверхности настроены, теперь самое время приступить к их загрузке в память. Откройте *CApp\_OnInit.cpp* и сделайте там правки — удалите тестовую поверхность, добавьте новые, а также измените размеры окна на 300x300 чтобы у нас не было каких-либо пустых мест в окне. И убедитесь в правильности написания путей до файлов с картинками!
**CApp\_OnInit.cpp**
```
#include "CApp.h"
bool CApp::OnInit() {
if(SDL_Init(SDL_INIT_EVERYTHING) < 0) {
return false;
}
if((Surf_Display = SDL_SetVideoMode(300, 300, 32, SDL_HWSURFACE | SDL_DOUBLEBUF)) == NULL) {
return false;
}
if((Surf_Grid = CSurface::OnLoad("./gfx/grid.bmp")) == NULL) {
return false;
}
if((Surf_X = CSurface::OnLoad("./gfx/x.bmp")) == NULL) {
return false;
}
if((Surf_O = CSurface::OnLoad("./gfx/o.bmp")) == NULL) {
return false;
}
return true;
}
```
Вы заметили, что я добавил *./gfx/* перед именами файлов? Аргументирую: во время разработки серъёзных и больших игр количество файлов исходного кода и всяческих файлов ресурсов неуклонно растет, поэтому удобнее всего располагать их в разных папках. Думаю вы со мной согласитесь =). Теперь давайте выведем наше поле на экран! Откройте *CApp\_OnRender.cpp* и замените отображение тестовой поверхности на поверхность поля:
**CApp\_OnRender.cpp**
```
#include "CApp.h"
void CApp::OnRender() {
CSurface::OnDraw(Surf_Display, Surf_Grid, 0, 0);
SDL_Flip(Surf_Display);
}
```
Теперь можно скомпилировать игру и наслаждаться «красивейшим игровым полем на планете»! Сейчас важно запомнить 5 простых шагов при работе с поверхностями: объявить, обнулить, загрузить, отрисовать, освободить (заучите эту мантру, ведь в дальнейших ваших разработках это поможет избежать множества ошибок, утечек памяти, тормозов и сбоев в работе вашей игры).
Скорее всего вы также обратили внимание на то, что картинки крестиков-ноликов на розовом фоне и подумали — «А автор что, эмо?». Спешу вас переубедить! Неважно каким цветом мы обозначим фон (просто в этом конкретном примере контраст позволяет точно определить грань между изображением и фоном), ведь впоследствии фон мы «опустим» и сделаем прозрачным с помощью простой и понятной функции *SDL\_SetColorKey*. Так давайте же её и применим! Для этого в файле *CSurface.h* напишите:
**CSurface.h**
```
#ifndef _CSURFACE_H_
#define _CSURFACE_H_
#include
class CSurface {
public:
CSurface();
public:
static SDL\_Surface\* OnLoad(char\* File);
static bool OnDraw(SDL\_Surface\* Surf\_Dest, SDL\_Surface\* Surf\_Src, int X, int Y);
static bool OnDraw(SDL\_Surface\* Surf\_Dest, SDL\_Surface\* Surf\_Src, int X, int Y, int X2, int Y2, int W, int H);
static bool Transparent(SDL\_Surface\* Surf\_Dest, int R, int G, int B);
};
#endif
```
А в *CSurface.cpp* добавьте функцию:
**CSurface.cpp**
```
bool CSurface::Transparent(SDL_Surface* Surf_Dest, int R, int G, int B) {
if(Surf_Dest == NULL) {
return false;
}
SDL_SetColorKey(Surf_Dest, SDL_SRCCOLORKEY | SDL_RLEACCEL, SDL_MapRGB(Surf_Dest->format, R, G, B));
return true;
}
```
Рассмотрим функцию более подробно. Кроме указателя на исходную поверхность ей передается ещё три переменных, каждая из которых отвечает за обозначение цветовой составляющей из формата *RGB* (если кто ещё не в курсе: R — red, G — green, B — blue; красный, зеленый и синий цвета). Т.е. если бы мы передали в функцию **255, 0, 0** то из поверхности «выключился» бы и стал прозрачным красный цвет.
Сперва наша функция производит проверку на существование поверхности и в случае успеха устанавливает соответствующий переданным значениям цвет (например **255, 0, 0**) в поверхности *Surf\_Dest* прозрачным («выключает» его). Настал черед разобраться в сигнатуре самой *[SDL\_SetColorKey](http://www.libsdl.org/docs/html/sdlsetcolorkey.html)*:
```
int SDL_SetColorKey(SDL_Surface *surface, Uint32 flag, Uint32 key);
```
* Первый параметр определяет поверхность к которой применяется функция;
* Вторым параметром передаются флаги, означающие: *SDL\_SRCCOLORKEY* — указывает что в поверхности нужно выключить цвет, передаваемый третьим параметром (*Uint32 key*), *SDL\_RLEACCEL* — разрешает использовать технологию сжатия изображений *[RLE](http://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%B4%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%B4%D0%BB%D0%B8%D0%BD_%D1%81%D0%B5%D1%80%D0%B8%D0%B9)* для ускорения отображения поверхности. Если мы передаем вместо флагов «0», то таким образом можем очистить значение «выключаемого» цвета, ранее установленное в этой поверхности;
* Третий параметр задает значение «выключаемого» цвета, вычисляемое с помощью *[SDL\_MapRGB](http://www.libsdl.org/docs/html/sdlmaprgb.html)*, которая ищет максимально подходящий цвет в формате передаваемой поверхности (вы же знаете, что цветовые форматы отличаются друг от друга, а эта функция сильно помогает нам их «сдружить»).
Ну вот всё и готово, осталось применить функцию к нашим поверхностям. Откройте *CApp\_OnInit.cpp* и напишите:
**CApp\_OnInit.cpp**
```
#include "CApp.h"
bool CApp::OnInit() {
if(SDL_Init(SDL_INIT_EVERYTHING) < 0) {
return false;
}
if((Surf_Display = SDL_SetVideoMode(300, 300, 32, SDL_HWSURFACE | SDL_DOUBLEBUF)) == NULL) {
return false;
}
if((Surf_Grid = CSurface::OnLoad("./gfx/grid.bmp")) == NULL) {
return false;
}
if((Surf_X = CSurface::OnLoad("./gfx/x.bmp")) == NULL) {
return false;
}
if((Surf_O = CSurface::OnLoad("./gfx/o.bmp")) == NULL) {
return false;
}
CSurface::Transparent(Surf_X, 255, 0, 255);
CSurface::Transparent(Surf_O, 255, 0, 255);
return true;
}
```
Вот и настроены все поверхности, дело за малым — отрисовать их. Прежде всего нам нужен массив из девяти составляющих, которые будут хранить тип области для отображения крестика или нолика. Нулевой элемент будет хранить тип для верхнего левого квадранта, первый — для верхнего среднего, второй — для правого верхнего и т.д. до нижнего правого. Нужно прописать этот массив в *CApp.h*:
**CApp.h**
```
#ifndef _CAPP_H_
#define _CAPP_H_
#include
#include "CEvent.h"
#include "CSurface.h"
class CApp : public CEvent {
private:
bool Running;
SDL\_Surface\* Surf\_Display;
private:
SDL\_Surface\* Surf\_Grid;
SDL\_Surface\* Surf\_X;
SDL\_Surface\* Surf\_O;
private:
int Grid[9];
public:
CApp();
int OnExecute();
public:
bool OnInit();
void OnEvent(SDL\_Event\* Event);
void OnExit();
void OnLoop();
void OnRender();
void OnCleanup();
};
#endif
```
Мы в курсе что каждая ячейка нашей сетки может быть либо пустой, либо содержать крестик или нолик. Чтобы не использовать всякие "[магические числа](http://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D0%B3%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D1%87%D0%B8%D1%81%D0%BB%D0%BE_(%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))", нам разумнее всего использовать т.н. перечисление (enum), подробнее про которое можно прочитать [здесь](http://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D0%B5%D1%87%D0%B8%D1%81%D0%BB%D1%8F%D0%B5%D0%BC%D1%8B%D0%B9_%D1%82%D0%B8%D0%BF). Таким образом мы назначим нашим состояниям ячейки осмысленные имена и всегда будем знать что *GRID\_TYPE\_NONE* = 0, *GRID\_TYPE\_X* = 1, и *GRID\_TYPE\_O* = 2. Вернитесь к *CApp.h* и добавьте перечисление под объявлением массива координат ячеек:
**CApp.h**
```
enum {
GRID_TYPE_NONE = 0,
GRID_TYPE_X,
GRID_TYPE_O
};
```
Надеюсь вы хорошо ориентируетесь в коде нашего фрэймворка и точно знаете в какое место какого файла писать предложенный мною код. Просто иногда я привожу код полностью, но могу просто сказать где расположить участок кода, а дальше надеюсь на вашу компетенцию. У нас почти всё готово, осталось предусмотреть функцию для очистки нашего игрового поля. Давайте объявим в *CApp.h* функцию *Reset*:
**CApp.h**
```
public:
void Reset();
```
В *CApp.cpp* пропишите:
**CApp.cpp**
```
void CApp::Reset() {
for(int i = 0;i < 9;i++) {
Grid[i] = GRID_TYPE_NONE;
}
}
```
Этот цикл пробегается по ячейкам сетки и очищает их, путем установки значения *GRID\_TYPE\_NONE*. Нам лучше всего вызывать эту очистку в самом начале запуска игры, поэтому, откройте *CApp\_OnInit.cpp* и внесите следующие изменения:
**CApp\_OnInit.cpp**
```
//...остальной код...
CSurface::Transparent(Surf_X, 255, 0, 255);
CSurface::Transparent(Surf_O, 255, 0, 255);
Reset();
```
Теперь добавим возможность отрисовки крестиков и ноликов. Определите в *CApp.h* ещё одну функцию:
**CApp.h**
```
void SetCell(int ID, int Type);
```
Ну и, соответственно в *CApp.cpp*:
**CApp.cpp**
```
void CApp::SetCell(int ID, int Type) {
if(ID < 0 || ID >= 9) return;
if(Type < 0 || Type > GRID_TYPE_O) return;
Grid[ID] = Type;
}
```
Эта функция, как мы видим, принимает 2 аргумента — ID изменяемой ячейки и тип на который нужно изменить её значение. Также реализована примитивная проверка на корректность передаваемых параметров, во избежание крахов игры из-за выхода за границы массива. Переходим непосредственно к отрисовке:
**CApp\_OnRender.cpp**
```
for(int i = 0;i < 9;i++) {
int X = (i % 3) * 100;
int Y = (i / 3) * 100;
if(Grid[i] == GRID_TYPE_X) {
CSurface::OnDraw(Surf_Display, Surf_X, X, Y);
}else
if(Grid[i] == GRID_TYPE_O) {
CSurface::OnDraw(Surf_Display, Surf_O, X, Y);
}
}
```
Тут немного посложнее. Сначала мы запускаем цикл в котором бегаем по всем ячейкам в сетке игрового поля, а потом, в зависимости от типа ID, отображаем крестик либо нолик. А находим мы координаты для отображения крестика и нолика следующим образом: для X-координаты делим итератор на 3 с остатком и умножаем на 200 (размер одной отображаемой ячейки), в итоге получая 0 для i = 0, 1 для 1, 2 для 2, 0 для 3 и т.д.; для Y-координаты делим итератор на 3 без остатка и умножаем опять на 200, получая 0 для 0, 1 и 2, и т.д. После проверки типа отрисовываемой ячейки, мы её отображаем. Теперь нам остается только переопределить функцию обработки событий и добавить переменную, отвечающую за игрока. Откройте *CApp.h* и добавьте функцию *OnLButtonDown* чуть ниже функции *OnEvent*:
**CApp.h**
```
void OnLButtonDown(int mX, int mY);
```
Теперь измените *CApp\_OnEvent*:
**CApp\_OnEvent.cpp**
```
void CApp::OnLButtonDown(int mX, int mY) {
int ID = mX / 100;
ID = ID + ((mY / 100) * 3);
if(Grid[ID] != GRID_TYPE_NONE) {
return;
}
if(CurrentPlayer == 0) {
SetCell(ID, GRID_TYPE_X);
CurrentPlayer = 1;
}else{
SetCell(ID, GRID_TYPE_O);
CurrentPlayer = 0;
}
}
```
Этим кодом мы выполняем проверку на то, заполнена ли уже ячейка на которую нажал игрок, и если нет, то заполняем её картинкой крестика или нолика (в зависимости от игрока), а затем переключаем игроков (т.е. если идентификатор игрока — CurrentPlayer = 1 следующее нажатие кнопки будет интерпретировано как нажатие игроком c идентификатором 0). Откройте *CApp.h* и добавьте переменную, отвечающую за игрока:
**CApp.h**
```
int CurrentPlayer;
```
И не забудьте её обнулить в *CApp.cpp*:
**CApp.cpp**
```
CApp::CApp() {
CurrentPlayer = 0;
Surf_Grid = NULL;
Surf_X = NULL;
Surf_O = NULL;
Surf_Display = NULL;
Running = true;
}
```
Ну вот и всё! Наконец-то игра готова, так что let's play! Откомпилируйте и наслаждайтесь! Поздравляю вас! Вы прошли долгий путь и заслужили отдых.
В перспективе вы можете поэкспериментировать и добавить надписи в конце игры «X Выиграл», «O выиграл», реализовать режимы игры человекVSчеловек, человекVSкомпьютер и т.д. Дерзайте, ведь основа для игры у вас уже есть!
А вот видео работающих крестиков-ноликов:
Mой вариант [на GitHub'e](https://github.com/m0sk1t/TicTacToe).
Ссылки на исходный код:
* [Win32](http://www.sdltutorials.com/Data/Posts/103//sdl-tutorial-tic-tac-toe.zip)
* [\*nix](http://www.sdltutorials.com/Data/Posts/103//sdl-tutorial-tic-tac-toe.tar.gz)
Ссылки на все уроки:
* [Разработка игрового фрэймворка. Часть 1 — Основы SDL](http://habrahabr.ru/post/166875/)
* [Разработка игрового фрэймворка. Часть 2 — Координаты и отображение](http://habrahabr.ru/post/167035/)
* [Разработка игрового фрэймворка. Часть 3 — События](http://habrahabr.ru/post/167245/)
* Разработка игрового фрэймворка. Часть 4 — Крестики-Нолики
* [Разработка игрового фрэймворка. Часть 5 — Анимация](http://habrahabr.ru/post/169197/)
* [Разработка игрового фрэймворка. Часть 6 — Сущности](http://habrahabr.ru/post/169295/) | https://habr.com/ru/post/167443/ | null | ru | null |
# Теория управления шаговым двигателем (или как вертеть PTZ камеру)
Настал тот редкий случай, когда в работе программиста микроконтроллеров появилась потребность в математике и даже физике. У меня на работе была интересная задача по теме разработки тяжелой (70кг) PTZ камеры.
 Там была задачка по физике из раздела кинематики. Правда по уровню сложности её можно отнести к школьной программе 6го класса.
Шаговые двигатели применяются в CNC станках, 2D/3D принтерах, жестких дисках, сканерах, плоттерах, PTZ камерах, крутилках радарных антенн, турелей, в линейных актюаторах, в стрелочных приборах (аналоговые часы) и может быть еще где-то.
У шаговых двигателей есть одна проблема. Из-за высоких моментов инерции нагрузки шаговые двигатели могут потерять шаги и не отработать команды. Чтобы минимизировать потерю шагов вал шагового двигателя надо раскручивать **плавно**. Самый простой способ - это использовать **трапециевидные** профили движения.
### Постановка задачи
**дано:**
| | | |
| --- | --- | --- |
| **Параметр** | **Пояснение** | **Units** |
| PhiSet | Угол на который надо повернуть вал шагового двигателя | Radians |
| OmegaMax | Максимально возможная угловая частота | Radians/s |
| BettaMax | Максимальное угловое ускорение | Radians/(s^2) |
Дан угол, PhiSet на который следует повернуть вал шагового двигателя. Двигатель работает в трех режимах: ускорение **ACCEL**, работа на постоянной крейсерской скорости **RUN**, замедление **DECEL**. Получается трапециевидный профиль скорости.
Или ускорение **ACCEL** и замедление **DECEL**. Получается треугольный профиль скорости (в случае, если крейсерская скорость OmegaMax очень высока, а угловой путь PhiSet, что надо пройти, очень мал).
В качестве параметров движения даны только ускорение **BettaMax** [rad/s^2] и крейсерская скорость **OmegaMax** [rad/s] в режиме **RUN**. В нулевой момент времени t0 вал трогается с места и начинает набирать угловую скорость **Omega** с постоянным ускорением **BettaMax**. Вычислить момент времени t1, при котором следует остановить ускорение ACCEL и начать вращение на постоянной скорости **OmegaMax** (фаза RUN), и вычислить момент время t2, при котором следует остановить движение на постоянной скорости **OmegaMax** RUN и начать замедление DECEL.
### Примечание
Моменты времени t1 и t2 могут совпадать, если **BettaMax** очень высоко, а **PhiSet** мало. Для симметрии и простоты положим, что ускорение во время набора скорости и ускорение во время замедления по модулю равны **BettaMax**, но противоположны по знаку.
### Терминология
Профиль - это график зависимости угловой скорости от времени Omega(t).
Фаза RUN - движение с постоянной скоростью.
Хороший инженер должен не только решить задачу, но и быть способным внятно объяснить доступным языком свое решение коллегам.
### Решение
Из кинематики известно, что **путь это интеграл скорости по времени**. В данном случае интеграл считать нет смысла так как фигуры простецкие: 2 треугольника да прямоугольник.
Первым делом процессор должен решить нужна ли вообще фаза RUN?
Площадь равнобедренного треугольника равна S0. По сути можно сложить квадрат.
Если phi\_set < S0, то фаза RUN не нужна и получится **треугольный** профиль. Если S0 < phi\_set, то фаза RUN однозначно нужна и получится **трапецевидный** профиль. Как выразить S0 зная **BettaMax**?
угловая скорость в момент времени t2 Получается что S0
Угол который вал заметает при разгоне и остановкеПри треугольном профиле получается, что
Угол который вал заметает при разгоне и остановке### Треугольный профиль (phi\_set <= S0)
Ок. Как же определить t1(время переключения) в случае треугольного профиля? Надо просто решить данную систему уравнений. Выразить t1. t0 можно обнулить.
Эта формула работает только для треугольного профиляУгловая скорость при равноускоренном движенииВыразив OmegaTop из каждой формулы и приравняв их можно выразить t1. Получается
время переключения при треугольном профиле### А теперь случай трапецевидного профиля (S0 < phi\_set)
С t1 просто. Из OmegaMax=BettaMax\*t1 получаем
В трапецевидном профиле площадь состоит из 2х треугольников и одного прямоугольника
ввиду симметрии получим
Выражаем время включения фазы замедления
Как видите все расчеты был составлен чисто из геометрических соображений (площадь графика ω(t) всегда должна быть равна phi\_set ).
Ниже представлен простой алгоритм на языке ДРАКОН, который помогает **наглядно** показать алгоритм вычисления моментов времени t1 и t2 переключения режимов ACCEL/RUN/DECEL при повороте на угол set в условиях заданной скорости OmegaMax в режиме RUN и допустимого ускорения BettaMax.
Вычисление моментов времени t1 и t2 переключения режимов работы шагового двигателя при повороте PTZ камерыРешение на языке MATLAB
```
function [ t1 t2 tf wlim] = calcTimesF( phi_set, w_max, B_max )
S1=((w_max)^2)/B_max;
if(phi_set < S1)
%without RUN t1= t2
t1=sqrt(phi_set/B_max);
t2=t1;
tf=2*t1;
wlim = B_max*t1;
else
%with RUN t1 < t2
t1=w_max/B_max;
t2=(phi_set/w_max);
tf=t2+t1;
wlim = w_max;
end
end
```
Эту задачу в реальности надо решать для дискретного движения, так как в реальности имеем дело с шаговым двигателем. Там заметно усложняется решение. В изменении стадии движения (ACCEL, RUN, DECEL ) приходится ориентироваться не по времени, как в непрерывной постановке, а по пройденному пути (количеству сделанных шагов шагового двигателя). Так как MCU(шка) отлично считает количество положительных фронтов на проводе STEP. Плюс нужна реализация функции квадратного корня на уровне прошивки. Про это есть публикация Asynchronous Control System for Stepper Motor With an Incremental Encoder Feedback.
### Вывод
Как видите обыкновенной школьной математики вполне достаточно, чтобы решать реальные оценочные задачи из prod(a) станкостроения.
При расчетах всегда на каждом шаге проверяйте размерность в формулах.
Если вы программируете микроконтроллеры и вам приходилось прибегать к математике, то пишите это в комментариях.
| | |
| --- | --- |
| **Акроним** | **расшифровка** |
| PTZ | Pan-tilt-zoom |
| CNC | computer numerical control |
**Links**
Online редактор формул <http://latex.codecogs.com/eqneditor/editor.php>
<https://ww1.microchip.com/downloads/en/Appnotes/doc8017.pdf> | https://habr.com/ru/post/709500/ | null | ru | null |
# Ускорение автоматизации тестирования веб-интерфейса за счет применения Python и Selenide
Одной из задач компании RTL-Service, которая занимается разработкой систем локального позиционирования с высокой точностью и обеспечением голосовой связи по зашифрованному каналу, является разработка веб-клиента:
В связи с постоянным развитием веб-клиента (оптимизация, появление дополнительных функций), задача минимизации затрат времени тестировщика и разработчика автотестов является особенно актуальной. Далее приводится опыт ускорения разработки UI-тестов путем применения для этого Selenide и Python сотрудниками нашего отдела тестирования.
Представляется, что Selenide имеет очевидные преимущества. Во-первых, Selenide является верхним программным уровнем Selenium Webdriver, позволяющим сократить время на выполнение стандартных операций Selenium и, как следствие, ускорить написание и поддержку автотестов. Во-вторых, в нашем случае Selenium тесты были написаны на Java, что и обусловило выбор программной платформы на этом же языке.
Помимо прочего, Selenide “из коробки” имеет ряд таких полезных особенностей как: автоскриншоты завершившихся ошибкой тестов, возможность загрузить в одну строчку или скачать файл, быстрое развертывание тестового окружения (одной строчкой open(«http://rtlservice.com/»)) и множество других. При завершении теста ошибкой в консоли появится примерно следующее:
```
Element should not be exist {By.name: infoEdit}
Element: ''
Screenshot: file://build/reports/tests/1458565041545.0.png
```
и полный StackTrace, как обычно.
В данном случае 1458565041545.0.png и есть скриншот окна браузера, где можно увидеть точное место возникновения проблемы.
Поскольку основным браузером для нашей системы является Chrome, где основные сценарии тестируются на Debian 7, на первом этапе возможно столкновение с проблемой инициализации веб-драйвера. После проведения теста на разных системах нашими сотрудниками, был сделан вывод о том, что эта проблема относится скорее к операционной системе, нежели к самой платформе. Для ее устранения был создан экземпляр RemoteWebDriver в коде инициализации с применением chromedriver и передан через статичный метод setWebDriver в Selenide. Для реализации этого способа была соблюдена примерно такая последовательность действий:
1. Установка chromedriver.
2. Запуск chromedriver не под sudo. По умолчанию он запускается на 127.0.0.1:9515.
3. Создание драйвера через аннотацию [before](https://habrahabr.ru/users/before/):
```
@Before
public void openBrowser () throws Exception {
driver = new RemoteWebDriver(new URL("http://127.0.0.1:9515"), DesiredCapabilities.chrome());
WebDriverRunner.setWebDriver(driver);
driver.manage().window().maximize(); // при необходимости разворачиваем браузер
}
```
Кроме того, ещё одним существенным плюсом использования Selenide является наличие расширенных методов по управлению самим элементами в DOM. Если, к примеру, в Selenium все сводится к методу click() с проверкой на isSelected() у элемента, то у Selenide есть возможность выбора чекбоксов/радиокнопок или списков.
Например, в нашем проекте используется OpenLayers, поэтому для более удобной работы со слоями (включение / отключение) в Selenide можно сделать довольно лаконичную конструкцию, которая снимет выделение со всех чекбоксов:
```
for (SelenideElement checkBox : $$(By.tagName("input")).filterBy(Condition.hasAttribute("type", "checkbox"))) {
checkBox.setSelected(false);
}
```
Не менее важным пунктом является использование «умных ожиданий». «Умные ожидания» представляют собой более простой для чтения код без нагромождения WebDriverWait или ожиданий через Thread.sleep с подбором времени появления элемента на глаз.
В случае с Selenide достаточно написать:
```
$(By.id("select-map-div")).waitUntil(Condition.visible, 5000);
```
где 5000 — время в миллисекундах, в течении которого Selenide будет ожидать появления элемента.
На заметку: если вы уверены, что элемент появится в промежутке до 4х секунд, то достаточно использовать только метод should. В этом случае Selenide будет ждать 4 секунды до вывода ошибки. Безусловно, это время можно изменить в конфигурации.
Таким образом, на таких нюансах, Selenide и позволяет в итоге сэкономить много времени как на написание тестов, так и на их поддержку, как минимум при использовании более очевидной конструкции should по сравнению с assert'ами.
Более подробно ознакомиться с возможностями Selenide можно в статье разработчика этого инструмента (<https://habrahabr.ru/post/274071/>).
Вторая важная деталь в ускорении разработки тестов состоит в использовании Python, который добавляет гибкость тестам и применяется для быстрой разработки дополнительных утилит, облегчающих жизнь тестировщикам.
Python повышает гибкость тестов за счет своей интерпретируемости, которая позволяет работать с периодически изменяющимся API. То есть, просто вызывая Python скрипт из Java, можно всегда получать актуальные данные без внесения изменений в код теста, будь то события, местоположение, карты или что-то другое.
Кроме того, появляется возможность делать выборку из базы для получения необходимых данных в процессе обновления структуры этой базы от версии к версии. В нашем случае это используется для получения номеров устройств и дальнейших звонков на них из самих тестов.
Из этого пункта также вытекает возможность использовать как виртуальные, так и реальные устройства в процессе тестирования, заменив выборку из базы на массив MAC-адресов необходимых устройств и запустив тест (иногда таким образом удается выявить проблемы и в прошивках устройств).
Примечательно, что на Python также пишутся скрипты к различным внутренним программам для ручного тестирования, предоставляющие более интерактивную оболочку. Бесспорно, для этого можно применять bash, но, субъективно, у Python порог вхождения ниже и при каких-либо проблемах поправить на нем скрипт будет проще.
Таким образом, с одной стороны, при использовании Selenide нам удалось повысить скорость разработки автотестов на 30% и значительно облегчить их поддержку, а, с другой, при помощи Python удалось добиться гибкости тестов в динамически изменяющейся системе.
Авторы: Николай Федоров, Николай Смирнов | https://habr.com/ru/post/300860/ | null | ru | null |
# Как отрефакторить 2.5 млн строк кода
*Истерический, негативно-позитивный пост добра и ненависти, обо всем и ни о чем, из которого вы узнаете: как папа Крузо встретил маму Робинзона, почему трава зеленая а смурфики голубые, как нам реорганизовать Рабкрин и много других, важных штук.*
Увертюра
--------
Заголовок поста не просто так, я пишу по мотивам реального проекта, которым сейчас занимаюсь. Это ядро коммерческого продукта, который работает уже почти 20 лет и все это время активно развивается, а учитывая, что это «Кровавый Энтерпрайз» и к тому же еще, плюс минус тиражируемый, в нем накопилось всякого разного. Не сказать, что до этого совсем ничего не предпринималось в плане улучшения внутренней структуры проекта, но такой масштабной переработки не было. И у меня, несмотря на 30+ лет опыта работы, не было опыта именно переработки проекта, такого масштаба. Не знаю, у кого как, а для меня это действительно вызов. Самое смешное, что я создал его для себя сам, не то, чтобы проект совсем пиратский, но я занимаюсь этим в рамках проекта по выкорчевыванию библиотек с не пермиссивными лицензиями. Воспользовался, понимаешь, поводом. К сожалению, я начал записывать свои мысли, которые возникали в процессе работы уже ближе к ее окончанию, жаль, наверное, я что-то упущу, но постараюсь восстановить как можно большее.
Многие проблемы, о которых я пишу дальше, очевидным образом проходили через призму моего восприятия, и мои подходы. Я не настолько самонадеян, чтобы считать это истинной в последней инстанции (но достаточно, чтобы этим поделится). И не считаю, что программирование это вот прям наука, поэтому личность человека важна и накладывает отпечаток на результат. Я знаю, что многим не нравится такой взгляд и считают, что может быть только один единственно верный, математически выверенный подход. Я в это не верю, и «верю» тут ключевое слово. Это конечно не значит, что надо писать код абы как и не следовать никаким правилам, best practices (какой гадкий термин) и т.д. Правила необходимо соблюдать, но правило которое я всегда ставлю на первое место: **Правил нет, есть здравый смысл**. Если здравый смысл говорит вам – Делай так! – делайте так, даже если нарушаете какой-нибудь DRY, SOLID и т.д., принципы должны помогать, а не мешать.
Например, больная тема: паттерны, паттерны блин, почему-то вспомнились именно они. Знать о них надо, даже надо с ними ознакомится, по крайней мере с самыми известными, их даже надо использовать, но бесит, когда код пишут паттернами, бездумно, просто потому что они есть, потому что так «правильно», и вместо одной строчки кода у вас тоже строчка + новый файл с классом из десяти строк, и это еще ничего, бывает хуже. Человек пишет калькулятор, калькулятора еще нет, зато уже есть адаптер к провайдеру, и скоро появится фабрика математических операторов.
Я недавно тоже писал калькулятор, ну такой, встроенный в программу, Drop down в полях ввода, нужно было избавиться от существующего там LGPL под капотом и ненужных зависимостей. У меня не случилось ни одной фабрики классов, и вообще их (классов) всего два: собственно калькулятор (вычислитель), и контрол для него (отображатель). Уже много, вычислитель за пределами отображателя нигде не используется и не будет, но мне так больше нравится – легче код читать, да да: MVC, я знаю. Зато я взял в руки реальный, железный (пластиковый) бухгалтерский калькулятор, потыкал в него. Опросил наших бухгалтеров – А вам правда нужны M+, M-? Еще как нужны, оказывается. Зато история вычислений с промежуточными результатами – не нужны. Т.е. вообще-то нужны, и еще как, но пользоваться не будут – не привыкли. Знайте, если с вашим ПО работают бухгалтеры, то, наверное, они сидят за десктопами, а не за ноутбуками с их ублюдочными клавиатурами и Num Lock у них всегда включен, правая рука, как коршун висит над цифровым блоком. Это знание может пригодится, например при расстановке ShortCut’ов и прочей клавиатурной навигации. **Num Lock важен, Singleton нет!** А еще они прошаренные пользователи (я не шучу) и клавиатуру используют в хвост и гриву, т.ч. **Tab Order важнее Pixel Perfect** (наезд на дизайнеров). *Люблю интерфейсы, и у меня есть что сказать и про Material Design’ы всякие, и про бухгалтерские интерфейсы в стиле MS Access, но совсем не тема поста – а жаль.*
P.S. Историю вычислений я все равно сделал, и память с произвольным доступом и даже возможность определения собственных констант (ну зачем бухгалтеру π, когда есть ставка чего-то там, про что я никогда не слышал).
Проект, по мотивам которого я пишу этот пост, написан на Паскале (Delphi), поэтому примеры, в основном будут на нем, но большинство тем достаточно общие, много кода не будет и надеюсь он будет понятен, что-то специфичное для Паскаля я постараюсь отмечать и объяснять.
Рефакторинга нет
----------------
Или есть, или нет… Когда меняешь дурацкое название переменной — это рефакторинг? Ну да, маленький, но рефакторинг. А когда переписываешь бездонное море кода в ядре системы? Кажется, что уже что-то другое, но формально – функциональность системы то не меняется, меняется только легкость поддержки и развития. А если меняются другие потребительские качества, например быстродействие? Где грань? Оставлю эту тему теоретикам.
Самое интересное, что я про него выяснил: **нет никаких особых правил рефакторинга**, все тоже самое, как при разработке нового и доработке существующего - можно заканчивать статью. Зато смещается система приоритетов. Работая с уже написанным кодом, смотришь на него как-бы новым взглядом, даже если это куски твоего собственного старого кода. Когда пишешь что-то новое у тебя в голове есть стройная картинка, ты в потоке, и все самой собой разумеется, а в реальности глаз замылен. Проходит время и все уже не так очевидно: многословно, слишком сложно, нелогично и непонятно... **Делайте рефакторинг часто, но не слишком**, когда новый взгляд уже есть, но не раньше и лучше не позже. Чем раньше вы облегчите себе и вашим коллегам жизнь, тем лучше. Делайте Code Review, рефакторинг может не понадобится, у нас его нет – пичалька, попробуем замутить.
Что делать
----------
> На извечные вопросы русской интеллигенции: Что делать и Кто виноват, есть два ответа: Ничего не делать, никто не виноват; Зимой мерзнуть, летом потеть. Анекдот советских времен
>
>
Нельзя просто так взять и сделать рефакторинг, скорее всего вы уже хорошо знаете проект изнутри и представляете себе степень бедствия. Но все равно надо с чего-то начать. Открою страшную тайну: не важно с чего вы начнете, главное ввязаться в битву. Например, проведите ревизию используемых фреймворков, библиотек и прочих зависимостей. Вот вроде бы я главный разработчик и провожу рефакторинг своего проекта, который я не плохо знаю изнутри, а в процессе такой ревизии обнаружил аж пять ZLib’ов. Пять! Карл!
Провели ревизию, теперь наведите уже порядок в своем королевстве, а то у вас свиньи, а не верноподданные! Бродят, где хотят. Поставьте их на место. Скорее всего у вас уже есть модули, библиотеки общего назначения, если нет (серьезно!?) – создайте. Переносите туда все, что у вас есть общего назначения, сплошь и рядом встречаю какие-нибудь там строковые функции в модуле работы с БД. Оформляйте их (библиотеки) как самостоятельный продукт, представьте себе, что вы будете их распространять, и даже продавать, вне зависимости от основного продукта. Выстроите четкую иерархию использования, только в одну сторону, никаких обратных или кросс связей. Должно получиться что-то такое:
Получите более компактный код на каждом уровне выше, обнаружите кучу функций, дублирующих друг друга (я вам обещаю), станет легче ориентироваться в коде – понятно, где и что лежит, как минимум, где искать. Сплошной профит. Обязательно выносите всё платформенно зависимое в отдельные модули, прикрывайте их платформенно независимыми абстракциями. Я вот выношу, а абстракции оставил «на будущее» - не хватает времени. В самый, самый базовый модуль засуньте компиляторо-зависимые объявления. Например, если вам нужно собираться на старой версии системной библиотеки, и там не хватает типа, которой есть в более свежей версии, IFDEF вам в помощь.
Как метод, вообще создайте новые библиотеки, и переносите туда из старых, по мере востребованности, очень интересно смотреть, какой мусор остается в старых. И он есть, я обнаружил много не используемого. На начальном этапе, изменения были настолько тектонические: создавались и удалялись папки, массово менялись названия файлов, что-то прибывало, что-то убывало, что я это даже в SVN не заливал. Кстати, про репозитории, не вздумайте все это делать на старом репозитории – создайте новый. В старом, только если у вас не такой тотальный разгром, как у меня.
Тестируйте! Обязательно! Я не поклонник TDD, но это не значит, что тесты не нужны. Когда я дошел до тестирования API ядра, ошибок почти не было, а все почему: ~~а потому что у меня раньше велосипеда не было~~ библиотеки протестированы, кода стало меньше, и он стал более воздушный. Тестировать нужно, 100% покрыть все тестами заранее – ну пробуйте, я и пробовать не стал.
Размер имеет значение. Мало плохо, много – тоже плохо. Должно быть «в самый раз». В среде Delphi программистов есть такая тенденция: делать методы на сотни строк и с кучей параметров, юниты на бесконечные тысячи строк. Такое ощущение, что про декомпозицию никто не знает. В среде модных паттерн-программистов обратная тенденция: всякие Import и Uses занимают большую часть текста, и слева (или справа) у вас бесконечная портянка из папочек, в которых папочки, в которых фолдеры, в которых директории. В них файлы. Текста в файлах кот наплакал. Я даже не знаю, что хуже. Воздержание! Воздержание!
Про жизнь
---------
Лучшая работа – которую не надо делать. И кодирование не исключение.
Попробуйте рефакторинги встроенные в IDE. У меня не взлетело, единственное чем я реально пользуюсь, это переименование. Удобно, если работает. Все остальное – нет. Не так и не то. По крайней мере у меня не зашли всякие там «Extract interface», ни в одной IDE, которой я пользовался. Я не настаиваю, если вам удобно – славно, повезло! Для меня самый удобный рефакторинг – Ctrl+R/Ctrl+H, Replace мощная штука, только регулярки я пишу со скрипом, ну никак они мне не даются. Говорят, у IntelliJ с рефакторингами хорошо, не знаю, не довелось, к сожалению. Но попробуйте обязательно, если еще не пробовали.
Другой способ ничего не делать: взять готовое (ага, выше выкидывали, теперь берем). Писать собственный парсер JSON невероятно интересная задача, и столь же глупая. Возьмите готовую библиотеку. Но и это еще не все, если вы возьмете нашу библиотеку прямо сейчас, то совершенно бесплатно получите в нагрузку лицензию и смену версий, включая отсутствие поддержки устаревших версий. И тут в дело вступает реальность, во всей своей красе. Если вы пишите собственный проект, или просто одноразовый – это одно, можно не заморачиваться и использовать то, что лучше всего подошло. Если внутренний или под заказчика, но долгоживущий – другое, если же, как у нас, долгоживущий, тиражируемый, обросший кучей зависимостей, кастомизаций, интеграций и сертификаций – ~~это капец~~ совсем другое.
С лицензиями все более-менее понятно, есть политика фирмы или продукта, например разрешающая только пермиссивные лицензии, до свидания весь LGPL, MPL и прочая. Так что приходится бить по рукам, в первую очередь себя любимого, когда так и подмывает выкинуть кусок кода и заменить готовым, который написали люди поумнее меня, да и база пользователей у него несравнимая. Но, нет – нельзя. Но проблема решаемая, обычно есть что-то с лицензией Apache, MIT или BSD. Если все совсем плохо, есть коммерческие библиотеки или, иногда, можно купить коммерческую лицензию на Open Source продукт. Если денег дадут, конечно. Обычно дают, если сказать: «Очень надо», но это у нас фирма хорошая, не всем так повезло. Если чувствуете себя в силах – пишите сами, в конце концов, кто-то же написал все эти клевые библиотеки? Чем вы хуже? Создайте еще одну, свою, лучшую, уникальную, двигайте технологии вперед. Были бы идеи.
С версиями все гораздо сложнее, притащив себе что-то в ~~постель~~ проект, нужно отдавать себе отчет, что вам с этим дальше жить. Если на раз, можно и не париться особо, а если надолго? Выбирайте как жену/мужа, **избегайте беспорядочных связей со сторонним ПО**. Нужно понимать, что вам придется регулярно обновлять весь код, работающий с этой библиотекой, поддерживая работу ее актуальных версий. Если этого не делать, пройдет несколько лет и вы останетесь с тыквой на руках. Надо, просто обязательно, думать об этом заранее, и это не простой выбор: взять и поддерживать актуальность, залить себе в кодовою базу и держать как свое или сразу пилить свое. Оценивайте плюсы и минусы: как это скажется на затратах сейчас и в будущем, как скажется на качестве кода, на возможности развития? Смотрите на историю проекта, как они развиваются, как относятся к обратной совместимости. Сложно, особенно сложно если у вас фронтенд, я безумно рад что у нас его можно сказать что и нет. Ну правда, не представляю себе на чем сейчас писать проект со сроком жизни в годы и даже десятки, ванильный JS и все? Или таки тащить React/Angular/Vue, с их бешенным темпом развития? Или Vaadin? Или переписывать все 5-тыс форм каждые несколько лет? Ужос страшный, и не моя головная боль (хотя я, конечно, знаю, что делать, но не скажу). Как хорошо жить с РСУБД, SQL не меняется десятилетиями – вот что значит грамотный дизайн.
Вот мы и перешли, плавно, к самым страшным словам на свете: Обратная совместимость. Я знаю, руки чешутся, всё зудит… НО! Если вы кого-то на что-то подсадили, всё! Забудьте и не смейте трогать! Добавлять можно, исправлять и улучшать можно – менять, тем более удалять, нельзя! Кое-что конечно сделать можно. Предположим, у вас есть, НЕЧТО, работающее так-то, вас не устраивает как оно работает. Добавляете настройку или параметр или новый header: Старый вариант, Новый вариант, по умолчанию - Старый. Или как-то так: «Версия 1», «Версия 2», «Версия N». Если у вас форматы протоколов, файлов, API – вводите версии форматов, если их еще нет. Без них никак, потом замучаетесь.
Главное, не забудьте, старое должно работать по-старому. Новое – как хотите.
Про совместимость в коде, бывает страшное, вы сделали что-то нехорошее, хак, и не уверены, что в следующих обновлениях компилятора, базы данных, ОС — это будет работать. Не делайте так! Но иногда очень надо, «ну позязяаа, можно я сделаю каку?» и взгляд кота Шрека. Отмечайте это как-то, лучше всего если на этапе компиляции, вот так:
```
{$IFDEF CompilerVersion <= 42}
DoShit;
{$ELSE}
У тебя не тестированная версия Delphi! Проверь каку!
{$ENDIF}
```
Компилятор просто свалится на этом куске. Повторюсь, делать так можно только в самом, самом крайнем случае, если остальные варианты еще хуже.
Часто, вопрос совместимости возникает, потому что решили частную проблему, здесь и сейчас. Ну как-же: не заниматься преждевременной оптимизацией, не плодить абстракции раньше времени – херь полная. Хотите создать себе, или другим, страшный геморрой в будущем, не думайте о нем. Затраты на переделку гораздо больше, чем сделать сразу. Иногда, переделать совсем невозможно. Да вы не сможете сразу сделать все правильно, но, чаще всего, это вылезет еще на этапе начальной разработки, когда у вас уже есть зависимости, это делать сложнее. Все знают про снижение зависимостей: интерфейсы там всякие, DI, API абстрактный… И какой DI, какой API, если вы сразу не подумаете о абстракциях? У вас высоконагруженный сервис, а вы фигачите сериализатор на RTTI (Reflection), и протокол к нему в нагрузку соответствующий. Знаете, каково это потом выковыривать? Делайте сразу абстрактную прослойку (Middleware), будут вам и протоколы и сериализаторы на любой вкус. И не забудьте сделать их Zero Copy, ага, если сможете. Ну хоть кольцевой буфер, где-то в конце прослоек, не больше. Думайте о будущем! **Make future great again!**
Наплодили абстракций, по всему коду приведения типа, плохо наплодили, плохо использовали! Нет, приведение типов нужно, но, если его видите, возьмите лупу, рассмотрите получше. Это как насморк, ничего страшного, но может быть симптомом чего-то нехорошего. Например, Delphi программисты (опять про них, но это потому, что я этот мир лучше знаю. В вашем мире другие примеры, ничем не лучше) часто настолько не любят абстракции, что вообще не используют специализированных типов, особенно для внутреннего использования. ~~Натягивают сову на глобус~~ повсеместно используют TStringList, TList и т.д. куда запихивается все что не попадя, ну что сложно сделать свой тип элементов контейнера, унаследовать от TList свой класс? И это если вы сидите на древней версии, а если на новой? Вам и Generic’ов завезли, и контейнеров на них, на любой вкус, и Record’ы вам с сокрытием видимости, методами и перегрузкой операторов. Не, всё в StringList и потом: TEdit(List.Objects[Index]), тьфу на вас. Хорошо спроектированные типы залог успеха! Они упрощают программу, дают возможности для оптимизаций, сокращают кол-во ошибок.
Ура! Сделали типы! Теперь в них так:
```
TMyClass = class
Name: string;
```
Не используйте публичные поля, у вас есть property и IDE пишет их за вас.
```
TMyClass = class
private
FName: string;
procedure SetName(const Value: string);
public
property Name: string read FName write SetName;
```
Обратили внимание на public/private, тоже бывает ленятся. Все публичное в property! Делайте на автомате, думать не надо. А то мне потом breakpoint ставить некуда.
Свойства есть, пора подумать о конструкторах (Внимание!!! это рекомендация для Pascal). Всегда вызывайте унаследованный конструктор в конструкторе, даже если он не виртуальный (разработчики C++ бьются в истерике), даже если в суперклассе его нет. Все равно вызывайте. Вы не знаете, что еще запихнет разработчик суперкласса в свой конструктор. А если он изменит его сигнатуру, вы сразу об этом узнаете. Бывают случаи, когда этого делать не надо, но это редкость и скорее всего ошибка проектирования.
Данные есть, объекты создаются, теперь они должны себя «вести». Пора лепить методы. Раньше я любил делать методы с параметрами по умолчанию, теперь меньше люблю. Предпочитаю перегруженные методы, они более специализированные, соответственно проще, понятнее и часто, быстрее. В любом случае, думайте о сигнатурах методов! Лучше дайте разные названия, чем потом искать почему «происходит что-то странное».
Давайте методам имена в одном стиле, например, типичные для Delphi:
* Something – просто метод: собственно поведение;
* DoSomething, DoBeforeSomthing, DoAfterSomething – виртуальные методы, с высокой вероятностью вызывающие события (делегаты). Вызываются в Something, интерцепторы;
* HandleSomething – то что вешается на события других классов;
* GetSomething, SetSomething – понятно.
Сразу понятно, о чем речь. Если у вас большой класс, разбивайте внутри модификаторами доступа, ничего страшного если у вас несколько private и protected секций, зато сеттеры отдельно, делегаты отдельно, реализации интерфейсов отдельно (комментируйте, какой интерфейс реализуете). Внутри сортируйте по алфавиту, все равно не сможете расположить члены класса в некоем «логически верном» порядке. А по алфавиту хоть искать проще.
Используйте правильные модификаторы для параметров. Если с var параметрами, обычно, нет проблем их просто надо ставить «по логике», то с out и const, часто не заморачиваются, а зря. Думаю, понятно почему, и семантика сразу ясна, и защита от ошибок и Warningи не кидаются.
Не забываем про компилятор, в Pascal, например, передача всякой динамики (строки, динамические массивы, Variant) и интерфейсов в const параметры существенно оптимизируется, аргументы не копируются в записи активации, не ведется подсчет ссылок. Не поддаются счету такты процессора и ячейки памяти, которые я сэкономил, просто проставив const, где его не было. Ставьте const не думая, если что, компилятор вам напомнит. Если ваш такого не умеет - плохо. Но тогда и модификаторов нет, скорее всего.
Вот и вернулись к «преждевременным» оптимизациям. Оптимизации оптимизациям рознь. Есть эффективные и дешевые, как const параметры, есть дорогие и сложные. И, как правило, сложные не дают кратного роста эффективности, это последний рубеж, когда эффективность дороже затрат. Часто простые оптимизации, отталкивающиеся от знания предметной области, гораздо эффективнее чем от математики или знания нюансов работы процессора. Вот пример:
```
function TQuery.FindField(const FieldName: string): TField;
var
I: Integer;
begin
for I := FLastFieldIndex to Fields.Count - 1 do
if Fields[I].FieldName = FieldName then
begin
Result := Fields[I];
FLastFieldIndex := I;
Exit;
end;
for I := 0 to FLastFieldIndex - 1 do
if Fields[I].FieldName = FieldName then
begin
Result := Fields[I];
FLastFieldIndex := I;
Exit;
end;
Result := inherited FindField(FieldName);
end;
```
В чем фишка? Это переопределение системного метода FindField, который в цикле перебирает все поля, пока не найдет нужное, причем регистр не учитывается, т.е. там циклический вызов Юникодного сравнения строк без учета регистра – медленно. Из каких предположений написан этот код:
* Я знаю, что в нашей системе, все или почти все вызовы, делаются в правильном написании, т.е. мы можем использовать просто равенство, бинарное сравнение гораздо быстрее.
* Получение значения одного поля в цикле, LastFieldIndex его покрывает.
* Перебор множества полей в цикле, довольно часто порядок перебора и порядок в запросе одинаковы, LastFieldIndex нам в помощь.
Все это не нужно, если не лениться биндить поля на переменные перед циклом – супероптимизация! **Лень не всегда двигатель прогресса.**
Другой пример. Есть такой код, в системной библиотеке, который мы раньше использовали, пишет Variant’ы в поток (часть сериализатора), и там метод для записи вариантных массивов. Обобщенный, не в смысле Generics, а в смысле что может писать многомерные массивы (код приводить не буду – его слишком много). Код там довольно сложный, и это понятно. Но давайте посмотрим правде в глаза, вы когда последний раз использовали многомерные Variant array? Вообще многомерные массивы? В 100 случаях из 100, это одномерный массив. Ну и пишем простой код, для одномерного массива: длина, элемент. Быстро, просто, эффективно. Старый запихиваем в else, если все-таки встретится многомерный. Идем дальше, очень часто, в таких массивах передаются просто двоичные данные, т.е. это массив чисел. Вспоминаем, что есть волшебная функция VarArrayLock (SafeArrayLock в WinAPI). Возвращает нам ссылку на память, занятую этим массивом, этот блок упакован, ну и пишем его целиком. Никакого копирования памяти при этом не происходит, т.е. представьте себе, мегабайтный массив, в первом случае это миллион раз получить элемент массива, с проверкой индекса, промежуточным копированием значения, во втором никаких проверок, никаких копирований сразу пишется куда надо, и все. Практически бесплатно. Сложная оптимизация? Дорогая?
Make Up
-------
Вы можете выглядеть, как угодно, и даже доедать завтрак из бороды во время презентации, мне плевать кто и что думает о моей внешности, но ваш код обязан быть элегантным, и не только своими решениям, но и внешне. Вы слышите меня ~~бандерлоги~~ пытающиеся запихнуть в одну строчку кода как можно большее? Краткость сестра таланта, но не во вред читабельности. Правила просты и не новы, и все равно, сплошь и рядом жуткая жуть.
Придерживайтесь единого стиля написания кода, даже если он вам не нравится. Если, как в моем случае, все написано в разнобой, приводите к одному стилю, и да, в этом случае, у вас есть возможность выбора. Но не очень большая, по моему мнению надо писать в некотором «общепринятом» стиле, я за основу взял стиль в оформлении и именовании принятый в системной библиотеке (скажем: наиболее распространенный в системной библиотеке).
Даже если язык не чувствителен к регистру, пишите так как будто чувствителен. Повышается читаемость, улучшается поиск. Если чувствителен, не злоупотребляйте этим, мне, лично, не нравится распространённая практика использовать одинаковые идентификаторы для свойств, в CamelCase, и соответствующих им полей класса, в lowercase. Но я их использую, если такова практика, например в C# часто такое. Но предпочитаю так: \_lowerCamelCase.
Именование идентификаторов. Во всем надо знать меру, я не люблю короткие имена, но злоупотреблять излишне длинными, тоже ни к чему: FWDDEOF - ужасно, как и FindWordByDifferentDelimitersFormEndOfFile (нужна ли вообще такая функция – отдельный вопрос). Я для себя придумал следующее правило: В цепочке вызовов не должно быть масла масляного, и должно быть понятно, о чем речь:
· Entity.EntityTable.TableName – плохо;
· Entity.Table.Name – хорошо.
Именование счетчиков, не надо их называть ItemIndex, достаточно I, J, K… Хотя если дошли до K, остановитесь, наверное, что-то пошло не так.
Пример из жизни, как плохо жить с непонятным кодом. Имеем следующее:
`procedure TProvider.ProcessLF(ads,dds:TDataset;sads:TQueryDataset);`
Что имеем (кроме эмоций):
1. Экономию пробелов, в дефиците были;
2. LF в названии метода. Вы знаете, что такое LF? Я тоже не знаю. Line Feed?
3. ads, dds, sads – ну теперь то стало понятнее! Что, не стало? Мне тоже нет.
Лезем в код, ага, LF это Linked Fields. Про DS’ы ясно только одно – это TDataset. Что делает метод, тоже не особо понятно, из кода не очевидно, верьте мне. Ищем вызовы метода, ага «ads» – SourceDS, «dds» – DeltaDS, становится яснее. Я знаю, что это такое, более того именно так они называются в системной библиотеке. Остался «sads», и это… барабанная дробь! Тоже самое, что и SourceDS, но приведенное к конкретному типу. Тупо переименовываем, и получаем:
`TProvider.ProcessLinkedFields(SourceDS: TQueryDataSet; DeltaDS: TDataSet);`
Уже гораздо лучше. Еще немного рефакторингов, и конечный результат:
`TLinkedFieldList.Build(const SourceDS: TQueryDataSet; const DeltaDS: TCustomClientDataSet);`
Вызов:
`Provider.LinkedFields.Build`
Кроме всего прочего, код в Build, сократился вдвое, за счет устранения ненужных преобразований, приведений типов и проверок.
Комментарии. Кажется уже всем плешь проели: Пишите их только если что-то нельзя понять из кода, описывать код не надо. Надо писать так, чтобы и без них все было понятно. И все равно… Правильные комментарии:
`//Workaround VCL bug, QC #12345678`
`//TODO: Вынести в настройки`
Отстой:
`Counter: Integer; //Счетчик записей`
`Document.Delete; //Удаляем документ`
`OM = $08; // FPU Overflow interrupt mask`
Лучше так:
```
FPUOverflowMask = $08; // Комментарий уже не нужен
{ Вариант для эстетов: }
{$SCOPEDENUMS ON}
TFPUControlMask = (
…
Overflow = $08
);
```
«Магические» константы. Ну даже писать ничего не буду, но они все равно есть. Вот почему Copy(S, I, 99999) вместо Copy(S, I, MaxInt)!? И это еще не самое худшее.
Все знают, если есть повторяющийся кусок кода, наверное его надо вынести в отдельный метод. Но я часто выделяю код в отдельный метод, или чаще локальную функцию, просто для повышения читабельности, даже если в этом нет другого смысла. Например, у вас есть длинный метод, с циклом, скажем. Внутри цикла сложная проверка, и если она выполняется, делаем одно, если нет – другое. Если кода много (в экран не влазит), я разбиваю, проверка в отдельной функции, действия при True в другой, при False в третьей. Читабельность резко повышается.
Доктор едет-едет
----------------
Верьте себе! Не верьте себе!
Иногда бывает, что вы смотрите на код и он вам не нравится, непонятно чем, но с ним «что-то не так». Подумайте, почему у вас такая реакция на этот код, что именно «не так»? С высокой вероятностью обнаружится какая-либо проблема и/или пути улучшения кода. Очень часто наши интуитивные реакции оказываются верными. **Верьте себе**!
Из наблюдений за собой, основной источник плохого кода: доведение кода до рабочего состояния: вот здесь подправлю, тут добавлю, а еще это не так работает… Тяп ляп, во – работает. Закончил кусок, посмотри на него снова, оцени.
Основной источник дублирования кода – память (ваша, а не комьютера), невозможно удержать все фреймворки и библиотеки, со всеми их возможностями в памяти, вот и появляется дублирование. Не пишите функции там, где не надо, просто потому что они вам понадобились именно здесь. Найдите им «правильное» место, возможно там ее и найдете. А вообще не знаю, как решать проблему системно.
Системное мышление порождает несистемные проблемы. Если я вижу, что какие-то классы содержат похожий набор методов, реализующих сходное поведение, я сразу-же «на автомате» начинаю выделять общий базовый класс, интерфейс, агрегат. Потом оказывается, что этот интерфейс нигде и не используется, так зачем плодить сущности? Выделить интерфейс, если он нужен, всегда успеется. Тем не менее, однозначно есть повод призадуматься. И тогда могут открыться интересные вещи, а могут и не открыться.
Иногда, я захожу в тупик, проще говоря начинаю пороть уйню, или просто тупить. **Не верьте себе!** Следите за собой, если почувствовали, что всё, приехали - остановитесь, переключите задачу. Вообще переключите область деятельности, займитесь спортом, напейтесь, сварите борщ. Мозг рано или поздно вернется, но не надо его насиловать, это неприятно и вредно для него и для работы. Я, вот, пишу этот пост.
Катарсис
--------
Может сложится впечатление, что я переделывал какой-то ад кромешный — это не так, понятно, что я приводил самые вопиющие примеры, не все так плохо. Но все равно эта работа вымотала меня окончательно.
Жалею ли я, что ввязался в это? – ни на грамм. Я давно не испытывал такого кайфа. Улучшать, создавать для продукта перспективы на будущее развитие – огромный кайф!
Кода
----
Я, на разных этапах, давал почитать этот пост разным людям, и собрал много критики: словоблудие сплошное, слишком длинно, непонятно на кого рассчитано, плохо структурировано, вот это так делать нельзя… Каюсь, все правда, со всем согласен! И всё равно, я не стал ничего править и публикую в том виде, в каком есть. Дело в том, что это не мой пост, он сам себя написал, мне не было сложно его писать, он такой родился. Сам собою. И я не хочу его предавать, пытаясь улучшить и переделать, тем более не публиковать.
За сим откланиваюсь, желаю всем в новом году сделать что-нибудь хорошее, доброе, вечное, так как год ожидает быть… Пошел стругать ~~Буратину~~ оливье. Пока! | https://habr.com/ru/post/707982/ | null | ru | null |
# Двусторонний binding данных с ECMAScript-2015 без Proxy
Привет, уважаемые читатели Хабра. Эта статья некое противопоставление недавно прочитанной мной статье [«Односторонний binding данных с ECMAScript-2015 Proxy»](https://habrahabr.ru/company/rtl-service/blog/309978/). Если вам интересно узнать, как же сделать двусторонний асинхронный биндинг без лишних структур в виде Proxy, то прошу под кат.
Тех, кому не интересно читать буквы, приглашаю сразу понажимать на эти самые буквы [DEMO binding](http://plnkr.co/edit/YXC6J0h7kvyWxSE5xwW8?p=preview)
Итак, что же меня смутило в той статье и мотивировало на написание своей:
1. Автор говорит о связывании данных, но описывается реализация **observer**`а. Т.е. подписка на изменение свойств объектов. Конечно, с помощью колбэков, можно реализовать связывание, но хочется как-то попроще. Сам термин связывание предполагает простое указание соответствия значения одной единицы хранения значению другой.
2. Не очень удачная реализация асинхронности —
> setTimeout(()=> listener(event), 0);
При минимальном таймауте все нормально, функции подписчики вызываются одна за другой через постоянный минимальный интервал (вроде как 4mc). Но что если нам необходимо увеличить его, например, до 500 мс. Тогда просто произойдет задержка на заданный интервал и потом все функции будут вызваны, но также с минимальным интервалом. А хотелось бы указать интервал, именно, между вызовами подписчиков.
3. И еще немножко — незащищенность полей общего хранилища от прямой перезаписи, нет реализации привязок DOM → JS, DOM → DOM.
Ну что ж, хватит умничать, самое время показать свое «творчество». Начнем с постановки задачи.
**Дано:**
* «чистые» JS объекты и DOM элементы.
**Задание:**
* Реализовать двустороннюю привязку данных между любыми типами объектов (DOM – JS, JS – DOM, JS – JS, DOM – DOM).
* Реализовать асинхронность привязок с возможностью указания таймаута
* Реализовать возможность подписок на изменение свойств (навешивание функций наблюдателей) для расширения функционала привязок.
* Реализовать распределенное хранилище привязок с защитой о прямой записи.
**Решение:**
Основные идеи реализации:
1. Никаких общих хранилищ создаваться не будет, каждый объект будет хранить свои привязки сам. Создадим отдельный класс таких объектов. Конструктор этого класса будет создавать новые объекты или расширять существующие объекты нужными нам структурами.
2. Необходим функционал перехвата доступа к свойствам объекта, но без создания лишних структур в виде **proxy** объектов. Для этого отлично подойдет функционал геттеров и сеттеров (**Object.defineProperty**) определенный еще в ECMAScript 5.1.
3. Для последовательного асинхронного биндинга реализуем очереди. Попробуем использовать для этого **setTimeout + Promises**.
Реализация:
1. Структура класса Binder:
*Рис. 1 — схема класса Binder*
Static:
* **hash** — вычисляет хэш функции, будет использоваться для индентификации функций наблюдателей
* **delay** – реализация таймаута в асинхронной очереди
* **queue** – создает асинхронную очередь
* **timeout** – getter/setter для \_timeout
* **\_timeout** – таймаут по умолчанию
* **prototypes** – хранит прототипы для «расширенных» объектов
* **createProto** – создает прототипы для «расширенных» объектов
Instance:
* **«transformed properties»** — свойства объектов преобразованные в getter/setter
* **\_binder** – служебная информация
* **emitter** – указывает на объект который в текущий момент инициирует привязку
* **bindings** – хранилище привязок
* **watchers** – хранилище наблюдателей
* **properties** – хранилище свойств – значений которые были преобразованы в getter/setter
* **\_bind / \_unbind** – реализация привязки / отвязки
* **\_watch / \_unwatch** – реализация подписки / оптиски
2. Конструктор класса:
```
constructor(obj){
let instance;
/*1*/
if (obj) {
instance = Binder.createProto(obj, this);
} else {
instance = this;
}
/*2*/
Object.defineProperty(instance, '_binder', {
configurable: true,
value: {}
});
/*3*/
Object.defineProperties(instance._binder, {
'properties': {
configurable: true,
value: {}
},
'bindings':{
configurable: true,
value: {}
},
'watchers':{
configurable: true,
value: {}
},
'emitter':{
configurable: true,
writable: true,
value: {}
}
});
return instance;
}
/*1*/ — Проверяем, если конструктор был вызван без аргументов, то создаем новый объект. Если был передан объект то модифицируем его. Статический метод `createProto` см. описание /*8*/
/*2*/ — /*3*/ — Указываем объекту поле-обертку `_bunder`, и записываем в него хранилище привязок, хранилище наблюдателей и значения свойств, которые подверглись трансформации. Поле «emitter» будет указывать на инициатора биндинга, но об этом чуть позже. Все свойства указываются через дескрипторы, таким образом защищаемся от прямой перезаписи (`writable: false`).
```
3. Статические методы класса:
```
/* Очередь и таймауты */
/*4*/
static get timeout(){
return Binder._timeout || 0;
}
/*5*/
static set timeout(ms){
Object.defineProperty(this, '_timeout', {
configurable: true,
value: ms
});
}
/*6*/
static delay(ms = Binder.timeout){
return new Promise((res, rej) => {
if(ms > 0){
setTimeout(res, ms);
} else {
res();
}
});
}
/*7*/
static get queue(){
return Promise.resolve();
}
/*4*/-/*5*/— Геттер и сеттер для статического свойтсва `_timeout` задающего таймуат по умолчанию для асинхронной очереди. В принципе, геттер и сеттер тут ни к чему, но синтаксис ES6 не позволяет в описании класса указать статические свойства-значения.
/*6*/-/*7*/ метод queue задает начала асинхронных очередей, в которые будут добавляться задачи. Метод `delay` возвращает промис, который будет "зарезолвен" по истечении указанного таймаута или таймаута по умолчанию. При этом вся асинхронная очередь будет ждать.
```
```
/* Модицикация объектов */
/*8*/
static createProto(obj, instance){
let className = obj.constructor.name;
if(!this.prototypes){
Object.defineProperty(this, 'prototypes', {
configurable: true,
value: new Map()
});
}
if(!this.prototypes.has(className)){
let descriptor = {
'constructor': {
configurable: true,
value: obj.constructor
}
};
Object.getOwnPropertyNames(instance.__proto__).forEach(
( prop ) => {
if(prop !== 'constructor'){
descriptor[prop] = {
configurable: true,
value: instance[prop]
};
}
}
);
this.prototypes.set(
className,
Object.create(obj.__proto__, descriptor)
);
}
obj.__proto__ = this.prototypes.get(className);
return obj;
}
/*8*/— Используется в конструкторе класса. Встраивает в цепочку прототипов объект с необходимыми методами. Если необходимо создает новый объект прототипа, либо берет уже созданный из статического хранилища класса - `Binder.prototypes`
```
```
/* Модицикация объектов */
/*9*/
static transform(obj, prop){
let descriptor, nativeSet;
let newGet = function(){ return this._binder.properties[prop];};
let newSet = function(value){
/*10*/
let queues = [Binder.queue, Binder.queue];
/*11*/
if(this._binder.properties[prop] === value){ return; }
Object.defineProperty(this._binder.properties, prop, {
configurable: true,
value: value
});
if(this._binder.bindings[prop]){
this._binder.bindings[prop].forEach(( [prop, ms], boundObj ) => {
/*12*/
if(boundObj === this._binder.emitter) {
this._binder.emitter = null;
return;
}
if(boundObj[prop] === value) return;
/*13*/
queues[0] = queues[0]
.then(() => Binder.delay(ms) )
.then(() => {
boundObj._binder.emitter = obj;
boundObj[prop] = value;
});
});
queues[0] = queues[0].catch(err => console.log(err) );
}
/*14*/
if( this._binder.watchers[prop] ){
this._binder.watchers[prop].forEach( ( [cb, ms] ) => {
queues[1] = queues[1]
.then(() => Binder.delay(ms) )
.then(() => { cb(value); });
});
}
if( this._binder.watchers['*'] ){
this._binder.watchers['*'].forEach( ( [cb, ms] ) => {
queues[1] = queues[1]
.then(() => Binder.delay(ms) )
.then(() => { cb(value); });
});
}
queues[1] = queues[1].catch(err => console.log(err));
};
/*15*/
if(obj.constructor.name.indexOf('HTML') === -1){
descriptor = {
configurable: true,
enumerable: true,
get: newGet,
set: newSet
};
} else {
/*16*/
if('value' in obj) {
descriptor = Object.getOwnPropertyDescriptor(
obj.constructor.prototype,
'value'
);
obj.addEventListener('keydown', function(evob){
if(evob.key.length === 1){
newSet.call(this, this.value + evob.key);
} else {
Binder.queue.then(() => {
newSet.call(this, this.value);
});
}
});
} else {
descriptor = Object.getOwnPropertyDescriptor(
Node.prototype,
'textContent'
);
}
/*17*/
nativeSet = descriptor.set;
descriptor.set = function(value){
nativeSet.call(this, value);
newSet.call(this, value);
};
}
Object.defineProperty(obj._binder.properties, prop, {
configurable: true,
value: obj[prop]
});
Object.defineProperty(obj, prop, descriptor);
return obj;
}
/*9*/ - функция `transform` трансформируется свойства объекта. Если это JS объект, то значение свойтства записывается в `obj._binder.properties`, само свойство преобразуется в геттер/сеттер. Если же это DOM объект, то делает обертки над нативными геттером/сеттером.
/*10*/ - стартуем две асинхронные очереди для привязок и наблюдателей.
/*11*/ - проверяем если значение переданное в сеттер не отличает от текущего значения свойства то ничего не делаем.
/*12*/ - Защита от волны кросс привязок - проверка эмиттера и текущего значения свойства. Объект инициатор обновления привязки прописывает себя в свойство `obj._binder.emitter` привязанного объекта. Привязанный объект таким образом не будет обновлять значение привязки инициатора. Иначе был бы бесконечный цикл взаимных обновлений привязок.
/*13*/ - Добавление исполнения привязки в асинхронную очередь с заданными таймаутом.
/*14*/ - Добавление исполнения функций наблюдателей в асинхронную очередь с заданными таймаутом.
/*15*/ - Проверка на принадлежность объекта к DOM
/*16*/ - Проверка на тип DOM элемента. В данном случае подразумеваются "активные" элементы`input`, `textarea` со свойством `value` и остальные с `textContent`.
У "активных" элементов геттер/сеттер `value` находится в прототипе (см. `рис. 2`). Например, для `input` это будет `HTMLInputElementPrototype`. `textContent` это тоже геттер/сеттер который находится в `Node.prototype`(см. `рис. 3`). Чтобы получить нативные геттер/сеттер используем метод `Object.getOwnPropertyDescriptor`. Ну и в случае "активного" элемента без обработчика события не обойтись.
/*17*/ - Делаем обертку на нативным сеттером, что и позволяет реализовать механизм привязок.
/*Примечание*/ - Объявление `newSet` и `newGet`, конечно, следовало бы вынести во вне.
```
*Рис.2 — наследование свойства `value`*
*Рис.3 — наследование свойства `textContent`, на примере элемента `div`*
Для наглядности приведу еще одно изображение поясняющее трансформацию DOM элемента, на примере элемента «div» (***рис. 4***)
*Рис.4 — схема трансформация DOM элемента.*
Теперь про асинхронные очереди. В начале я предполагал сделать одну очередь исполнения для всех привязок конкретного свойства, но тут возник неприятный эффект см. ***рис. 5***. Т.е. первая привязка будет ждать исполнения всей очереди, перед тем как вновь обновить значение. В случае раздельных очередей мы точно знаем, что первая привязка обновиться через заданный интервал, а все последующие через сумму интервалов предыдущих привязок.
*Рис.5 сравнение общей очереди исполнения с раздельными.*
4. Методы инстанса класса **Binder**:
```
/*18*/
_bind(ownProp, obj, objProp, ms){
if(!this._binder.bindings[ownProp]) {
this._binder.bindings[ownProp] = new Map();
Binder.transform(this, ownProp);
}
if(this._binder.bindings[ownProp].has(obj)){
return !!console.log('Binding for this object is already set');
}
this._binder.bindings[ownProp].set(obj, [objProp, ms]);
if( !obj._binder.bindings[objProp] ||
!obj._binder.bindings[objProp].has(this)) {
obj._bind(objProp, this, ownProp, ms);
}
return this;
}
/*19*/
_unbind(ownProp, obj, objProp){
try{
this._binder.bindings[ownProp].delete(obj);
obj._binder.bindings[objProp].delete(this);
return this;
} catch(e) {
return !!console.log(e);
}
};
/*20*/
_watch(prop = '*', cb, ms){
var cbHash = Binder.hash(cb.toString().replace(/\s/g,''));
if(!this._binder.watchers[prop]) {
this._binder.watchers[prop] = new Map();
if(prop === '*'){
Object.keys(this).forEach( item => {
Binder.transform(this, item);
});
} else {
Binder.transform(this, prop);
}
}
if(this._binder.watchers[prop].has(cbHash)) {
return !!console.log('Watchers is already set');
}
this._binder.watchers[prop].set(cbHash, [cb, ms]);
return cbHash;
};
/*21*/
_unwatch(prop = '*', cbHash = 0){
try{
this._binder.watchers[prop].delete(cbHash);
return this;
} catch(e){
return !!console.log(e);
}
};
/*18*/ - /*19*/ - функции привязки/отвязки. Функции привязки получает в качестве аргументов имя собственного свойства объекта, ссылку на объект, к которому привязываемся, название свойства привязываемого объекта и таймаут привязки. После привязки вызывается аналогичный метод у привязываемого объекта для обратной (двусторонней) привязки. См. `рис. 6`
/*20*/ - /*21*/ - функции подписки/отписки. Функция подписки получает в качестве параметров имя собственного свойства объекта (по умолчанию все - "*"). Функцию наблюдателя и таймаут вызова этой функции при изменении свойства. В качестве возвращаемого значения используется вычисленный хэш функции.
```
*Рис.6 Знакомтесь, кот Биндер*
**Итоги :**
##### Хорошо:
1. Защита свойств от прямой перезаписи;
2. Механизм подписок на изменение свойств объекта;
3. Настраиваемые асинхронные очереди привязок и подписок;
4. Двусторонний «честный» биндинг, т.е. мы просто указываем соответствие значения одного другому.
##### Плохо :
1. Для DOM элементов привязка только к свойтсвам **'value'** и **'textContent'**;
2. Возможность указания только одной привязки между двумя объектами;
**P.S.** Это ни в коем случае не готовое для использования решение. Это просто реализация некоторых размышлений.
Спасибо всем за внимание. Комментарии и критика приветствуются.
Всё! Наконец-то конец :) | https://habr.com/ru/post/315410/ | null | ru | null |
# Инкрементальный бэкап VDS с сайтом на 1С-Битрикс в Яндекс.Облако
Мне было необходимо делать 2 раза в сутки бэкап сайта на «1С-Битрикс: Управление сайтом» (файлов и базы mysql) и хранить историю изменений за 90 дней.
Сайт расположен на VDS под управлением ОС CentOS 7 с установленным «1С-Битрикс: Веб-окружение». Дополнительно делать резервную копию настроек ОС.
**Требования:**
* Частота — 2 раза в сутки;
* Хранить копии за последние 90 дней;
* Возможностью достать отдельные файлы за определенную дату, при необходимости;
* Бэкап должен храниться в отличном от VDS дата-центре;
* Возможность получить доступ к бэкапу из любого места (другой сервер, локальный компьютер и т.д.).
Важным моментом являлась возможность быстро создавать бэкапы с минимальным потреблением дополнительного места и ресурсов системы.
Речь идет не о снапшоте для быстрого восстановления всей системы, а именно о файлах и базе и историей изменения.
**Исходные данные:**
* VDS на виртуализации XEN;
* ОС CentOS 7;
* 1С-Битрикс: Веб-окружение;
* Сайт на базе «1С-Битрикс: Управление сайтом», версия Стандарт;
* Размер файлов — 50 Гб и будет расти;
* Размер базы — 3 Гб и будет расти.
Стандартное резервное копирование встроенное в 1С-Битрикс — исключил сразу. Оно подойдет только небольшим сайтам, т.к.:
* Делает полную копию сайта каждый раз, соответственно каждая копия будет занимать столько же места, сколько занимаю файлы, в моём случае это 50 Гб.
* Резервное копирование делается средствами PHP, что с такими объемами файлов — невозможно, оно перегрузит сервер и не закончится никогда.
* И конечно же ни о каких 90 днях речи идти не может при хранении полной копии.
Решение которое предлагает хостер, это диск для бэкапов находящийся в том же дата-центре, где и VDS, но на другом сервере. С диском можно работать по FTP и использовать свои сценарии, либо если на VDS установлен ISPManager, то через его модуль резервного копирования. Данный вариант не подходит из-за использования того же дата-центра.
Из всего вышесказанного оптимальным для меня выбором является инкрементальный бэкап по собственному сценарию в Яндекс.Облако (Object Storage) или Amazon S3 (Amazon Simple Storage Service).
**Для этого требуется:**
* root доступ к VDS;
* установленная утилита duplicity;
* аккаунта в Яндекс.Облаке.
> ***Инкрементальный бэкап** — метод при котором архивируются только измененные с момента последнего бэкапа данные.
>
>
>
> **duplicity** — бэкап утилита использующая rsync алгоритмы и умеющая работать с Amazon S3.*
>
>
### Яндекс.Облако vs Amazon S3
Разницы между Яндекс.Облаком и Amazon S3 в данном случае для меня нет. Яндекс поддерживает основную часть API Amazon S3, поэтому с ним можно работать используя решения, которые есть для работы с S3. В моём случае это утилита duplicity.
Основным плюсом Яндекса может быть оплата в рублях, если данных будет очень много, то не будет привязки к курсу. В плане скорости Европейские дата-центры Amazon работают соизмеримо с российскими в Яндексе, например можно использовать Франкфурт. Я ранее использовал Amazon S3 для подобных задач, сейчас решил попробовать Яндекс.
Настройка Яндекс.Облака
-----------------------
**1.** Необходимо создать платежный аккаунт в Яндекс.Облаке. Для этого нужно авторизоваться в Яндекс.Облаке через свой аккаунт Яндекса или создать новый.
**2.** Создать «Облако».
**3.** В «Облаке» создать «Каталог».
**4.** Для «Каталога» создать «Сервисный аккаунт».
**5.** Для «Сервисного аккаунта» создать ключи.
**6.** Ключи сохранить, они нужны будут в дальнейшем.
**7.** Для «Каталога» создать «Бакет», в него будут попадать файлы.
**8.** Рекомендую задать лимит и выбрать «Холодное хранилище».
Настройка резервного копирования по расписанию на сервере
---------------------------------------------------------
Данное руководство предполагает наличие базовых навыков администрирования.
**1.** Установить на VDS утилиту duplicity
```
yum install duplicity
```
**2.** Создать папку для дампов mysql, в моём случае это /backup\_db в корне VDS
**3.** Создать папку для bash скриптов /backup\_scripts и сделать первый скрипт, который будет выполнять бэкап /backup\_scripts/backup.sh
Содержание скрипта:
```
#!`which bash`
# /backup_scripts/backup.sh
# Это условие проверяет не идёт ли в данный момент процесс резервного копирования, если идёт, то на email отправляется сообщение об ошибке (этот блок можно не использовать)
if [ -f /home/backup_check.mark ];
then
DATE_TIME=`date +"%d.%m.%Y %T"`;
/usr/sbin/sendmail -t <
Subject:Error backup to YANDEX.CLOUD
Content-Type:text/plain; charset=utf-8
Error backup to YANDEX.CLOUD
$DATE\_TIME
EOF
else
# Основной блок отвечающий за резервное копирование
# Если нет ощибки ставим метку и запускаем backup
echo '' > /home/backup\_check.mark;
# Удаляем файлы с дампами базы оставшиеся от предыдущего backup
/bin/rm -f /backup\_db/\*
# Делаем дамп всех mysql баз, предполагается что доступ добавлен в файле /root/.my.cnf
DATETIME=`date +%Y-%m-%d\_%H-%M-%S`;
`which mysqldump` --quote-names --all-databases | `which gzip` > /backup\_db/DB\_$DATETIME.sql.gz
# Добавляем данные для отправки в Яндекс.
export PASSPHRASE=<Придумайте пароль для шифрования архива>
export AWS\_ACCESS\_KEY\_ID=<Идентификатор ключа полученный у Яндекса>
export AWS\_SECRET\_ACCESS\_KEY=<Секретный ключ полученный у Яндекса>
# Запускаем duplicity для резервирования необходимых папок на сервере.
# Данная команда будет создавать полный backup раз в месяц и до следующего месяца добавлять инкрементальные к нему
# -- exclude это папки, которые нужно исключить, я исключаю все папки с кешем битрикса
# --include папки которые нужно резервировать в моём случае это:
# - /backup\_db
# - /home
# - /etc
# s3://storage.yandexcloud.net/backup , backup это имя созданного выше бакета
# Техническая особенность и значения некоторых параметров:
# Две строки "--exclude='\*\*'" и "/" нужны, чтобы можно было выше оперировать --include и --exclude для разных папок. Эти две строчки сначала добавляют в бэкап весь сервер "/", потом исключают его "--exclude='\*\*'"
# --full-if-older-than='1M' - создавать полную копию каждый месяц
# --volsize='512' - максимальный размер каждого из файлов в бэкапе в мегабайтах
# --log-file='/var/log/duplicity.log' - куда писать лог файл
`which duplicity` \
--s3-use-ia --s3-european-buckets \
--s3-use-new-style \
--s3-use-multiprocessing \
--s3-multipart-chunk-size='128' \
--volsize='512' \
--no-print-statistics \
--verbosity=0 \
--full-if-older-than='1M' \
--log-file='/var/log/duplicity.log' \
--exclude='\*\*/www/bitrix/backup/\*\*' \
--exclude='\*\*/www/bitrix/cache/\*\*' \
--exclude='\*\*/www/bitrix/cache\_image/\*\*' \
--exclude='\*\*/www/bitrix/managed\_cache/\*\*' \
--exclude='\*\*/www/bitrix/managed\_flags/\*\*' \
--exclude='\*\*/www/bitrix/stack\_cache/\*\*' \
--exclude='\*\*/www/bitrix/html\_pages/\*/\*\*' \
--exclude='\*\*/www/bitrix/tmp/\*\*' \
--exclude='\*\*/www/upload/tmp/\*\*' \
--exclude='\*\*/www/upload/resize\_cache/\*\*' \
--include='/backup\_db' \
--include='/home' \
--include='/etc' \
--exclude='\*\*' \
/ \
s3://storage.yandexcloud.net/backup
# Данная команда нужна для чистки.
# Она оставляет 3 последних полных backup и ассоциированных с ними инкрементальных backup.
# Т.о. у меня остаются backup за 3 месяца, т.к. первая команда каждый месяц делает новый полный backup
`which duplicity` remove-all-but-n-full 3 --s3-use-ia --s3-european-buckets --s3-use-new-style --verbosity=0 --force s3://storage.yandexcloud.net/backup
unset PASSPHRASE
unset AWS\_ACCESS\_KEY\_ID
unset AWS\_SECRET\_ACCESS\_KEY
# Удаляем метку об идущем backup
/bin/rm -f /home/backup\_check.mark;
fi
```
4. Запустить скрипт первый раз и проверить результат, в «Бакете» должны появиться файлы.
```
`which bash` /backup_scripts/backup.sh
```
5. Добавить скрипт в cron для пользователя root на выполнение 2 раза в день, либо с нужной вам частотой.
```
10 4,16 * * * `which bash` /backup_scripts/backup.sh
```
Восстановление данных из Яндекс.Облака
--------------------------------------
**1.** Сделать папку для восстановления /backup\_restore
**2.** Сделать bash скрипт для восстановления /backup\_scripts/restore.sh
Я привожу самый востребованный пример восстановления определенного файла:
```
#!`which bash`
export PASSPHRASE=<Пароль для шифрования архива используемый при бэкапе>
export AWS_ACCESS_KEY_ID=<Идентификатор ключа полученный у Яндекса>
export AWS_SECRET_ACCESS_KEY=<Секретный ключ полученный у Яндекса>
# 3 примера, раскомментировать нужный
# Получить статус backup
#`which duplicity` collection-status s3://storage.yandexcloud.net/backup
# Восстановить index.php из корня сайта
#`which duplicity` --file-to-restore='home/bitrix/www/index.php' s3://storage.yandexcloud.net/backup /backup_restore/index.php
# Восстановить index.php из корня сайта 3х дневной давности
#`which duplicity` --time='3D' --file-to-restore='home/bitrix/www/index.php' s3://storage.yandexcloud.net/backup /backup_restore/index.php
unset PASSPHRASE
unset AWS_ACCESS_KEY_ID
unset AWS_SECRET_ACCESS_KEY
```
**3.** Запустить скрипт и дождаться результата.
```
`which bash` /backup_scripts/backup.sh
```
В папке /backup\_restore/ вы найдёте файл index.php, который ранее попал в резервную копию.
Более тонкую настройку можете производить под свои нужды.
**Минус duplicity**
У duplicity есть один минус — нет возможности задать лимит использования канала. С обычным каналом это не создает проблемы, а с при использовании канала с защитой от DDoS с тарификацией по скорости в сутки, я бы хотел иметь возможность установить ограничение в 1-2 мегабита.
В качестве вывода
-----------------
Резервирование в Яндекс.Облаке или Amazon S3 дает независимую копию сайта и настроек ОС к которой можно обратится с любого другого сервера или локального компьютера. При этом данная копия не видна ни в панели управления хостингом, ни в админке битрикса, что дает дополнительную безопасность.
При самом печальном исходе можно собрать новый сервер и развернуть сайт за любую дату. Хотя наиболее востребованным функционалом будет возможность обратиться к файлу за определённую дату.
Использовать данную методику можно с любыми VDS или Dedicated серверами и сайтами на любых движках, не только 1С-Битрикс. ОС также может быть отличная от CentOS, например Ubuntu или Debian. | https://habr.com/ru/post/515872/ | null | ru | null |
# Node.js vs Java + Rhino + Jetty + FreeMarker
Хоть Node.js и обзавелся с момента своего появления [множеством модулей](https://github.com/joyent/node/wiki/modules), он все еще существенно уступает по возможностям [мощному набору библиотек](http://en.wikipedia.org/wiki/Category:Java_libraries) Java. Так отчего бы не воспользоваться потенциалом Java для разработки web-приложений на JavaScript? Давайте посмотрим, как можно построить удобный JavaScript MVC framework на Java.
#### Mozilla Rhino
Прежде всего, начнем с носорогов. Для компиляции/интерпретации JavaScript будем использовать движок [Mozilla Rhino](https://developer.mozilla.org/en-US/docs/Rhino), обеспечивающий отличную интеграцию кода ECMAScript в Java-приложения. Начиная с J2SE 6 Rhino включается в JRE в составе Java Scripting API, однако версия в JRE значительно устаревшая и, кроме того, с некоторыми [неприятными особенностями](http://stackoverflow.com/questions/4801037/sun-org-mozilla-rhino-and-extending-java-abstract-classes) реализации от Sun, поэтому лучше воспользоваться [свежим build-ом](https://developer.mozilla.org/en-US/docs/Rhino/Download_Rhino?redirectlocale=en-US&redirectslug=RhinoDownload).
Прежде всего, `helloworld.js`:
```
print('Hey you!');
```
Предполагая, что библиотеки Rhino распакованы в `./lib`, запускаем пример следующим образом:
```
java -Djava.ext.dirs=./lib org.mozilla.javascript.tools.shell.Main helloworld.js
```
Кстати, в комплекте идет и отладчик с неплохим UI, запускается он так:
```
java -Djava.ext.dirs=./lib org.mozilla.javascript.tools.debugger.Main helloworld.js
```
Rhino, помимо стандартных объектов ECMAScript, включает в глобальный контекст целый ряд функций, облегчающих связь JavaScript с Java. Да, если вы еще не поняли, из кода на JavaScript можно будет прозрачно работать с кодом на Java. Для работы с пакетами существует глобальный объект `Packages`. Например, так можно создать экземпляр `java.io.File`:
```
var file = new Packages.java.io.File('filename');
```
Впрочем, также существуют глобальные объекты `java`, `com`, `org`, `edu` и `net`, поэтому код можно сократить до следующего:
```
var file = new java.io.File('filename');
```
Для импорта можно пользоваться таким pattern-ом:
```
var File = java.io.File;
//...
var file = new File('filename');
```
Но все же удобнее так:
```
importClass(java.io.File);
//...
var file = new File('filename');
```
Или так:
```
importPackage(java.io);
//...
var file = new File('filename');
```
Rhino позволяет реализовывать интерфейсы Java удобным для JS-программиста способом:
```
var runnable = new java.lang.Runnable({run: function() { print("I'm running!"); }});
new java.lang.Thread(runnable).start();
```
Кстати, обратите внимание на то, что `java.lang` **не импортируется в глобальный контекст** во избежание конфликтов со встроенными типами ECMAScript.
А еще последние версии Rhino включают полноценную реализацию [CommonJS](http://wiki.commonjs.org/wiki/Modules), которую можно включить в Rhino Shell с помощью switch-а `-require`.
Если у нас есть модуль `./modules/math.js`:
```
exports.sum = function(a, b) {
return a + b;
}
```
То воспользоваться им можно так:
```
var math = require('math');
print(math.sum(2, 4));
```
Запускается этот код так:
```
java -Djava.ext.dirs=./lib org.mozilla.javascript.tools.shell.Main -require -modules ./modules test.js
```
#### Jetty
В качестве основы для HTTP-сервера возьмем [Jetty](http://www.eclipse.org/jetty/). Jetty — контейнер servlet-ов, а заодно и гибкий в настройке web-server с поддержкой SPDY, WebSocket, OSGi, JMX, JNDI и JAAS. Скачать дистрибутив можно [тут](http://download.eclipse.org/jetty/stable-9/dist/).
Простейший код, запускающий Jetty:
```
importPackage(org.eclipse.jetty.server);
var server = new Server(8888); // Порт 8888
server.start();
server.join(); // Передадим управление Jetty
```
JAR-ы из дистрибутива Jetty следует также поместить в `./lib`, в дальнейшем все будем запускать так:
```
java -Djava.ext.dirs=./lib org.mozilla.javascript.tools.shell.Main -require -modules ./modules server.js
```
**Да, это все.**
Этот сервер выдает `HTTP 404` при любом запросе. Превратим его в простой файловый сервер.
```
importPackage(org.eclipse.jetty.server);
importPackage(org.eclipse.jetty.server.handler);
var resourceHandler = new ResourceHandler();
resourceHandler.setDirectoriesListed(true); // Разрешим просмотр списка файлов в папках
resourceHandler.setResourceBase('web'); // Установим базовой директорию ./web
resourceHandler.setWelcomeFiles(['index.html']); // В качестве главной страницы будет использоваться index.html
var server = new Server(8888);
server.setHandler(resourceHandler);
server.start();
server.join();
```
Теперь попробуем создать servlet.
```
importPackage(org.eclipse.jetty.server);
importPackage(org.eclipse.jetty.server.handler);
importPackage(org.eclipse.jetty.servlet);
importPackage(javax.servlet.http);
var contextHandler = new ServletContextHandler(ServletContextHandler.SESSIONS);
contextHandler.setContextPath('/');
contextHandler.addServlet(
new ServletHolder(new HttpServlet({ // Обратим еще раз внимание на то, как изящно реализуются интерфейсы
doGet: function(request, response) {
response.setContentType('text/plain');
response.getWriter().println('Yes, it works!');
}
})),
'/test'
);
var server = new Server(8888);
server.setHandler(contextHandler);
server.start();
server.join();
```
Наш servlet доступен на `localhost:8888/test`. В качестве еще одного примера оформим в виде модуля servlet, генерирующий на лету картинку с текстом.
```
importPackage(java.awt.image);
importClass(java.awt.Color);
importClass(javax.imageio.ImageIO); // Входит в состав J2SE 6
var width = 400, height = 400;
exports.doGet = function(request, response) {
var image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
var graphics = image.createGraphics();
var color = new Color(Math.random(), Math.random(), Math.random());
graphics.setColor(color);
graphics.fillRect(0, 0, width, height);
graphics.setColor(color.brighter());
graphics.drawString('On the fly!', 10, 20);
response.setContentType('image/png');
var outputStream = response.getOutputStream();
ImageIO.write(image, 'png', outputStream);
outputStream.close();
};
```
Поместим его в папку `./modules` как `imageServlet.js` и включим в код сервера:
```
contextHandler.addServlet(
new ServletHolder(new HttpServlet(require('imageServlet'))),
'/image.png'
);
```
Что там с СУБД? Посмотрим, как получить список баз данных из MySQL.
```
importPackage(java.sql);
exports.doGet = function(request, response) {
try {
var connection = DriverManager.getConnection('jdbc:mysql://localhost/?', 'root', '');
try {
var resultSet = connection
.createStatement()
.executeQuery('show databases;');
response.setContentType('text/html;charset=UTF-8');
var writer = response.getWriter();
writer.println('Databases
=========
');
while (resultSet.next()) {
writer.println(resultSet.getString('Database') + '
');
}
} catch(e) {} finally {
resultSet.close();
}
} catch(e) {} finally {
if(connection)
connection.close();
}
};
```
Для этого кода понадобится [MySQL Connector/J](http://dev.mysql.com/downloads/connector/j/) для JDBC.
Теперь остался последний компонент, шаблонизатор.
#### FreeMarker
[FreeMarker](http://freemarker.sourceforge.net/) — определенно лучший шаблонизатор для Java, причем не только для HTML и HTTP. Про его богатые возможности можно написать отдельную статью, так что сразу перейдем к конкретике.
Положим в `./templates/template.ftl` такой вот шаблон:
```
${title}
${title}
========
<#if message??>
```
${message?html}
```
<#else>
```
Суффикс `?html` заменяет в подставляемой переменной [те самые спецсимволы](https://www.owasp.org/index.php/Cross-site_Scripting_(XSS)) на escape-последовательности. Этот шаблон будет использовать следующий servlet:
```
importPackage(Packages.freemarker.template);
importPackage(Packages.freemarker.ext.rhino);
var configuration = new Configuration();
configuration.setObjectWrapper(new RhinoWrapper()); // Поистине приятный сюрприз.
var template = configuration.getTemplate('templates/template.ftl');
exports.doGet = function(request, response) {
response.setContentType('text/html;charset=UTF-8');
template.process(
{'title': 'Compose a message'},
response.getWriter()
);
};
exports.doPost = function(request, response) {
response.setContentType('text/html;charset=UTF-8');
template.process(
{
'title': 'Message',
'message': request.getParameter('message')
},
response.getWriter()
);
};
```
Сравнение с Node.js я благородно сваливаю на читателя. Полный код примера доступен на [GitHub](https://github.com/dannote/rhinomvc). | https://habr.com/ru/post/183334/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.