text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Светодиод, таймер и прерывания на RISC-V с нуля (на примере GD32VF103 и IAR C++)
Сегодня речь пойдет о модном — о RISС-V микроконтроллере. Я давно хотел познакомиться с этим ядром и ждал когда появится что-то похожее на STM32 и вот дождался, встречайте — китайский GigaDevice — GD32V.
Инфраструктура для этого микроконтроллера не такая обширная как для STM32, но есть все необходимое для того, чтобы начать с ним работать. Благо отладочные платы можно заказать на аликекспресс, например, вот тут: [Longan Nano GD32VF103CBT6 RISC-V MCU](https://aliexpress.ru/item/4000818117666.html)
Китайцы продвигают для этого микроконтроллера среду разработку Platform IO, которую можно поставить как расширение под Visual Studio Code. Но мы не будем её использовать, это ведь не по инженерным понятиям, мы же инженеры и хотим разобраться во всем сами. Поэтому давайте попробуем запустить плату на IAR, написав все с нуля.
Кстати, IAR раздает отладочный комплект (отладочная плата + отладчик I-Jet + 30 Дней полная лицензия) IAR RISC-V GD32V Evaluation kit. Вот тут можно оставить заявку [Request for Development Tools](https://www.iar.com/rfq/). Не уверен, что они посылают комплект всем желающим, но мы получили в течение 5 дней. Спасибо им за это!
Ну что же, кто заинтересовался, добро пожаловать под кат
Введение
--------
Вообще я хотел портировать очень простой планировщик из статьи [Переключение контекста и простой вытесняющий планировщик для CortexM](https://habr.com/ru/post/506414/), но из-за найденной мною ошибки в компиляторе IAR (но IAR обещал исправить все в ближайшее время), напрямую этого сделать не удалось, пришлось немного переделать стратегию определения задач, да и материала получалось много.
Поэтому я решил начать с простого — с моргания светодиодом, точнее двумя. Когда я только сел разбираться, думал, что разберусь за пару часов, но открыв документацию, которая ссылается на другую документацию, которая ссылается на еще другую документацию, которая, в конечном итоге, равномерно разбросана по интернету, понял, что парой часов тут не обойтись и первое впечатление от RISC-V было вот прямо как у Джереми, когда, видимо, он тоже увидел RISC-V микроконтроллер.
Но чуть позже я привык и даже проникся теплыми чувствами к ученым из Калифорнийского университета, которые придумали вот это всё (это я про саму архитектуру RISC-V). И потому попытаюсь донести, что же я понял, и что такое китайский RISC-V.
Описывать все детали архитектуры RISC-V не хватит никаких сил, я ограничусь только необходимым минимумом для того, чтобы понять, как правильно поморгать светодиодом через таймер с прерыванием. Но даже, чтобы описать такую, казалось бы простую задачу, мне пришлось написать очень много букв, поэтому, если вы не хотите проходить со мной весь этот тернистый путь, можете сразу мотать на раздел **Моргаем светодиодом**, там где начинается код.
Материала по RISC-V на русском не так много (вот есть обзор [Создание процессора со свободной архитектурой RISC-V](https://visuale-ru.turbopages.org/s/visuale.ru/blog/sozdanie-protsessora-so-svobodnaya-arkhitekturoj-risc-v-chast-1), вот еще презентация от [Syntacore](https://syntacore.com/media/riscv_moscow_2019/SCR1%20Tutorial%20Symposium%20Moscow.pdf)), поэтому, как обычно, начнем с азов. Итак, поехали.
### Какая поддержка уже существует у GD32VF103
Для начала опишу, какими ресурсами я пользовался, возможно кому-то пригодится.
1. Описание ISA RISC-V с официального сайта RISC-V организации:
[Непривилегированная ISA](https://github.com/riscv/riscv-isa-manual/releases/download/draft-20200727-8088ba4/riscv-spec.pdf)
[Привилегированная ISA](https://github.com/riscv/riscv-isa-manual/releases/download/draft-20200727-8088ba4/riscv-privileged.pdf)
2. Описание микроконтроллера [GD32VF103](http://www.gd32mcu.com/data/documents/shujushouce/GD32VF103_User_Manual_EN_V1.2.pdf). Открывается очень медленно, а иногда и не открывается вовсе. Поэтому вот еще ссылка прямо на производителя [GD32VF103CBT6 — GD32 RISC-V Microcontroller](https://www.gigadevice.com/microcontroller/gd32vf103cbt6/)
3. Ядро микроконтроллера GD32VF103 сделано на ядре [Bumblebee](https://github.com/nucleisys/Bumblebee_Core_Doc/blob/master/Bumblebee%20Core%20Architecture%20Manual.pdf), которое в свою очередь использует архитектуру [Nuclei processor core](https://doc.nucleisys.com/nuclei_spec/isa/introduction.html)
4. Описание [контроллера прерываний ECLIC](https://github.com/riscv/riscv-fast-interrupt/blob/master/clic.adoc#clic-interrupt-enable-clicintie).
5. Вот тут чувак [пытался разобраться](https://www.susa.net/wordpress/2019/10/longan-nano-gd32vf103/) как работает наш микроконтроллер и ему почти это удалось. Советую почитать.
6. Есть общие библиотеки ядра Nuclei RISC-V на Си, например можно посмотреть [здесь в репозитории IAR](https://github.com/IARSystems/iar-risc-v-gd32v-eval/tree/master/Firmware/RISCV) или тут в оригинале [n200 drivers](https://github.com/nucleisys/n200-sdk/tree/master/bsp/nuclei-n200/n200/drivers)
7. Есть библиотека периферии от самой GigaDevice, например можно взять [тут же в репозитории IAR](https://github.com/IARSystems/iar-risc-v-gd32v-eval/tree/master/Firmware) или на сайте производителя [Библиотека от производителя](https://www.gigadevice.com/firmware/gd32vf103xxxx-firmware-library/)
8. Так же есть порты операционных систем FreeRTOS и uCOS II [n200 sdk](https://github.com/nucleisys/n200-sdk/tree/master/software)
9. Нет, ну есть еще всякие Platform IO примеры, но это совсем не про нас. Поэтому даже ссылок давать не буду.
Из всего этого будем пользоваться только первыми 4 пунктами, попробуем написать код на С++ без всех этих библиотек — все сами, заглядывая только в документацию. Задача будет такая:
> *Моргать двумя светодиодами раз в 100 мс и 200 мс соответственно от прерывания ~~системного~~ машинного таймера*
Немного определений
-------------------
RISC-V это уникальная архитектура. Все определения и понятия тут свои, основные понятия, которые вам будут постоянно встречаться на извилистом пути изучения RISC-V, я приведу ниже:
* **Hart (Аппаратный поток)** — архитектура поддерживает многопоточность, поэтому может быть несколько аппаратных потоков исполнения кода. Под потоком (**hart**) подразумевается аппаратный поток. Микроконтроллер как минимум должен иметь один поток (**hart**) с ID равным 0. Вот наш микроконтроллер именно такой с одним единственный **hart**ом.
* **Trap(Ловушка)** — ловушка это совокупное объедение смысла таких слов, как прерывание и исключение. Я буду постоянно путаться и называть ловушку прерыванием, или исключение — ловушкой, или прерывание — ловушкой, знайте, я не со зла. Ловушки бывают нескольких типов:
+ Ловушка исключения (**exception**) — это понятие означает синхронное событие, которое прерывает исполнения кода. Исключение может прерываться другим исключением, или **NMI**.
+ Ловушка прерывания (**interrupt**) — внешнее асинхронное событие, которое может привести к тому, что поток неожиданно может передать управление. Прерывание может прерываться другим прерыванием, **NMI**, или исключением.
+ Ловушка немаскируемого прерывания(**NMI**) — немаскируемое прерывание. **NMI** не может прерываться другим **NMI**, но может перейти из обработчика **NMI** в режим обработки исключения, если в момент обработки **NMI** произойдет исключение. В нашем микроконтроллере, например, отказ высокоскоростного кварцевого генератора, заведен на немаскируемое прерывание.
* **Machine (машинный)** — В ядре все машинное — регистры, таймер, режим. Поэтому все что связано со словом **machine**(машинный) должно поддерживается на уровне ядра. Наверное, можно позволить своему внутреннему Я, заменить это на слово *системный*, но лучше так не делать.
Ну хватит… остальное вроде бы привычно для ушей эмбеддеров.
Краткий обзор возможностей архитектуры RISC-V
---------------------------------------------
Для начала, немного википедии:
> RISC-V (риск-пять) — открытая и свободная система команд (ISA — Instruction Set Architecture) и процессорная архитектура на основе концепции RISC для микропроцессоров и микроконтроллеров. Спецификация доступна для свободного и бесплатного использования, включая коммерческие реализации непосредственно в кремнии или конфигурировании ПЛИС. Имеет встроенные возможности для расширения списка команд и подходит для широкого круга применений.
На данный момент, в архитектуре разделяются следующие наборы команд, который я скрыл под спойлер, так как она довольно большая:
**Таблица расширений RISC-V**
| Сокращение | Наименование | Версия | Статус |
| --- | --- | --- | --- |
| | **Базовые наборы команд** | | |
| RV32I | 32-битный базовый набор с целочисленными операциями с 32 регистрами общего назначения | 2.1 | Ratified |
| RV32E | 32-битный базовый набор с целочисленными операциями для встраиваемых систем с 16 регистрами общего назначения | 1.9 | Draft |
| RV64I | 64-битный базовый набор с целочисленными операциями с 32 регистрами общего назначения | 2.1 | Ratified |
| RV128I | 128-битный базовый набор с целочисленными операциями | 1.7 | Draft |
| | **Стандартные расширенные наборы команд** | | |
| M | Целочисленное умножение и деление (Integer Multiplication and Division) | 2.0 | Ratified |
| A | Атомарные операции (Atomic Instructions) | 2.1 | Ratified |
| F | Арифметические операции с плавающей запятой над числами одинарной точности (Single-Precision Floating-Point) | 2.2 | Ratified |
| D | Арифметические операции с плавающей запятой над числами двойной точности (Double-Precision Floating-Point) | 2.2 | Ratified |
| G | Сокращенное обозначение для комплекта из базового и стандартного наборов команд | н/д | н/д |
| Q | Арифметические операции с плавающей запятой над числами четвертной точности | 2.2 | Ratified |
| L | Арифметические операции над числами с фиксированной запятой (Decimal Floating-Point) | 0.0 | Open |
| C | Сокращённые имена для команд (Compressed Instructions) | 2.2 | Ratified |
| B | Битовые операции (Bit Manipulation) | 0.36 | Open |
| J | Двоичная трансляция и поддержка динамической компиляции (Dynamically Translated Languages) | 0.0 | Open |
| T | Транзакционная память (Transactional Memory) | 0.0 | Open |
| P | Короткие SIMD-операции (Packed-SIMD Instructions) | 0.1 | Open |
| V | Векторные расширения (Vector Operations) | 0.2 | Open |
| N | Инструкции прерывания (User-Level Interrupts) | 1.1 | Open |
Как видно из спрятанной таблицы, архитектура уже подразумевает поддержку довольно большого количества расширений, что делает её очень привлекательной для независимого будущего. Ведь можно делать ядра начиная от простейших микроконтроллеров и заканчивая уже мощными процессорами для научных расчетов.
Но нам нужна только небольшая часть из всего этого, так как на самом деле для микроконтроллеров общего назначения используется в основном 32 битная архитектура с очень небольшим количеством расширений, например:
Ядро:
* **RV32Е:** 32 битная архитектура с 16 регистрами общего назначения
* **RV32I:** 32 битная архитектура с 32 регистрами общего назначения
Расширения:
* **M:** целочисленные инструкции по умножению и делению
* **C:** сжатые до 16 бит инструкции для уменьшения размера кода
* **А:** Атомарные Инструкции
* **F:** Инструкции С Плавающей Запятой Одиночной Точности
* **D:** Инструкции С Плавающей Запятой Двойной Точности
Как видите — вполне себе стандартенький наборчик для обычного общепромышленного микроконтроллера.
Давайте теперь кратенько взглянем на регистры.
Регистры общего назначения
--------------------------
RISC-V имеет 32 регистра **x0-x31**. Но обычно к ним обращаются через ABI имена.
**Рабочие регистры:**
Регистры **t0-t6**(x5-x7, x28-x31) и **a0-a7**(x10-x17), а также регистр адреса возврата являются рабочими регистрами. Любая функция может изменять содержимое этих регистров и если ей нужно воспользоваться какими-то из этих регистров после вызова другой функции, она должна сохранить их значение на стеке.
**Сохраняемые регистры:**
Регистры **s0-s11** (x8, x9, x18-x27 ) должны сохраняться вызываемой функцией на стеке (если функция хочет их использовать) перед входом в функцию и восстанавливаться перед выходом, .
Далее табличка из интернета, описывающая каждый регистр, не стал переводить, итак все понятно:
**Все 32 регистра в одной таблице**
| Register | ABI Name | Description | Saver |
| --- | --- | --- | --- |
| x0 | zero | Hard-wired zero | — |
| x1 | ra | Return address | Caller |
| x2 | sp | Stack pointer | Callee |
| x3 | gp | Global pointer | — |
| x4 | tp | Thread pointer | — |
| x5 | t0 | Temporary/alternate link register | Caller |
| x6–7 | t1–2 | Temporaries | Caller |
| x8 | s0/fp | Saved register/frame pointer | Callee |
| x9 | s1 | Saved register | Callee |
| x10–11 | a0–1 | Function arguments/return values | Caller |
| x12–17 | a2–7 | Function arguments | Caller |
| x18–27 | s2–11 | Saved registers | Callee |
| x28–31 | t3–6 | Temporaries | Caller |
| pc | pc | Program counter | |
А вот теперь ~~моя вольная~~ интерпретация некоторых регистров.
**x0/zero:**
Регистр хранит всегда 0 и может использоваться в некоторых командах доступа к регистрам CSR(об этом и о многом другом чуть дальше), например, в команде CSRRS (Atomic Read and Set Bits in CSR), при использовании регистра **x0** как источника маски, команда будет атомарно только читать CSR регистр без его модификации. Если вы захотите использовать другой регистр в котором хранится ноль, то команда все равно произведет запись в регистр CSR, поэтому если необходимо только прочитать биты, то нужно использовать регистр **zero**.
**x1/ra:**
(Link register или Return Address регистр). Регистр содержащий адрес возврата из функции. Этот регистр может использоваться как рабочий регистр в функции, поэтому при входе в функцию он должен быть сохранен, а при выходе, перед вызовом инструкции ret, восстановлен.
**x2/sp:**
Указатель стека. Ничего не придумал от себя — просто указатель стека. И он один, не как в CortexM, где их два.
**x3/gp:**
(The global pointer register). Глобальный регистр указателей (**gp/x3**) используется для эффективного доступа к памяти в пределах области в 4 Кбайта.
Компоновщик сравнивает значение адресов памяти со значением которым должен быть проинициализирован **gp**, и если оно находится в пределах диапазона 4 кбайта, заменяет абсолютную/pc-относительную адресацию на gp-относительную адресацию, что делает код более эффективным. Этот процесс также называется короткой памятью.
Область 4K может находиться в любом месте памяти, но для того, чтобы оптимизация была эффективной, она должна предпочтительно охватывать наиболее интенсивно используемую область оперативной памяти. Поэтому обычно в настройках компоновщика для инициализации этого указателя используют адрес на начало сегмента глобальных и статических данных.
**x4/tp:**
(The thread pointer). Указатель потока. Этот регистр используется для реализации механизма Локального хранилища потока (Thread Local Storage (TLS)), например при реализации спецификатора класса thread\_local в С++.
Не не будем сильно заморачиваться с этими регистрами, все что нам нужно знать про них для нашей задачи — это тот факт, что как минимум все рабочие регистры нужно будет сохранить во время входа в прерывание и восстановить при выходе.
Наборы инструкций
-----------------
Я не буду описывать наборы инструкций и ассемблер, потому что он нам не нужен, но вот про спецификации, описывающие ISA, стоит рассказать. Существует две спецификации набора инструкций:
1. Непривилегированный набор инструкций
2. Привилегированный набор инструкций
В нашем китайском микроконтроллере используется оба набора.
### Непривилегированный набор инструкций
Спецификация на этот набор описывает инструкции и функциональность которые обычно используются во всех режимах привилегий, т.е. общие для всех архитектур набор инструкций и функций. Спецификация на этот набор доступна здесь: [Непривилегированный ISA](https://github.com/riscv/riscv-isa-manual/releases/download/draft-20200727-8088ba4/riscv-spec.pdf)
### Привилегированный набор инструкций
Основное её назначение — это разделение уровня приложений и уровня ядра, а также поддержка операционных систем вплоть до нескольких разных операционных систем типа Linux, работающих через виртуальную машину.
Но нас это не особо беспокоит, у нас же небольшой микроконтроллер, который из всего этого дела использует почти самую простую форму привилегированности.
Спецификация на привилегированный набор описывает возможную архитектуру привилегированных режимов, в том числе специальные инструкции и дополнительную функциональность для каждого из них. Спецификация доступна здесь: [Привилегированная ISA](https://github.com/riscv/riscv-isa-manual/releases/download/draft-20200727-8088ba4/riscv-privileged.pdf)
Следует уточнить, что эта спецификация носит рекомендованный характер, и она описывает только одно из возможных решений. Основное её преимущество, в том, что привилегированная архитектура никак не задевает основную непривилегированную функциональность и является её расширением.
Далее речь пойдет как раз о некоторых деталях этой привилегированной архитектуры, так как есть кое-какие нюансы, которые нужно знать при работе с ловушками.
#### Уровни привилегий
В RISC-V архитектуре существует 3 уровня привилегий. Уровни привилегий используются для обеспечения защиты между различными компонентами программного обеспечения (например, пользовательским приложением и ядром операционной системы). Любые попытки выполнения операций, не разрешенных текущим режимом привилегий, вызовут исключение.
Ниже показаны значения режима привилегий:
| Уровень | Код режима | Имя | Сокращенное название | Описание |
| --- | --- | --- | --- | --- |
| 0 | 00 | User/Application | U | Самый низкий уровень привилегий |
| 1 | 01 | Supervisor | S | |
| 2 | 10 | Reserved | | |
| 3 | 11 | Machine | M | Самый высокий уровень привилегий |
| Поддерживаемые режимы | Предполагаемое использование |
| --- | --- |
| M | Системы со встроенным ПО |
| M, U | Защищенные системы со встроенным ПО и операционными системами реального времени |
| M,S,U | Системы с Unix подобными операционными системами |
Как видно из таблички, для микроконтроллеров, таких как GD32VF103 рекомендованы режимы M или М и U. Собственно он и поддерживает оба режима. И если микроконтроллер работает в пользовательском режиме U, то ему недоступны настройки машинного режима и доступ к машинным регистрам, таким как **mtvt**, **mepc**, о них речь пойдет немного ниже. И чтобы обратиться к ним, вам необходимо зайти в ловушку, так как в GD32VF103, при попадании в ловушку ядро переходит в машинный режим.
Т.е. любое прерывание или исключение переводит ядро в машинный режим M и уже внутри него можно обращаться к машинным регистрам. В общем случае алгоритм доступа к машинным регистрам из пользовательского режима выглядит следующим образом — вам надо вызывать инструкцию **ecall** — запрос среды исполнения, которая переведет микроконтроллер в машинный режим и вызовет обработчик ловушки, в котором вы можете поменять машинные регистры в соответствии с запросом. Переход же из машинного режима в пользовательский происходит после команды **mret** — возврат из машинного режима.
Забегая вперед скажу, что хотя микроконтроллер и поддерживает два режима, после сброса он находится в машинном режиме, и переводить в пользовательский режим мы его не будет, чтобы не нагружать итак уже большую статью.
***Примечание:**
Согласно стандартной привилегированной архитектуре RISC-V, мы не можем на прямую узнать текущий привилегированный режим (например, машинный режим или режим пользователя).*
#### Режим привилегий микроконтроллера GD32VF103
Пусть вас не смущает буква F в названии микроконтроллера GD32VF103 — это просто маркетинговое название, чтобы было похоже на уже существующую линейку GD32F103 на ядре CortexM3. Никакой поддержки инструкций с плавающей точкой здесь нет. Наверное, ставка была на то, что кто-то спутает GD32F103 с STM32F103 и не заметит подвоха… а затем еще спутает и GD32VF103 c GD32F103. Мой продавец попался в эту *ловушку* (это другая ловушка, если что), и вначале мне пришел микроконтроллер GD32F103, вместо GD32VF103.
Этот микроконтроллер построен на архитектуре RV32IMAC — что идентифицирует микроконтроллер как RISC-V 32-битная архитектура с 32-битными регистрами общего назначения, который имеет целочисленные инструкции умножения и атомарные инструкции, инструкции сжаты до 16 бит для уменьшения размера кода.
Микроконтроллер может использоваться в защищенных системах, для которых достаточно только два режима:
* Машинный Режим (Machine Mode), повторюсь, режим который имеет наивысший уровень привилегий и который является обязательным.
* Пользовательский режим (User Mode), который можно конфигурировать.
Как я уже говорил выше, привилегированная спецификация это не панацея и производители могут добавлять и даже изменять архитектуру. В данном случае, ребята добавили несколько подрежимов Машинного режима. Почитать о ней можно тут: [Nuclei privileged ISA](https://doc.nucleisys.com/nuclei_spec/isa/privileged_arch.html)
#### Подрежимы Машинного режима
Существует 4 подрежима:
* Нормальный подрежим (**Normal Mode — 0x0**)
Ядро будет находиться в этом подрежиме после сброса и работать в нем до тех пора пока не произойдет прерывание, немаскируемое прерывание (NMI) или исключение.
* Подрежим обработки исключения (**Exception Handling Mode — 0x2**)
Ядро находится в этом режиме когда оно обрабатывает исключение.
* Подрежим обработки немаскируемого прерывания (**NMI Handling Mode — 0x3**)
Ядро находится в этом подрежиме когда оно обрабатывает немаскируемое прерывание NMI.
* Подрежим обработки прерывания (**Interrupt Handling Mode — 0x1**)
Ядро находится в этом подрежиме когда оно обрабатывает прерывание.
Эти подрежимы можно узнать из поля **TYP** машинного регистра **msumbm**
По умолчанию после сброса ядро находится в машинном режиме в подрежиме **0** (Нормальный подрежим работы) и вообще для большинства применений этого и достаточно, потому как у нас есть полный доступ ко всем регистрам и пользовательским и машинным.
Собственно, в моем примере я буду использовать только такой режим, но если мы сильно хотим ограничить пользователя от настроек ядра, например, запретить пользователю изменять машинные регистры из задач операционной системы, то мы всегда можем перейти в режим пользователя. Для этого, в нормальном подрежиме машинного режима, необходимо просто выполнить инструкцию **mret** — возврат из машинного режима, предварительно подменив в регистре **mstatus** поле **MPP** на пользовательский режим, а также поставив правильный адрес возврата в регистре **mepc**. Вот про эти странные регистры мы сейчас и узнаем.
Регистры статуса и управления CSR (Control and Status Registers)
----------------------------------------------------------------
Я тут уже вскользь упомянул регистры **mstatus**, **mepc**, **msumbm**, **mtvt** ..., так что это за регистры?
Эти регистры встроены в ядро микроконтроллера, поэтому доступ к ним можно осуществить только с помощью специальных команд ассемблера, например **cssr** или **csrr**.
Это не очень хорошо, так как я собирался использовать для доступа к ним мою [обертку над регистрами](https://habr.com/ru/post/459642/), а она не подходит для доступа к регистрам ядра, из-за того, что доступ к ним осуществляется особым образом через эти специальные команды.
Чтобы не трогать уже написанную обертку и генератор регистров, я сделал отдельный класс для их обработки.
На пользователей это никак не повлияло, а я получил возможность удобно обращаться к таким регистрам. Суть класса таже самая — только вместо прямого чтения, все сделано на ~~ассемблере~~, встроенных в IAR функции доступа к CSR регистрам. (Было лень писать на ассемблере просто взял встроенные функции IAR, но правильно переписать на ассме, чтобы подходило для GCC тоже).
Вот так выглядит метод чтения значения такого регистра
```
//Метод Get возвращает целое значение регистра, будет работать только для регистров, которые можно считать
template::value ||
std::is\_base\_of::value>>
inline static Type Get()
{
return \_\_read\_csr(address) ;
}
```
Пример доступа к специальному регистру на ассемблере
```
unsigned long get_mstatus()
{
unsigned long value;
asm volatile("csrr %0, 0x300" : "=r"(value));
return value;
}
auto mstatus = get_mstatus() ;
```
и через обертку
```
auto mstatus = CSR::MSTATUS::Get() ;
```
Регистров целая куча, есть регистры, которые обязательны в соответствии со спецификацией, а есть уже добавленные производителем. CSR регистры существуют для каждого режима, поэтому в общем случае они называются **x**имярегистра, например **xstatus** — может быть регистр **mstatus** — регистр статуса машинного режима, **ustatus** — регистр статуса пользовательского режима. И, например, доступ к **m** регистрам запрещен из пользовательского режима, а к **u** регистрам разрешен.
Под спойлером описание всех регистров статуса и управления нашего микроконтроллера.
**CSR регистры микроконтроллера**
| Адрес | Доступ | Имя | Описание |
| --- | --- | --- | --- |
| | | | **Стандартные регистры машинного режима, соответствующие спецификации привилегированной архитектуры RISC-V CSR (Machine Mode)** |
| 0xF11 | MRO | mvendorid | (Machine Vendor ID Register) Регистр содержащий код производителя ядра, который выдается JEDEC ассоциацией |
| 0xF12 | MRO | marchid | (Machine Microacrhitecture ID Register) Идентификатор микроархитектуры ядра |
| 0xF13 | MRO | mimpid | (Machine Implementation ID Register) Идентификатор номера версии ядра. |
| 0xF14 | MRO | mhartid | (Hart ID Register) Идентификатор аппаратного потока, который выполняет код. |
| 0x300 | MRW | mstatus | (Machine Status Register) Регистр содержит текущее состояние и управляет текущим состоянием аппаратного потока |
| 0x301 | MRO | misa | (Machine ISA Register) Идентификатор набора команд, собственно в нем закодирован поддерживаемый набор команд |
| 0x304 | MRW | mie | (Machine Interrupt Enable Register) Регистр отвечает за включение прерываний при использовании PLIC (platform-level interrupt controller) |
| 0x305 | MRW | mtvec | (Machine Trap-Vector Base-Address Register) Регистр содержит адрес обработчика(ловушки) исключений. |
| 0x307 | MRW | mtvt | (ECLIC Interrupt Vector Table Base Address) Регистр содержит базовый адрес вектора прерываний для ECLIC контроллера. На самом деле спецификация на [контроллер прерываний](https://github.com/riscv/riscv-fast-interrupt/blob/master/clic.adoc#new-xtvec-csr-mode-for-clic) еще не утверждена, поэтому это не совсем стандартный регистр. |
| 0x340 | MRW | mscratch | (Machine Scratch Register) Назовем его регистр-записная книжка, обеспечивает механизм сохранения и восстановления специфических данных для ограничения доступа к данным более высокого уровня привилегий из низкого уровня привилегий. Например, после входа в режим прерывания или обработки исключений регистр указателя стека приложения (**sp**) временно сохраняется в регистре **mscratch**. Перед выходом из обработчика исключений значение в регистре-записная книжка используется для восстановления регистра указателя стека (**sp**). Программное обеспечение может получить доступ к этому регистру только из машинного режима. |
| 0x341 | MRW | mepc | (Machine Exception Program Counter) Регистр, который содержит в себе адрес инструкции, которая была прервана исключением или прерыванием. Регистр может быть явно изменен программой в машинном режиме. Младший бит этого регистра всегда равен 0. |
| 0x342 | MRW | mcause | (Machine Cause Register) Этот регистр индицирует событие, которое стало причиной исключения. |
| 0x343 | MRW | mtval | (Machine Trap Value Register). Регистр содержащий специфическую информацию, чтобы помочь с обработкой исключения, например, может хранить код инструкции вызвавшей исключение или адрес в котором произошла ошибка. |
| 0x344 | MRW | mip | (Machine Interrupt Pending Register). Содержит информацию об ожидающих прерываниях, при использовании PLIC (platform-level interrupt controller). |
| Ox345 | MRW | mnxti | (Next Interrupt Handler Address and Interrupt-Enable CSR) Регистр, содержащий адрес следующего обработчика прерываний. Может использоваться программным обеспечением для обработки следующего прерывания, когда оно находится в том же режиме привилегий, без очистки конвейера прерываний и затрат на сохранения/восстановления контекста. Тоже регистр из неутвержденной спецификации на [контроллер прерываний](https://github.com/riscv/riscv-fast-interrupt/blob/master/clic.adoc#new-xtvec-csr-mode-for-clic) |
| 0x346 | MRO | mintstatus | (Current Interrupt Levels). Регистр содержащий уровень активного прерывания в машинном режиме. Регистр из неутвержденной спецификации на [контроллер прерываний](https://github.com/riscv/riscv-fast-interrupt/blob/master/clic.adoc#new-xtvec-csr-mode-for-clic) |
| 0x348 | MRW | mscratchcsw | (Scratch swap register for privileged mode). Этот регистр используется для того, чтобы выполнить обмен значения хранящиеся в одном из регистров ядра с регистром **mscratch** (например для обмена значений указателя на стек **sp** и **mscratch**). Используется при входе в прерывание и смене режима привилегий для разграничения доступа к данным между уровнями привилегий. Регистр из неутвержденной спецификации на [контроллер прерываний](https://github.com/riscv/riscv-fast-interrupt/blob/master/clic.adoc#new-xtvec-csr-mode-for-clic) |
| 0x348 | MRW | mscratchcswl | (Scratch swap register for interrupt levels). Этот регистр также используется для обмена значений между регистром ядра и регистром **mscratch**, но в случае когда уровень привилегий не меняется. В частности он используется для ускорения обработки прерывания при переключении между несколькими уровнями прерываний. Регистр из неутвержденной спецификации на [контроллер прерываний](https://github.com/riscv/riscv-fast-interrupt/blob/master/clic.adoc#new-xtvec-csr-mode-for-clic) |
| 0xB00 | MRW | mcycle | (Lower 32 bits of Cycle counter). Младшие 32 бита счетчика циклов |
| 0xB80 | MRW | mcycleh | (Upper 32 bits of Cycle counter). Старшие 32 бита счетчика циклов |
| 0xB02 | MRW | minstret | (Lower 32 bits of Instructions-retired counter). Младшие 32 бита счетчика успешно выполненных инструкций. |
| 0xB82 | MRW | minstreth | (Lower 32 bits of Instructions-retired counter). Старшие 32 бита счетчика успешно выполненных инструкций. |
| | | | **Стандартные регистры пользовательского режима. RISC-V Standard CSR （User Mode）** |
| 0xC00 | URO | cycle | Копия регистра **mсycle**, для чтения из пользовательского режима |
| 0xC01 | URO | time | Копия регистра **mtime**, содержащий младшие 32 бита счетчика машинного таймера. |
| 0xC02 | URO | instret | Копия регистра **minstret**, для чтения из пользовательского режима |
| 0xC80 | URO | cycleh | Копия регистра **mcycleh**, для чтения из пользовательского режима. |
| 0xC81 | URO | timeh | Копия регистра **mtimeh**, содержащий старшие 32 бита счетчика машинного таймера. |
| 0xC82 | URO | instreth | Копия регистра **minstreth**, для чтения из пользовательского режима |
| 0x810 | MRW | wfe | Регистр для управления низко-потребляющим режимом |
| | | | \*\*Специализированные регистры ядра Bumblebee. Bumblebee Customized CSR&& |
| 0x320 | MRW | mcountinhibit | (Customized register for counters on & off). Регистр для управления включением отключением подсчета тактов (регистр **mcycle**) и количества успешных команд (**minstret**). |
| 0x7c3 | MRO | mnvec | (NMI Entry Address). Адрес обработчика NMI. |
| 0x7c4 | MRW | msubm | (Customized Register Storing Type of Trap). Регистр хранит тип текущей ловушки и ловушки до входа в текущую ловушку. |
| 0x7d0 | MRW | mmisc\_ctl | (Customized Register holding NMI Handler Entry Address). Адрес обработчика прерываний NMI. |
| 0x7d6 | MRW | msavestatus | (Customized Register holding the value of mstatus). Регистр хранит значения регистров **mstatus** и **msubm**, что гарантирует, что эти регистры не будут сброшены исключением или NMI. |
| 0x7d7 | MRW | msaveepc1 | (Customized Register holding the value of mepc for the first-level preempted NMI or Exception). Регистр хранит значение регистра **mepc**. |
| 0x7d8 | MRW | msavecause1 | (Customized Register holding the value of mcause for the first-level preempted NMI or Exception). Регистр хранит значение регистра **mcause**. |
| 0x7d9 | MRW | msaveepc2 | (Customized Register holding the value of mepc for the second-level preempted NMI or Exception). Регистр хранит значение регистра **mepc**. |
| 0x7eb | MRW | pushmsubm | (Push msubm to stack). Вспомогательный регистр, обеспечивает метод сохранения регистра **msubm** в стеке. |
| 0x7ec | MRW | mtvt2 | (ECLIC non-vectored interrupt handler address register). Регистр хранит адрес единого обработчика прерывания в режиме не-векторной обработки. |
| 0x7ed | MRW | jalmnxti | (Jumping to next interrupt handler address and interrupt-enable register). Вспомогательный регистр, используется для того, чтобы уменьшить задержки прерываний и ускорить обработку цепочки последовательно происходящих прерываний. |
| 0x7ee | MRW | pushmcause | (Push mcause to stack). Вспомогательный регистр, обеспечивает метод сохранения регистра **mcause** в стеке. |
| 0x7ef | MRW | pushmepc | (Push mepc to stack). Вспомогательный регистр, обеспечивает метод сохранения регистра **mepc** в стеке. |
| 0x810 | MRW | wfe | (Wait for Event Control Register) Регистр настройки способа пробуждения микроконтроллера от прерывания, NMI или от события . |
| 0x811 | MRW | sleepvalue | (WFI Sleep Mode Register). Регистр содержащий настройку режима пониженного энергопотребления |
| 0x812 | MRW | txevt | (Send Event Register). Регистр настройки события |
Для нашей задачи нам не нужны все регистры, мы ограничимся только теми, что нужны для решения конкретно нашей задачи. Напомню её на всякий случай — **поморгать светодиодами**.
#### Регистр mcause
Регистр указывающий причину возникновения прерывания. Табличку скрыл под спойлер, чтобы места не занимала.
**Описание полей регистра mcause**
| Полн | Биты | Описание |
| --- | --- | --- |
| INTERRUPT | 31 | Тип ловушки: **0x0:** Исключение или NMI **0x1:** Прерывание |
| MINHV | 30 | Указывает на, что микроконтроллер находится состоянии чтения таблицы векторов прерываний. Это поле доступно только в при работе ECLIC контроллера. |
| MPP | 29:28 | Режим привилегий значение регистра **mstastus.MIE** до входа в ловушку: **0x0:** Привилегии пользователя, **0x1:** Привилегии супервизора, **0x2:** Зарезервировано, **0x3:** Режим машинных привилегий. |
| MPIE | 27 | Значение регистра **mstastus.MIE** перед входом в ловушку: **0x1:** Машинное прерывание было разрешено. **0x0:** Машинное прерывание было запрещено |
| Reserved | 26:24 | Reserved 0 |
| MPIL | 23:16 | Уровень прерывания до входа в обработчик прерывания |
| Reserved | 15:12 | Reserved 0 |
| EXCCODE | 11:0 | Номер(ID) прерывания. EXCCODE для NMI может быть **0x1** или **0xfff**. Значение управляется регистром **mmisc\_ctl**. |
### Регистр mtvt2
Регистр хранящий адрес общего обработчика прерываний в не-векторном режиме при работе ECLIC контроллера.
| Поле | Биты | Описание |
| --- | --- | --- |
| CMMON-CODE-ENTRY | 31:2 | Когда **mtvt2.MTVT2EN=1**, это поле определяет адрес общего обработчика в не-векторном режиме ECLIC контроллера. |
| Резерв | 1 | Значение 0 |
| MTVT2EN | 0 | Бит активации **mtvt2**. Если он равен **0x0:** то адрес общего обработчика прерывания в не-векторном режиме ECLIC контроллера определяется регистром **mtvec**. Если он равен **0x1:** то адрес общего обработчика прерывания в не-векторном режиме ECLIC контроллера определяется регистром полем **mtvt2.CMMON-CODE-ENTRY** |
### msumb
Специализированный регистр ядра Bumblebee, хранящий текущий машинный подрежим и подрежим, в которой было ядро перед входом в текущую ловушку.
| Поле | Бит | Описание |
| --- | --- | --- |
| Резерв | 31:10 | Все биты установлены в 0 |
| PTYP | 9:8 | Машинный подрежим перед входом в ловушку. **0x0:** Нормальный Машинный режим, **0x1:** Подрежим обработки прерываний **0x2:** Подрежим обработки исключения **0x3:** Подрежим обработки NMI |
| TYP | 7:6 | Текущий машинный подрежим. **0x0:** Нормальный Машинный режим, **0x1:** Подрежим обработки прерываний **x02:** Подрежим обработки исключения **0x3:** Подрежим обработки NMI |
| Резерв | 5:0 | Все биты установлены в 0 |
### mstatus
Регистр **mstatus** отслеживает и управляет текущим рабочим состоянием аппаратного потока (**hart**). Также под спойлер.
**Описание полей регистра mstatus**
| Поле | Бит | Описание |
| --- | --- | --- |
| SD | 31 | Бит **SD** — это бит только для чтения, который служит для того, чтобы определить сигнализирует ли поле **FS** или поле **XS** о наличии Dirty состояния, которое потребует сохранения контекста расширений микроконтроллера в памяти. По сути этот бит определяется следующей логической операцией: **SD = (((FS == 0x3)) or (DS == 0x3))**. SD можно проверить при переключения контекста, чтобы быстро определить, требуется ли сохранение или восстановление состояния в блоке FPU или дополнительных расширений |
| XS | 16:15 | Бит **XS** кодирует состояние пользовательских расширений, включая дополнительные регистры и CSR регистры и используется для снижения затрат на сохранение и восстановление контекста. **0x0:** — (Off) расширение отключено, любая вызванная инструкция этого расширения вызовет исключение, **0x1:** (Initial) когда состояние является начальным и имеет некое постоянное значение, **0x2:** (Clear) соответствующее состояние потенциально отличается от начального значения, но соответствует последнему сохраненному значению контекста. **0x3**: (Dirty)соответствующее состояние потенциально было изменено с момента последнего сохранения контекста и требуется его сохранение или восстановление. |
| FS | 13:14 | Бит **XS** кодирует состояние модуля FPU, включая дополнительные регистры(f0-f31) и CSR регистры и используется для снижения затрат на сохранение и восстановление контекста. **0x0:** — (Off) FPU отключен, любая вызванная инструкция FPU вызовет исключение, **0x1:** (Initial) когда состояние является начальным и имеет некое постоянное значение, **0x2** — (Clear) соответствующее состояние потенциально отличается от начального значения, но соответствует последнему сохраненному значению контекста. **0x3:** (Dirty)соответствующее состояние потенциально было изменено с момента последнего сохранения контекста и требуется его сохранение или восстановление. |
| MPP | 11:12 | Хранит текущий режим привилегий перед входом в ловушку. **0x0:** Пользовательский режим, **0x1:** Режим Супервизора, **0x3:** — Машинный режим |
| MPIE | 7 | Значение **MIE** перед входом в ловушку. |
| MIE | 3 | Глобальное разрешение машинного прерывания **0x0:** — Машинные прерывания запрещены. **0x1:** — Машинные прерывания разрешены. |
### mmisc\_ctl
Регистр содержит настройку того, чему равно значение регистра **mnvec**, в котором лежит адрес обработчика ловушки NMI.
Содержит единственно поле — бит номер 9 (**NMI\_CAUSE\_FF**). Да, именно бит номер 9 — в принципе, почему бы и нет.
Так вот, если **NMI\_CAUSE\_FF**(бит 9) равен **0x0**, то значение регистра **mnvec** будет равен адресу содержащемуся по вектору сброса. Если этот бит равен **0x1**, то значение регистра **mnvec** будет равно значению, лежащему в регистре **mtvec**, т.е. NMI исключения и прерывания будут обрабатываться через одну ловушку, а номер обработчика будет равен **0xFFF**.
### mepc
Регистр содержащий адрес возврата из ловушки. Адрес возврата автоматически сохраняется в этом регистре при возникновении исключения или прерывания. При возврате из ловушки он восстанавливается из это регистра в pc.
Этот регистр можно изменять, что используется в RTOS при переключении на другую задачу.
### mtvec
Регистр содержащий адрес ловушки. Может содержать как адрес ловушки прерываний, так и адрес ловушки обработчика исключений, зависит от настроек в регистре **mmisc\_ctl**
Ну вот, все нужные регистры изучены. Теперь можно прояснить ситуацию с обработкой прерываний и исключений.
Исключения и прерывания
-----------------------
Как я уже говорил, существует 3 различные ловушки событий, которые прерывают поток выполнения программы. Эти события разделяются на
* **исключения** (синхронные события),
* **NMI**(асинхронное немаскируемое событие),
* **прерывания**(асинхронные маскируемые события).
Каждое из таких событий обрабатывается ядром немного по-разному.
### Исключения и таблица исключений
Исключения обрабатываются отдельно. Базовый набор исключений ядра Bumblebee нашего микроконтроллера выглядит так:
**Таблица исключений**
| Код исключения | Тип Исключения/Прерывания | Синхронное/Асинхронное | Описание |
| --- | --- | --- | --- |
| 0 | Адрес инструкции не выровнен | Синхронное | Адрес в PC не выровнен. Это тип исключения не возникает в ядрах с сокращенными командами (С расширение ядра). |
| 1 | Ошибка доступа к инструкции | Синхронное | |
| 2 | Недопустимая инструкция | Синхронное | |
| 3 | Точка останова | Синхронное | Архитектура RISC-V определяет инструкцию BREAK. При выполнении этой инструкции ядро войдет в обработчик исключений. Эта инструкция обычно используется отладчиком, для установки точек останова. |
| 4 | Доступ по не выровненному адресу при операции чтения | Синхронное(исключение) | Ядро Bumblebee не поддерживает невыровненный доступ к памяти, поэтому доступ к памяти по невыровненным адресам вызовет исключение. |
| 5 | Ошибка доступа к памяти при операции чтения | Асинхронный |
| 6 | Доступ по не выровненному адресу при операции записи | Синхронное(исключение) | Ядро Bumblebee не поддерживает невыровненный доступ к памяти, поэтому доступ к памяти по невыровненным адресам вызовет исключение. |
| 7 | Ошибка доступа к памяти при операции записи | Асинхронный |
| 8 | Вызов окружения (команды ecall) из Пользовательского режима | Синхронное | RISC-V архитектура определяет инструкцию ECALL. При выполнении этой инструкции ядро войдет в обработчик исключений. Эта инструкция обычно используется программным обеспечением для принудительного перехода ядра в режим обработки исключений. |
| 11 | Вызов окружения (команды ecall) из машинного режима | Синхронное | RISC-V архитектура определяет инструкцию ECALL. При выполнении этой инструкции ядро войдет в обработчика исключений. Эта инструкция обычно используется программным обеспечением для принудительного перехода ядра в режим обработки исключений. |
Теперь рассмотрим как обработать прерывания:
### Прерывания
Прерывания — это асинхронные события прерывающие поток исполнения. У нашего микроконтроллера существует две реализации контроллеров прерывания RISC-V базовый контроллер PLIC(Platform-Level Interrupt Controller)умолчанию и режим CLIC (Core-Local Interrupt Controller). PLIC описан в привилегированной спецификации, а драфт версия для CLIC описана [здесь](https://github.com/riscv/riscv-fast-interrupt/blob/master/clic.adoc)
Работа PLIC опирается на регистры **mie** and **mip**, которые являются частью привилегированной спецификации RISC-V. Как говорит руководство на ядро, использование этого контроллера рекомендуется для симметричных многопроцессорных систем или для операционных систем типа Linux.
А для встроенного ПО и операционных систем реального времени рекомендуется использовать CLIC. Поэтому далее мы будем говорить только про CLIC.
После сброса ядро работает с базовым контроллером PLIC и необходимо явно переключиться на работу с CLIC. Это делается с помощью CSR регистра **mtvec** в двух его младших битах. По умолчанию они стоят в режиме (**00b**) PLIC в не-векторном режиме.
Для перехода в CLIC нужно установить два этих младших бита в **11b**. На самом деле микроконтроллер GD32VF103 использует ECLIC (расширенный контроллер прерываний) — немного улучшенная версия CLIC, описанного [здесь](https://doc.nucleisys.com/nuclei_spec/isa/eclic.html)
Но вкратце:
Котроллер поддерживает до 4096 прерываний, все прерывания и исключения, включая стандартные подключены к нему и управляются им. Прерывания, начиная с номера 19 являются внешними, например это может любая периферия. Вот как к ECLIC подключены прерывания.
Контроллер поддерживает следующие возможности:
Поиск обработчика по номеру прерывания, разрешение/запрещение прерываний, возведение флага прерывания, определение прерывания по его уровню и фронту, приоритизацию прерываний, векторный и невекторный режимы.
Все его режимы рассматривать не будем. Узнаем только про то, что нам надо. Всего в нашем китайском микроконтроллере 87 источников прерываний.
**87 прерываний микроконтроллера GD32VF103**
| Номер прерывания | Имя прерывания | Адрес вектора прерывания |
| --- | --- | --- |
| 3 | CLIC\_INT\_SFT | 0x0000\_000C |
| 7 | CLIC\_INT\_TMR | 0x0000\_001C |
| 17 | CLIC\_INT\_BWEI | 0x0000\_0044 |
| 18 | CLIC\_INT\_PMOVI | 0x0000\_0048 |
| 19 | WWDGT interrupt | 0x0000\_004C |
| 20 | LVD from EXTI interrupt | 0x0000\_0050 |
| 21 | Tamper interrupt | 0x0000\_0054 |
| 22 | RTC global interrupt | 0x0000\_0058 |
| 23 | FMC global interrupt | 0x0000\_005C |
| 24 | RCU global interrupt | 0x0000\_0060 |
| 25 | EXTI Line0 interrupt | 0x0000\_0064 |
| 26 | EXTI Line1 interrupt | 0x0000\_0068 |
| 27 | EXTI Line2 interrupt | 0x0000\_006C |
| 28 | EXTI Line3 interrupt | 0x0000\_0070 |
| 29 | EXTI Line4 interrupt | 0x0000\_0074 |
| 30 | DMA0 channel0 global interrupt | 0x0000\_0078 |
| 31 | DMA0 channel1 global interrupt | 0x0000\_007C |
| 32 | DMA0 channel2 global interrupt | 0x0000\_0080 |
| 33 | DMA0 channel3 global interrupt | 0x0000\_0084 |
| 34 | DMA0 channel4 global interrupt | 0x0000\_0088 |
| 35 | DMA0 channel5 global interrupt | 0x0000\_008C |
| 36 | DMA0 channel6 global interrupt | 0x0000\_0090 |
| 37 | ADC0 and ADC1 global interrupt | 0x0000\_0094 |
| 38 | CAN0 TX interrupts | 0x0000\_0098 |
| 39 | CAN0 RX0 interrupts | 0x0000\_009C |
| 40 | CAN0 RX1 interrupts | 0x0000\_00A0 |
| 41 | CAN0 EWMC interrupts | 0x0000\_00A4 |
| 42 | EXTI line[9:5] interrupts | 0x0000\_00A8 |
| 43 | TIMER0 break interrupt | 0x0000\_00AC |
| 44 | TIMER0 update interrupt | 0x0000\_00B0 |
| 45 | TIMER0 trigger and channel commutation interrupts | 0x0000\_00B4 |
| 46 | TIMER0 channel capture compare interrupt | 0x0000\_00B8 |
| 47 | TIMER1 global interrupt | 0x0000\_00BC |
| 48 | TIMER2 global interrupt | 0x0000\_00C0 |
| 49 | TIMER3 global interrupt | 0x0000\_00C4 |
| 50 | I2C0 event interrupt | 0x0000\_00C8 |
| 51 | I2C0 error interrupt | 0x0000\_00CC |
| 52 | I2C1 event interrupt | 0x0000\_00D0 |
| 53 | I2C1 error interrupt | 0x0000\_00D4 |
| 54 | SPI0 global interrupt | 0x0000\_00D8 |
| 55 | SPI1 global interrupt | 0x0000\_00DC |
| 56 | USART0 global interrupt | 0x0000\_00E0 |
| 57 | USART1 global interrupt | 0x0000\_00E4 |
| 58 | USART2 global interrupt | 0x0000\_00E8 |
| 59 | EXTI line[15:10] interrupts | 0x0000\_00EC |
| 60 | RTC alarm from EXTI interrupt | 0x0000\_00F0 |
| 61 | USBFS wakeup from EXTI interrupt | 0x0000\_00F4 |
| 62 | Reserved | 0x0000\_00F8 |
| 63 | Reserved | 0x0000\_00FC |
| 64 | Reserved | 0x0000\_0100 |
| 65 | Reserved | 0x0000\_0104 |
| 66 | Reserved | 0x0000\_0108 |
| 67 | Reserved | 0x0000\_010C |
| 68 | Reserved | 0x0000\_0110 |
| 69 | TIMER4 global interrupt | 0x0000\_0114 |
| 70 | SPI2 global interrupt | 0x0000\_0118 |
| 71 | UART3 global interrupt | 0x0000\_011C |
| 72 | UART4 global interrupt | 0x0000\_0120 |
| 73 | TIMER5 global interrupt | 0x0000\_0124 |
| 74 | TIMER6 global interrupt | 0x0000\_0128 |
| 75 | DMA1 channel0 global interrupt | 0x0000\_012C |
| 76 | DMA1 channel1 global interrupt | 0x0000\_0130 |
| 77 | DMA1 channel2 global interrupt | 0x0000\_0134 |
| 78 | DMA1 channel3 global interrupt | 0x0000\_0138 |
| 79 | DMA1 channel4 global interrupt | 0x0000\_013C |
| 80 | Reserved | 0x0000\_0140 |
| 81 | Reserved | 0x0000\_0144 |
| 82 | CAN1 TX interrupt | 0x0000\_0148 |
| 83 | CAN1 RX0 interrupt | 0x0000\_014C |
| 84 | CAN1 RX1 interrupt | 0x0000\_0150 |
| 85 | CAN1 EWMC interrupt | 0x0000\_0154 |
| 86 | USBFS global interrupt | 0x0000\_0158 |
### Обработка прерываний
Процесс обработки прерываний и исключений довольно прост. При возникновении таких событий, вход в ловушку Исключения/Прерывания/NMI происходит практически одинаково и включает в себя следующие шаги, которые выполняются одновременно за один цикл:
#### Вход в ловушку
* При входе в ловушку ядро обновляет CSR контрольные регистры
+ **mcause**
+ **mepc**
+ **mstatus**
+ **mintstatus** для прерывания или исключения
* Одновременно ядро переходит в Машинный Привилегированный режим и в соответствующий подрежим машинного режима
* В это же время останавливается выполнение текущей программы и PC загружается адрес обработчика ловушки в зависимости от того, какое событие произошло — Исключением, Прерывание или NMI. Адрес обработчика может браться из разных регистров.
Важно, что обработчик ловушки находится всегда в Машинном режиме.
На рисунке я показал синим — шаги которые одинаковы для всех видов ловушек и шаги, разными цветами уникальные шаги для входа в различные ловушки.
Нам понадобится эта картинка для того, чтобы правильно сделать обработчики прерываний.
#### Выход из прерывания
Картинку рисовать не буду, опишу в общих деталях:
* При выходе из ловушки ядро прекращает работу текущей программы, загружает в PC адрес, который записан в регистр **mepc** и переходит на него
* Обновляет следующие CSR регистры:
+ **mstatus**
+ **mcause**
+ **mintstatus**
* Обновляет режим привилегий и машинные подрежимы, возвращаясь в те режимы, что были до входа в ловушку.
Все это дело выполняется за один цикл.
В RISC-V нет автоматического stacking и unstacking как в CortexM ядрах, поэтому, как минимум 16 регистров общего назначения придется сохранять и восстанавливать руками.
Давайте разберемся как же обрабатывать прерывания. Как видно из картинки существует два режима обработки прерываний — векторный, через таблицу векторов и не-векторный — через единый обработчик прерывания. Также существует несколько способов(например, Interrupt Tail-Chaining) сделать обработку прерываний эффективнее.
Чтобы не раздувать, итак уже офигенно большую статью, я покажу как реализовать только не-векторный режим без оптимизации и шаманства. Но вкратце опишу оба.
### Векторный и невекторный режимы работы прерываний
Контроллер прерываний ECLIC позволяет выбрать режим обработки прерываний и обеспечивает гибкость для выбора поведения каждого отдельного прерывания — либо с использованием аппаратной векторизации, либо без неё. В результате это позволяет пользователям оптимизировать каждое прерывание и пользоваться преимуществом обоих видов поведения. Аппаратная векторизация имеет более быстрый механизм обработки прерывания, но и имеет больший объем кода (из-за сохранения и восстановления контекста для каждого из прерываний). Напротив, невекторный режим имеет преимущество в размере кода, так как используется только один обработчик всех прерываний, но обработка происходит медленнее. Какой режим выгоднее, выбирает разработчик. Я выбрал не-векторный.
### Векторный режим
В этом режиме при возникновении прерывания контроллер прерываний переходит на адрес прерывания, который указан в таблице векторов прерываний в соответствии с номером прерывания (алгоритм работы очень похож на обработку прерываний CortexM).
### Не-векторный режим обработки прерываний
По умолчанию все прерывания настроены в не-векторный режим. Т.е. для обработки прерывания существует только один единый обработчик.
Тип обработки прерывания указывается в регистре **CLICINTATTR[i]** в поле **SHV**. По умолчанию там записан **0** — в этом случае прерывание настроено на не-векторный режим, т.е. при возникновении прерывания или исключения контроллер всегда вызывает единый обработчик, находящийся по адресу, указанному в регистре **mtvec** или **mtvt2**, в зависимости от настроек и типов ловушки.
В этом обработчике необходимо определить, какое прерывание произошло и вызвать необходимую функцию обработки прерывания. Узнать, что за прерывание произошло можно с помощью регистра **mcause** — который хранит в себе номер прерывания в поле **EXCCODE**.
### Регистры контроллера прерываний ECLIC
Для настройки контроллера нам понадобится описание его регистров. Ниже я привел табличку с 7 регистрами, но на самом деле их на много больше, так как i — означает номер прерывания. Т.е. существует 87 **clicintip**, и 87 **clicintie**, и 87 **clicintattr** и 87 **clicintctl**, каждый из которых отвечает за свое прерывание.
| Смещение | Доступ | Названия | Длина |
| --- | --- | --- | --- |
| 0x0000 | RW | cliccfg | 8-bit |
| 0x0004 | R | clicinfo | 32-bit |
| 0x000b | RW | mth | 8-bit |
| 0x1000+4\*i | RW | clicintip[i] | 8-bit |
| 0x1001+4\*i | RW | clicintie[i] | 8-bit |
| 0x1002+4\*i | RW | clicintattr[i] | 8-bit |
| 0x1003+4\*i | RW | clicintctl[i] | 8-bit |
Ну а теперь, надо же описать, что это за регистры…
#### Регистр MTH
Регистр, который задает уровень срабатывания прерывания. Как видно из картинки, можно управлять не только приоритетом прерывания, но и уровнем прерывания и делать, что-то типа прореживания, мол если уровень прерывания ниже определенной границы, то это и не прерывание вовсе и не нужно его возводить.
Сам уровень конкретного прерывания, как было сказано задается **clicintctl[i]**.
А вот уровень срабатывания — как раз задается регистром **mth**. Собственно это просто 8-битный регистр, хранящий уровень срабатывания прерывания.
#### Регистр CLICINTCTL[i]
Регистр используется для задания уровня и приоритета прерывания. Как будет рассказано ниже, старшие биты(эффективные биты), количество которых задается в регистре CLICCFG указывают уровень прерывания, а младшие — приоритет. Количество эффективных битов также можно считать из регистра CLICINFO в поле CLICINTCTLBITS.
#### Регистр CLICCFG
Регистр общей конфигурации прерываний. Он задает количество эффективных битов, ответственных за установку уровня и приоритета прерывания. Чтобы было понятнее, приведу картинку.
Непонятно? Тогда следите за описанием бита **nlbits** в табличке, должно много прояснить.
| Поле | Биты | Доступ | Значение по умолчанию | Описание |
| --- | --- | --- | --- | --- |
| Резерв | 7 | R | N/A | Зарезервировано, значение 0 |
| nmbits | 6:5 | R | N/A | Режим привилегий прерываний. Для нашего микроконтроллера он всегда 0: машинный. |
| nlbits | 4:1 | RW | 0 | Используется для указания эффективной разрядности значения уровня в регистре **clicintctl[i]**. Т.е. если в этом регистре стоит значение 4, то при задании уровня в регистре **clicintctl[i]** можно использовать только 4 старших бита, остальные биты используются для задания приоритета. Обычно используется значение от 2 до 8. |
| nvbits | 0 | R | N/A | Для нашего микроконтроллера всегда **1**: Поддерживает векторный режим. А если бы не поддерживал, был бы **0** |
#### Регистр CLICINFO
Регистр общей информации о системе прерываний
| Поле | Биты | Разрешение | значение по умолчанию | Описание |
| --- | --- | --- | --- | --- |
| Резерв | 31:25 | R | N/A | Зарезервировано, все значения в 0 |
| CLICINTCTLBITS | 24:21 | R | N/A | Эффективная разрядность регистра **clicintctl[i]**. |
| VERSION | 20:13 | R | N/A | Номер версии аппаратной реализации контроллера прерываний. |
| NUM\_INTERRUPT | 12:0 | R | N/A | Количество источников прерываний, поддерживаемых микроконтроллером. |
#### CLICINTIP[i]
Регистр содержащий единственный флаг запроса прерывания. i — обозначает номер прерывания. Наш контроллер содержит 87 прерываний, поэтому будет 87 таких регистров.
| Поле | Биты | Разрешение | значение по умолчанию | Описание |
| --- | --- | --- | --- | --- |
| Резерв | 7:1 | RO | N/A | Зарезервировано, все значения в 0 |
| IP | 0 | RW | 0 | Флаг ожидания источника прерывания. **1** — означает что прерывание сработало. Если контроллер настроен на работу с прерываниями по уровню, то программно его очистить нельзя. Он будет очищен автоматически когда будет очистен исходный источник прерывания. |
#### CLICINTIE[i]
Регистр разрешения прерываний. Их тоже 87.
| Поле | Биты | Разрешение | значение по умолчанию | Описание |
| --- | --- | --- | --- | --- |
| Резерв | 7:1 | RO | N/A | Зарезервировано, все значения в **0** |
| IE | 0 | RW | 0 | **1** — означает что прерывание разрешено |
#### CLICINTATTR[i]
Регистр настройки источника прерываний. Как было показано выше, контроллер прерываний может работать в нескольких режимах. Прерывания могут срабатывать по уровню, по фронту переднем или заднему, а также тип прерывания векторный или не векторный. И их тоже 87.
| Поле | Биты | Разрешение | По умолчанию | Описание |
| --- | --- | --- | --- | --- |
| Резерв | 7:6 | R | N/A | Зарезервировано, значение **11b** |
| Резерв | 5:3 | R | N/A | Зарезервировано, все значения **0** |
| TRIG | 2:1 | RW | 0 | **00b и 10b:** Прерывание срабатывает по уровню. **01b:** Прерывание срабатывает по положительному фронту. **11b:** Прерывание срабатывает по отрицательному фронту. |
| SHV | 0 | RW | 0 | **0x0:** Прерывание обрабатывается в невекторном режиме. **0x1**: Прерывание обрабатывается в векторном режиме. |
Все регистры кончились, осталось описать, как работает машинный таймер и порты… уже немножко и можно будет моргать.
### Машинный таймер
Машинный таймер — это как системный таймер в CortexM, но только машинный. Сам машинный таймер является неотъемлемой частью привилегированной архитектуры ядра, доступ к нему должны иметь все аппаратные потоки(hart). И для работы с ним даже выделили регистры **mtime** и **mtimecmp**.
Спецификация привилегированной архитектуры рекомендует сделать эти регистры как обычные регистры, а не регистры CSR. Собственно китайские ребята так и сделали, вот только в документациях, я нигде не смог найти на каком адресе находятся эти регистры.
Пришлось вытащить его из примеров. Находится регистр **mtime** по адресу **0xd1000000**, а регистр **mtimecmp** по адресу **0xd1000008**.
Размер у обоих регистров 64 бита. И отвечают они за:
* **mtime** — регистр содержащий счетчик таймера
* **mtimecmp** — регистр сравнения. Когда значение таймера в регистре **mtime** будет равно значению с регистре **mtimecmp** таймер поставит флаг запроса на прерывание в регистре **CLICINTIP[7]**.
Запись в эти регистры гарантированно сбросит флаг запроса прерывания, но это неточно, потому что он сбрасывается не сразу и возможны паразитные прерывания таймера. Однако, как говорит спецификация-это очень редкое событие, и потому все нормально.
> Writes to mtime and mtimecmp are guaranteed to be reflected in MTIP eventually, but not necessarily immediately.
>
>
>
> A spurious timer interrupt might occur if an interrupt handler increments mtimecmp then immediately returns, because MTIP might not yet have fallen in the interim. All software should be
>
> written to assume this event is possible, but most software should assume this event is extremely unlikely. It is almost always more performant to incur an occasional spurious timer interrupt than to poll MTIP until it falls.
В нашем случае, когда таймер досчитает до значения в **mtimecmp**, мы должны сбросить **mtime** в 0 в обработчике, чтобы флаг запроса на прерывание тоже сбросился.
В модуль таймера ребята из Китая запихнули еще один регистр **msip** — с помощью него можно генерировать программное прерывание. Его тоже можно использовать для обращения к машинным регистрам из пользовательского режима. А RTOS используют его для генерации программного прерывания, которое используется для переключения контекста.
| Поле | Биты | Разрешение | значение по умолчанию | Описание |
| --- | --- | --- | --- | --- |
| Резерв | 7:1 | RO | N/A | Зарезервировано, все значения в **0** |
| MSIP | 0 | RW | 0 | **1** — сгенерировать программное прерывание |
### Порты и регистры периферии
Порты в нашем китайском микроконтроллер очень похожи на порты в STM32, все тоже самое, только регистры называются по другому и настройки немного по другому сгруппированы. Но суть такая же.
Нужно подать тактирование на порты, а затем настроить порты в режим выхода через регистр Port control register 0 (**GPIOx\_CTL0**, x=A..E).
И собственно для нас нужен еще один регистр Port output control register (**GPIOx\_OCTL**, x=A..E), который позволит переключить ножку в противоположное состояние, чтобы моргнуть светодиодом.
На самом деле периферийные регистры я сгенерировал из svd файла и обращаться к ним через мою обертку можно точно также, как и регистрам STM32. Поэтому зацикливаться тут я не буду, лучше уже перейду к коду.
Моргаем светодиодом
-------------------
Фуууух… ну кажется все, думаю этих знаний достаточно, чтобы поморгать светодиодом. Теперь можно перейти и к практике. И первое что нужно сделать, это настроить контроллер прерываний. Как я уже говорил, работать мы будем с ECLIC контроллером в не-векторном режиме.
В этом режиме у нас один единственный обработчик прерываний, при входе в него нам нужно сохранить регистры, и еще нужно сохранить регистры **mcause**, **mepc** и **msubm**, потому как нас могут опять прервать, а как вы знаете из разноцветной картинки, которую я показал выше, во время прерывания эти регистры перезаписываются. Соответственно при выходе нужно восстановить все это дело.
Сохранять регистры сами мы не будем, за нас это может сделать компилятор, для этого есть специальный атрибут функции **\_\_interrupt**, собственно когда компилятор его видит, он подставляет пролог и эпилог функции в которых как раз и производится сохранение регистров при входе, и восстановление регистров при выходе и еще добавляет команду **mret** выхода из машинного режима.
Но если сильно нужно, можно написать функцию на ассемблере или stackless функцию на С++ и сохранить регистры самостоятельно… эффект будет тот же самый.
Итак, вот наш общий единый обработчик всех прерываний.
```
__interrupt void IrqEntry()
{
const auto mcause = CSR::MCAUSE::Get();
const auto mepc = CSR::MEPC::Get();
const auto msubm = CSRCUSTOM::MSUBM::Get();
//номер прерывания сохранен в mcause
const auto exceptionCode = mcause & 0xFFF ;
//вызываем обработчик нужного прерывания
NonVectoredInt::HandleInterrupt(exceptionCode);
__disable_interrupt();
CSR::MCAUSE::Write(mcause);
CSR::MEPC::Write(mepc);
CSRCUSTOM::MSUBM::Write(msubm) ;
}
```
Во-первых, при входе мы сохранили все регистры на стеке(это у нас делает сам компилятор, потому что мы указали волшебное слово **\_\_interrupt**), при выходе они восстанавливаются из стека.
Во-вторых, мы сохранили CSR регистры, которые необходимо сохранить в прерываниях, в соответствии с документацией, и при выходе мы их восстановили.
В-третьих, мы вызвали нужную нам функцию обработки прерывания в зависимости от его номера. Вот кстати, как эта функция выглядит (подглядел у IAR).
```
namespace NonVectoredInt
{
static void HandleInterrupt(std::uint32_t interruptId)
{
// проверим, что код прерывания не больше размера таблицы прерываний
assert(interruptId < InterruptVectorTable.size());
// ищем указатель на функцию обработчика в таблице прерываний
tInterruptFunction fp = InterruptVectorTable[interruptId];
if (fp != nullptr)
{
fp(); // вызываем обработчик
}
}
} ;
```
Мы просто берем указатель на нужную функцию из таблицы, которая выглядит как одномерный массив указателей на функции для обработки прерываний.
```
using tInterruptFunction = void(*)() ;
inline constexpr std::array InterruptVectorTable
{
nullptr,
nullptr,
nullptr,
DummyModule::HandleInterrupt,//программное прерывание
nullptr,
nullptr,
nullptr,
SystemTimer::HandleInterrupt, //А вот и наш обработчик машинного таймера
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
DummyModule::HandleInterrupt,//eclic\_bwei\_handler,
DummyModule::HandleInterrupt, //eclic\_pmovi\_handler,
DummyModule::HandleInterrupt, //WWDGT\_IRQHandler,
DummyModule::HandleInterrupt,//LVD\_IRQHandler,
....
} ;
```
Если вы заметили, под номером 7 стоит адрес функции обработки прерывания от машинного таймера, но следуя, моему внутреннему эго, я по старинке назвал его SystemTimer::HandleInterrupt
```
struct SystemTimer
{
static void HandleInterrupt()
{
auto mtime = MACHINETIMER::MTIME::Get() -
MACHINETIMER::MTIMECMP::Get();
MACHINETIMER::MTIME::Write(mtime);
AppTimerService::OnSystemTick() ;
}
};
```
В нем происходит вызов функции `OnSystemTick()` сервиса таймеров. Про него немного позже, а пока нужно настроить обработку исключений и NMI.
Для этого, с исключениями мы провернем точно такой же "фокус". Только таблица будет поменьше, исключений всего 12.
```
inline constexpr std::array ExceptionVectorTable
{
DummyModule::HandleInterrupt, //0 - Instruction address misaligned
DummyModule::HandleInterrupt, //1 - Instruction access fault
DummyModule::HandleInterrupt, //2 - Illegal instruction
DummyModule::HandleInterrupt, //3 - Breakpoint
DummyModule::HandleInterrupt, //4 - Load address misaligned
DummyModule::HandleInterrupt, //5 - Load access fault
DummyModule::HandleInterrupt, //6 - Store/AMO address misaligned
DummyModule::HandleInterrupt, //7 - Store/AMO access fault
EnvironmentCall::HandleInterrupt, //8 - Environment call from U-mode
nullptr,
nullptr,
EnvironmentCall::HandleInterrupt, //11 - Environment call from M-mode
};
```
```
namespace NonVectoredInt
{
static void HandleException(std::uint32_t exceptiontId)
{
assert(exceptiontId < ExceptionVectorTable.size());
tInterruptFunction fp = ExceptionVectorTable[exceptiontId];
if (fp != nullptr)
{
fp();
}
}
} ;
```
**NMI** будем обрабатывать вместе с исключениями. Зададим его номер — 0xFFF.
```
__interrupt void ExceptionEntry()
{
const auto mcause = CSR::MCAUSE::Get();
const auto mepc = CSR::MEPC::Get();
const auto msubm = CSRCUSTOM::MSUBM::Get();
const auto exceptionCode = mcause & 0xFFF ;
if (exceptionCode != 0xFFF) // если не NMI
{
NonVectoredInt::HandleException(exceptionCode);
} else
{
DummyModule::HandleInterrupt() ; // а это если NMI
}
__disable_interrupt();
CSR::MCAUSE::Write(mcause);
CSR::MEPC::Write(mepc);
CSRCUSTOM::MSUBM::Write(msubm) ;
}
```
Теперь нужно указать, что **NMI** будет обрабатываться той же ловушкой, что используется для исключений, адрес обработчика которой будет указан в **mtvec**, а номер обработчика **NMI** будет **0xFFF**, см описание регистра **MMISC\_CTL** выше в статье.
```
// Устанавливаем указание адреса обработчика NMI через обработчик,
// адрес которого указан в mtvec. Номер обработчика NMI будет 0xFFF
CSRCUSTOM::MMISC_CTL::NMI_CAUSE_FFF::MnvecIsMtvecNmiIsFFF::Set();
```
Настроим в каком регистре будет указан адрес ловушки общего обработчика прерываний
```
// Настраиваем адрес единого обработчика прерываний.
// Указываем, что он будет находится в регистре MTVT2
CSRCUSTOM::MTVT2::Write(
CSRCUSTOM::MTVT2::MTVT2EN::Mtvt2IsTrapAddress::Value |
reinterpret_cast(&NonVectoredInt::IrqEntry));
```
Ну a теперь переключимся в режим работы контроллера ECLIC и укажем адрес единого обработчика исключений и NMI в регистре **mtvec**
```
// Переключаемся на режим работы с ECLIC и задаем адрес единого обработчика исключений
CSR::MTVEC::Write(
CSR::MTVEC::MODE::Eclic::Value |
reinterpret_cast(&NonVectoredInt::ExceptionEntry));
```
Собственно все… контроллер и адреса обработчиков настроены. Полный код
```
extern "C"
{
int __low_level_init(void)
{
{
CriticalSection cs;
// Устанавливаем указание адреса обработчика NMI через общий обработчик,
// адрес которого указан в mtvec. Номер обработчика NMI будет 0xFFF
CSRCUSTOM::MMISC_CTL::NMI_CAUSE_FFF::MnvecIsMtvecNmiIsFFF::Set();
// Настраиваем адрес единого обработчика прерываний.
// Указываем, что он будет находится в регистре MTVT2
CSRCUSTOM::MTVT2::Write(
CSRCUSTOM::MTVT2::MTVT2EN::Mtvt2IsTrapAddress::Value |
reinterpret_cast(&NonVectoredInt::IrqEntry));
// Переключаемся на режим работы с ECLIC
// и задаем адрес единого обработчика исключений
CSR::MTVEC::Write(CSR::MTVEC::MODE::Eclic::Value |
reinterpret\_cast(&NonVectoredInt::ExceptionEntry));
// Включаем подсчет циклов и счетчика инструкций mycycle\_minstret
CSRCUSTOM::MCOUNTINHIBITPack::Set();
}
}
```
Теперь нужно настроить машинный таймер и его прерывание.
```
// Настраиваем количество бит отвечающих за уровень прерывания
// в регистре CLICINTCTL_7. Пусть будет 3 бита
ECLIC::CLICCFG::NLBITS::MaxBitsForLevel3::Set();
//Ставим уровень срабатывания прерывания в 0
ECLIC::MTH::Write<0U>();
//Ставим невекторный режим для обработки прерывания таймера
ECLIC::CLICINTATTR_7::SHV::NonVectored::Set();
//Ставим уровень прерывания в 1, приоритет не будем трогать
ECLIC::CLICINTCTL_7::Write<
1U << (8U - ECLIC::CLICCFG::NLBITS::MaxBitsForLevel3::Value)>();
//Настраиваем машинный таймер. Таймер будет переполнятся раз в 1 мс.
MACHINETIMER::MTIMECMP::MTIMEField::Value::Write() ;
MACHINETIMER::MTIME::Write<0U>();
//Разрешить прерывание таймера - прерывание номер 7
ECLIC::CLICINTIE\_7::IE::Enable::Write();
//Разрешаем глобальное машинное прерывание
CSR::MSTATUSPack::SetValueBitsAtomic();
```
Осталось подать тактирование на порты, к которым подключены светодиоды и настроить эти порты на выход. Светодиоды у нас на портах GPIOC.7 и GPIOB.6
```
RCU::APB2EN::PCEN::Enable::Set();
RCU::APB2EN::PBEN::Enable::Set();
GPIOC::CTL0::CTLMD7::GpioOutputPushPull50Mhz::Set();
GPIOB::CTL0::CTLMD6::GpioOutputPushPull50Mhz::Set();
```
**Полный код**
```
#include "gpiocregisters.hpp"
#include "gpiobregisters.hpp"
#include "rcuregisters.hpp" //for RCU
#include "csrregisters.hpp" //for CSR
#include "eclicregisters.hpp" // for ECLIC
#include "machinetimerregisters.hpp"
#include "systemconfig.hpp" // for SystemTimerPeriod
#include "criticalsection.hpp" // for CriticalSection
#include "csrcustomregisters.hpp"
#include "vectortable.hpp" //for InterruptVectorTable
namespace NonVectoredInt
{
static void HandleInterrupt(std::uint32_t interruptId)
{
assert(interruptId < InterruptVectorTable.size());
tInterruptFunction fp = InterruptVectorTable[interruptId];
if (fp != nullptr)
{
fp();
}
}
static void HandleException(std::uint32_t exceptiontId)
{
assert(exceptiontId < ExceptionVectorTable.size());
tInterruptFunction fp = ExceptionVectorTable[exceptiontId];
if (fp != nullptr)
{
fp();
}
}
__interrupt void ExceptionEntry()
{
const auto mcause = CSR::MCAUSE::Get();
const auto mepc = CSR::MEPC::Get();
const auto msubm = CSRCUSTOM::MSUBM::Get();
const auto exceptionCode = mcause & 0xFFF;
if (exceptionCode != 0xFFF) // if not NMI
{
NonVectoredInt::HandleException(exceptionCode);
}
else
{
DummyModule::HandleInterrupt(); // for NMI handling
}
__disable_interrupt();
CSR::MCAUSE::Write(mcause);
CSR::MEPC::Write(mepc);
CSRCUSTOM::MSUBM::Write(msubm);
}
__interrupt void IrqEntry()
{
const auto mcause = CSR::MCAUSE::Get();
const auto mepc = CSR::MEPC::Get();
const auto msubm = CSRCUSTOM::MSUBM::Get();
const auto exceptionCode = mcause & 0xFFF;
NonVectoredInt::HandleInterrupt(exceptionCode);
__disable_interrupt();
CSR::MCAUSE::Write(mcause);
CSR::MEPC::Write(mepc);
CSRCUSTOM::MSUBM::Write(msubm);
}
}
extern "C"
{
int __low_level_init(void)
{
{
CriticalSection cs;
// Устанавливаем указание адреса обработчика NMI через общий обработчик,
// адрес которого указан в mtvec. Номер обработчика NMI будт 0xFFF
CSRCUSTOM::MMISC_CTL::NMI_CAUSE_FFF::MnvecIsMtvecNmiIsFFF::Set();
// Настраиваем адрес единого обработчика прерываний.
// Указываем, что он будет находится в регистре MTVT2
CSRCUSTOM::MTVT2::Write(
CSRCUSTOM::MTVT2::MTVT2EN::Mtvt2IsTrapAddress::Value |
reinterpret_cast(&NonVectoredInt::IrqEntry));
// Переключаемся на режим работы с ECLIC и устанавливаем
// адрес единого обработчика исключений
CSR::MTVEC::Write(
CSR::MTVEC::MODE::Eclic::Value |
reinterpret\_cast(&NonVectoredInt::ExceptionEntry));
// Включаем подсчет циклов и счетчика инструкций mycycle\_minstret
CSRCUSTOM::MCOUNTINHIBITPack::Set();
}
ECLIC::CLICCFG::NLBITS::MaxBitsForLevel3::Set();
//Ставим уровень срабатывания прерывания в 0
ECLIC::MTH::Write(0U);
//Ставим невекторный режим для обработки прерывания таймера
ECLIC::CLICINTATTR\_7::SHV::NonVectored::Set();
//Ставим уровень прерывания в 1, приоритет не будем трогать
ECLIC::CLICINTCTL\_7::Write<
1U << (8U - ECLIC::CLICCFG::NLBITS::MaxBitsForLevel3::Value)>();
MACHINETIMER::MTIMECMP::MTIMECMPField::Value::Write() ;
MACHINETIMER::MTIME::Write<0U>();
//Разрешить прерывание таймера - прерывание номер 7
ECLIC::CLICINTIE\_7::IE::Enable::Write();
//Enable machine interrupt
CSR::MSTATUSPack::SetValueBits();
RCU::APB2ENPack::Set();
GPIOC::CTL0::CTLMD7::GpioOutputPushPull50Mhz::Set();
GPIOB::CTL0::CTLMD6::GpioOutputPushPull50Mhz::Set();
return 1;
}
}
int main()
{
while (true)
{
asm volatile(" ");
}
return 0;
}
```
Мы все ближе к морганию светодиода.
Определим сервис таймера и функцию, которая будет запускаться в обработчике прерывания машинного таймера. Она простая. Она будет вызвать функцию `OnTick()` у программных таймеров
```
template
struct TimerService
{
static void OnSystemTick()
{
(Timers::OnTick(), ...);
}
};
```
Программный таймер — это вот такая штука, которая вызывает метод OnTimeout(), когда он переполнится.
```
template
class SoftwareTimer
{
public:
static void OnTick()
{
--ticksRemain ;
if (ticksRemain == 0U)
{
ticksRemain = ticksReload ;
(Subscribers::OnTimeout(),...) ;
}
}
private:
static constexpr std::uint32\_t msInSec = 1000UL ;
static constexpr std::uint32\_t ticksReload =
static\_cast((msPeriod \* TimerFrequency) / msInSec) ;
static inline volatile std::uint32\_t ticksRemain = ticksReload;
} ;
```
Теперь создадим отдельный программный таймер для каждого светодиода, один на 100 ms, второй на 200ms и зарегистрируем программные таймеры в сервисе системного таймера
```
//Настройка таймеров для светодиодов
using Led1Timer = SoftwareTimer ;
using Led2Timer = SoftwareTimer ;
//регистрация таймеров
using AppTimerService = TimerService ;
```
Ну и кульминация, светодиоды Led1 и Led2 — это просто ножки портов GPIOB.6 и GPIOC.7
```
template
struct Leds
{
static void OnTimeout()
{
// Переключение ножки, которое вызывается в программных таймерах
Pin::Toggle();
}
};
template
struct DummyPin
{
static void Toggle()
{
Port::OCTL::Toggle(1 << num);
}
};
using Led1 = Leds>;
using Led2 = Leds>;
```
Функция main, не интересная, она выглядит очень скромно
```
int main()
{
while (true)
{
asm volatile(" ");
}
return 0;
}
```
В общем и целом, это работает так:
Как только мы разрешили прерывание машинного таймера и глобальное машинное прерывание. Через 1 мс срабатывает прерывание машинного таймера, которое вызывает метод `OnTick()` программных таймеров. В момент, когда время программного таймера истекло, вызывается его метод `OnTimeout()`, в котором переключается ножка порта к которому подключен светодиод.
Вроде бы все, надеюсь кому-то может помочь, если начнете изучать RISC-V.
Как обычно, выкладываю код под [IAR 1.31 for RISC-V](https://yadi.sk/d/IQ7Dw28t5G9CPw).
[И ссылка на Гитхаб](https://github.com/lamer0k/GD32VF103) с исходниками
З.Ы. RISC-V оставил двоякое впечатление, с одной стороны это очень расширяемая и гибкая штука, можно делать что угодно, с другой, есть риск, что производителей занесет в строну, и каждый будет городить свой огород. Надеюсь, что все таки все спецификации скоро утвердят и все уляжется.
Исправления, по наставлению [Ryppka](https://habr.com/ru/users/ryppka/) заменил структуру NonVectoredInt на namespace | https://habr.com/ru/post/516006/ | null | ru | null |
# Тестирование в Яндексе. Матчеры: когда они полезны и как легко их использовать
[](http://habrahabr.ru/company/yandex/blog/184634/)Как вы могли догадаться по картинке справа, речь пойдёт об автоматизированном тестировании. Точнее о такой технологии, как матчеры. Они помогают серьёзно сократить дублирование кода и упростить код тестов для восприятия, а создавать и использовать матчеры достаточно просто.
Сама по себе технология матчеров не новая — в текущем виде она была залита в репозиторий в июле 2012 года, а появилась и того раньше. Но, несмотря на это, многие о ней до сих пор не слышали или по каким-то причинам избегают. Мы хотим рассказать, как легко получать преимущества от её использования, и поделиться с вами нашей библиотекой матчеров.
Предположим, у нас есть набор неких фруктов. Среди них чаще всего встречается круглый, оранжевый и сладкий.
```
public class Fruit {
...
public Color getColor() {...}
public boolean isSweet() {...}
public Shape getShape() {...}
}
```
Известно, что именно таким условиям удовлетворяет апельсин. Помимо фруктов, у нас есть и конвейер, через который можно пропустить такие фрукты. Есть и задача для конвейера — отсеять не апельсины, проведя серию тестов.
И вот удача — у нас под рукой как раз оказался аппарат, который умеет определять сладкий ли фрукт и какого он цвета, сравнивать его форму с рядом известных и проводить еще множество проверок. Аппарат этот называется [JUnit](http://en.wikipedia.org/wiki/JUnit).
Перед началом теста, на конвейер вываливается новый фрукт.
```
@Before
public void setUp() throws Exception {
someFruit = getNextFruit();
}
```
Определим сперва, что фрукт круглый.
```
@Test
public void orangeIsRound() {
assertEquals("Expected shape - " + Shape.ROUND + ", but was - " + someFruit.getShape(),
someFruit.getShape(), Shape.ROUND);
}
```
Затем, что фрукт сладкий.
```
@Test
public void orangeIsSweet() {
assertTrue("Fruit should be sweet - expected TRUE", someFruit.isSweet());
}
```
И, наконец, посмотрим на его цвет.
```
@Test
public void orangeHasOrangeColor() {
assertEquals("Orange has orange color, but was - " + someFruit.getColor(),
someFruit.getColor(), Color.ORANGE);
}
```
Какие минусы сразу очевидны? Во-первых, в каждой из проверок пришлось самостоятельно склеивать комментарий из ожидаемого значения, фактического значения, значения дополнительных уточнений и разных междометий. Даже описание этого списка утомительно.
Во-вторых, представьте, что мы решили определять еще и сорт апельсинов, добавили для этого специального «дегустатора» и сказали ему: «Одобряй только сорт «Валенсия»». Но «дегустатор» не знает, что решил проверяющий автомат, если сам не спросит — автомат не болтлив. В итоге он будет пробовать все подряд. Чтобы не отравить «дегустатора» мячиком, который не успели проверить на сладость, нужно научить его игнорировать всё лишнее. Для этого ему нужно спросить автомат отдельно и самостоятельно, после чего всё забракованное отложить в сторону и больше не трогать.
«Дегустатор» — это всего лишь еще один тест в нашем JUnit-аппарате, поэтому можно и нужно использовать встроенный рантайм-механизм игнорирования теста — assume. Тогда сценарий начала дегустации будет выглядеть так.
```
@Test
public void degusto() {
assumeTrue("Expected shape - " + Shape.ROUND + ", but was - " + someFruit.getShape(),
someFruit.getShape().equals(Shape.ROUND));
assumeTrue("Fruit should be sweet - expected TRUE", someFruit.isSweet());
assumeTrue("Orange has orange color, but was - " + someFruit.getColor(),
someFruit.getColor().equals(Color.ORANGE));
// Далее дегустатор полностью уверен что фрукт можно кусать.
}
```
Хорошо заметно, что у каждого нового «дегустатора» при таком описании сценария есть два пути — копипастить сценарий или делать новый метод на каждый набор предпроверок. И в каждой предпроверке снова нужно самому заботиться о составлении сообщения о причине выбраковки. Любой из этих вариантов сложно поддерживать и очень страшно воспринимать.
Вдобавок ко всему, придется отказываться от `assertEquals`, `assertNotEquals`, `assertNotNull`, `assertArrayEquals` и т.д. В стандартной поставке JUnit эти assert\* есть почти на любой тривиальный случай. А некоторых еще и несколько — на каждый тип аргументов. То есть логика проверки заключена в названии метода и жёстко привязана к его реализации. А теперь представьте, сколько нужно было бы кода дублировать и поддерживать, если на каждый assert\* пришлось бы сделать аналогичный assume\*.
Значит, нужно разделить логику самой проверки, вывода описания и функцию принятия решения:
* бракуем — assert,
* игнорируем — assume,
* а так же, фильтруем, ищем нужные, просеиваем, изменяем и т.д.
Тут в дело и вступают матчеры — маленькие объекты, которые содержат логику принятия решения, знают, что ждали и что получили, о чем самостоятельно сообщают. Первые три проверки при помощи матчеров почти что поэтично описывают действие. И это может прочитать любой, кто хочет узнать, что делает сценарий.
```
@Test
public void orangeIsRoundWithMatcher() {
assertThat(someFruit, is(round()));
}
@Test
public void orangeIsSweetWithMatcher() {
assertThat(someFruit, is(sweet()));
}
@Test
public void orangeHasColorWithMatcher() {
assertThat(someFruit, hasColor(Color.ORANGE));
}
```
Для такой красоты, существует специальная библиотека [Hamcrest](https://code.google.com/p/hamcrest/wiki/Tutorial). Она содержит в себе и интерфейс для реализации, и методы **assertThat** и **assumeThat** (последний, на самом деле, внутри JUnit, но использует интерфейс из Hamcrest). Они и спрашивают матчер об объекте, принимая решение.
Начиная с версии 4.11, в зависимостях JUnit библиотека Hamcrest имеет версию не ниже 1.3. Именно она ввела интерфейс, в котором реализовано всё, что описано дальше. Поэтому, используя мавен, достаточно подключить JUnit 4.11, и минимально необходимый набор инструментов готов к использованию. А для полного набора всех доступных матчеров из поставки Hamcrest, понадобится артифакт hamcrest-all, который можно подключить отдельно.
[Так может выглядеть ваш pom](https://github.com/lanwen/matchers-examples/blob/master/pom.xml).
#### Как это работает?
В библиотеке есть абстрактный класс ``TypeSafeMatcher, параметризуемый по типу проверяемого объекта. Класс предоставляет для переопределения три метода:
* public boolean matchesSafely(Fruit fruit) — логика проверки,
* `public void describeTo(Description description)` — описание ожидаемого значения,
* `protected void describeMismatchSafely(Fruit item, Description mismatchDescription)` — описание полученного значения.
Экземпляр класса, расширяющего этот, перед выполнением собственного кода выполнит родительский — рутинные проверки поступающего объекта на `null` и соответствие указанному классу.
Например, [матчер, проверяющий форму фрукта,](https://github.com/lanwen/matchers-examples/blob/master/src/test/java/ru/yandex/qatools/examples/matchers/ShapeMatcher.java) выглядит так:
```
public class ShapeMatcher extends TypeSafeMatcher {
private Shape expected;
public ShapeMatcher(Shape expected) {
this.expected = expected;
}
@Override
public boolean matchesSafely(Fruit fruit) {
return expected.equals(fruit.getShape());
}
@Override
protected void describeMismatchSafely(Fruit item, Description mismatchDescription) {
mismatchDescription.appendText("fruit has shape - ").appendValue(item.getShape());
}
@Override
public void describeTo(Description description) {
description.appendText("shape - ").appendValue(expected);
}
@Factory
public static ShapeMatcher round() {
return new ShapeMatcher(Shape.ROUND);
}
}
```
Количество кода сперва пугает. Но, если приглядеться, сразу заметно, что каждое логическое действие выделено в отдельный метод, а в тесте вызов умещается в одно слово — использовать очень просто!
#### Но и это не все
Частая ситуация, как, например, выше, вызвана необходимостью использовать для проверки только одно свойство объекта. Целый класс для этого — лишняя трата времени и сил. Здесь на помощь приходят анонимные классы Java и абстрактный класс `FeatureMatcher`, параметризуемый двумя типами: какой объект поступит на вход и свойство какого типа нужно проверить.
Конструктор у этого класса один и требует 3 атрибута:
* матчер, который применим к *WhatWeWannaCheck* типу,
* описание ожидания (оно добавится к описанию субматчера),
* описание полученного значения (оно добавится к мисматч-описанию субматчера)
Потомок этого класса, переопределив метод f`eatureValueOf` позволит вытащить нужное свойство из объекта и применить к нему существующий матчер. А их в поставке Hamcrest хватает для любых стандартных типов.
Перепишем наш матчер для формы, а заодно и [остальные](https://github.com/lanwen/matchers-examples/blob/master/src/test/java/ru/yandex/qatools/examples/matchers/OrangeMatchers.java), используя этот класс.
```
public class Matchers {
public static Matcher hasShape(final Shape shape) {
return new FeatureMatcher(equalTo(shape), "fruit has shape - ", "shape -") {
@Override
protected Shape featureValueOf(Fruit fruit) {
return fruit.getShape();
}
};
}
public static Matcher round() {
return hasShape(Shape.ROUND);
}
public static Matcher sweet() {
return new FeatureMatcher(is(true), "fruit should be sweet", "sweet -") {
@Override
protected Boolean featureValueOf(Fruit fruit) {
return fruit.isSweet();
}
};
}
public static Matcher hasColor(Color color) {
return new FeatureMatcher(equalTo(color), "fruit have color - ", "color -") {
@Override
protected String featureValueOf(Fruit fruit) {
return fruit.getColor();
}
};
}
}
```
#### Feel the POWER OF MATCHERS
Одно из главных преимуществ матчеров — возможность их объединения. Для этого в Hamcrest есть целый ряд специальных связующих: allOf, anyOf, both, either. Каждый из них заботливо соединит и описание ожидаемого значения, и описание проваленных матчеров из цепочки.
Благодаря этому, сценарий предпроверки для нашего «дегустатора» сокращается еще сильнее:
```
@Test
public void orangeBothSweetRoundAndOrangeColorWithMatchers() throws Exception {
assumeThat(someFruit, both(round()).and(sweet()).and(hasColor(Color.ORANGE)));
// дальше дегустаторская магия
}
```
[Исходники всех тестов](https://github.com/lanwen/matchers-examples/blob/master/src/test/java/ru/yandex/qatools/examples/FruitDegustationTest.java).
Еще одна из замечательных возможностей, которую даёт эта технология, — применение одного или ряда матчеров к коллекции. Предположим, вместо одного фрукта за раз стал поступать целый набор и все объекты в нём нужно проверить одновременно. Больше не нужно никаких циклов — все проще простого:
```
@Test
public void orangeBothSweetRoundAndOrangeColorWithMatchers() throws Exception {
assertThat(someFruitList, everyItem(both(round()).and(sweet()).and(hasColor(Color.ORANGE))));
}
```
Как говорим, так и пишем: проверить каждый элемент нашим матчером. Возможны вариации — например, проверять что в пачке есть хотя бы один объект, удовлетворяющий условию `hasItem()`.
[Примеры работы с коллекцией](https://github.com/lanwen/matchers-examples/blob/master/src/test/java/ru/yandex/qatools/examples/ProductionLineTest.java).
#### Еще раз о велосипедах
Матчеры появились уже давно, и за всё время существования их и их наборов было создано очень много. Так что прежде чем воодушевленно писать свой матчер, поищите в интернете — скорее всего, он уже кем-то написан. Если вы его не нашли, заходите в нашу библиотеку матчеров, — возможно, там он есть. Если нужного вам матчера нигде нет и вы решили его написать, присылайте нам его реализацию в виде пулл-реквеста. Давайте вместе помогать другим не тратить время на изобретение велосипеда.
Наша библиотека матчеров находится по адресу [github.com/yandex-qatools/matchers-java](https://github.com/yandex-qatools/matchers-java).`` | https://habr.com/ru/post/184634/ | null | ru | null |
# Шейдер для жука
[](//habrastorage.org/files/0e0/e1b/5ab/0e0e1b5ab1a04d969302e81ca7e2984e.png)
*снизу фотографии настоящих жуков, сверху — моя реализация*
Продолжение [предыдущей](http://habrahabr.ru/post/239557/) статьи, на этот раз пишем шейдер.
#### Иризация
Итак в чем же особенность панциря такого жука? Если смотреть на него под разными углами — он будет изменять свой цвет. Как компакт диск. Такой цвет удобнее всего представлять в цветовой модели [HSV](https://ru.wikipedia.org/wiki/HSV_(%D1%86%D0%B2%D0%B5%D1%82%D0%BE%D0%B2%D0%B0%D1%8F_%D0%BC%D0%BE%D0%B4%D0%B5%D0%BB%D1%8C)), а конкретно нас интересует параметр Hue или цветовой тон, который изменяется вот в таком диапазоне:
Если взять угол между вектором направления взгляда и нормалью к поверхности панциря, то получим число, которое можно использовать в качестве параметра Hue в вышеописанной модели. С дополнительной корректировкой по диапазону можно добиться нужного результата. Так же диапазон можно корректировать через текстуру, об этой карте смещений я писал в предыдущей статье. Примерный алгоритм:
1. Для текущего фрагмента определяем вектор направления взгляда eyeDir
2. Вычисляем скалярное произведение между вектором направления взгляда и нормалью к поверхности angle=dot(normal, eyeDir)
3. Дополнительный шаг для повышения реализма — возводим получившийся угол в квадрат angle=pow(angle, 2.0)
4. Используем угол для определения тона, выбираем цветовой диапазон hue=angle\*hueRange+hueAverage, где hueRange — диапазон, hueAverage — смещение
5. Дополнительно вычисляем смещение для текущего фрагмента из соответствующей текстуры: hue-=shift
6. Выбираем оставшиеся два параметра цветовой модели HSV и конвертируем ее в RGB: color=hsv2rgb(hue, saturation, value)
В итоге получаем чистый цвет, который в последствии можно дополнить отражением, затенением и прочими эффектами.
Часть шейдера с этим алгоритмом может выглядит так:
```
// код конвертации был взят отсюда: http://lolengine.net/blog/2013/07/27/rgb-to-hsv-in-glsl
vec3 hsv2rgb(float h, float s, float v) {
vec4 k = vec4(1.0, 2.0/3.0, 1.0/3.0, 3.0);
vec3 p = abs(fract(vec3(h)+k.xyz)*6.0-k.www);
return v*mix(k.xxx, clamp(p-k.xxx, 0.0, 1.0), s);
}
const float iridescenceOpacity = 0.6;
const float hsvSaturation = 0.7;
const float hsvValue = 0.8;
const float addIridescenceValue = 0.2;
void main() {
...
float hue = (1.0-pow(dot(normal, eyeDir), 2.0))*hueRange+hueAverage;
hue -= (1.0-dataTex.a)*addIridescenceValue;
vec3 diffuse = hsv2rgb(hue, hsvSaturation, hsvValue)*iridescenceOpacity;
...
}
```
На этом собственно и заканчивается часть с определением переливающейся части цвета. Остальная часть цвета вычисляется стандартно на основе карт ao, отражений и освещенности. Как видно алгоритм простой и его можно применять практически к любой поверхности и материалу.
Хотя есть один нюанс — у жука на фотографии отражение окружения на панцире размыто. У меня в шейдере для отражений используется cubemap, что бы отражение было размытым можно размыть кубмапу или уменьшить ее разрешение или как сделал я использовать низкий мип-уровень. Так как в GLSL 1.1 нельзя обращаться к конкретному мипу из вершинного шейдера, установить его придется через параметр GL\_TEXTURE\_BASE\_LEVEL функции glTexParameteri:
```
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_BASE_LEVEL, 6);
```
Я использовал шестой уровень мипа, но все зависит от изначального разрешения текстуры и требуемой степени размытия. Честно говоря это не очень хороший способ размытия, так как на гранях кубмапы образуются полосы в виде резкой границы перехода цвета, но так как на жуке ярко выраженная рельефная поверхность — этого не заметно.
Кстати как вариант, можно еще использовать сферические гармоники.
*резкая граница*
Еще вместо конвертирования цветовой модели, можно взять одномерную текстуру и делать выборку по ней, используя в качестве текстурной координаты вычисленный угол между наблюдателем и нормалью. Таким образом меняя текстурку можно менять цвет жука.
**Полный шейдер**Вершинный:
```
#version 110
uniform mat4 matrixProj; //матарица проекции
uniform mat4 matrixView; //матрица вида
attribute vec3 vertex;
attribute vec3 normal;
attribute vec3 tangent;
attribute vec2 texCoord;
varying vec2 vTexCoord;
varying mat3 vTbn; //матрица тангент битангент нормаль
varying float zPos; // z-координата
void main() {
vec4 pos = matrixProj*matrixView*vec4(vertex, 1.0);
gl_Position = pos;
vTexCoord = texCoord;
zPos = pos.z;
vec3 bitangent = cross(normal, tangent); // вычисляем битангент
vTbn = mat3(tangent, bitangent, normal); // ...и матрицу
}
```
Фрагментный:
```
#version 110
uniform sampler2D texture; //текстура о которой я писал в предыдущей статье
uniform samplerCube envMap; //карта окружения
uniform vec3 light; //позиция источника света
uniform float bright; //общая яркость
uniform float focalDistance; //фокусное расстояние для блура
uniform float focalRange; //область фокуса
uniform vec3 eyeDir; //направление взгляда
uniform float hueAverage; //смещение для цветового тона, фактически начальная величина
uniform float hueRange; //диапазон тона
varying vec2 vTexCoord;
varying mat3 vTbn;
varying float zPos;
const float shadowOpacity = 0.7; //прозрачность затенения
const float envBright = 1.0; //яркость карты окружения
const float envLighting = -0.6;//яркость отражения
const float iridescenceOpacity = 0.6;//влияние иризации на цвет
const float hsvSaturation = 0.7; //насыщенность цвета
const float hsvValue = 0.8;//значение цвета
const float addIridescenceValue = 0.2;//влияние карты смещений на тон
vec3 hsv2rgb(float h, float s, float v) {
vec4 k = vec4(1.0, 2.0/3.0, 1.0/3.0, 3.0);
vec3 p = abs(fract(vec3(h)+k.xyz)*6.0-k.www);
return v*mix(k.xxx, clamp(p-k.xxx, 0.0, 1.0), s);
}
void main() {
vec4 dataTex = texture2D(texture, vTexCoord);
vec3 normal = normalize(vTbn*(vec3(dataTex.rg, 1.0)*2.0-1.0));//вытаскиваем нормаль из текстуры
float lighting = clamp(dot(normal, light), 0.0, 1.0);//вычисляем освещенность
float hue = (1.0-pow(dot(normal, eyeDir), 2.0))*hueRange+hueAverage;//вычисляем цветовой тон
hue -= (1.0-dataTex.a)*addIridescenceValue;//делаем смещение на основе данных из текстуры
vec3 diffuse = hsv2rgb(hue, hsvSaturation, hsvValue)*iridescenceOpacity;//конвертируем в RGB
vec3 env = textureCube(envMap, reflect(-eyeDir, normal)).rgb;//вычисляем отражение
diffuse += env*bright*envBright+envLighting;//корректировка отражения и добавление к основному цвету
float shadow = lighting*dataTex.b*shadowOpacity+1.0-shadowOpacity;//вычисляем затенение на основе освещенности источником цвета и ао из текстуры
gl_FragColor.rgb = shadow*diffuse;//добавляем тени
gl_FragColor.a = clamp((focalDistance+zPos)/focalRange, -1.0, 1.0);//вычисляем и записываем значение размытия
}
```
#### Немного про GUI
Мне было интересно попробовать такой способ:
Берется вот такая текстура:
Она достаточно маленькая, хватит 16х16 пикселей. Любой прямоугольный элемент гуи имеет такую сетку:
У этой сетки текстурные координаты задаются таким образом, что используя текстурку выше получается вот такой черно-белый спрайт:
А теперь главное — каждый пиксель этого спрайта — это текстурная координата для одномерной текстуры, которая представляет из себя тему оформления элемента интерфейса. Чем то напоминает distance field. Например, для скриншота выше использовались такие полоски:
У каждой полоски по три строки пикселей — для фона, нажатой кнопки и отпущенной.
Все текстуры должны использоваться с билинейной интерполяцией. Таким образом используя две очень маленькие текстурки можно добиться почти векторного качества элементов интерфейса, на любых DPI. Правда оформление получается во все стороны симметричное, нельзя, например, сделать падающие тени.
**Пиксельный шейдер для рендера такого вида интерфейса**
```
#version 110
uniform sampler2D guiMap; //спрайт с гуи-элементом
uniform sampler2D themeMap; //тема оформления
uniform float themeNum;//строка (v-координата текстуры) в теме оформления
varying vec2 vTexCoord;
void main() {
float a = texture2D(guiMap, vTexCoord).r; //находим текстурную координату для темы
gl_FragColor = texture2D(themeMap, vec2(a, themeNum)); //берем цвет
}
```
#### Видео
Я добавил к [блуру](http://habrahabr.ru/post/239085/#first_unread) немного шума, чтобы эмитировать эффект film grain. Так же можно заметить недостаток такого эффекта размытия — небольшой ореол вокруг резких границ.
Скринкаст к сожалению получился без вертикальной синхронизации, несмотря на то, что она была включена.
**Проблема**Система Kubuntu 12.04, включена вертикальная синхронизация в стандартных настройках. Можно дополнительно включить синхронизацию через nvidia xserver settings. На мониторе у приложений никаких разрывов не наблюдаются, не наблюдаются и во время скринкаста, но если посмотреть полученную запись — видно что там есть разрывы. Видео записываю через avconv:
`avconv -f x11grab -s 1280x720 -i :0.0+2240,185 -c:v libx264 -r 30 -vsync 2 -b 4000k -threads 8 -y 1.mp4`
с параметром vsync игрался по всякому. Какие бы я настройки не выставлял, но при высокой нагрузке, даже при включенной синхронизации во всех настройках — появляются разрывы. Есть подозрение, что косяк в дровах от нвидии. Если кто-то с этим сталкивался и нашел решение проблемы — сообщите, пожалуйста. Прошу прощения за некачественное видео.
#### Исходники
Писал на C++ с использованием Qt версии 4.7.\* или 4.8.\*, тестировал на Kubuntu 12.04 и 14.04, Mac 10.8, видеокартах intel hd 4000, GeForce gtx560, Radeon HD 6750M.
Исходники: [github.com/Torvald3d/Beetle](https://github.com/Torvald3d/Beetle)
Модель жука (obj): [github.com/Torvald3d/Beetle/tree/master/obj](https://github.com/Torvald3d/Beetle/tree/master/obj)
Лицензия Creative Commons, однако в проекте есть HDR карты с [этого](http://www.doschdesign.com/products/hdri) сайта со всеми вытекающими последствиями, а так же код шейдера fxaa.frag, который был взят [отсюда](https://github.com/mitsuhiko/webgl-meincraft/blob/master/assets/shaders/fxaa.glsl).
#### Ссылки
* [lolengine.net/blog/2013/07/27/rgb-to-hsv-in-glsl](http://lolengine.net/blog/2013/07/27/rgb-to-hsv-in-glsl) — конвертация цвета HSV модели в RGB
* [mew.cx/glsl\_quickref.pdf](http://mew.cx/glsl_quickref.pdf) — GLSL 1.1 Quick Reference Guide | https://habr.com/ru/post/239661/ | null | ru | null |
# Android in-app purchases, часть 5: серверная валидация покупок
Всем привет, я Кирилл, СТО [Adapty](https://adapty.io/?utm_source=habr.com&utm_medium=referral&utm_campaign=blogpost_android-iap_server-validation). Я делал систему серверной валидации для наших SDK и сегодня расскажу про то, как её настроить для приложений на Android.
Это пятая статья из серии о внедрении внутренних покупок на Android, советую познакомиться с остальными:
1. [Android in-app purchases, часть 1: конфигурация и добавление в проект.](https://habr.com/ru/company/adapty/blog/568902/)
2. [Android in-app purchases, часть 2: инициализация и обработка покупок.](https://habr.com/ru/company/adapty/blog/571122/)
3. [Android in-app purchases, часть 3: получение активных покупок и смена подписки.](https://habr.com/ru/company/adapty/blog/573058/)
4. [Android in-app purchases, часть 4: коды ошибок от Billing Library и как не облажаться с тестированием.](https://habr.com/ru/company/adapty/blog/575866/)
5. Android in-app purchases, часть 5: серверная валидация покупок. — Вы тут.
### Что такое серверная валидация покупки?
Серверная валидация позволяет проверить подлинность покупки: устройство обращается к серверам Google за информацией, действительно ли была совершена покупка, и валидна ли она.
### Зачем валидировать покупки
Серверная валидация необязательна, покупки будут работать без неё. Но с ней лучше, потому что она даёт важные преимущества:
1. **Продвинутая аналитика платежей.** Это особенно актуально для подписок. После того, как подписка активирована, списания происходят без участия устройства. Если пользователь не заходит в приложение, без серверной обработки мы не сможем своевременно получать информацию о статусе подписки: продлил, отменил, возникла проблема с платежом.
2. **Проверка подлинности покупки**. Серверная валидация позволяет убедиться, что транзакция действительно произошла, и покупка была не фродовой. Поскольку на Android процент мошеннических операций выше, чем на iOS, то в приложениях на Google Play об этом особенно важно позаботиться.
3. **Кроссплатформенные подписки**, имея данные по статусу подписки в живом режиме, можно синхронизировать подписки пользователя с другими платформами. Так, если пользователь подписался на приложение на Android, доступ к нему у него будет на iOS, Web и других платформах.
4. **Возможность контролировать доступ к контенту со стороны сервера.** Серверная валидация не даст доступ к контенту тем пользователям, которые хотят получить его, отправляя запросы к серверу.
Вообще уже один первый пункт стоит того, чтобы настроить серверную валидацию.
### Валидация платежей
В целом процесс валидации платежей на Android можно описать схемой:
Серверная валидация покупок в приложениях на Android#### Аутентификация запросов к Google Play Developer API
Для того, чтобы работать с Google Play Developer API, необходимо создать ключ, с помощью которого будут подписываться все запросы. Сначала надо связать аккаунт Google Play Console (место, где вы управляете приложением) с аккаунтом в Google Cloud (там будет создавать ключ для подписи запросов). После того, как всё настроено, необходимо дать права пользователю на менеджмент покупок. Чтобы подробно описать весь этот процесс, понадобится отдельная статья. К счастью, мы уже сделали пошаговую инструкцию в [документации Adapty](https://docs.adapty.io/docs/service-account-key-file), а к выходу этой статьи я обновил скриншоты, потому что интерфейс периодически меняется.
Обратите внимание, что обычно после создания ключа необходимо ждать сутки или больше, прежде чем он заработает. Чтобы этого не делать, можно обновить описание у любого in-app продукта или подписки, тогда ключ сразу будет активным.
Мы используем официальную библиотеку [google-api-python-client](https://github.com/googleapis/google-api-python-client) для работы с Google Play Developer API. Данная библиотека доступна для большинства популярных языков, и я рекомендую использовать её, потому что в ней поддерживаются все нужные методы.
#### Валидация транзакций о подписке
В отличии от [серверной валидации iOS](https://habr.com/ru/company/adapty/blog/572370/), в Android валидация подписок и остальных продуктов делается с помощью разных методов. Поэтому в момент валидации вам необходимо понимать, работаете ли вы с подпиской или продуктом. На практике это означает, что вам надо передавать эту информацию со стороны мобильного приложения, а также хранить флаг в базе данных, если возникнет необходимость повторной проверки токена.
Второе большое отличие — в Android у каждой транзакции есть свой токен, в то время как на iOS все транзакции хранятся в одном токене (shared secret). Это означает, что для восстановления покупок пользователя необходимо хранить все токены покупок, а не только один для любой из них.
Для валидации подписки необходимо вызвать метод [*purchases.subscriptions.get*](https://developers.google.com/android-publisher/api-ref/rest/v3/purchases.subscriptions/get). По факту это вызов GET-запроса `https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/purchases/subscriptions/{subscriptionId}/tokens/{token}`.
Все параметры обязательны:
* `packageName` — идентификатор приложения, например, com.adapty.sample\_app.
* `subscriptionId` — идентификатор подписки, которую нужно провалидировать, например, com.adapty.sample\_app.weekly\_sub.
* `token` — уникальный токен транзакции, который появляется после покупки на стороне мобильного приложения.
Для начала разберём ошибки, которые необходимо отслеживать, чтобы всё корректно работало:
* **400, Invalid grant: account not found** — ошибка означает, что неправильно создан ключ для аутентификации запросов. Убедитесь, что используется верный аккаунт, учётные записи связаны, есть достаточные права, а также активированы необходимые API. О том, как всё правильно настроить, написано в предыдущей секции. Также обратите внимание на подсказку про обновление описания продукта.
* **400, The purchase token does not match the package name** — эта ошибка чаще всего встречается во фродовых транзакциях. Если вы видите её в процессе тестирования, убедитесь, что вы не отправляете токен от покупки в одном приложении в другое.
* **403, Quota exceeded for quota metric 'Queries' and limit 'Queries per day' of service 'androidpublisher.googleapis.com'** — превышена квота на количество запросов к API Google в сутки. По умолчанию можно отправлять [не более 200000](https://developers.google.com/android-publisher/quotas) запросов в сутки. Эту квоту можно увеличить, но для большинства приложений её должно быть достаточно. Возможно, если вы упёрлись в неё, то стоит убедиться в правильности логики работы.
* **410, The subscription purchase is no longer available for query because it has been expired for too long** — ошибка возвращается для транзакций, где подписка истекла более 60 дней назад. По сути это не ошибка, так что не стоит её обрабатывать как ошибку.
#### Подписочная транзакция
В случае успешной валидации в ответ приходит [информация о транзакции](https://developers.google.com/android-publisher/api-ref/rest/v3/purchases.subscriptions#SubscriptionPurchase).
Информация о транзакции (подписка)
```
{
"expiryTimeMillis": "1631116261362",
"paymentState": 1,
"acknowledgementState": 1,
"kind": "androidpublisher#subscriptionPurchase",
"orderId": "GPA.3382-9215-9042-70164",
"startTimeMillis": "1630504367892",
"autoRenewing": true,
"priceCurrencyCode": "USD",
"priceAmountMicros": "1990000",
"countryCode": "US",
"developerPayload": ""
}
```
Чтобы понимать, есть ли у пользователя доступ к платным функциям приложения, то есть имеется ли у него активная подписка, необходимо:
1. Проверить параметры `startTimeMillis` и `expiryTimeMillis`, текущее время должно быть между ними.
2. Кроме того, необходимо убедиться, что параметр `paymentState` не равен `1`. Это означает, что подписка ожидает оплаты и в настоящий момент не нужно давать доступ к платным функциям приложения.
3. Если в транзакции присутствует поле `autoResumeTimeMillis`, то подписка на паузе, то есть доступ к платным функциям приложения не нужно предоставлять раньше этой даты.
Давайте разберём важные свойства подписочной транзакции:
* `kind` — тип транзакции, у подписок он всегда `androidpublisher#subscriptionPurchase`. С помощью этого параметра можно определять, подписка перед вами или продукт, и в зависимости от этого выбирать логику обработки.
* `paymentState`— статус платежа, не приходит для истёкших транзакций. Возможные значения:
+ `0` — по данной транзакции ещё не прошла оплата. В некоторых странах подписку можно оплатить в магазине, то есть сначала пользователь оформляет её на устройстве, потом идёт в терминал и оплачивает там. В целом, это редкий кейс, но стоит иметь в виду.
+ `1` — подписка оплачена*.*
+ `2` — подписка находится в триальном периоде.
+ `3` — в следующем периоде произойдёт апгрейд или даунгрейд текущей подписки, то есть смена тарифного плана.
* `acknowledgementState` — статус подтверждения покупки. Это важный параметр, который служит для подтверждения, получил ли пользователь доступ к тому, за что он платил. Значение `0` означает, что не получил, `1` — получил. Разработчик сам отвечает за простановку этого статуса, это можно сделать как на стороне мобильного приложения, так и на стороне сервера. Если не подтвердить статус покупки, то через 3 дня автоматически произойдёт рефанд. Рекомендую реализовать логику, что, если в транзакции пришёл `acknowledgementState=0`, то сервер его изменяет. О том, как это сделать, расскажу ниже.
* `orderId` — уникальный идентификатор транзакции. У каждой покупки/продления будет свой идентификатор, его можно использовать, чтобы понимать, была ли ранее обработана данная транзакция. У каждого продления основная часть идентификатора остаётся неизменной, просто в конце добавляется две точки и номер продления, начиная с 0. Если при активации подписки у неё был идентификатор `GPA.3382-9215-9042-70164,` то у первого продления будет `GPA.3382-9215-9042-70164..0`, у второго — `GPA.3382-9215-9042-70164..1` и тд. Таким образом можно выстраивать цепочки транзакций и отслеживать количество продлений.
* `startTimeMillis` — дата начала подписки.
* `expiryTimeMillis` — дата окончания подписки.
* `autoRenewing` — флаг, показывающий, будет ли продлена подписка на следующий период.
* `priceCurrencyCode` — валюта покупки в 3-х символьном формате, например RUB.
* `priceAmountMicros` — цена покупки. Для того, чтобы получить нормальное числовое значение цены, надо поделить данное значение на 1000000. То есть 1990000 — это 1.99.
* `countryCode` — страна аккаунта, с которого совершена покупка, в 2-х символьном формате, например, RU.
* `purchaseType` — тип покупки. В большинстве случаев этого ключа нет. Но при этом его важно учитывать, потому что с помощью него можно понимать, что покупка была совершена в Sandbox окружении. Возможные значения:
+ `0` — покупка из Sandbox окружения, то есть её не нужно учитывать в аналитике.
+ `1` — покупка оплачена промокодом.
* `autoResumeTimeMillis` — дата, когда подписка возобновится. Приходит только для подписок, которые были поставлены на паузу. Если этот параметр есть, то доступ к платным функциям приложения не нужно предоставлять раньше указанной даты.
* `cancelReason` — причина, по которой подписка не будет продлеваться на следующий период. Возможные значения:
+ `0` *— пользователь сам отменил автопродление.*
+ `1` *— подписка отменена системой, чаще всего это связано с billing issue, то есть с пользователя не смогли снять деньги.*
+ `2` — пользователь перешёл на другую подписку.
+ `3` — разработчик отменил подписку.
* `userCancellationTimeMillis` — дата, когда пользователь отменил продление подписки. Приходит только если `cancelReason=0`*.* Подписка может быть всё ещё активна, это надо смотреть по параметру `expiryTimeMillis`*.*
* `cancelSurveyResult` *—* [*объект*](https://developers.google.com/android-publisher/api-ref/rest/v3/purchases.subscriptions#SubscriptionCancelSurveyResult)*, в котором хранится информация о причине отмены подписки пользователем, если он ответил на данный вопрос.*
* `introductoryPriceInfo` — [объект](https://developers.google.com/android-publisher/api-ref/rest/v3/purchases.subscriptions#IntroductoryPriceInfo), в котором хранится информации о цене для вводного периода (специальное предложение, например 1 месяц со скидкой 50%).
* `promotionType` — тип промокода, который был использован при активации подписки. Возможные значения:
+ `0` *— одноразовый промокод.*
+ `1` *— кастомный промокод, который может быть использован несколькими пользователями. Такие коды можно использовать для рекламы у блогеров.*
* `promotionCode` — кастомный промокод, который был использован при активации подписки. Данный параметр не приходит для одноразовых промокодов.
* `priceChange` — [объект](https://developers.google.com/android-publisher/api-ref/rest/v3/purchases.subscriptions#SubscriptionPriceChange), в котором хранится информация о будущем изменении цены, а также статус того, одобрил ли пользователь это изменение или нет.
#### Подтверждение подписки (acknowledge subscription)
Как говорилось выше, ***если не подтвердить подписку, то через 3 дня она будет автоматически отменена, и пользователю вернутся деньги***. Если честно, я не понимаю, зачем нужна такая логика, ни в каких других системах оплаты, в том числе iOS, я её не встречал. Тем не менее, если в транзакции пришёл `acknowledgementState=0`, необходимо подтвердить подписку.
Чтобы подтвердить подписку, нужно вызвать метод [*purchases.subscriptions.acknowledge*](https://developers.google.com/android-publisher/api-ref/rest/v3/purchases.subscriptions/acknowledge). Данный метод делает POST-запрос `https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/purchases/subscriptions/{subscriptionId}/tokens/{token}:acknowledge`. Параметры точно такие же, как при валидации запроса. В случае успешного выполнения запроса подписка будет подтверждена, а значит, вы не потеряете деньги.
> Если подписка ещё не оплачена, то её не надо подтверждать.
>
>
#### Отмена возобновления, отзыв, рефанд и продление подписки
Кроме валидации и подтверждения подписки, с помощью Google Play Developer API можно делать ещё несколько операций с подписками. Стоит отметить, что все они довольно редкие, и за исключением продления, все поддерживаются в Google Play Console. Но всё же перечислю их, чтобы было общее представление о возможностях API. Во всех запросах такие же обязательные параметры, как и в ранее рассмотренных методах: `packageName`, `subscriptionId` и `token`.
* Отмена возобновления. Метод [*purchases.subscriptions.cancel*](https://developers.google.com/android-publisher/api-ref/rest/v3/purchases.subscriptions/cancel). Отменяет продление для выбранной подписки, при этом подписка будет активна до окончания текущего периода.
* Рефанд (возврат денег) подписки. Метод [*purchases.subscriptions.refund*](https://developers.google.com/android-publisher/api-ref/rest/v3/purchases.subscriptions/refund). Возвращает пользователю деньги за подписку. При этом доступ к подписке остаётся, и в следующем периоде она автоматически продлится. В большинстве случаев вместе с рефандом надо использовать отзыв подписки.
* Отзыв подписки. Метод [*purchases.subscriptions.revoke*](https://developers.google.com/android-publisher/api-ref/rest/v3/purchases.subscriptions/revoke). Моментально прекращает действие подписки, то есть у пользователя сразу же пропадает доступ к платным функциям приложения. Подписка не будет продлеваться в дальнейшем. Обычно используется вместе с рефандом.
* Продление подписки. Метод [*purchases.subscriptions.defer*](https://developers.google.com/android-publisher/api-ref/rest/v3/purchases.subscriptions/defer). Продлевает действие подписки до указанной даты. В запросе необходимо передать текущую дату истечения подписки и желаемую, которая обязательно больше текущей.
#### Валидация продуктов (не подписок)
Валидация продуктов похожа на валидацию подписок. Необходимо вызвать метод [*purchases.products.get*](https://developers.google.com/android-publisher/api-ref/rest/v3/purchases.products/get), который выполнит GET-запрос `https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/purchases/products/{productId}/tokens/{token}`. Все параметры уже нам знакомы из рассмотренных ранее примеров.
Информация о транзакции (продукт)
```
{
"purchaseTimeMillis": "1630529397125",
"purchaseState": 0,
"consumptionState": 0,
"developerPayload": "",
"orderId": "GPA.3374-2691-3583-90384",
"acknowledgementState": 1,
"kind": "androidpublisher#productPurchase",
"regionCode": "RU"
}
```
[Транзакция продукта](https://developers.google.com/android-publisher/api-ref/rest/v3/purchases.products) содержит заметно меньше значений, чем транзакция подписки. Рассмотрим важные свойства:
* `kind` — тип транзакции, у продуктов он всегда *androidpublisher#productPurchase*. С помощью этого параметра можно определять, подписка перед вами или продукт, и в зависимости от этого выбирать логику обработки.
* `purchaseState`— статус платежа. Обратите внимание, что значения ключей тут отличаются от параметра *paymentState* в подписке. Возможные значения:
+ `0` — покупка оплачена.
+ `1` — покупка отменена, то есть она ожидала оплаты, но в итоге пользователь её не оплатил.
+ `2` — покупка ожидает оплаты. В некоторых странах покупку можно оплатить в магазине, то есть сначала пользователь делает покупку на устройстве, потом идёт в терминал и оплачивает там. В целом, это редкий кейс, но стоит иметь в виду.
* `acknowledgementState` — статус подтверждения покупки. Как и в транзакциях подписки, этот параметр нужен для подтверждения, получил ли пользователь доступ оплаченным функциям/коненту. Значение `0` означает, что не получил, `1` — получил. За простановку этого статуса отвечает разработчик, сделать это можно и на стороне мобильного приложения, и на стороне сервера. Если не подтвердить статус покупки, то через 3 дня автоматически произойдёт рефанд. Рекомендую реализовать логику, что если в транзакции пришёл `acknowledgementState=0`, то сервер его изменяет. Ниже расскажу, как это делается.
* `consumptionState` — статус потребления продукта. Это то, что в iOS называется consumable. Задаётся со стороны мобильного приложения Значение `0` означает, что продукт не употреблён, а `1` — употреблён. Если вы продаёте доступ к приложению навсегда или доступ к определённой функциональности приложения навсегда, то такой продукт не нужно употреблять, то есть статус должен быть `0`. Если же вы продаёте монетки, и пользователь может покупать их много раз, то такие продукт нужно употреблять, то есть статус должен быть `1`. `consumptionState=0` означает, что продукт можно купить только один раз, а `consumptionState=1` — много раз.
* `orderId` — уникальный идентификатор транзакции. У каждой покупки будет свой идентификатор, его можно использовать, чтобы понимать, была ли ранее обработана данная транзакция.
* `purchaseTimeMillis` — дата покупки.
* `regionCode` — страна аккаунта, с которого совершена покупка в двухсимвольном формате, например, RU. Обратите внимание, что название этого параметра отличается от подписки, там он называется *countryCode*.
* `purchaseType` — тип покупки. В большинстве случаев этого ключа нет. Но при этом его важно учитывать, потому что с помощью него можно понимать, что покупка была совершена в Sandbox окружении. Возможные значения:
+ `0` — покупка из Sandbox окружения, то есть её не нужно учитывать в аналитике.
+ `1` — покупка оплачена промокодом.
+ `2` — покупка выдана за целевое действие, например, пользователь смотрел рекламу вместо оплаты.
Как видите, в целом валидация продукта похожа на валидацию подписки, но есть странные моменты:
* Не возвращается цена, хотя это очень удобно для аналитики.
* В параметре `purchaseState` значения сильно отличаются от значений `paymentState` в подписке, если это не учитывать, то будут ошибки.
* Возвращается `regionCode`, хотя в подписке он называется `countryCode`*.*
Покупку продуктов надо подтверждать, так же как и покупку подписки. Для этого необходимо вызвать метод [*purchases.products.acknowledge*](https://developers.google.com/android-publisher/api-ref/rest/v3/purchases.products/acknowledge), который сделает POST-запрос `https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/purchases/products/{productId}/tokens/{token}:acknowledge`.
> Если покупка ещё не оплачена, то её не надо подтверждать.
>
>
#### Отслеживание рефандов (возвратов денег) подписок и продуктов
Для качественной аналитики вам необходимо учитывать рефанды. К сожалению, информация о рефанде не приходит внутри транзакции или отдельным событием, как это работает в iOS. Для получения списка транзакций, по которым вернули деньги, надо с определённой периодичностью (например, раз в сутки) вызывать метод [*purchases.voidedpurchases.list*](https://developers.google.com/android-publisher/api-ref/rest/v3/purchases.voidedpurchases/list), который выполняет GET-запрос `https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/purchases/voidedpurchases`. В ответ вернётся список всех [транзакций](https://developers.google.com/android-publisher/api-ref/rest/v3/purchases.voidedpurchases), по которым произошёл возврат денег. Рекомендую использовать для поиска транзакций в базе параметр `orderId`, а не `purchaseToken`. Во-первых, так будет быстрее, а во-вторых, у всех продлений подписки будет один и тот же токен, и вам надо находить последний из них.
### Серверные уведомления о транзакциях
[Серверные уведомления](https://developer.android.com/google/play/billing/rtdn-reference) (Real-time developer notifications) позволяют получать информацию о событии, которое произошло на стороне Google, на вашем сервере практически моментально. После их настройки вы будете получать информацию о новых покупках, продлениях, проблемах с платежами и так далее. Это позволяет собирать более точную аналитику, а также упрощает менеджмент состояния подписчика.
Для того, чтобы получать серверные уведомления, необходимо в Google Cloud Pub/Sub создать топик, который будет отправлять уведомления по желаемому адресу. После этого данный топик необходимо указать в разделе Monetization setup в Google Play Console. Подробнее об этом со скриншотами вы можете прочитать в [документации Adapty](https://docs.adapty.io/docs/real-time-developer-notifications-rtdn).
Серверное уведомление
```
{
"message": {
"data": "eyJ2ZXJzaW9uIjoiMS4wIiwicGFja2FnZU5hbWUiOiJjb20uYWRhcHR5LnNhbXBsZV9hcHAiLCJldmVudFRpbWVNaWxsaXMiOiIxNjMwNTI5Mzk3MTI1Iiwic3Vic2NyaXB0aW9uTm90aWZpY2F0aW9uIjp7InZlcnNpb24iOiIxLjAiLCJub3RpZmljYXRpb25UeXBlIjo2LCJwdXJjaGFzZVRva2VuIjoiY2o3anAuQU8tSjFPelIxMjMiLCJzdWJzY3JpcHRpb25JZCI6ImNvbS5hZGFwdHkuc2FtcGxlX2FwcC53ZWVrbHlfc3ViIn19",
"messageId": "2829603729517390",
"message_id": "2829603729517390",
"publishTime": "2021-09-01T20:49:59.124Z",
"publish_time": "2021-08-04T20:49:59.124Z"
},
"subscription": "projects/935083/subscriptions/adapty-rtdn"
}
```
Нас в первую очередь интересует ключ `data`, в котором лежит информация о транзакции, закодированная с помощью base64. Ключ `messageId` можно использовать для дедупликации сообщений, чтобы не обрабатывать повторно пришедшие сообщения.
Транзакция в серверном уведомлении
```
{
"version": "1.0",
"packageName": "com.adapty.sample_app",
"eventTimeMillis": "1630529397125",
"subscriptionNotification": {
"version": "1.0",
"notificationType": 6,
"purchaseToken": "cj7jp.AO-J1OzR123",
"subscriptionId": "com.adapty.sample_app.weekly_sub"
}
}
```
С помощью ключа `packageName` можно понять, к какому приложению относится событие. Ключ `subscriptionId` говорит, о какой подписке идёт речь, а с помощью `purchaseToken` мы можем найти конкретную транзакцию. В случае с подписками надо всегда искать последнюю транзакцию в цепочке продления, событие относится именно к ней. В ключе `notificationType` указан [тип события](https://developer.android.com/google/play/billing/rtdn-reference#sub). На мой взгляд, самые полезные для подписок:
* `2: SUBSCRIPTION_RENEWED` — подписка успешно продлилась.
* `3: SUBSCRIPTION_CANCELED` — пользователь выключил автопродление подписки. Если автопродление выключили, надо пытаться вернуть пользователя в число активных подписчиков.
* `5: SUBSCRIPTION_ON_HOLD`,`6: SUBSCRIPTION_IN_GRACE_PERIOD` — подписку не получилось продлить из-за проблем с оплатой. Стоит сообщить пользователю об этом, чтобы у него не отменилась подписка автоматически.
* `12: SUBSCRIPTION_REVOKED` — подписка отозвана. Нужно закрыть пользователю доступ к функциям, которые давала эта покупка.
Для продуктов (не подписок) вместо ключа `subscriptionNotification` будет приходить `oneTimeProductNotification`, и в нём вместо ключа `subscriptionId` будет `sku`. Также для продуктов приходит всего 2 [типа события](https://developer.android.com/google/play/billing/rtdn-reference#one-time):
* `1: ONE_TIME_PRODUCT_PURCHASED` — успешная покупка продукта.
* `2: ONE_TIME_PRODUCT_CANCELED` — покупка продукта отменилась, потому что пользователь не оплатил его.
### Заключение
Серверная валидация сильно снижает возможность несанкционированного доступа к платному контенту вашего приложения и улучшает качество аналитики. При настройке серверной валидации придётся учитывать много сайд-кейсов: upgrade подписки, смена подписки, триал, introductory price, возвраты. Кроме того, есть ещё нюансы, вроде того, что Google снижает комиссию с 30% до 15% для подписок, которые продлеваются больше года. Так что весь процесс долгий и трудоёмкий.
Если хотите сэкономить ресурсы своей команды разработчиков, то советую присмотреться к Adapty.
Про Adapty
----------
Adapty не только упрощает техническую реализацию подписок:
* Встроенная аналитика позволяет быстро понять основные метрики приложения.
* Когортный анализ отвечает на вопрос, [как быстро сходится экономика](https://habr.com/ru/company/adapty/blog/564748/).
* [А/Б тесты](https://adapty.io/paywalls-ab-testing) увеличивают выручку приложения.
* Интеграции с внешними системами позволяют отправлять транзакции в сервисы атрибуции и продуктовой аналитики.
* [Промо кампании](https://adapty.io/return-subscribers?utm_source=habr.com&utm_medium=referral&utm_campaign=blogpost_android-iap_server-validation) уменьшают отток аудитории.
* Open source SDK позволяет интегрировать подписки в приложение за несколько часов.
* Серверная валидация и API для работы с другими платформами.
[Познакомьтесь подробнее с этими возможностями](https://adapty.io?utm_source=habr.com&utm_medium=referral&utm_campaign=blogpost_android-iap_server-validation), чтобы быстрее внедрить подписки в своё приложение и улучшить конверсии. | https://habr.com/ru/post/576164/ | null | ru | null |
# Трансдьюсеры в JS – так ли уж необходимы?
Функциональный подход потихоньку-полегоньку проник почти во все современные языки программирования. Тогда как одни элементы оттуда, вроде монад («всего лишь моноид в категории эндофункторов, в чем проблема?») – очень спорные для мэйнстрима, другие – вроде преобразований map, reduce, filter – стали стандартом де-факто.
При всех своих плюсах святая троица map/filter/reduce – в JS не очень экономно работает с памятью. Грандиозный архитектурный костыль – [трансдьюсеры](https://habrahabr.ru/company/infopulse/blog/347968/) – успешно запортирован с Clojure на JS, и поражает неофитов своей непонятностью, при этом вроде как решает проблему с излишним выделением памяти.
При чтении документации на [Transducers.js](https://github.com/cognitect-labs/transducers-js) (протокол для трансдьюсеров) меня не оставляло стойкое чувство дежавю – где-то что-то похожее я видел. Ага – [итераторы и генераторы на MDN](https://developer.mozilla.org/ru/docs/Web/JavaScript/Guide/Iterators_and_Generators)! Все вменяемые браузеры и серверные рантаймы уже их умеют (гусары, молчать про Ишака!).
Не так давно я экспериментировал с этими вещами, чтобы построить нечто, что может потоково обрабатывать данные в JS – без создания промежуточных массивов.
Итак – поехали.
Чтобы было стильно, модно, молодежно – спионерим из интернетов две функции:
```
const compose = (...fns) => x => fns.reduceRight((c, f) => f(c), x)
```
Пространные комментарии излишни – классическая композиция функций: compose(f, g, k) это f(g(k(x))). Ух, вроде со скобками не слажал.
И вторая (тут у нас про функциональщину, помним?):
```
const curry = (fn, a = []) => (...args) =>
a.length + args.length >= fn.length
? fn(...a, ...args)
: curry(fn, [...a, ...args]);
```
Превращает функцию с кучкой аргументов в функцию одного аргумента. Для условного f(a, b) вызов curry(f) вернет функцию g – обертку для f, которую можно вызвать как g(a, b), так и g(a)(b). Главное, чтобы оборачиваемая функция имела стабильное количество аргументов (никаких аргументов со значениями по умолчанию).
Теперь переизобретем функцию map, используя генераторы.
```
function *_gmap(f, a) {
for (let i of a) yield f(i);
}
const gmap = curry(_gmap);
```
Код элементарный, проходимся по входу **a** функцией **f(a)** и ответ выкладываем наружу. Можно вызвать как **gmap(f, a)**, так и **gmap(f)(a)**. Что это дает – можно сохранить частично примененный **gmap(f)** в переменную, а когда понадобится – переиспользовать.
Теперь фильтрация:
```
function *_gfilter(p, a) {
for (let i of a)
if (p(i)) yield i;
}
const gfilter = curry(_gfilter);
```
Тоже можно вызвать как сразу – **gfilter(f, a)**, так и в лучших традициях функциональщины – **gfilter(f)(a)**.
Чтоб было проще, еще пара примитивных функций (лиспом навеяло):
```
function *ghead(a) {
for (let i of a) {
yield i;
break;
}
}
function *gtail(a) {
let flag = false;
for (let i of a) {
if (flag) {
yield i;
} else {
flag = true;
}
}
}
```
**ghead(a)** возвращает первый элемент от входа, **gtail(a)** – всё, кроме первого.
Ну и небольшой пример, как это всё может быть использовано:
```
let values = [3, 4, 5, 6, 7, 8, 9];
const square = x => x * x;
const squareNfirst = compose(ghead, gmap(square));
let x = [...squareNfirst(values)];
```
В переменную **x** попадет массив из одного элемента.
```
const moreThan5 = gfilter(x => x > 5);
let xxx = [...moreThan5(values)];
```
Общая идея такая – на вход gmap и gfilter можно скормить как массив, так и нечто, реализующее iterable protocol – а на выходе тоже будет итератор, который в ES6 можно развернуть в обычный массив через три точки ( **let x = […squareNfirst(values)]** ).
А что же reduce, можете спросить? Универсального подхода тут не будет, или использовать классический [].reduce(f, init), или вот так:
```
function _greduce(f, i, a) {
let c = i;
for(let v of a) c = f(c, v);
return c;
}
const greduce = curry(_greduce);
```
**greduce(f, i, a)** свернет входящий массив или итератор в одно значение.
Пример:
```
const mixFn = compose(greduce((c, v) => c + v, 0), square, moreThan5);
let yyy = mixFn(values);
```
Функция-композит последовательно отсечет из входа числа больше 5, потом полученные элементы возведет в квадрат, и напоследок просуммирует с помощью reduce.
### Зачем вся эта возня?
Главный профит от того, что обработка на итераторах – в маленьком потреблении памяти. При цепочке преобразований у нас протаскивается один элемент ровно. Плюс если в цепочке преобразований встречаются функции типа ghead(a) – у нас появляется «ленивость», т.е. то, что ghead() не возьмет – даже не будет обсчитываться.
Ну и плюс функциональненько, это сейчас модно :)
Надеюсь, что подобный подход поможет вам сэкономить немножко памяти при обработке много-десятко-мегабайтных массивов. Иначе не стоит и велосипедить. | https://habr.com/ru/post/348170/ | null | ru | null |
# Почему циклы должны умереть
Всем привет,
Прочитав недавнее обсуждение по поводу PHP, обнаружилось, что много людей боятся рекурсии как огня. Таковой миф нужно разоблачить!
Сегодня мы обоснуем, почему циклы это плохо, и почему их надо замочеть. В процессе мы будем пейсать на православном языке Хаскель, который очень непонятен. Вас предупредили!
Итак, что же такое цикл «for»?
* это «оператор» (а точнее, инструкция, statement), которая позволяет изменить поток управления программы
* это синтаксическая абстракция
* это замаскированный goto, которые суть зло (Дейкстра доказал уже в своем труде «Goto considered harmful», ЕМНИП)
* это еще один способ «повторить себя»
А что тут плохого, спросит фтыкатель? Перечислим те штуки, которые с циклом делать нельзя:
* передавать в функции в качестве аргументов и возвращать из других функций
* строить с помощью них другие циклы
Цикл не помогает вводить новые понятия в программу, потому что цикл сам по себе никакого смысла не имеет (ну напишешь ты `for (int i = 0; i < 10; i++);` и чего?), а только помогает немного сберечь пальцы (ведь он разворачивается в инструкции, вовлекающие goto).
Цикл также смешивает по сути разные операции (фильтрация, отображение, свертка, и наверное, много чего еще), выражая их неявно, из-за чего получаем вкусный спагетти-код. Было бы круто записать указанные операции явно, чтобы получить возможность свободно комбинировать их, не повторяя себя лишний раз.
Какова же альтернатива? Ну конечно же божественная рекурсия! Она, во-первых, проще, а во-вторых, помогает вводить те самые понятия.
Начнем с простого. У нас есть список (пусть даже массив), и мы хотим посчитать сумму его элементов.
Посмотрим на обычное решение этой проблемы ©:
```
int sum(int *a, size_t length) {
int x = 0;
size_t i = 0;
for (; i < length; i++) {
x += a[i];
}
return x;
}
```
А теперь — примерно оно же, но в Хаскеле:
```
-- надо заметить, что эта функция уже определена в "стандартной библиотеке"
sum = foldr (+) 0
```
Функция foldr определяется как рекурсивный процесс:
```
foldr f z [] = z
foldr f z (x:xs) = f x (foldr f z xs)
```
Разница заметна невооруженным взглядом. Код на Хаскеле проще, понятней, и, как ни странно, может использоваться для того, чтобы получить новые функции, в которых будут учитываться дополнительные условия!
Например, мы внезапно решили сложить только четные числа нашего списка.
C, обычное решение — копипастим старую функцию, добавляем условие:
```
int sumEven(int *a, size_t length) {
int x = 0;
size_t i = 0;
for (; i < length; i++) {
if (a[i] % 2 == 0)
x += a[i];
}
return x;
}
```
А теперь на Хаскеле:
```
-- эта функция уже определена в "стандартной библиотеке",
-- но повторение это мать учения :)
even x = x `mod` 2 == 0
sumEven = sum . filter even
```
Никакой копипасты, мы просто отбрасываем все элементы списка, которые не удовлетворяют предикату even, и применяем к этому списку функцию sum.
Вот примерно так, используя функции высшего порядка и рекурсию, мы радикально сокращаем количество кода. Таковые сокращения не могут не сказаться положительно на нашем психическом и «пальцевом» здоровье. %)
А циклы таки не нужны. :)
#### Примечания
* Большое количество взаимно-рекурсивных функций конечно же, сложно понять. Поэтому тут надо быть осторожным, и все делать в меру. Вообще-то, в функциональных языках обычно присутствуют средства абстракции, достаточно мощные для того, чтобы убрать (или, точнее, снизить) сложность для восприятия.
* В некоторых особо распространенных языках программирования этот подход неприменим, но это недостатки этих языков, а не подхода. :)
* Не следует боятся того, что функция foldr съесть весь стек, потому что ее можно переписать в итеративный процесс, определенный рекурсивно.
* Более подробно (с объяснениями, как же оно работает), можно почитать в [блоге Adam Turoff](http://notes-on-haskell.blogspot.com/2007/02/whats-wrong-with-for-loop.html)
UPD: правка (JS -> C), замечания (спасибо [tass](https://geektimes.ru/users/tass/) и [voicer](https://geektimes.ru/users/voicer/)) | https://habr.com/ru/post/47429/ | null | ru | null |
# Компьютер маленького человечка
Все мы знаем машину Тьюринга и машину Поста. Это абстрактные вычислительные машины, придуманные математиками для теории алгоритмов. Компьютер маленького человечка ([Little man computer](http://en.wikipedia.org/wiki/Little_man_computer)) — модель компьютера, предназначенная для обучения тому, как устроен и работает компьютер. Эта модель была предложена профессором Стюартом Мэдником в 1965 году и успешно используется для обучения студентов начальных курсов как в области программирования, так и конструирования компьютеров.
Давайте посмотрим на компьютер как на небольшое почтовое отделение.
В отделении есть два окошка для общения с внешним миром: в окошко INP поступают, а из окошка OUT выходят листочки с числами.Числа могут быть от 0 до 999. В отделении есть 100 почтовых ящиков, пронумерованных от 0 до 99, из них человечек может брать листочки с трехзначными числами, а также может заменять эти листочки новыми. Также у него есть простой калькулятор (аккумулятор), позволяющий складывать и вычитать трехзначные числа. При обработке чисел на калькуляторе автоматически поднимаются флажки для чисел, равных 0 и больших 0.
Оператор компьютера пишет программу на листочках и кладет их в почтовые ящики, затем устанавливает счетчик команд (PC) в 0 и нажимает кнопку «Начать работу». Внутри почтового отделения человечек обрабатывает листочки с числами, лежащие в почтовых ящиках. Опишем цикл обработки по шагам:
1. Выбрать число из счетчика команд. Это число — номер почтового ящика.
2. Запомнить число из почтового ящика, номер которого получен на 1 шаге.
3. Увеличить счетчик команд на 1.
4. Разобрать команду (число, полученное на 2 шаге).
5. Выполнить выборку данных из почтового ящика, если это требуется.
6. Выполнить саму команду.
7. Сохранить данные в почтовый ящик, если это требуется.
8. Вернуться к шагу 1 или остановиться, если команда равна 0.
Команды — трехзначные десятичные числа, цифра сотен определяет тип команды, а цифры десятков и единиц — номер почтового ящика.
| Код команды | Тип команды | Действия |
| --- | --- | --- |
| 1xx | ADD | Добавить число из ящика хх к аккумулятору. Поднять флаг НОЛЬ или ПОЛОЖИТЕЛЬНОЕ ЧИСЛО. Если результат больше 999, то закончить работу с ошибкой. |
| 2xx | SUB | Вычесть число из ящика хх из аккумулятора. Поднять флаг НОЛЬ или ПОЛОЖИТЕЛЬНОЕ ЧИСЛО. Если результат меньше 0, то аккумулятор не изменяется а флаги опускаются. |
| 3xx | STA | Сохранить содержимое аккумулятора в ящике хх. |
| 5xx | LDA | Загрузить число из ящика хх в аккумулятор. Поднять флаг НОЛЬ или ПОЛОЖИТЕЛЬНОЕ ЧИСЛО. |
| 6xx | BRA | Установить счетчик команд равным xx. |
| 7xx | BRZ | Если флаг НОЛЬ, то установить счетчик команд равным xx. |
| 8xx | BRP | Если флаг НОЛЬ или ПОЛОЖИТЕЛЬНОЕ ЧИСЛО, то установить счетчик команд равным xx. |
| 901 | INP | Выбрать число из окошка INP и записать в аккумулятор. Поднять флаг НОЛЬ или ПОЛОЖИТЕЛЬНОЕ ЧИСЛО. Если число не попадает в диапазон от 0 до 999, то закончить работу с ошибкой. |
| 902 | OUT | Записать число из аккумулятора на листочке и положить в окошко OUT. |
| 000 | HLT | Закончить работу. |
Итак, мы описали компьютер с архитектурой фон Неймана с небольшим набором команд. В модели не используется двоичное кодирование команд и это упрощает написание программ для этого компьютера — устройство компьютера можно нарисовать на доске, а программы выполнять на листке бумаги. Думаю, что в 60-х годов ХХ века многие студенты выполняли программы таким образом, но сейчас мы можем написать эмулятор такого компьютера, что я и сделал на AWK.
Исходный код эмулятора и примеры программ: [GitHub](https://github.com/Ono2it/lmc).
Эмулятор запускается командой:
```
awk -f lmc.awk
```
Команды эмулятора:
```
LOAD ###[ ### ...] - загрузить программу в кодах
DUMP - показать содержимое памяти
RUN - выполнить программу
ASM <имя файла> - скомпилировать программу на ассемблере и загрузить
```
Несколько коротких программ:
```
LOAD 901 902 000 - копируем число с INP в OUT, останавливаемся
LOAD 901 104 902 000 1 - добавляем 1 к числу из INP, пишем в ОUT, останавливаемся
LOAD 901 902 704 600 000 - копируем числа с INP в OUT, и прекращаем работу после печати 0
```
**Пример запуска программы:**
```
LOAD 901 902 0
DUMP
00: 901 902 0 0 0 0 0 0 0 0
10: 0 0 0 0 0 0 0 0 0 0
20: 0 0 0 0 0 0 0 0 0 0
30: 0 0 0 0 0 0 0 0 0 0
40: 0 0 0 0 0 0 0 0 0 0
50: 0 0 0 0 0 0 0 0 0 0
60: 0 0 0 0 0 0 0 0 0 0
70: 0 0 0 0 0 0 0 0 0 0
80: 0 0 0 0 0 0 0 0 0 0
90: 0 0 0 0 0 0 0 0 0 0
RUN
INP:100
OUT:100
```
Одинаковая длина и простой формат команд позволяет быстро написать ассемблер для этого компьютера. После этого можно писать длинные программы без ручного расчета адресов.
**Числа Фибоначчи:**
```
awk -f lmc.awk
asm fib.lma
00: #Print fibonacci numbers
00: LDA ONE #Load init values
01: STA FIB1 #First number
02: STA FIB2 #Second number
03: OUT #Print first
04: OUT #Print second
05: LOOP LDA MAX #ACC=MAX
06: SUB FIB1 #ACC=ACC-FIB1
07: SUB FIB2 #ACC=ACC-FIB2
08: BRP CONT #ACC positive ? Continue
09: BRA END #Negative : goto end of program
10: CONT LDA FIB1 #ACC=FIB1
11: ADD FIB2 #ACC=ACC+FIB2
12: STA FIBN #Store FIBN - next number
13: OUT #Print it
14: LDA FIB2 #FIB1=FIB2
15: STA FIB1
16: LDA FIBN #FIB2=FIBN
17: STA FIB2
18: BRA LOOP #Next LOOP
19: END HLT
20: ONE DAT 1 #Init value
21: FIB1 DAT #First fib number
22: FIB2 DAT #Second fib number
23: FIBN DAT #Next fib number
24: MAX DAT 999 #Max computer number
Labels:
LOOP 05
MAX 24
FIB1 21
FIB2 22
FIBN 23
ONE 20
END 19
CONT 10
Xrefs:
LOOP 18
MAX 5
FIB1 1 6 10 15
FIB2 2 7 11 14 17
FIBN 12 16
ONE 0
END 9
CONT 8
LOAD 520 321 322 902 902 524 221 222 810 619 521 122 323 902 522 321 523 322 605 0 1 0 0 0 999
``` | https://habr.com/ru/post/257331/ | null | ru | null |
# Как работает Activity. Часть 1
Мобильные операционные системы имеют свою специфику. Когда мы пользуемся смартфонами, создается впечатление, что мы находимся в одном приложении и переход между ними происходит практически незаметно. Например, мы можем из нашего приложения вызвать приложение почты, и это будет выглядеть так, будто мы встроили экран приложения почты в наше.
Вся эта магия происходит благодаря тому, что Android предоставляет фреймворк с базовыми компонентами. Мы не управляем этими компонентами, а лишь можем реагировать на колбэки, которые есть во фреймворке. Процессом приложения управляет система.
В первой части совсем немного расскажу про Binder, про то, как происходит запуск Activity, как стартует процесс приложения и как на вызов Activity влияют флаги и launch mode. Во второй части будет про то, как вызываются методы жизненного цикла Activity, что происходит при сворачивании приложения, и более подробно расскажу про старт первой Activity.
Все начинается с Binder
-----------------------
Binder — фреймворк для построения межпроцессной коммуникации. Сам Binder работает на уровне ядра системы. Он использует набор низкоуровневых функций ОС, позволяющих обмениваться данными между процессами так, будто у них есть общая память.
Фишка в том, что он позволяет описать интерфейсы на специальном языке AIDL, Android Interface Definition Language, — что-то вроде суперурезанной Java. А потом при помощи кодогенерации сгенерировать классы Java. Дальше вызываются сгенеренные методы Java-классов, как будто все происходит в одном процессе. На самом деле данные будут ходить между процессамиЗнать про Binder нужно, чтобы разобраться во всем, что будет дальше. Про саму технологию много есть в телеграм-канале [Android Easy Notes](https://t.me/android_easy_notes/141) и на Хабре:
Основы безопасности операционной системы Android. Безопасность на уровне Application Framework. Binder IPCВступление После небольшого перерыва я продолжаю объяснять базовые принципы как обеспечивается безоп...[habr.com](https://habr.com/ru/post/176093/)Система Android работает на базе ядра Linux, пусть и сильно изменившегося. Это значит, что так или иначе приложения работают в разных процессах. Мы не контролируем создание процесса приложения и управление им. Вся сложность скрывается за фреймворком, который любезно предоставляет команда Google.
Работа проходит в разных адресных пространствах, нельзя влезть в другой процесс и дернуть методы какого-то класса. Задача сложная, когда появляется много межпроцессных вызовов.
Нужен был инструмент, который позволил бы разработчикам фреймворка легко реализовывать межпроцессное взаимодействие. И разработчики Android создали Binder.
Как стартует первая Activity
----------------------------
Все начинается с лаунчера. Лаунчер — первое приложение, которое запускается системой. Он отличается от обычного приложения тремя вещами:
1️⃣ Главной Activity лаунчера устанавливается категория HOME, благодаря чему система будет вызывать эту Activity при нажатии на кнопку Home.
2️⃣ Всем Activity лаунчера нужно выставить флаг excludeFromRecents, чтобы они не мелькали в recents.
3️⃣ Activity лаунчера пользователь будет видеть чаще всего. То, что приложением будут пользоваться чаще всего, — сказка для эффективных менеджеров. Но цена такого успеха — когда крашится обычное приложение, пользователи пугаются и удаляют лаунчер.
Основная задача лаунчера — вывести красивый список других приложений. Получить список приложений можно несколькими путями, но самый простой — через сервис [LauncherApps.](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/content/pm/LauncherApps.java?q=LauncherApps&ss=android%2Fplatform%2Fsuperproject)
Выводим список, и при нажатии на иконку приложения нужно запустить процесс уже другого приложения либо восстановить, если приложение было свернуто.
Можно запустить Activity приложения через обычный Intent, но хороший лаунчер должен учитывать [рабочий профиль.](https://developer.android.com/work/managed-profiles) Поэтому запуск первой Activity желательно делать при помощи все того же системного сервиса [LauncherApps.](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/content/pm/LauncherApps.java?q=LauncherApps&ss=android%2Fplatform%2Fsuperproject)
```
launcherApps.startMainActivity(
сomponentName, // название пакета приложения
userHandle, // пользователь, из которого нужно запустить приложение
null, // указание координат иконки нашего приложения
options // bundle для всяких допнастроек типа варианта анимации
)
```
У сервиса есть [специальный метод](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/content/pm/LauncherApps.java;l=810;bpv=1;bpt=1?q=LauncherApps&ss=android%2Fplatform%2Fsuperproject) для запуска первой Activity. Он заставляет указать пользователя, с которого нужно запустить приложение, а еще передать данные для красивой анимации запуска приложения от иконки до сплеша.
```
val options = ActivityOptions.makeScaleUpAnimation(
view, // изображение иконки приложения
0, // старовая позиция X анимации относительно переданной иконки
0, // старовая позиция Y анимации относительно переданной иконки
view.measuredWidth, // изначальная ширина будущей Activity
view.measuredHeight // изначальная высота будущей Activity
)
```
Помимо приведенной выше функции, есть еще множества других и при желании можно подсунуть свою. Как видим лаунчер может отображать запуск приложение как ему заблагорассудится.
Все дороги ведут в ActivityStarter
----------------------------------
После запуска специального метода через ActivityManagerService приходим в [ActivityStarter.](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java) По названию очевидно, что класс отвечает за старт Activity. Каждый раз, запуская Activity, мы будем приходить сюда.
ActivityStarter — интересный класс, его API отдаленно напоминает запрос из OkHttp. Очень большой билдер, через который задаются настройки, и все запускается через метод executeВ ActivityStarter передается куча параметров, и один из них — сам Intent запускаемой Activity. ActivityStarter из этого Intent вытаскивает объект [ActivityInfo](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/content/pm/ActivityInfo.java;drc=652335ea7c2f8f281a1b93a1e1558960b6ad1b6f;l=57) — класс, который описывает все, что мы прописываем про Activity в Manifest.
```
class ActivityInfo(
val theme: Int,
val launchMode: Int,
val taskAffinity: Int
/*...*/
)
```
На основании ActivityInfo [создается ActivityRecord](https://cs.android.com/android/platform/superproject/+/master:out/soong/.intermediates/frameworks/base/services/core/services.core.unboosted/android_common/xref31/srcjars.xref/frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java;l=1175;drc=master;bpv=0;bpt=1) — класс, который является репрезентацией Activity. Он описывает состояние Activity и позволяет системе принимать решения о том, какой метод жизненного цикла нужно вызвать, исходя из этого состояния.
```
class ActivityRecord(
val packageName: String,
val activityInfo: ActivityInfo,
val task: Task, //Task, в котором запущена (будет запущена) Activity
/*...*/
)
```
В классе больше информации, чем в ActivityInfo: например, в каком Task запущена Activity, в каком статусе жизненного цикла она находится и запущен ли вообще процесс этой Activity.
Про ActivityRecord обычно знают, если на собеседовании прилетал вопрос: «А где же хранятся ViewModel?» Это не те ActivityRecord. ViewModel хранятся в ActivityClientRecord, которые создаются только в рамках приложения, что-то вроде локальной версии ActivityRecord, о которых мы сейчас говорим.
Система напрямую не дергает методы Activity, именно о классе Activity система ничего не знает и сама их не создает. Она знает только о ActivityRecord — и уже исходя из информации, полученной из ActivityRecord, принимает решения о том, какой метод жизненного цикла нужно дернуть. Подробнее о том, как это происходит, поговорим дальше.
После того как ActivityStarter создал ActivityRecord, он пытается запустить его. Тут два варианта:
1. Процесс уже создан, и нужно лишь отправить Activity в этот процесс.
2. Процесса нет, и для начала нужно [создать этот процесс.](https://cs.android.com/android/platform/superproject/+/master:out/soong/.intermediates/frameworks/base/services/core/services.core.unboosted/android_common/xref31/srcjars.xref/frameworks/base/services/core/java/com/android/server/wm/ActivityTaskSupervisor.java;l=1034;drc=master)
Сниппет кода, как это происходит:
```
fun startSpecificActivity(r: ActivityRecord, andResume: Boolean, checkConfig: Boolean) {
// Is this activity's application already running?
val wpc = activityTaskManagerService
.getProcessController(r.processName, r.info.applicationInfo.uid)
/*..*/
if (wpc != null && wpc.hasThread()) {
realStartActivityLocked(r, wpc, andResume, checkConfig)
/*..*/
} else
/*..*/
activityTaskManagerService.startProcessAsync(r)
}
```
Через много вложенных методов, с проверками и настройками приходим в статический метод из класса ZygoteProcess — [startViaZygote.](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/os/ZygoteProcess.java;l=619;drc=652335ea7c2f8f281a1b93a1e1558960b6ad1b6f;bpv=1;bpt=1) Используем этот метод, чтобы подать сигнал Zygote о том, что нужно запустить новый процесс.
Краткое описание Zygote и fork
------------------------------
ZygoteInit каждый видел в стеке «вызов функций». Независимо от того, что у вас за приложение, стартовать оно всегда будет отсюда.
Зигота — термин из биологии. Это клетка, которая возникает при слиянии мужской и женской половых клеток. После определенного времени она начинает делиться, клонируя себя. Разработчики назвали этот класс не просто так, потому что, по сути, именно это и происходит каждый раз при старте приложения.
Если погрузиться в череду вызовов системных функций, то при старте системы запускается файл init.rc. В нем описано, как запускать все процессы-демоны, сервисы и остальные элементы системы.
Разработчики Android сделали систему ([Android Init Language](https://android.googlesource.com/platform/system/core/+/master/init/README.md)), которая при помощи специальных инструкций описывает, как именно и в каком порядке нужно запустить все системные сервисы. Этот файл различается для разных версий ОС и напоминает работу с yml-файлами при настройке CI. Там мы тоже описываем команды, а также триггеры, когда эти команды вызывать. Вот конфигурация старта zygote:
```
service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
class main
priority -20
…
```
Service — специальная команда ([Android Init Language](https://android.googlesource.com/platform/system/core/+/master/init/README.md)), которая запускает некоторый сервис. Только это не тот сервис, который в Android Framework, а просто программа на низкоуровневом языке. В нашем примере запускается [app\_process.](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/cmds/app_process/app_main.cpp;l=173;drc=b45a2ea782074944f79fc388df20b06e01f265f7;bpv=1;bpt=1)
```
int main(int argc, char* const argv[]){
/*...*/
AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
/*...*/
if (zygote) {
runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
} else if (!className.isEmpty()) {
runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
} else {
fprintf(stderr, "Error: no class name or --zygote supplied.\n");
/*...*/
}
}
```
App\_process — небольшая программа на C++, основная задача которой — запустить JVM и в частности main-функцию ZygoteInit.
С этого начинается работа Zygote. Сначала подгружаются все классы для работы JVM и все Android-зависимости, необходимые для работыПосле загрузки классов запускается ZygoteServer, который [запускает бесконечный цикл](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/com/android/internal/os/ZygoteServer.java;l=433;drc=69e700c7922c34583bddbab4b7ce78adadb90730), и начинается самое интересное.
```
class ZygoteInit {
fun main(argv: Array) {
var zygoteServer: ZygoteServer? = null;
/\* Загрузка всех необходимых классов \*/
var caller: Runnable? = null
/\* ... \*/
zygoteServer = ZygoteServer(isPrimaryZygote)
// Запускаем бесконечный цикл, родительский процесс дальше не двигается
// Созданные процессы будут выходить из этого цикла и идти дальше
caller = zygoteServer.runSelectLoop(abiList)
/\* ... \*/
// Тут мы уже находимся в новом созданном процессе и выполняем переданную команду
caller.run()
}
}
```
Эта магия системного программирования, которую очень редко можно встретить в обычных проектах. Объясню на примере кода на низкоуровневом языке. C++, на мой взгляд, должен отправиться на полку истории, поэтому модно-молодежно черканем пару строк на Rust:
```
fn main() {
let fork_result = unsafe { fork() };
match fork_result {
Ok(ForkResult::Parent { child }) => {
println!("I'm a parent process, pid: {}, child pid {}", process::id(), child);
}
Ok(ForkResult::Child) => println!("I'm a new child process, pid: {}", process::id()),
Err(_) => println!("Fork failed"),
};
}
```
В Unix есть системный вызов, который называется fork. Он берет ваш процесс, копирует все состояния переменных, потоки, стеки, хип, переносит в отдельное место в оперативной памяти и запускается как отдельный процесс.
Можно вызвать системный метод из любой точки программы. Бывает трудно разобраться в потоках, и можно сделать программу, где после определенного вызова функции будет два процесса. Именно это и делает ZygoteServer
```
/*...*/
val command = Os.poll()
/*...*/
val caller = Zygote.forkUsap(mUsapPoolSocket, sessionSocketRawFDs, isPriorityRefill)
/*...*/
```
[ZygoteServer](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/com/android/internal/os/ZygoteServer.java;l=340;drc=b45a2ea782074944f79fc388df20b06e01f265f7;bpv=0;bpt=1) запускает бесконечный цикл, в этом цикле он ждет команду от системы на запуск нового процесса. Когда система дает команду на создание нового процесса, новый процесс выходит из бесконечного цикла и идет дальше, запуская ActivityThread. Изначальный процесс так и остается в бесконечном цикле в ожидании новых команд от ОС. ZygoteServer буквально живет ради детей.
Android и так не всегда быстрый, а если бы при каждом старте еще нужно было каждый раз подгружать все нужные классы, было бы совсем грустно. Поэтому разработчики придумали копировать инстанс JVM с уже загруженными классами. Отсюда и смесь кода на Java и системных вызовов. Zygote можно воспринимать как кэш с загруженными классами для любого нового процесса приложения.
Зачем нужно вообще на каждый старт приложения запускать новый процесс, почему на одной JVM все приложения не запускать?
Основная причина — безопасность. Когда приложение работает, хочется быть уверенным, что в его память никто не сможет залезть. И если мы работаем в рамках одного процесса, такой безопасности никто гарантировать не может.
Всегда есть возможность чуть-чуть подтюнить JVM под себя или сломать все. Скорее всего, вы были бы сильно недовольны, если бы ваше приложение сломалось по той причине, что другое приложение решило поиграться с настройками этой самой JVM.
Для решения этой проблемы каждое приложение запускается в отдельном процессе, и эта система называется **sandbox**.
Как подать сигнал Zygote для старта нового процесса
------------------------------------------------------
ZygoteServer называется сервером не просто так, он буквально слушает сокет. Тот самый джавовский сокет, только не совсем обычный.
В Unix-системах есть Unix Domain Socket (UDS) — специальная реализация сокета, которая не использует сетевую карту и предназначена именно для передачи данных между двумя процессами на одной машине
UDS работает на базе файловой системы, если интересно узнать подробнее — прочтите [статью на Википедии.](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D0%BA%D0%B5%D1%82_%D0%B4%D0%BE%D0%BC%D0%B5%D0%BD%D0%B0_Unix) Через этот сокет общаются все демоны операционной системы. Через него же и подается сигнал о том, что пора бы и новый процесс запустить.
Запуск последующих Activity
---------------------------
Activity запускаются в Task — это стек, в который складываются Activity при запуске. Стек фрагментов делался как копия Task, поэтому работают они примерно одинаково.
Таких Task у приложения может быть несколько. По дефолту все Activity запускаются в одном Task. Но у Activity есть специальный атрибут, который позволяет указать, в каком Task должна запускаться Activity. Этот атрибут называется taskAffinity.
```
Task, а в ActivityStarter [есть метод](https://cs.android.com/android/platform/superproject/+/master:out/soong/.intermediates/frameworks/base/services/core/services.core.unboosted/android_common/xref31/srcjars.xref/frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java;l=2405;drc=master;bpv=1;bpt=1), который определяет, в какой именно Task будет отправлена Activity, исходя из флага или настройки taskAffinity.На практике этот флаг красиво использует LeakCanary. Библиотека подсовывает свои Activity таким образом, что кажется, будто вам внедрился целый кусок другого приложения. Подробнее об этом [я писал в телеграм-канале.](https://t.me/android_easy_notes/114)
Еще из интересного, есть атака через этот атрибут, которая называется [Android Task Hijacking.](https://xakep.ru/2017/08/14/android-task-hijacking/) Если кратко, можно сделать так, чтобы Activity нашего приложения запускалась в Task другого приложения, ну и, соответственно, можно, например, встроить рекламу ставок на спорт туда, где этого ну вообще не ожидали. Будьте аккуратнее с флагом singleTask!
Теперь обсудим launch mode. Есть четыре основных launch mode и куча различных флагов, которые мы можем передать в Intent. Разбирать, какие есть флаги, нет смысла, потому как их прямо много, а про launch mode можно отдельно прочитать [тут.](https://habr.com/ru/company/otus/blog/493802/)
Работа с ними осуществляется все в том же ActivityStarter, для этого есть [отдельный метод.](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java;l=2286) По факту вся работа дальше происходит только с флагами, все launch mode, которые мы указываем в манифесте, дальше превращаются во флаги. В зависимости от флага ActivityStarter настраивает, в какой Task нужно отправить Activity, нужно ли удалять предыдущие и прочее.
После того как запустилась наша первая Activity, последующие Activity мы открываем через интенты, которые отправляем уже сами.
Когда мы хотим показать новую Activity, мы вызываем startActivity. Но он не сразу идет в системный сервис, а сначала вызывает метод mInstrumentation.execStartActivity.
Класс [Instrumentation](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/Instrumentation.java;l=75?q=Instrumentation&ss=android%2Fplatform%2Fsuperproject) в основном используется в тестах, по сути своей это hook, который позволяет перехватить методы показа Activity и еще много чего.
В обычной реализации execStartActivity передает вызов в ActivityTaskManagerService, который отправляет вызов в уже известный нам ActivityStarter. Как видите, нет особой разницы, запускаем ли мы сами Activity или ее запускает система.
Однажды я встретил вопрос: «Для чего нужно обозначать наши Activity в манифесте? Скажем, вот пример с BroadcastReceiver, мы можем его назначить динамически, можно ли так сделать с Activity?»
Ответ на этот вопрос кроется в логике работы ActivityStarter. Как он может узнать о том, как ему запускать Activity, если приложение еще ни разу не было запущено? ActivityStarter получает данные о том, какую Activity ему нужно запустить и как именно ее нужно запустить, из PackageManager.
PackageManager получает все эти данные из манифеста при установке приложения. Системе нужно знать об Activity не только тогда, когда приложение запущено, но и тогда, когда приложения еще нет в памяти и ни разу не было.
Кроме этого, у нас есть возможность расшарить нашу функциональность другим приложениям, которые будут запускать наши Activity, причем не только главную, но еще и в разных Task.
Вместо заключения
-----------------
В статье я описал лишь функциональность, которая относится к запуску Activity и приложения, и это лишь бесконечно малая часто того, что делает система. Но уже на этом примере прослеживаются интересные архитектурные паттерны, которые использует Android внутри себя.
Очень многое сделано на базе клиент-серверной архитектуры, в которой запрос отправляется при помощи Binder. Вы наверняка часто встречали, что при помощи метода getSystemService мы почему-то получаем какой-то Manager. Самый банальный пример:
```
val connectivityManager = context.getSystemService(CONNECTIVITY_SERVICE) as ConnectivityManager
```
И вот, если вдуматься в синтаксис, абсурд же происходит! Вроде достаем сервис, а получаем менеджер. Просто нужно понимать, что этот Manager — это клиент для работы с каким-то системным сервисом.
Системный сервис чем-то похож на привычный нам сервис, только работает он всегда и в другом отдельном процессе.
Manager — это клиент, Service — сервер. Такая архитектура позволяет как угодно менять Service, делать его вложенным классом, затаскивать в другое место — не имеет никакого значения. Главное, что, если не меняется интерфейс AIDL, клиент также не будет меняться.
Эта же концепция действует и при работе с Activity. Мы просто отправляем запрос в приложение посредством Binder, а приложение уже само решает, как именно ему нужно показать Activity.
Если вам понравилась статья и иллюстрации к ней, подписывайтесь [на мой телеграм-канал.](https://t.me/android_easy_notes) Я пишу про Android-разработку и Computer Science, на канале есть больше интересных постов про разработку под Android. А еще залетайте [на наш ютуб с подборкой про Android](https://www.youtube.com/playlist?list=PLLrf_044z4Jqn-veCMIomCkkVy_nmccUY) и слушайте [подкаст «Кем ты стал»](https://castbox.fm/episode/Android-%D1%80%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0.-%D0%9A%D0%B0%D0%BA-%D0%BF%D1%80%D0%B5%D0%B2%D1%80%D0%B0%D1%82%D0%B8%D1%82%D1%8C-%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D1%83-%D0%B2-%D0%BB%D0%B8%D1%87%D0%BD%D1%8B%D0%B9-%D0%B1%D1%80%D0%B5%D0%BD%D0%B4-id4522210-id517096573?country=ru) о том, как превратить работу в личный бренд.
``` | https://habr.com/ru/post/703548/ | null | ru | null |
# Введение в секционирование таблиц
По материалам статьи Craig Freedman: [Introduction to Partitioned Tables](https://docs.microsoft.com/en-us/archive/blogs/craigfr/introduction-to-partitioned-tables)
В этой статье я собираюсь продемонстрировать особенности планов исполнения запросов при обращении к секционированным таблицам. Обратите внимание, что существует большая разница между секционированными таблицами (которые стали доступны только с SQL Server 2005) и секционированными представлениями (которые были доступных ещё в SQL Server 2000, и по-прежнему доступны в SQL Server 2005 и последующих версиях). Особенности планов запросов к секционированным представлениям я продемонстрирую в другой статье.
### Просмотр таблицы
Давайте создадим простую секционированную таблицу:
```
create partition function pf(int) as range for values (0, 10, 100)
create partition scheme ps as partition pf all to ([primary])
create table t (a int, b int) on ps(a)
```
Этот сценарий создает таблицу с четырьмя секциями. SQL Server присвоил значения идентификаторам каждой из четырех секций так, как это показано в таблице:
| | |
| --- | --- |
| **PtnId** | **Values** |
| 1 | t.a <= 0 |
| 2 | 0 < t.a <= 10 |
| 3 | 10 < t.a <= 100 |
| 4 | 100 < t.a |
Теперь давайте рассмотрим план такого запроса, который бы вынудил оптимизатор использовать просмотр всей таблицы (Table Scan):
```
select * from t
```
|–Nested Loops(Inner Join, OUTER REFERENCES:([PtnIds1004]) PARTITION ID:([PtnIds1004]))
……|–Constant Scan(VALUES:(((1)),((2)),((3)),((4))))
…….|–Table Scan(OBJECT:([t]))
В представленном выше плане, SQL Server явно указывает все идентификаторы секции в операторе «Constant Scan», который реализует просмотр таблицы и поставляет данные оператору соединения вложенных циклов. Тут следует напомнить, что оператор соединения вложенных циклов выполняет проход по внутренней таблице (в данном случае это полный просмотр таблицы) один раз для каждого значения из внешней таблицы (в нашем случае это «Constant Scan»). Таким образом, мы выполняем просмотр таблицы четыре раза; один раз для каждого идентификатора секции.
Следует также отметить, что соединение вложенных циклов показывает явно что внешняя таблица является значениями столбца [PtnIds1004], где хранятся ID секций. Хотя это не сразу видно в текстовом представлении плана исполнения (к сожалению, мы иногда не замечаем эту информацию), просмотр таблицы использует столбец с идентификаторами секций, которые выбираются для выполнения просмотра и определяют какую секцию сканировать. Эта информация всегда доступна в графическом плане исполнения (нужно заглянуть в свойства оператора просмотра таблицы), а также в XML представление плана исполнения запроса:
`…`
**Статическая фильтрация секций**
Рассмотрим следующий запрос:
```
select * from t where a < 100
```
|–Nested Loops(Inner Join, OUTER REFERENCES:([PtnIds1005]) PARTITION ID:([PtnIds1005]))
…….|–Constant Scan(VALUES:(((1)),((2)),((3))))
…….|–Table Scan(OBJECT:([t]), WHERE:([t].[a]<(100)) PARTITION ID:([PtnIds1005]))
Предикат «а <100» явно исключает все строки для секции со значением идентификатора равным 4. В данном случае, нет смысла в просмотре соответствующей секции, поскольку ни одна из строк этой секции не удовлетворяет условию предиката. Оптимизатор учитывает этот факт и исключает эту секцию из плана исполнения запроса. В операторе «Constant Scan» указаны только три секции. У нас принято называть это статической фильтрацией секций (static partition elimination), поскольку мы знаем, что во время компиляции список просматриваемых секций остаётся статичным.
Если в результате статичной фильтрации будут исключены все разделы, кроме одного, нам вообще не понадобятся операторы «Constant Scan» и «Nested Loops Join»:
```
select * from t where a < 0
```
|–Table Scan(OBJECT:([t]), WHERE:([t].[a]<(0)) PARTITION ID:((1)))
Обратите внимание, что указание «PARTITION ID:((1))», которое задаёт идентификатор подлежащей просмотру секции, теперь является частью оператора просмотра таблицы (Table Scan).
### Динамическая фильтрация секций
В некоторых случаях SQL Server не может определить, что на момент компиляции состав просматриваемых секций не изменится, но ему видно, что некоторые секции можно исключить.
```
declare @i int
select @i = 0
select * from t where a < @i
```
|–Nested Loops(Inner Join, OUTER REFERENCES:([PtnIds1004]) PARTITION ID:([PtnIds1004]))
…….|–Filter(WHERE:([PtnIds1004]<=RangePartitionNew([@i],(0),(0),(10),(100))))
…….| |–Constant Scan(VALUES:(((1)),((2)),((3)),((4))))
…….|–Table Scan(OBJECT:([t]), WHERE:([t].[a]<[@i]) PARTITION ID:([PtnIds1004]))
Это параметризованный запрос. Так как до исполнения значение параметра мы не знаем (то, что я использую константу в качестве параметра в том же батче, не меняет положение вещей), то на этапе компиляции невозможно определить значение идентификатора секции для оператора «Constant Scan». Возможно придётся просматривать только секцию 1, или это будут секции 1 и 2, и так далее. Поэтому, в этом операторе указаны все четыре идентификатора секций, и мы используем фильтрацию идентификаторов секций на этапе исполнения. Мы называем это «Динамическая фильтрация секций» (Dynamic Partition Elimination).
Фильтр сравнивает каждый идентификатор секции c результатом работы специальной функции «RangePartitionNew». Эта функция вычисляет результаты применения функции секционирования к значению параметра. Аргументами этой функции (слева направо) являются:
* значение (в данном случае параметр @i), который мы хотим отобразить на ID секции;
* булевой флаг, указывающий, отображает ли функция секционирования граничные значения слева (0) или справа (1);
* граничные значения секций (в данном случае это 0, 10, и 100).
В этом примере, поскольку @i имеет значение 0, результатом «RangePartitionNew» является 1. Таким образом, мы просматриваем только секцию с идентификатором 1. Заметим, что в отличие от примера со статической фильтрацией секций, хотя мы сканируем только один раздел, мы по-прежнему имеем «Constant Scan» и «Nested Loops Join». Нам потому нужны эти операторы, что до этапа исполнения мы не знаем секции, которые будут просмотрены.
В некоторых случаях оптимизатор уже на этапе компиляции может определить, что мы будем сканировать только одну секцию, даже если он не может определить, какую именно. Например, если в запросе используется предикат эквивалентности по ключу секционирования, тогда мы знаем, что только одна секция может удовлетворять такому условию. Поэтому, несмотря на то, что у нас должна была быть динамическая фильтрация секций, у нас отпадает необходимость в операторах «Constant Scan» и «Nested Loops Join». Пример:
```
declare @i int
select @i = 0
select * from t where a = @i
```
|–Table Scan(OBJECT:([t]), WHERE:([t].[a]=[@i]) PARTITION ID:(RangePartitionNew([@i],(0),(0),(10),(100))))
### Сочетание статической и динамической фильтрации секций
SQL Server может совмещать статическую и динамическую фильтрацию секций в одном плане запроса:
```
declare @i int
select @i = 0
select * from t where a > 0 and a < @i
```
|–Nested Loops(Inner Join, OUTER REFERENCES:([PtnIds1004]) PARTITION ID:([PtnIds1004]))
……|–Filter(WHERE:([PtnIds1004]<=RangePartitionNew([@i],(0),(0),(10),(100))))
……| |–Constant Scan(VALUES:(((2)),((3)),((4))))
……|–Table Scan(OBJECT:([t]), WHERE:([t].[a]<[@i] AND [t].[a]>(0)) PARTITION ID:([PtnIds1004]))
Обратите внимание, что в последнем плане присутствует статическая фильтрация секции ID = 1 с использованием «Constant Scan», и также присутствует динамическая фильтрация для других секций, определяемых предикатами.
### $partition
Можно явно вызвать функцию RangePartitionNew, используя $partition:
```
select *, $partition.pf(a) from t
```
|–Compute Scalar(DEFINE:([Expr1004]=RangePartitionNew([t].[a],(0),(0),(10),(100))))
……|–Nested Loops(Inner Join, OUTER REFERENCES:([PtnIds1005]) PARTITION ID:([PtnIds1005]))
………..|–Constant Scan(VALUES:(((1)),((2)),((3)),((4))))
………..|–Table Scan(OBJECT:([t]))
Отличительной особенностью такого плана исполнения запроса является появление оператора Compute Scalar.
### Дополнительная информация
[Статья в блоге SQL Server Development Customer Advisory Team](https://techcommunity.microsoft.com/t5/datacat/partition-elimination-in-sql-server-2005/ba-p/304935) содержит несколько интересных примеров фильтрации секций. | https://habr.com/ru/post/661571/ | null | ru | null |
# Как правильно и неправильно спать
Не так давно мимо нас пробегала неплохая статья об ужасном состоянии производительности современного ПО ([оригинал на английском](http://tonsky.me/blog/disenchantment/), [перевод на Хабре](https://habr.com/post/423889/)). Эта статья напомнила мне об одном антипаттерне кода, который встречается весьма часто и в общем кое-как работает, но приводит к небольшим потерям производительности то тут, то там. Ну, знаете, мелочь, пофиксить которую руки никак не дойдут. Беда лишь в том, что десяток таких «мелочей», разбросанных в разных местах кода начинают приводить к проблемам типа «вроде у меня последний Intel Core i7, а прокрутка дёргается».
Я говорю о неверном использовании функции [Sleep](https://docs.microsoft.com/en-us/windows/desktop/api/synchapi/nf-synchapi-sleep) (регистр может отличаться в зависимости от языка программирования и платформы). Итак, что же такое Sleep? Документация отвечает на этот вопрос предельно просто: это пауза в выполнении текущего потока на указанное количество миллисекунд. Нельзя не отметить эстетическую красоту прототипа данной функции:
```
void Sleep(DWORD dwMilliseconds);
```
Всего один параметр (предельно понятный), никаких кодов ошибок или исключений — работает всегда. Таких приятных и понятных функций очень мало!
**Ещё большим уважением проникаешься к этой функции, когда читаешь, как она работает**Функция идёт к планировщику потоков ОС и говорит ему «мы с моим потоком хотели бы отказаться от выделенного нам ресурса процессорного времени, сейчас и ещё на вот столько-то миллисекунд в будущем. Отдайте бедным!». Слегка удивлённый подобной щедростью планировщик выносит функции благодарность от имени процессора, отдаёт оставшийся кусок времени следующему желающему (а такие всегда найдутся) и не включает вызвавший Sleep поток в претенденты на передачу ему контекста выполнения на указанное количество миллисекунд. Красота!
Что же могло пойти не так? То, что программисты используют эту замечательную функцию не для того, для чего она предназначена.
А предназначена она для программной симуляции какого-то внешнего, определённого чем-то реальным, процесса паузы.
### Корректный пример №1
Мы пишем приложение «часы», в котором раз в секунду нужно менять цифру на экране (или положение стрелки). Функция Sleep здесь подходит как нельзя лучше: нам реально нечего делать чётко определённый промежуток времени (ровно одну секунду). Почему бы и не поспать?
### Корректный пример №2
Мы пишем контроллер ~~самогонного аппарата~~ хлебопечки. Алгоритм работы задаётся одной из программ и выглядит примерно так:
1. Перейти в режим 1.
2. Проработать в нём 20 минут
3. Перейти в режим 2.
4. Проработать в нём 10 минут
5. Выключиться.
Здесь тоже всё чётко: мы работаем со временем, оно задано технологическим процессом. Использование Sleep — приемлемо.
А теперь посмотрим на примеры неверного использования Sleep.
Когда мне нужен какой-то пример некорректного кода на С++ — я иду в [репозиторий](https://github.com/notepad-plus-plus/notepad-plus-plus) кода текстового редактора Notepad++. Его код ужасен настолько, что любой антипаттерн там точно найдётся, я об этом даже [статью](https://habr.com/company/infopulse/blog/185144/) когда-то писал. Не подвёл меня ноутпадик++ и в этот раз! Давайте посмотрим, как в нём используется Sleep.
### Плохой пример №1
При старте Notepad++ проверяет, не запущен ли уже другой экземпляр его процесса и, если это так, ищет его окно и отправляет ему сообщение, а сам закрывается. Для детектирования другого своего процесса используется стандартный способ — глобальный именованный мьютекс. Но вот для поиска окон написан следующий код:
```
if ((!isMultiInst) && (!TheFirstOne))
{
HWND hNotepad_plus = ::FindWindow(Notepad_plus_Window::getClassName(), NULL);
for (int i = 0 ;!hNotepad_plus && i < 5 ; ++i)
{
Sleep(100);
hNotepad_plus = ::FindWindow(Notepad_plus_Window::getClassName(), NULL);
}
if (hNotepad_plus)
{
...
}
...
}
```
Программист, писавший этот код, попытался найти окно уже запущенного Notepad++ и даже предусмотрел ситуацию, когда два процесса были запущены буквально одновременно, так что первый из них уже создал глобальный мьютекс, но ещё не создал окно редактора. В этом случае второй процесс будет ждать создания окна «5 раз по 100 мс». В итоге мы или не дождёмся вообще, или потеряем до 100 мс между моментом реального создания окна и выходом из Sleep.
Это и есть первый (и один из главных) антипаттернов использования Sleep. Мы ждём не наступление события, а «сколько-то миллисекунд, вдруг повезёт». Ждём столько, чтобы с одной стороны не очень раздражать пользователя, а с другой стороны — иметь шанс дождаться нужного нам события. Да, пользователь может не заметить паузы в 100 мс при старте приложения. Но если подобная практика «ждать сколько-нибудь от балды» будет принята и допустима в проекте — закончиться это может тем, что ждать мы будем на каждом шагу по самым мелочным причинам. Здесь 100 мс, там ещё 50 мс, а здесь вот 200 мс — и вот у нас программа уже «почему-то тормозит несколько секунд».
Кроме того, просто эстетически неприятно видеть код, работающий долго в то время, как он мог бы работать быстро. В данном конкретном случае можно было бы использовать функцию [SetWindowsHookEx](https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-setwindowshookexa), подписавшись на событие HSHELL\_WINDOWCREATED — и получить нотификацию о создании окна мгновенно. Да, код становиться чуть сложнее, но буквально на 3-4 строки. И мы выигрываем до 100 мс! А самое главное — мы больше не используем функции безусловного ожидания там, где ожидание не является безусловным.
### Плохой пример №2
```
HANDLE hThread = ::CreateThread(NULL, 0, threadTextTroller, &trollerParams, 0, NULL);
int sleepTime = 1000 / x * y;
::Sleep(sleepTime);
```
Я не очень разбирался, чего конкретно и как долго ждёт этот код в Notepad++, но общий антипаттерн «запустить поток и подождать» я видел часто. Люди ждут разного: начала работы другого потока, получения из него каких-то данных, окончания его работы. Плохо здесь сразу два момента:
1. Многопоточное программирование нужно для того, чтобы делать что-то многопоточно. Т.е. запуск второго потока предполагает, что мы что-то продолжим делать в первом, в это время второй поток выполнит другую работу, а первый, закончив свои дела (и, возможно, ещё немного подождав), получит её результат и как-то его использует. Если мы начинаем «спать» сразу же после запуска второго потока — зачем он вообще нужен?
2. Ожидать нужно правильно. Для правильного ожидания существуют проверенные практики: использование событий, wait-функций, вызов колбеков. Если мы ждём начала работы кода во втором потоке — заведите для этого событие и сигнальте его во втором потоке. Если мы ждём завершения работы второго потока — в С++ есть замечательный класс thread и его метод join (ну или опять-таки платформенно-зависимые способы типа WaitForSingleObject и HANDLE в Windows). Ждать выполнения работы в другом потоке «сколько-то миллисекунд» попросту глупо, поскольку если у нас не ОС реального времени — никто вам не даст никакой гарантии за сколько времени тот второй поток запустится или дойдёт до какого-то этапа своей работы.
### Плохой пример №3
Здесь мы видим фоновый поток, который спит в ожидании каких-то событий.
```
class CReadChangesServer
{
...
void Run()
{
while (m_nOutstandingRequests || !m_bTerminate)
{
::SleepEx(INFINITE, true);
}
}
...
void RequestTermination()
{
m_bTerminate = true;
...
}
...
bool m_bTerminate;
};
```
Нужно признать, что здесь используется не Sleep, а [SleepEx](https://docs.microsoft.com/en-us/windows/desktop/api/synchapi/nf-synchapi-sleepex), который более интеллектуален и может прерывать ожидание при некоторых событиях (типа завершения асинхронных операций). Но это нисколько не помогает! Дело в том, что цикл while (!m\_bTerminate) имеет полное право работать бесконечно, игнорируя вызванный из другого потока метод RequestTermination(), сбрасывающий переменную m\_bTerminate в true. О причинах и следствия этого я писал в [предыдущей статье](https://habr.com/company/infopulse/blog/424729/). Для избегания этого следовало бы использовать что-то, гарантированно правильно работающее между потоками: atomic, event или что-то подобное.
Да, формально SleepEx не виноват в проблеме использования обычной булевой переменной для синхронизации потоков, это отдельная ошибка другого класса. Но почему она стала возможной в этом коде? Потому, что сначала программист подумал «тут надо спать», а затем задумался как долго и по какому условию прекратить это делать. А в правильном сценарии у него даже и не должно было бы возникнуть первой мысли. В голове должно была бы возникнуть мысль «тут надо ожидать события» — и вот с этого момента мысль уже бы работала в сторону выбора правильного механизма синхронизации данных между потоками, который исключил бы как булевскую переменную, так и использование SleepEx.
### Плохой пример №4
В этом примере мы посмотрим на функцию backupDocument, которая выполняет роль «автосохранялки», полезной на случай непредвиденного падения редактора. По-умолчанию она спит 7 секунд, затем даёт команду сохранить изменения (если они были).
```
DWORD WINAPI Notepad_plus::backupDocument(void * /*param*/)
{
...
while (isSnapshotMode)
{
...
::Sleep(DWORD(timer));
...
::PostMessage(Notepad_plus_Window::gNppHWND, NPPM_INTERNAL_SAVEBACKUP, 0, 0);
}
return TRUE;
}
```
Интервал поддаётся изменению, но не в этом беда. Любой интервал будет одновременно слишком большим и слишком малым. Если мы набираем одну букву в минуту — нет никакого смысла спать всего 7 секунд. Если мы откуда-то копипастим 10 мегабайт текста — не нужно ждать после этого ещё 7 секунд, это достаточно большой объём, чтобы инициировать бекап немедленно (вдруг мы его откуда-то вырезали и там его не осталось, а редактор через секунду крешнется).
Т.е. простым ожиданием мы здесь заменяем отсутствующий более интеллектуальный алгоритм.
### Плохой пример №5
Notepad++ умеет «набирать текст» — т.е. эмулировать ввод текста человеком, делая паузы между вставкой букв. Вроде бы писалось это как «пасхальное яйцо», но можно придумать и какое-нибудь рабочее применение этой фиче (~~дурить Upwork, ага~~).
```
int pauseTimeArray[nbPauseTime] = {200,400,600};
const int maxRange = 200;
...
int ranNum = getRandomNumber(maxRange);
::Sleep(ranNum + pauseTimeArray[ranNum%nbPauseTime]);
::SendMessage(pCurrentView->getHSelf(), SCI_DELETEBACK, 0, 0);
```
Беда здесь в том, что в код вшито представление о каком-то «среднем человеке», делающем паузу 400-800 мс между каждой нажатой клавишей. Ок, может это «в среднем» и нормально. Но вы знаете, если используемая мною программа делает какие-то паузы в своей работы просто потому, что они кажутся ей красивыми и подходящими — это совсем не значит, что я разделяю её мнение. Мне хотелось бы иметь возможность настройки длительности данных пауз. И, если в случае Notepad++ это не очень критично, то в других программах мне иногда встречались настройки типа «обновлять данные: часто, нормально, редко», где «часто» не было для меня достаточно часто, а «редко» — не было достаточно редко. Да и «нормально» не было нормально. Подобный функционал должен давать пользователю возможность точно указать количество миллисекунд, который он хотел бы ждать до выполнения нужного действия. С обязательной возможностью ввести «0». Причём 0 в данном случае вообще не должен даже передаваться аргументом в функцию Sleep, а просто исключать её вызов (Sleep(0) на самом деле не возвращается мгновенно, а отдаёт оставшийся кусок выданного планировщиком временного слота другому потоку).
Выводы
------
С помощью Sleep можно и нужно выполнять ожидание тогда, когда это именно безусловно заданное ожидание в течение конкретного промежутка времени и есть какое-то логическое объяснение, почему он такой: «по техпроцессу», «время рассчитано вот по этой формуле», «столько ждать сказал заказчик». Ожидание каких-то событий или синхронизация потоков не должны реализовываться с использованием функции Sleep. | https://habr.com/ru/post/427843/ | null | ru | null |
# Кибергруппа Turla использует Metasploit в кампании Mosquito
Turla – известная кибершпионская группировка, действующая не менее десяти лет. Первое упоминание группы датировано 2008 годом и связано с взломом [Министерства обороны США](https://www.nytimes.com/2010/08/26/technology/26cyber.html?_r=1&ref=technology). Впоследствии Turla приписывали многочисленные инциденты информационной безопасности – атаки на органы государственного управления и стратегические отрасли, включая [оборонную промышленность](https://www.melani.admin.ch/melani/en/home/dokumentation/reports/technical-reports/technical-report_apt_case_ruag.html).
В январе 2018 года мы опубликовали [первый отчет](https://habr.com/company/eset/blog/352784/) о новой кампании Turla по распространению бэкдора Mosquito и [индикаторы заражения](https://github.com/eset/malware-ioc/tree/master/turla#mosquito-indicators-of-compromise). Кампания все еще активна; злоумышленники сменили тактику, чтобы избежать обнаружения.
С марта 2018 года мы наблюдаем значительные изменения в этой кампании – теперь Turla использует для распространения Mosquito фреймворк с открытым исходным кодом Metasploit. Это не первый случай, когда Turla отказывается от собственных инструментов – ранее мы видели использование утилит для извлечения учетных данных (Mimikatz). Но здесь примечательно, что Turla впервые использует Metasploit как бэкдор первого этапа атаки вместо своих разработок, таких как [Skipper](https://labs.bitdefender.com/wp-content/uploads/downloads/pacifier-apt/).
### Распространение
Как мы рассказывали в [предыдущем отчете](https://habr.com/company/eset/blog/352784/), вектор заражения целевых устройств в текущей кампании Turla – поддельный установщик, загружающий один из бэкдоров группы вместе с легитимным Adobe Flash Player. Приоритетные цели – консульства и посольства стран Восточной Европы.
Компрометация осуществляется, когда пользователь загружает установщик Flash с get.adobe.com через HTTP. Трафик перехватывается между конечным устройством и серверами Adobe, что позволяет операторам Turla заменить легитимный файл троянизированной версией. На рисунке ниже показаны точки, в которых **теоретически** можно перехватить трафик. **Обратите внимание, что пятый сценарий – компрометация Adobe/Akamai – исключен. Атакующие лишь использовали бренд Adobe для обмана пользователей.**
Мы не установили точку перехвата трафика, но обнаружили новый исполняемый файл, имитирующий легитимный установщик Flash, под названием `flashplayer28_xa_install.exe`. Таким образом, первоначальный способ компрометации все еще используется.
### Анализ
В начале марта 2018 года, в рамках работы по отслеживанию активности Turla, мы заметили изменения в кампании по распространению Mosquito. Несмотря на то, что группа не использует какие-либо новаторские инструменты, это серьезный сдвиг в ее тактике, технике и процедурах (ТТР).
Ранее цепь компрометации включала поддельный установщик Flash, сбрасывающий загрузчик и главный бэкдор (см. рисунок ниже).
В последнее время мы наблюдаем, что изменился способ сброса последнего бэкдора. В кампании по-прежнему задействован фейковый установщик Flash, но, вместо того, чтобы напрямую сбросить две вредоносные DLL, он выполняет шеллкод Metasploit и сбрасывает или загружает с Google Drive легитимный установщик. Затем шеллкод загружает Meterpreter – [типичную полезную нагрузку Metasploit](https://www.offensive-security.com/metasploit-unleashed/about-meterpreter/), – открывая злоумышленнику доступ к скомпрометированной системе. Наконец, на рабочую станцию устанавливается бэкдор Mosquito. Новая схема – на рисунке ниже.
В связи с использованием Metasploit мы можем предположить, что оператор управляет процессом вручную. Продолжительность атаки сравнительно небольшая – последний бэкдор сброшен в течение тридцати минут после начала попытки компрометации.
Используемый шеллкод типичен для Metasploit. Он защищен с помощью [кодера shikata\_ga\_nai](http://ttp://radare.today/posts/unpacking-shikata-ga-nai-by-scripting-radare2/) с семью итерациями. На скриншотах ниже показана зашифрованная и расшифрованная полезная нагрузка.
После расшифровки шеллкод связывается с C&C-сервером по адресу [209.239.115](https://209.239.115)[.]91/6OHEJ, управляющим загрузкой дополнительного шеллкода. По данным телеметрии ESET, на следующем этапе загружается Meterpreter. Этот IP-адрес соответствует домену psychology-blog.ezua[.]com, который использовался в кампании Mosquito с октября 2017 года.
Далее поддельный установщик Flash загружает легитимный инсталлер Adobe с a Google Drive URL и выполняет его, чтобы пользователь ничего не заподозрил.
### Дополнительные инструменты
В дополнение к новому фейковому установщику и Meterpreter мы заметили, что Turla использует дополнительные инструменты:
* Кастомный исполняемый файл, который содержит только шеллкод Metasploit. Используется для поддержания доступа к сессии Meterpreter. Сохраняется в
```
C:\Users\\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\msupdateconf.exe
```
, что обеспечивает персистентность.
* Другой кастомный исполняемый файл для выполнения скриптов PowerShell.
* Jscript-бэкдор Mosquito, использующий в качестве C&C-сервера Google Apps Script.
* Повышение привилегий с помощью модуля Metasploit [ext\_server\_priv.x86.dll](https://github.com/rapid7/meterpreter/tree/master/source/extensions/priv/server/elevate).
### Выводы
В посте описана эволюция кампании Turla по распространению Mosquito в последние несколько месяцев. Главное изменение – использование Metasploit, популярного фреймворка для тестирования на проникновение, в качестве первого этапа кастомного бэкдора Mosquito.
### Индикаторы компрометации
C&C
• [209.239.115](https://209.239.115)[.]91/6OHEJ
• [70.32.39](https://70.32.39)[.]219/n2DE3
Ссылка на легитимный установщик Flash
• [drive.google](https://drive.google)[.]com/uc?authuser=0&id=1s4kyrwa7gCH8I5Z1EU1IZ\_JaR48A7UeP&export=download | https://habr.com/ru/post/412667/ | null | ru | null |
# Система управления проектами по модели Open Core в госсекторе
Продолжаем рассказывать вам об опенсорсных продуктах реализованных на JS фреймворке — **IONDV. Framework**. Сегодня поговорим о системе управления проектами, которая была одним из наших первых масштабных проектов и которую изначально мы реализовали для правительства Хабаровского края России. А сейчас веб-приложение открыто на [GitHub](https://github.com/iondv/pm-gov-ru) под лицензией *Apache 2.0*. Система которую мы создали в большей степени заточена под региональный госсектор, поэтому она обладает соответствующей структурой метаданных и набором функций. Но мы не видим существенных препятствий, которые помешали бы доработать систему под конкретные задачи, да и использовать её по назначению никто не запрещает.
Прежде чем делиться опытом, ответим на очевидные на первый взгляд вопросы. Что это такое и зачем? Искать готовую или делать свою? И приведем наш опыт реализации технического решения.
### Что и зачем?
Что же такое система управления проектной деятельности и зачем она вам нужна? Это набор организационных и технологических методов и инструментов, которые управляют и поддерживают проекты организации и повышают качество и эффективность их реализации. *Для тех, кто в теме, ничего нового я тут не сказала и можете сразу скролить к технической части статьи.* Система позволяет повысить качество управления всеми проектами и увеличить коэффициент успешных проектов, которые укладываются во временные и бюджетные рамки. Также для руководителя это может стать инструментом для контроля загруженности сотрудников над проектами, впоследствии это позволит экономно распределить ресурсы на наиболее приоритетный или отстающий по срокам проект. Не забывайте, что чтобы не допустить фатальных ошибок очень важно видеть целую картину проекта. Это позволит вовремя среагировать, изменить тактику и принять верное управленческое решение.
Кстати для совсем дотошных — реализовывали по нормативке, она длинная — в спойлере.
**Нормативка**C учетом Постановления Правительства РФ от 31 октября 2018 г. № 1288 "Об организации проектной деятельности в Правительстве Российской Федерации" и Методических рекомендаций по внедрению проектного управления в органах исполнительной власти утвержденных распоряжением Минэкономразвития России от 14 апреля 2014 г.No26Р-АУ.
### Из коробки или разработка с нуля?
Рынок программного обеспечения насыщен большим количеством готовых современных решений. Как говорится, велосипед уже изобретен. Но кто сказал, что нельзя его модернизировать по своему усмотрению? Мы пришли к компромиссу разработки с нуля и системы «из коробки». Информационная система так или иначе собирается под конкретные нужды, но не с нуля, а из готовых компонентов, как условный конструктор. Только пользователь решает, что будет в нее входить, а что нет, а разработчик решает при помощи каких компонентов это реализовать. Четко сформулированные требования и ожидания от информационной системы обеспечивают ожидаемый результат.
Сроки реализации такого решения значительно ниже, чем у разработки с нуля, да и нет проблем с жесткими ограничениями настройки и возможностей перепрограммирования. А самое главное, содержать такую систему проще и дешевле. Ну а так как она находится в открытом доступе на [GitHub](https://github.com/iondv/pm-gov-ru), то это еще и бесплатно.
Кстати мы сами же и используем этот метод. Когда встал вопрос реализации подобной системы, мы собрали прототип с метаданными за неделю и ещё неделю потратили, чтобы создать новый модуль диаграммы Гантта — готовый фреймворк прикрутили к АПИ ядра.
Этот каркас уже был работоспособным прототипом. И все что делали в дальнейшем — это бесконечно переделывали метаданные по все новым и новым требованиям. "А ещё вот здесь — ползунок должен быть в виде прогресс-бара...".
#### Тех детали
> Приложение IONDV. Project-management реализовано на основе собственной технологии **IONDV. Framework**. Это опенсорс фреймворк на node.js по созданию высокоуровневых веб-приложений на основе метаданных, что не требует серьезных навыков программирования. Основа фреймворка это независимая модель данных, API ядра, функциональные модули и шаблоны представлений. Для СУБД используется MongoDb — в ней хранятся настройки приложения, метаданные и сами данные. Фреймворк запускается в среде Node.js. Все вместе обеспечивает кроссплатформенность фреймворка.
>
> Сочетание IONDV. Studio + IONDV. Framework + IONDV. Apps (билдер приложения из репозитория) — является системой быстрого прототипирования. В которой можно получить веб-приложение для отработки бизнес-логики и структуры данных, безопасности и готовым REST API — чтобы потом править фронт с любимым ангуляром или реактом. И SOAP — чтобы отрабатывать интеграцию.
### Процесс подготовки системы
Работа над системой проходила по устоявшемуся технологическому процессу в 4 этапа: подготовка, реализация, коррекция и приемка.
Гляньте нашу простую инфографику, где мы рисуем суть процесса работы с заказчиком.
### Детали
В системе управления проектами используются функциональные модули такие как: модуль бизнес-процессов, модуль отчетов и анализа, модуль диаграммы Гантта, модуль графов, геомодуль, модуль личного кабинета, модуль облачного хранилища — они все доступны на [гитхаб](http://github.com/iondv). На этапе реализации системы, эти готовые модули позволяют дополнить функционал системы под конкретную сферу деятельности и ускорить реализацию бизнес-логики и быстро начать собирать custdev. Иногда мы создаем новые модули по собственной инициативе или для решения рабочих задач, поэтому банк готовых модулей постоянно пополняется.
Система управления проектами это веб-приложение, но с фреймворком nw.js мы пробовали делать из него и десктоп приложение.
#### Что включает IONDV. Project managment?
* Учет проектов и мероприятий
* Разделение прав и безопасности
* Бюджетирование
* Мониторинг объектов
* Визуализация географических данных
* Печатные формы
* Сбор отчетной информации
* График Гантта
* Хранение проектных документов в файловом хранилище.
Как итог, система с достаточно простым интерфейсом, в котором ведется работа с модулями для решения ключевых задач: создание проекта, мониторинг, управление всеми видами показателей на любой стадии его развития. Хранение файлов и совместная работа с документами возможны благодаря облачному хранилищу — *Nextcloud*. Плюс, есть возможность подключения бесплатной версии *collabora online* для совместного редактирования документов онлайн. Покажем на примере, как это выглядит в пользовательском режиме. Кстати можете потестить это в демке. В карточке проекта, в разделе «Сведения» опускаемся вниз до поля «Файлы» и нажимаем на кнопку со значком «sharing».
Формируется ссылка, нажимаем галочку «Разрешить на редактирование» и voilà файл доступен для совместного редактирования.
Кстати, мы записали [видео](https://www.youtube.com/watch?v=AsY2D5quPQs&feature=youtu.be) где рассказываем как заводить проекты и мероприятия в системе и показали базовый функционал. ~~Ставьте лайки, подписывайтесь на канал,~~ ну вы поняли, посмотрите.
В системе управления проектами, ключевым классом конечно же является класс «project», который в формате JSON выглядит вот так:
```
{
"isStruct": false,
"key": [
"guid"
],
"semantic": "name| ( |code| )",
"name": "project",
"version": "31",
"caption": "Региональный проект",
"ancestor": "basicObj",
"container": null,
"creationTracker": "",
"changeTracker": "",
"history": 0,
"journaling": true,
"compositeIndexes": null,
"properties": [
{
"orderNumber": 20,
"name": "code",
"caption": "Код мероприятия",
"type": 0,
"size": null,
"decimals": 0,
"allowedFileTypes": null,
"maxFileCount": 0,
"nullable": false,
"readonly": false,
"indexed": true,
"unique": true,
"autoassigned": true,
"hint": "Наименование проекта на английском или траснлитом. Состоит только из букв английского алфавита. Является уникальным идентификатором проекта.",
"defaultValue": {"if": ["$basicObj", {"concat": ["$basicObj.project_code", "-", {"next": ["$basicObj.project_code"]}]}, ""]},
"refClass": "",
"itemsClass": "",
"backRef": "",
"backColl": "",
"binding": "",
"semantic": null,
"selConditions": [],
"selSorting": [],
"selectionProvider": null,
"indexSearch": false,
"eagerLoading": false,
"formula": null
},
{
"orderNumber": 30,
"name": "project_code",
"caption": "project_code [вычислимое, храним код проекта]",
"type": 0,
"size": null,
"decimals": 0,
"allowedFileTypes": null,
"maxFileCount": 0,
"nullable": false,
"readonly": false,
"indexed": true,
"unique": false,
"autoassigned": true,
"hint": null,
"defaultValue": {"if": ["$basicObj", "$basicObj.project_code", "$code"]},
"refClass": "",
"itemsClass": "",
"backRef": "",
"backColl": "",
"binding": "",
"semantic": null,
"selConditions": [],
"selSorting": [],
"selectionProvider": null,
"indexSearch": false,
"eagerLoading": false,
"formula": null
},
```
Мы уже рассказывали вам, что классы метаданных могут наследоваться. Для них отдельно задаются представления, отличающиеся по разным шагам бизнес-процессов и многое другое. В свойстве properties перечислен список атрибутов. У этого класса 40+ атрибутов. [Подробнее](https://github.com/iondv/framework/blob/master/docs/ru/index.md) о метаданных. А глубина наследования — 7-мь уровней: базовый объект/проект/блок мероприятий/мероприятие/мероприятие объекта/мероприятие развитие объекта/контрольная точка. А есть ещё ответвления наследников. Большая семья...
Функции мониторинга показателей проектов реализованы модулем Портала:
В нём же реализуются АРМы по ролям, например АРМ Куратора проектов.
Особенностью проекта является — специальные шаблоны со сводной информацией по проекту.
Реализовано это в виде небольших шаблонов. Причем источниками данных являются:
* API объектов — самый медленный.
* Закешированные вычисления самого проекта, изменяемые при его сохранении.
* API модуля отчетов — данные вычисляются по расписанию — самый быстрый способ.
Например информер прогресса:
```
<%
let value = parseInt(item.property('progress').getValue()) || 0;
value = value < 0 ? 0 : value > 100 ? 100 : value;
let text = value === 100 ? 'Готов' : `${value}%`;
let css = value === 100 ? 'ready' : ``;
%>
<%- text %>
```
А вот так шаблон подключается вместо атрибута:
```
{
"caption": "Общий прогресс",
"type": 7,
"property": "totalProgress",
"size": 12,
"options": {
"template": "attrs/project/totalProgress"
}
}
```
### Где посмотреть и потрогать?
Под линуксом установить приложение можно одной строкой, если локально стоит git, node.js и mongodb с использованием установщика iondv-app. Скрипт поставит зависимости окружения, склонирует все необходимые репоизтории фреймворка, модулей и приложения из GitHub, соберет, инициирует и запустит приложение:
```
bash <(curl -sL https://raw.githubusercontent.com/iondv/iondv-app/master/iondv-app) -q -i -m localhost:27017 pm-gov-ru
```
Где вместо localhost:27017 нужно указать адрес MongoDb. Обратите внимание, что система ожидает nextcloud, доступный по адресу <http://localhost:8080> и с учетной записью demo, пароль ion-demo.
Также можно запустить докер контейнер:
```
# Создайте сеть для приложений
docker network create iondv
# Запустите СУБД mongodb в этой сети
docker run --name mongodb --net iondv -v mongodb_data:/data/db -p 27017:27017 -d mongo
# Запустите и инициализируйте nextcloud (curl посылает POST Запрос для инициализации конейнера
docker run -d --name nextcloud --net iondv -p 8080:80 nextcloud && \
sleep 120 && \
docker exec -it nextcloud curl -X POST --connect-timeout 90 -k -s -d "install=true&adminlogin=demo&adminpass=ion-demo&adminpass-clone=ion-demo&directory=/var/www/html/data&dbtype=sqlite&dbhost=localhost" -H "Host: nextcloud" http://localhost:80
# Запустите IONDV. PM-GOV
docker run -d -p 8888:8888 --net iondv iondv/pm-gov-ru
```
После запуска открыть ссылку *<http://localhost:8888>*. Для бек офиса логин: demo, пароль: ion-demo с правами администратора. Второй пользователь с ограниченными правами оператора operator пароль ion-demo.
Смотрите также [руководство пользователя](https://github.com/iondv/pm-gov-ru/blob/master/manuals/RP_pm.docx) приложения.
Протестируйте [демо-приложение](https://pm-gov-ru.iondv.com). Логин – demo, пароль — ion-demo.
Демо включает в себя модуль Гантта и иерархическое представление справочников показателей (TreeGrid из дополнительного приложения viewlib-extra) в ряде объектов. К сожалению, эти модули содержат проприетарные компоненты и мы не в силах опубликовать их на GitHub (помните мы торопились чтобы показать прототип???), поэтому версия приложения и публичный докер контейнер их не содержат.
### Дальнейшее развитие
Решение о внедрении системы управления проектами это многосторонний процесс, который часто зависит от не очевидных на первый взгляд факторов. Выбор системы это также выбор команды которая поможет вам ее внедрить. Если вы уверены в своих силах и коллегах, то действуйте, а мы вас поддержим технически и *морально*.
Все усилия и затраты окупятся, когда благодаря системе вы начнете более эффективно распоряжаться временными, человеческими и финансовыми ресурсами для достижения поставленных целей компании. А главное вы можете все переделать — именно так как это работает у вас.
Надеемся, что вы почерпнули для себя какие-то идеи для дальнейшего развития и мы показали вам, что необязательно платить нескромную сумму за систему, которую вы можете собрать и доработать сами. Интересно услышать ваше мнение, насколько вообще вы считаете подобную *Open Core* модель жизнеспособной в современных условиях, особенно с такими тяжеловесными системами, наподобие **IONDV. Project-management**. | https://habr.com/ru/post/459578/ | null | ru | null |
# 10 шагов к YAML-дзену
Мы все любим Ansible, но Ansible – это YAML. Для конфигурационных файлов существует масса форматов: списки значений, пары «параметр-значение», INI-файлы, YAML, JSON, XML и множество других. Однако по нескольким причинам из всех них YAML часто считается особенно трудным. В частности, несмотря на его освежающий минимализм и впечатляющие возможности для работы с иерархическими значениями, синтаксис YAML может раздражать своим Python-образными подходом к отступам.
Если вас бесит YAML, вы можете – и должны! – предпринять 10 следующих шагов, чтобы снизить свое раздражение до приемлемого уровня и полюбить YAML. Как и положено настоящему списку, наша десятка советов будет нумероваться с нуля, медитацию и духовные практики добавляем по желанию ;-)
### 0. Заставьте ваш редактор работать
Неважно, какой у вас текстовый редактор – для него наверняка существует хотя бы один плагин для работы с YAML. Если у вас такого нет, немедленно найдите и установите. Потраченное на поиск и настройку время будет многократно окупаться каждый раз, когда вам придется редактировать YAML.
Например, редактор [Atom](http://atom.io/) поддерживает YAML по умолчанию, а вот для GNU Emacs придется установить дополнительные пакеты, например, [yaml-mode](https://github.com/yoshiki/yaml-mode).
*Emacs в режиме YAML и отображения пробелов.*
Если в вашем любимом редакторе нет режима YAML, то часть проблем можно решить, поработав с настройками. Например, штатный для GNOME текстовый редактор Gedit не имеет режима YAML, но по умолчанию подсвечивает синтаксис YAML и позволяет настроить работу с отступами:
*Настройка отступов в Gedit.*
А плагин [drawspaces](https://wiki.gnome.org/Apps/Gedit/ShippedPlugins) для Gedit отображает пробелы в виде точек, устраняя неясности с уровнями отступа.
Иными словами, потратьте время на изучение своего любимого редактора. Выясните, что он сам или его сообщество разработки предлагают для работы с YAML, и используйте эти возможности. Вы точно об этом не пожалеете.
### 1. Используйте линтер (linter)
В идеале языки программирования и языки разметки используют предсказуемый синтаксис. Компьютеры хорошо справляются с предсказуемостью, поэтому еще в 1978 году возникла концепция [линтера](https://ru.wikipedia.org/wiki/Lint). Если за 40 лет своего существования она прошла мимо вас и вы до сих пор не пользуетесь YAML-линтером, то самое время попробовать yamllint.
Установить [yamllint](https://pypi.org/project/yamllint/) можно с помощью штатного менеджера пакетов Linux. Например, в [Red Hat Enterprise Linux](https://www.redhat.com/en/technologies/linux-platforms/enterprise-linux) 8 или [Fedora](https://getfedora.org/) это делается так:
```
$ sudo dnf install yamllint
```
Затем вы просто запускаете yamllint, передавая ему YAML-файл для проверки. Вот как это выглядит, если передать линтеру файл с ошибкой:
```
$ yamllint errorprone.yaml
errorprone.yaml
23:10 error syntax error: mapping values are not allowed here
23:11 error trailing spaces (trailing-spaces)
```
Цифры слева – это не время, а координаты ошибки: номер строки и столбца. Описание ошибки может вам ни о чем не говорить, зато вы точно знаете, где она находится. Просто посмотрите на это место в коде, и, скорее всего, все станет ясно.
Когда yamllint не находит ошибок в файле, на экран ничего не выводится. Если вас пугает такая тишина и хочется немного больше обратной связи, то можно запускать линтер с условной командой echo через двойной амперсанд (&&), вот так:
```
$ yamllint perfect.yaml && echo "OK"
OK
```
В POSIX двойной амперсанд срабатывает тогда и только тогда, когда предшествующая команда возвращает 0. А yamllint как раз возвращает количество найденных ошибок, поэтому вся эта условная конструкция и работает.
### 2. Пишите на Python, а не на YAML
Если вас реально бесит YAML, просто не пишите на нем, в буквальном смысле. Бывает, что YAML – это единственный формат, который воспринимается приложением. Но и в этом случае необязательно создавать YAML-файл. Пишите на том, что вам нравится, а потом конвертируйте. Например, для Python есть отличная библиотека [pyyaml](https://pyyaml.org/) и целых два способа конвертирования: самоконвертирование и конвертирование через скрипты.
#### Самоконвертирование
В этом случае файл с данными заодно является и Python-скриптом, который генерирует YAML. Этот способ лучше всего подходит для небольших наборов данных. Вы просто пишите JSON-данные в переменную Python, предваряете это директивой import, а в конце файла добавляете три строчки для реализации вывода.
```
#!/usr/bin/python3
import yaml
d={
"glossary": {
"title": "example glossary",
"GlossDiv": {
"title": "S",
"GlossList": {
"GlossEntry": {
"ID": "SGML",
"SortAs": "SGML",
"GlossTerm": "Standard Generalized Markup Language",
"Acronym": "SGML",
"Abbrev": "ISO 8879:1986",
"GlossDef": {
"para": "A meta-markup language, used to create markup languages such as DocBook.",
"GlossSeeAlso": ["GML", "XML"]
},
"GlossSee": "markup"
}
}
}
}
}
f=open('output.yaml','w')
f.write(yaml.dump(d))
f.close
```
Теперь запускаем это файл на Python-е и на выходе получаем файл output.yaml:
```
$ python3 ./example.json
$ cat output.yaml
glossary:
GlossDiv:
GlossList:
GlossEntry:
Abbrev: ISO 8879:1986
Acronym: SGML
GlossDef:
GlossSeeAlso: [GML, XML]
para: A meta-markup language, used to create markup languages such as DocBook.
GlossSee: markup
GlossTerm: Standard Generalized Markup Language
ID: SGML
SortAs: SGML
title: S
title: example glossary
```
Это абсолютно корректный YAML, но yamllint выдаст предупреждение, что он не начинается с ---. Что ж, это можно легко поправить вручную или слегка доработать Python-скрипт.
#### Конвертирование через скрипты
В этом случае сначала пишем на JSON-е, а затем запускаем конвертор в виде отдельного Python-скрипта, который на выходе дает YAML. По сравнению с предыдущим этот способ лучше масштабируется, поскольку конвертирование отделено данных.
Для начала создадим JSON-файл example.json, например, его можно взять на [json.org](https://json.org/example.html):
```
{
"glossary": {
"title": "example glossary",
"GlossDiv": {
"title": "S",
"GlossList": {
"GlossEntry": {
"ID": "SGML",
"SortAs": "SGML",
"GlossTerm": "Standard Generalized Markup Language",
"Acronym": "SGML",
"Abbrev": "ISO 8879:1986",
"GlossDef": {
"para": "A meta-markup language, used to create markup languages such as DocBook.",
"GlossSeeAlso": ["GML", "XML"]
},
"GlossSee": "markup"
}
}
}
}
}
```
Затем создадим простой скрипт-конвертор и сохраним его под именем json2yaml.py. Этот скрипт импортирует оба модуля — YAML и JSON Python, а также загружает указанный пользователем файл JSON, выполняет конвертирование и пишет данные в файл output.yaml.
```
#!/usr/bin/python3
import yaml
import sys
import json
OUT=open('output.yaml','w')
IN=open(sys.argv[1], 'r')
JSON = json.load(IN)
IN.close()
yaml.dump(JSON, OUT)
OUT.close()
```
Сохраните этот скрипт в system path и запускайте по мере необходимости:
```
$ ~/bin/json2yaml.py example.json
```
### 3. Парсите много и часто
Иногда на проблему полезно взглянуть под другим углом. Если вам трудно представить взаимосвязи между данными в YAML, можно временно преобразовать их в нечто более привычное.
Например, если вам удобно работать со словарными списками или с JSON, то YAML можно преобразовать в JSON всего двумя командами в интерактивной оболочке Python. Допустим, у вас есть YAML-файл mydata.yaml, тогда вот как это будет выглядеть:
```
$ python3
>>> f=open('mydata.yaml','r')
>>> yaml.load(f)
{'document': 34843, 'date': datetime.date(2019, 5, 23), 'bill-to': {'given': 'Seth', 'family': 'Kenlon', 'address': {'street': '51b Mornington Road\n', 'city': 'Brooklyn', 'state': 'Wellington', 'postal': 6021, 'country': 'NZ'}}, 'words': 938, 'comments': 'Good article. Could be better.'}
```
На эту тему можно найти массу других примеров. Кроме того, в наличии множество онлайн-конвертеров и локальных парсеров. Так что не стесняйтесь переформатировать данные, когда видите в них только непонятную мешанину.
### 4. Читайте спеки
Возвращаясь к YAML после долгого перерыва, полезно зайти на [yaml.org](https://yaml.org/spec/1.2/spec.html) и перечитать спецификации (спеки). Если у вас трудности с YAML, но до спецификации руки так и не дошли, то пора эту ситуацию исправлять. Спеки на удивление легко написаны, а требования к синтаксису иллюстрируются большим количеством примеров в [Главе 6](https://yaml.org/spec/1.2/spec.html#Basic).
### 5. Псевдоконфиги
При написании книги или статьи всегда полезно сперва набросать предварительный план, хотя бы в виде оглавления. Так же и с YAML. Скорее всего, вы представляете, какие данные надо записать в файл YAML, но не очень понимаете, как связать их друг с другом. Поэтому прежде чем ваять YAML, нарисуйте псевдоконфиг.
Псевдоконфиг похож на псевдокод, где не надо заботиться о структуре или отступах, отношениях «родитель-потомок», наследовании и вложенности. Так и здесь: вы рисуете итерации данных по мере того, как они возникают у вас в голове.
*Псевдоконфиг с перечислением программистов (Martin и Tabitha) и их навыков (языков программирования: Python, Perl, Pascal и Lisp, Fortran, Erlang, соответственно).*
Нарисовав псевдоконфиг на листе бумаги, внимательно проанализируйте его и, если все в порядке, оформите в виде валидного YAML-файла.
### 6. Дилемма «табуляция или пробелы»
Вам придется решить дилемму [«табуляция или пробелы?»](https://opensource.com/article/18/9/spaces-poll). Не в глобальном смысле, а лишь на уровне вашей организации, или хотя бы проекта. Неважно, будет ли при этом использоваться пост-обработка скриптом sed, настройка текстовых редакторов на машинах программистов или же поголовное взятие расписок о строгом соблюдении указаний линтера под угрозой увольнения, но все члены вашей команды, которые так или иначе касаются YAML, в обязательном порядке должны использовать только пробелы (как того требует спецификация YAML).
В любом нормальном текстовом редакторе можно настроить автозамену табуляции на заданное количество пробелов, поэтому бунта приверженцев клавиши **Tab** можно не бояться.
Как хорошо известно каждому ненавистнику YAML, на экране не видно разницы между табуляцией и пробелами. А когда чего-то не видно, об этом, как правило, вспоминают в последнюю очередь, после того, как перебрали, проверили и устранили все остальные возможные проблемы. Час времени, убитый на поиск кривой табуляции или блока пробелов, просто вопиет о том, что вам над срочно создать политику использования того или другого, а затем реализовать железобетонную проверку ее соблюдения (например, через Git-хук для принудительного прогона через линтер).
### 7. Лучше меньше да лучше (или больше – это меньше)
Некоторые люди любят писать на YAML, поскольку он подчеркивает структуру. При этом они активно используют отступы, чтобы выделять блоки данных. Это такое своего рода жульничество для имитации языков разметки, в которых используются явные разделители.
Вот пример такой структурированности из [документации Ansible](https://docs.ansible.com/index.html?extIdCarryOver=true&sc_cid=701f2000001Css5AAC):
```
# Employee records
- martin:
name: Martin D'vloper
job: Developer
skills:
- python
- perl
- pascal
- tabitha:
name: Tabitha Bitumen
job: Developer
skills:
- lisp
- fortran
- erlang
```
Кому-то такой вариант помогает разложить в голове структуру YAML, других он наоборот раздражает массой ненужных, на их взгляд, отступов.
Но если вы являетесь владельцем YAML-документа и отвечаете за его сопровождение, то *вы и только вы* должны определять, как использовать отступы. Если вас раздражают большие отступы, сведите их к минимуму, который только возможен согласно спецификации YAML. Например, вышеприведенный файл из документации Ansible без каких бы то ни было потерь можно переписать вот так:
```
---
- martin:
name: Martin D'vloper
job: Developer
skills:
- python
- perl
- pascal
- tabitha:
name: Tabitha Bitumen
job: Developer
skills:
- lisp
- fortran
- erlang
```
### 8. Используйте заготовки
Если при заполнении файла YAML вы постоянно повторяете одни и те же ошибки, имеет смысл вставить в него шаблон-заготовку в виде комментария. Тогда в следующий раз можно будет просто скопировать эту заготовку и вписать туда реальные данные, например:
```
---
# - :
# name: Given Surname
# job: JOB
# skills:
# - LANG
- martin:
name: Martin D'vloper
job: Developer
skills:
- python
- perl
- pascal
- tabitha:
name: Tabitha Bitumen
job: Developer
skills:
- lisp
- fortran
- erlang
```
### 9. Используйте что-то другое
Если приложение не держит вас мертвой хваткой, то, возможно, стоит сменить YAML на другой формат. Со временем конфигурационные файлы могут перерастать себя и тогда лучше преобразовать их в простые скрипты на Lua или Python.
YAML – отличная штука, которую многие любят за минимализм и простоту, но это далеко не единственный инструмент в вашем арсенале. Так что иногда от него можно отказаться. Для YAML легко найти библиотеки парсинга, поэтому, если вы предложите удобные варианты миграции, ваши пользователи относительно безболезненно переживут такой отказ.
Если же без YAML никак не обойтись, то возьмите на вооружение эти 10 советов и победите свою неприязнь к YAML раз и навсегда! | https://habr.com/ru/post/462125/ | null | ru | null |
# Что делать, если к вам попал Android со сломанным сенсорным дисплеем
В один прекрасный день ко мне в руки попал Nexus 4. В наших краях это редкость, поэтому хотелось бы использовать его как основной телефон. К сожалению, тач у него разбит. Одна из болячек всех современных смартфонов. Ну, решено было восстанавливать. Купил тач на ebay. Теперь ждать слоупочту россии месяцок-другой. Захотелось узнать о девайсе побольше, поработать с ним, пока посылка едет. Заодно проверить, всё ли работает. А то, может, камера или динамики тоже покрошились. В данной статье рассмотрим захват управления девайсом, если сломан тач.
##### Сведения
В ходе испытания будут использованы nexus 4, usb кабель, ubuntu как ось для работы, информация из интернета и мозги.
Первым делом хочется отметить — телефон полностью в стоковом состоянии. Предыдущий владелец сделал полный сброс всех данных. После включения появляется экран Welcome с выбором языка. Управление устройством никак нельзя осуществить без дальнейшего вмешательства.
Напомню, у nexus 4 нету OTG, поэтому мышь подключить к нему нельзя без специального кабеля с внешним питанием. Такого у меня нету, можно заказать на том же ebay, но опять ждать.
##### Фигачим
Первым делом я поставил CWM.
Устанавливаем программы для работы с андроидами:
```
sudo apt-get install android-tools-adb
```
Это и fastboot, и adb.
Поставить рекавери можно через fastboot:
```
fastboot flash recovery recovery.img
```
Естественно, выбрана notouch версия. Кстати, я еще разблокировал бутлоадер (команда fastboot oem unlock). Поменял прошивку на последнюю сразу. Уже и не помню, зачем. Для других телефонов нужно искать свои инструкции. У каких-то устройств можно поставить через встроенный рекавери, у каких-то есть специальные программы для прошивки.
Загружаемся в CWM. Ищем пункт mounts and storage и монтируем system (или потом сделать это через adb — *mount -o remount,rw /system*). Пригодится.
В консоле на компьютере пишем
```
adb devices
```
Выдает циферки и recovery. То, что и нужно!
Отлично. В наши задачи входит: скипнуть welcome экран и включить usb отладку.
Для этого скачиваем *build.prop* в текущую папку
```
adb pull /system/build.prop ./
```
Открываем скачанный файл и заменяем строку:
```
ro.setupwizard.enterprise_mode=1
```
на
```
ro.setupwizard.enterprise_mode=0
ro.setupwizard.mode=DISABLED
persist.service.adb.enable=1
persist.service.debuggable=1
persist.sys.usb.config=mtp,adb
```
Если считаете нужным, можете подправить еще какие другие строки. Я вроде отключал экран блокировки для удобства, но сейчас уже лень искать какая строка отвечает. Если не сложно, уточните в комментах.
Сохраняем и загружаем обратно.
```
adb push ./build.prop /system/
```
Пропишем последние строки и в *default.prop*. На всякий случай.
```
adb shell
echo "persist.service.adb.enable=1" >> default.prop
echo "persist.service.debuggable=1" >> default.prop
echo "persist.sys.usb.config=mtp,adb" >> default.prop
```
Попробуем перезагрузиться
Экран сбросился.
Однако *adb devices* показывает offline.
Убиваем adb командой
```
adb kill-server
```
Делаем запрос *adb devices*
Всё еще offline. Кажется, приплыли. Но нет! Дело в ключах.
Ищем в домашней дирректории папку */.android*
Там должен был сгенерироваться файл *adbkey.pub*. Его нужно закинуть на девайс.
Перезагружаемся в рекавери, монтируем data, выполняем
```
cd ~/.android
adb push ./adbkey.pub /data/misc/adb/adb_keys
```
Перезагружаемся снова. Смотрим *adb devices* — всё есть!
Далее я, например, прописал кнопкам на нампаде команды *adb shell input keyevent XX*
**Список кодов**0 --> «KEYCODE\_UNKNOWN»
1 --> «KEYCODE\_MENU»
2 --> «KEYCODE\_SOFT\_RIGHT»
3 --> «KEYCODE\_HOME»
4 --> «KEYCODE\_BACK»
5 --> «KEYCODE\_CALL»
6 --> «KEYCODE\_ENDCALL»
7 --> «KEYCODE\_0»
8 --> «KEYCODE\_1»
9 --> «KEYCODE\_2»
10 --> «KEYCODE\_3»
11 --> «KEYCODE\_4»
12 --> «KEYCODE\_5»
13 --> «KEYCODE\_6»
14 --> «KEYCODE\_7»
15 --> «KEYCODE\_8»
16 --> «KEYCODE\_9»
17 --> «KEYCODE\_STAR»
18 --> «KEYCODE\_POUND»
19 --> «KEYCODE\_DPAD\_UP»
20 --> «KEYCODE\_DPAD\_DOWN»
21 --> «KEYCODE\_DPAD\_LEFT»
22 --> «KEYCODE\_DPAD\_RIGHT»
23 --> «KEYCODE\_DPAD\_CENTER»
24 --> «KEYCODE\_VOLUME\_UP»
25 --> «KEYCODE\_VOLUME\_DOWN»
26 --> «KEYCODE\_POWER»
27 --> «KEYCODE\_CAMERA»
28 --> «KEYCODE\_CLEAR»
29 --> «KEYCODE\_A»
30 --> «KEYCODE\_B»
31 --> «KEYCODE\_C»
32 --> «KEYCODE\_D»
33 --> «KEYCODE\_E»
34 --> «KEYCODE\_F»
35 --> «KEYCODE\_G»
36 --> «KEYCODE\_H»
37 --> «KEYCODE\_I»
38 --> «KEYCODE\_J»
39 --> «KEYCODE\_K»
40 --> «KEYCODE\_L»
41 --> «KEYCODE\_M»
42 --> «KEYCODE\_N»
43 --> «KEYCODE\_O»
44 --> «KEYCODE\_P»
45 --> «KEYCODE\_Q»
46 --> «KEYCODE\_R»
47 --> «KEYCODE\_S»
48 --> «KEYCODE\_T»
49 --> «KEYCODE\_U»
50 --> «KEYCODE\_V»
51 --> «KEYCODE\_W»
52 --> «KEYCODE\_X»
53 --> «KEYCODE\_Y»
54 --> «KEYCODE\_Z»
55 --> «KEYCODE\_COMMA»
56 --> «KEYCODE\_PERIOD»
57 --> «KEYCODE\_ALT\_LEFT»
58 --> «KEYCODE\_ALT\_RIGHT»
59 --> «KEYCODE\_SHIFT\_LEFT»
60 --> «KEYCODE\_SHIFT\_RIGHT»
61 --> «KEYCODE\_TAB»
62 --> «KEYCODE\_SPACE»
63 --> «KEYCODE\_SYM»
64 --> «KEYCODE\_EXPLORER»
65 --> «KEYCODE\_ENVELOPE»
66 --> «KEYCODE\_ENTER»
67 --> «KEYCODE\_DEL»
68 --> «KEYCODE\_GRAVE»
69 --> «KEYCODE\_MINUS»
70 --> «KEYCODE\_EQUALS»
71 --> «KEYCODE\_LEFT\_BRACKET»
72 --> «KEYCODE\_RIGHT\_BRACKET»
73 --> «KEYCODE\_BACKSLASH»
74 --> «KEYCODE\_SEMICOLON»
75 --> «KEYCODE\_APOSTROPHE»
76 --> «KEYCODE\_SLASH»
77 --> «KEYCODE\_AT»
78 --> «KEYCODE\_NUM»
79 --> «KEYCODE\_HEADSETHOOK»
80 --> «KEYCODE\_FOCUS»
81 --> «KEYCODE\_PLUS»
82 --> «KEYCODE\_MENU»
83 --> «KEYCODE\_NOTIFICATION»
84 --> «KEYCODE\_SEARCH»
85 --> «TAG\_LAST\_KEYCODE»
Хотя можно просто поставить [VNC сервер](https://play.google.com/store/apps/details?id=com.schumi.vncs) (нужен рут).
Я поставил через adb
```
adb install vncfwq_1386321119498.apk
adb shell am start -n com.schumi.vncs/com.schumi.vncs.VNC_serverActivity
```
С нумпада поставил настройки, включить получилось командой тыка в зону off — *adb shell input tap 400 300* (это координаты тыка)
Ну и чтобы не лезть в настройки вайфай
```
adb forward tcp:5901 tcp:5901
```
Запускаем vnc клиент, вводим *localhost:5901* и делаем всё, что душе угодно.
На этом всё. Прочного вам стекла, уважаемые!
PS: думаю, всё тоже можно сделать с разбитым дисплеем. Нужно только делать скриншоты. [Вроде как мануал](http://forum.xda-developers.com/showthread.php?t=1496213). | https://habr.com/ru/post/210472/ | null | ru | null |
# Тормозит Mac OS? — Catalina проверяет любой неподписанный код через интернет при запуске
Многие пользователи после перехода на Catalina начали жаловаться на тормоза. Западные коллеги выяснили в чем причина: MacOS отправляет хеш любого неподписанного кода на сервера Apple.
Это создает серьезные задержки в выполнении, что можно легко проверить:
```
echo $'#!/bin/sh\necho Hello' > /tmp/test.sh && chmod a+x /tmp/test.sh
time /tmp/test.sh && time /tmp/test.sh
```
Результаты удивляют:
```
$ time /tmp/test.sh && time /tmp/test.sh
Hello
real 0m1.417s
user 0m0.001s
sys 0m0.003s
Hello
real 0m0.003s
user 0m0.001s
sys 0m0.002s
```
Почему так происходит? Apple довольно давно использует механизм [Notarization](https://developer.apple.com/documentation/xcode/notarizing_macos_software_before_distribution) — с его помощью пользователи могут быть уверены, что программа, подписанная валидным Developer-ID не содержит зловредных компонентов. То есть помимо того, что приложение подписано, Apple его еще и автоматически проверит на элементы malware.
Что интересно, в будущем Apple вообще планирует запретить запуск не прошедших нотаризацию программ. Цитата:
> Important
>
>
>
> Beginning in macOS 10.14.5, software signed with a new Developer ID certificate and all new or updated kernel extensions must be notarized to run. Beginning in macOS 10.15, all software built after June 1, 2019, and distributed with Developer ID must be notarized.
Сейчас, видимо, в целях обкатки, любой новый неподписанный код, который вы запускаете, отправляется на сервера AAPL. Это легко проверить, запустив любой сетевой анализатор и увидев обращения к домену api.apple-cloudkit.com. Нужно отметить, что передается не сам код, а хеш-сумма. Проверить это можно двумя способами — сравнить обьем данных, передаваемых по сети, для скриптов разного размера; а также посмотрев на содержимое самого демона, ответственного за пересылку данных (*otool -tV /usr/libexec/syspolicyd*). Тем не менее, при медленном интернет соединении задержки могут составлять секунды — пользователь из Китая пишет о задержке в 5.47 секунд.
С одной стороны Apple можно понять — она заботится о безопасности пользователей, правда, вместе с тем превращая процесс любой разработки на их платформе в ад.
Но я хочу процитировать слова разработчика, который первым обратил внимание на проблему:
Подобное поведение операционной системы свидетельствует о серьезных проблемах в ее дизайне, когда два метода из низкоуровневого системного API (например exec и getxattr) выполняют синхронные сетевые обращения прежде чем вернуть результат.
Ссылки:
[lapcatsoftware.com/articles/catalina-executables.html](https://lapcatsoftware.com/articles/catalina-executables.html)
[news.ycombinator.com/item?id=23275922](https://news.ycombinator.com/item?id=23275922)
[sigpipe.macromates.com/2020/macos-catalina-slow-by-design](https://sigpipe.macromates.com/2020/macos-catalina-slow-by-design/) | https://habr.com/ru/post/503670/ | null | ru | null |
# Солянка
За последнее время скопилось несколько различных мыслей. Надеюсь, какие-то из них покажутся интересными.
Итак, в солянке:
1. Java: что такое `ThreadLocal` и `InheritableThreadLocal`
2. Palm Pre: личные впечатления
3. Android: как развернуть сервер на телефоне
4. Интерфейсы: концепция страницы «про нас»
5. Книжки: впечатления от Pragmatic Thinking and Learning: Refactor Your Wetware
#### 1. Java: что такое `ThreadLocal` и `InheritableThreadLocal`
Cтатические переменные в Java — глобальны. Все, за исключением одной: ThreadLocal. ThreadLocal — это контейнер, в который можно положить значение, специфическое для текущей нити.
Например, пусть у нас есть статическая переменная `Global.threadLocal`. В нити 1 скажем: "`Global.threadLocal.set("Thread1")`". В нити 2 попросим: "`Global.threadLocal.get()`". И нам вернётся значение по умолчанию, а не «Thread1».
`InheritableThreadLocal` расширяет концепцию. Он сохраняет значения, установленные в нити, из которой стартовала текущая. Если бы нить 2 была бы создана из нити 1, то `Global.inheritableThreadLocal.get()` в нити 2, вернуло бы значение из нити 1.
*Бонус:* если надо построить дерево нитей (кто кого создал), то можно перегрузить функцию `childValue()` класса `InheritableThreadLocal`. Она вызывается в точности в момент создания новой нити.
#### 2. Palm Pre: личные впечатления
Не так давно мне удалось порабоать с [Palm Pre](http://en.wikipedia.org/wiki/Palm_Pre). Palm Pre — это новый телефон от Palm. iPhone killer. На самом деле, телефон оказался очень неплохим. Во-первых, добротно сделаная операционная система: очень приятый интерфейс, особенно радует грамотно реализованый мултитач. Во-вторых, отличный набор тулзов для разработчика. Для тех, кто хочет глубоко интегрироваться с системой (на уровне OS) предоставляется SDK и набор хедеров. Для разработчиков обычных аппов — неплохой набор тулзов и эмулятор. Приложения представляют собой довольно интересный гибрид веб-приложений и нативных методов. Платформа сделана очень developer-friendly.
Говорят, что все в Palm очень гордятся продуктом. С моей точки зрения, есть чем гордится.
#### 3. Android: как развернуть сервер на телефоне
На Android, оказывается, можно развернуть сервер. Просто на раз-два.
Там отлично поддерживается [ServerSocket](http://developer.android.com/reference/java/net/ServerSocket.html). То есть, можно создать нить вот с чем-нибудь таким:
> `while ( isRunning )
>
> {
>
> // Ждём нового клиента
>
> final Socket socket = serverSocket.accept();
>
>
>
> // Есть клиент! Всё ли в порядке?
>
> if ( socket != null && socket.isConnected() )
>
> {
>
> // Обрабатываем клинтский сокет
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Для того, чтобы это заработало на локальной машинке, надо включить форвадинг портов. Для этого, надо сказать `adb forward tcp:12345 tcp:54321`, где 12345 — порт, на котором висит серверный сокет на телефоне, а 54321 — порт локальной машинки.
Удивительно, что всё просто работает из коробки и на эмуляторе, и на настоящих дейвайсах.
Пожалуй, стоит лишь предупредить разработчиков об аккуротном закрытие сокетов, `Socket::isClosed()` не всегда адекватно выражает состояние соединения.
#### 4. Интерфейсы: концепция страницы «про нас»
Вот такая идея: на странице «про нас» поместить общую фотографию всех разработчиков. Обводишь мышкой лицо разработчика, а слева появляется информация о том, чем человек занимался. Ну и, может, форма отправки сообщения. Что-то такое:
#### 5. Книжки: впечатления от Pragmatic Thinking and Learning: Refactor Your Wetware
Основная идея книжки: те, кто занимается умственным трудом должны развивать не только «software» мозга, но и «hardware» («wetware», в случае человеков). Постоянно учиться, менять сферы деятельности, запоминать новую информацию, не лениться быть любопытным. Эти активности помогут мозгу не прекращать создавать новые нейронные связи и менять существующие.
Более того, автор продвигает интересный тезис: развите мозга может не прекращаться в определённом возрасте. То есть, при желании, с возрастом можно не растерять остроту мышления и способность учиться новому. Напротив, можно развить мозг так, что он будет эффективно усваивть и обрабатывать информацию.
Очень рекомендую: [Pragmatic Thinking and Learning: Refactor Your Wetware](http://www.amazon.com/Pragmatic-Thinking-Learning-Refactor-Programmers/dp/1934356050/ref=tag_dpp_lp_edpp_ttl_ex).
**Надеюсь, в моей солянке оказалось достаточно копчёностей, и читатель получил от неё удовольствие.** | https://habr.com/ru/post/61388/ | null | ru | null |
# Southbridge в Челябинске и Битрикс в Kubernetes
В Челябинске проходят митапы системных администраторов Sysadminka, и на последнем из них я делал доклад о нашем решении для работы приложений на 1С-Битрикс в Kubernetes.
Битрикс, Kubernetes, Сeph — отличная смесь?
Расскажу, как мы из всего этого собрали работающее решение.
Поехали!
Митап прошел 18 апреля Челябинске. Про наши митапы можно почитать в [Timepad](https://sysadminka.timepad.ru) и посмотреть на [ютубе](https://www.youtube.com/channel/UCMblNgU0Gt-TXb9GdVeeinw/).
Если хотите прийти к нам с докладом или как слушатель — велкам, пишите на vadim.isakanov@gmail.com и в Телеграм t.me/vadimisakanov.
Мой доклад
----------
[](https://www.youtube.com/watch?v=MZqPNMUjr_M "Доклад о Битрикс в Kubernetes")
[Слайды](https://yadi.sk/i/1q0YpFHBGBdtcg)
Решение «Битрикс в Kubernetes, версия Southbridge 1.0»
------------------------------------------------------
Я расскажу о нашем решении в формате «для чайников в Kubernetes», как это было сделано на митапе. Но предполагаю, что слова Битрикс, Docker, Kubernetes, Ceph вам известны хотя бы на уровне статей в Википедии.
#### Что вообще есть готового про Битрикс в Kubernetes?
Во всем интернете очень мало информации о работе приложений на Битрикс в Kubernetes.
Я нашел только такие материалы:
Доклад Александра Сербула, 1С-Битрикс, и Антона Тузлукова из Qsoft:
Рекомендую послушать его.
Разработка собственного решения от пользователя [serkyron](https://habr.com/ru/users/serkyron/) [на Хабре](https://habr.com/ru/post/351286/).
Нашел еще [такое решение](https://github.com/ESSch/kubernetes).
Ииии… собственно, все.
Предупреждаю, качество работы решений по ссылкам выше мы не проверяли :-)
Кстати, при подготовке нашего решения я общался с Александром Сербулом, тогда его доклада еще не было, поэтому в моих слайдах есть пункт «Битрикс не пользуется Kubernetes».
Но зато готовых Docker образов для работы Битрикс в Docker уже много: <https://hub.docker.com/search?q=bitrix&type=image>
Достаточно ли этого для создания полноценного решения для Битрикс в Kubernetes?
Нет. Есть большое количество проблем, которые нужно решить.
#### В чем проблемы с Битрикс в Kubernetes?
**Первая — готовые образы из Dockerhub не подходят для Kubernetes**
Если мы хотим построить микросервисную архитектуру (а в Kubernetes мы обычно хотим), приложение в Kubernetes нужно разделять на контейнеры и добиваться того, чтобы каждый контейнер выполнял одну маленькую функцию (и делал это хорошо). Почему только одну? Если кратко — чем проще, тем надежнее.
Если подлиннее —- посмотрите эту статью и видео, пожалуйста: <https://habr.com/ru/company/southbridge/blog/426637/>
Docker образы в Dockerhub в основном построены по принципу «все в одном», поэтому нам пришлось все-таки делать свой велосипед и даже образы делать с нуля.
**Вторая — код сайта правится из админ-панели**
Создали новый раздел на сайте — обновился код (добавилась директория с названием нового раздела).
Изменили свойства компонента из админ-панели — изменился код.
Kubernetes «по умолчанию» с таким работать не умеет, контейнеры должны быть не изменяемыми (Stateless).
Причина: каждый контейнер (под) в кластере обрабатывает только часть трафика. Если изменить код только в одном контейнере (поде), то в разных подах код будет разным, сайт будет работать по-разному, разным пользователям будут показываться разные версии сайта. Так жить нельзя.
**Третья — нужно решать вопрос с деплоем**
Если у нас монолит и один «классический» сервер, все совсем просто: разворачиваем новую кодовую базу, проводим миграцию БД, переключаем трафик на новую версию кода. Переключение происходит мгновенно.
Если у нас сайт в Kubernetes, распилен на микросервисы, контейнеров с кодом много — ой. Нужно собирать контейнеры с новой версией кода, выкатывать их вместо старых, правильно выполнять миграцию БД, и в идеале делать это незаметно для посетителей. Благо, в этом Kubernetes нам помогает, поддерживая целую тучу разных видов деплоя.
**Четвертая — нужно решать вопрос с хранением статики**
Если ваш сайт весит «всего лишь» 10 гигабайт и вы развернете его целиком в контейнерах, вы получите контейнеры весом в 10 гигабайт, которые будут деплоиться вечность.
Нужно хранить самые «тяжелые» части сайта вне контейнеров, и встает вопрос, как правильно это делать
#### Чего нет в нашем решении
Совсем весь код Битрикс на микрофункции/микросервисы не разрезан (так, чтобы регистрация отдельно, модуль интернет-магазина отдельно, и т.п.). Всю кодовую базу мы храним в каждом контейнере целиком.
Базу в Kubernetes также не храним (я все же реализовывал решения с базой в Kubernetes для окружений разработчиков, но не для продакшн).
Администраторам сайта все-таки будет заметно, что сайт работает в Kubernetes. Функция «проверка системы» работает некорректно, для редактирования кода сайта из админ-панели нужно сначала нажимать кнопку «хочу отредактировать код».
С проблемами определились, с необходимостью реализации микросервисности определились, цель ясна — получить работающую систему для работы приложений на Битрикс в Kubernetes, сохранив и возможности Битрикс, и преимущества Kubernetes. Начинаем реализацию.
#### Архитектура
Много «рабочих» подов с вебсервером (worker'ы).
Один под с крон-тасками (обязательно только один).
Один upgrade под для редактирования кода сайта из админ-панели (также обязательно только один).
Решаем вопросы:
* Где хранить сессии?
* Где хранить кэш?
* Где хранить статику, не размещать же гигабайты статики в куче контейнеров?
* Как будет работать база данных?
#### Docker образ
Начинаем со сборки Docker образа.
Идеальный вариант — у нас один универсальный образ, на его основе мы получаем и worker-поды, и поды с кронтасками, и upgrade поды.
[Мы сделали как раз такой образ](https://hub.docker.com/r/centosadmin/bitrixenv).
В него включен nginx, apache/php-fpm (можно выбрать при сборке), msmtp для отправки почты, и cron.
При сборке образа в директорию /app копируется полная кодовая база сайта (за исключением тех частей, что мы вынесем в отдельный shared storage).
#### Микросервисность, сервисы
**worker поды:**
* Контейнер с nginx + контейнер apache/php-fpm + msmtp
* msmtp вынести в отдельный микросервис не вышло, Битрикс начинает возмущаться, что не может напрямую отправить почту
* В каждом контейнере полная кодовая база.
* Запрет на изменение кода в контейнерах.
**cron под:**
* контейнер с apache, php, cron
* в комплекте полная кодовая база
* запрет на изменение кода в контейнерах
**upgrade под:**
* контейнер с nginx + контейнер apache/php-fpm + msmtp
* запрета на изменение кода в контейнерах нет
**хранилище сессий**
**хранилище кэша Битрикс**
Еще важно: пароли для подключения ко всему, от базы данных до почты, мы храним в kubernetes secrets. Получаем бонус, пароли видны только тем, кому мы даем доступ к секретам, а не всем, у кого есть доступ к кодовой базе проекта.
#### Хранилище для статики
Можно использовать что угодно: ceph, nfs (но nfs не рекомендуем для продакшн), network storage от «облачных» провайдеров, etc.
Хранилище нужно будет подключать в контейнерах в /upload/ директорию сайта и другие директории со статикой.
#### База данных
Для простоты рекомендуем выносить базу за пределы Kubernetes. База в Kubernetes — отдельная сложная задача, она сделает схему на порядок сложнее.
#### Хранилище сессий
Используем memcached :)
Он хорошо справляется с хранением сессий, кластеризуется, «нативно» поддерживается как session.save\_path в php. Такая система много раз отработана еще в классической монолитной архитектуре, когда мы строили кластеры с большим числом веб-серверов. Для деплоя мы используем helm.
```
$ helm install stable/memcached --name session
```
php.ini — здесь в образе заданы настройки для хранения сессий в memcached
Мы использовали Environment Variables для передачи данных о хостах с memcached <https://kubernetes.io/docs/tasks/inject-data-application/define-environment-variable-container/>.
Это позволяет использовать один и тот же код в окружениях dev, stage, test, prod (имена хостов memcached в них будут отличаться, поэтому в каждое окружение нам нужно передавать уникальное имя хостов для сессий).
Хранилище кэша Битрикс
Нам нужно откаузостойчивое хранилище, в которое все поды могли бы писать и из которого могли бы читать.
Также используем memcached.
Это решение рекомендуется самим Битрикс.
```
$ helm install stable/memcached --name cache
```
bitrix/.settings\_extra.php — здесь в Битрикс задается, где у нас хранится кэш
Так же используем Environment Variables.
### Кронтаски
Есть разные подходы к выполнению кронтасков в Kubernetes.
* отдельный deployment с подом для выполнения кронтасков
* cronjob для выполнения кронтасков (если это web app — с wget <https://$host$cronjobname>, или kubectl exec внутрь одного из worker подов, и т.п.)
* etc.
Можно спорить о наиболее правильном, но в этом случае мы выбрали вариант "отдельный deployment с подами для кронтасков"
Как это сделано:
* крон-таски добавляем через ConfigMap либо через файл config/addcron
* в одном экземпляре запускаем контейнер, идентичный worker-поду + разрешаем выполнение крон-тасков в нем
* используется та же кодовая база, благодаря унификации сборка контейнера проста
Что хорошего получаем:
* имеем работающие кронтаски в окружении, идентичном окружению разработчиков (docker)
* кронтаски не нужно "переписывать" для Kubernetes, они работают в том же виде и в той же кодовой базе, что и раньше
* крон-таски могут добавлять все члены команды с правами commit в production ветку, а не только админы
### Модуль Southbridge K8SDeploy и редактирование кода из админ-панели
Мы ведь говорили про upgrade под?
А как направлять туда трафик?
Ура, мы написали для этого модуль на php :) Это небольшой классический модуль для Битрикс. Его еще нет в открытом доступе, но мы планируем его открыть.
Модуль устанавливается как обычный модуль в Битрикс:
И выглядит вот так:
Он позволяет задать cookie, которая идентифицирует администратора сайта и позволяет Kubernetes отправлять трафик на upgrade под.
Когда изменения завершены, нужно нажать git push, изменения кода будут отправлены в git, далее система соберет образ с новой версией кода и «раскатает» ее по кластеру, заменив старые поды.
Да, несколько костыльно, но при этом мы сохраняем микросервисную архитектуру и не забираем у пользователей Битрикс любимую возможность поправить код из админки. В конце концов, это опция, можно задачу правки кода решить по-другому.
#### Helm чарт
Для сборки приложений в Kubernetes мы, как правило, используем пакетный менеджер Helm.
Для нашего решения Битрикс в Kubernetes Сергей Бондарев, наш ведущий системный администратор, написал специальный Helm чарт.
Он выполняет сборку worker, ugrade, cron подов, настраивает ingress'ы, сервисы, передает переменные из Kubernetes secrets в поды.
Код мы храним в Gitlab, и сборку Helm также запускаем из Gitlab.
Если кратко, это выглядит так
```
$ helm upgrade --install project .helm --set image=registrygitlab.local/k8s/bitrix -f .helm/values.yaml --wait --timeout 300 --debug --tiller-namespace=production
```
Helm также позволяет делать «бесшовный» откат, если вдруг при деплое что-то пошло не так. Приятно, когда не вы в панике «фиксите код по фтп, потому что прод упал», а Kubernetes делает это автоматически, причем без даунтайма.
#### Деплой
Да, мы фанаты Gitlab & Gitlab CI, используем его :)
При коммите в Gitlab в репозитарий проекта Gitlab запускает пайплайн, который выполняет разворачивание новой версии окружения.
Этапы:
* build (собираем новый Docker образ)
* test (тестируем)
* clean up (удаляем тестовое окружение)
* push (отправляем его в Docker registry)
* deploy (разворачиваем приложение в Kubernetes через Helm).
Ура, готово, внедряем!
Ну или задаем вопросы, если они есть.
Итак, что мы сделали
--------------------
**С технической точки зрения:**
* докеризировали Битрикс;
* «разрезали» Битрикс на контейнеры, каждый из которых выполняет минимум функций;
* добились stateless состояния контейнеров;
* решили проблему с обновлением Битрикс в Kubernetes;
* все функции Битрикс продолжили работать (почти все);
* отработали деплой в Kubernetes и откат между версиями.
**С точки зрения бизнеса:**
* отказоустойчивость;
* инструменты Kubernetes (простая интеграция с Gitlab CI, бесшовный деплой, etc);
* пароли в секретах (видны только тем, кому прямо предоставлен доступ к паролям);
* удобно делать дополнительные окружения (для разработки, тестов и др) внутри единой инфраструктуры. | https://habr.com/ru/post/456608/ | null | ru | null |
# Интеграция проекта VueJS+TS с SonarQube
В своей работе мы активно используем платформу *SonarQube* для поддержания качества кода на высоком уровне. При интеграции одного из проектов, написанном на *VueJs+Typescript*, возникли проблемы. Поэтому хотел бы рассказать подробней о том, как удалось их решить.
В данной статье речь пойдет, как писал выше, о платформе SonarQube. Немного теории — что это такое вообще, для тех, кто слышит о ней впервые:
> ***SonarQube** (бывший **Sonar**) — платформа с открытым исходным кодом для непрерывного анализа (англ. continuous inspection) и измерения качества кода.
>
> Поддерживает анализ кода и поиск ошибок согласно правилам стандартов программирования MISRA C, MISRA C++, MITRE/CWE и CERT Secure Coding Standards. А также умеет распознавать ошибки из списков OWASP Топ-10 и CWE/SANS Топ-25 ошибок программирования.
>
> Несмотря на то, что платформа использует различные готовые инструменты, SonarQube сводит результаты к единой информационной панели (англ. dashboard), ведя историю прогонов и позволяя тем самым увидеть общую тенденцию изменения качества программного обеспечения в ходе разработки.*
Более подробно можно узнать на [официальном сайте](https://www.sonarqube.org/)
Поддерживается большое количество языков программирования. Судя по информации из ссылки выше — это более 25 языков. Для поддержки конкретного языка необходимо установить соответствующий плагин. В community-версию входит плагин для работы с *Javascript* (в том числе typesсript), хотя в wiki написано обратное. За *Javascript* отвечает плагин *SonarJS*, за Typescript *SonarTS* соответственно.
Для отправки информации о покрытии используется официальный клиент ***sonarqube-scanner***, который, используя настройки из *config*-файла, отправляет эти данные на сервер *SonarQube* для дальнейшей консолидации и агрегирования.
Для *Javascript* есть [npm-обертка](https://github.com/bellingard/sonar-scanner-npm). Итак, начинаем пошаговое внедрение *SonarQube* в *Vue*-проект, использующий *Typescript*.
Для развертывания сервера *SonarQube* воспользуемся *docker-compose*.
***sonar.yaml***:
```
version: '1'
services:
simplesample-sonar:
image: sonarqube:lts
ports:
- 9001:9000
- 9092:9092
network_mode: bridge
```
***Запуск:***
```
docker-compose -f sonar.yml up
```
После этого *SonarQube* будет доступен по адресу – <http://localhost:9001> .
Пока в нем нет проектов и это справедливо. Будем исправлять данную ситуацию. За основу я взял официальный проект-пример для *VueJS+TS+Jest*. Склонируем его к себе:
```
git clone https://github.com/vuejs/vue-test-utils-typescript-example.git
```
Сначала нам нужно установить клиент *SonarQube*, который называется *sonar-scanner*, для *npm* есть обертка:
```
yarn add sonarqube-scanner
```
И сразу же добавим команду в *scripts* для работы с ним.
***package.json:***
```
{
…
scripts: {
...
"sonar": "sonar-scanner"
...
},
…
}
```
Далее, для работы сканера, нужно задать настройки проекта в специальном файле. Начнем с базовых.
***sonar-project.properties***:
```
sonar.host.url=http://localhost:9001
sonar.projectKey=test-project-vuejs-ts
sonar.projectName=Test Application (VueJS+TS)
sonar.sources=src
# sonar.tests=
sonar.test.inclusions=src/**/*tests*/**
sonar.sourceEncoding=UTF-8
```
* *sonar.host.url* – адрес *Sonar*’а;
* *sonar.projectKey* – уникальный идентификатор проекта на сервере *Sonar*’а;
* *sonar.projectName* – его наименование, оно может быть изменено в любой момент, так как идентификация проекта производится по *projectKey*;
* *sonar.sources* – папка с исходниками, обычно это *src*, но может быть любым. Эта папка задается относительно рутовой папки, которой является папка откуда запущен сканер;
* *sonar.tests* – параметр, который идет в паре с предыдущим. Это папка, где находятся тесты. В данном проекте, нет такой папки, а тест находится рядом с тестируемым компонентом в папке '**test**', поэтому мы его пока проигнорируем и воспользуемся следующим параметром;
* *sonar.test.inclusions* – путь для тестов с использованием маски, может быть несколько элементов перечисленных через запятую;
* *sonar.sourceEncoding* – кодировка для исходных файлов.
Для первого запуска сканера все готово, кроме основного предшествующего действия: запуск самого тестового движка, для формирования им информации о покрытии, которую и будет в последствии использовать сканер.
Но для этого нужно настроить тестовый движок на формирование данной информации. В данном проекте тестовый движок — это *Jest*. И его настройки находятся в соответствующем разделе файла *package.json*.
*Добавим эти настройки:*
```
"collectCoverage": true,
"collectCoverageFrom": [
"src/**/*",
"!src/main.ts",
"!src/App.vue",
"!src/**/*.d.*",
"!src/**/*__tests__*"
],
```
То есть задаем сам флаг необходимости вычисления покрытия и источник (вместе с исключениями), на основе которых оно будет формироваться.
*Теперь запустим тест:*
```
yarn test
```
*Увидим следующее:*
Причина в том, что в самом компоненте, как такового, кода нет. Исправим это.
***HelloWorld.vue:***
```
...
methods: {
calc(n) {
return n + 1;
}
},
mounted() {
this.msg1 = this.msg + this.calc(1);
},
...
```
Этого будет достаточно для расчета покрытия.
*После перезапуска теста убедимся в этом:*
На экране мы должны увидеть информацию о покрытии, а в папке проекта будет создана папка *coverage* с информацией о покрытии тестами в универсальном формате *LCOV (LTP GCOV extension)*.
> **Gcov** — свободно распространяемая утилита для исследования покрытия кода. Gcov генерирует точное количество исполнений для каждого оператора в программе и позволяет добавить аннотации к исходному коду. Gcov поставляется как стандартная утилита в составе пакета GCC.
>
> **Lcov** — графический интерфейс для gcov. Он собирает файлы gcov для нескольких файлов с исходниками и создает комплект HTML страниц с кодом и сведениями о покрытии. Также генерируются страницы для упрощения навигации. Lcov поддерживает покрытие строк, функций, ветвлений.
После выполнения тестов информация о покрытии будет находится в ***coverage/lcov.info***.
Нам надо сказать *Sonar*’у откуда ее взять. Поэтому добавим следующие строчки в его файл конфигурации. Но есть один момент: проекты могут быть мультиязычные, то есть в папке *src* находятся исходники для нескольких языков программирования и принадлежность к тому или иному, и в свою очередь использование того или иного плагина, определяется по его расширению. И информация о покрытии может хранится в разных местах для разных языков программирования, поэтому для каждого ЯП есть свой раздел для настройки этого. У нас проект использует *Typescript*, поэтому нам необходим раздел настроек именно для него:
***sonar-project.properties***:
```
sonar.typescript.coveragePlugin=lcov
sonar.typescript.lcov.reportPaths=coverage/lcov.info
```
Все готово к первому запуску сканера. Хочу заметить, что проект в *Sonar*’е создается автоматически при первом запуске сканера для данного проекта. В последующие разы информация уже будет аккумулироваться, чтобы видеть динамику изменения параметров проекта во времени.
Итак, воспользуемся командой, созданной ранее в *package.json*:
```
yarn run sonar
```
***Примечание:** можно также воспользоваться параметром* -X *для более детального логирования.*
Если запуск сканера был впервые, то сначала скачается бинарник самого сканера. После этого он запускается и начинает сканировать сервер *Sonar*’а на предмет установленных плагинов, вычисляя тем самым поддерживаемые ЯП. Также загружаются другие различные параметры для его работы: *quality profiles, active rules, metrics repository, server rules*.
***Примечание:** подробно на них мы останавливаться не будем в рамках данной статьи, но всегда можно обратиться в официальные источники.*
Далее начинается анализ папки *src* на предмет наличия исходных файлов для всех (если не задан явно какой-то конкретный) поддерживаемых ЯП, с последующей их индексацией.
Далее идут другие различные анализы, на которых мы не заостряем внимание в данной статье (например, такие как: линтинг, определение дублирования кода и тд).
В самом конце работы сканера происходит агрегирование всей собранной информации, архивирование и отправка ее на сервер.
После этого мы можем уже посмотреть что получилось в вэб-интерфейсе:
Как видим, что-то получилось, и даже показывает какое-то покрытие, но оно не соответствует нашему *Jest*-отчету.
Давайте разбираться. Посмотрим на проект более детально, кликнем по значению покрытия, и "провалимся" в детализированный отчет по файлам:
Здесь мы видим помимо основного, исследуемого файла *HelloWorld.vue*, присутствует и файл *main.ts*, который и портит всю картину покрытия. Но как же так, мы его исключали из расчета покрытия. Да, все правильно, но это было на уровне *Jest*, но сканер его проиндексировал, поэтому он попал в его расчеты.
Давайте исправим это:
***sonar-project.properties***:
```
...
sonar.exclusions=src/main.ts
...
```
Хочется сделать уточнение: помимо тех папок, которые заданы в данном параметре, также добавляются все папки, перечисленные в параметре *sonar.test.inclusions*.
После запуска сканера видим уже корректную информацию:
Разберем следующий момент – *Quality profiles*. Я говорил выше о поддержке *Sonar*’ом несколько ЯП одновременно. Вот это как раз мы и наблюдаем. Но мы знаем, что проект у нас написан на *TS*, поэтому зачем напрягать сканер лишними манипуляциями и проверками. Язык для анализа зададим через добавление еще одного параметра в файл конфигурации *Sonar*’а:
***sonar-project.properties***:
```
...
sonar.language=ts
...
```
Снова запустим сканер и посмотрим результат:
Покрытие пропало вовсе.
Если посмотрим в лог сканера, то можем увидеть следующую строчку:
То есть файлы нашего проекта просто не были проиндексированы.
Ситуация следующая: официально поддержка *VueJs* есть в плагине *SonarJS*, который отвечает за *Javascript*.
Но этой поддержки нет в плагине *SonarTS* для *TS*, о чем заведен официальный тикет в баг-трекере *Sonar*’а:
1. <https://jira.sonarsource.com/browse/MMF-1441>
2. <https://github.com/SonarSource/SonarJS/issues/1281>
Вот некоторые ответы одного из представителей со стороны разработчиков SonarQube, подтверждающий этот факт.
Но у нас же все работало, возразите Вы. Да, так и есть, давайте попробуем немного *“похакерить”*.
Если есть поддержка *.vue*-файлов *Sonar*’ом, то давайте попробуем сказать ему чтобы он их рассматривал как *Typescript*.
Добавим параметр:
***sonar-project.properties***:
```
...
sonar.typescript.file.suffixes=.ts,.tsx,.vue
...
```
Запустим сканер:
И, вуаля, все вернулось на круги своя, и с одним профилем только для *Typescript*. То есть удалось решить проблему в поддержке *VueJs+TS* для *SonarQube*.
Попробуем пойти дальше и немного улучшим информацию о покрытии.
Что же мы сделали на данный момент:
* добавили в проект *Sonar*-сканер;
* настроили *Jest* для формирования информации о покрытии;
* сконфигурировали *Sonar*-сканер;
* решили проблему поддержки *.vue*-файлов + *Typescript*.
Кроме покрытия тестами есть другие интересные полезные критерии качества кода, например, дублирование кода и количество строк (участвует в расчете коэффициентов, связанных со сложностью кода) проекта.
В текущей реализации плагина для работы с *TS* (*SonarTS*) не будет работать *CPD (Copy Paste Detector)* и подсчет строк кода *.vue*-файлов.
Для создания синтетической ситуации по дублированию кода, просто задублируем файл компонента с другим именем, также добавим в код *main.ts* функцию-пустышку и задублируем его с другим именем. Чтобы проверить дублирование как в *.vue*, так и в *.ts* -файлах.
***main.ts:***
```
...
function name(params:string): void {
console.log(params);
}
...
```
Для этого необходимо временно закоментировать строчку конфигурации:
***sonar-project.properties***:
```
...
sonar.exclusions=src/main.ts
...
```
Перезапустим сканер вместе с тестированием:
```
yarn test && yarn run sonar
```
У нас конечно упадет покрытие, но сейчас нам это не интересно.
В разрезе дублирования строк кода увидим:
Для проверки воспользуемся *CPD*-утилитой – *jscpd*:
```
npx jscpd src
```
Для строк кода:
Возможно, это решится в будущих версиях плагинов *SonarJS(TS)*. Хочу заметить, что они постепенно начинают сливать эти два плагина в один *SonarJS*, что, думаю, правильно.
Теперь хотелось рассмотреть вариант улучшения информации о покрытии.
Пока мы видим покрытие тестами в процентном отношении, по всему проекту, и по файлам в частности. Но есть возможность расширить этот показатель информацией о количестве *unit*-тестов по проекту, а также в разрезе файлов.
Есть библиотека, которая умеет *Jest*-репорт конвертировать в формат для *Sonar*’а:
*generic test data* — <https://docs.sonarqube.org/display/SONAR/Generic+Test+Data>.
Установим эту библиотеку к себе в проект:
```
yarn add jest-sonar-reporter
```
И добавим его в конфигурацию *Jest*:
***package.json:***
```
…
"testResultsProcessor": "jest-sonar-reporter"
…
```
Теперь выполним тест:
```
yarn test
```
После чего в корне проекта будет создан файл *test-report.xml*.
Задействуем его в конфигурации *Sonar*’а:
***sonar-project.properties***:
```
…
sonar.testExecutionReportPaths=test-report.xml
…
```
И перезапустим сканер:
```
yarn run sonar
```
Посмотрим, что поменялось в интерфейсе *Sonar*’а:
И ничего не поменялось. Дело в том, что Sonar не рассматривает файлы, описанные в Jest-репорте, как файлы *unit*-тестов. Для того, чтобы исправить эту ситуацию задействуем параметр конфигурации *Sonar* *sonar.tests*, в котором явно укажем папки с тестами (она у нас пока одна):
***sonar-project.properties***:
```
…
sonar.tests=src/components/__tests__
…
```
Перезапустим сканер:
```
yarn run sonar
```
Посмотрим, что поменялось в интерфейсе:
Теперь мы увидели количество наших *unit*-тестов и, провалившись по клику внутрь, можем посмотреть распределение этого числа по файлам проекта:
Заключение
==========
Итак, мы рассмотрели инструмент для непрерывного анализа ***SonarQube***. Успешно интегрировали в него проект, написанный на *VueJs+TS*. Решили некоторые проблемы совместимости. Повысили информативность показателя о покрытии тестами. В данной статье мы рассмотрели лишь один из критериев качества кода (возможно, один из основных), но *SonarQube* поддерживает и другие критерии качества, включая тестирование на безопасность. Но не все эти возможности в полном объеме доступны в *community*-версии. Одна из интересных и полезных возможностей — это интеграции *SonarQube* с различными системами управления репозиториями кода, например, такие как GitLab и BitBucket. Чтобы не допустить *merge pull(merge) request*’а в основную ветку репозитория при деградации покрытия. Но это история уже совершенно другой статьи.
**PS:** Все, что описано в статье в виде кода доступно в [моем форке](https://github.com/kolesoffac/vue-test-utils-typescript-example). | https://habr.com/ru/post/488242/ | null | ru | null |
# AspectJ в автоматическом тестировании — несколько практических примеров
***Мне понравился механизм аспектно-ориентированного программирования (АОП), который используется в Allure Framework для перехвата выполнения тестовых шагов, отмеченных аннотацией @Step. И я попробовал применить его в автотестировании, не подключая к тестам таких монстров, как Spring или Guice.***
***В этой статье вы найдете несколько полезных примеров использования аспектов.***
В двух словах аспектно-ориентированное программирование - это концепция, разделения функциональности программы для упрощения ее разложения на модули. Здесь я не буду останавливаться на теории, чтобы быстрее перейти к практическим примерам. Неплохая статья для знакомства с подходом [есть на Хабре](https://habr.com/ru/post/114649/). А [в Википедии есть словарь](https://ru.wikipedia.org/wiki/%D0%90%D1%81%D0%BF%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) основных терминов АОП.
С точки зрения автотестирования это механизм, который позволяет в существующий большой проект дописать файлик Aspect с так называемыми Advice, которые будут выполняться в нужных местах и добавлять некоторые полезные инструменты в весь проект.
В общем случае выглядит это так
-------------------------------
Все тестовые шаги мы помечаем аннотацией @Step - это способ отделить их от остальных методов. Если в ходе работы приложения выполняется метод, который соответствует какому-либо указателю @Pointcut из наших аспектов, то в зависимости от вида Advice-а будет:
* выполнен код Advice, а затем уже метод (@Before);
* выполнен метод, а затем уже Advice (@After, @AfterReturning);
* выполнен код Advice, внутри которого можно запустить исходный метод (один или несколько раз) или же не делать ничего (@Around).
Например, если при выполнении метода вываливается исключение, его можно перехватить и “проглотить” с помощью аспекта, записав при этом в лог. Со стороны же выполнение будет выглядеть так, будто программа выполнилась без ошибок.
Advice имеет доступ к телу метода - мы можем получить параметры, с которыми его вызывают и использовать эти данные для выполнения каких-то своих действий - той же записи в log.
[Allure Framework](http://allure.qatools.ru/), который мы (и многие другие) используем для формирования отчетов автотестов, построен как раз на механизмах AOP. Allure-адаптер делает ровно то же самое - отлавливает аннотации @Step в последовательности выполняющихся методов. А описание того, что необходимо сделать при обнаружении аннотации, хранится в аспекте. Среди прочего там есть добавление информации о шаге в отчет. Если шаг выполняется успешно, он помечается в отчете зеленым, если нет - красным.
Честно говоря, я и набрел на аспектно-ориентированное программирование, пока ковырялся в Allure, пытаясь реализовать там необходимое мне поведение. Наверное, для моих целей можно было бы использовать тот же Lombok, но библиотека AspectJ уже есть в комплекте с Allure и легко внедряется в наши проекты. Плюс на примере Allure было отлично видно, как с ее помощью получить то, что мне нужно. А усложнение и увеличение числа используемых инструментов не входило в планы.
Полезные примеры применения аспектов в автотестах
-------------------------------------------------
Для сборки я использую Gradle, в Maven все будет немного иначе.
Прежде чем переходить к конкретным шагам, необходимо подключить AspectJ с помощью зависимостей:
```
compile 'org.aspectj:aspectjrt:1.9.2'
compile ‘org.aspectj:aspectjweaver:1.9.2’
```
Я использую плагин io.qameta.allure:allure-gradle:2.8.1, в котором уже есть библиотека “aspectjweaver”, т.е. для Allure достаточно указать версию:
```
allure {
version = '2.8.1'
autoconfigure = true
allureJavaVersion = '2.13.7'
aspectjVersion = '1.9.2'
configuration = 'compile'
}
```
Исходники примеров, изложенных ниже, вы можете найти [в моем GitHub](https://github.com/yuri-kudryavtsev/aop).
### Сквозное логирование
Аспекты позволяют добавить сквозное логирование ко всему проекту. Для этого достаточно создать всего лишь один класс, который будет записывать в log-файл данные о выполнении метода, обернутого в аспект.
Предположим, у нас есть простейший тест, который открывает главную страницу Google, выполняет поиск по какому-то запросу и сравнивает результаты с ожидаемыми (берет один из веб-элементов на странице - в нашем случае строку с количеством результатов - и проверяет совпадение с заданным текстом).
```
@Test
public void allureLogTest() {
GoogleSteps.openSearchPage();
GoogleSteps.searchFor("java");
String resultStats = GoogleSteps.getResultStats();
MatcherAssert.assertThat(
"Неправильная сводка по результатам поиска",
resultStats,
Matchers.equalTo("-")
);
}
```
В этом примере я специально задал кривой текст для сравнения, чтобы тест упал.
Если мы не используем другие инструменты (например, встроенный механизм Selenide, который позволяет добавлять своих слушателей на разные события), то тест будет работать молча, не сообщая о текущих выполняемых шагах в консоль.
Под капотом у нас есть аннотации @Step, которые мы используем для шагов, попадающих в отчет Allure. Но по умолчанию эти шаги в консоль не выводятся.
```
public class GoogleSteps {
@Step("Получаем сводку по результатам поиска")
@Attachment
public static String getResultStats() {
return Selenide.$("#result-stats").text();
}
@Step("Выполняем поиск по запросу: {0}")
public static void searchFor(String request) {
Selenide.$("[name='q']").setValue(request);
Selenide.$("[name='btnK']").click();
}
@Step("Открываем страницу поиска")
public static void openSearchPage() {
Selenide.open("https://www.google.ru/");
}
}
```
Вывести их в консоль с минимальными вмешательствами можно с помощью аспектов. Достаточно создать аспект - фактически, обычный класс java со специальной аннотацией - который будет выделять название шагов @Step.
```
@Aspect
public class AllureLogAspect {
private static final Logger log = LoggerFactory.getLogger(AllureLogAspect.class);
…
}
```
Внутри мы должны указать pointcut, где будет срабатывать аспект. Допустим, нам нужно, чтобы он срабатывал перед запуском любого метода, в котором проставлена аннотация io.qameta.allure.Step:
```
@Before("@annotation(io.qameta.allure.Step) && execution(* *(..))")
public void beforeStep(JoinPoint joinPoint) {
String stepName = getStepName(joinPoint);
log.info("BEGIN: " + stepName);
}
```
@Before означает, что аспект должен сработать перед запуском метода. В этот метод передается точка присоединения (JoinPoint), содержащая указатель на запускаемый метод. Здесь же мы можем получить параметры запуска:
```
private String getStepName(JoinPoint joinPoint) {
MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
Map parametersMap = getParametersMap(joinPoint);
Method method = methodSignature.getMethod();
Step step = method.getAnnotation(Step.class);
String stepName = step.value();
return Optional.of(stepName)
.filter(StringUtils::isNoneEmpty)
.map(it -> processNameTemplate(it, parametersMap))
.orElse(methodSignature.getName());
}
```
Отмечу, что вместо
```
return Optional.of(stepName)
.filter(StringUtils::isNoneEmpty)
.map(it -> processNameTemplate(it, parametersMap))
.orElse(methodSignature.getName());
```
можно было написать просто
```
return stepName;
```
Но в этом случае мы получили бы просто исходный текст аннотации и не имели бы возможности заменить подстановочные символы. Чуть более сложная запись позволяет при открывании страницы увидеть в консоли ее адрес, переданный в метод.
Что мы получаем в результате?
При запуске теста еще до открытия страницы выполняется метод beforeStep, из него мы выделяем адрес страницы и пишем в лог. Дальше управление возвращается исходному методу.
Чтобы лог был полным после его выполнения мы подставим еще один аспект с @AfterReturning:
```
@AfterReturning(
pointcut = "@annotation(io.qameta.allure.Step) && execution(* *(..))",
returning = "result"
)
public void afterStep(JoinPoint joinPoint, Object result) {
String stepName = getStepName(joinPoint);
log.info("END: " + stepName);
if(result != null) {
log.info("RESULT: " + result);
}
}
```
Здесь помимо аналогичной записи в лог мы также проверяем, есть ли какой-то результат вызова метода. Если результат не пустой, он также выводится в консоль.
С описанием аспекта мы закончили. Осталось создать в папке /resources/META-INF мета-файл aop-ajc.xml, в котором следует указать пульт до нового класса:
```
```
Теперь когда мы запускаем тест, в консоль выводятся все шаги, которые попадают в отчет Allure. Параллельно мы получаем сводку по результатам.
У меня на проектах задача логирования в консоль решается через встроенный механизм Selenide, который позволяет добавлять listener-ы на различные события. А аспекты используются для других задач. Например, для логирования HTTP-запросов из созданных через OpenAPI-генератор Swagger-клиентов. Также с помощью AOP я добавляю текущее время и дату к названиям тестовых шагов в отчетах Allure. Так удобнее утром разбирать ночные прогоны. Еще один вариант использования - логирование SQL-запросов в БД.
### Механизм повторов
Аспекты позволяют реализовать необходимое количество повторов тестовых шагов.
Предположим, некий тестовый шаг со специальной аннотацией не всегда проходит с первого раза. Мы хотели бы, чтобы при неудаче у нас было еще 2-3 попытки. И если хотя бы одна из них выполнилась корректно, шаг считался бы зеленым.
В качестве примера я сделал шаг checkRandom(), где мы генерируем случайное число от 0 до 9 и проверяем, что оно равно desiredValue:
```
public class CommonSteps {
@Step("Проверяем, что случайное число = {0}")
@WithRetries(20)
public static void checkRandom(int desiredValue) {
Random random = new Random();
int i = random.nextInt(10);
MatcherAssert.assertThat(
"Неправильный результат",
i,
Matchers.equalTo(desiredValue)
);
}
}
```
Без аспекта тест ожидаемо падает (с соответствующей вероятностью).
Чтобы обеспечить повторы, я создал новую аннотацию @WithRetries. По умолчанию методы, отмеченные этой аннотацией, повторяются 3 раза:
```
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface WithRetries {
int value() default 3;
}
```
Также я создал класс:
```
@Aspect
public class WithRetriesAspect {
private static final ThreadLocal processingWrapper = ThreadLocal.withInitial(() -> false);
private static final Logger log = LoggerFactory.getLogger(WithRetriesAspect.class);
public static Boolean isProcessing() {
return processingWrapper.get();
}
...
}
```
В отличие от предыдущего примера, здесь я использую pointcut @Around. Это позволяет полностью контролировать выполнение методов, отмеченных аннотацией @WithRetries.
```
@Around("@annotation(org.example.aop.annotations.WithRetries) && execution(* *(..))")
public Object handleRetries(final ProceedingJoinPoint joinPoint) throws Throwable {
processingWrapper.set(true);
MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
Method method = methodSignature.getMethod();
WithRetries annotation = method.getAnnotation(WithRetries.class);
int retryCount = annotation.value();
Throwable storedException = null;
Object result = null;
boolean processed = false;
int i = 0;
while (!processed && i < retryCount) {
try {
result = joinPoint.proceed();
processed = true;
} catch(Throwable throwable) {
log.warn("Попытка №" +i+":\r\n"+throwable.toString());
storedException = throwable;
}
i++;
}
```
Разберем, что здесь происходит.
Внутри Advice я получаю из аннотации количество попыток выполнения и пытаюсь исполнить метод. Если возникает исключение, я его перехватываю здесь же и сохраняю в переменную storedException. В конце я проверяю, по какой причине мы вышли из цикла - получили результат или переполнился счетчик попыток. Если какой-то результат есть, я возвращаю его, а в ином случае выкидываю исключение.
```
processingWrapper.set(false);
if(!processed) {
assert storedException != null;
throw storedException;
}
return result;
```
Подключается аспект точно также в файле /resources/META-INF/aop-ajc.xml
```
```
### Поглощение исключений
Еще один интересный пример возможностей АОП - это обработка исключений таким образом, чтобы при их появлении появлялось предупреждение, но тест не останавливался.
Подход аналогичный предыдущим двум примерам. Я создаю аспект:
```
@Aspect
public class MatcherAssertAspect {
private static final Logger log = LoggerFactory.getLogger(MatcherAssertAspect.class);
…
}
```
Но pointcut здесь немного сложнее.
Такой pointcut сработает на все методы, которые называются assertThat:
```
@Pointcut("execution(* assertThat(..))")
void inMethods() {
}
```
Следующий pointcut - на все методы, которые расположены в классе org.hamcrest.MatcherAssert:
```
@Pointcut("execution(* org.hamcrest.MatcherAssert.*(..))")
void inMatcherAssert() {
}
```
А этот pointcut сработает на все публичные методы:
```
@Pointcut("execution(public * *(..))")
void anyPublic() {
}
```
После объединения всех pointcut-ов у нас остаются все публичные методы с названием assertThat внутри класса org.hamcrest.MatcherAssert.
Внутри аспекта используем тот же Advice @Arround:
```
@Around("anyPublic() && inMatcherAssert() && inMethods()")
public Object handleAssert(final ProceedingJoinPoint joinPoint) throws Throwable {
Object result = null;
try {
result = joinPoint.proceed();
} catch (Throwable throwable) {
if (WithRetriesAspect.isProcessing()) {
throw throwable;
} else {
log.warn(throwable.toString());
}
}
return result;
}
```
Здесь у меня добавлена синхронизация с описанным выше аспектом, обрабатывающим повторы.
Простейший тест для проверки выглядит следующим образом:
```
@Test
void errorsSkippingTest() {
MatcherAssert.assertThat("test", true, Matchers.equalTo(false));
MatcherAssert.assertThat("test2", 1, Matchers.equalTo(2));
MatcherAssert.assertThat("test3", "olol", Matchers.equalTo("pishpish"));
}
```
Перед запуском также подключаем класс в файле /resources/META-INF/aop-ajc.xml
```
```
Используя повторы и поглощение исключений можно обрабатывать самые неприятные тесты - Flaky-тесты. Ты запускаешь их несколько раз подряд с одними и теми же тестовыми данными в одном и том же окружении, а результат оказывается случайным (то зеленые, то красные). Они не несут в себе совершенно никакой полезной информационной нагрузки, но мешают получению данных о работоспособности тестируемого продукта.
У Allure для таких тестов предусмотрена специальная аннотация - @Flaky. Если упали только тесты с такой аннотацией, весь прогон считается зеленым, а сами тесты помечены специальным символом. Я написал аналогичный аспект для тестовых шагов. В отчете такие шаги помечаются красными, прикрепляется StackTrace ошибки, но сам тест остается зеленым.
Это полезно, когда в автотестах среди прочего проверяются какие-то дополнительные сценарии - например, что в файловой системе записались логи, что они ушли в Kibana, в БД создались все сущности и т.п. В определенные моменты логи файловой системы могут быть недоступны, а Kibana может не функционировать. Чтобы спокойно заниматься своими делами, пока коллеги все чинят, достаточно расставить аннотации и остальные автотесты смогут проверить главное. Это у меня реализовано через AOP.
Автор статьи: Юрий Кудрявцев.
P.S. Мы публикуем наши статьи на нескольких площадках Рунета. Подписывайтесь на наши страницы в [VK](https://vk.com/maxilect), [FB](https://www.facebook.com/maxilectru/), [Instagram](https://www.instagram.com/maxilectteam/) или [Telegram-канал](https://t.me/maxilect), чтобы узнавать обо всех наших публикациях и других новостях компании Maxilect. | https://habr.com/ru/post/539904/ | null | ru | null |
# Анатомия шаблонов Blogger
#### Вступление
В Сети, как оказалось, не так уж и много информации относительно того, как создавать свои собственные темы оформления для блоговой платформы от Google, во всяком случае, в Рунете. Есть какие-то куцые посты про то, как настроить отдельное свойство конкретного виджета, да и только. Посему, в этой статье я решил консолидировать знания на данную тему.
#### Базовые элементы шаблона
В общем случае шаблон Blogger представляет собой XML-файл, содержащий описание HTML-страницы (CSS-форматирование также включено в этот файл). Выглядит это примерно так (некоторые детали опущены для простоты):
```
xml version="1.0" encoding="UTF-8" ?
...
...
...
...
```
Блоки и , отвечающие за CSS-оформление, я рассматривать не буду, поскольку лично я для создания темплейтов использую фреймворк Twitter Bootstrap. Сейчас лучше займемся той частью, которая отвечает за отображение контента.
Итак, основной составляющей любого шаблона Blogger является его тело — ````
. Оно состоит преимущественно из секций и виджетов. Секциями являются ключевые элементы страницы: шапка, боковое меню, подвал и тому подобные. Ну, а виджеты – это индивидуальные кирпичики страницы, такие как сообщение, картинка или любой другой элемент, который можно добавить на вкладке «Элементы страницы» в редакторе шаблона. Секции может окружать любой пользовательский HTML-код, который требуется.
Каждая секция в шаблоне открывается и закрывается специальным тегом, выглядит это примерно так:
```
Тег может иметь следующие атрибуты (обязательным является только id):
* id – уникальное имя, состоящее только из букв и цифр;
* class – обычное название класса в терминах HTML;
* maxwidgets – как видно из названия, это максимальное количество виджетов, которые могут присутствовать в данной секции;
* showaddelement – булевое поле, которое может принимать значения «yes» или «no» («yes» - по-умолчанию), определяя, может ли на вкладке «Элементы страницы» отображаться кнопка «Добавить элемент страницы» в данной секции;
* growth – последняя опция с возможными значениями «horizontal» или «vertical» («vertical» - по-умолчанию), которая определяет, как будут располагаться виджеты в данной секции.
Секции могут содержать только виджеты: если нужно вставить дополнительный код между виджетами в рамках одной секции, то эту секцию придется разбить на несколько частей.
Виджет, по сути, представляет собой одинарный тег, который вставляется в том месте, где на странице должно отобразиться содержимое этого виджета: само наполнение хранится в базе данных Blogger’а и извлекается оттуда во время рендеринга на стороне сервера. Ниже представлено несколько примеров виджетов:
```
```
Виджет может иметь следующие атрибуты (только первые два из которых являются обязательными):
* id – уникальный идентификатор виджета, не может быть изменен без удаления виджета и создания нового;
* type – определяет тип виджета из списка допустимых типов (об этом чуть ниже);
* locked – булевое поле («no» - по-умолчанию), определяющее, может ли данный виджет быть перемещен или удален на вкладке «Элементы страницы»;
* title – заголовок виджета;
* pageType – может быть «all», «archive», «main», или «item» (с «all» по-умолчанию), указывает, на каких страницах блога будет отображаться данный виджет;
* mobile – может принимать значения «yes», «no» или «only» («default» по-умолчанию) и определяет, будет ли данный виджет отображаться в мобильной версии блога.
А вот и обещанные типы виджетов, которые вы можете использовать в своем шаблоне:
* BlogArchive
* Blog
* Feed
* Header
* HTML
* SingleImage
* LinkList
* List
* Logo
* BlogProfile
* Navbar
* VideoBar
* NewsBar
Каждый из них может быть описан в краткой (представленной выше) или расширенной форме, детализируя содержимое. О том, как настроить и видоизменить тот или иной виджет, речь пойдет в следующем разделе. Пока что хочу отметить, что после применения шаблона к блогу все элементы и будут заменены на div’ы с определенными идентификаторами, то есть к элементам можно свободно обращаться в CSS, например, `div#header` или `div#myList`.
#### Расширение и модификация виджетов
Просто натыкать виджетов в тему – не интересно. Интересно кастомизировать их в соответствии со своими нуждами. Для этого, прежде всего, необходимо заменить одинарный тег на двойной:
```
...
```
О том, что можно поместить посредине, речь пойдет дальше.
##### Вставки
Наполнение виджета содержится в блоке «includable» в следующем формате:
```
...
```
Атрибутов всего два: id и var. C id мы знакомы, а var – это еще один идентификатор, который служит для того, чтобы ссылаться на данный блок во внутренних секциях (об этом чуть дальше).
Каждый виджет должен иметь один includable с id='main'. Чаще всего это будет единственный элемент, который будет содержать всю необходимую информацию. Если вы опишете больше одного внутреннего блока, то они не будут отображаться автоматически. Например, если вы создали блок с id='new', то для его отображения в main вам нужно будет написать .
Тег `b:include` может иметь следующие атрибуты: name (обязательный) и data. Name должен совпадать с id одного из существующих includable, а data – это выражение или данные, которые будут переданы в includable (в качестве значения var).
Ниже представлен простой пример комбинации includable-блоков (о циклах речь пойдет чуть ниже):
```
Title:
```
Один блок includable может вставляться в нескольких местах страницы или не вставляться нигде, если пока его не нужно отображать.
##### Данные
Итак, мы добрались до ключевого элемента из тех, которые нас интересуют, до данных:
*
*
* и т.д.
Это несколько примеров того, как просто можно использовать тег data. В первом случае мы просто подставляем значение заголовка в необходимом месте, а во втором - атрибут url элемента photo (это похоже на доступ к полю объекта в ООП). То, какие «поля» есть у каких «объектов» в Blogger мы рассмотрим чуть позже.
##### Циклы
Для записи циклов в шаблонах Blogger используется тег `b:loop`, имеющий следующий синтаксис:
```
...
```
Как видим, все довольно просто: в качестве var указывается переменная, служащая итератором, а в values мы записываем коллекцию, которую будем перебирать. Наглядный пример:
```
```
##### Ветвление
Условия, как не парадоксально, в Blogger записывают с помощью тегов `b:if` и `b:else`. Общий формат условий имеет такой вид:
```
[content to display if condition is true]
[content to display if condition is false]
```
Тега `b:else`, впрочем, может и не быть, если контр-условие нам не нужно.
В качестве условия может быть использовано любое выражение, принимающее значения true или false. Несколько примеров напоследок:
*
*
*
*
#### Data-теги
Как было сказано ранее, существует множество предопределенных тегов, позволяющих извлекать данные из базы Blogger’a. Все они записываются в виде: или , в зависимости от глубины вложенности той или иной информации.
Важно помнить, что data-теги, касающиеся определенного виджета, могут быть доступны исключительно в рамках этого виджета: например, нельзя, обратиться к photo.url, находясь внутри виджета BlogArchive, потому что он «не знает» ни о какой фотографии, а тем более о ее адресе. Однако существует исключение – так называемые, глобально доступные данные. Информацию из этой категории можно получить в любом месте шаблона, обращаются к ней в такой форме: (где вместо звездочки записывается интересующий нас атрибут). В данную категорию входят следующие атрибуты:
* title – заголовок блога;
* pageType – тип страницы, может быть «item», «archive» или «index»;
* url – адрес текущей страницы;
* homepageUrl – адрес домашней страницы;
* pageTitle – заголовок страницы;
* encoding – кодировка блога, например, UTF-8;
* languageDirection – направление текста, может быть «ltr» (слева направо) или «rtl» (наоборот);
* feedLinks – автоопределяемые ссылки для заголовка страницы.
Остальные теги данных не являются глобальными и делятся на категории в соответствии с существующими в Blogger’е виджетами:
* Page Header
* Blog Posts
* Blog Archives
* Profile
* Text / HTML / JavaScript
* Feed
* Picture
* Labels
* List
* Link List
* Logo
Я не буду описывать каждую из категорий, так как все они очень похожи. Прочитать подробно про них можно [здесь](http://support.google.com/blogger/bin/answer.py?hl=en&answer=47270).
#### Заключение
Вот, пожалуй, и все. Теперь вы имеет общее представление об архитектуре темы оформления для Blogger. На всякий случай подскажу, где можно увидеть примеры шаблонов, и как загрузить свой. Для этого необходимо зайти в настройки вашего блога, в раздел «Шаблон». Там нужно нажать на кнопку «Редактировать HTML». Вуаля – перед вами откроется окно с кодом примененного на данный момент шаблона.
Надеюсь, статья оказалась для кого-то полезной. Большую часть информации я почерпнул из следующих источников:
* [support.google.com/blogger/bin/answer.py?hl=en&answer=46888](http://support.google.com/blogger/bin/answer.py?hl=en&answer=46888)
* [support.google.com/blogger/bin/answer.py?hl=en&answer=46995](http://support.google.com/blogger/bin/answer.py?hl=en&answer=46995)
* [support.google.com/blogger/bin/answer.py?hl=en&answer=47270](http://support.google.com/blogger/bin/answer.py?hl=en&answer=47270)` | https://habr.com/ru/post/166073/ | null | ru | null |
# Как заработать на API Яндекс.Денег
**С вас — идеи монетизации стриминга и реализация на API Яндекс.Денег, с нас — аудитория, реклама и деньги.**
Шестой день рождения API переводов мы решили отпраздновать антихакатоном, на котором любой желающий может попробовать свои силы в борьбе за джекпот. Помимо денежного приза в 100 000 рублей мы **поделимся с победителем прибылью от переводов** через Яндекс.Деньги.
Приглашаем под кат всех индивидуальных разработчиков, предпринимателей и команды стартапов.
**Как принять участие:** нужно разработать готовое к использованию решение для сбора денег за стриминг в Сети.
**Зачем это вообще нужно:** количество сервисов с потоковой передачей платного контента стабильно растет, а удобного способа получения денег для них пока нет. По крайней мере такого, который был бы удобен не только владельцу сервиса, но и пользователям.
**Насколько свободно творчество:** в решении должны быть задействованы платежи через API Яндекс.Денег, все остальное — на ваше усмотрение. Жюри из экспертов компании выберет лучшее решение, а его авторы получат приз в 100 000 рублей и смогут забрать комиссию 0,5 % с каждой операции своего сервиса.
**Когда будем подводить итоги:** готовые прототипы и ваши анкеты мы принимаем *до 1 августа 2017*.
API позволяет выполнять следующие задачи:
* запрашивать баланс;
* просматривать историю операций;
* переводить деньги между кошельками;
* пополнять электронный кошелек с банковской карты.
Чтобы вам было проще погрузиться в решение задачи, разберем на примерах популярные сценарии использования API.
#1 Запрос доступа к операциям в кошельке
========================================
Перед совершением каких-либо операций с кошельками в Яндекс.Деньгах (например, просмотр истории операций или состояния счета) разработчику нужно получить [определенные права](https://tech.yandex.ru/money/doc/dg/concepts/protocol-rights-docpage/).
> К слову, авторизация приложений в Яндекс.Деньгах соответствует следующим спецификациям:
>
> * [The OAuth 2.0 Authorization Framework](http://tools.ietf.org/html/rfc6749)
> * [The OAuth 2.0 Authorization Framework: Bearer Token Usage](http://tools.ietf.org/html/rfc6750)
>
>
>
>
Зарегистрируйте приложение и укажите его параметры. В качестве Redirect URI задайте адрес, на который Яндекс.Деньги будут отправлять пользователя после успешной OAuth-авторизации. После этого вы получаете свой уникальный идентификатор **client\_id**.
Теперь можно запрашивать права на проведение необходимых нам действий с кошельками пользователей. Пример запроса авторизации с правом просмотра истории операций кошелька:
```
POST /oauth/authorize HTTP/1.1
Host: money.yandex.ru
Content-Type: application/x-www-form-urlencoded
Content-Length: 191
client_id=ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ01&response_type=code&redirect_uri=https%3A%2F%2Fclient%2Eexample%2Ecom%2Fcb&scope=account%2Dinfo%20operation%2Dhistory
```
По запросу авторизации пользователь перенаправляется на страницу аутентификации, где вводит логин-пароль и может подтвердить или отклонить перечень запрошенных прав:
*Интерфейс авторизации.*
Результат авторизации возвращается как **HTTP 302 Redirect** – приложение перенаправит пользователя на адрес Redirect URI, который разработчик указал в параметрах запроса. Значение Redirect URI должно совпадать с настройками приложения, допуская возможность добавить в конце строки какие-либо дополнительные параметры. В адресе перенаправления с успешным результатом авторизации содержится параметр **code** — временный токен авторизации.
```
HTTP/1.1 302 Found
Location: https://client.example.com/cb?code=i1WsRn1uB1ehfbb37
```
Последний шаг – получение токена, для которого назначен определенный набор прав. После этого приложение меняет временный токен на токен авторизации, который разработчик будет использовать для доступа к информации в кошельке:
```
POST /oauth/token HTTP/1.1
Host: money.yandex.ru
Content-Type: application/x-www-form-urlencoded
Content-Length: 421
code=0DF3343A8D9C7B005B1952D9B933DC56ACB7FED6D3F2590A6FD90EC6391050EDFFCC993D325B41B00F58E5383F37F6831E8F415696E1CF07676EE8D0A3655CDD7C667189DFB69BFDB7116C0329303AB2554290048BAF9B767B4C335BF0E85830AC017AD2F14D97F529893C202D3B2C27A61EE53DC4FB04DAE8E815DE2E3F865F&client_id=ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ01&grant_type=authorization_code&redirect_uri=https%3A%2F%2Fclient%2Eexample%2Ecom%2Fcb
```
А вот такой ответ придет при успешном обмене временного токена:
```
HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 293
Cache-Control: no-store
{
"access_token":"410012345678901.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ0123"
}
```
Access\_token является симметричным секретом, поэтому разработчику приложения стоит предпринять дополнительные меры по его защите: хранить токен в зашифрованном виде, предоставлять доступ только при успешном прохождении владельцем аутентификации.
#2 Просмотр истории операций
============================
Когда токен получен, разработчик может использовать его для авторизованных действий с кошельком. Напомню, что конкретно эта авторизация позволила просматривать историю в кошельке пользователя.
> Самый простой пример из области краудфандинга в соцсетях: некое сообщество ВКонтакте, посвященное футболу, — подписчиков много и активность хорошая, но это сделанный на досуге проект, а не цель жизни. Одно время паблик проводил встречи подписчиков и через электронный кошелек администратора собирал на эту и прочие нужды деньги. Для большей прозрачности распределения поступивших денег администратор создал таблицу и подтянул туда данные об истории операций через API. Когда кто-то отправляет в кошелек деньги, то все видят детали операции, отправителя и цель перевода.
Для просмотра данных воспользуемся методом [operation-history](https://tech.yandex.ru/money/doc/dg/reference/operation-history-docpage/), позволяющим персонализировать запрос разработчика. На выходе получим, например, последние 10 транзакций, или операции за последние полгода, или только расходные операции. Все зависит от аппетита пользователей, для которых разработчик создает сервис.
В случае со стримерами полезно выводить информацию по дате и времени входящего пополнения, включая его сумму, никнейм и сообщение отправителя, используемый платежный метод. Данные чаще всего фильтруются по никнейму, что может быть полезно для стримера: например, можно выбрать лучшего донатера (подписчика) и поощрить его предложением выбрать любую игру, которая будет распространяться в ближайшее время.
Пример запроса на получение пяти последних входящих зачислений в кошелек выглядит так:
```
POST /api/operation-history HTTP/1.1
Host: money.yandex.ru
Authorization: Bearer 410012345678901.7EE34A50588723226C886A475AD1D415471BF687CCC2AFC7664BA12F4EC2BDBA1EB82625E49BC29D114A6C6AF12F87639A877E81A5B77B81F003A9DB4CCEB9BD80C6E70B157C18410E884465276AACBD58C2D7B6022CBDFD0004B80704E82D3F0E4039A29655EFAA44F037D6BF763B0B803329FE8A0E511057173B04341C4317
Content-Type: application/x-www-form-urlencoded
records=5&type=deposition
```
Вот что на это может ответить сервис Яндекс.Денег:
```
{
"next_record": "5",
"operations": [
{
"operation_id": "548936732440013012",
"title": "Перевод с банковской карты",
"amount": 1.96,
"direction": "in",
"datetime": "2017-05-24T10:25:32Z",
"label": "123007",
"status": "success",
"type": "deposition"
},
{
"pattern_id": "p2p",
"operation_id": "1097872036856016025",
"title": "Перевод от 410012345678902",
"amount": 0.99,
"direction": "in",
"datetime": "2017-05-24T10:13:38Z",
"status": "success",
"type": "incoming-transfer"
},
{
"operation_id": "548428048231013012",
"title": "Перевод с банковской карты",
"amount": 1.96,
"direction": "in",
"datetime": "2017-05-18T13:07:28Z",
"status": "success",
"type": "deposition"
},
{
"operation_id": "548427906481013012",
"title": "Перевод с банковской карты",
"amount": 1.96,
"direction": "in",
"datetime": "2017-05-18T13:05:06Z",
"status": "success",
"type": "deposition"
},
{
"pattern_id": "p2p",
"operation_id": "1096319740674326025",
"title": "Перевод от 410012345678903",
"amount": 0.01,
"direction": "in",
"datetime": "2017-05-15T10:37:50Z",
"status": "success",
"type": "incoming-transfer"
}
]
}
```
Еще один пример сервиса на основе запроса к истории — коллективные закупки на форумах: люди договариваются скинуться и заказать что-то оптом по более низкой цене, а организатор собирает деньги на свой кошелек. Чтобы все видели, сколько участников в закупке и как расходуются деньги, можно использовать один из множества сервисов на базе API Яндекс.Денег. Сборщику достаточно авторизоваться кошельком в одном из таких сервисов.
#3 Проверка баланса
===================
Игровые стримеры часто работают с несколькими мониторами, поэтому команда Яндекс.Денег разработала виджет, в котором можно указать цель сбора денег, необходимую сумму – и отслеживать прогресс. Например, стример хочет купить новую PlayStation 4. Как только в кошельке наберется нужная сумма, Яндекс.Деньги пришлют в виджет уведомление, что пора делать заказ.
*Виджет накопления.*
> Другой пример, когда стриминговому сервису нужен постоянный доступ к балансу — программа лояльности: в личном кабинете стримера, к примеру, можно разместить пиццерийный оффер со скидкой, по которому можно мгновенно заказать пиццу. Но перед этим сервис должен убедиться, что денег на счете достаточно для заказа.
Для просмотра баланса можно воспользоваться методом [account-info:](https://tech.yandex.ru/money/doc/dg/reference/account-info-docpage/)
```
POST /api/account-info HTTP/1.1
Host: money.yandex.ru
Authorization: Bearer 410012345678901.1578E01607EB3899853D2883E47841A195BC561F1F8CF479D593B662AD60B2D146EE49F02D750CB2972E51E0DF10369AE77FD930D82B7563AA0D65FA709A7C31EB59D4FFC1F2E85A14A817BDFB282C5A82FF1B79C65D2AE7B3BAE1C1C7D89CBE80477FF1C51A8F3DD9A032475BE629235949B7A2CA7823AC6AC06DB3176F9B54
Content-Type: application/x-www-form-urlencoded
```
В ответ сервер вернет следующее:
```
{
"account": "410012345678901",
"balance": 192.45,
"currency": "643",
"account_type": "professional",
"identified": true,
"account_status": "identified",
"cards_linked": [
{
"type": "MasterCard",
"id": "4005641800",
"pan_fragment": "532130******2227"
}
],
"balance_details": {
"total": 192.45,
"available": 192.45,
"blocked": 1
}
}
```
В результате вы получите не только детализированную информацию по балансу, но и сведения о привязанных банковских картах: маскированный номер карты, тип, идентификатор привязанной карты.
**Еще пара сценариев, где пригодится проверка баланса через API.*** Мой любимый пример — Дзен-мани. Это сервис, который помогает пользователям следить за своим бюджетом и планировать расходы на будущее. Разработчики Дзен-мани предложили пользователям привязать кошелек Яндекс.Денег к приложению, чтобы оно могло самостоятельно добавлять новые расходные операции и доходы. Разумеется, опция полезна только активным пользователям кошелька, которые оплачивают из него большинство покупок. И это действительно большое благо, так как в учете личных финансов сложнее всего не забывать отмечать расходы в программе. Почитать, как все это работает, можно в статье Дзен-мани на [Geektimes](https://geektimes.ru/post/118161).
* Или Classto — сервис для общения родителей и учителей. С его помощью можно собирать в общий кошелек на нужды класса не наличные, а переводы с банковских карт прямо в приложении. Еще можно проверить баланс и узнать, сколько всего денег собрано — важный элемент прозрачности сборов и трат, так как эту информацию видит любой из родителей.
#4 Перевод из кошелька
======================
С помощью API можно инициировать не только переводы из кошелька, но и с привязанной карты. Это удобно для мгновенных расчетов с людьми, которые не держат деньги на кошельке и используют его как прослойку, чтобы не светить карту в интернете. При этом за плательщиком по-прежнему остается контроль расходов, ведь даже автоматические списания с привязанной карты нужно авторизовать.
Как это работает:
1. После получения подтверждения от пользователя, API попробует списать из кошелька запрошенную сумму.
2. Если денег на балансе не хватает, сервис ответит **not\_enough\_funds**.
3. Далее сервис может списать деньги с привязанной к кошельку карты, если пользователь это разрешил. Автоматическое списание с привязанной карты доступно только получателям-юрлицам. Кроме того, списать деньги с карты не получится при переводе между кошельками.
Стримеры могут мотивировать зрителей подписаться на регулярные переводы за публичную благодарность в эфире или соцсетях, подарки или право выбора следующей игры для стрима.
Подписка выглядит следующим образом:
1. Рядом с кнопкой «Поддержать» может стоять галка «Подписаться на ежемесячный платеж в пользу этого стримера».
2. Когда пользователь нажимает на кнопку «Поддержать», разработчик проверяет условие регулярных платежей и корректирует список запрашиваемых прав в запросе к Яндекс.Деньгам.
Поскольку речь идет об операции в кошельке, нужно запросить разрешение на ее проведение – запрос на предоставление доступа остается практически как в примере №1, но меняется набор прав (scope).
Набор запрашиваемых прав, который позволяет совершить единовременный перевод на сумму 1000 рублей в кошелек 410012345678901, выглядит следующим образом:
```
payment.to-account("410012345678901").limit(,1000)
```
Если же отправитель подписался на регулярные платежи, авторизация может иметь следующее значение:
```
payment.to-account("410012345678901").limit(30,1000)
```
Где 30 — период времени в сутках, 1000 — общая сумма платежей за период.
Пример запроса на регулярное списание:
```
POST /oauth/authorize HTTP/1.1
Host: money.yandex.ru
Content-Type: application/x-www-form-urlencoded
client_id=49414287408917F4BC735301F4731878533F409F3BA8EA055D0D441EE002F69B&redirect_uri=http%3A%2F%2Fexample.com%2Fapi%2Fredirect_uri.php&response_type=code&scope=payment.to-account(%22410012345678903%22).limit(30%2C1000)
```
Отправитель же увидит красивую форму:
После получения токена разработчику нужно выполнить списание через методы **request-payment** и **process-payment**:
```
POST /api/request-payment HTTP/1.1
Host: money.yandex.ru
Content-Type: application/x-www-form-urlencoded
Authorization: Bearer 410012345678901.D2E0917C3E09DE474DD3BF6288DDCB6818D55B6BBC8A9386ABA2A983F3F4666102F9B7A2D370D7079891299907368389F3BA8E2BE04597DCFF4CF02F4E3423896776D1C5CCE30A09B5D2E73874C5FE33CAE19286EAB03D146B46A188939BEC1ADA93F3530ECBFACA2591715F686EDBC9F616A7BF912CF4DC9CFB689473328347
pattern_id=p2p&to=410012345678903&amount=10&comment=Transfer+to+Nuke73&message=Transfer+from+SuperMan
```
Пример ответа:
```
{
"status": "success",
"request_id": "333235373335343733345f646366303562383436613661306133373130663766343166303137666131336262656637353539655f323537353532373836",
"recipient_identified": true,
"multiple_recipients_found": false,
"recipient_account_type": "professional",
"recipient_account_status": "identified",
"contract_amount": 10,
"money_source": {
"cards": {
"allowed": false
},
"wallet": {
"allowed": true
},
"card": {
"allowed": "false"
}
}
}
```
> К слову о переводах и комиссиях. В личном кабинете можно выбрать, кто платит комиссию за перевод – за это отвечают параметры **amount** и **amount\_due**. Если в шаблоне платежа указан параметр amount\_due, то именно эта сумма поступит в кошелек стримера (комиссию оплачивает зритель). Если же стример готов взять её на себя, то на входе указывается параметр amount. Таким образом, amount (сумма к переводу) равняется сумме комиссии и amount\_due (сумма к получению).
Перевод выполняется после вызова метода **process-payment** уже без участия пользователя, который один раз при авторизации доступа подтвердил свои намерения. В качестве **request\_id** используется идентификатор из ответа метода request-payment.
```
POST /api/process-payment HTTP/1.1
Host: money.yandex.ru
Content-Type: application/x-www-form-urlencoded
Authorization: Bearer 410012345678901.D2E0917C3E09DE474DD3BF6288DDCB6818D55B6BBC8A9386ABA2A983F3F4666102F9B7A2D370D7079891299907368389F3BA8E2BE04597DCFF4CF02F4E3423896776D1C5CCE30A09B5D2E73874C5FE33CAE19286EAB03D146B46A188939BEC1ADA93F3530ECBFACA2591715F686EDBC9F616A7BF912CF4DC9CFB689473328347
request_id=333235373335343733345f646366303562383436613661306133373130663766343166303137666131336262656637353539655f323537353532373836
```
Пример ответа:
```
{
"status": "success",
"payer": "410012345678901",
"payee": "410012345678903",
"credit_amount": 9.95,
"payment_id": "549038975018120011"
}
```
Отлично – списание с кошелька прошло успешно.
#5 Перевод с банковской карты
=============================
Перевод с банковской карты отличается от перевода из кошелька:
* Во-первых, он не требует запроса на авторизацию. Чтобы идентифицировать приложение для оплаты картами, разработчик регистрирует в Яндекс.Деньгах его копию и получает instance\_id с помощью [одноименного метода](https://tech.yandex.ru/money/doc/dg/reference/instance-id-docpage/);
* Во-вторых, отправителю где-то нужно указать реквизиты своей банковской карты. Чтобы отображать эту форму, разработчику нужно сформировать платеж на основе стандартизированного шаблона методом [request-external-payment](https://tech.yandex.ru/money/doc/dg/reference/request-external-payment-docpage/), а затем инициировать платежную операцию с помощью [process-external-payment](https://tech.yandex.ru/money/doc/dg/reference/process-external-payment-docpage/).
Если перевод сформировался успешно, метод **request-external-payment** вернет следующее:
```
{
"status": "success",
"title": "Перевод на счет 410011498692222",
"contract_amount": 102.04,
"request_id": "333235373135303437315f36313764393332336462393164373433353264303465346432626262313465353933363763333133",
"money_source": {
"payment-card": {}
}
}
```
После получения **request\_id** – уникального идентификатора контекста платежа – можно инициировать платежную операцию и перенаправить пользователя на форму Яндекс.Денег. Для этого используется POST-запрос по адресу acs\_uri с параметрами acs\_params, где плательщику нужно указать данные банковской карты.
Пример запроса:
```
POST /api/process-external-payment HTTP/1.1
Host: money.yandex.ru
Content-Type: application/x-www-form-urlencoded
request_id=333235373135303437315f36313764393332336462393164373433353264303465346432626262313465353933363763333133&instance_id=hh2CVJWrU9uU7N2hpEh1LvjfyBAby8USyMUEF4DM8AS6w93o53M3xrlGHsMUiWTL&ext_auth_success_uri=http%3A%2F%2Fexample.com%2Fsuccess%2F&ext_auth_fail_uri=http%3A%2F%2Fexample.com%2Ffalse%2F&request_token=false
```
И ответ:
```
{
"status": "ext_auth_required",
"acs_uri": "https://m.money.yandex.ru/internal/public-api/to-payment-type",
"acs_params": {
"cps_context_id": "333235373135303437315f36313764393332336462393164373433353264303465346432626262313465353933363763333133",
"paymentType": "FC"
}
}
```
*Карточная форма Яндекс.Денег.*
Непосредственное проведение платежа ложится на плечи Яндекс.Денег. После указания реквизитов банковской карты и нажатия на кнопку «Заплатить» пользователь попадет на страницу **3-D Secure** своего банка-эмитента и после ввода пароля возвращается к сервису разработчика: если 3-D Secure-аутентификация по банковской карте завершается успешно, он попадет на страницу с подтверждением платежа (ext\_auth\_success\_uri). Если же банк-эмитент отказал в аутентификации, пользователь перенаправляется на страницу с ошибкой (ext\_auth\_fail\_uri).
> Адреса перенаправления разработчик может указать при вызове метода process-external-payment.
Когда плательщик переходит на страницу успеха после проверки 3-D Secure, нужно удостовериться что авторизация по банковской карте тоже прошла успешно. Для этого разработчик повторно вызывает **process-external-payment** с ранее полученным **request\_id**.
Пример ответа:
```
{
"status": "success",
}
```
Обычно авторизация карты происходит в промежутке 10-20 секунд после аутентификации. Если в момент повторного вызова process-external-payment мы не получили состояние авторизации от банка, разработчик об этом обязательно узнает.
Пример подобного ответа:
```
{
"status": "in_progress",
"next_retry": "5000"
}
```
**Next\_retry** — рекомендуемое время в миллисекундах, когда следует повторить запрос. Поле присутствует только при статусе **in\_progress**.
Дополнительные возможности: конструктор форм и кнопок
=====================================================
Платежное решение с использованием API требует определенных усилий и сложного технологического взаимодействия. Более простой вариант заключается в использовании [готовых настраиваемых форм](https://money.yandex.ru/doc.xml?id=526991) Яндекс.Денег: в них информация о переводе разбита на параметры и передается методом POST на специальный адрес.
*Пример интерфейса формы переводов в кошелек стримера на Яндексе.*
Сценарий перевода с использованием кастомизированной формы выглядит так:
1. Отправитель выбирает, как перевести деньги — из электронного кошелька или с банковской карты.
2. Разработчик формирует строку из [набора параметров](https://money.yandex.ru/doc.xml?id=526991) Яндекс.Денег и передает их методом POST на адрес **money.yandex.ru/quickpay/confirm.xml** вместе с уникальной меткой платежа (label) для дальнейшей идентификации. Детали операции разработчик хранит в своей базе.
3. Плательщик переходит на страницу выбора способа оплаты и подтверждения перевода на стороне Яндекс.Денег, а сумма списывается и зачисляется на кошелек стримера. Разумеется, за вычетом комиссии.
4. Получатель узнает о поступлении средств через HTTP-уведомление, email, SMS, push. Адрес обработчика уведомлений получателю нужно заранее указать в настройках кошелька.
5. Разработчик анализирует поступившие на адрес обработчика детали и принимает решение о дальнейших действиях. В нашем случае, если входящая сумма удовлетворяла условиям стримера, в его видеопотоке передавалось сообщение подписчика с анимированным сопровождением. Сообщение воспроизводилось с использованием технологии [SpeechKit](https://tech.yandex.ru/speechkit/).
В этом сценарии есть один недостаток: для нормальной работы сервиса от стримера требуются лишние манипуляции с настройками HTTP-уведомлений внутри кошелька.
**В отличии от API, формы и кнопки позволяют переводить деньги с привязанной банковской карты. Однако комиссия берется только с получателя**.
Чтобы не требовать от стримера лишних манипуляций, достаточно научиться смотреть в его историю операций и сопоставлять уникальную метку перевода с данными из базы. Осталось только получить доступ к операциям стримера, для чего в самом начале статьи мы попросили стримера подтвердить доступ к правам **account-info** и **operation-history**. Первый метод поможет нам узнать номер кошелька стримера, второй — информацию по операциям.
Вот так выглядит ответ на запрос последних двух операций в кошельке стримера через API методом operation-history (перевод поступил через кастомизированную форму):
```
{
"next_record": "2",
"operations": [
{
"operation_id": "549575176734053012",
"title": "Перевод с банковской карты",
"amount": 49,
"direction": "in",
"datetime": "2017-05-31T19:46:16Z",
"label": "yadonate#1782",
"status": "success",
"type": "deposition"
},
{
"pattern_id": "p2p",
"operation_id": "1098088627442030025",
"title": "Перевод от 410011498790000",
"amount": 9.95,
"direction": "in",
"datetime": "2017-05-25T16:18:33Z",
"label": "testpayment",
"status": "success",
"type": "incoming-transfer"
}
]
}
```
После проверки успешности перевода в кошелек стримера можно творить в видеопотоке любимую вами магию.
В этом посте мы рассмотрели только самые базовые идеи и сценарии использования API для стриминговых сервисов. Если что-то непонятно, смело спрашивайте в комментариях. А если среди читателей есть стримеры или их зрители — поделитесь мнением о том, как сделать донаты удобнее и веселее.
Зарегистрироваться для участия можно на [Яндекс.Событиях](https://events.yandex.ru/events/meetings/18-august-2017/). **Прототипы и анкеты принимаем до 1 августа 2017.**
*От винта!* | https://habr.com/ru/post/330096/ | null | ru | null |
# Динамическая типизация C
### Преамбула
Эта статья была написана и опубликована мной на своем сайте более десяти лет назад, сам сайт с тех пор канул в лету, а я так и не начал писать что-то более вразумительное в плане статей. Все ниже описанное является результатом исследования C как языка двадцатилетним парнем, а, следовательно, не претендует на звание учебного пособия, несмотря на стиль изложения. Тем не менее, я искренне надеюсь, что она побудит молодых разработчиков погрузиться в эксперименты с C также, как когда-то делал это я.
### Предупреждение
Эта короткая статья, окажется абсолютно бесполезной для опытных программистов *C/C++*, но кому-то из начинающих, возможно, позволит сэкономить время. Хочу подчеркнуть, что в большинстве хороших книг по C/C++ данная тема рассмотрена в достаточной степени.
### Динамическая и статическая типизация
Во многих интерпретируемых языках используется динамическая типизация. Такой подход позволяет хранить в переменной с одним именем значения разных типов. В языке *C* используется статическая типизация, что, на мой взгляд более, чем правильно. Однако бывают случаи (хоть и не так часто), когда гораздо удобней было бы использовать динамическую типизацию. Зачастую, такая потребность напрямую связана с некачественным проектированием, но не всегда. Не зря же в *Qt* присутствует тип `QVariant`.
Здесь мы поговорим про язык C, хотя все, что описано ниже, применимо и к *C++*.
### Магия указателя пустоты
На самом деле, никакой динамической типизации в C нет и быть не может, однако существует универсальный указатель, тип которому `void *`. Объявление переменной такого типа, скажем, в качестве аргумента функции, позволяет передавать в нее указатель на переменную любого типа, что может быть крайне полезно. И вот он — первый пример:
```
#include
int main()
{
void \*var;
int i = 22;
var = &i
int \*i\_ptr = var;
if(i\_ptr)
printf("i\_ptr: %d\n", \*i\_ptr);
double d = 22.5;
var = &d
double \*d\_ptr = var;
if(d\_ptr)
printf("d\_ptr: %f\n", \*d\_ptr);
return 0;
}
```
**Вывод:**
```
i_ptr: 22
d_ptr: 22.500000
```
Здесь мы одному и тому же указателю присвоили указатели (простите за тавтологию) как на тип `int`, так и на `double`.
Первый пример не нес никакой полезной нагрузки. Попробуем ее поискать во втором примере:
```
#include
#include
int lilround(const void \*arg, const char type)
{
if(type == 0) // если передан int
return \*((int \*)arg); // просто возвращаем значение целого аргумента
// если передан double
return round(\*(double \*)arg); // округляем
}
int main()
{
int i = 12;
double j = 12.5;
printf("round int: %d\n", lilround(&i, 0)); // пытаемся округлить целое число
printf("round double: %d\n", lilround(&j, 1)); // пытаемся округлить число двойной точности
return 0;
}
```
**Вывод:**
```
round int: 12
round double: 13
```
Здесь мы создали, можно сказать, универсальную функцию для округления как целых чисел (которым оно не требуется, конечно), так и для чисел двойной точности. Следует понимать, что функция может выполнять и что-то более полезное, в зависимости от типа аргумента.
Альтернативная реализация функции `lilround()`:
```
int lilround(const void *arg, const char type)
{
return type == 0 ? *((int *)arg) : round(*((double *)arg));
}
```
Но для того, чтобы функция знала — с чем имеет дело — мы передаем в нее второй аргумент. Если он равен `0`, то первый интерпретируется как указатель на `int`, если нет — как указатель на `double`. Такой подход может во многих случаях сгодиться, но, в основном, смысл использования универсального указателя как раз-таки в том, чтобы не указывать тип передаваемого параметра.
Предположим, что у нас две или более структур (`struct`), которые содержат различный набор полей. Но так уж получилось, что нужно передать их одной и той же функции. Почему так вышло рассуждать не будем.
Что же делать? Ответ почти очевиден: передавать их в виде указателя неопределенного типа. И, все ничего, но как же тогда наша функция узнает об их типе? Все просто: в самое начало структуры добавим поле `type`, в которое будем записывать идентификатор структуры, по которому наша функция и будет определять ее тип, предварительно приведя неопределенный указатель к любой из структур. Идентификатором может быть поле любого типа, хоть еще одна структура, но оно должно стоять первым в каждой из структур и иметь один и тот же тип. Такое условие следует из способа расположения структур в памяти компьютера. Если написать так:
```
typedef struct {
char type;
int value;
} iStruct;
typedef struct {
char type;
double value;
} dStruct;
```
То все сработает корректно. Но если написать так:
```
typedef struct {
char type;
int value;
} iStruct;
typedef struct {
double value;
char type;
} dStruct;
```
То программа соберется, но во время работы выдаст неверный вариант, так как, в зависимости от того — к какой структуре приведем указатель, в случае обращения программа попытается считать первый байт из *double value* или, вообще, неизвестно откуда.
А вот и пример использования такого подхода:
```
#include
#include
#pragma pack(push, 1)
typedef struct {
char type; // идентификатор типа структуры
int value; // целочисленное значение
} iStruct;
#pragma pack(pop)
#pragma pack(push, 1)
typedef struct {
char type; // идентификатор типа структуры
double value; // значение двойной точности
} dStruct;
#pragma pack(pop)
int lilround(const void \*arg)
{
iStruct \*s = (iStruct \*)arg;
if(s->type == 0) // если передан int
return s->value; // просто возвращаем значение целого аргумента
// если передан double
double a = ((dStruct \*)arg)->value;
return round(a); // округляем
}
int main()
{
iStruct i;
i.type = 0;
i.value = 12;
dStruct j;
j.type = 1;
j.value = 12.5;
printf("round int: %d\n", lilround(&i)); // пытаемся округлить целое число
printf("round double: %d\n", lilround(&j)); // пытаемся округлить число двойной точности
return 0;
}
```
**Примечание:** директивы компилятора `#pragma pack(push, 1)` и `#pragma pack(pop)` необходимо помещать до и после каждой специфической структуры, соответственно. Данная директива используется для выравнивания структуры в памяти, что обеспечит корректность метода. Однако не стоит также забывать о порядке полей.
В теле функции аргумент приводится к структуре `iStruct` и проверяется значение поля type. Дальше уже аргумент приводится к другому типу структуры, если нужно.
Перед тем, как перейти к последней части, стоить пояснить работу с простыми void-указателями. Сложение, вычитание, инкремент, декремент и т.д. запрещены для типа `void`, поэтому необходимо сперва привести аргумент к нужному типу, а уж затем совершать операцию:
```
#include
int main()
{
int i = 22;
void \*var = &i // объявляем void-указатель и инициализируем его адресом переменной i
(\*(int \*)var)++; // приводим void-указатель к int-указателю, разыменовываем его и производим операцию инкремента
printf("result: %d\n", i); // выводим измененное значение i
return 0;
}
```
Исходя из кода: для совершения операции необходимо записать `(*(int *)var)` и уже к данной записи применить требуемый оператор.
#### Подобие интерфейсов в C
Вернемся к структурам. Если структура "засылается" далеко и глубоко в код, возможно даже чужой, то имеет смысл передать вместе с ней и методы, которые будут обрабатывать ее значения. Для этого создадим дополнительную структуру, которая заменит поле `type`:
```
typedef struct {
void (*printType)(); // указатель на функцию, выводящую тип
int (*round)(const void *); // указатель на функцию, округляющую значение
} uMethods;
```
Опишем реализации указанных выше функций для разных типов структур, а также — функции инициализации. Результат ниже:
```
#include
#include
typedef struct {
void (\*printType)(); // указатель на функцию, выводящую тип
int (\*round)(const void \*); // указатель на функцию, округляющую значение
} uMethods;
#pragma pack(push, 1)
typedef struct {
uMethods m; // структура с указателями на функции
int value; // целочисленное значение
} iStruct;
#pragma pack(pop)
#pragma pack(push, 1)
typedef struct {
uMethods m; // структура с указателями на функции
double value; // значение двойной точности
} dStruct;
#pragma pack(pop)
void intPrintType() // вывод типа для iStruct
{
printf("integer\n");
}
int intRound(const void \*arg) // округление для iStruct
{
return ((iStruct \*)arg)->value; // приводим аргумент к указателю на iStruct и возвращаем значение
}
void intInit(iStruct \*s) // инициализация iStruct
{
s->m.printType = intPrintType; // задаем полю printType указатель на функцию вывода для iStruct
s->m.round = intRound; // задаем полю round указатель на функцию округления для iStruct
s->value = 0;
}
void doublePrintType() // вывод типа для dStruct
{
printf("double\n");
}
int doubleRound(const void \*arg) // округление для dStruct
{
return round(((dStruct \*)arg)->value);
}
void doubleInit(dStruct \*s)
{
s->m.printType = doublePrintType; // задаем полю printType указатель на функцию вывода для dStruct
s->m.round = doubleRound; // задаем полю round указатель на функцию округления для dStruct
s->value = 0;
}
int lilround(const void \*arg)
{
((iStruct \*)arg)->m.printType(); // приводим к любой структуре, в данном случае iStruct, и выводим тип
return ((iStruct \*)arg)->m.round(arg); // возвращаем округленное значение
}
int main()
{
iStruct i;
intInit(&i); // инициализируем целочисленную структуру
i.value = 12;
dStruct j;
doubleInit(&j); // инициализируем структуру с данными двойной точности
j.value = 12.5;
printf("round int: %d\n", lilround(&i)); // пытаемся округлить целое число
printf("round double: %d\n", lilround(&j)); // пытаемся округлить число двойной точности
return 0;
}
```
**Вывод:**
```
integer
round int: 12
double
round double: 13
```
**Примечание:** директивами компилятора следует обрамлять только те структуры, которые необходимо использовать в качестве аргумента для void-указателя.
### Заключение
В последнем примере можно заметить сходство с ООП, что, в общем-то, правда. Здесь мы создаем структуру, инициализируем ее, задаем ее ключевым полям значения и вызываем функцию округления, которая, кстати говоря, крайне упростилась, хотя мы сюда же добавили вывод типа аргумента. На этом все. И помните, что применять подобные конструкции нужно размумно, ведь, в подавляющем большинстве задач их наличие не требуется.
UPD.: Спасибо модераторам хабра за указания на опечатки и досадные ошибки исходной версии текста.
UPD.: Спасибо [mastan](https://habr.com/ru/users/mastan/) за то замечание по поводу усложненного некорректного округления, хоть это и не относится к теме статьи, все же, лучше исправить на использование `round()` из `math.h`. Также была перефразирована часть про арифметику с `void` (не `void *`) благодаря замечанию [eanmos](https://habr.com/ru/users/eanmos/). При помощи разбора кода со стороны [sergio\_nsk](https://habr.com/ru/users/sergio_nsk/) код в статье стал более читаем и лишился спорной части с неподтвержденным примечанием. | https://habr.com/ru/post/560730/ | null | ru | null |
# Сказка о поломке или что делать, когда проблема не понятна
Я решил рассказать о ситуации, в которую мы попали по стечению обстоятельств при выполнении обычных работ по перенастройке MS SQL. Т.к. нигде не смогли найти информацию о подобных поломках, то имеет смысл это зафиксировать.
Предыстория такова: понадобилось перенести tempdb на новый раздел, подключенный к новому хранилищу.
Задача простая
1. пишем запрос, показывающий где у нас лежит tempdb:
`use tempdb`
`go`
`exec sp_helpfile`
`go`
2. пишем запрос для изменения настроек хранения tempdb:
`use master`
`go`
`alter database tempdb`
`modify file (name = tempdev, filename = 'Новый_Диск:\Новый_Каталог\tempdb.mdf')`
`go`
`alter database tempdb`
`modify file (name = templog, filename = 'Новый_Диск:\Новый_Каталог\templog.ldf')`
`go`
3. выполняем его и рестартуем службу SQL Server
После перезапуска службы tempdb создается уже на новом месте. Всё просто и понятно, всего два действия - выполнение запроса для переноса и рестарт службы. Ну а если служба не запустится, то идем в логи сервера и смотрим что помешало - места нет под tempdb, прав не хватает у службы SQL Server или неправильно путь указали для tempdb, всякое бывало в работе.
Приступаем. Запрос выполнили, службу перезапустили, служба перезапущена, проверяем коннект и SSMS зависает на попытке подключится к серверу. Идем смотреть логи сервера Windows и... ничего. Служба запущена без ошибок, проблем нет.
Очень сложно исправлять поломку, когда не понимаешь в чём её причина.
В текстовых логах MS SQL были лишь сообщения:
Logon Lo*gin failed for user 'AD\User'. Reason: Failed to open the explicitly specified database 'database'. [CLIENT: 10.10.1.10]*
*Logon Error: 18456, Severity: 14, State: 38.*
По коду ошибки было понятно, что есть проблемы с правами на базы данных, но подключится не получалось даже используя sa.
Т.к. идеи у нас быстро кончились, в интернете пытались найти причины проблемы с правами простым перебором:
1. Подключили диск для tempdb на раздел, где места с большим запасом. Маловероятно, что tempdb не создался из-за нехватки места и в логе это не указал, но проверить это требовалось. Не помогло.
2. Запустили SQL Server в минимальной конфигурации (с ключом –f). Файлы tempdb создались в варианте по умолчанию, но на доступ к серверу это не повлияло.
3. В минимальной конфигурации подключились используя DAC и попытались изменить ещё раз пути для tempdb. Обнаружили, что настройки из базы данных считываются, но не меняются, выдавая ошибку, что данного файла не существует.
Сложив полученное определили, что причиной проблем является повреждение базы master - из базы не могли получить данные о правах пользователя и tempdb, но в логе это никак не отражалось и понять в чем причина не удавалось. После восстановления базы master:
***DBCC CHECKALLOC ('master',REPAIR\_REBUILD);***
***CHECKALLOC found 0 allocation errors and 0 consistency errors in database 'master'.***
получили возможность подключится к остальными базам. Решение было неочевидным, т.к. на поломку базы master указывали только косвенные признаки, такие как недоступность информации о правах.
Два простых вывода - лог может подвести и понять в чем неисправность можно только по совокупности косвенных признаков и backup служебных баз может сильно сэкономить время на восстановление работы сервиса. | https://habr.com/ru/post/585192/ | null | ru | null |
# Чеклист фронтенд-разработчика
*Глеб Летушов, [редактор-фрилансер](http://gletushov.ru/), адаптировал для блога [Нетологии](https://netology.ru/?utm_source=blog&utm_medium=747&utm_campaign=habr) [чеклист](https://github.com/thedaviddias/Front-End-Checklist/blob/master/README.md) с Github от David Dias. Этот чеклист уже переводили, но так как на Хабре его нет, мы решили, что он пригодится. В чеклисте собран полный список элементов, которые необходимо проверить перед запуском и публикацией сайта.*
Список основан на многолетнем опыте фронтенд-разработчиков, а дополнения собраны из общедоступных источников.
Содержание
----------
1. Head
2. HTML
3. Шрифты
4. CSS
5. Изображения
6. JavaScript
7. Безопасность
8. Производительность
9. Доступность
10. SEO
### Как пользоваться
Все пункты из чеклиста обязательны для большинства проектов, но иногда некоторые из них можно опустить. Например, в случае приложения администрирования (administration web app), RSS не пригодится.
Head
----
Список элементов из раздела Head HTML-документа можно найти на [GitHub](https://github.com/joshbuchea/HEAD).
### Мета-теги
* **Doctype**: указывает на версию HTML-файла и находится в самом начале страницы. В Doctype должна быть указана пятая версия HTML.
```
```
*[Определение кодировки страницы HTML5 W3C](https://www.w3.org/TR/html5/syntax.html#determining-the-character-encoding)*.
*Следующие три мета-тега (Charset, X-UA Compatible и Viewport) необходимо поместить в начало страницы сразу после doctype:*
* **Charset**: кодировка документа — UTF-8.
```
```
* **X-UA-Compatible**: управляет отображением страницы в Internet Explorer, поэтому его необходимо задать.
```
```
*[Определение отображения страниц для Internet Explorer](https://msdn.microsoft.com/en-us/library/jj676915%28v=vs.85%29.aspx)*.
* **Viewport**: мета-тег Viewport задан правильно.
```
```
* **Title**: тег Title используется на всех страницах. Google вычисляет длину заголовка, и обрезает в выдаче те, которые больше 472 пикселей. Оптимальная длина для заголовка — около 55 символов.
```
Заголовок страницы короче 65 символов
```
*[Тег Title в HTML-документе — MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/title).
[SERP Snippet Generator – создание описания сайта, которое Google покажет на странице выдачи результатов поиска (для англ. текста)](https://www.sistrix.com/serp-snippet-generator/)*.
* **Description**: описание сайта внутри тега является уникальным и не превышает 150-и символов.
```
```
*[Тег Description в HTML -документе — MDN](https://developer.mozilla.org/en-US/docs/Learn/HTML/Introduction_to_HTML/The_head_metadata_in_HTML#Adding_an_author_and_description)*.
* **Favicon**: каждый фавикон корректно отображается. Если файл только один, favicon.ico, его нужно поместить в корневой каталог сайта. В таком случае ссылаться на него в HTML-документе необязательно. Однако ссылку на фавикон лучше указывать так, как на примере ниже. Оптимальный формат изображения — .*png*, а не *.ico*. Разрешение — 32×32 px.
```
```
*[Favicon Generator — создание фавикона.](https://www.favicon-generator.org/)
[RealFaviconGenerator](https://realfavicongenerator.net/).
[Гайд по фавиконам на GitHub](https://github.com/audreyr/favicon-cheat-sheet).
[Favicons, Touch Icons, Tile Icons, etc. Which Do You Need? — CSS Tricks](https://css-tricks.com/favicon-quiz/).
[PNG favicons — caniuse](https://caniuse.com/#feat=link-icon-png)*.
* **Apple Touch Icon**: установлена иконка Apple touch icon для отображения на iOS-устройствах. *(Разрешение файла должно быть 200x200 px, чтобы иконка хорошо отображалась на всех устройствах).*
```
```
*[Configuring Web Applications](https://developer.apple.com/library/content/documentation/AppleApplications/Reference/SafariWebContent/ConfiguringWebApplications/ConfiguringWebApplications.html)*.
* **Windows Tiles** указан следующим образом:
```
Browser configuration schema reference
```
* **Xml-разметка** для файла browserconfig.xml выглядит так, как на примере:
```
xml version="1.0" encoding="utf-8"?
```
*[Browser configuration schema reference](https://msdn.microsoft.com/en-us/library/dn320426%28v=vs.85%29.aspx)*.
* **Атрибут canonical**: используйте rel=«canonical», чтобы избежать повторения контента.
```
```
*[Use canonical URLs — Search Console Help — Google Support](https://support.google.com/webmasters/answer/139066?hl=en).
[5 common mistakes with rel=canonical — Google Webmaster Blog](https://webmasters.googleblog.com/2013/04/5-common-mistakes-with-relcanonical.html)*.
### HTML-теги
* **Атрибут lang**: должен указывать язык текущей HTML-страницы.
* **Direction**: направление текста задано в специальном HTML-теге.
*[dir — HTML — MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/dir)*.
* **Переадресация на страницу с другим языком**: значение атрибута rel установлено как alternate.
* **Условные комментарии для Internet Explorer**: задаются, если необходимы.
```
Код для браузера Internet Explorer <![endif]–>
```
*[About conditional comments (Internet Explorer) — MSDN — Microsoft](https://msdn.microsoft.com/en-us/library/ms537512%28v=vs.85%29.aspx)*.
* **RSS**: если вы готовите к запуску блог или сайт со статьями, то не забудьте задать ссылку на RSS.
* **Инлайновый критический CSS**: задан критический CSS — это стили, которые мгновенно загружаются во время открытия страницы. Обычно подключается до основного CSS-файлы с помощью тега Style.
*[Critical by Addy Osmani on Github](https://github.com/addyosmani/critical) — автоматизирует создание критического CSS.*
* **Правильный вызов CSS**: все CSS-файлы должны быть подключены до JavaScript в разделе Head. Исключение составляют JS-файлы, которые загружаются асинхронно и расположены в самом верху страницы.
### Мета-теги для социальных сетей
*На любой сайт желательно добавить основные мета-теги Facebook и* *Twitter. Остальные теги можно добавить при необходимости*.
* **Facebook Open Graph**: теги Facebook Open Graph (OG) проверены, настроены и отображают нужную информацию. Размер изображений должен быть хотя бы 600 x 315 px, а лучше 1200 x 630 px.
```
```
*[A Guide to Sharing for Webmasters](https://developers.facebook.com/docs/sharing/webmasters/).
Проверить страницу с помощью [валидатора Facebook OG](https://developers.facebook.com/tools/debug/)*.
* **Twitter Card**: должен быть настроен как на примере ниже.
```
```
*[Getting started with cards — Twitter Developers](https://developer.twitter.com/en/docs/tweets/optimize-with-cards/guides/getting-started).
Проверить сайт с помощью [валидатора Twitter card](https://cards-dev.twitter.com/validator)*.
HTML
----
* **Семантические элементы HTML5**: элементы HTML5 используются надлежащим образом (header, section, footer, main…).
*[HTML Reference](http://htmlreference.io/) — удобная инструкция по HTML*.
* **Страницы ошибок**: созданы страницы для 404 и 500-х ошибок. Страницы пятисотых ошибок должны включать в себя стили CSS (без внешних вызовов на сервере).
* **Noopener**: если внешнюю ссылку необходимо открывать в новой вкладке с помощью *target="\_blank"*, то добавьте к ним атрибут *rel=«noopener»*. Это предотвратит кражу данных пользователей, если страница другого сайта используется для фишинга. Для старых версий браузера Firefox задайте атрибут *rel=«noopener noreferrer»*.
*[About rel=noopener](https://mathiasbynens.github.io/rel-noopener/)*.
* **Комментарии**: перед публикацией страницы убедитесь, что удалили все комментарии и ненужный код.
### Тестирование HTML-верстки
* **W3C-валидатор**: все страницы сайта необходимо протестировать валидатором на сайте W3C. Он поможет найти незамеченные ошибки в HTML-коде.
*[W3C validator](https://validator.w3.org/)*.
* **Оформление HTML-кода**: чтобы поправить недочеты в коде и сократить его размер, воспользуйтесь специальным сервисом.
*[Dirty markup](https://dirtymarkup.com/)*.
* **Проверка ссылок на странице**: все ссылки рабочие и не выдают 404 ошибку при переходе.
*[W3C Link Checker](https://validator.w3.org/checklink)*.
Шрифты
------
* **Формат подключенного шрифта**: форматы WOFF, WOFF2 and TTF поддерживаются всеми современными браузерами.
*[WOFF — Web Open Font Format — Caniuse](https://caniuse.com/#feat=woff).
[WOFF 2.0 — Web Open Font Format — Caniuse](https://caniuse.com/#feat=woff2).
[TTF/OTF — TrueType and OpenType font support](https://caniuse.com/#feat=ttf).
[Using @font-face — CSS-Tricks](https://css-tricks.com/snippets/css/using-font-face/)*.
* **Вес шрифта**: не превышает 2-х Мб.
CSS
---
Ознакомьтесь [с руководством по CSS](https://cssguidelin.es/) и [гайдом по Sass](https://sass-guidelin.es/), многие ведущие фронтенд-разработчики придерживаются правил, описанных в этих руководствах. Если возникнут дополнительные вопросы по CSS, ответы можно найти на [CSS Reference](http://cssreference.io/).
* **Адаптивный дизайн**: верстка на сайте адаптивная.
* **Печать с помощью CSS**: таблицы печати настроены корректно для каждой страницы.
* **Препроцессоры**: страница использует CSS-препроцессор ([Sass](http://sass-lang.com/) предпочтительней).
* **Уникальные ID**: идентификаторы на странице не повторяются.
* **Reset CSS**: на странице подключены актуальные CSS-файлы для сброса стандартных стилей браузера (reset, normalize или reboot). Во многие CSS-фреймворки, например, в Bootstrap или Foundation, включен файл *Normalize.css*.
*[Reset.css](https://meyerweb.com/eric/tools/css/reset/).
[Normalize.css](https://necolas.github.io/normalize.css/).
[Reboot](https://getbootstrap.com/docs/4.0/content/reboot/)*.
* **JS-префиксы**: все классы или id, используемые в JS, начинаются с js- и не используются для задания стилей через CSS.
```
```
* **Тег Style в HTML-документе**: избегайте использования тега Style для задания стилей внутри HTML-страницы. В некоторых случая использование оправдано, например, для задания фона для слайдера.
* **Вендорные префиксы**: вендорные префиксы CSS решают проблемы с совместимостью со старыми версиями браузеров.
-webkit — Chrome и Safari,
-o — Opera;
-ms — Internet Explorer;
-moz — Mozilla.
*[Autoprefixer CSS online](https://autoprefixer.github.io/)*.
### Производительность
* **Объединение CSS-файлов**: все файлы CSS объединены в один файл. (*Не подходит для HTTP/2*).
* **Оптимизация**: все CSS-файлы сжаты.
* **CSS, блокирующие отображение сайта**: убедитесь, что CSS-файлы не блокируют отображение контента, увеличивая время загрузки страницы.
*[loadCSS by filament group](https://github.com/filamentgroup/loadCSS).
[Example of preload CSS using loadCSS](https://gist.github.com/thedaviddias/c24763b82b9991e53928e66a0bafc9bf)*.
* **Неиспользуемый CSS-код**: весь лишний код удален.
*[UnCSS Online](https://uncss-online.com/).
[PurifyCSS](https://github.com/purifycss/purifycss).
[Chrome DevTools Coverage](https://developers.google.com/web/updates/2017/04/devtools-release-notes#coverage)*.
### Тестирование CSS
* **Stylelint**: все CSS и SCSS файлы без ошибок.
*[stylelint, a CSS linter](https://stylelint.io/).
[Sass guidelines](https://sass-guidelin.es/)*.
* **Адаптивный дизайн**: страницы сайта протестированы для разрешений: 320 px, 768 px, 1024 px (можно проверить и на других разрешениях в зависимости от цели сайта).
* **CSS Validator**: найдены и исправлены все ошибки в CSS-файлах.
*[CSS Validator](https://jigsaw.w3.org/css-validator/)*.
* **Браузеры**: страницы сайта протестированы в популярных браузерах (Safari, Firefox, Chrome, Internet Explorer).
* **Мобильные браузеры**: сайт проверен в мобильных браузерах (Chrome, Safari…).
* **OS**: сайт протестирован в популярных операционных системах (Windows, Android, iOS, MacOS)
* **Pixel perfect**: страница сверстана максимально точно. Конечно, не на 100%, но все же стоит придерживаться шаблона.
*[Pixel Perfect — Chrome Extension](https://chrome.google.com/webstore/detail/perfectpixel-by-welldonec/dkaagdgjmgdmbnecmcefdhjekcoceebi?hl=en)*.
* **Направление чтения**: если в проекте нужно поддержка не только языков, которые читаются слева направо (left-to-right — LTR), но и тех, которые читаются справа налево (right-to-left — RTL), то нужно проверить, поддерживает ли их сайт.
*[Building RTL-Aware Web Apps & Websites: Part 1 — Mozilla Hacks](https://hacks.mozilla.org/2015/09/building-rtl-aware-web-apps-and-websites-part-1/).
[Building RTL-Aware Web Apps & Websites: Part 2 — Mozilla Hacks](https://hacks.mozilla.org/2015/10/building-rtl-aware-web-apps-websites-part-2/)*.
Изображения
-----------
Чтобы разобраться в оптимизации изображений, посмотрите книгу [Essential Image Optimization](https://images.guide/) (на англ.) от Эдди Озмани (Addy Osmani).
* **Оптимизация**: Все изображения оптимизированы для отображения в браузере. Формат WebP можно использовать на важных страницах, например, на главной.
*[Imagemin](https://github.com/imagemin/imagemin).
Бесплатно оптимизировать изображение можно с помощью [ImageOptim](https://imageoptim.com/)*.
* **Picture/Srcset**: использованы атрибуты *picture/srcset* для того, чтобы отображать наиболее подходящую картинку в данном разрешении (размере) экрана.
*[How to Build Responsive Images with srcset](https://www.sitepoint.com/how-to-build-responsive-images-with-srcset/)*.
* **Retina**: все изображения должны иметь 2x или 3x разрешения, чтобы хорошо отображаться на retina-дисплеях.
* **Спрайт-файл**: маленькие картинки на сайте объединены в один спрайт-файл. Это большое изображение, состоящие из мелких картинок. Если это иконки, то их можно объединить в спрайт-картинку SVG формата.
* **Ширина и высота**: если заранее известны нужные размеры изображения, то ширина и высота должна быть задана в атрибуте img.
* **Описание изображения**: все картинки img должны быть описаны словами в атрибуте alt.
```
![’Описание]()
```
*[Alt-texts: The Ultimate Guide](https://axesslab.com/alt-texts/)*.
* **Отложенная загрузка изображений**: сайт настроен так, чтобы изображения загружались не сразу, а по мере пролистывания сайта.
JavaScript
----------
* **JavaScript-код отдельными файлами**: в HTML-документе не должно быть встроенного JS-кода. Лучше просто указать ссылку на файл с кодом.
* **Объединение**: JavaScript-файлы объединены в один.
* **Оптимизация**: все JavaScript-файлы минимизированы (можно добавить суффикс .min к названию).
*[Minify Resources (HTML, CSS, and JavaScript)](https://developers.google.com/speed/docs/insights/MinifyResources)*.
* **Безопасность JavaScript**:
*[Guidelines for Developing Secure Applications Utilizing JavaScript](https://www.owasp.org/index.php/DOM_based_XSS_Prevention_Cheat_Sheet#Guidelines_for_Developing_Secure_Applications_Utilizing_JavaScript)*.
* **Async или defer**: JavaScript-файлы загружаются асинхронно при помощи атрибута async, или используют атрибут defer, который запускает скрипт только после полной загрузки страницы.
*[Remove Render-Blocking JavaScript](https://developers.google.com/speed/docs/insights/BlockingJS)*.
* **Modernizr**: если нужно добавить на сайт специфическую функцию, то можно использовать JS-библиотеку Modernizr. Она определяет, какие возможности HTML, CSS, JS поддерживает браузер пользователя.
*[Modernizr](https://modernizr.com/)*.
### JavaScript-тестирование
* **ESLint**: JavaSript-код проверен в ESLint, исправлены ошибки.
*[ESLint — The pluggable linting utility for JavaScript and JSX](https://eslint.org/)*.
Безопасность
------------
### Проверьте сайт
*[securityheaders.io](https://securityheaders.io/) — проверяет HTTP-заголовки безопасности.
[Observatory by Mozilla](https://observatory.mozilla.org/) — указывает на слабые места в безопасности.
[ASafaWeb — Automated Security Analyser for ASP.NET Websites](https://asafaweb.com/)*.
* **HTTPS**: HTTPS используется не только на всех страницах, но и для внешних элементов — плагины, изображения.
*[Let’s Encrypt — Free SSL/TLS Certificates](https://letsencrypt.org/).
[Free SSL Server Test](https://www.ssllabs.com/ssltest/index.html).
[Strict Transport Security](http://caniuse.com/#feat=stricttransportsecurity)*.
* **HTTP Strict Transport Security (HSTS)**: настроен HSTS, принудительно активирующий соединение через HTTPS.
*[Check HSTS preload status and eligibility](https://hstspreload.org/).
[HTTP Strict Transport Security Cheat Sheet — OWASP](https://www.owasp.org/index.php/HTTP_Strict_Transport_Security_Cheat_Sheet).
[Transport Layer Protection Cheat Sheet — OWASP](https://www.owasp.org/index.php/Transport_Layer_Protection_Cheat_Sheet)*.
* **Межсайтовая подделка запроса (CSRF)**: чтобы предотвратить CSRF, вы должны быть уверены, что запросы на сервер происходят именно с вашего сайта или приложения.
*[Cross-Site Request Forgery (CSRF) Prevention Cheat Sheet — OWASP](https://www.owasp.org/index.php/Cross-Site_Request_Forgery_%28CSRF%29_Prevention_Cheat_Sheet)*.
* **Межсайтовый скриптинг (XSS)**: На странице или сайте не должно быть XSS-запросов.
*[XSS (Cross Site Scripting) Prevention Cheat Sheet — OWASP](https://www.owasp.org/index.php/XSS_%28Cross_Site_Scripting%29_Prevention_Cheat_Sheet).
[DOM based XSS Prevention Cheat Sheet — OWASP](https://www.owasp.org/index.php/DOM_based_XSS_Prevention_Cheat_Sheet)*.
* **Content Type Options**: в Google Chrome и Internet Explorer предотвращает попытки mime-сниффинговых атак и подмены типов mime на отличные от тех, что были заявлены на сервере.
*[X-Content-Type-Options — Scott Helme](https://scotthelme.co.uk/hardening-your-http-response-headers/#x-content-type-options)*.
* **X-Frame-Options (XFO)**: посетители сайта защищены от кликджекинга.
*[X-Frame-Options — Scott Helme](https://scotthelme.co.uk/hardening-your-http-response-headers/#x-frame-options).
[RFC7034 — HTTP Header Field X-Frame-Options](https://tools.ietf.org/html/rfc7034)*.
Производительность
------------------
* **Вес страницы**: каждая страница весит до 500 Кб.
*[Website Page Analysis](https://tools.pingdom.com/)*.
[Size Limit: Make the Web lighter](https://evilmartians.com/chronicles/size-limit-make-the-web-lighter).
* **Оптимизация**: HTML-код минимизирован.
*[W3C Validator](https://validator.w3.org/)*.
* **Отложенная загрузка элементов (Lazy loading)**: изображения, скрипты и CSS-стили загружаются по мере пролистывания страницы, чтобы уменьшить время отзыва сайта.
* **Размер Cookies**: если вы используете cookies, то проверьте, чтобы размер каждого файла был бы не более 4096 байтов, а общее количество файлов не превышало 20.
*[Cookie specification: RFC 6265](https://tools.ietf.org/html/rfc6265).
[Cookies](https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies).
[Browser Cookie Limits](http://browsercookielimits.squawky.net/)*.
* **Компоненты сторонних разработчиков**: сторонние фреймы iframe и внешние скрипты JS (например, кнопки «поделиться») заменены на статические элементы, где это возможно. Это ограничивает количество вызовов внешних API и сохраняет в тайне от сторонних сервисов действия пользователей на вашем сайте.
*[Simple sharing buttons generator](https://simplesharingbuttons.com/)*.
### Запросы
*[Explanation of the following techniques](https://css-tricks.com/prefetching-preloading-prebrowsing/)*.
* **DNS-prefetch**: время загрузки DNS других сайтов сокращается благодаря использованию предсказывающих страниц с *dns-prefetch*.
* **Preconnection**: поиск DNS, установка TCP и TLS-связи с сервисами, которые скоро понадобятся, выполняется заранее во время простоя с помощью *preconnect*.
* **Prefetching**: ресурсы, которые скоро понадобятся (например, изображения при ленивой загрузке) загружаются браузером заранее и помещаются в кэш с помощью *prefetch*.
* **Preloading**: ресурсы, которые будут нужны на текущей странице (например, скрипты, находящиеся в конце тега Body), можно загрузить с помощью
*preload*.
*[Difference between prefetch and preload](https://medium.com/reloading/preload-prefetch-and-priorities-in-chrome-776165961bbf)*.
### Тестирование производительности
* **Google PageSpeed**: все страницы сайта (не только домашняя) были протестированы в Google PageSpeed и набрали по крайней мере 90 очков из 100.
*[Google PageSpeed](https://developers.google.com/speed/pagespeed/insights/).
[Test your mobile speed with Google](https://testmysite.withgoogle.com/).
[WebPagetest — Website Performance and Optimization Test](https://www.webpagetest.org/)*.
Доступность
-----------
Посмотрите плейлист [A11ycasts с Rob Dodson](https://www.youtube.com/playlist?list=PLNYkxOF6rcICWx0C9LVWWVqvHlYJyqw7g) (англ.).
* **Progressive enhancement**: Большинство функций сайта, например, навигация или поиск, должны работать с выключенным JavaScript.
*[Enable / Disable JavaScript in Chrome Developer Tools](https://www.youtube.com/watch?v=kBmvq2cE0D8)*.
* **Цветовой контраст**: цветовой контраст сайта соответствует стандарту WCAG AA (для мобильных — AAA).
*[Contrast ratio](https://leaverou.github.io/contrast-ratio/)*.
### Заголовки
* **H1**: на всех страницах присутствует заголовок H1, который отличается от названия сайта, заданного в title.
* **Заголовки**: заголовки использованы в правильном порядке — от H1 до H6.
*[Why headings and landmarks are so important — A11ycasts #18](https://www.youtube.com/watch?v=vAAzdi1xuUY&index=9&list=PLNYkxOF6rcICWx0C9LVWWVqvHlYJyqw7g)*.
### Landmarks
* **Role banner**: для тега Header указан атрибут *role=«banner»*.
* **Role navigation**: для Nav — атрибут *role=«navigation»*.
* **Role main**: для Main указан атрибут *role=«main»*.
*[Using ARIA landmarks to identify regions of a page](https://www.w3.org/WAI/GL/wiki/Using_ARIA_landmarks_to_identify_regions_of_a_page)*.
### Семантика
* **Использованы разные типы input-ов на HTML5**: это важно для мобильных устройств, потому что для разных типов вводимых данных они показывают по-разному выглядящие клавиатуры.
*[Mobile Input Types](http://mobileinputtypes.com/)*.
### Формы
* **Label**: связан с каждым отдельным input-ом в элементах формы. Если label не может быть отображен, нужно использовать aria-label.
*[Using the aria-label attribute — MDN](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/ARIA_Techniques/Using_the_aria-label_attribute)*.
### Тестирование доступности
* **Стандарты тестирования доступности**: чтобы протестировать страницу, используйте WAVE.
*[Wave testing](http://wave.webaim.org/)*.
* **Навигация с помощью клавиатуры**: проверьте свой сайт, пользуясь только клавиатурой. Все элементы на сайте должны быть доступны для использования.
* **Скрин-ридер**: все страницы сайта должны работать в программах для чтения информации (VoiceOver, ChromeVox, NVDA или Lynx).
* **Фокус**: если фокус для элементов отключен, он заменяется видимым в CSS состоянием.
*[Managing Focus — A11ycasts #22](https://www.youtube.com/watch?v=srLRSQg6Jgg&index=5&list=PLNYkxOF6rcICWx0C9LVWWVqvHlYJyqw7g)*.
SEO
---
* **Google Analytics**: Google Analytics установлен и корректно работает.
* **Заголовки**: текст в заголовках помогает понимать информацию на текущей странице.
* **sitemap.xml**: создана карта сайта sitemap.xml и отправлена в Google Search Console (Google Webmaster Tools).
* **robots.txt**: файл *robots.txt* не блокирует страницы сайта.
*Проверить robots.txt с помощью [Google Robots Testing Tool](https://www.google.com/webmasters/tools/robots-testing-tool)*.
* **Структурированные данные**: помогают поисковым роботам понимать информацию на страницах. Поэтому страницы должны быть протестированы и не содержать ошибок.
*[Introduction to Structured Data — Search — Google Developers](https://developers.google.com/search/docs/guides/intro-structured-data).
Проверьте сайт с помощью [Structured Data Testing Tool](https://developers.google.com/structured-data/testing-tool/).
Полный список классов для структурирования данных можно найти на [Schema.org](http://schema.org/docs/full.html)*.
* **HTML-карта сайта**: работает и доступна в футере сайта.
*[Sitemap guidelines — Google Support](https://support.google.com/webmasters/answer/183668?hl=en).
[Sitemap generator](https://websiteseochecker.com/html-sitemap-generator/)*.
От редакции
-----------
Онлайн-курсы Нетологии по теме:
* курс «[HTML-верстка: с нуля до первого макета](https://netology.ru/programs/html-verstka?utm_source=blog&utm_medium=747&utm_campaign=habr)»;
* курс «[Адаптивная и мобильная верстка](https://netology.ru/programs/adaptive-mobile-layout?utm_source=blog&utm_medium=747&utm_campaign=habr)»;
* профессия «[Frontend-разработчик](https://netology.ru/programs/front-end?utm_source=blog&utm_medium=747&utm_campaign=habr)»;
* профессия «[Веб-разработчик](https://netology.ru/programs/web-developer)»;
* бесплатный курс для начинающих «[HTML и CSS с нуля](https://netology.ru/programs/html-css-base?utm_source=blog&utm_medium=747&utm_campaign=habr)». | https://habr.com/ru/post/347740/ | null | ru | null |
# Symfony 2 Internals на практике
Пост навеян вот [этим](http://habrahabr.ru/qa/22083/) вопросом. Будем использовать стандартные эвенты Symfony для переопределения вывода контроллера. Итак, как, в общем, всё это будет работать:
1. Создадим аннотацию Ajax для обработки типа контента контроллера
2. Будем обрабатывать эту аннотацию через эвенты
3. Будем переопределять тип контента в соответствии с выбранным типом в аннотации
Сразу предупрежу, код не претендует на идеальный, не используется кэширование (позднее скажу об этом), но главная идея, думаю, будет понятной. Также, более подробно почитать о Symfony2 Internals вы можете в [официальной документации](http://symfony.com/doc/current/book/internals.html).
Итак, преступим.
Для начала определим класс аннотации:
```
namespace SomeNamespace\SomeBundle\Annotations;
/** @Annotation */
class Ajax
{
/**
* @var array @contentType
*/
public $contentType;
/**
* @var array @parameters
*/
public $parameters;
public function __construct($data)
{
if (isset($data['value'])) {
$this->contentType = $data['value'];
}
if (isset($data['parameters'])) {
$this->parameters = $data['parameters'];
}
}
/**
* @param array $contentType
*/
public function setContentType($contentType)
{
$this->contentType = $contentType;
}
/**
* @return array
*/
public function getContentType()
{
return $this->contentType;
}
}
```
Эта аннотация и определяет тип контента, отдаваемый контроллером.
Далее создадим слушатель эвентов:
```
namespace SomeNamespace\SomeBundle\Event;
use Symfony\Component\HttpKernel\Event\KernelEvent;
use Symfony\Component\HttpKernel\Event\GetResponseForControllerResultEvent;
use Doctrine\Common\Annotations\Reader;
use Symfony\Component\HttpFoundation\Response;
/**
* Controller Event listener
*/
class ControllerListener
{
/**
* @var ServiceContainer
*/
private $container;
/**
* Parameters of Event Listener
*
* @var array
*/
private $parameters;
/**
* @var AnnotationsReader
*/
private $annotationReader;
//В конструкторе мы будем искать контент-тайпы в директории Core/ContentTypes
public function __construct($c, $a)
{
$this->container = $c;
$this->annotationReader = $a;
//@TODO здесь небольшой быдлокод, по хорошему это нужно делать при обновлении кэша. Также, хотелось бы чтобы контент-тайпы собирались не только из этого бандла, а из всех.
$classes = array();
$namespace = 'SomeNamespace\SomeBundle';
$namespace = str_replace('\\', '/', $namespace);
$dir = opendir('../src/' . $namespace . '/Core/ContentTypes');
while ($classes[] = str_replace('.php', '', readdir($dir))) {
;
}
foreach ($classes as $key => $class) {
if ($class == '') {
unset($classes[$key]);
continue;
}
if ($class[0] == '.') {
unset($classes[$key]);
}
}
$this->parameters['contentTypes'] = $classes;
}
/**
* Controller event listener
*
* @param \Symfony\Component\HttpKernel\Event\KernelEvent $event
*/
public function onKernelController(KernelEvent $event)
{//это событие возникает при каждом вызове контроллера. Здесь мы будем читать аннотации. Если кто не знает, можно посмотреть мою предыдущую статью, там всё это описано, здесь я не буду на этом останавливаться
$controller = $event->getController();
$object = new \ReflectionObject($controller[0]);
$method = $object->getMethod($controller[1]);
$annotations = $this->annotationReader->getMethodAnnotations($method);
$response = new Response();
$this->parameters['attributes'] = $event->getRequest()->attributes;
foreach ($annotations as $annotation) {
if ($annotation instanceof \ITE\JSBundle\Annotations\Ajax) {
$this->parameters['annotation'] = $annotation;
}
}
$class = NULL;
$params = array();
if (isset($this->parameters['annotation'])) {
if (isset($this->parameters['annotation']->parameters)) {
$params = $this->parameters['annotation']->parameters;
}
foreach ($this->parameters['contentTypes'] as $contentType) {
$className = '\ITE\JSBundle\Core\ContentTypes\\' . $contentType;
$name = $className::getName();
if ($name == $this->parameters['annotation']->contentType) {
$class = $className;
}
}
if (!$class) {
throw new \ITE\JSBundle\Core\Exception\ContentTypeException(
'ContentType "' . $this->parameters['annotation']->contentType . '" is not found!');
}
//Создаём объект контент-тайпа и вызываем первый хук. Об этой структуре расскажу ниже.
$contentType = new $class($this->container, $params);
$this->parameters['contentType'] = $contentType;
$contentType->hookPre($event->getRequest());
}
}
/**
* Controller Response listener
*
* @param $event
*/
public function onKernelResponse($event)
{// Этот эвент вызывается при каждом ответе контроллера. Здесь я встраиваю свой javascript в страницу, также, как это делает Symfony Profiler. В этом эвенте можно переопределить ответ контроллера
$response = $event->getResponse();
$response = $this->addJavascript($response);
$event->setResponse($response);
}
/**
* Controller Request listener
*
* @param $event
*/
public function onKernelRequest($event)
{ // Вызывается при запросе контроллера. Здесь можно переопределить параметры запроса
$this->generateRoutes();
}
/**
* Controller response listener
*
* @param GetResponseForControllerResultEvent $event
*/
public function onKernelView(GetResponseForControllerResultEvent $event)
{
// Этот эвент вызывается перед выводом. И соответсвенно перед onKernelResponse
if (isset($this->parameters['contentType'])) {
$contentType = $this->parameters['contentType'];
$response = new Response;
$response->setContent($contentType->encodeParameters($event->getControllerResult()));
$response = $contentType->hookPost($response);
$event->setResponse($response);
}
}
/**
* Generating route array and move to javascript file
*/
private function generateRoutes()
{ // По хорошему, это нужно делать при обновлении кэша
$routeCollection = $this->container->get('router')->getRouteCollection();
$routes = array();
foreach ($routeCollection->all() as $route) {
$r = array();
$defaults = $route->getDefaults();
try {
$method = new \ReflectionMethod($defaults['_controller']);
} catch (\Exception $e) {
continue;
}
$ann = $this->annotationReader->getMethodAnnotations($method);
foreach ($ann as $a) {
if ($a instanceof \Sensio\Bundle\FrameworkExtraBundle\Configuration\Route) {
$r[$a->getName()] = $route->getPattern();
}
}
$routes += $r;
}
$path = __FILE__;
$path = str_replace('Event' . DIRECTORY_SEPARATOR . 'ControllerListener.php', '', $path);
$path .= 'Resources' . DIRECTORY_SEPARATOR . 'js' . DIRECTORY_SEPARATOR . 'routing_template.js';
$content = file_get_contents($path);
$route_string = json_encode($routes);
$content = str_replace('__routes__', $route_string, $content);
$kernel = $this->container->get('kernel');
$params = array(
'env' => $kernel->getEnvironment(),
'debug' => $kernel->isDebug(),
'name' => $kernel->getName(),
'startTime' => $kernel->getStartTime(),
);
$content = str_replace('__params__', json_encode($params), $content);
$path = str_replace('routing_template', 'routing', $path);
file_put_contents($path, $content);
}
/**
* Adding global Symfony javascript
*
* @param $response
*
* @return mixed
*/
private function addJavascript($response)
{// Добавляем свой яваскрипт в каждую страницу
$content = $response->getContent();
$arr = explode('', $content);
if (count($arr) == 1) {
return $response;
}
$twig = $this->container->get('templating');
$c = $twig->render('SomeNamespaceSomeBundle:Javascript:js.html.twig');
$content = $arr[0] . $c . "" . $arr[1];
$response->setContent($content);
return $response;
}
}
```
И зарегистрируем его в системе:
```
#SomeBundle\Resources\config\services.yml
services:
my.ajax.listener:
class: "SomeNamespace\SomeBundle\Event\ControllerListener"
tags: [{name: kernel.event_listener, event: kernel.response, method: onKernelResponse, priority: -128}, {name: kernel.event_listener, event: kernel.request, method: onKernelRequest}, {name: kernel.event_listener, event: kernel.view, method: onKernelView, priority: -128}, {name: kernel.event_listener, event: kernel.controller, method: onKernelController}]
arguments: [@service_container, @annotation_reader]
```
Обратите внимание на ещё один аргумент: priority. Он задаёт приоритет эвента. Если приводить пример, то мне в голову приходит Drupal. Это аналог веса модуля, только наоборот. В друпале, чем больше вес, тем позже вызовется хук. А в Symfony, чем больше приоритет, тем раньше вызовется эвент.
Итак, как выглядет структура каждого контент-тайпа:
Для начала, создадим интерфейс:
```
namespace SomeNamespace\SomeBundle\Core;
interface ContentTypeInterface {
/**
* Get the name of ContentType
* @abstract
* @return mixed
*/
public static function getName();
/**
* Encoder
* @abstract
* @param $data
* @return mixed
*/
public function encodeParameters($data);
/**
* Decoder
* @abstract
* @param $data
* @return mixed
*/
public function decodeParameters($data);
/**
* Prepares request
* @abstract
* @param Request
* @return mixed
*/
public function hookPre($request);
/**
* Changes response
* @abstract
* @param Response
* @return mixed
*/
public function hookPost($response);
}
```
А теперь расскажу поподробнее:
* encodeParameters — кодирует входные данные в нужный контент-тайп (например, для JSON это будет json\_encode)
* decodeParameters — декодирует входные данные в нужный контент-тайп (например, для JSON это будет json\_decode). Это может пригодиться, если данные приходят вам запакованными этим же контент-тайпом в один параметр POST
* hookPre — вызывается при запросе к контроллеру, здесь контент-тайп может делать всё что угодно с объектом request
* hookPost — вызывается при ответе контроллера, здесь контент-тайп может делать всё что угодно с объектом response
Далее мы создадим класс, который будет реализовывать наш интерфейс, от которого будут наследоваться все контент-тайпы:
```
namespace SomeNamespace\SomeBundle\Core;
class ContentType implements ContentTypeInterface
{
/**
* @var ServiceContainer
*/
protected $container;
/**
* @var array parameters
*/
protected $parameters;
/**
* Public constructor
* @param $container
*/
public function __construct($container, $params = array()){
$this->container = $container;
$this->parameters = $params;
}
/**
* Get the name of ContentType
* @return mixed
*/
public static function getName()
{
return 'contentType';
}
/**
* Encoder
* @param $data
* @return mixed
*/
public function encodeParameters($data)
{
return $data;
}
/**
* Decoder
* @param $data
* @return mixed
*/
public function decodeParameters($data)
{
return $data;
}
/**
* Prepares request
* @param $data
* @return mixed
*/
public function hookPre($request)
{
}
/**
* Changes response
* @param $data
* @return mixed
*/
public function hookPost($response)
{
return $response;
}
}
```
Как видно, он реализует интерфейс ContentTypeInterface.
Теперь можно создавать свои контент-тайпы, для примера я приведу свой контент-тайп json:
```
namespace SomeNamespace\SomeBundle\Core\ContentTypes;
use SomeNamespace\SomeBundle\Core\ContentType;
class JSONContentType extends ContentType
{
private $params;
/**
* Get the name of ContentType
* @return mixed
*/
public static function getName()
{
return "json";
}
/**
* Changes response
* @param $data
* @return mixed
*/
public function hookPost($response)
{
return $response;
}
/**
* Encoder
* @param $data
* @return mixed
*/
public function encodeParameters($data)
{
return json_encode($data);
}
/**
* Decoder
* @param $data
* @return mixed
*/
public function decodeParameters($data)
{
return json_decode($data);
}
}
```
И в заключение, приведу код javascript, который используется для генерации маршрутов и параметров:
```
//SomeBundle\Resources\js\routing_template.js
(function(){if(typeof SF!='undefined'){SF.sSet('routes',__routes__);SF.parameters = __params__;}})();
```
А также javascript, который всё это дело сохраняет и использует:
```
(function () {
SF = function () {
};
SF.prototype.fn = SF.prototype;
SF = new SF();
SF.fn.Storage = {};
SF.fn.hasValue = function (name) {
return this.Storage[name] !== undefined;
};
SF.fn.getValue = function (name) {
if (this.hasValue(name)) {
return this.Storage[name];
} else {
return void 0;
}
};
SF.fn.getAllValues = function () {
return this.Storage
};
SF.fn.loggingEnabled = function () {
return this.parameters.debug;
};
SF.fn.messagingEnabled = function () {
return this.parameters.messaging !== undefined && this.parameters.messaging;
};
SF.fn.getMessages = function () {
return !this.framework || this.framework.messaging === undefined ? { } : this.framework.messaging;
};
// framework
SF.fn.getLocation = function (name) {
if (this.hasLocation(name)) {
return this.framework.ajax[name];
} else {
return void 0;
}
};
SF.fn.hasLocation = function (name) {
return this.framework !== null &&
this.framework.ajax !== undefined &&
this.framework.ajax[name] !== undefined;
};
// Storage setter and getter
SF.fn.sSet = function (key, val) {
this.Storage[key] = val;
};
SF.fn.sGet = function (key) {
return this.Storage[key] ? this.Storage[key] : null;
};
// log function with debug checking
SF.fn.l = function (a, b) {
if (!b)
b = 'log';
if (this.parameters.debug) {
switch (b) {
case 'log':
console.log('[SF]: ', a);
break;
case 'info':
console.info('[SF]: ', a);
break;
case 'warning':
console.warn('[SF]: ', a);
break;
case 'error':
console.error('[SF]: ', a);
break;
}
}
};
// SF path function
SF.fn.path = function (name, arguments) {
if (this.Storage.routes[name]) {
var path = this.Storage.routes[name];
for (var a in arguments) {
path = path.replace('{' + a + '}', arguments[a]);
}
return path;
} else {
this.l('Route "' + name + '" is not found!', 'error');
return false;
}
};
})(window);
```
ну а теперь, самое интересное — пример работы. Создадим в контроллере акшн:
```
//не забываем использовать use для аннотации, иначе Symfony её не найдёт
/**
*
* @param key string
* @Route("/ajax/{key}", name="JSBundle_ajax")
* @Ajax("json")
* @return array
*/
public function ajaxAction($key)
{
//do some work
return array('a' => 'b', 'd' => 'c');
}
```
Ответ контроллера будет таким:
```
{
a: "b",
d: "c"
}
```
также, пример для javascript:
```
SF.l(SF.path('JSBundle_ajax', {'key': 'asd'}));
```
Если у вас в Symfony отключен debug, то в консоль ничего не распечатается, иначе распечатается:
/ajax/asd
P.S. дополнения приветствуются. Рад буду услышать умные мысли. | https://habr.com/ru/post/149378/ | null | ru | null |
# Разбираемся с Notifications API
Продолжаю серию переводов статей сайта [html5rocks](http://www.html5rocks.com). Мы уже говорили про то, как [внедрять шрифты](http://habrahabr.ru/blogs/webdev/104182/), как работать с [видео](http://habrahabr.ru/blogs/webdev/104591/), сегодня мы поговорим про то как делать всплывающие сообщения в браузере с помощью [Notifications API](http://www.chromium.org/developers/design-documents/desktop-notifications/api-specification). Работает оно к сожалению пока только в Хроме, но есть уже начальная версия [спецификации](http://www.chromium.org/developers/design-documents/desktop-notifications/api-specification). Под катом подробности.
Для начала проверяем есть ли возможность использовать данный функционал:
> `if (window.webkitNotifications) {
>
> console.log("Notifications are supported!");
>
> }
>
> else {
>
> console.log("Notifications are not supported for this Browser/OS version yet.");
>
> }`
Имя *webkitNotifications* является временным — стандарт по-прежнему не утвержден.
Далее создаем само оповещение, которые может быть либо простым текстовым сообщением, либо html-ным. Ниже показана функция, которая создает оповещения обоих типов в зависимости от настроек:
> `function createNotificationInstance(options) {
>
> if (options.notificationType == 'simple') {
>
> return window.webkitNotifications.createNotification(
>
> 'icon.png', 'Notification Title', 'Notification content...');
>
> } else if (options.notificationType == 'html') {
>
> return window.webkitNotifications.createHTMLNotification('http://someurl.com');
>
> }
>
> }`
Теперь мы переходим наверное к ключевому моменту создания оповещений — настроек безопасности. Любой из выше представленных методов выкинет ошибку безопасности, если нет соответствующих разрешений. Избежать этих ошибок можно с помощью try-catch или просто использовать метод **checkPermission** .
> `document.querySelector('#show\_button').addEventListener('click', function() {
>
> if (window.webkitNotifications.checkPermission() == 0) { // 0 is PERMISSION\_ALLOWED
>
> // function defined in step 2
>
> createNotificationInstance({ notificationType: 'html' });
>
> } else {
>
> window.webkitNotifications.requestPermission();
>
> }
>
> }, false);`
Если разрешения еще не выданы, то мы увидим вот такое сообщение:
Здесь ключевым моментом является то, что метод **requestPermission** может быть вызван только в следствие какого-либо события, как например нажатие мыши на клавишу. Таким образом, нам всегда необходима активность пользователя, для того чтобы вывести сообщения.
Мы так же можем вызвать какие-то действия, связанные с появлением оповещением — менять цвет фона, проигрывать звук и так далее. Как это сделать — показано ниже:
> `document.querySelector('#show\_button').addEventListener('click', function() {
>
> if (window.webkitNotifications.checkPermission() == 0) { // 0 is PERMISSION\_ALLOWED
>
> // function defined in step 2
>
> notification\_test = createNotificationInstance({notificationType: 'html'});
>
> notification\_test.ondisplay = function() { ... do something ... };
>
> notification\_test.onclose = function() { ... do something else ... };
>
> notification\_test.show();
>
> } else {
>
> window.webkitNotifications.requestPermission();
>
> }
>
> }, false);`
По [ссылке](http://www.html5rocks.com/tutorials/notifications/quick/) можно посмотреть на пример загрузки последних твитов любого пользователя
И последний комментарий. На экране одновременно могут отображаться только 5 сообщений, остальные появятся после закрытия видимых. | https://habr.com/ru/post/104670/ | null | ru | null |
# Упаковщик для dsniff.db
Доброе время суток.
Поставив для экспериментов dsniff, через пару суток обнаружил, что он насобирал невероятное количество мусора от всяких разных банерных сетей и лог работы стало невозможно читать.
Поискав в интернете скрипты редактирования лога решил написать свой.
Скрипт первым делом проходит по всем записям в базе и удаляет записи согласно регекспа, дальше просто разбирает структуру записи dsniff и выводит результат.
```
#!/usr/bin/perl
use strict;
use DB_File;
use Socket;
my $filename = $ARGV[0];
tie my %h, 'DB_File', $filename, undef, 0644, $DB_BTREE ;
foreach my $key (keys %h) {
if($h{$key} =~ /
adriver\.ru|google-analytics\.com|ad\.doubleclick\.net|tns-counter\.ru|ads\.adfox\.ru|a\.adwolf\.ru
/) { delete $h{$key}; }
}
foreach my $key (keys %h) {
my ($time,$srcaddr,$dstaddr,$proto,$sport,$dport,$servicename,$datalength,$data) = unpack('N I I N N N N/A* N A*',$h{$key});
if($datalength eq 0) { ($data) = unpack("C/A*",$data); }
my $srchostname = gethostbyaddr(pack("N",$srcaddr),AF_INET) || join ('.',unpack("C4",pack("N",$srcaddr)));
my $dsthostname = gethostbyaddr(pack("N",$dstaddr),AF_INET) || join ('.',unpack("C4",pack("N",$dstaddr)));
my $protoname = getprotobynumber($proto);
print "------------------------\n",scalar localtime($time)," $protoname ",$srchostname,":$sport -> ",$dsthostname,":$dport (",$servicename,")\n",$data,"\n\n";
}
untie %h;
```
Всё просто как 2х2, но похожего инструмента я не нашёл. Может пригодится кому.
Aborche 2012
 | https://habr.com/ru/post/136282/ | null | ru | null |
# Задаём виртуальной машине IP по MAC без использования DHCP
*В статье рассказывается о использовании скриптов для CentOS и Windows XP, которые устанавливают IP в соответствии с MAC сетевого интерфейса VM, а также о сложностях управления сетевым интерфейсом в Windows*
Система, которую мы разрабатываем, очень активно работает с виртуальными машинами. Когда ядру системы требуется очередная машина, копируется шаблонный образ, и запускается эта копия. Таким образом, одновременно может работать очень много копий по сути одной и той же машины.
Конечно, в момент запуска каждая виртуальная машина идентична шаблонной. В том числе наследуются и установленные параметры сети. Все виртуальные машины работают в одной подсети, а значит, они не должны пользоваться тем статическим IP, который достался им от шаблонной машины — иначе будут возникать конфликты. То есть каждая машина должна получить собственный IP. Казалось бы, решение очень простое — использовать DHCP сервер и динамические IP.
Однако, есть и другой вариант, о котором я расскажу в этой статье.
[1. Для чего нам нужны виртуальные машины](#why)
[2. Проблема одинаковых статических адресов при запуске нескольких клонов VM](#problem)
[3. Кодируем IP в MAC](#ip_encoding)
[4. Выделение IP по MAC: DHCP](#get_ip_dhcp)
[5. Выделение IP по MAC: скрипт mac2ip](#get_ip_script)
[a) Linux](#linux)
[b) Windows](#windows)
[6. Замечания](#notes)
[**Update**](#update)
[**Update 2**](#update2)
*Спойлер: собственно, самое интересное — в пунктах 3) и 5), остальное — для тех, кто захочет увидеть всю картину.*
### 1. Для чего нам нужны виртуальные машины
Наш проект, [Nerrvana](http://www.crunchbase.com/product/trillium), выполняет функциональные тесты сайтов в разных браузерах. Тесты эти работают со специальным фреймворком для функционального тестирования — Selenium, который позволяет эмулировать действия пользователя в брaузере (клики по элементам, движения мышью, ввод символов, чтение текста), делать скриншоты страниц и некоторые другие вещи.
Тест сайта представляет собой последовательность действий, которые мог бы сделать на сайте пользователь, и проверок, что результат этих действий — точно такой, как ожидается. Например, простейший тест — логин на сайт. Необходимо открыть страницу логина, ввести логин, пароль, нажать «Ввод», и убедиться, что мы залогинены — скажем, увидев стандартное приветствие. Все знают, что браузеры могут совершенно по-разному отображать и работать с одной и той же страницей, и поэтому имеет смысл выполнить одинаковые тесты в наиболее популярных браузерах. Как уже говорилось, именно этой работой и занимается наша система.
Тесты в выбранных браузерах выполняются одновременно и совершенно независимо друг от друга. Выполнение теста в одном из браузеров мы назвали спеком (speck). То есть, допустим, если я хочу выполнить тест логина на браузерах IE 8 и FF 3.6, наша система сделает два независимых спека — выполнит код тестов с использованием выбранных браузеров. Не сильно вдаваясь в подробности, скажу, что для работы каждого спека мы создаём как минимум две виртуальные машины. Одна машина, «хаб», будет заниматься собственно выполнением тестов — там есть Java и PHP, на которых должны быть написаны тесты. На второй машине, «тестере», работает Selenium RC и нужный браузер. Через Selenium RC происходит взаимодействие между тестами и браузером. После выполнения каждого спека виртуальные машины, на которых он работал, уничтожаются.
Так как одновременно работающих тестов может быть много, и каждый может использовать несколько спеков, виртуальных машин тоже может работать относительно много — 50, к примеру.
### 2. Проблема одинаковых статических адресов при запуске нескольких клонов VM
Для каждого типа виртуальных машин имеется шаблонный образ. Когда ядру системы требуется очередная машина, этот образ копируется, и запускается копия образа — сам образ остаётся неизменным. Таким образом, одновременно может работать очень много копий по сути одной и той же машины.
И тут появляется некоторая проблема.
Естественно, в момент запуска каждая виртуальная машина абсолютно идентична шаблонной — ведь все данные хранятся в образе, в который нельзя внести изменений. В том числе наследуются и установленные параметры сети. Так как все виртуальные машины работают в одной подсети, совершенно очевидно, что они не должны пользоваться тем статическим IP, который достался им от шаблонной машины — иначе будут возникать конфликты адресов. То есть каждая машина должна динамически получить собственный IP.
Казалось бы, решение очень простое — использовать DHCP сервер, который и выдаст каждой машине уникальный адрес.
Однако, не всё так просто. Дело в том, что ядро системы активно взаимодействует с виртуальными машинами. Оно должно проделать просто кучу работы с ними: например, убедиться, что виртуальные машины успешно стартовали, запустить Selenium RC на тестере, загрузить на хаб и выполнить сами тесты, следить за их выполнением, а потом получить обратно результаты (скриншоты, логи и т.д.). Работа ведётся через ssh.
Т.е. ядро системы, как ни крути, должно знать IP-адреса машин, которые только что были запущены по её требованию.
Мы видели два подхода к решению задачи:
1) После того, как виртуальная машина поднялась, она получает случайный адрес от DHCP, и затем каким-то образом регистрирует себя в базе — т.е. указывает, что я — машина такого-то типа, получила от DHCP такой-то адрес.
2) Каким-то образом ядро даёт понять виртуальной машине, какой адрес ей следует использовать, т.е. соответствие IP — виртуальная машина имеется ещё до запуска машины.
Первый вариант казался нам довольно сложным по нескольким причинам. Этот вариант делал VM слишком независимыми от ядра, появлялась лишняя связь — от виртуальной машины к базе, появлялись сложности с сопоставлением запрошенных и зарегистрированных VM, и некоторые проблемы, связанные с архитектурой ядра.
Второй вариант нам нравился куда больше, потому что ядро сразу получало полный контроль над VM, а не оказывалось в подвешенном состоянии в ожидании, пока VM сама зарегистрируется.
### 3. Кодируем IP в MAC
Как же воздействовать на ещё не запущенную машину, чтобы сообщить ей будущий ip-адрес? Мы нашли такой способ: при запуске виртуальной машины можно задать MAC-адрес виртуальной сетевой плате. А сама виртуальная машина может в любой момент его узнать. То есть MAC можно использовать как носитель информации о IP (или о чём-нибудь ещё).
Как именно мы будем кодировать IP в мак-адресе? Для виртуализации мы используем [Xen](http://ru.wikipedia.org/wiki/Xen "xen"), и виртуальные сетевые платы xen должны иметь MAC, который выглядит так: 00:16:3E:XX:XX:XX, где 00:16:3E — код производителя сетевой платы. Последние три байта мы можем использовать по своему усмотрению (конечно, помня о том, что MAC должен быть уникальным).
Предположим, что наша система будет работать в подсети 10.0.0.0/8, и поэтому логичное решение — использовать для трёх последних байтов MAC значения, соответствующие трём последним байтам IP адреса, который мы хотим закодировать.
То есть для адреса 10.1.1.3 мы будем использовать MAC 00:16:3E:01:01:03.
Осталось заставить машину получить нужный IP, соответствующий её MAC. Это опять-таки можно сделать двумя способами.
### 4. Выделение IP по MAC: DHCP
Первый способ довольно очевиден. Мы запустим DHCP сервер, который будет настроен так, чтобы выдавать IP по MAC-адресу в соответствии с описанным способом кодирования.
Сценарий работы будет выглядеть так:
1) Ядру требуется VM.
2) Ядро просматривает пул IP-адресов, выбирает первый незанятый IP (например, 10.4.0.15), и преобразует его в MAC (00:16:3E:04:00:0F)
4) Ядро копирует шаблонный образ VM нужного типа, подготавливает файл конфигурации VM (в котором указывает в том числе и полученный MAC)
5) Ядро запускает VM
6) VM обращается к DHCP за адресом, тот сверяется с таблицей соответствия MAC/IP, и выдаёт IP 10.4.0.15.
7) Ядро в это время периодически пингует 10.4.0.15, и, получив ответ, начинает работать с виртуальной машиной (конечно, предварительно дождавшись старта sshd)
**-** требуется DHCP сервер
**-** если мы переедем в другую подсеть или получим другой пул IP-адресов, придётся менять конфигурацию не только ядра, но и DHCP
**+** используется стандартный подход к получению IP
### 5. Выделение IP по MAC: скрипт mac2ip
Второй способ менее очевиден и требует некоторой дополнительной работы.
Он заключается в том, что VM при старте выполнит специальный скрипт, который получит MAC, преобразует его в IP, и назначит сетевой плате. Сценарий работы, таким образом, будет практически таким же — изменится только пункт 6. Он будет выглядеть так:
6) VM вычисляет свой IP на основании своего MAC, и устанавливает его перед стартом интерфейса.
**+** не требуется дополнительное звено в виде DHCP и хранения там таблицы соответствия MAC-IP.
**-** для каждой ОС потребуется свой скрипт mac2ip
Мы реализовали именно этот вариант.
Мы работаем с виртуальными машинами с CentOS 5.6 и Windows XP PRO SP3, и поэтому нам нужно было два скрипта mac2ip — для каждой из систем.
Рассмотрим оба скрипта.
##### a) Linux
```
#!/bin/bash
# первый байт всегда будет равен 10
IP1=10
IFCFG=/etc/sysconfig/network-scripts/ifcfg-eth0
NETWORK=/etc/sysconfig/network
case "$1" in
*start)
;;
*)
exit
;;
esac
# получаем MAC и проверяем, что мы его таки получили
MAC=$(ifconfig eth0|grep HWaddr|awk '{print $NF}'|grep ^00:16:3E)
if [[ -z "$MAC" ]] ; then
echo "Can't determine MAC address" >&2
exit 1
fi
# преобразуем MAC в IP
set -- $(echo $MAC|awk -F: '{print $4,$5,$6}')
IPADDR=${IP1}.$((0x$1)).$((0x$2)).$((0x$3))
# меняем настройки интерфейса
sed -i -e "s/^IPADDR.*/IPADDR=$IPADDR/" $IFCFG
sed -i -e "/^HWADDR/d" $IFCFG
sed -i -e "s/^HOSTNAME.*/HOSTNAME=localhost/" $NETWORK
```
И заставляем запускаться этот скрипт до запуска network.
##### b) Windows
Та же самая работа в Windows XP делается куда более заумными путями. Возможно, со временем найдётся более эффективный способ преобразования MAC в IP.
Первая проблема, с которой я столкнулся — это невозможность относительно лёгкими путями изменить адрес интерфейса ДО его включения. Таким образом, шаблонная VM должна иметь выключенный по умолчанию «сетевое подключение», иначе две одновременно запущенные копии Windows сразу после запуска попробуют использовать один и тот же адрес (он статический, т.к. для VM мы не используем DHCP).
Ок, это не проблема — выключить интерфейс. Однако утилита [getmac](http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/getmac.mspx?mfr=true), которую мы будем использовать для получения мак-адреса сетёвки, не может вернуть MAC для того интерфейса, который выключен! Поэтому нам придётся сначала присвоить интерфейсу случайный IP, включить его, узнать MAC, и уже тогда установить желаемый IP.
Для манипуляций с устройствами используется утилита [devcon](http://support.microsoft.com/kb/311272/ru "devcon").
Вот как это выглядит:
```
@echo off
SET MAC=
SET IP=
SET MASK=255.255.255.0
SET GATEWAY=
rem получаем случайный IP. Этот IP будет использоваться в течении пары секунд,
rem и поэтому для обеспечения уникальности достаточно сгенерировать случайно два последних байта.
rem 100 - смещение, которое гарантирует, что мы в любом случае
rem не воспользуемся реально используемыми IP.
set /A TEMP_THIRD_BYTE=100+%RANDOM:~0,2%
set /A TEMP_FOURTH_BYTE=100+%RANDOM:~0,2%
set TEMP_IP="192.168.%TEMP_THIRD_BYTE%.%TEMP_FOURTH_BYTE%"
set TEMP_GATEWAY="192.168.%TEMP_THIRD_BYTE%.1"
rem устанавливаем параметры интерфейса
netsh interface ip set address local static %TEMP_IP% %MASK% %TEMP_GATEWAY% 1
rem включаем интерфейс. для этого мы используем
C:\devcon\i386\devcon enable *VEN_10E*
rem получаем три последних байта MAC
FOR /F "Tokens=4-6 Delims=- " %%d in ('getmac^|find "Device\Tcpip_"') do (
set /a dec_d=0x%%d
set /a dec_e=0x%%e
set /a dec_f=0x%%f
)
rem подготавливаем нужный IP и шлюз
SET IP=10.%dec_d%.%dec_e%.%dec_f%
SET GATEWAY=10.%dec_d%.0.1
rem меняем параметры интерфейса на реальные
netsh interface ip set address local static %IP% %MASK% %GATEWAY% 1
netsh interface ip set dns local static %GATEWAY%
```
Добавляем этот скрипт в автозагрузку — например, так (требуется перезагрузка):
```
reg ADD "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run" /v "mac2ip" /t REG_SZ /d "c:\init\mac2ip.bat"
```
Таким образом, после выполнения этих скриптов виртуальная машина получит заданный ядром адрес, и будет готова к работе.
Ядро узнает об этом по заработавшему пингу к этому адресу.
Возможно, эта схема добавит наглядности (по клику — полный размер в новом окне):
[](http://www.deepshiftlabs.com/dev_blog/wp-content/uploads/2011/04/mac2ip_ru.png)
### 6. Замечания
Используемый нами способ — со скриптом mac2ip в автозагрузке — оказался довольно медленным в Win XP. Во всяком случае, текущая его реализация делает свою работу 10-15 секунд. При этом время, которое уходит от старта виртуальной машины до начала выполнения скрипта mac2ip, составляет 15-20 секунд.
Однако мы не спешим перейти на использование первого способа (DHCP с привязкой IP к MAC), потому что:
— во-первых, VM у нас завершаются не штатным для них способом (т.е. centos/windows не выполняют завершение работы), а выполнением virsh destroy для VM (всё равно, что питание выдернуть). Это позволяет экономить много времени, а целостность использованной VM нас всё равно не интересует — она будет немедленно удалена после использования. Так вот, арендованный VM адрес не будет в этом случае освобождён сразу, а будет освобождён по истечении default-lease-time DHCP. Это значит, что мы не сможем сразу же запустить VM с таким же MAC (и таким же IP). Вряд ли установка default-lease-time слишком маленьким (секунды) — хорошая идея. Более реальный вариант — изучение и использование OMAPI/omshell, и с их помощью удалять ненужные записи DHCP сразу после остановки VM.
— во-вторых, для Linux получение адреса от DHCP будет происходить медленнее, чем текущий вариант с назначением статического адреса.
— в третьих — конечно, обнаружатся и другие подводные камни.
Так что относительно медленная работа текущей версии скрипта в Windows — недостаточная причина для того, чтобы перейти на использовать варинанта с DHCP.
Идеальным решением было бы ускорение работы скрипта mac2ip для Windows. Буду рад советам — поскольку это мой первый опыт в управлении сетевым интерфейсом windows из скриптов, то, возможно, уже имеется велосипед.
**Update:** Во-первых, [The\_Kf](http://habrahabr.ru/users/the_kf/) открыл глаза на банальный способ получения MAC на выключенном интерфейсе с помощью ipconfig.
Во-вторых, [gribozavr](http://habrahabr.ru/users/gribozavr/) провёл [эксперимент](http://habrahabr.ru/blogs/sysadm/121137/#comment_3978095), который показал, что заботиться о lease-time арендованного IP вообще не надо, потому что при привязке IP к MAC DHCP выдаст IP в любом случае машине с тем же MAC, даже ели аренда не истекла. Также он указал на stateless autoconfiguration из IPv6.
В-третьих, при общении с [akshakirov](http://habrahabr.ru/users/akshakirov/) я внезапно [понял](http://habrahabr.ru/blogs/sysadm/121137/#comment_3978101), почему сразу более пристально не смотрели в сторону DHCP.
**Update 2:** в-четвёртых, [amarao](http://habrahabr.ru/users/amarao/) [предложил](http://habrahabr.ru/blogs/sysadm/121137/#comment_3978624) использовать xenstore для передачи IP в VM. В гостевой Linux-машине для этого просто надо установить xenstore-utils, однако для винды, возможно, потребуется написать утилиту для чтения из xenstore. | https://habr.com/ru/post/121137/ | null | ru | null |
# Опыт применения теоремы о свертке с использованием scipy.fft
[Теорема о свёртке](https://mathworld.wolfram.com/ConvolutionTheorem.html) утверждает, что преобразование Фурье от свёртки двух функций является произведением их Фурье образов:
Как следствие, свёртку двух функций можно вычислить путём обратного преобразования Фурье:
Когда свёртку не удаётся получить аналитически, использование теоремы позволяет вместо численного интегрирования воспользоваться алгоритмом быстрого преобразования Фурье и существенно ускорить процесс вычислений. В ходе решения возникшей у меня задачи мне не удалось найти в интернете достаточно подробного описания алгоритма действий, поэтому я решил изложить его здесь, во-первых, как памятку для себя и во-вторых, на случай если это окажется полезным кому-то ещё. Не претендуя на общность изложения, ниже я приведу примеры найденных решений для функций от одной и от двух переменных.
Функция от одной переменной
---------------------------
Допустим, нам нужно вычислить свёртку функций
причём имеется в виду, что нас интересует только действительная часть области значений функции, то есть область её определения лежит в интервале ![x \in [-1,1]](https://habrastorage.org/getpro/habr/upload_files/f19/e25/8a8/f19e258a8ac8dc83c71e46343c458173.svg). Интеграл функции в этом интервале равен 1, а преобразование Фурье [вычисляется аналитически](https://www.wolframalpha.com/input/?i=integrate+exp%28-2*pi*i*u*x%29%2Fsqrt%281-x%5E2%29+dx+from+-1+to+1):
где - [функция Бесселя первого рода](https://www.wolframalpha.com/input/?i=%CF%80+BesselJ%280%2C+2+%CF%80+x%29). Фурье образ функции Гаусса:
Дискретным преобразованием Фурье (ДПФ) называется метод вычислений, в котором и функция и ее преобразование заменяются дискретными аналогами. Быстрое преобразование Фурье (БПФ) относится к способу эффективного вычисления ДПФ с использованием симметрии в вычисляемых условиях. Симметрия наивысшая, когда число узлов, в которых вычисляется значение функции, и число гармоник, являются степенью двойки. В библиотеке [SciPy](https://scipy.org/) с открытым исходным кодом для работы с БПФ предназначен модуль [scipy.fft](https://docs.scipy.org/doc/scipy/reference/tutorial/fft.html). Для того, чтобы вычислить искомую свёртку методом БФП, нужно задать интересующую нас область определения результата и задать количество узлов разбиения, в которых мы хотим получить значение свёртки.
Выберем область определения ![x\in[-R+D_x/2,R-D_x/2]](https://habrastorage.org/getpro/habr/upload_files/24a/4d4/022/24a4d4022f25313c6f9b394a089ce64b.svg), где и- положительные вещественные числа, которые мы будем считать размерными, например, пусть это будут сантиметры. Разобъём этот интервал на одинаковых отрезков, длина каждого из которых равна . Интервал называется шагом дискретизации и определяет расстояние между соседними узлами разбиения шкалы . Обратная величина называется частотой дискретизации и в нашем примере измеряется в обратных сантиметрах.
В шкале частот нашему диапазону шкалыбудет соответствовать набор из  положительных и отрицательных гармоник разложения Фурье. Если - чётное, последовательность частот, которая генерируется функцией [scipy.fft.fftfreq](https://docs.scipy.org/doc/scipy/reference/generated/scipy.fft.fftfreq.html#scipy.fft.fftfreq), будет такая:
![u=\Bigl[0,\;\frac{1}{2R},\;\dots,\;\frac{(N_x-1)/2}{2R},\; -\frac{N_x/2}{2R},\;\dots,\; -\frac{1}{2R} \Bigr].](https://habrastorage.org/getpro/habr/upload_files/adc/d64/943/adcd6494319e33b1f2df5c19bf0ef2bf.svg)Если функция, которую мы ищем, вещественна (не имеет мнимой части), положительные частоты в последовательности являются сопряженными величинами отрицательных частот, за счёт этого можно примерно в два раза сократить время вычислений. Для получения укороченной (без отрицательных частот) последовательности используется функция [scipy.fft.rfftfreq](https://docs.scipy.org/doc/scipy/reference/generated/scipy.fft.rfftfreq.html#scipy.fft.rfftfreq). Для выполнения прямого и обратного преобразований Фурье для вещественного сигнала предназначены функции [scipy.fft.rfft](https://docs.scipy.org/doc/scipy/reference/generated/scipy.fft.rfft.html#scipy.fft.rfft) и [scipy.fft.irfft](https://docs.scipy.org/doc/scipy/reference/generated/scipy.fft.irfft.html#scipy.fft.irfft) соответственно. Функция [scipy.fft.fftshift](https://docs.scipy.org/doc/scipy/reference/generated/scipy.fft.fftshift.html#scipy.fft.fftshift) располагает компоненту с нулевой частотой в середине частотного спектра, а [scipy.fft.ifftshift](https://docs.scipy.org/doc/scipy/reference/generated/scipy.fft.ifftshift.html#scipy.fft.ifftshift) осуществляет обратное преобразование. Ниже приведён код для вычисления свёртки:
```
import numpy as np
from scipy.special import j0 as BesselJ0
import scipy.fft as FFT
from matplotlib import pyplot as plt
π = np.pi
σ = 0.01
R = 1.5 # интервал, в котором вычисляется свёртка
Nx = 4096 # число разбиений по оси x
Dx = 2*R/Nx # шаг дискретизации
x = np.linspace(0.5*Dx-R, R-0.5*Dx, num = Nx)
u = FFT.rfftfreq(Nx//16, d = 16*Dx) # цифровой ФНЧ
J0 = BesselJ0(2*π*u)*np.exp(-2*(π*σ*u)**2)
y = FFT.ifftshift(FFT.irfft(J0, n=Nx, norm='forward'))
plt.subplot(211)
plt.plot(u, J0, 'r-', label='спектр частот')
plt.xlabel('u, [1/см]')
plt.grid(True); plt.legend()
plt.subplot(212)
plt.plot(x, y, 'r-', label='результат свёртки')
plt.xlabel('x, [см]')
plt.grid(True); plt.legend()
plt.show()
```
Результат представлен на картинке. Как видно из спектра частот, амплитуда гармоник экспоненциально падает с ростом частоты (из-за , см. выше) , поэтому число вычисляемых гармоник уменьшено в 16 раз с помощью "цифрового ФНЧ".
Функция от двух переменных
--------------------------
Перейдем к рассмотрению двумерного случая, основываясь на [статье Natalie Baddour](http://issuu.com/nbaddour/docs/2d-fourier-polar-chapter). Фурье преобразование функцииопределяется по аналогии с одномерным случаем:
где- круговые частоты в плоскости Фурье-образа функции. Обратное преобразование Фурье выглядит так:
где для краткости используются обозначения. Переход к полярным координатам осуществляется путём замены переменных в координатной плоскости и в частотной плоскости. В результате такой замены, преобразование Фурье в полярных координатах выглядит следующим образом:
Если функция не зависит от угла, т. е. , то её не нужно интегрировать по и предыдущее выражение упрощается:
Используя интегральное определение функции Бесселя нулевого порядка
наше Фурье преобразование можно записать так:
гденазывается преобразованием Ганкеля ([Hankel transform](https://en.wikipedia.org/wiki/Hankel_transform)) нулевого порядка.
---
Для примера вычислим свёртку двух функций:
одна из которых задана в полярных координатах, а другая - в декартовых. Фурье-образ функции  в нашем случае легко вычисляется аналитически:
где . В иных случаях преобразование Ганкеля можно делать численно с помощью функции [scipy.fft.fht](https://docs.scipy.org/doc/scipy/reference/generated/scipy.fft.fht.html#scipy.fft.fht). Пользуясь полученными выше формулами и рецептами, создадим код для вычисления свёртки:
```
import numpy as np
from scipy import fft as FFT
import matplotlib.pyplot as plt
π = np.pi
σx = 0.05
σy = 0.02
R = 1.5
N = 1024
D = 2*R/N
s = np.linspace(0.5*D-R, R-0.5*D, num = N)
f = FFT.fftshift(FFT.fftfreq(N, d = D))
x,y = np.meshgrid(s,s)
u,v = np.meshgrid(f,f)
J = 2*np.sinc(2*(u**2 + v**2)**0.5)*np.exp(-2*π*π*((σx*u)**2 + (σy*v)**2))
z = np.abs(FFT.ifftshift(FFT.irfft2(J, s=[N,N], workers=-1, norm='forward')))
plt.figure(figsize=(16, 9))
levels = np.linspace(J.min(), J.max(), 16)
plt.subplot(121)
plt.contourf(u, v, np.real(J), levels)
plt.colorbar(); plt.title('Фурье образ')
plt.xlim(-5,5); plt.xlabel('u, [1/см]')
plt.ylim(-5,5); plt.ylabel('v, [1/см]')
plt.subplot(122)
levels = np.linspace(z.min(), z.max(), 16)
plt.contourf(x, y, z, levels)
plt.colorbar(); plt.title('Результат свёртки')
plt.xlabel('x, [см]')
plt.ylabel('y, [см]')
plt.show()
```
Опция `workers=-1` в функции irfft2 позволяет параллельно использовать все имеющиеся в системе процессорные ядра. Результат вычислений представлен на картинке:
Заключение
----------
Вот вроде бы и всё о чём я хотел написать. Буду рад критике, вопросам и предложениям. Всех с наступающим 2022! | https://habr.com/ru/post/598289/ | null | ru | null |
# PVS-Studio для Visual Studio
Многие наши статьи посвящаются чему угодно, но только не самому инструменту PVS-Studio. А ведь мы очень много делаем, чтобы разработчикам было удобно пользоваться нашим инструментом. Но как раз это часто оказывается за кадром. Решил исправить эту ситуацию и рассказать о плагине PVS-Studio для Visual Studio. Если вы используете Visual Studio, то эта статья для вас.
Что такое статический анализ кода и зачем он нужен
--------------------------------------------------
Статический анализ кода — это процесс выявления ошибок и недочетов в исходном коде программ. Статический анализ можно рассматривать как автоматизированный процесс обзора кода. Совместный [обзор кода](https://www.viva64.com/ru/t/0073/) — замечательная методология. Но у неё есть и существенный недостаток — высокая стоимость. Необходимо регулярно собирать нескольких программистов для обзора нового кода или повторного обзора кода после внесения рекомендаций.
С одной стороны, хочется регулярно осуществлять обзор кода. С другой — это слишком дорого. Компромиссным решением являются инструменты статического анализа кода. Они без устали обрабатывают исходные тексты программ и выдают программисту рекомендации обратить повышенное внимание на определенные участки кода. Конечно, программа не заменит полноценного обзора кода, выполняемого коллективом программистов. Однако, соотношение польза/цена делает использование статического анализа весьма полезной практикой, применяемой многими компаниями. Если читателя интересуют конкретные числа, то предлагаю познакомиться со статьёй "[PVS-Studio ROI](https://www.viva64.com/ru/b/0606/)".
Существует большое количество коммерческих и бесплатных статических анализаторов кода. Большой список статических анализаторов имеется на сайте Wikipedia: [List of tools for static code analysis](https://en.wikipedia.org/wiki/List_of_tools_for_static_code_analysis). Список языков, для которых существуют статические анализаторы кода, также достаточно велик (Си, Си++, C#, Java, Ada, Fortran, Perl, Ruby, ...). Естественно, мы будем рассказывать вам об анализаторе [PVS-Studio](https://www.viva64.com/ru/pvs-studio/).
Главное преимущество статического анализа состоит в возможности существенного снижения стоимости устранения дефектов в программе. Чем раньше ошибка выявлена, тем меньше стоимость ее исправления. Так согласно данным, приведенным в книге Макконнелла «Совершенный Код», исправление ошибки на этапе тестирования обойдется в десять раз дороже, чем на этапе конструирования (написания кода):
*Рисунок 1. Средняя стоимость исправления дефектов в зависимости от времени их внесения и обнаружения (данные для таблицы взяты из книги С. Макконнелла «Совершенный Код»).*
Инструменты статического анализа позволяют выявить большое количество ошибок этапа конструирования, что существенно снижает стоимость разработки всего проекта. Например, статический анализатор кода PVS-Studio может запускаться в фоновом режиме сразу после компиляции и, в случае нахождения потенциальной ошибки, уведомит программиста. Подробнее об этом режиме будет рассказано ниже.
Статический анализатор кода PVS-Studio
--------------------------------------
PVS-Studio — статический анализатор, выявляющий ошибки и потенциальные уязвимости в исходном коде приложений на языках C, C++ (также поддерживаются расширения: [C++/CLI](https://ru.wikipedia.org/wiki/C%2B%2B/CLI) и [C++/CX](https://ru.wikipedia.org/wiki/C%2B%2B/CX)), C# и Java на платформах Windows, Linux и macOS. Анализатор великолепно интегрируется в среды Visual Studio 2010 — 2019 и IntelliJ IDEA. В этой статье мы подробно рассмотрим работу PVS-Studio для проверки кода на языках C, C++ и C#. Про то, как использовать PVS-Studio для проверки Java кода в IntelliJ IDEA, можно почитать [здесь](https://www.viva64.com/ru/m/0044/).
После установки PVS-Studio и интеграции в Visual Studio, пользователи получают дополнительный пункт «PVS-Studio» в главном меню и окно для работы с диагностическими сообщениями (см. рисунок 2).
*Рисунок 2. Основные элементы, добавляемые анализатором PVS-Studio при интеграции в Visual Studio.*
### Начальные настройки
Анализатор готов к работе сразу после установки. В большинстве случаев вам не потребуется ничего настраивать, чтобы осуществить первый запуск. Единственная настройка, которая может понадобиться вам в начале, это исключение сторонних библиотек. Вы ведь все равно не будете ничего править в исходных файлах, например, библиотеки jpeg, поэтому незачем её проверять. Вдобавок, исключение лишних папок сократит время анализа проекта. Исключаемые из анализа директории задаются здесь: PVS-Studio > Options… > Don't Check Files > PathMasks (см. рисунок 3).
*Рисунок 3. Редактирование списка директорий, которые анализатор не будет проверять.*
Если в полном пути файла есть одно из указанных имён, то анализ выполняться не будет. По умолчанию, в список уже включены имена некоторых директорий. Однако, в вашем проекте папка с библиотекой ZLib может называться не «zlib», а, например, «zip\_lib». Поэтому следует отредактировать этот список. Для начала редактирования следует нажать кнопку с тремя точками.
Примеры допустимых масок для списка PathMasks:
* c:\Libs\ — будут исключены все файлы проекта, расположенные в данной папке и её подпапках.
* \Libs\ или \*\Libs\\* — будут исключены все файлы, расположенные в директориях, путь до которых содержит подпапку «Libs». Если символы "\*" не указаны, они все равно будет автоматически добавлены, поэтому оба варианта записи одинаковы.
* Libs или \*Libs\* — исключены будут все файлы, путь до которых содержит подпапку, имеющую 'Libs' в качестве имени либо фрагмента имени. Также в этом случае будут исключены файлы, содержащие Libs в имени, например, c:\project\mylibs.cpp. Для избегания путаницы рекомендуем всегда использовать слеши.
Помимо исключений целых папок, можно задавать маски для исключения отдельных файлов. Для этого существует настройка FileNameMasks. Подробнее, как работать со списками исключения можно познакомиться в документации: [Settings: Don't Check Files](https://www.viva64.com/ru/m/0014/).
### Проверка проекта
По завершению первичных настроек, вы можете приступить к проверке проекта. PVS-Studio для Visual Studio поддерживает проверку C++ (.vcxproj) и C# (.csproj) проектов. Также можно сразу попробовать проверить решение, содержащее проекты таких типов, целиком. Для этого выберите пункт меню Extensions > PVS-Studio > Check > Solution (см. рисунок 4).
*Рисунок 4. Проверка решения (Solution) с помощью анализатора PVS-Studio.*
Если с проверкой возникнут какие-то трудности, мы рекомендуем обратиться к разделу "[Не удается проверить?](https://www.viva64.com/ru/m/0029/)" на нашем сайте. Это не бестолковые рекомендации в духе «проверьте, что вилка вставлена в розетку». В разделе описаны типовые ситуации, с которыми к нам обращались пользователи, и предложены варианты действий.
### Работа со списком диагностических сообщений
После проверки все диагностические сообщения будут отображены в специальном окне. Окно имеет много элементов для управления. Все они служат для того, чтобы показать именно те диагностические сообщения, которые интересны пользователю. Однако, в первый момент окно может показаться сложным. Давайте рассмотрим все управляющие элементы (см. рисунок 5).
*Рисунок 5. Окно с диагностическими сообщениями.*
1. Собственно, окно PVS-Studio.
2. Дополнительное меню. Позволяет получить доступ к таким опциям, как: пометка предупреждения как ложного, скрытие сообщений, добавление файлов в исключения (об этом ниже).
3. Кнопка включает сообщения «что-то пошло не так». Например, не удается препроцессировать один из файлов.
4. Переход к предыдущему/следующему сообщению. При этом открывается соответствующий файл, и курсор ставится на строку с потенциальной ошибкой. Также всегда можно выбрать диагностику из списка с помощью двойного щелчка мышью. Можно [назначить горячие клавиши](https://www.viva64.com/ru/b/0296/) для осуществления переходов к предыдущему/следующему сообщению. По умолчанию это Alt+'[' и Alt+']'.
5. Кнопки, включающие предупреждения разных уровней. Сейчас включены два первых уровня диагностик. При этом в окне показывается 90 предупреждений первого уровня, 6700 предупреждение второго уровня. Уровень сообщения показывается в левой части окна, в виде полоски, соответствующей по цвету полоске на кнопке соответствующего уровня. Почему так много срабатываний? Откуда 6700 предупреждений? Для демонстрации возможностей интерфейса включен набор правил [MISRA](https://www.viva64.com/ru/b/0596/), что делать для обыкновенных прикладных программ противопоказано :).
6. Активные наборы диагностических правил. General — диагностики общего назначения, Optimization — микрооптимизации, 64-bit — 64-битные диагностики, MISRA — диагностики стандартов MISRA C и MISRA C++. Сейчас в окне отображаются все виды предупреждений.
7. Показывает количество сообщений, помеченных как ложные (False Alarms). Включить/выключить отображение размеченных сообщений можно в настройках, PVS-Studio > Options… > Specific Analyzer Settings > Display False Alarms.
8. Быстрые фильтры. Можно, например, оставить в списке только сообщения с кодом V501 и, находящиеся в проекте XYZ.
9. Некоторые диагностики предлагают обратить внимание не на одну, а несколько строк. В этом случае, рядом с номером строки появляется многоточие. Кликнув по нему мышкой, можно увидеть список строк и выбрать одну из них.
Таблица с диагностическими сообщениями разбита на следующие колонки:
* **Уровень.** Уровень достоверности, что найдена именно ошибка. 1-й уровень (красный) — наиболее подозрительные места. 3-й (желтый) уровень — скорее всего несущественная неточность в коде.
* **Звездочка**. У неё нет конкретного назначения. Пользователь может интерпретировать её по своему усмотрению. Например, он может отметить наиболее интересные предупреждения для дальнейшего внимательного анализа. Аналогия — отметка звездочками писем в почтовой программе типа Thunderbird или Outlook.
* **ID**. Уникальный номер сообщения. Может пригодиться при работе с большим списком. Например, можно перейти к сообщению с определенным номером (см. пункт «Navigate to ID...» в [контекстном меню](https://www.viva64.com/ru/m/0021/)).
* **Code**. Код сообщения. Если щелкнуть по нему мышкой, то откроется страница с описанием предупреждения.
* **CWE.** Позволяет идентифицировать предупреждение по [коду CWE](https://www.viva64.com/ru/cwe/) (Common Weakness Enumeration). При нажатии на ссылку можно посмотреть описание данного CWE в сети.
* **MISRA.** То же, что и выше, но только [для стандарта MISRA](https://www.viva64.com/ru/b/0596/).
* **Message**. Текст диагностического сообщения.
* **Project**. Имя проекта (можно отключить эту колонку, используя контекстное меню).
* **File**. Имя файла.
* **Line**. Номер строки. **Важно!** Обратите внимание, что после некоторых строк стоит многоточие. Пример: «123 (...)». Кликнув на это число, вы получите список всех строк кода, которые относятся к этому сообщению. При этом есть возможность перейти к каждой из строк в списке.
Да, прочитать всё это было утомительно. Однако, уверяю вас, начав пользоваться, вы быстро освоитесь с инструментом. И нажимать что-то для настройки будете крайне редко.
### Контекстное меню
Итак, по двойному клику мышки на сообщении вы переходите к нужному фрагменту кода. По нажатию правой кнопки мышки открывается контекстное меню.
Меню достаточно простое, и не стоит перегружать статью описанием каждого из пунктов. Если что-то непонятно, можно подсмотреть в документации.
Однако, хочу остановиться на одной очень полезной фиче. Помните, что в настройках можно добавить папки/файлы для исключения (см. рисунок 2). Так вот, добавлять что-то намного проще, чем кажется!
Обратите внимание на пункт «Don't check files and hide all messages from...». При нажатии на него выпадает список путей, которые можно добавить в исключение (см. рисунок 6).
*Рисунок 6. Исключение файлов из проверки.*
Можно выбрать как отдельный файл, так и одну из директорий. На рисунке показано, что выбирается папка «SDL2-2.0.9\src\haptic\windows». Это значит, что все файлы в этой папке и всех подпапках будут исключены из анализа. Более того, все сообщения, относящиеся к этим файлам, сразу исчезнут из списка. Очень удобно. Не нужно перезапускать анализ, чтобы убрать все сообщения, относящиеся к тестам.
Режим инкрементального анализа
------------------------------
Введение в PVS-Studio будет неполным, если не рассказать об одной из важнейших возможностей — [инкрементальном анализе](https://www.viva64.com/ru/m/0021/) кода.
Чем раньше ошибка найдена, тем дешевле её устранение. Идеально сразу подчеркивать ошибки в редактируемом тексте программы. Однако, это технически сложно и ресурсоемко. Поэтому PVS-Studio запускается в фоновом режиме в тот момент, когда исправленный код успешно скомпилирован. Таким образом, ищутся ошибки в только что измененном коде. О том, что происходит анализ, можно судить по иконке в системной области уведомлений.
Когда ошибка найдена, появляется всплывающее окошко, предупреждающее об опасности (см. рисунок 7).
*Рисунок 7. Всплывающее сообщение, что найдены подозрительные места в отредактированных файлах.*
Если кликнуть мышкой на иконку, то откроется IDE с результатом проверки проекта (см. рисунок 2) и можно будет изучить подозрительный фрагменты кода.
На самом деле, чем описывать этот режим, проще попробовать поработать с ним. Вы пишите код, как и раньше. А если надо, анализатор потревожит вас. Попробуйте!
Мы сами постоянно используем этот режим. Да, мы тоже иногда допускаем ошибки при кодировании. И возможность их сразу исправить существенно сокращает время на обнаружение дефекта и попытку понять, отчего программа ведёт себя не так, как планировалось. Очень обидно потратить минут 15-20 на отладку, чтобы потом обнаружить опечатку в индексе. Вот один из случаев, когда PVS-Studio нашел ошибку в PVS-Studio сразу после того, как она появилась в коде:
```
if (in[0] == '\\' && in[1] == '.' && in[1] == '\\')
{
in += 2;
continue;
}
```
Но это, конечно, цветочки. Анализатор PVS-Studio иногда может оказаться намного полезнее. Вот один из отзывов о нашем анализаторе: "[Пример использования статического анализатора](https://www.viva64.com/ru/b/0221/)". Текст заставляет задуматься.
Резюмирую. Инкрементальный анализ — это то, что вы должны обязательно попробовать. Вы его полюбите, как только найдете пару ляпов в свежем коде.
Возможности PVS-Studio
----------------------
Будем кратки. Невозможно лаконично описать все диагностики, которые имеются в PVS-Studio. Полный список диагностик и их подробное описание можно найти в документации: [Описание диагностируемых ошибок](https://www.viva64.com/ru/w/). Ограничимся таблицей, в которой диагностики сгруппированы по типам. Некоторые диагностики входят более, чем в одну группу. Дело в том, что деление весьма условно. Например, опечатка может приводить к использованию неинициализированной памяти. Некоторым ошибкам наоборот места в таблице не нашлось, слишком они специфические. Тем не менее, таблица в целом дает представление о функциональности статического анализатора кода (см. рисунок 8).
*Рисунок 8. Возможности PVS-Studio.*
Как видите, анализатор максимально проявляет себя в таких областях, как поиск ошибок, возникших из-за опечаток, Copy-Paste. Хорошо диагностирует проблемы, которые связаны с безопасностью кода.
Как всё это работает на практике, можно узнать, заглянув в [базу ошибок](https://www.viva64.com/ru/examples/). Мы собираем в эту базу все ошибки, которые нашли, проверяя различные Open-Source проекты.
SAST
----
PVS-Studio является средством статического тестирования защищённости приложений (Static Application Security Testing, SAST) — анализатор может выявлять потенциальные уязвимости в коде проекта и показывать соответствующий идентификатор ошибки в определенной классификации.
PVS-Studio поддерживает следующие классификации ошибок:
1. CWE
2. SEI CERT
3. MISRA
Включить отображение кодов CWE можно по контекстному меню в окне анализатора по пути Show Columns > CWE
*Рисунок 9. Контекстное меню и пример вывода CWE-кодов.*
Либо в меню сверху (Extensions > PVS-Studio > Display CWE Codes in Output Window)
*Рисунок 10. Меню расширения.*
Диагностики MISRA включаются отдельно в настройках:
*Рисунок 11. Список определяемых ошибок.*
Подробнее про эти классификации можно прочитать [здесь](https://www.viva64.com/ru/sast/).
Проверка проектов из командной строки
-------------------------------------
PVS-Studio\_Cmd.exe — утилита для проверки C++/C# Visual Studio проектов (.vcxproj/.csproj) и решений .sln из командной строки. Она может быть полезна для автоматизации анализа. Программа находится в директории, куда была произведена установка — по умолчанию это 'C:\Program Files (x86)\PVS-Studio'.
Программа имеет множество [параметров](https://www.viva64.com/ru/m/0035/), но для начала нам понадобится только 3 из них:
* --target: файл проекта или решения, который требуется проверить.
* --output: plog-файл, куда требуется записать отчет.
* --progress: показывать прогресс проверки.
Вот так будет выглядеть запуск:
*Рисунок 12. Вывод программы PVS-Studio\_Cmd.exe*
После выполнения мы получим plog-файл с отчетом, путь до которого мы указали в параметрах запуска. Этот отчет можно преобразовать в другие форматы с помощью утилиты PlogConverter.exe, а для просмотра отчета в IDE достаточно двойного клика по plog-файлу в проводнике.
Также файл отчета можно открыть в меню расширения по пути Extensions > PVS-Studio > Open/Save > Open Analysis Report…
Подробную информацию по утилите и ее параметрам можно найти в [документации](https://www.viva64.com/ru/m/0035/).
Подавление ложных предупреждений
--------------------------------
Некоторые сообщения, выданные анализатором, неизбежно будут ложными. С этим ничего нельзя поделать. Статический анализатор это всего лишь программа, которая не обладает искусственным интеллектом и не может точно определить, нашла она настоящую ошибку или нет.
Для борьбы с ложными срабатываниями в анализаторе предусмотрен набор различных механизмов. Подробно они описаны в следующих разделах документации:
* [Тонкая настройка](https://www.viva64.com/ru/m/0017/).
* [Грубый метод](https://www.viva64.com/ru/m/0032/), позволяющий работать только с предупреждениями, относящимися к новому или изменённому коду.
Заключение
----------
Конечно, здесь мы рассказали не всё об инструменте. Если рассказывать всё, то статья превратится в документацию. Цель была показать, как легко можно работать с инструментом в рамках среды Visual Studio. Про другие среды и режимы работы можно почитать в документации и других статьях, расположенных на нашем [сайте](https://www.viva64.com/ru/pvs-studio/). Там, кстати, много интересного для программистов. Заходите побродить.
Cтоит отметить, что PVS-Studio работает не только в среде от Microsoft. Мы также поддерживаем язык Java, можем работать под Linux и macOS, интегрироваться в CMake и много чего еще. Подробнее можно узнать в [документации](https://www.viva64.com/ru/m/).
Желаю вам безбажного кода и надеюсь, что вам понравится PVS-Studio. Если возникнут какие-то вопросы, то мы всегда поможем и подскажем. [Пишите нам](https://www.viva64.com/ru/about-feedback/).
Дополнительные ресурсы:
-----------------------
1. [Обзор кода (code review)](https://www.viva64.com/ru/t/0073/).
2. [Статический анализ кода](https://www.viva64.com/ru/t/0046/).
3. [Инструменты статического анализа кода](https://www.viva64.com/ru/t/0074/).
4. [SAST](https://www.viva64.com/ru/sast/).
5. [Технологии, используемые в анализаторе PVS-Studio](https://www.viva64.com/ru/b/0592/).
6. [Скачать PVS-Studio](https://www.viva64.com/ru/pvs-studio-download/) и попробовать в деле.
7. [Поддержка Visual Studio 2019](https://www.viva64.com/ru/b/0630/).
8. Обсудить цену на анализатор PVS-Studio для вашей команды и способах его приобретения: [купить PVS-Studio](https://www.viva64.com/ru/order/).
9. [Пример использования статического анализатора](https://www.viva64.com/ru/b/0221/).
10. [Ответы](https://www.viva64.com/ru/b/0593/) на вопросы, которые часто задают на конференциях.
11. [Как запустить PVS-Studio Java](https://www.viva64.com/ru/m/0044/)
12. [Как запустить PVS-Studio в Linux и macOS](https://www.viva64.com/ru/m/0036/)
[](https://www.viva64.com/en/b/0635/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Sergey Larin. [PVS-Studio for Visual Studio](https://habr.com/en/company/pvs-studio/blog/458068/) | https://habr.com/ru/post/458070/ | null | ru | null |
# PHPStamp — честная генерация DOCX документов из шаблона
Это еще одна попытка реализовать стабильный, полноценный шаблонизатор офисных документов, основанных на XML, пользуясь стандартными для PHP средствами DOMDocument и XSL.
Задача состояла именно в генерации шаблона для многократного использования, который не придется править вручную или прибегать к сторонним программам для его доработки.
Найти библиотеку можно здесь: [github.com/shadz3rg/PHPStamp](https://github.com/shadz3rg/PHPStamp)
#### Принцип работы
Несмотря на все прелести визуальных редакторов, на выходе всегда получается далеко не самый оптимальный код документа, и MS Word — не исключение. Вот так просто добавленные в документ Тэги заменить на XSL логику не получится, даже не смотря на относительно простую структуру DOCX документа.
Основную проблему представляют разбитые на отрывки (они же «run», представлены нодами ) параграфы, содержимое Тэгов разбивается на несколько нод и в таком виде их обработать не получится.
Для начала попробуем упростить разметку.
1. Удалим свойства языка у отрывков. Что логично, при замене Тэга может быть вставлено значение на любом языке, к тому же знаки пунктуации не имеют принадлежности к языку, что доставляет дополнительные проблемы при поиске Тэгов.
2. Удалим пустые ноды свойств отрывков, чисто технический момент.
3. Объединим рядом стоящие отрывки, используя deepEqual сравнение (которое в DOMDocument до сих пор «Not implemented») нод свойств.
Если все прошло по плану, библиотеке остается лишь добавить подходящую XSL логику. Предусмотрена возможность — некоторая расширяемость с опциями. Так, например, на данный момент реализованы табличные строки и списки.
Полученный шаблон кэшируется в файловой системе, поэтому последующие его вызовы будут максимально быстрыми (настолько, насколько способен XSL).
Предусмотрена поддержка разных форматов. В планах было добавить поддержку формата ODT, но ввиду отличной поддержки DOCX в LibreOffice особой необходимости нет. Возможно, хорошей идеей будет генерация XLSX, должно получится довольно быстро в сравнении с PHPExcel.
#### Зависимости и установка
Установить библиотеку вы можете через Composer, на сервере понадобится PHP 5.3 с модулями Zip, DOM и XSL.
```
{
"minimum-stability": "dev",
"require": {
"shadz3rg/php-stamp": "dev-master"
}
}
```
#### Пример использования
Для примера используем шаблон:
```
php
require 'vendor/autoload.php';
use PHPStamp\Templator;
use PHPStamp\Document\WordDocument;
$cachePath = 'path/to/writable/directory/';
$templator = new Templator($cachePath); // опционально можно задать свой формат скобочек
// Для того чтобы каждый раз шаблон генерировался заново:
// $templator-debug = true;
$documentPath = 'path/to/document.docx';
$document = new WordDocument($documentPath);
$values = array(
'library' => 'PHPStamp 0.1',
'simpleValue' => 'I am simple value',
'nested' => array(
'firstValue' => 'First child value',
'secondValue' => 'Second child value'
),
'header' => 'test of a table row',
'students' => array(
array('id' => 1, 'name' => 'Student 1', 'mark' => '10'),
array('id' => 2, 'name' => 'Student 2', 'mark' => '4'),
array('id' => 3, 'name' => 'Student 3', 'mark' => '7')
),
'maxMark' => 10,
'todo' => array(
'TODO 1',
'TODO 2',
'TODO 3'
)
);
$result = $templator->render($document, $values);
$result->download();
```
На выходе получаем документ с нужными нам данными:
 | https://habr.com/ru/post/244421/ | null | ru | null |
# Роботы-доставщики, облачные технологии и дополненная реальность: что дал IT-сфере 2021 год
В декабре в отсветах полыхающих дедлайнов бывает трудно разглядеть то, что давало нам вдохновение и помогало двигаться вперёд весь этот год. А ещё труднее распознать вещи, которые могут стать прорывными и, скорее всего, будут иметь долгие позитивные последствия для развития технологий в будущем.
В этой статье мы собрали шесть самых важных, на наш взгляд, трендов, событий и технологий 2021 года в области финтеха, кибербезопасности, digital-маркетинга и других связанных сфер. Ко многим из них имеет отношение и Сбер. Конечно, это далеко не всё, что происходило и двигало нас вперёд. Если вам есть чем дополнить наш список, будем рады пообщаться в комментариях.
Итак, поехали.
1. Ускоренный переход на облачные технологии
--------------------------------------------
Сегмент облачных технологий демонстрировал рост ещё до пандемии, но в 2021 году «облака» стали развиваться космическими темпами. Это произошло в том числе и благодаря повсеместному переходу IT-компаний на удалённую работу. По данным [совместного исследования Deloitte и X5 Group](https://www2.deloitte.com/ru/ru/pages/human-capital/articles/2021/remote-work-research.html) от 2021 года, в котором участвовали 80 компаний из России и СНГ, только в 3% фирм сотрудники работают в обычном режиме из офиса или на производстве. Все остальные — на удалёнке или в гибридном режиме.
«Облака» помогают не только быстро разворачивать удалённые доступы даже для большого числа сотрудников, но и выполнять вычисления, требующие высокопроизводительного оборудования, без расширения собственных мощностей. А это особенно актуально в свете тренда № 2 (читайте ниже).
В самом процессе развития «облаков» не было единства. Так, например, только в сфере безопасности облачных хранилищ Gartner отмечает целых 29 частных технологий, вызывавших больший или меньший интерес в 2021 году.
Источник — GartnerСбер не отставал от трендов и весь год улучшал SberCloud.
* Мы представили новый российский суперкомпьютер Christofari Neo, обладающий производительностью в 11,95 петафлопс. Вместе с предшественником он демонстрирует суммарную производительность более 18 петафлопс.
* Christofari Neo работает на графических процессорах NVIDIA A100 и создан специально для разработки моделей-трансформеров с современной архитектурой, для которых требуются большие датасеты.
* В ноябре 2021 года SberCloud обновил платформу [ML Space](https://developers.sber.ru/portal/tools/ml-space). Самое значимое изменение в том, что теперь платформа мультикластерная. В ней можно использовать как отдельные карты GPU V100 и A100 для разработки, тестирования и деплоя, так и всю мощность Christofari и Christofari Neo. Любая компания сегодня может стать клиентом ML Space, чтобы обучать свои ИИ-модели.
* Был анонсирован гибридный режим платформы ML Space Private, при котором её часть развёртывается на серверах компании, а часть продолжает работать в «облаке» SberCloud.
* Облачные сервисы платформы SberCloud.Advanced теперь доступны для физических лиц. Любой, кто работает над проектами в области ML, может зарегистрироваться на платформе, оплатить услуги и пользоваться возможностями и готовыми технологиями SberCloud.
* Создана платформа [Data Science Works](https://sbercloud.ru/ru/ds-works) (DS Works), чтобы решать бизнес-задачи в области Machine Learning и легко организовывать чемпионаты среди специалистов по Data Science. Чемпионаты могут понадобиться компаниям, если у них не хватает своих специалистов по DS (победители могут быть приняты в штат) или если у них есть сложная задача по ML, которую не смогли решить штатные сотрудники.
«Облака» продолжат развиваться в ближайшие 3–5 лет, поэтому важнейшими задачами для IT-компаний, в том числе и SberCloud, станет повышение удобства работы с облачными ресурсами для клиентов самых разных уровней, а также повышение защищённости данных.
2. Развитие генеративного ИИ
----------------------------
Особый интерес в мире проявляется к генеративному ИИ — нацеленному на генерацию оригинальных, реалистичных артефактов различного характера: музыки, изображений, текстов, видеороликов и др. Они находят не только локальное применение в сфере дизайна, обслуживания клиентов, повышения продаж, но и глобально влияют на реализацию ESG-стратегии компаний.
Впрочем, обо всём по порядку.
* В начале года команды SberDevices и Sber AI представили [ruDALL-E](https://rudalle.ru/) — модель для генерации изображений по текстовому описанию, а затем дообучали и дорабатывали её. Модель обучалась на 512 GPU TESLA V100 в течение 37 дней, а затем ещё 11 дней по 128 GPU — всего 20352 GPU-дней. RuDALL-E сравнима с DALL-E от OpenAI по количеству параметров (12 млрд). Генерировать изображения может любой желающий и не только на русском, но и на иностранных языках.
* В сентябре команда Sber AI совместно с CopyMonkey.ai выпустила [AI-копирайтера](https://promo.copymonkey.ai/)— сервис, который генерирует уникальные товарные описания на русском языке. Для работы ему достаточно задать название продукта и характеристики, которые необходимо отразить в тексте. Он работает на базе RuGPT-3.
* Также мы выпустили первый [музыкальный альбом](https://press.sber.ru/publications/sber-vypustil-muzykalnyi-albom-thriving-machine-sozdannyi-s-pomoshchiu-neirosetei), созданный нейросетью.
* Тренды и достижения в области AI, в том числе и острый вопрос влияния ИИ на ESG, мы обсудили на организованной нами международной онлайн-конференции [Artificial Intelligence Journey](https://ai-journey.ru/), которая проходила в ноябре. На неё зарегистрировались более 52 тысяч человек, а записи просмотрели свыше 50 миллионов людей по всему миру.
Мы развивали не только генеративный ИИ. Например, энкодерная языковая модель ruRoberta-large с 355 млн параметров была [оценена](https://habr.com/ru/company/sberbank/news/t/574798/) русскоязычным бенчмарком Russian SuperGLUE как лучшая после человека. Кроме того, в 10-ке рейтинга ещё 5 моделей от SberDevices.
Про все перечисленные и многие другие AI-сервисы мы писали в 2021-м. Кстати, в конце этой статьи мы собрали ссылки на наши лучшие публикации на Хабре этого года, среди которых много материалов по ИИ.
3. Омниканальность на новом уровне
----------------------------------
Омниканальность — это бесшовное объединение всех каналов коммуникации с потребителем. При реализации такой стратегии для клиента нет разницы, как и когда он обратился в компанию: через сайт, по почте, в соцсетях или мессенджере, в магазине или по телефону. Диалог должен бесшовно продолжаться даже при смене способа и средства коммуникации, а у бизнеса при этом должна быть вся информация о том, чего хотят клиенты. Средний потребитель больше не использует 1–2 точки контакта для каждой покупки. Их количество доходит до 6 и растёт.
В период пандемии стремительно выросло количество онлайн-покупок, поэтому вопрос организации омниканальных взаимодействий и аналитики стал не просто острым, но жизненно необходимым в ряде компаний. Развились сервисы, организующие такую коммуникацию. В России уже второй год при участии исследовательского агентства Data Insight составляется [рейтинг омниканальных ритейлеров](https://www.omnirating.ru/).
В экосистему Сбера входит Группа компаний ЦРТ (Центр речевых технологий), которая создаёт системы управления омниканальным клиентским опытом. ЦРТ работает с технологиями распознавания лиц и голоса, а также синтеза речи. По оценке гендиректора ЦРТ Дмитрия Дырмовского, наиболее востребованы в 2021 году были технологии:
* речевой аналитики, помогающие выявлять потребности клиентов и подбирать релевантные ответы на их запросы;
* голосовые и текстовые виртуальные ассистенты.
Кроме того, в 2021 году ЦРТ запустил ИИ-платформу, объединяющую более 7 самостоятельных продуктов и технологий, обеспечивающих омниканальность и оптимизирующих процесс работы с клиентами.
Платформа включает 3 блока:
* «Общение» — сервисы для обработки входящих и исходящих обращений по телефону, через голосовые меню, текстовых и речевых ботов;
* «Персонализация» — продукты для быстрой и безопасной идентификации клиентов во время дистанционного обслуживания, в том числе для защиты от мошенничества, а также для персонализации предложений;
* «Аналитика» — сервисы для оценки общения персонала и ботов с клиентами, позволяющие повышать качество этих процессов.
На платформе реализовано свыше 90 проектов для крупного бизнеса, в том числе для Сбера.
4. Умная кибербезопасность
--------------------------
По [официальным данным МВД](https://xn--b1aew.xn--p1ai/news/item/24738876), по итогам первых 5 месяцев 2021 года количество преступлений, совершённых с использованием IT-технологий, увеличилось на 25,7% по сравнению с тем же периодом прошлого года. К сожалению, ситуация в мире ненамного лучше. По данным аналитиков Cybersecurity Ventures, в течение следующих пяти лет затраты от киберпреступности в мире будут расти на 15% ежегодно. В сфере банковского обслуживания по понятным причинам число угроз для кибербезопасности одно из самых высоких.
Сбер активно развивает технологии защиты от мошенничества. Причём большинство из них «невидимы» для пользователей. В Лаборатории кибербезопасности разработан ряд продуктов, которые позволяют противодействовать корпоративному, пользовательскому и кибермошенничеству.
* Фрод-мониторинг — проверка транзакций с помощью ИИ для выявления и блокировки подозрительных.
* Системы цифрового и видеомаркирования документов, которые позволяют в режиме реального времени незаметно маркировать документы, фото, видео, отслеживать действия пользователей и сообщать о подозрительных или мошеннических манипуляциях.
* AntiDeepFakes — противодействие технологии реализации кибератак через видео. Система может определить сгенерированные или изменённые ролики. Несколько нейросетей, обученных на множестве видеороликов, с высокой точностью определяют модифицированные изображения лиц в последовательностях изображений, фокусируясь на незаметных для человеческого глаза неестественных артефактах.
В СберБанк Онлайн доступны несколько сервисов по защите от мошенничества.
* Сервис проверки входящих звонков, который на этапе вызова предупреждает клиента, что ему, возможно, звонит злоумышленник.
* Форма «Сообщить о мошеннике», позволяющая отправить в банк телефон или сайт преступников.
* Сервис «Проверить телефон и почту» для проверки, не попала ли эта персональная информация к мошенникам.
* Сервис «Управление приложениями», позволяющий посмотреть все устройства, подключённые к СберБанк Онлайн, и отключить подозрительные.
* Сервис «Ограничение оплаты в интернете», дающий возможность ограничивать оплату покупок в сети полностью или только без ввода пароля.
* Симулятор кибермошенничества — приложение, дающее людям возможность поучаствовать в диалоге с виртуальным мошенником в рамках различных мошеннических схем, чтобы научиться их распознавать. В роли мошенника выступает робот.
5. Беспилотники и роботы-курьеры
--------------------------------
Технологии беспилотной перевозки пассажиров и доставки грузов давно будоражат умы исследователей по всему миру. Пандемия ускорила процесс развития инноваций. Так, например, в США с компанией-производителем беспилотников для доставки Nuro сотрудничает Walmart, анонсировано сотрудничество и с FedEx. Технологию автономного вождения [реализовала компания Nissan](https://www.nissan.ru/experience-nissan/intelligent-mobility.html) в концепции Intelligent Mobility. И это не единственные примеры расширения функционала умных роботов.
В экосистему Сбера входит компания СберАвтоТех (SberAutoTech), главная цель которой — создавать транспорт нового поколения. Так, она спроектировала ФЛИП — полностью электрический беспилотный транспорт, который обладает габаритами стандартного легкового автомобиля, но вмещает шесть пассажиров. Комплекс радаров, лидаров и сенсоров обеспечивает обзор на 360°, а скорость реакции компьютера выше, чем у любого профессионального водителя.
Среди разработок Лаборатории робототехники Сбера, которые уже доступны на рынке, — робот-дезинфектор и робот-курьер, о которых мы недавно [писали](https://habr.com/ru/company/sberbank/blog/595845/). Первый предназначен для автоматизации обеззараживания различных помещений большой площади в офисах, медучреждениях, отелях и др. Робот-курьер может доставлять любые грузы массой до 15 кг и взаимодействовать с посетителями в офисах, конференц-залах, больницах, отелях.
Кроме того, пока в единственном экземпляре сконструирован робот-сомелье — уникальный и не имеющий аналогов в мире объект, предназначенный для ресторанов и винных галерей высокого класса. Он может самостоятельно подобрать нужное вино с учётом пожеланий гостя, открыть бутылку, разлить вино по бокалам и передать гостям.
6. Расширение области применения AR/VR
--------------------------------------
Технологии виртуальной и дополненной реальности и так были востребованы, когда в декабре Цукерберг подлил масла в огонь со своей метавселенной. Им уже анонсированы гарнитура дополненной реальности Project Cambria и очки Project Nazaré. Аналитики предрекают новую волну популярности VR и AR в следующие несколько лет.
По этому направлению нам тоже есть чем поделиться! Недавно мы [писали](https://habr.com/ru/company/sberbank/blog/592209/) про Лабораторию Sber AR/VR Lab. Весь 2021 год она активно работала над технологией VPS (Visual Positioning System). VPS позволяет установить положение пользователя в пространстве посредством камеры смартфона с точностью до 0,5 метра и функционирует как в помещении, так и на улице. Сейчас технология находится на стадии тестирования, а в будущем имеет много возможностей:
* построение высокоточных маршрутов в городе с указаниями в режиме дополненной реальности;
* участие в AR-экскурсиях через приложения;
* использование в интерактивных играх и др.
Мы не только разрабатывали новые продукты и сервисы, но и активно писали об этом! За год в этом блоге набралось много материалов, которые вам понравились. Вот самые популярные из них:
1. [ruDALL-E: генерируем изображения по текстовому описанию, или Самый большой вычислительный проект в России.](https://habr.com/ru/company/sberbank/blog/586926/)
2. [Рассказываем про библиотеку для Process Mining: теперь SberPM в открытом доступе.](https://habr.com/ru/company/sberbank/blog/554378/)
3. [Применяем ruGPT-3 в популярных задачах и показываем, зачем языковым моделям триллион параметров.](https://habr.com/ru/company/sberbank/blog/550056/)
4. [Языки программирования на эмодзи, и как можно использовать смайлики в коде.](https://habr.com/ru/company/sberbank/blog/579816/)
5. [ruT5, ruRoBERTa, ruBERT: как мы обучили серию моделей для русского языка.](https://habr.com/ru/company/sberbank/blog/567776/)
6. [Я тебя породил, я тебя вторично и переработаю: как финтех подготовился к отказу от пластика](https://habr.com/ru/article/579740/).
7. [Обучение рукописной OCR на синте от GAN'ов.](https://habr.com/ru/company/sberbank/blog/589537/)
8. [Нет, это не скучно! Или 5 мифов о работе тестировщика](https://habr.com/ru/company/sberbank/blog/577144/).
9. [Метавселенные рядом — нужно только знать, куда смотреть. Один из проектов Sber AR/VR Lab в 2021-м.](https://habr.com/ru/company/sberbank/blog/592209/)
10. [ГИС для бизнеса: GeoAI, IoT для городов, большие данные с геотегами и геопространственное мышление.](https://habr.com/ru/company/sberbank/blog/589817/)
Если что-то из этого прошло мимо вас, загляните — там всё ещё интересно.
И спасибо, что были с нами в 2021 году: читали, оценивали, сохраняли и
делились мнением в комментариях. До встречи в `11111100110!` | https://habr.com/ru/post/598091/ | null | ru | null |
# Routing слой в iOS-приложениях
Случалось ли с вами, что вы открыли *Storyboard* и от увиденного вас начинают переполнять ~~положительные~~ эмоции?
В этот момент, возможно, вы задумываетесь, что хорошо продуманная навигация между экранами (в дальнейшем *Routing*) в крупных проектах может стать крайне значимой задачей, решение которой поможет экономить время и нервы всем, кто будет участвовать в проекте.
Что подразумевается под словом *Routing* в данной публикации?
В общих чертах это можно охарактеризовать как путь из одного экрана в другой. И у каждого этот путь свой. Кто-то сразу представит *Storyboard Segue*, а кому-то по душе вот такой вызов:
```
self.navigationController?.pushViewController(UIViewController(), animated: true)
```
В какой момент может возникнуть нужда в переосмыслении *Routing* слоя?
* Вы открыли старый проект (возможно даже ваш) и никак не можете понять всей картины переходов между экранами.
* Вы работаете над крупным проектом и хотите сразу сделать доступно и прозрачно для всех участников проекта.
* Вы читаете [статью про VIPER](https://www.objc.io/issues/13-architecture/viper/#routing) и планируете погрузиться в ~~чудесный~~ мир архитектурных дискуссий.
* Ваш *Storyboard* стал настолько большим, что добавляя каждый новый экран вы испытываете различные сложности.
* Маломощные машины просто не в силах открыть *Storyboard* проекта.
* Вы вообще не используете *Storyboard* ([по этой причине?](https://github.com/facebook/AsyncDisplayKit/blob/master/examples/Swift/Sample/ViewController.swift#L47)) и вызовы типа *pushViewController* разбросаны по всему проекту.
* *Ваш уникальный случай и другие ситуации.*
С чего можно начать переосмысление *Routing* слоя?
Важно определиться какие вещи попадут в *Routing*. Это могут быть функции *UIViewController*, *UINavigationController* и др. осуществляющие различные *переходы*: *pushViewController*, *popViewController*, *popToViewController*, *popToRootViewController*, *present*, *dismiss*, *setViewControllers*. Так же в *Routing* может попасть показ различных всплывающих окон типа *alert*, *action sheet*, *toast*, *snackbar*.
Не менее важным шагом будет принятие решения о том, как будет вызываться переход. В идеале код перехода будет достаточно краток и понятен даже тому, кто видит его в первый раз.
```
func someFunction() {
...
routing(with: .dismiss)
}
```
Подготовка *UIViewController* для осуществления переходов
Если попытаться реализовать пример, приведенный выше, то *routing* будет являться функцией, которую реализует сам *UIViewController*:
```
extension UIViewController {
func routing(with routing: Routing) {
...
}
}
```
Далее, надо создать элемент *Routing*, который будет попадать в функцию в виде параметра. В языке swift перечисления получились очень гибкими и в данной ситуации подойдут лучше всего:
```
enum Routing {
case dismiss
case preparedNavigation
case selectedCityTransport(CityTransport)
case selectedTrafficRoute(TrafficRoute)
...
}
```
Стоит заметить, что один и тот же *Routing* параметр может быть вызван разными *UIViewController* и, например, при таких вызовах должны происходить разные переходы. Соответственно, приложение должно знать из какого конкретно *UIViewController* был вызван переход. Можно добиться адекватного сопоставления *UIViewController* и перехода разными способами. Однако, в идеале, хотелось бы у *UIViewController* завести определенный параметр для этих целей. Например при помощи ~~запрещенной магии~~ [runtime](http://nshipster.com/swift-objc-runtime/):
```
extension UIViewController {
enum ViewType {
case undefined
case navigation
case transport
...
}
private struct Keys {
static var key = "\(#file)+\(#line)"
}
var type: ViewType {
get {
return objc_getAssociatedObject(self, &Keys.key) as? ViewType ?? .undefined
}
set {
objc_setAssociatedObject(self, &Keys.key, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
}
}
}
```
Введя новый параметр *type* у *UIViewController* можно детализировать функцию *routing*, в которой будут собраны все вызовы переходов между экранами приложения и разбиты по типу вызывающего *UIViewController*:
```
extension UIViewController {
func routing(with routing: Routing) {
switch type {
case .navigation:
preparedNavigation(with: routing)
case .transport:
selectedCityTransport(with: routing)
default:
break
}
}
}
```
Конкретную реализацию каждого перехода можно, например, вынести в отдельный приватный *UIViewController extension*:
```
private extension UIViewController {
func preparedNavigation(with routing: Routing) {
switch routing {
case .preparedNavigation:
guard let view = self as? UINavigationController else { break }
view.setViewControllers([TransportView()], animated: true)
default: break
}
}
func selectedCityTransport(with routing: Routing) {
switch routing {
case .selectedCityTransport(let object):
navigationController?.pushViewController(RoutesView(object), animated: true)
default: break
}
}
}
```
Чего удалось добиться в итоге?
* Все переходы приложения описаны в одном месте, упорядочены и не дублируются.
* Вызов перехода лаконичен и прост в использовании.
* При необходимости можно смело отказываться от использования *Storyboard*, если на то есть причины. Например, вы решаете использовать [AsyncDisplayKit](http://asyncdisplaykit.org).
* Не появилось никаких новых менеджеров, сервисов или синглтонов… Вся логика остается внутри *UIViewController extension*.
Использовался ли данный подход авторами публикации?
В двух проектах, написанных на swift с нуля, удалось внедрить представленную реализацию *Routing* слоя. Один из проектов был написан с использованием [RxSwift](https://github.com/ReactiveX/RxSwift) и *routing* вызов был обернут примерно таким образом:
```
extension Reactive where Base: UIViewController {
var observerRouting: AnyObserver {
let binding = UIBindingObserver(UIElement: base) { (view: UIViewController, routing: Routing) in
view.routing(with: routing)
}
return binding.asObserver()
}
}
```
Размеры проектов составили 55к и 125к [loc](https://gist.github.com/Tokuriku/f7d6ce5a68d2154c28b0). Размеры файлов в каждом проекте, которые содержали в себе весь *Routing* слой, были примерно одинаковы и составили около 600 строк кода. | https://habr.com/ru/post/321842/ | null | ru | null |
# SafeThreadUpdate() для wpf-контролов
Привет, ребята! Многим, наверно, неудобно обращаться к Dispatcher каждый раз, когда нужно обновить контрол с не UI-потока в WPF… в общем, меня это конкретно достало, поэтому написал очень простенький extension-метод, которым и хочу поделиться с вами всеми:
```
static class exMethods
{
async public static void ThreadSafeUpdate(this System.Windows.Controls.Control @this, Action updateLogic)
{
await @this.Dispatcher.BeginInvoke(updateLogic);
}
}
```
Работает вот так:
```
this.ThreadSafeUpdate(() => this.Visibility = Visibility.Hidden);
``` | https://habr.com/ru/post/271781/ | null | ru | null |
# Обзор одной российской RTOS, часть 8. Работа с прерываниями
Публикую последнюю статью из первого тома «Книги знаний» ОСРВ МАКС. Надеюсь, это неформальное руководство поможет вам, коллеги, в случае, если придется работать с этой RTOS.
Предыдущие статьи:
[Часть 1. Общие сведения](https://habrahabr.ru/post/336308/)
[Часть 2. Ядро ОСРВ МАКС](https://habrahabr.ru/post/336696/)
[Часть 3. Структура простейшей программы](https://habrahabr.ru/post/336944/)
[Часть 4. Полезная теория](https://habrahabr.ru/post/337476/)
[Часть 5. Первое приложение](https://habrahabr.ru/post/337974/)
[Часть 6. Средства синхронизации потоков](https://habrahabr.ru/post/338682/)
[Часть 7. Средства обмена данными между задачами](https://habrahabr.ru/post/339498/)
Часть 8. Работа с прерываниями (настоящая статья)
Почему прерывания жизненно необходимы
-------------------------------------
Преподаватели информатики очень любят рассказывать о том, что существует работа по опросу, а также — по прерыванию, после чего обычно приводят небольшой примерчик обработки прерываний и забывают о теме. Дальше, при реальном программировании, приходится постигать основы этого дела не собственной шкуре.
При программировании в однозадачных системах, очень часто удаётся «выкрутиться» за счёт работы с оборудованием по опросу. В многозадачных системах это становится всё труднее.
Рассмотрим простейший пример. Пусть идёт приём из последовательного порта с ужасно низкой скоростью 9600 БОД. Реальные скорости давно находятся в районе 250 КБОД, но чтобы не возникало желания просто снизить скорость для решения проблемы, давайте рассмотрим именно сверхмедленный вариант.
В последовательном порту один байт — это при моей любимой настройке порта 10 бит (8 битов данных, а также стартовый и стоповый). Итого, приходит 960 байт в секунду. Округлим до 1000. Это 1 байт в миллисекунду. Разместим события на оси времени.
Если в типовом контроллере не успеть обработать очередной байт до прихода следующего, он будет затёрт новым пришедшим из линии значением. Рассмотрим суть этого на схеме из описания контроллера STM32.
По умолчанию, задачи переключаются 1 раз в 1 миллисекунду. Разместим на оси времени случай последовательного переключения пяти задач.
Пусть COM порт опрашивается в задаче 1. Совместим два рисунка…
Как видно, 4 байта из последовательного порта придут, когда задача, ожидающая их, неактивна. Имеются контроллеры с большой аппаратной очередью. Например, ESP8266 может принять 128 байт в аппаратный буфер. Таким контроллерам рассмотренная ситуация нипочём — задача 1 получит данные, накопленные аппаратурой. Но, например, у всех STM32 входной буфер может принять не более одного байта. И для них работа с последовательным портом в многозадачной среде по опросу смерти подобна даже на таких «смешных» скоростях, как 9600 бит в секунду.
Правильным решением будет пришедшие байты складывать в буферную память, чтобы обрабатывающая задача взяла всё, что накоплено, оптом. Как вариант, производить какую-то предобработку (например, первичный разбор пакетов, если это возможно без особых задержек) и передавать в обрабатывающую задачу уже предобработанные параметры.
Разумеется, пример с последовательным портом был выбран, как наиболее близкий большинству читателей. На самом деле, имеется намного больше случаев, где опрос даже в однозадачной среде слабо приемлем, а в многозадачной — невозможен. Первое, что приходит на ум — поддержание оборотов двигателя. Реальный случай — двигатель вращается на скорости до 5 тысяч оборотов в минуту, от него приходит два импульса обратной связи на оборот.
Один из типовых алгоритмов измерения частоты вращения, требует измерить при помощи таймера период следования этих импульсов. То есть, требуется снять показания таймера на момент прихода, а затем — перезапустить таймер для нового измерения. Если от момента прихода импульса до момента снятия показаний будет проходить случайное время — точность измерения существенно упадёт. Чаще всего — не просто существенно, а неприемлемо упадёт.
Прикинем нашу ситуацию — 10000 импульсов обратной связи в минуту. Делим на 60 — получаем 167 Гц. 1 импульс в 5 миллисекунд, который надо обработать как можно ближе к моменту его возникновения, чтобы не потерять точность измерений. Время прихода импульса подгадать невозможно — двигатель вращается так, как нравится ему. При пяти задачах, время возможного ожидания передачи управления следящей задаче составляет более половины периода следования импульсов. Например, вот такая ситуация:
Сколько времени прошло от прихода импульса до активации задачи, производящей опрос — неизвестно. Как видно, и здесь реализовать сколь-либо разумную обработку данных можно только по прерываниям. Импульс пришёл, время его прихода было запомнено, а уже обрабатывающая задача может этим временем воспользоваться когда угодно.
Из всего вышесказанного следует, что
> прерывания в многозадачной среде являются не только мощным, но зачастую и единственно возможным механизмом работы с аппаратурой.
Основной механизм обработки прерываний в ОСРВ МАКС
--------------------------------------------------
При работе с ОСРВ МАКС, прерывания допускается обрабатывать двумя способами — «удобным» и «быстрым». Рассмотрим сначала тот, который считается основным вариантом («удобный»).
В рамках ОС разрабатывается обычная задача, но она должна наследоваться не от **Task**, а от **TaskIrq**. Этой задаче ставится высокий приоритет, так как она должна будет вытеснить все остальные задачи, как только возникнет прерывание. Класс TaskIrq содержит виртуальную функцию IrqHandler(), которую следует перекрыть, разместив там все действия, связанные с обработкой прерывания.
Во время инициализации, прерывание следует разрешить через программирование контроллера прерывания (я сам пугаюсь, сколько раз слово «прерывание» было сказано в последних двух абзацах, но увы, без этого никак). При постановке задачи на планирование, так как она унаследована от особого класса, следует в виде параметра указать номер запроса на прерывание, который она обрабатывает.
Идеологически, вызов данной задачи можно представить следующим образом:
Именно поэтому её приоритет должен быть высоким — она ничем не отличается от остальных задач, поэтому обязана их вытеснить, а это делается именно при помощи приоритета. Теперь рассмотрим практический пример. Вот типичная задача — обработчик радиомодуля, подключённого к последовательному порту. Как видим, она действительно унаследована от TaskIrq, и в ней действительно перекрыта функция IrqHandler().
**Текстом**
```
class PortRadioTask : public TaskIrq
{
public:
PortRadioTask() : TaskIrq("Radio") {}
virtual void IrqHandler();
};
```
Вот так эта задача добавляется:
```
const int Radio_IrqNumber = EXTI15_10_IRQn;
...
result = TaskIrq::Add(radio_task = new PortRadioTask, Radio_IrqNumber, Task::PriorityRealtime);
```
Настройку NVIC для примера радиомодуля вынесем за пределы этого раздела. На мой взгляд, в этом примере она не очень иллюстративна. Чисто для иллюстрации покажем, как настраивается NVIC для конкретного обработчика в другом примере (специально выбран вариант с изменением приоритета, хотя можно приоритет и не изменять).
```
NVIC_EnableIRQ(EXTI9_5_IRQn);
NVIC_SetPriority(EXTI9_5_IRQn,1);
```
Итак. Задача описана, её функция TaskIrq перекрыта, задача добавлена в планировщик, что дальше? А дальше — забота ОС. Когда возникнет прерывание, внутренний обработчик прерывания самостоятельно вызовет планировщик. Тот — активирует задачу. Здесь важно, чтобы у задачи был высокий приоритет, чтобы она гарантированно вытеснила другие задачи. Ну, и через некоторое время (требуемое на переключение задач), функция IrqHandler() получит управление. Что разместить в теле данной функции — проблемы прикладного программиста (в следующей части документа будут описаны типовые решения для случаев работы через драйверы нижнего уровня).
Стандартные решения:
* можно принять данные, предобработать их, поставить в очередь сообщений для задачи с нормальным приоритетом,
* а можно — взвести семафор для задачи с нормальным приоритетом
Простенький пример обработчика прерывания:
```
Semaphore s_sema_radio_irq(0, 1); // семафор разблокируется в обработчике прерывания радиомодуля
void PortRadioTask::IrqHandler() {
s_sema_radio_irq.Signal();
}
```
Возможные проблемы при использовании основного механизма
--------------------------------------------------------
Все возможные проблемы от использования основного механизма обработки прерываний связаны с одним: для пробуждения задачи-обработчика требуется переключить контекст задач. На это требуется время. При практической работе в системе с двумя задачами, на осциллограмме мы видели, что переключение происходило за 4.7 микросекунды. В целом, время зависит от опций сборки, от количества задач, от прочих условий. Возьмём за основу для дальнейших прикидок достаточно реальное и достаточно круглое значение 10 микросекунд.
Давайте рассмотрим несколько типовых сценариев работы оборудования, обслуживаемого микроконтроллером. Начнём с простого. Станок с ЧПУ, получающий команды G-CODE через последовательный порт на скорости 250 килобит. Как уже говорилось, в последовательном порту байт — это 10 бит (8 бит данных, плюс стартовый и стоповый биты). Итого, частота прихода байтов составляет 25 КГц. Один байт в 40 микросекунд. И на переключение контекста уходит 10 микросекунд.
Четверть времени работы микроконтроллера (мощного 32 битного микроконтроллера) будет уходить только на переключение контекста, так как строки G-Code идут одна за одной, достаточно плотным потоком. Приемлемо ли это? Скорее нет, чем да.
Дальше, работа с шаговым двигателем, требующим 200 шагов на миллиметр на 3D принтере, печатающем со скоростью 150 мм/с требует работы на частоте 30 КГц. Это уже даже больше четверти.
G-Code принимается тем же контроллером, который управляет шаговыми двигателями. Итого, на вход в прерывание требуется уже более половины процессорного времени.
Само собой, такой вариант неприемлем.
Но с другой стороны. Возьмём тот же последовательный порт, на той же самой скорости, но подключим к нему радиомодуль, с которого приходят 32-байтные пакеты 4 раза в секунду. Таким образом, нагрузка на процессор будет повышаться на участках длиной 1200 микросекунд, а за секунду такие периоды пиковой нагрузки будут возникать в течение 4800 микросекунд. Это 4.8% времени. Приемлемо? Чаще да, чем нет. То есть, считаем, что этот вариант для обработки стандартным способом приемлем.
Точно так же можно прикинуть, что уже упомянутый механизм определения скорости вращения двигателя по сигналам обратной связи будет неприемлем — показания таймера надо снимать как можно ближе к моменту прихода сигнала. А снятие показаний с датчика влажности — вполне приемлемо. В то же время, обработка данных с последовательного порта на скорости 921 килобит в секунду займёт 100% времени на переключение задач, поэтому неприемлема… Ну, и так далее. В игру «приемлемо-неприемлемо» можно играть долго. Давайте сформулируем общие принципы.
Если прерывания приходят редко — вариант приемлем.
Если прерывания приходят так часто, что на переключение контекста уйдёт 100 и боле процентов времени — вариант неприемлем
Если на переключение контекста уйдёт высокий процент времени, но это будет происходить достаточно редко и достаточно короткими пачками — вариант приемлем.
Если переключение с высокой частотой будет постоянным — вариант неприемлем.
Какую же замену можно предложить? Конечно, прямую обработку прерываний.
Почему не стоит отказываться от основного механизма
---------------------------------------------------
Вы можете спросить: «А почему не предложить прямую обработку прерываний во всех случаях?». Я задал точно такой же вопрос разработчикам ОСРВ МАКС. Увы, их ответ был категоричен: есть причины, по которым стандартная обработка всё-таки удобнее.
Начнём с простого. Имена обработчиков прерываний. Даже в пределах семейств ARM они разные. Приведём наиболее яркие различия между семействами STM32 и «Миландр»
| | |
| --- | --- |
| **STM32** | **«Миландр»** |
| USART1\_IRQHandler | UART1\_IRQHandler |
| TIM1\_UP\_TIM10\_IRQHandler | Timer1\_IRQHandler |
| TIM2\_IRQHandler | Timer2\_IRQHandler |
При миграции, их потребуется переписывать. При основном механизме, имена обработчиков — это забота ОС. Они скрыты от прикладного программиста (жаль только, что имена векторов всё-таки не скрыты, но без этого уже не обойтись).
Далее, при использовании стандартного обработчика, вызывается обычная задача. Настоящий обработчик прерываний скрыт от глаз прикладного программиста. Он всего лишь пробуждает задачу-обработчик и сообщает планировщику, что следует переключить контекст. Всё остальное — это обычная задача. А вот с прерываниями — там всё иначе. Если посмотреть описание любой ОС (хоть реального времени, хоть даже и Windows), то будет видно, что очень многие механизмы не работают в обработчике прерываний. Бегло осмотрим механизмы ОСРВ МАКС.
Давайте разберёмся, почему пара записей, казалось бы, могла быть жёлтой (ведь при некоторых условиях механизм доступен), но отмечена красным. При реализации указанных механизмов, требуется исключить возможность повторного входа в функцию. Для этого, в ней размещается критическая секция, которая, как мы помним, блокирует все прерывания, приоритет которых ниже, чем MAX\_SYSCALL\_INTERRUPT\_PRIORITY. Собственно, этим всё сказано. Прерывания временно запрещаются. То есть, мы не получаем преимуществ от прямой обработки прерываний. С другой стороны, мы теряем все удобства, имеющиеся в основном механизме обработки прерываний. В общем, в ситуациях, ради которых отказываются от основного механизма обработки прерываний в пользу прямого, семафоры устанавливать нельзя и очередями сообщений пользоваться нельзя. Поэтому в таблице они отмечены красным.
> Итак, если есть возможность пользоваться всеми возможностями ОС, то лучше и проще ими пользоваться, а переходить к прямой обработке прерываний только если в этом есть крайняя необходимость.
>
>
Прямая обработка прерываний
---------------------------
При прямой обработке прерываний, скорость реакции определяется только возможностями микроконтроллера. Перечень обработчиков прерываний удобно брать из файла startupXXXX.s, имеющегося в каждом проекте. В демонстрационном приложении PinListAndTimerDemo обрабатывается прерывание от таймера 2, давайте рассмотрим, как быстро найти имя его обработчика.
0
Зная имя обработчика, его очень просто сделать, пользуясь следующими правилами:
* Если он размещается в файле cpp (код C++), обязательно следует добавить префикс **extern «C»**. Без этого, имя функции будет сформировано по правилам С++ и система не поймёт, что мы подменяем обработчик прерывания.
* Возвращаемый тип — void.
* Аргументов – нет.
Таким образом, в уже упомянутом примере, обработчик прерывания от таймера 2 в стартовом коде именован так:
А функция обработки, соответственно,
```
extern "C" void TIM2_IRQHandler (void)
{
...
```
Важно помнить, что обработчик такого прерывания должен исполняться максимально быстро. Пока программа находится в обработчике, не работают все остальные задачи, а также заблокированы прерывания с меньшим приоритетом.
Обработчик прерываний должен быстро принять данные, положить их для дальнейшей обработки и тут же прекратить свою работу. Никаких сложных вычислений, никакой другой лишней работы в обработчике прерываний располагаться не должно.
Удобным механизмом для связи прерываний с основными задачами является кольцевой буфер. Прерывание помещает принятые данные в него по мере их прихода, а какая-либо задача — изымает и использует, не заботясь о скорости обработки.
Кольцевой буфер из библиотеки mcucpp
------------------------------------
Библиотека mcucpp Константина Чижова, используемая в качестве вспомогательной, уже содержит реализацию кольцевых буферов. О самой библиотеке много будет говориться в следующей части документа, а пока рассмотрим файл ring\_buffer.h.
Класс RingBuffer использует в своей работе оператор new для добавления каждого элемента, поэтому в приложениях реального времени (и, тем более, в прерываниях) использован быть не может. Но этот же заголовочный файл содержит класс RingBufferPO2 — кольцевой буфер, размер которого кратен степени двойки. Данный класс не только работает с заранее предвыделенным буфером, но и ещё настолько потокобезопасен для схемы «один писатель, один читатель», насколько это позволяет система команд микроконтроллера (опасные счётчики записываются через класс атомарного доступа, и безопасность определяется уже тем классом).
Определяется класс следующим образом:
**template
class RingBufferPO2**
**SIZE** — количество элементов. Должно быть кратно степени двойки, в противном случае, компилятор выдаст ошибку.
**T** — тип хранимых данных. Допускаются как скаляры, так и структуры.
**Atomic** — класс для обеспечения атомарности операций (если не указан — атомарность не обеспечивается).
> Буфер для хранения данных является переменной-членом класса. Поэтому объект класса следует помещать в тот пул, в котором имеется достаточно свободного места (стек, куча, глобальная память, специально заданный пул памяти и т.п.)
Пример объявления для буфера байтов, принятых из COM порта (на 64 символа):
```
Mcucpp::Containers::RingBufferPO2<64, uint8_t, Mcucpp::Atomic> bufFromUart;
Для помещения данных в буфер, используется функция
**bool push\_back(const T& value)**
```
если результат равен false, то данные не были помещены, так как буфер переполнен.
Обычно для получения данных используется функция, которая попутно выталкивает их из очереди. Для случая скалярных величин, это оправдано, но для случая структур — выполняется лишняя операция копирования — данные копируются на новое место, так как из старого они будут удалены. Скорее всего, для предотвращения копирования, автор библиотеки mcucpp пошёл несколько другим путём. Данные из очереди не выталкиваются, а считываются (получается ссылка на них). Для удаления данных, используется отдельная функция.
Основной функцией чтения данных можно назвать следующую:
**const T& front()const**
**T& back()**
Как видим, она возвращает ссылку на данные, то есть, **не выполняет копирования.**
Можно получить ссылку на самый последний элемент в очереди:
**const T& back()const
T& front()**
Можно даже работать с очередью по индексу:
**const T& operator[] (size\_type i)const
T& operator[] (size\_type i)**
Ну, и когда в элементе отпала нужда, его следует удалить из очереди при помощи функции:
**bool pop\_front()**
Если очередь пустая, функция вернёт false.
Имеются также вспомогательные функции проверки очереди на переполненность и пустоту:
**bool full()const
bool empty()const**
Можно узнать, сколько конкретно элементов находится в настоящий момент в очереди:
**size\_type size()const**
Наконец, можно узнать ёмкость очереди (правда, она равна константе и задаётся на этапе разработки программы, но для совместимости с динамическими буферами, эти функции могут оказаться полезны):
**size\_type max\_size()
size\_type capacity()**
Давайте проверим, насколько плох подход вызова двух функций вместо одной. Чтобы получить хорошие реперы, обрамим фрагмент кода чётко выраженными вызовами (соответствующие строки зачеркнём).
**Текстом**
```
txtOuter.ShowSymbol('A');
txtOuter.ShowSymbol(bufFromUart.front());
bufFromUart.pop_front();
txtOuter.ShowSymbol('B');
```
Соответствующий ассемблерный код выглядит так:
**Текстом**`00025c 2141 MOVS r1,#0x41 ;288
00025e a801 ADD r0,sp,#4 ;288
000260 f7fffffe BL _ZN9TextOuter10ShowSymbolEwb ; TextOuter::ShowSymbol(wchar_t, bool)
000264 484b LDR r0,|L4.916|
000266 2201 MOVS r2,#1 ;290
000268 f8901044 LDRB r1,[r0,#0x44] ;290
00026c f001013f AND r1,r1,#0x3f ;290
000270 5c09 LDRB r1,[r1,r0] ;290
000272 a801 ADD r0,sp,#4 ;290
000274 f7fffffe BL _ZN9TextOuter10ShowSymbolEwb ;
000278 f3bf8f4f DSB ;290
00027c 4845 LDR r0,|L4.916|
00027e 6c02 LDR r2,[r0,#0x40] ;290
000280 6c41 LDR r1,[r0,#0x44] ;290
000282 428a CMP r2,r1 ;290
000284 d001 BEQ |L4.650|
000286 1c49 ADDS r1,r1,#1 ;290
000288 6441 STR r1,[r0,#0x44] ;290
|L4.650|
00028a 2201 MOVS r2,#1 ;293
00028c 2142 MOVS r1,#0x42 ;293
00028e a801 ADD r0,sp,#4 ;293
000290 f7fffffe BL _ZN9TextOuter10ShowSymbolEwb ;`
Как видно, оптимизатор не стал делать вызовы функций, а разместил всё линейно. И качество кода таково, что будь тут одна или две функции — разницы не будет. Как не будет и копирования в случае использования структур.
Пример использования кольцевого буфера
--------------------------------------
Собственно, пример прост. Рассмотрим его на примере буферизации данных, приходящих из COM-порта. В третьей части документа постараемся рассмотреть работу с COM-портом и его прерываниями более подробно. Объявляем буфер на 64 элемента (я интуитивно принял решение, что такой буфер точно не переполнится, если будут обрабатываться строки со средней длиной 30 символов).
```
#include
#include
...
Mcucpp::Containers::RingBufferPO2<64, uint8\_t, Mcucpp::Atomic> bufFromUart;
```
В обработчике прерываний помещаем данные в буфер:
```
bufFromUart.push_back (Buf[i]);
```
А в одной из задач, среди прочих вещей, выполняем какие-либо действия, например, такие:
```
while (!bufFromUart.empty())
{
char ch = bufFromUart.front();
bufFromUart.pop_front();
...
```
не опасаясь за то, что данные будут затёрты (само собой разумеется, размер очереди должен быть достаточным, чтобы она не переполнилась). Ну, и производим некие действия с полученным символом ch. Если очередь пуста, вход в указанный цикл просто не произойдёт.
Смешанный способ обработки прерываний
-------------------------------------
Чтобы вас не запутать, начнём с простой фразы: всё, что необходимо для начала работы с прерываниями, уже было описано. Всё остальное — уже высший пилотаж. Наверное, самое правильное — сначала освоить две крайности (медленно и удобно, а также быстро и не очень удобно), а затем — уже вернуться к чтению этой части раздела.
Существует смешанный способ обработки прерывания. Сначала переписывается обработчик, в его начале выполняются критически важные действия, а затем — из него активируется обычная высокоприоритетная задача. В частности, для случая измерения частоты — в этом обработчике может быть получено фактическое значение таймера в момент прихода прерывания от ножки, затем — таймер запущен на следующее измерение, после чего — проблема обработки полученного с таймера значения делегирована обычной задаче. Ну, и любые другие вещи. Если важна мгновенная реакция, а то, что переключение контекста займёт время — не критично, то можно использовать данный метод.
Итак, мы создали задачу, порождённую от TaskIrq, мы создали собственный обработчик прерывания, в нём мы выполнили критичные ко времени действия… Что дальше?
А дальше следует вызвать функцию **MaksIrqHandler ()**. Эта функция инициирует переключение контекста и передачу управления функции, связанной с прерыванием.
**Текстом**
```
extern "C" {
extern void MaksIrqHandler ();
void EXTI15_10_IRQHandler()
{
if (EXTI_GetITStatus(EXTI_Line13) != RESET) {
/* Clear interrupt flag - существенно, что в конце! */
EXTI_ClearITPendingBit(EXTI_Line13);
// переключение в задачу обработки прерывания
MaksIrqHandler ();
}
}
}
```
Виртуальные прерывания
----------------------
И, наконец, рассмотрим механизм, который не относится непосредственно к прерываниям, но связан с ними. Этот механизм просто предоставляет программисту дополнительные выразительные сведения, не являясь обязательным к использованию.
При создании задачи, классу-наследнику от **TaskIRQ** можно присвоить реально несуществующий номер прерывания. Он должен быть больше, чем значение **FIRST\_VIRT\_IRQ** (для архитектуры ARM это значение равно 0x100, но для других архитектур может оказаться иным).
Такая задача не связывается ни с одним реальным прерыванием и никогда не будет активирована ядром автоматически. Но программист всегда может вызвать функцию:
**void ProceedIrq(int irq\_num);**
после чего произойдёт активация задачи по всем принципам активации задачи, связанной с прерыванием. Зачем? Варианты возможны самые фантастические. Например, можно вызывать несколько разных задач-обработчиков из одного физического обработчика прерываний, если на одном векторе «висит» несколько устройств (как ни велик диапазон линий IRQ, а уже даже на нём разработчики контроллеров умудряются объединять вызовы). В целом, как объяснил один из разработчиков ОС: «Механизм достался даром, почему бы не воспользоваться?». Функция **ProceedIrq(**) в любом случае, необходима для внутренних нужд системы.
На этом, рассмотрение ядра можно считать начерно законченным. Впереди — драйверы, но про них — во втором томе руководства. | https://habr.com/ru/post/340032/ | null | ru | null |
# Пожалуй, лучшая архитектура для UI тестов
Наверное, где-то есть идеальная статья, сразу и полностью раскрывающая тему архитектуры тестов, легких и в написании, и в чтении, и в поддержке, и так, чтобы быть понятной начинающим, с примерами реализации и областей применения. Хочу предложить свое видение этой «идеальной статьи», в том формате, о котором мечтала, только получив первую задачу «напиши автотесты». Для этого расскажу о известных и не очень подходах к автотестам веба, зачем, как и когда их применять, а также про удачные решения хранения и создания данных.
Привет, Хабр! Меня зовут Диана, я руководитель группы тестирования пользовательских интерфейсов, автоматизирую веб и десктоп тесты уже пять лет. Примеры кода будут на java и для web, но, на практике проверено, подходы применимы и к питону с десктопом.
В начале было...
----------------
Вначале было слово, и слов было много, и заполняли они все страницы равномерно кодом, не обращая внимания на эти ваши архитектуры и принципы DRY (don’t repeat yourself — не надо повторять код, который вы уже написали три абзаца выше).
### Простыня
На самом деле, архитектура «портянки», она же «простыня», она же сваленный в кучу неструктурированный код, равномерно заполняющий экран, не так уж плоха и вполне применима в следующих ситуациях:
* Быстроклик в три строчки (ну ладно, в двести три) для очень маленьких проектов;
* Для примеров кода в мини-демо;
* Для первого кода в стиле «хелоу ворд» среди автотестов.
Что нужно сделать для получения архитектуры Простыни? просто записать весь нужный код в один файл, общим полотном.
```
import com.codeborne.selenide.Condition;
import com.codeborne.selenide.WebDriverRunner;
import org.testng.annotations.Test;
import static com.codeborne.selenide.Selenide.*;
public class RandomSheetTests {
@Test
void addUser() {
open("https://ui-app-for-autotest.herokuapp.com/");
$("#loginEmail").sendKeys("test@protei.ru");
$("#loginPassword").sendKeys("test");
$("#authButton").click();
$("#menuMain").shouldBe(Condition.appear);
$("#menuUsersOpener").hover();
$("#menuUserAdd").click();
$("#dataEmail").sendKeys("mail@mail.ru");
$("#dataPassword").sendKeys("testPassword");
$("#dataName").sendKeys("testUser");
$("#dataGender").selectOptionContainingText("Женский");
$("#dataSelect12").click();
$("#dataSelect21").click();
$("#dataSelect22").click();
$("#dataSend").click();
$(".uk-modal-body").shouldHave(Condition.text("Данные добавлены."));
WebDriverRunner.closeWebDriver();
}
}
```
*Если вы только начинаете знакомиться с автотестами, то «простыни» уже хватит для выполнения простого тестового задания, особенно если вы при этом покажете хорошие знания тест-дизайна и хорошее покрытие. Но это слишком просто для масштабных проектов, так что, если у вас есть амбиции, но нет времени идеально выполнять каждое тестовое, то хотя бы на вашем гите должен быть пример более сложной архитектуры.*
### PageObject
Слышали слухи, что PageObject устарел? Вы просто не умеете его готовить!
Основной рабочей единицей в этом паттерне является «страница», то есть законченный набор элементов и действий с ними, например, MenuPage — класс, описывающий все действия с меню, то есть клики по вкладкам, раскрытие выпадающих подпунктов и так далее.
Чуть сложнее составить PageObject для модального окошка (для краткости «модалки») создания объекта. Набор полей класса понятен: все поля ввода, чекбоксы, выпадающие списки; а для методов есть два варианта действий: можно сделать как универсальные методы «заполни все поля модалки», «заполни все поля модалки рандомными значениями», «проверь все поля модалки», так и отдельные методы «заполни название», «проверь название», «заполни описание» и так далее. Что использовать в конкретном случае определяется приоритетами — подход «один метод на всю модалку» увеличивает скорость написания теста, но по сравнению с подходом «по одному методу на каждое поле» сильно проигрывает в читаемости теста.
**Пример**
Составим общий Page Object создания пользователей для обоих видов тестов:
```
public class UsersPage {
@FindBy(how = How.ID, using = "dataEmail")
private SelenideElement email;
@FindBy(how = How.ID, using = "dataPassword")
private SelenideElement password;
@FindBy(how = How.ID, using = "dataName")
private SelenideElement name;
@FindBy(how = How.ID, using = "dataGender")
private SelenideElement gender;
@FindBy(how = How.ID, using = "dataSelect11")
private SelenideElement var11;
@FindBy(how = How.ID, using = "dataSelect12")
private SelenideElement var12;
@FindBy(how = How.ID, using = "dataSelect21")
private SelenideElement var21;
@FindBy(how = How.ID, using = "dataSelect22")
private SelenideElement var22;
@FindBy(how = How.ID, using = "dataSelect23")
private SelenideElement var23;
@FindBy(how = How.ID, using = "dataSend")
private SelenideElement save;
@Step("Complex add user")
public UsersPage complexAddUser(String userMail, String userPassword, String userName, String userGender,
boolean v11, boolean v12, boolean v21, boolean v22, boolean v23) {
email.sendKeys(userMail);
password.sendKeys(userPassword);
name.sendKeys(userName);
gender.selectOption(userGender);
set(var11, v11);
set(var12, v12);
set(var21, v21);
set(var22, v22);
set(var23, v23);
save.click();
return this;
}
@Step("Fill user Email")
public UsersPage sendKeysEmail(String text) {...}
@Step("Fill user Password")
public UsersPage sendKeysPassword(String text) {...}
@Step("Fill user Name")
public UsersPage sendKeysName(String text) {...}
@Step("Select user Gender")
public UsersPage selectGender(String text) {...}
@Step("Select user variant 1.1")
public UsersPage selectVar11(boolean flag) {...}
@Step("Select user variant 1.2")
public UsersPage selectVar12(boolean flag) {...}
@Step("Select user variant 2.1")
public UsersPage selectVar21(boolean flag) {...}
@Step("Select user variant 2.2")
public UsersPage selectVar22(boolean flag) {...}
@Step("Select user variant 2.3")
public UsersPage selectVar23(boolean flag) {...}
@Step("Click save")
public UsersPage clickSave() {...}
private void set(SelenideElement checkbox, boolean flag) {
if (flag) {
if (!checkbox.isSelected()) checkbox.click();
} else {
if (checkbox.isSelected()) checkbox.click();
}
}
}
```
А в классе тестов пользователей распишем тест с комплексными действиями:
```
@Test
void addUser() {
baseRouter.authPage()
.complexLogin("test@protei.ru", "test")
.complexOpenAddUser()
.complexAddUser("mail@test.ru", "pswrd", "TESTNAME", "Женский", true, false, true, true, true)
.checkAndCloseSuccessfulAlert();
}
```
И с подробными действиями:
```
@Test
void addUserWithoutComplex() {
//Arrange
baseRouter.authPage()
.complexLogin("test@protei.ru", "test");
//Act
baseRouter.mainPage()
.hoverUsersOpener()
.clickAddUserMenu();
baseRouter.usersPage()
.sendKeysEmail("mail@test.ru")
.sendKeysPassword("pswrd")
.sendKeysName("TESTNAME")
.selectGender("Женский")
.selectVar11(true)
.selectVar12(false)
.selectVar21(true)
.selectVar22(true)
.selectVar23(true)
.clickSave();
//Assert
baseRouter.usersPage()
.checkTextSavePopup("Данные добавлены.")
.closeSavePopup();
}
```
Второй тест очевиден и не требует закапывания в код глубже. Особенно это заметно на действии открытия страницы добавления пользователя: если сотрудник не знает, что для появления определенной ситуации на сайте нужно зайти на первую страницу, открыть третью вкладку, навести курсор на четвертую ссылку, подпрыгнуть и притопнуть — сокрытие реализации сильно усложнит ему жизнь. Однако подготовительные действия, например, авторизацию, вполне можно скрыть.
Суть в том, что внутри пейджей инкапсулируются (реализация скрыта, доступны только логические действия) все действия со страницами, таким образом, в тесте используются уже бизнес-функции. А это в свою очередь позволяет писать свои пейджи под каждую платформу (веб, десктоп, мобилки), не меняя при этом тесты.
Жаль только, что абсолютно одинаковые интерфейсы на разных платформах встречаются редко.
Для уменьшения расхождения между интерфейсами появляется соблазн усложнения отдельных шагов, их выносят в отдельные промежуточные классы, а тесты становятся все менее читаемыми, вплоть до двух шагов: «авторизоваться, сделать хорошо», тест закончен. Кроме веба в наших проектах дополнительных интерфейсов не было, а читать кейсы приходится чаще, чем писать, поэтому в угоду читаемости исторические PageObject приобрели новый вид.
*PageObject — классика, о которой знают все. По этому подходу можно найти множество статей с примерами почти на любом языке программирования. По использованию PageObject очень часто судят, знает ли кандидат что-то о тестировании пользовательских интерфейсов. Выполнение тестового задания с помощью этого подхода — это то, чего ждут большинство работодателей, и его очень много живет в продакшн-проектах, даже если тестят только веб.*
### А что еще бывает?
Как ни странно, не PageObject’ом единым!
* Часто встречается паттерн ScreenPlay, о котором можно почитать [например тут](https://habr.com/ru/company/arcadia/blog/434122/). У нас он не прижился, так как использовать bdd-подходы без вовлечения людей, не умеющих читать код — бессмысленное насилие над автоматизаторами.
* У js-фреймворков появляются свои собственные упрощающие жизнь подходы, помимо обязательного PageObject, но при их разнообразии говорить о чем-то устоявшемся и универсальном, мне кажется, слишком смело.
* Можно написать и что-то свое, например, фреймворк на основе ModelBaseTesting, о чем хорошо рассказали в докладе с гейзенбага [докладе с гейзенбага](https://www.youtube.com/watch?v=TeKHZw61pb8). Этот подход используется в первую очередь в проектах со сложносвязанными объектами, когда обычных тестов не хватает для проверки всех возможных комбинаций состояний и взаимодействий объектов.
А я вам расскажу подробнее про Page Element, позволяющий уменьшить количество однотипного кода, повысив при этом читаемость и обеспечив быстрое понимание тестов даже у тех, кто не знаком с проектом. А еще на нем (со своими блекджеками и преферансами, конечно!) построены популярные не-js фреймворки htmlElements, Atlas и епамовский JDI.
Что такое Page Element?
-----------------------
Для построения паттерна Page Element начнем с самого низкоуровневого элемента. Как говорит [Викисловарь](https://ru.wiktionary.org/wiki/%D0%B2%D0%B8%D0%B4%D0%B6%D0%B5%D1%82), «виджет» — программный примитив графического интерфейса пользователя, имеющий стандартный внешний вид и выполняющий стандартные действия. Например, самый простой виджет «Кнопка» — на него можно кликнуть, у него можно проверить текст и цвет. В «Поле ввода» можно ввести текст, проверить, какой текст введен, кликнуть, проверить отображение фокуса, проверить количество введенных символов, ввести текст и нажать «Enter», проверить placeholder, проверить подсветку «обязательности» поля и текст ошибки, и всё, что еще может понадобиться в конкретном случае. При этом все действия с этим полем стандартны на любой странице.
Бывают виджеты более сложные, для которых действия не так очевидны, например, древовидные оглавления. При их написании нужно отталкиваться от того, что с этой областью программы делает пользователь, например:
* Клик по элементу оглавления с заданным текстом,
* Проверка существования элемента с заданным текстом,
* Проверка отступа элемента с заданным текстом.
Виджеты могут быть двух видов: с локатором в конструкторе и с локатором, вшитым внутрь виджета, без возможности его изменить. Оглавление обычно одно на странице, у него способ поиска на странице можно оставить «внутри» действий с оглавлением, выносить его локатор отдельно нет смысла, так как извне локатор можно случайно испортить, а выгоды от его отдельного хранения нет. В свою очередь текстовое поле — вещь универсальная, с ним наоборот нужно работать *только* через локатор из конструктора, потому что полей ввода может быть много и сразу. Если появляется хотя бы один метод, предназначенный только для одного специального поля ввода, например с дополнительнм кликом по выпадающей подсказке, это уже не просто поле ввода, под него уже пора делать свой виджет.
Для уменьшения всеобщего хаоса виджеты, как элементы страницы, объединяются во все те же пейджи, откуда, видимо, и составлено название Page Element.
```
public class UsersPage {
public Table usersTable = new Table();
public InputLine email = new InputLine(By.id("dataEmail"));
public InputLine password = new InputLine(By.id("dataPassword"));
public InputLine name = new InputLine(By.id("dataName"));
public DropdownList gender = new DropdownList(By.id("dataGender"));
public Checkbox var11 = new Checkbox(By.id("dataSelect11"));
public Checkbox var12 = new Checkbox(By.id("dataSelect12"));
public Checkbox var21 = new Checkbox(By.id("dataSelect21"));
public Checkbox var22 = new Checkbox(By.id("dataSelect22"));
public Checkbox var23 = new Checkbox(By.id("dataSelect23"));
public Button save = new Button(By.id("dataSend"));
public ErrorPopup errorPopup = new ErrorPopup();
public ModalPopup savePopup = new ModalPopup();
}
```
Для использования всего выше созданного в тестах нужно последовательно обращаться к странице, виджету, действию, таким образом получаем следующую конструкцию:
```
@Test
public void authAsAdmin() {
baseRouter
.authPage().email.fill("test@protei.ru")
.authPage().password.fill("test")
.authPage().enter.click()
.mainPage().logoutButton.shouldExist();
}
```
Можно добавить классический слой степов, если есть необходимость для этого в вашем фреймворке (реализация remote библиотеки на Java для RobotFramework требует на вход класс степов, например), или если хочется добавить аннотаций для красивых отчетов. Мы это сделали генератором на основе аннотаций, если интересно, пишите в комментах, расскажем.
**Пример класса степов авторизации**
```
public class AuthSteps{
private BaseRouter baseRouter = new BaseRouter();
@Step("Sigh in as {mail}")
public BaseSteps login(String mail, String password) {
baseRouter
.authPage().email.fill(mail)
.authPage().password.fill(password)
.authPage().enter.click()
.mainPage().logoutButton.shouldExist();
return this;
}
@Step("Fill E-mail")
public AuthSteps fillEmail(String email) {
baseRouter.authPage().email.fill(email);
return this;
}
@Step("Fill password")
public AuthSteps fillPassword(String password) {
baseRouter.authPage().password.fill(password);
return this;
}
@Step("Click enter")
public AuthSteps clickEnter() {
baseRouter.authPage().enter.click();
return this;
}
@Step("Enter should exist")
public AuthSteps shouldExistEnter() {
baseRouter.authPage().enter.shouldExist();
return this;
}
@Step("Logout")
public AuthSteps logout() {
baseRouter.mainPage().logoutButton.click()
.authPage().enter.shouldExist();
return this;
}
}
public class BaseRouter {
// Класс для создания страниц, чтобы не дублировать этот код везде, где понадобится обращение к странице
public AuthPage authPage() {return page(AuthPage.class);}
public MainPage mainPage() {return page(MainPage.class);}
public UsersPage usersPage() {return page(UsersPage.class);}
public VariantsPage variantsPage() {return page(VariantsPage.class);}
}
```
Эти степы очень похожи на степы внутри пейджей, практически ничем не отличаются. Но выделение их в отдельные классы открывает простор для генерации кода, при этом, жесткая связь с соответствующей страницей не теряется. При этом, если в пейдже не прописывать степы, то смысл инкапсуляции исчезает, а если не добавлять класс степов в pageElement, то взаимодействие со страницей всё равно остается отделенным от бизнес-логики.
*Таким образом, для составления теста нужно описать простые действия с каждым элементом страницы, причем некоторые элементы вроде полей ввода универсальны и могут быть использованы в нескольких проектах практически без изменений. После этого для каждой страницы указывается набор полей с локаторами. И все, можно писать сам тест, который гарантированно окажется читаемым и воспроизводимым, ведь он состоит из прямых указаний «нажми тут, введи текст там». Проверили на десятке проектов — этот подход самый читаемый, причем не надо дублировать в каждом page object однотипный код для каждого поля, ведь все нужные действия указаны один раз в виджетах!*
Хранение данных
---------------
Неправильно говорить об архитектуре проекта, не затронув способы удобного оперирования тестовыми данными.
Самый простой способ — передавать данные прямо в тесте «как есть» или переменными. Этот способ подходит для архитектуры простыни, но в больших проектах начинается бардак.
Другой способ — хранение данных в качестве объектов, именно он для нас оказался лучшим, так как собирает в одно место все данные, относящиеся к одной сущности, убирая соблазн все перемешать и использовать что-то не то не там. Кроме того, у этого способа есть множество дополнительных улучшений, которые могут быть полезны на отдельных проектах.
Для каждой сущности создается описывающая ее модель, которая в самом простом случае содержит названия и типы полей, например вот модель пользователя:
```
public class User {
private Integer id;
private String mail;
private String name;
private String password;
private Gender gender;
private boolean check11;
private boolean check12;
private boolean check21;
private boolean check22;
private boolean check23;
public enum Gender {
MALE,
FEMALE;
public String getVisibleText() {
switch (this) {
case MALE:
return "Мужской";
case FEMALE:
return "Женский";
}
return "";
}
}
}
```
Лайфхак №1: если у вас rest-подобная архитектура клиент-серверного взаимодействия (между клиентом и сервером ходят json или xml объекты, а не кусочки нечитаемого кода), то можно загуглить json to <ваш язык> object, вероятно, нужный генератор уже есть.
Лайфхак №2: если ваши разработчики сервера пишут на том же объектно-ориентированном языке программирования, то можно использовать их модели.
Лайфхак №3: если вы джавист и компания позволяет использовать сторонние библиотеки, а вокруг нет нервных коллег, предсказывающих много боли еретикам, использующим дополнительные библиотеки вместо чистой и прекрасной Java, берите [ломбок](https://habr.com/ru/post/345520/)! Да, обычно IDE может сгенерировать геттеры, сеттеры, toString и билдеры. Но при сравнении наших ломбоковских моделек и разрабских без ломбока виден профит в сотни строк «пустого», не несущего бизнес-логики кода на каждый класс. При использовании ломбока не надо бить по рукам тех, кто перемешивает поля и геттеры сеттеры, класс читается легче, можно получить представление об объекте сразу, без пролистывания трех экранов.
Таким образом, у нас появляются каркасы объектов, на которые нужно натянуть тестовые данные. Данные можно хранить как final static переменные, например это может быть полезно для главного админа системы, из под которого создаются другие пользователи. Использовать лучше именно final, чтобы не было соблазна данные изменять в тестах, потому что тогда следующий тест вместо админа может получить «бесправного» пользователя, не говоря уже про параллельный запуск тестов.
```
public class Users {
public static final User admin = User.builder().mail("test@protei.ru").password("test").build();
}
```
Для получения данных, не влияющих на другие тесты, можно использовать [паттерн «прототип»](https://refactoring.guru/ru/design-patterns/prototype) и клонировать в каждом тесте свой инстанс. Мы решили сделать проще: написать метод-рандомилку полей класса, примерно вот так:
```
public static User getUserRandomData() {
User user = User.builder()
.mail(getRandomEmail())
.password(getShortLatinStr())
.name(getShortLatinStr())
.gender(getRandomFromEnum(User.Gender.class))
.check11(getRandomBool())
.check21(getRandomBool())
.check22(getRandomBool())
.check23(getRandomBool())
.build();
//business-logic: 11 xor 12 must be selected
if (!user.isCheck11()) user.setCheck12(true);
if (user.isCheck11()) user.setCheck12(false);
return user;
}
```
При этом методы, творящие непосредственный рандом, лучше вынести в отдельный класс, так как они будут использоваться и в других моделях:
В методе получения рандомного пользователя использовался [паттерн «строитель»](https://refactoring.guru/ru/design-patterns/builder), который нужен для того, чтобы не создавать новый вид конструктора под каждый необходимый набор полей. Вместо него, конечно, можно просто вызывать нужный конструктор.
Этот способ хранения данных использует паттерн Value Object, на его основе можно добавить любых своих хотелок, в зависимости от надобностей проекта. Можно добавить сохранение объектов в базу, и таким образом подготовить систему перед тестом. Можно не рандомить пользователей, а загружать их из файлов properties (и еще одна [классная библиотека](http://owner.aeonbits.org/docs/why/) ). Можно использовать везде одного и того же пользователя, но сделать так называемые Реестры данных (data registry) под каждый вид объектов, в котором к имени или другому уникальному полю объекта будет добавляться значение сквозного счетчика, и в тесте всегда будет свой уникальный testUser\_135.
Можно написать свое Хранилище объектов (гуглить object pool и flyweight), из которого запрашивать необходимые сущности в начале теста. Хранилище отдает один из своих уже готовых к работе объектов и отмечает его у себя занятым. В конце теста объект возвращается в хранилище, где его по необходимости чистят, отмечают свободным и отдают следующему тесту. Так делают, если операции создания объектов очень ресурсоемкие, а при таком подходе хранилище работает независимо от тестов и может заниматься подготовкой данных под следующие кейсы.
Создание данных
---------------
Для кейсов редактирования пользователя вам определенно понадобится созданный пользователь, которого вы будете редактировать, при этом, в общем-то, тесту редактирования не важно, откуда этот пользователь взялся. Есть несколько способов его создать:
* нажимать кнопки руками перед тестом,
* оставить данные от предыдущего теста,
* развернуть перед тестом из backup,
* создать кликами по кнопкам прямо в тесте,
* использовать API.
У всех этих способов есть минусы: если перед тестом надо что-то в системе вводить вручную, то это плохой тест, они потому и называются автотестами, что должны действовать максимально независимо от человеческих рук.
Использование результатов предыдущего теста нарушает принцип атомарности и не дает запускать тест отдельно, придется запускать всю пачку, а ui-тесты не такие уж и быстрые. Хорошим тоном считается писать тесты так, что каждый можно запустить в гордом одиночестве и без дополнительных танцев. Кроме того, бага в создании объекта, уронившая предыдущий тест, вовсе не гарантирует багу в редактировании, а в такой конструкции тест на редактирование упадет следом, и работает ли именно редактирование — не узнать.
Использовать backup (сохраненный образ базы данных) с нужными для теста данными уже более менее хороший подход, особенно если backup разворачиваются автоматически или если данные в базу кладут сами тесты. Однако почему в тесте используется конкретно этот объект не очевидно, также могут начатся проблемы пересечения данных при большом количестве тестов. Иногда backup перестают корректно работать из-за обновления архитектуры базы, например, если нужно запустить тесты на старой версии, а в backup уже есть новые поля. С этим можно бороться, организовав хранилище backup под каждую версию приложения. Иногда backup перестают быть валидными опять же из-за обновления архитектуры базы — регулярно появляются новые поля, поэтому backup нужно регулярно актуализировать. А еще внезапно может оказаться, что конкретно вот такой единственный пользователь-из-backup никогда не падает, а если бы пользователь был создан только что или имя ему задавали немножко рандомно, то нашли бы баг. Это называется «эффект пестицида», тест перестает ловить баги, потому что приложение «привыкло» к одинаковым данным и не падает, а отклонений в сторону нет.
Если пользователь создан в тесте через клики по тому же самому интерфейсу, то уменьшается пестицид и уходит неочевидность появления пользователя. Минусы аналогичны использованию результатов предыдущего теста: скорость так себе, а еще если будет баг в создании, даже самый маленький (особенно баг теста, например, поменяется локатор кнопки сохранения), то мы не узнаем, работает ли редактирование.
Наконец, еще один способ создания пользователя — через http-API из теста, то есть вместо кликов по кнопкам сразу отправить запрос на создание нужного пользователя. Таким образом уменьшен, насколько возможно, пестицид, очевидно, откуда взялся пользователь, а скорость создания сильно выше, чем при кликах по кнопкам. Минусы этого способа в том, что он не подходит для проектов без json или xml в протоколе обмена данными между клиентом и сервером (например если разработчики пишут используя gwt и не хотят писать дополнительный api для тестировщиков). Можно при использовании API потерять кусок логики, выполняемой админкой, и создать не валидную сущность. API может меняться, отчего тесты упадут, однако обычно об этом известно, да и изменения ради изменений никому не нужны, скорее всего это новая логика, которую все равно придется проверять. Также возможно, что и на уровне API будет бага, но от этого ни один способ кроме готовых backup не застрахован, поэтому подходы к созданию данных лучше комбинировать.
Добавим капельку API
--------------------
Среди способов подготовки данных нам больше всего подошли http-API для текущих нужд отдельного теста и разворачивание backup для дополнительных тестовых данных, которые в тестах не меняются, например, иконок для объектов, чтобы тесты этих объектов не падали при багах в загрузке иконок.
Для создания объектов через API в Java оказалось удобнее всего использовать библиотеку restAssured, хоть она предназначена не совсем для этого. Хочу поделиться парой найденных фишек, знаете еще — пишите!
Первая боль — авторизация в системе. Её способ нужно для каждого проекта подбирать отдельно, однако есть общее — авторизацию нужно выносить в спецификацию запроса, например:
```
public class ApiSettings {
private static String loginEndpoint="/login";
public static RequestSpecification testApi() {
RequestSpecBuilder tmp = new RequestSpecBuilder()
.setBaseUri(testConfig.getSiteUrl())
.setContentType(ContentType.JSON)
.setAccept(ContentType.JSON)
.addFilter(new BeautifulRest())
.log(LogDetail.ALL);
Map cookies = RestAssured.given().spec(tmp.build())
.body(admin)
.post(loginEndpoint).then().statusCode(200).extract().cookies();
return tmp.addCookies(cookies).build();
}
}
```
Можно добавить возможность сохранения Cookies конкретного пользователя, тогда количество запросов к серверу уменьшится. Второе возможное расширение этого метода — сохранять полученные Cookies для текущего теста, и подкидывать их драйверу браузера, пропуская шаг авторизации. Выигрыш — секунды, но если их умножить на количество тестов, можно неплохо ускориться!
Есть плюшечка для аллюра и красивых отчетов, обратите внимание на строку `.addFilter(new BeautifulRest())`:
**Класс BeautifulRest**
```
public class BeautifulRest extends AllureRestAssured {
public BeautifulRest() {}
public Response filter(FilterableRequestSpecification requestSpec, FilterableResponseSpecification responseSpec, FilterContext filterContext) {
AllureLifecycle lifecycle = Allure.getLifecycle();
lifecycle.startStep(UUID.randomUUID().toString(), (new StepResult()).setStatus(Status.PASSED).setName(String.format("%s: %s", requestSpec.getMethod(), requestSpec.getURI())));
Response response;
try {
response = super.filter(requestSpec, responseSpec, filterContext);
} finally {
lifecycle.stopStep();
}
return response;
}
}
```
Модели объектов отлично ложатся на restAssured, так как библиотека сама справляется с сериализацией и десериализаций моделей в json/xml (превращением из json/xml форматов в объект заданного класса).
```
@Step("create user")
public static User createUser(User user) {
String usersEndpoint = "/user";
return RestAssured.given().spec(ApiSettings.testApi())
.when()
.body(user)
.post(usersEndpoint)
.then().log().all()
.statusCode(200)
.body("state",containsString("OK"))
.extract().as(User.class);
}
```
Если рассмотреть подряд несколько степов создания объектов, можно заметить идентичность кода. Для уменьшения одинакового кода можно написать общий метод создания объектов.
```
public static Object create(String endpoint, Object model) {
return RestAssured.given().spec(ApiSettings.testApi())
.when()
.body(model)
.post(endpoint)
.then().log().all()
.statusCode(200)
.body("state",containsString("OK"))
.extract().as(model.getClass());
}
@Step("create user")
public static User createUser(User user) {
create(User.endpoint, user);
}
```
Еще раз про рутинные операции
-----------------------------
В рамках проверки редактирования объекта нам в целом не важно, как объект появился в системе — через api или из backup, или все-таки создан ui-тестом. Важные действия — найти объект, нажать у него иконку «редактировать», очистить поля и заполнить их новыми значениями, нажать «сохранить» и проверить, все ли новые значения правильно сохранились. Всю ненужную информацию, не относящуюся непосредственно к тесту, лучше убирать в отдельные методы, например, в класс степов.
```
@Test
void checkUserVars() {
//Arrange
User userForTest = getUserRandomData();
// Проверка корректности сохранения полей уже есть в другом тесте,
// этот тест проверяет отображение вариантов из-под залогинившегося юзера,
// поэтому не важно, как юзер создан
usersSteps.createUser(userForTest);
authSteps.login(userForTest);
//Act
mainMenuSteps
.clickVariantsMenu();
//Assert
variantsSteps
.checkAllVariantsArePresent(userForTest.getVars())
.checkVariantsCount(userForTest.getVarsCount());
//Cleanup
usersSteps.deleteUser(userForTest);
}
```
Важно не увлекаться, так как тест, состоящий только из «комплексных» действий, становится менее читаемым, его сложнее воспроизвести без копания по коду.
```
@Test
void authAsAdmin() {
authSteps.login(Users.admin);
// Это всё, просто авторизовались под админом. Все действия и проверки внутри.
// Не очень очевидно, не правда ли?
```
Если в сьюте появляются практически одинаковые тесты, у которых отличается только подготовка данных, (например, надо проверить, что все три разновидности «разноправных» пользователей могут совершить одни и те же действия, или есть разные виды управляющих объектов, для каждого из которых надо проверить создание одинаковых зависимых объектов, или нужно проверить фильтрацию по десяти видам статусов объектов), то все равно нельзя повторяющиеся части выносить в отдельный метод. Совсем нельзя, если читаемость вам важна!
Вместо этого нужно почитать про data-driven тесты, для Java+TestNG это будет примерно так:
```
@Test(dataProvider = "usersWithDifferentVars")
void checkUserDifferentVars(User userForTest) {
//Arrange
usersSteps.createUser(userForTest);
authSteps.login(userForTest);
//Act
mainMenuSteps
.clickVariantsMenu();
//Assert
variantsSteps
.checkAllVariantsArePresent(userForTest.getVars())
.checkVariantsCount(userForTest.getVarsCount());
}
// Метод возвращает пользователей с полным перебором трех булевых параметров.
// Предположим, это важное бизнес-требование.
@DataSupplier(name = "usersWithDifferentVars")
public Stream usersWithDifferentVars(){
return Stream.of(
getUserRandomData().setCheck21(false).setCheck22(false).setCheck23(false),
getUserRandomData().setCheck21(true).setCheck22(false).setCheck23(false),
getUserRandomData().setCheck21(false).setCheck22(true).setCheck23(false),
getUserRandomData().setCheck21(false).setCheck22(false).setCheck23(true),
getUserRandomData().setCheck21(true).setCheck22(true).setCheck23(false),
getUserRandomData().setCheck21(true).setCheck22(false).setCheck23(true),
getUserRandomData().setCheck21(false).setCheck22(true).setCheck23(true),
getUserRandomData().setCheck21(true).setCheck22(true).setCheck23(true)
);
}
```
Тут используется библиотека [Data Supplier](https://automated-testing.info/t/datasupplier-entity-driven-alternativa-testng-dataprovideru/14452/2), которая является надстройкой над TestNG Data Provider, позволяющей использовать типизированные коллекции вместо Object [] [], но суть та же. Таким образом мы получаем один тест, выполняемый столько раз, сколько входных данных он получает.
Выводы
------
Итак, для создания большого, но удобного проекта автотестов пользовательских интерфейсов нужно:
* Описать все мелкие виджеты, встречаемые в приложении,
* Собрать виджеты в страницы,
* Создать модели для всех видов сущностей,
* Добавить методы генерации всех видов сущностей на основе моделей,
* Подумать о подходящем методе создания дополнительных сущностей
* Опционально: сгенерировать или собрать вручную файлы степов,
* Писать тесты так, чтобы в секции основных действий конкретного теста не было сложносоставных действий, только очевидные операции с виджетами.
Готово, вы создали проект на основе PageElement с простыми методами хранения, генерации и подготовки данных. Теперь у вас есть легко поддерживаемая архитектура, управляемая и достаточно гибкая. В проекте легко ориентируется и опытный тестировщик, и начинающий джун, так как автотесты в формате действий пользователя максимально удобно читать и понимать.
Примеры кода из статьи в виде готового проекта [добавлены в гит](https://gitlab.com/Vedii/protei-ui-autotest-example). | https://habr.com/ru/post/523802/ | null | ru | null |
# OpenCart popup, модальные окна
*Статья нашего сотрудника из его личного блога.*
Разрабатывая модуль в админке мне понадобилось использовать **модальные окна OpenCart** для вывода определенной информации, а так же для показа формы. Мой опыт frontend на тот момент был *так себе*, однако коллега подсказал что в OpenCart используется jquery (2.1.1), а у этой библиотеки есть поддержка popup окон. Но не все так просто …
*Уточним: модальное окно == всплывающее окно == popup.*
Библиотека модальных окон
-------------------------
Кнопка при клике по которой показывается модальное окноДля того чтобы использовать **модальное окно OpenCart**, надо определить какая библиотека предоставляет для этого функционал, используемый в этом движке. Разбирая админку OpenCart 3.0 (в 2.3 такой кнопки нет), в разделе `Панель состояния` была найдена кнопка, при клике по которой показалось **всплывающее окно**.
То что нужно, начинаем разбор :)
Модальное окно в админке OpenCart Настройки разработчикаЗаходим на страницу "Панель состояния", открываем ее исходный код и смотрим в конце скрипт:
```
$('#button-setting').on('click', function() {
$.ajax({
url: 'index.php?route=common/developer&user_token=D9aTD65JQVdyOY9pcVxcRUx0M3eTefnr',
dataType: 'html',
beforeSend: function() {
$('#button-setting').button('loading');
},
complete: function() {
$('#button-setting').button('reset');
},
success: function(html) {
$('#modal-developer').remove();
$('body').prepend('' + html + '');
$('#modal-developer').modal('show');
},
error: function(xhr, ajaxOptions, thrownError) {
alert(thrownError + "\r\n" + xhr.statusText + "\r\n" + xhr.responseText);
}
});
});
```
Как видно, на кнопку с id `button-setting` вешается обработчик на клик, в котором ajax запрос, успешный результат которого показывается в **popup окне**. А для показа этого окна используется:
```
$('#modal-developer').modal('show');
```
Похоже на библиотеку [jquerymodal](https://jquerymodal.com/). Однако в bootstrap тоже есть [поддержка модальных окон](https://getbootstrap.com/docs/4.0/components/modal/). Пробуем выяснить через отладчик какая библиотека все-таки используется, ставим брекпоинт в вышеприведенном скрипте на методе `modal`.
Брекпоинт на методе modalНажимаем на кнопку (на первом скрине), попадаем на брекпоинт, шагаем внутрь и попадаем в `bootstrap.min.js`.
Стек привел в bootstrap.min.js***Всплывающие окна в OpenCart****реализуются через bootstrap.*
### Использование popup окон в OpenCart
Проинспектировав окно выясняем, что оно уже содержит нужную нам логику закрытия окна и состоит из двух важных для нас частей:
* `div` с классом `modal-header` в котором `h4`, который и есть заголовок окна
* `div` с классом `modal-body`¨C11Cвнутри содержит контент окна
Просмотр html кода модального окна Настройки разработчикаТак как окно уже имеет оформление, то просто возьмем его каркас, классы и на основе верстки этого окна составим свое:
```
×
####
```
Для показа окна с id `modal-window` будем использовать:
```
$('#modal-window').modal('show');
```
Теперь в нужном нам месте страницы в админке разместим свои вёрстку и js. Для этого используем [события в OpenCart](https://habr.com/ru/post/534772/). Например повесим обработчик на страницу редактирования заказа:
```
$this->model_extension_event->addEvent('modal_window', 'admin/view/sale/order_form/after', 'extension/module/modal_window/eventSaleOrderFormAfter');
```
Теперь обработчик:
```
public function eventSaleOrderFormAfter(&$route, &$args, &$output)
{
$idOrder = $args["order_id"];
$this->load->model('sale/order');
$this->load->model('catalog/product');
//загрузка списка продуктов заказа
$aOrderProducts = $this->model_sale_order->getOrderProducts($args["order_id"]);
//строка верстки списка товаров
$sOrderProducts = "";
//формируем список товаров
for($i=0; $imodel\_catalog\_product->getProduct($aOrderProducts[$i]["product\_id"]);
$sOrderProducts .= "- ".$aProduct["name"]." - ".$aProduct["model"]." (".$aOrderProducts[$i]["quantity"]." шт.): ".round($aOrderProducts[$i]["total"], 2)."р.
";
}
$sOrderProducts = "$sOrderProducts
";
//верстка модального окна и скрипт вызова
$sModal = '
×
#### Список товаров
'.$sOrderProducts.'
$("#modal\_window").modal("show");
';
//находим закрывающий тег body и перед ним вставляем модальное окно и скрипт его показа
$iPos = strripos($output, "");
$output = substr($output, 0, $iPos).$sModal.substr($output, $iPos);
}
```
Каждый раз при входе на страницу редактирования заказа будет появляться всплывающее окно со списком товаров.
Можно вставлять кнопку в панель кнопок в админке (или в любое другое место), повесить на кнопку обработчик клика и показывать модальное окно (как это сделано на странице `Панель состояния`). Однако для этого придется использовать [регулярные выражения](https://www.php.net/manual/ru/ref.pcre.php) или [парсер DOM](https://www.php.net/manual/ru/book.dom.php).
[Автор: Виталий Бутурлин](https://byurrer.ru/modalnyie-okna-opencart.html) | https://habr.com/ru/post/537122/ | null | ru | null |
# Большие бинари в моем Rust?
*Disclaimer: Эта статья является очень вольным переводом и некоторые мометы достаточно сильно отличаются от оригинала*
Бороздя просторы интернета вы наверняка уже успели услышать про Rust. После всех красноречивых отзывов и расхваливаний вы, конечно же, не смогли не потрогать это чудо. Первая программа выглядела не иначе как:
```
fn main() {
println!("Hello, world!");
}
```
Скомпилировав получим соответствующий исполняемый файл:
```
$ rustc hello.rs
$ du -h hello
632K hello
```
632 килобайт для простого принта?! Rust позиционируется как системный язык, который имеет потенциал для замены C/C++, верно? Так почему бы не проверить аналогичную программу на ближайшем конкуренте?
```
$ cat hello.c
#include
int main() {
printf("Hello, World!\n");
}
$ gcc hello.c -ohello
$ du -h hello
6.7K hello
```
Более безопасные и громоздкие iostream-ы C++ выдают не сильно иной результат:
```
$ cat hello.cpp
#include
int main() {
std::cout << "Hello, World!" << std::endl;
}
$ g++ hello.cpp -ohello
$ du -h hello
8.3K hello
```
> Флаги -O3/-Os практически не меняют конечного размера
>
>
Так что не так с Rust?
======================
Кажется, что необычный размер исполняемых файлов Rust интересует много кого, и вопрос этот совершенно не нов. Взять, к примеру, [этот](https://stackoverflow.com/questions/29008127/why-are-rust-executables-so-huge) вопрос на stackoverflow, или множество [других](https://is.gd/m3YfDN). Даже немного странно, что все еще не было статей или каких-либо заметок описывающих эту проблему.
> Все примеры были перетестированы на Rust 1.11.0-nightly (1ab87b65a 2016-07-02) на Linux 4.4.14 x86\_64 без использования cargo и stable-ветки в отличии от оригинальной статьи.
>
>
Уровень оптимизации
===================
Любой опытный программист конечно же воскликнет, что дебаг билд на то и дебаг, и нередко его размер значительно превышает релиз-версию. Rust в данном случае не исключение и [достаточно гибко](http://doc.crates.io/manifest.html#the-profile-sections) позволяет настраивать параметры сборки. Уровни оптимизации аналогичны gcc, задать его можно с помощью параметра -C opt-level=x, где вместо x число от *0*-*3*, либо *s* для минимизации размера. Ну что же, посмотрим что из этого выйдет:
```
$ rustc helloworld.rs -C opt-level=s
$ du -h helloworld
630K helloworld
```
Что удивительно каких-либо значительных изменений нет. На самом деле это происходит из-за того, что оптимизация применяется лишь к пользовательскому коду, а не к уже скомпонованной среде исполнения Rust.
Оптимизация линковки (LTO)
==========================
Rust по стандартному поведению к каждому исполняемому файлу линкует всю свою стандартную библиотеку. Так что мы можем избавиться и от этого, ведь глупый линковщик не понимает, что нам не очень нужно взаимодействие с сетью.
На самом деле есть хорошая причина для такого поведения. Как вы наверное знаете языки C и C++ компилируют каждый файл по отдельности. Rust же поступает немного иначе, где единицей компиляции выступает [крейт](http://doc.crates.io/index.html) (crate). Не трудно догадаться, что вызов функций из других файлов компилятор не сможет оптимизировать, так как он попросту работает с одним большим файлом.
Изначально в C/C++ компилятор производил оптимизацию независимо каждого файла. Со временем появилась технология оптимизации при линковке. Хоть это и стало занимать значительно больше времени, зато в результате получались исполняемые файлы куда лучше, чем раньше. Посмотрим как изменит положение дел эта функциональность в Rust:
```
$ rustc helloworld.rs -C opt-level=s -C lto
$ du -h helloworld
604K helloworld
```
Так что же внутри?
==================
Первое, чем наверное стоит воспользоваться — это небезызвестная утилита strings из набора [GNU Binutils](https://www.gnu.org/software/binutils/). Вывод ее достаточно большой (порядка 6 тыс. строк), так что приводить его полностью не имеет смысла. Вот самое интересное:
```
$ strings helloworld
capacity overflow
attempted to calculate the remainder with a divisor of zero
: Error in atexit()
: Error in pthread\_atfork()
DW\_AT\_member
DW\_AT\_explicit
\_ZN4core3fmt5Write9write\_fmt17ha0cd161a5f40c4adE # или core::fmt::Write::write\_fmt::ha0cd161a5f40c4ad
\_ZN4core6result13unwrap\_failed17h072f7cd97aa67a9cE # или core::result::unwrap\_failed::h072f7cd97aa67a9c
```
На основе этого результата можно сделать несколько выводов:
— К исполняемым файлам Rust статически линкуется вся стандартная библиотека.
— Rust использует [jemalloc](http://www.canonware.com/jemalloc/) вместо системного аллокатора
— К файлам также статически линкуется библиотека libbacktrace, которая нужна для трассировки стека
Все это, как вы понимаете, для обычного println не очень то и нужно. Значит самое время от них всех избавиться!
Отладочные символы и libbacktrace
=================================
Начнем с простого — убрать из исполняемого файла отладочные символы.
```
$ strip hello
# du -h hello
356K helloworld
```
Очень неплохой результат, почти половину исходного размера занимают отладочные символы. Хотя в этом случае удобочитаемого вывода при ошибках, вроде panic! нам не получить:
```
$ cat helloworld.rs
fn main() {
panic!("Hello, world!");
}
$ rustc helloworld.rs && RUST_BACKTRACE=1 ./helloworld
thread 'main' panicked at 'Hello, world!', helloworld.rs:2
stack backtrace:
1: 0x556536e40e7f - std::sys::backtrace::tracing::imp::write::h6528da8103c51ab9
2: 0x556536e4327b - std::panicking::default_hook::_$u7b$$u7b$closure$u7d$$u7d$::hbe741a5cc3c49508
3: 0x556536e42eff - std::panicking::default_hook::he0146e6a74621cb4
4: 0x556536e3d73e - std::panicking::rust_panic_with_hook::h983af77c1a2e581b
5: 0x556536e3c433 - std::panicking::begin_panic::h0bf39f6d43ab9349
6: 0x556536e3c3a9 - helloworld::main::h6d97ffaba163087d
7: 0x556536e42b38 - std::panicking::try::call::h852b0d5f2eec25e4
8: 0x556536e4aadb - __rust_try
9: 0x556536e4aa7e - __rust_maybe_catch_panic
10: 0x556536e425de - std::rt::lang_start::hfe4efe1fc39e4a30
11: 0x556536e3c599 - main
12: 0x7f490342b740 - __libc_start_main
13: 0x556536e3c268 - _start
14: 0x0 -
$ strip helloworld && RUST\_BACKTRACE=1 ./helloworld
thread 'main' panicked at 'Hello, world!', helloworld.rs:2
stack backtrace:
1: 0x55ae4686ae7f -
...
11: 0x55ae46866599 -
12: 0x7f70a7cd9740 - \_\_libc\_start\_main
13: 0x55ae46866268 -
14: 0x0 -
```
Вытащить целиком *libbacktrace* из линковки без последствий не получится, он сильно связан со стандартной библиотекой. Но зато размотка для паники из *libunwind* нам не нужна, и мы можем ее выкинуть. Незначительные улучшения мы все таки получим:
```
$ rustc helloworld.rs -C lto -C panic=abort -C opt-level=s
$ du -h helloworld
592K helloworld
```
Убираем jemalloc
================
Компилятор Rust стандартной сборки чаще всего [использует](http://rurust.github.io/rust_book_ru/src/custom-allocators.html) jemalloc, вместо системного аллокатора. Изменить это поведение очень просто: нужно всего лишь вставить макро и импортировать нужный крейт аллокатора.
```
#![feature(alloc_system)]
extern crate alloc_system;
fn main() {
println!("Hello, world!");
}
```
```
$ rustc helloworld.rs && du -h helloworld
235K helloworld
$ strip helloworld && du -h helloworld
133K helloworld
```
Небольшой вывод
===============
Завершающим штрихом в нашем шаманстве могло быть удаление из исполняемого файла всей стандартной библиотеки. В большинстве случаев это не нужно, да и к тому же в [офф.книге](https://doc.rust-lang.org/book/no-stdlib.html) (или в [переводе](http://rurust.github.io/rust_book_ru/src/no-stdlib.html)) все шаги подробно описаны. Этим способом можно получить файл размером, сопоставимым с аналогом на Си.
Стоит также отметить, что размер стандартного набора библиотек постоянен и сами линковочные файлы(перечисленные в статье) не увеличиваются в зависимости от вашего кода, а значит вам скорее всего не придется беспокоится о размерах. На крайний случай вы всегда можете использовать упаковщики кода вроде upx
*Большое спасибо русскоязычному [комьюнити](https://rustycrate.ru/) Rust за помощь с переводом* | https://habr.com/ru/post/305246/ | null | ru | null |
# Контроль сложности и архитектура UDF
Сложность — главный враг разработчика. Есть такая гипотеза, хотя я бы отнес ее к аксиомам, что сложность любого программного продукта с течением времени, в процессе добавления нового функционала неизбежно растет. Растет она пока не достигнет порога при котором любое вносимое изменение гарантированно, т.е. с вероятностью близкой к 100%, внесет ошибку. Есть также дополнение к этой гипотезе — если такой проект продолжать и далее поддерживать, то рано или поздно он достигнет такого уровня сложности, что нужное изменение внести будет невозможно вообще. Невозможно будет придумать решение, не содержащее в себе какие либо костыли, заведомые антипаттерны.
#### Источник сложности
Сложность неизбежно привносится входными требованиями, избежать такого вида сложности невозможно. К примеру, в какой либо бухгалтерской программе у вас есть задача совершить выплаты человеку, и среди расчета этих выплат есть такое требование, что человеку проработавшему в компании больше какого то срока начисляется дополнительная сумма за стаж. Код приложения неизбежно будет содержать что то подобное:
```
if(qualifiedForExtraPayment(employee)) {
calculateThatExtraPayment(...)
}
```
Этот if и есть элемент сложности, внесенный в приложение бизнес-требованием.
Но есть и сложность, которая требованиями не определяется, и вносится непосредственно разработчиком. Больше всего эта «искуственная» сложность исходит от некоторой особенности понимания разработчиками принципа [DRY](https://ru.wikipedia.org/wiki/Don%E2%80%99t_repeat_yourself).
К примеру, в уже упомянутой гипотетической бухгалтерской программе нужно сделать две почти одинаковые страницы, на обоих нужно посчитать выплаты человеку, и показать детальную информацию по этим выплатам. Но одна страница чисто информационная, чтобы посмотреть сколько человек получит денег, а вторая страница уже исполнительная, где присутствует третие действие — совершить собственно денежный перевод.
Пример конечно вымышленный, но с подобными вещами в коде других разработчиков сталкиваюсь регулярно.
Как это нужно решать.
На первой странице псевдокод будет такой
```
const payment = calculatePayment(employee);
displayPayment(payment);
```
На второй странице
```
const payment = calculatePayment(employee);
displayPayment(payment);
proceedWithPayment(payment);
```
Как это иногда решают.
Вместо того, чтобы создать второй метод, в первый вводят дополнительный параметр
```
const payment = calculatePayment(employee);
displayPayment(payment);
if(isOnlyInformation) {
return;
}
proceedWithPayment(payment);
```
И вот мы видим еще один if, еще один элемент сложности в нашем приложении. Этот пункт сложности не исходит от требований, а исходит от способа решения задачи разработчиком.
Там где код уже достаточно декомпозирован, получается что два метода «склеились» в один из-за того, что в них совпали всего две строчки. Но изначально, на этапе когда код сначала пишется «в лоб», имплементация этих методов (calculatePayment и displayPayment) может быть еще не вынесена в отдельные методы, а написана прямо в теле этого, и картина выглядит так, что в двух методах совпадают, скажем, 100 первых строчек. В таком случае вот такое вот «избавление от дублирования кода», может даже показаться хорошим решением. Но это, очевидно, не так. В прошлой своей статье, про [сухой антипаттерн](https://habrahabr.ru/post/275939/) я уже приводил примеры, как использование принципа DRY несет в ваше приложение сложность, которую можно избежать. Со способами, как написать тот же код, но без использования оного паттерна, без внесения в приложение сложности, которая не исходит от требований.
Таким образом мы приходим к тому, что в руках одного разработчика сложность приложения растет линейно, пропорционально сложности требований, ну или по крайней мере стремится к этому, в руках другого разработчика сложность растет экспоненциально.
#### Принцип единственной ответственности
«Равномерно распределенная» сложность не так уж и вредна и опасна при всей своей неизбежности, но она становится страшным сном разработчика, когда концентрируется в одном месте. Если у вас в функции есть if, то у вас добавляется вторая ветка, если их два, причем не важно вложен он или нет, то будет как минимум 4 возможных варианта прохода через метод, третий if сделает 8. И если у вас есть две отделенные, успешно декомпозированные, не влияющие друг на друга функции, в каждой из которых 4 ветви исполнения, то на каждую из них потенциально нужно написать по четыре теста, итого 8. Если же декомпозировать не удалось, и вся эта логика в одном методе, то тестов нужно написать 4\*4 => 16, причем каждый такой тест будет более сложным чем тест из первых восьми. Количество и сложность тестов как раз таки и отражают итоговую сложность приложения, которая при том же количестве элементов сложности, будет отличаться более чем вдвое.
На борьбу с таким нагромождением сложности направлен широко извесный принцип проектирования кода, далее называемый SRP, первый пункт сборника принципов SOLID. И если остальные буквы этой аббревиатуры содержат правила по большей части относятся к объектно-ориентированному программированию, то SRP — универсален, и применим не только к любой парадигме программированию, но и к архитектурным решениям, да что там говорить, и к другим инженерным областям тоже. Принцип, к сожалению, содержит в себе некоторую недосказанность, не всегда понятно, а как определить вот сейчас единственная ответственность у чего либо или нет. К примеру вот god-class в миллион строк, но он имеет единственную ответственность — управляет спутником. Он же больше ничего не делает, все значит в порядке? Очевидно — нет. Принцип можно несколько перефразировать — если у некоего элемента вашего кода, а это может быть как функция, класс, так и целый слой вашего приложения, слишком много ответственности, значит нужно проводить декомпозицию, разбивать на части. А то что ее слишком много, можно определить как раз по таким признакам — если тест на это слишком сложен, содержит много шагов, либо если тестов нужно много, значит и ответственности слишком много, и нужно декомпозировать. Иногда это можно определить даже не смотря в код. По т.н. code-smell, если я захожу в файл с одним классом и вижу там 800 строк кода — мне не нужно даже читать этот код, чтобы видеть, что этот класс несет слишком много ответственности. Если в файле целая страница зависимостей (импортов, юзингов и т.п.) мне не нужно скролить вниз и начинать читать этот код, чтобы придти к такому же выводу. Есть конечно разные уловки, IDE потакают гражданам кодерам, схлопывая импорты «под плюсик», есть уловки самих г. кодеров, которые ставят широкоформатный монитор вертикально. Повторюсь, мне даже не нужно читать код такого разработчика, чтобы понять, что он мне скорее всего не понравится.
Но декомпозиция не обязана достигать абсолюта, «другой конец этой палки» — миллион методов каждый с одним операндом может быть и не лучше чем один метод с миллионом операндов. Опять же при чрезмерной декомпозиции неизбежно встанет первая из тех двух шутливых «самых сложных задач в программировании» — именования функций и инвалидации кеша. Но прежде чем дойти до такого, среднестатистическому разработчику надо сначала научиться хотя бы минимально его декомпозировать, хотя бы чуть отойти от того конца, с классом в 800 строк.
Кстати, есть еще одна такая шутливо-философская мысль — класс, как концепция, несет в себе слишком много ответственности — поведение и состояние. Ее можно разбить на две сущности — функции для поведения и «plain» объекты (POJO, POCO и т.п., либо структуры в С) для состояния. Отсюда — парадигма ООП несостоятельна. Живите с этим.
#### Архитектура, как борьба со сложностью
Как я уже сказал, сложность, как и умножение сложности, не специфичны для программирования, они существуют во всех аспектах жизни. И решение этой проблемы было предложено еще Цезарем — разделяй и властвуй. Две проблемы сцепленные друг с другом победить сложнее чем обе эти проблемы отдельно одну за другой, также как и сложнее победить два варварских племени, объединенных для борьбы с римлянами. Если же их как то отделить друг от друга, то по отдельности победить одно племя, потом другое значительно легче. На низком уровне, при написании уже конкретного кода этому служит декомпозиция и SRP. На высоком же уровне, на уровне проектирования приложения этому служат архитектурные решения.
Отсюда и далее я концентрируюсь на UI/frontend специфике.
Для разработки приложений, содержащих в себе UI, уже давно применяются такие архитектурные решения, как MVC, MVP, MVVM. У всех этих решений есть две общие черты, первая — М, «модель». Они даже ей дают какое то определение, я обойдусь здесь таким упрощением — вся остальная программа. Вторая — V, «представление» или view. Это слой, отделенный от всего остального приложения, единственная ответственность которого это визуальное представление данных, исходящих от модели. Различаются эти архитектуры способом связи M и V между собой. Рассматривать их я, конечно, не буду, обращу лишь внимание еще раз, что все силы, потраченные на разработку этих архитектур, были напрвлены на отделение одной проблемы от другой, и, как нетрудно догадаться, на уменьшение сложности приложения.
И, говоря, что визуальное представление — единственная ответственность этого слоя, я как раз имею ввиду основополагающий принцип этих архитектур — в слое представления не долно быть логики. Совсем. Именно ради этого эти архитектуры задуманы. И если говорить об архитектуре MVC, то там еще был такой термин «тонкий контроллер». Попользовавшись этой архитектурой, люди пришли к выводу, что и контроллер логики содержать не должен. Совсем. Ибо логика это будет уже вторая ответственность этого слоя, а стремиться нужно к тому, чтобы она была одна.
Архитектура Unidirectional Data Flow
------------------------------------
#### Мотивация
Цель этой архитектуры, как и цель ранее упомянутых архитектур ровно та же — уменьшение сложности приложения, посредством разделения проблем между собой, и возведения между ними логического барьера. Преимущество этой архитектуры, почему ее нужно предпочесть другим архитектурам в следующем. Приложения не ограничиваются одним «view» и одной «моделью», в любом приложении у вас их будет несколько. И какая то связь между ними должна быть. В качестве примера возьму следующее — нужно подсчитать какую либо сумму по таблице. В один view человек вводит в таблице данные, на эти данные подписывается другая модель, подсчитывает сумму, сообщает своему view что надо обновиться. Далее пример расширяем тем, что потом на эту сумму подписана третяя модель, в которой нужно сделать кнопку «Применить» активной. Причем иногда у разработчика может возникнуть заблуждение, что вот это вот последнее действие — ответственность именно представления, и мы можем видеть в разметке что то такое: .
Это уже ошибка, сравнение двух чисел это уже логика, которой должна заведовать строго модель, разметка должна оперировать строго посчитанными для нее флагами —
.
В особо запущенных случаях именно в view пишется эта связь между двумя моделями, проверяются данные из чужой модели, и вызывается метод, несущий побочные эффекты в своей модели. В любом случае, между моделями появляется этакий граф распространения изменений.
Рано или поздно этот граф становится неконтролируемым и, внося изменения, разработчику непросто отследить, какие последствия это понесет в side-effect-ах, происходящих ниже по графу. В презентации от фейсбука это назвали downstream effects, это не термин. Также, другой разработчик пытаясь починить ошибку возникшую ниже по графу, будет иметь сложности в том чтобы отследить root-cause этой проблемы, лежащий на один, а то и несколько шагов выше по этому графу. Местами этот граф может и зацикливаться, и условие выхода из этого цикла может быть сломано безобидным изменением совершенно в другой точке графа, как результат — ваше приложение повисает и вы не можете понять почему. Нетрудно увидеть, что граф распространения изменений не исходит от требований заказчика. Они лишь диктуют последовательные действия, которые надо совершить, а то, что эти действия разбросаны по коду как {подставьте нужный эпитет}, и между ними вставлены подписки, броски событий и т.п. это уже на совести разработчика.
Еще немного об этом можно почитать в [мотивации Redux](https://redux.js.org/introduction/motivation).
Архитектура же UDF представляет из себя конвейер, на который наложено два принципиальных ограничения 1) следующий этап конвейера не имеет права влиять на предыдущий, или на результаты его исполнения. 2) «Зацикливание» конвейера может произвести только ввод от пользователя. Отсюда и название архитектуры — самостоятельно приложение двигает данные лишь в одном направлении, в сторону пользователя, и лишь внешнее влияние может пойти в направлении обратном этому основному потоку.
Основных этапов в конвейере два, первый ответственен за состояние, второй за отображение. В чем то это похоже на модель и представление в вышеупомянутых архитектурах, отличие так же как и между теми архитектурами — во взаимодействии модели с представлением. И дополнительно к этому во взаимодействии моделей между собой. Всё состояние приложения концентрируется в некотором сторе, и при возникновении некоторого внешнего события, например ввода пользователя, все изменение состояния от точки А (до внешнего раздражителя) к точке B (после раздражителя) должно произойти в одно действие. То есть в том же вышеприведенном сценарии код будет выглядеть примерно так, на примере редюсера в redux:
```
function userInputHappened(prev, input) {
const table = updateRow(prev.table, input);
const total = calculateTotal(prev.total, table);
const canProceed = determineCanProceed(prev.canProceed, total);
return {
...prev,
table,
total,
canProceed
};
}
```
Тут проиллюстрирован ключевой принцип, главное отличие от привычного конструирования логики. Нет никаких подписок одного на другое, никаких брошенных event-ов между двумя последовательными операциями. Все действия, которые нужно выполнить на данный внешний раздражитель, должны быть написаны последовательно. И при внесении изменений в такой код все последствия изменений обозримы. И, как результат, эта искуственно вносимая сложность минимизирована.
#### Redux
Изначально архитектура UDF на фронтенде была предложена компанией Facebook в рамках связки двух библиотек react и flux, чуть позже на смену flux пришел redux, предлагая пару очень важных изменений. Первое — контроль состояния теперь предполагается писать чистым кодом, по сути все наше управление состоянием теперь можно описать одной простой формулой
Следующее состояние равно чистой функции от предыдущего состояния и некоторого раздражителя.
Второе — слой представления теперь представляет собой еще одну чистую функцию
То есть задача всех UI компонентов — получить на вход объект, выдать результатом разметку.
Таким образом достигаются следующее:
1. «нечистый», асинхронный код сдвигается от приложения к его краю, два больших, даже можно сказать определяющих блока вашего приложения становятся чистыми.
2. Очень крутые дебажные инструменты. Первый — hot reload, позволяет без потери состояния заменить чистую функцию render на лету, то есть вы можете «нагорячую» править UI слой и сразу видеть результат. не перезагружая каждый раз приложение, и также без необходимости «докликать» до точки воспроизведения бага. Второй инструмент — time travel, позволяет запомнить все ваши состояния от State(1) до State(n), и ходить по ним вперед назад, просматривая последовательно что где могло пойти не так. Дополнительно есть возможность воспроизвести баг на одном ПК, экспортировать таймлайн, и загрузить его на другом ПК, то есть передать баг от тестировщика к разработчику даже без описания шагов воспроизведения этого бага. Но этот второй инструмент накладывает еще одно требование — state и action-ы вышего приложения должны быть сериализуемы. Т.е. нельзя использовать даже такие базовые классы как Map или DateTime. Только POJO. Кроме того, в редюсерах нельзя полагаться на ссылочное равенство объектов, сравнивать нужно по значению, например по id.
3. переиспользование — задайте себе вопросы — сталкивались вы со случаем, когда какой то UI компонент сам лезет в модель, получает сам себе данные, сам их обрабатывает и отображает?
Случалось ли такое, что приходит новая задача использовать этот же UI, но с другим источником данных, либо в другом сценарии, с другим набором действий? Порой переиспользовать ту же разметку в другом сценарии просто нереально.
Совсем другое дело переиспользовать кусок UI, который принимает объект и выдает результатом разметку. Даже если у вас другая конструкция данных в нужном месте, вы ее конвертируете в то, что принимает этот компонент, вставляете его к себе и даете ему этот объект. Как результат, вы полностью уверены, что он порендерит то что вам нужно и это не понесет абсолютно никаких побочных эффектов.
Тоже самое с управлением состояния. У вас есть функция, которая обновляет строчку в таблице. Допустим она делает внутри себя что-то еще, нормализует таблицу каким либо образом, сортирует ее и т.п. Что стоит вызвать чистую функцию из другого сценария? Вы опять уверены, что никаких побочных эффектов это не понесет.
Переиспользовать же сценарий целиком становится нельзя. В силу того, что есть полный decoupling состояния представления. И точки входа для такого переиспользования придется продублировать, но основное «мясо» в таких точках входах может и должно быть переиспользовано.
К сожалению нет добра и без худа, Redux потерял одно важное ограничение. Как я уже говорил, «зацикливание», может быть инициировано только пользователем, и в FLUX было реализовано такое ограничение — в обработчике подписки на изменение состояния нельзя бросать новый Action, стор на это бросает исключение. Тоесть UI компонент, подписанный на стор, в обработчике этой подписки не имеет права сделать дополнительное изменение в состоянии. Только рендер, только хардкор. В redux это исключение убрали.
#### Пример некорректного использования Redux и UDF
В одном из наших приложений обнаружилось нарушение много чего, вплоть до здравого смысла.
1) Логика находится непосредственно в UI компонентах, UI компонент решает сам какие данные ему загрузить
2) UI компоненты наследуются друг от друга (sick!) и еще от каких то классов.
3) UI компоненты имеют название \*Adapter (что дальше, \*Injector, \*Factory?)
4) UI компонент «знает», где в дереве состояния лежат «свои» данные и данные других компонентов
5) UI компоненты самостоятельно подписываются на часть состояния, результатом обработки бросают новые Action, для изменения «своего» состояния, зацикливая архитектуру в которой заведомо этих зацикливаний быть не должно
Мотивацией этого дизайна было желание сделать единственную точку переиспользования. Причем эта точка, естественно, в UI слое, прямо в разметке. Звучит это примерно так — я вставляю UI компонент, автоматически подцепляется (да именно такие слова я все время слышу из соседних кубиков, подцепляется, инжектится, подписывается, пробрасывается, code-smell ощущается уже дистанционно, на слух) его состояние, компонент подписывается на стейт соседних компонентов, которые для него производят входные данные, данные от которых он зависит, сам получает данные с бакенда как для первоначальной так и ленивой загрузки. И когда в этом компоненте, использованном в трех приложениях, вдруг меняется метод api, либо нужно в этот компонент дорисовать новую логику, то мы допишем это в компонент, и это соответственно применяется сразу в трех местах.
Что при этом делать, если в одном из трех мест другой источник данных, либо другая логика обработки где то в середине этого компонента — этого такое архитектурное решение не подсказывает. Как говорится — ну сделай что нибудь, тыжпрограммист. Очевидно нужно залезть вовнутрь, написать новую логику, и воткнуть if, который включит ее для 3го сценария и выключит для первых двух.
Граф распространения изменений в этом приложении выглядит вот так:
Получилось так, что люди использовали в своем приложении redux, получили его отрицательные стороны, в частности «шумный» синтаксис, который на любой чих предполагает изменение в 4х файлах, но не получили плюсов которые он несет.
Если попытаться изобразить граф распространения изменений, то нетрудно увидеть, что он очень похож на граф, который был использован как [антипример](https://www.youtube.com/watch?v=nYkdrAPrdcw&feature=youtu.be&t=656) в презентации Facebook.
Итого:
1) Нарушена архитектура UDF, а redux предполагается для реализации именно ее, а не как fancy pub-sub.
2) Жесткий coupling разметки с состоянием
3) Нарушен принцип SRP — логика в слое представления
4) Нарушен здравый смысл — именование/предназначение компонентов слоя представления.
#### Сравнение с реактивным программированием
Есть еще одна концепция, годная для создания UI приложений, которая также «лучше чем обычный порошок». И за нее, а также за фреймворки ее реализующие, есть немало агитаторов.
Она предполагает такое взаимодествие между моделями, при которых когда вы меняете какую то сущность, вам не надо заботиться о зависимых сущностях, они сами обнаружат, что она изменилась и пересчитают себя.
Псеводокод буду писать на примере фреймворка knockoutJS.
У нас есть tableVm, в ней есть поле table, и функция, которая эту таблицу позволяет обновлять
```
tableVm.table = ko.observable(someInitialData);
tableVm.updateTable = function(input) {
const current = tableVm.table();
const updated = ... // some code here
tableVm.table(updated);
}
```
Далее есть код в другой(иногда в той же) View-Model-и
```
tableTotalVm.total = ko.computed(() => tableVm.table().map(...).sum());
```
В третьей VM следующий код
```
submitVm.canProceed = ko.computed(() => tableTotalVm.total() === 100);
```
Нетрудно увидеть что мы, что называется — «back to square one», пришли к тому, от чего UDF сознательно уходила — один кусочек кода подписан на другой, второй подписан на третий и т.д. Рано или поздно приходим к большому и неконтролируемому графу распространения изменений.
Кроме того предполагается и обратное распространение изменений.
Тут приведу более простой пример, где на нижнем уровне хранится индекс начинающийся с нуля, а на UI нужно отобразить в индекс от единицы, то есть нужно его конвертировать в одну сторону, когда же на UI что то меняется, то на нижний уровень нужно конвертировать соответственно обратно.
```
lowerVm.index = ko.observable(indexLoadedFromApi);
upperVm.index = ko.computed(
() => lowerVm.index() + 1),
(newVal) => lowerVm.index(newVal - 1)
);
```
И когда UI меняет верхнее значение в такой системе, computed продвигает это изменение в нижнюю модель. Т.к. изменилась нижняя модель, то нужно опять пересчитать верхнюю модель, и соответсвенно обновить UI. Тут еще может возникнуть такая ситуация — когда сверху вы положили одно значение, а из этой круговерти обновлений пересчиталось другое, из-за ошибки в коде, либо из-за нечеткой логики. В таком случае во фреймворке circular dependency detection механизм может некорректно отработать и вы либо «зависнете», либо получите исключение в совершенно непонятном месте, с ничего не говорящим сообщением об ошибке, а то и вовсе stack overflow.
Да и сам факт наличия подобного механизма как бы сообщает, что есть опасность создать зацикленные зависимости. А еще иногда циклические зависимости диктуются бизнес требованиями. Представьте себе игру вроде Civilization где три ползунка, наука, культура и производство, сумма их всегда должна быть 100%, вы крутите один вверх, другие два автоматически пропорционально едут вниз. Попробуйте реализовать что-то такое с помощью трех computed. Ну или, например симулятор жизни. Окажется, что это будет не тысяча computed зависящих друг от друга, а один observable, в котором будет вся модель всего приложения. И возникает вопрос, а нужен ли нам этот один observable в приложении.
[Вот здесь](https://habrahabr.ru/post/330466/) есть мнение автора, который выступает за реактивное программирование, не совсем такое, как в knockout, но есть подозрение, что симптоматика там ровно те же. И еще автор радостно выставляет UDF «в плохом свете», со смайликами. Что очень наглядно показывает что иногда даже люди считающие себя экспертами в написании UI приложений, вероятно даже заслуженно считающие, эту архитектуру совершенно не понимают. Она и правда непроста для понимания, ибо ломает все к чему за долгие годы привыкли.
Это непонимание видно по тому, какая рисуется диаграмма, а рисуется она с единственной моделью, единственной вьюшкой, там где не видно чем именно UDF должна завоевать умы разработчиков. Там где все архитектуры выглядят хорошо, и вообще понять между ними разницу непросто. А нужно рисовать ситуацию, когда этих моделей и вьюшек много. А там где их много с применением реактивного программирования диаграмма распространения изменений выглядит примерно так:
Тут я нарисовал как при каком либо действии пользователя во view1, изменения распространяются последовательно в разные computed, затем в некоторые observable, и видно, что computed5 будет пересчитан дважды, и view3 также будет обновлена дважды. Мы в нашем knockout приложении также однажды напоролись на такой эффект, где один computed пересчитывался N раз, по количеству элементов массива. Заявленое громкое преимущество, что knockout обновляет лишь то, что нужно, и его реактивная модель этим несет в мир производительность, в этот момент с треском лопнуло.
#### Приложение с UDF
Когда я изучал примеры приложения на react/redux, меня не покидало ощущение, что проработаны оно не до конца. В частности cамим автором redux, Деном Абрамовым предлагается непосредственно в UI компонентах, в тех же файлах писать т.н. dispatchToProps функции, которые навешивают на props ui компонентов следующее
```
(dispatch) => {
return {
someMethod: (someData) => {
dispatch({type: Actions.someAction, someData });
}
}
};
```
Иногда эти методы становятся более сложными, их наполнение расширяется, в том числе появляются асинхронные операции
```
(dispatch) => {
return {
async someMethod: (someId) => {
dispatch({type: Actions.startedLoadingAction });
const someData = await api.loadSomeData(someId);
dispatch({type: Actions.someAction, someData });
}
}
};
```
Нетрудно увидеть, что это бизнес логика. А я долго распинался на тему того, что в UI слое бизнес-логике не место. Кроме того эта логика, располагающаяся во втором шаге конвейера, влияет на первый, что нарушает уже саму архитектуру UDF. То что так делать нельзя, стало очевидно сразу, на как же делать можно и нужно? Через какое-то время, после изысканий, проб и ошибок, ответ пришел. Причем очевидность этого ответа поражает своей простотой — код который влияет на N-ный шаг конвейера должен находиться на шаге конвейера N-1. Кроме того, заявление о том, что асинхронный код должен быть сдвинут к краю приложения, обретает также и уточнение к какому именно краю. Внезапно это тот край, где backend, связь с которым и имеет асинхронную природу. Паззл сложился, и даже носки совпали цветом. Нужно создать еще один шаг конвейера, сервисный и поместить его перед шагом управляющим состоянием.
Общая диаграмма получилась следующая.
В момент входа на страницу/приложение нам нужно создать стор, после чего вызвать первый входной метод в конвейере. Я буду далее называть это методом-раздражителем. А также оформить единственную подписку UI на стор. Метод раздражитель вызовом соответствующего Action-а инициализирует состояние в положение «индикатор прогресса», далее соответственно срабатывает подписка UI и отрисовывает то, как это выглядит.
Метод раздражитель же следующим действием вызывает асинхронное действие на загрузку изначальных данных. Когда приходит ответ с сервера, происходит следующий проход по конвейеру, с еще одним рендером.
В разметке же располагаются подобные вещи
```
service.userClickedApply()} >батон
```
таким образом в ui-слое отсутствует бизнес логика, присутствует лишь указание, какой метод-раздражитель нужно дернуть при соответствующем действии пользователя.
Разработчик при этом может принять решение сделать ли у всех страниц приложения общий корень, либо у каждой страницы может быть свой корень. В последнем случае каждая страница инициализируя стор должна будет указать свой редюсер.
#### Взаимодействие первого шага конвейера со вторым.
Название сервисов соответствуют названиям UI компонентов, сочиненных специально для этого примера. Страница декомпозирована на левую панель, правую панель и футер, на левой панели и футере тоже предполагается размещать какие нибудь компоненты, на правой панели расположены Payments и UserData. Надо обратить внимание, что соответствующие сервисы и соответствующие состояния UI компонентам не принадлежат, а соответствуют, и имеют тот формат, который эти компоненты принимают на вход.
Если пользовательский ввод касается конкретного компонента, т.е. по требованиям этот пользовательский ввод больше ничего на экране не затрагивает, то вызывается сервис, соответствующий этому конкретному компоненту, его метод создает Action, лежащий рядом с определением его состояния, т.е. интерфейсом (подразумевается тайпскрипт), и собственно редюсером. Непосредственной связи с редюсером этого компонента у сервиса естественно нет, поэтому стрелочка пунктирная. Action подается в центральную точку входа, в стор.
Более интересен случай, когда требование подразумевает что-то изменить в состоянии сразу двух компонентов, к примеру в UserData компоненте человек нажал кнопку «показать платежи за прошлый год» и должна обновиться таблица payments, а на компоненте UserData должно измениться поле «итого». В этом случае должен вызваться сервис соответствующий правой панели, бросить соответствующий Action, и редюсер правой панели должен совершить соответствующие действия над своим состоянием и полями своего состояния, вызвав соответствующие чистые функции. Также как в примере, который я приводил в мотивации архитектуры. Таким же образом, если нам нужно обновить много всего на странице, например если выбран другой пользователь, то, перезагрузив все данные, в сервисе страницы нам нужно вызывать Action уровня редюсера страницы, который обновит сразу всё. Альтернативно, если к примеру данные для левой и правой панели могут загружаться раздельно, показывая отдельные индикаторы прогресса, то из сервиса страницы допускается вызвать соответствующие методы сервиса левой панели и правой. Переигрывать это действие можно как угодно, можно комбинировать эти запросы в параллель, можно последовательно, можно независимо, как больше подходит под требования.
#### Третий шаг конвейера
Как я уже говорил, подписка на состояние должна быть одна. В данном примере эта подписка на уровне страницы. На странице предполагается подобный код
```
import {store} from ...
import {LeftPanel, RightPanel, Footer } from ...
export class Page extends React.Component {
componentWillMount() {
store.subscribe(() => this.setState(store.getState()));
}
render() {
return (
Title here
==========
);
}
}
```
Далее предполагается то самое разделение на умные и глупые компоненты, компонент, отвечающий за правую панель — специфичен для именно этой страницы, не предполагается, что он будет вызван где то еще, поэтому можно сделать его умным. То есть он должен знать какие именно раздражители нужно вызвать на конкретные действия пользователя. А компонент UserData по желанию можно сделать глупым. И в одном сценарии один сервис совместно с соответствующим редюсером может управлять его данными в памяти, а в другом сценарии, на другой странице другой сервис будет вызывать асинхронные методы.
Выглядеть это будет примерно так
```
import {rightPanelService, userDataService} from ...
import {UserData } from ...
export class RightPanel extends React.PureComponent{
render() {
const state = this.props.state;
return (
rightPanelService.lastYearClicked()}
onUserNameChanged={(userName) => userDataService.userNameChanged(userName)} />
);
}
}
```
Тут можно обратить внимание, что использован PureComponent, это означает, что если при обновлении состояния на странице в этом состоянии поле rightPanel имеет то же значение, если изменения касались только других частей страницы, но не этой, то весь рендеринг правой панели и ниже будет отсечен. В этом присутствует положительное влияние чистого кода редюсеров на производительность рендеринга. Раньше этот PureComponent нужно было либо писать самому, благо его реализация исключительно проста, либо импортировать из еще одной библиотеки автора Redux, а сейчас такой компонент включен непосредственно в реакт. В ангуляре (версии 2, 4, 5...) за это отвечает стратегия обновления компонента. Там тоже можно определить правило, что если ни один из его @Input-ов не поменялся (подразумевается reference equality), то dirty check этого компонента, проводить не нужно, и также из цикла будут исключены все дочерние компоненты в его разметке, то есть можно отсечь всю ветвь рендера, как и в реакте.
Далее собственно компонент UserData
```
export function UserData({state, onLastYearClicked, onUserNameChanged}) {
return (
onUserNameChanged(newVal)} />
...etc.
);
}
```
#### Экстремальное тестирование
Еще одна мысль посетила меня не так давно. По сути получается, что frontend-приложение в котором отсутствует логика, может функционировать даже без рендера разметки. И если вынести на обсуждение такие факты:
1) вызов браузера — это самая «дорогая» в плане времени операция в behavior-тестах UI слоя.
2) Функциональность именно разметки относительно мала в сравнении с остальным приложением
3) Разметку тестировать дорого в плане затрат разработчика, а устранение найденных багов, таких как заползание одних элементов на другие, и т.п. как правило весьма дешево.
т.е. затраты на тестирование не стоят тех багов, которые они могут выявить.
А что если тестировать такое приложение прямо в nodeJS? Не открывая браузер, не производя никакой рендеринг, создай себе стор прямо в тесте, вызывай сервисные методы, имитируй действия пользователя, вызовом методов-раздражителей, да тестируй данные которые получились в сторе в результате таких операций. Протестировать можно успеть намного больше, поскольку не нужно даже писать код взаимодействия с селениумом (или что вы там используете), и тесты будут ходить в десятки а то и сотни раз быстрее, чем обычные.
Разумеется остается вариант дополнительно проверить запуск приложения в браузере, можно даже зайти по разу на каждую страницу, протестировать как работает роутинг, подписка в корне страниц. И такой тест можно положить туда же где лежит длительный нагрузочный тест, который запускается раз в две недели перед поставкой, ну или overnight. А большинство тестов, которые по прежнему behavior тесты и до уровняю unit-тестов еще не скатились, но уже ходят достаточно быстро, поэтому запускать их можно на каждый коммит, да хоть на любой чих в процессе разработки.
К сожалению, подобный фокус вряд ли получится с ангуляром. Поскольку для функционирования приложения все сервисы будут обернуты в @Injectable, и для запросов на backend будете пользоваться ангулярным сервисом Http. Попытка отказаться от dependency injection механизма плюс использовать «родной» fetch вместо Http и Promise вместо Observable может оказаться провальной, велик риск наткнуться на сценарий не поддерживаемый библиотекой zone.js, например заведомо известно, что не поддерживается async/await.
#### Напоследок
В следующей статье я планирую выжать таки из себя решение, позволяющее упростить жизнь с redux, автоматически на лету генерировать три из четырех кусков кода. Решение применимо только к typescript, т.к. основывается на том, что дерево своего состояния вы опишете в интерфейсах. | https://habr.com/ru/post/353590/ | null | ru | null |
# Работа с библиотекой OrnaJS
OrnaJS — свободная JavaScript библиотека для динамической стилизации HTML элементов без прямого написания JS или CSS кода. Стилизация осуществляется методом прибавления классов к HTML элементу, как и в привычных CSS-библиотеках. В отличие от СSS-библиотек, Orna не ограничена количеством ранее прописанных в ней классов, а работает как парсер, динамически обрабатывает класс и задает стиль. Стилизация в OrnaJS основана по принципу Atomic CSS, из чего следует, что вид элемента создается по частям (атомам), но не одним классом. Орну можно сравнить с атрибутом style в HTML, но с наследованием, сокращениями и событиями. Имя Orna сокращение от Ornament (украшение). В первые два месяца после публикации, хотя Орна предлагает нестандартный метод стилизации страниц, ее успели скачать более 2000 разработчиков, что говорит о растущей популярности динамической стилизации.
### OrnaJS и Atomic CSS
Atomic CSS — методология написания CSS кода, которая соблюдает принцип «один класс = одно свойство». При написании стилей по методологии Atomic CSS, разработчик создает универсальные классы, которые в большинстве случаев несут только одно свойство и его значение. Она призвана убрать повторяемость, многословность, запутанность при работе CSS и также с CSS препроцессорах, Less, Sass. CSS является фундаментом для создания стилей он дает возможность сделать надстройки и разрабатывать удобные архитектуры для конкретных разработчиков, именно поэтому у него полная форма свойств и нет строгой архитектуры. архитектура Atomic CSS разрабатывается командой из Yahoo, OrnaOrg и всеми энтузиастами.
Проект OrnaJS начался в 2015 году и изначально разрабатывался как инструмент для удобной реализации Atomic CSS архитектуры, но потом был подвержен реформации и сейчас соблюдает от части правила из Atomic CSS и от части из React CSS.
React CSS — реактивный CSS, в отличие от методологии Atomic CSS работает с динамическими стилями, которые создаются в процессе работы с элементами. React CSS методология, которая широко используется при создании SPA, где элементы разметки создаются динамически и изначально их еще нет. Команда Orna создала отдельную библиотеку для полной реализации Atomic CSS, которая предполагает уже описание атомарные стили, а не их динамическое создание, Orna4Node. Orna4Node автоматически генерирует CSS файл на основе классов прописанных в элементах, в отличие от OrnaJS которая не создает CSS файл, а на прямую, методами JavaScript обращается к DOM дереву. Orna4Node похожа по работе на Atomizer от Yahoo!..
### OrnaJS и jQuery
OrnaJS работает вместе с библиотекой jQuery, из которой вынесла основные селекторы и выборки по элементам. Orna работает с первой версией jQuery, со второй и с третьей, выбор поставлен на разработчика.
**bgc\_red\_div:even** — класс задает красный цвет фона всем четным, дочерним div элементам.
**bgc\_red\_div:odd** — класс задает красный цвет фона всем нечетным, дочерним div элементам.
**bgc\_red\_div:first** — класс задает красный цвет фона первому дочернему div элементу.
**bgc\_red\_div:last** — класс задает красный цвет фона последнему дочернему div элементу.
**bgc\_red\_option:selected** — класс задает красный цвет фона всем выбраним дочерним элементам option.
**bgc\_red\_input[type=text]** — класс задает красный цвет фона всем дочерним элементам input с типом текст.
**bgc\_red\_#menu** — класс задает красный цвет фона дочернему элементу с id menu.
**bgc\_red\_.menu** — класс задает красный цвет фона всем дочерним элементам с классом menu.
### Основное предназначение
Основное предназначение библиотеки-парсера OrnaJS упростить работу при стилизации элементов разметки. Орна помогает избавиться от повторяемости стилей, чрезмерной многословности и что основное от работы над структуризацией СSS кода. Так как Орна переняла основные идеи от методологии Atomic CSS, при работе с ней все атомарно, то есть стиль собирается частицами и все стили ложатся независимо, чисто, без необходимости усердного рефакторинга. Также с использованием Орны больше нет необходимости задавать стили элементам при помощи jQuery или Native JavaScript, так как в Орне это гораздо проще, из-за уровня абстракции, что работает по принципу водопада html --> ornajs --> jquery --> native javascript.
### Использование
Использовать Орну можно и для полной стилизации странниц или как дополнение к основным каркасным стилям. В современной тенденции веб-разработки, где много динамики и состояний, разработчики все больше и больше отходят от статической HTML и СSS разметки, в сторону их динамического создания в процессе взаимодействия пользователе с интерфейсом. OrnaJS может быть использована в контексте с react.js, riot.js, handlebars.js, angular.js, bootstrap.
Подключение библиотек:
```
```
### Структура классов в OrnaJS
property\_value
color\_red
property\_value\_event
color\_red\_click
property\_value\_childtagname
color\_red\_div
property\_value\_event\_childtagname
color\_red\_click\_div
property\_value\_childtagname\_event
color\_red\_div\_click
### Стилизация
```
Hello! I'm decorated by OrnaJS...
```
```
Hello! My (a)link decorated by OrnaJS...
[1](#)
[2](#)
[3](#)
[4](#)
```
### DOM дерево
#### Если динамически изменить DOM дерево?
1. Все новые элементы автоматически следуют стилям, которые были указаны через родительские элементы для дочерних, без перезапуска Орны.
Пример:
```
link
Click
```
2. Если были добавлены новые элементы уже с прописанными в них классами OrnaJS, то чтобы эти классы присвоились надо перезапустить OrnaJS.
Для этого запустить нужно функцию createatom(); Без аргумента функция стилизует все новые элементы, минуя старые, с аргументом конкретный новый элемент.
В OrnaJS подключаются любой font, который есть на компьютере в системных шрифтах, или загружен прямо в СSS и в его названии нет пробелов, так как пробел OrnaJS понимает, как конец класса. Два шрифта Arial и Times New Roman подключаются одним словом (arial, times) просто для быстрого доступа, а вообще нужно писать класс:
```
Text
Text
```
### Демо
[codepen.io/DimaPopov/pen/dXyZQR](http://codepen.io/DimaPopov/pen/dXyZQR)
[codepen.io/DimaPopov/pen/JKEaby](http://codepen.io/DimaPopov/pen/JKEaby)
[fiddle.jshell.net/dimapopov/hokLfqqo](https://fiddle.jshell.net/dimapopov/hokLfqqo/)
[www.youtube.com/watch?v=k4mkK\_3YUk8](https://www.youtube.com/watch?v=k4mkK_3YUk8)
### Ссылки
[ornaorg.github.io](http://ornaorg.github.io)
[ornaorg.github.io/AtomicCSS.html](http://ornaorg.github.io/AtomicCSS.html)
[www.npmjs.com/package/ornajs](https://www.npmjs.com/package/ornajs)
[github.com/OrnaOrg](https://github.com/OrnaOrg)
[github.com/OrnaOrg/OrnaJS](https://github.com/OrnaOrg/OrnaJS) | https://habr.com/ru/post/307200/ | null | ru | null |
# Что лучше выбрать: Wireguard или OpenVPN? Любимый VPN Линуса Торвальдса
Технологии VPN редко становятся объектами пристального внимания: есть и есть. Создатель Wireguard Jason A. Donenfeld оказался везунчиком после нетипичной для Линуса Торвальдса резко хвалебной оценки качества кода.
> Can I just once again state my love for it and hope it gets merged soon? Maybe the code isn’t perfect, but I’ve skimmed it, and compared to the horrors that are OpenVPN and IPSec, it’s a work of art.
Вскоре после этого Wireguard [оказался](https://kernelnewbies.org/Linux_5.6) в основной ветке стабильного ядра Linux. Чем же Wireguard так замечателен и отличается от остальных VPN?
Шифрование: отличия Wireguard от OpenVPN
----------------------------------------
Wireguard исповедует минималистский и безапелляционный подход к шифрованию, преднамеренно исключив гибкость и альтернативу выбора протоколов, так как это слишком затратно. Если нет выбора протоколов, нет и процесса согласования, в котором традиционно находят дыры безопасности. Кроме того SSL/TLS уязвимости, идущие ровным потоком, также не в пользу богатства выбора.
### Протоколы шифрования Wireguard
* **Краткость сестра таланта** — 4000 строк кода стало чуть ли не визитной карточкой Wireguard.
* Детерминированный набор современных криптографических алгоритмов:
* [ChaCha20](http://cr.yp.to/chacha.html) для симметричного шифрования также используется в [AEAD структуре RFC7539](https://tools.ietf.org/html/rfc7539);
* [Poly1305](http://cr.yp.to/mac.html) для аутентификации, также используется в [AEAD структуре RFC7539](https://tools.ietf.org/html/rfc7539);
* [Curve25519](http://cr.yp.to/ecdh.html) — эллиптическая кривая для протокола безопасного обмена ключей Diffie-Hellman;
* [Blake2](https://blake2.net/) — в [RFC7693](https://tools.ietf.org/html/rfc7693) для соответствующей хеш-функции;
* **SipHash2-4** — псевдослучайная функция для поиска расшифрованных открытых ключей инициатора сессии установления связи;
* **HKDF** — для извлечения ключей;
* **UDP** — в качестве протокола транспортного уровня;
* **Perfect forward secrecy** — принцип предотвращения компрометации сессионных ключей.
В отличие от OpenVPN, Wireguard не использует сертификаты X.509 и лишен сопутствующих [проблем](https://habr.com/en/post/346798/). Вместо этого Wireguard использует асимметричное шифрование с открытым и закрытым ключом.
### Протоколы шифрования OpenVPN
OpenVPN поддерживает множество криптографических алгоритмов, используя библиотеку [OpenSSL](https://www.openssl.org/). Более точно, для шифрования и аутентификации используются следующие алгоритмы.
`aes-128-cbc aes-128-ecb aes-192-cbc aes-192-ecb
aes-256-cbc aes-256-ecb aria-128-cbc aria-128-cfb
aria-128-cfb1 aria-128-cfb8 aria-128-ctr aria-128-ecb
aria-128-ofb aria-192-cbc aria-192-cfb aria-192-cfb1
aria-192-cfb8 aria-192-ctr aria-192-ecb aria-192-ofb
aria-256-cbc aria-256-cfb aria-256-cfb1 aria-256-cfb8
aria-256-ctr aria-256-ecb aria-256-ofb base64
bf bf-cbc bf-cfb bf-ecb
bf-ofb camellia-128-cbc camellia-128-ecb camellia-192-cbc
camellia-192-ecb camellia-256-cbc camellia-256-ecb cast
cast-cbc cast5-cbc cast5-cfb cast5-ecb
cast5-ofb des des-cbc des-cfb
des-ecb des-ede des-ede-cbc des-ede-cfb
des-ede-ofb des-ede3 des-ede3-cbc des-ede3-cfb
des-ede3-ofb des-ofb des3 desx
idea idea-cbc idea-cfb idea-ecb
idea-ofb rc2 rc2-40-cbc rc2-64-cbc
rc2-cbc rc2-cfb rc2-ecb rc2-ofb
rc4 rc4-40 rc5 rc5-cbc
rc5-cfb rc5-ecb rc5-ofb seed
seed-cbc seed-cfb seed-ecb seed-ofb
sm4-cbc sm4-cfb sm4-ctr sm4-ecb`
Для хеш сумм доступны такие функции.
`(1:701)$ openssl dgst --list
Supported digests:
-blake2b512 -blake2s256 -md4
-md5 -md5-sha1 -mdc2
-ripemd -ripemd160 -rmd160
-sha1 -sha224 -sha256
-sha3-224 -sha3-256 -sha3-384
-sha3-512 -sha384 -sha512
-sha512-224 -sha512-256 -shake128
-shake256 -sm3 -ssl3-md5
-ssl3-sha1 -whirlpool`
OpenVPN в связке с OpenSSL поддерживает PKI стандарты RSA, DSA и ECDSA, однако не все из них пригодны для любых пользовательских сценариев. Так, ключи ECDSA пока еще не получили широкой поддержки со стороны корневых CA.
* **UDP/TCP** — в качестве протокола транспортного уровня;
* **Perfect forward secrecy** — принцип предотвращения компрометации сессионных ключей.
### Выводы по стандартам шифрования и безопасности
*Архитектурно* Wireguard более безопасен за счет того, что поверхность атаки значительно меньше по сравнению с OpenVPN. Тем не менее, OpenVPN считается очень безопасным и надежным, многократно пройдя независимый аудит кода. За счет этого OpenVPN **выигрывает** при консервативном подходе к выбору VPN-решения.
Вместе с тем отсутствие гибкости, возможности выбора способа шифрования создает значительные препятствия для использования Wireguard в корпоративном сегменте пользователей VPN. Представьте стандартную для наших ситуацию, в которой сотрудники подключаются к рабочей сети по VPN с различных устройств. В такой ситуации отсутствие гибкости и выбора создаст гораздо больше проблем, чем сможет их устранить.
### Сравнение производительности
Так как Wireguard реализован в пространстве ядра, а OpenVPN в пользовательском пространстве, у первого должно быть преимущество в скорости. Связано это с тем, что пакеты постоянно копируются из одного пространства в другое и кроме того требуется постоянная фоновая служба OpenVPN.
Все это необходимо проверить на практике, к счастью есть множество замеров скорости для VPN туннелей. Для начала можно взглянуть на результаты VPN-дерби от самого автора Wireguard. Вот некоторые детали и результаты замера.
* **Технологии** — IPSEC, OpenVPN и Wireguard;
* **Процессоры** IntelCore i7-3820QM и Intel Core i7-5200U;
* **Сетевые карты** — Intel 82579LM и Intel I218LM gigabit Ethernet;
*Сравнение производительности различных VPN со стороны Jason A. Donenfeld-а*
В обоих тестах — на пропускную способность и время отклика ping, Wireguard значительно превзошел OpenVPN, а заодно и две вариации IPSec-а. Кроме того, во время теста на пропускную способность с использованием OpenVPN и IPSec утилизация CPU **достигала 100%**. В то же время использование Wireguard так сильно не загружало центральный процессор, давая тем самым возможность полностью утилизировать ресурсы сетевой карты Gigabit Ethernet.
Естественно предположить, что автор Wireguard может быть предвзятым в составлении сценариев и трактовке результатов замера производительности технологий VPN. Следовательно, имеет смысл ознакомиться с другими тестами скорости разных VPN. Благо все, что для этого нужен VPS сервер, VPN и пакет iperf3.
Но и другие [подобные](https://blog.entrostat.com/openvpn-vs-wireguard-network-performance-tests/) тесты показывают превосходство Wireguard в тестах производительности.
*Сравнение производительности Wireguard и OpenVPN*
Неожиданным фактом можно считать, что openvpn-tcp быстрее openvpn-udp, однако при ближайшем рассмотрении все становится на свои места. TCP-поток имеет меньше завершенных тестов, чем UDP. Во всяком случае и тут Wireguard показывает лучшие результаты производительности.
В той же серии тестов любопытно сравнение скорости VPN-соединения в зависимости от числа открытых сокетов. При росте их количества производительность Wireguard скачкообразно падает, хотя продолжает оставаться выше, чем openvpn-tcp и openvpn-udp.
*Сравнение производительности Wireguard и OpenVPN в зависимости от числа открытых сокетов. TestID 0-600 соответствует openvpn-udp, 700-1200 — openvpn-tcp и 1300-1800 — Wireguard*
### Выводы по скорости VPN-соединения
Синтетические тесты скорости от разных авторов, с использованием пакета iperf3, позволяют предположить, что **Wireguard быстрее**, чем OpenVPN.
Конфиденциальность данных
-------------------------
VPN-протоколы уделяют гораздо большее внимание безопасности соединения, нежели конфиденциальности. Однако возможность сохранения анонимности тоже имеет значение — кому охота писать объяснительные по факту закачки учебника Oracle, или эмулятора топологии Cisco? Ничто так хорошо не выдает факт правонарушения, как IP адрес пользователя.
Настройки Wireguard в явном виде содержат IP адреса пользователей и это обстоятельство не позволит им остаться незамеченным после того, как сервером заинтересуются правоохранительные органы. Сетевой трафик прочитать, конечно, не удастся, однако можно идентифицировать самих участников защищенного соединения.
Сама настройка защищенного соединения Wireguard довольно проста. Сперва установка.
```
(1:530)$ sudo emerge -av wireguard-modules wireguard-tools
These are the packages that would be merged, in order:
Calculating dependencies... done!
[binary N ] net-dns/openresolv-3.11.0 USE="(-selinux)"
[binary N ] virtual/resolvconf-1
[ebuild N ] net-vpn/wireguard-modules-1.0.20201221 USE="module -debug -module-src"
[binary N ] net-vpn/wireguard-tools-1.0.20200827 USE="wg-quick"
Would you like to merge these packages? [Yes/No]
```
Создаем открытый и закрытый ключи.
```
(1:531)$ wg genkey | tee privatekey | wg pubkey > publickey
```
Далее, необходимо настроить файл /etc/wireguard/wg0.conf.
```
/etc/wireguard/wg0.conf
[Interface]
Address = 10.0.0.1/24, fdc9:1f28:04d7:9ee9::1/64
SaveConfig = true
ListenPort = 51820
PrivateKey = 2JtKAUFzecmgIVzbscQh3iUZrZanxIzvbejcIkvC5Hk= #PEER_A_PRIVATE_KEY
[Peer]
PublicKey = rgqd1cHKgRWX3IkYYSlrKA/SW3qZUhSJMqwTq4+3eFs= #PEER_B_PUBLIC_KEY
PresharedKey = PEER_A-PEER_B-PRESHARED_KEY
AllowedIPs = 10.0.0.2/32, fdc9:1f28:04d7:9ee9::2/128
Endpoint = pb.example.com:51280
```
Второй участник подключения должен у себя настроить такой же файл, указав в нем свой закрытый ключ и открытый ключ участника A. Для установки соединения каждая из сторон выполняет `wg-quick up interface_name.`
Из этого видно, что при настройке Wireguard IP адрес, либо имя узла задаются в явном виде и будут видны в системных лог-файлах и таблицах SNMP до момента перезагрузки сервера.
OpenVPN лучше защищает конфиденциальность клиентских подключений, так как не требует до установки защищенного соединения прописывать IP адреса, или сетевое имя клиентских компьютеров.
### Выводы по конфиденциальности данных
В этой номинации OpenVPN имеет определенное преимущество ввиду того, что лишь Wireguard предполагает хранение IP-адреса пользователей на VPN-сервере в течение длительного времени.
Итоги: какой же VPN выбрать?
----------------------------
Есть огромное количество пользовательских сценариев использования VPN, и вряд ли одна и та же рекомендация будет хороша для всех. Соответственно, для разных сценариев можно выделить две группы с наиболее подходящим решением для VPN.
* Если вы обычный пользователь;
* VPN вам нужен для обхода всяких нелепых ограничений РКН;
* скорость для вас имеет значение, например для файлообмена, или работы вашего приложения;
**Используйте Wireguard.**
* Бизнес пользователи средней и крупной компании использующие VPN для удаленного доступа к внутренней сети;
* бизнес пользователи, предоставляющие удаленный доступ по VPN к ИТ ресурсам, содержащим конфиденциальные данные, или коммерческую тайну;
* все, кому нужно надежное и проверенное временем решение для VPN;
**То лучше используйте OpenVPN.**
Ну а какой [VPS](https://ruvds.com/) брать под VPN вы и так знаете.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=mikael&utm_content=kakoy-vpn-vibrat#order) | https://habr.com/ru/post/537010/ | null | ru | null |
# HI-Load — или снимаем ограничения на скачивания с файлообменников
Имею желание пропиарить свой проект. Реализован на php и с++.
**Суть проекта:**
`1) Клиент приходит к нам
2) Вводит ссылку на файл, который желает скачать
3) Получает ссылку для скачивания с нашего сервера.
4) Успешно качает многопоточно и с докачкой`
Введено тестовое скачивание на 1 файл размером до 100 мб.
Стоимость полного доступа — 2 $ в месяц.(надо же как то затраты окупать)
Скорость на один поток огранничена до 50 кб.
Так что для скачивания на большей скорости — больше потоков.
Поддерживаемые на данный момент файлообменники
`depositfiles.com
megaupload.com
turbobit.net
vip-file.com
letitbit.net
sms4file.com`
Также получение прямых линков на
`youtube.com
rutube.ru
rutv.ru`
Линк — [hi-load.net](http://hi-load.net) | https://habr.com/ru/post/87256/ | null | ru | null |
# Постраничная навигация с MySQL при большом количестве записей
Рано или поздно многие крупные проекты сталкиваются с проблемами производительности при постраничной навигации по записям. Некоторые из них решают эту проблему ограничением количества доступных для просмотра записей (скажем, не больше 1000). Вполне приемлемое решение. Но в этом случаем могут возникнуть проблемы с индексированием сайта сторонними поисковиками, которые и представляют наибольшую угрозу. В этой статье я хотел бы отказаться от привычной для всех панели навигации вида «1..2..3..4..» в пользу простой «вперед… назад» (будет проще объяснить), но это не проблема реализовать подобное и с первым вариантом.
Более точно определить тему, назвав, какое количество записей считать достаточно большим для появления тормозов, не получится, так как эта цифра для всех разная и сильно зависит от того, насколько быстрые у Вас жесткие диски, сколько памяти, и какая часть Ваших данных уже закеширована в ней и тд. Но если Вы и Ваши сервера ощущают, что n-ная страница при выводе даётся тяжелее первой, и при этом не знаете, что с этим делать – статья для Вас. Но для начала, я хотел бы на пальцах объяснить, почему ОНО работает медленно.
Кстати, тест происходит на виртуальной машинке, работаю я с СУБД под рутом, версия MySQL – 5.0.32.
#### 1 Начнем с данных
Для тестирования создадим небольшую табличку и наполним ее чем-нибудь.
`CREATE TABLE items (
id INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,
height INT UNSIGNED NOT NULL DEFAULT 0,
width INT UNSIGNED NOT NULL DEFAULT 0,
price DECIMAL(10,2) NOT NULL DEFAULT 0.0,
title VARCHAR(255) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=UTF8;`
Небольшим скриптом на PHP был сгенерирован INSERT 100000 записей. Данные такого вида:
— порядок полей в INSERT:
height, width, price, title
— шаблон для полей:
$val\_tmpl = "\t(%d, %d, %f, 'Item %d')";
— тестовые значения ($i = 1..100000):
sprintf($val\_tmpl, rand(0, 120), rand(0, 220), 10 \* rand(0, $i) / $i, $i);
Заносим это все в нашу БД. И можно начинать…
#### 2 Обычный метод постраничного вывода
Все, кто уже знает, чем плохи COUNT(\*) и LIMIT… OFFSET, могут пропустить эту часть.
Прежде, чем рисовать навигатор, мы делаем SELECT COUNT(\*) … WHERE (условия\_выборки). Многие, почему-то уверены, что даже если у нас миллионы записей, но условия\_выборки позволяют использовать индекс, то такой запрос отработает очень быстро. Проведем эксперимент. Выберем количество записей, у которых height больше 100. Для начала посмотрим, что будет, если индекса по полю height нет.
FLUSH STATUS;
SELECT SQL\_NO\_CACHE COUNT(\*) FROM items WHERE height>100;
+----------+
| count(\*) |
+----------+
| 16405 |
+----------+
1 row in set (0.09 sec)
SHOW STATUS LIKE ‘handler%’;
Последняя команда покажет, сколько же, и каких действий пришлось сделать СУБД, чтобы выполнить наш запрос. Так как индекса у нас нет, MySQL пришлось читать данные прямо из таблицы, поэтому нас интересует строка:
…
| Handler\_read\_rnd\_next | 100001 |
…
То есть, MySQL пришлось сделать 100001 операцию перехода к следующей записи, чтобы найти все, соответствующие запросу.
Везде ниже перед каждым SELECT подразумевается выполнение FLUSH STATUS, а после: SHOW STATUS LIKE ‘handler%’.
Чем нам может помочь индекс.
ALTER TABLE items ADD INDEX height\_idx (height);
SELECT SQL\_NO\_CACHE COUNT(\*) FROM items FORCE INDEX(height\_idx) WHERE height>100;
+----------+
| count(\*) |
+----------+
| 16405 |
+----------+
1 row in set (0.04 sec)
В данном случае использовался индекс, поэтому Handler\_read\_rnd\_next будет равен 0, а вот
…
| Handler\_read\_next | 16405 |
…
То есть индекс позволяет изначально посчитать только те записи, которые нужны, НО ему все равно требуется пробежаться по ним всем. Нет никакой магии, MySQL нигде не хранит количество записей, соответствующих запросу. Поэтому, если у вас миллионы записей, соответствующих условиям запроса, COUNT будет работать очень медленно.
Второй момент. LIMIT … OFFSET. Тот же эксперимент. Попросим нам 5 записей.
SELECT SQL\_NO\_CACHE \* FROM items FORCE INDEX(height\_idx) WHERE height>100 LIMIT 5;
…
5 rows in set (0.00 sec)
…
| Handler\_read\_next | 4 |
…
Вроде все логично. А теперь попросим вернуть другие 5 записей, начиная с 16401.
SELECT SQL\_NO\_CACHE \* FROM items FORCE INDEX(height\_idx) WHERE height>100 LIMIT 16400, 5;
…
5 rows in set (0.13 sec)
Видим, что время выборки значительно возросло. Смотрим статус:
…
| Handler\_read\_next | 16404 |
…
То есть, MySQL, прочитал все 16405, а только потом просто откинул все ненужные.
Как быть?
#### 3 Как быть
Итак. От нас требуется вывести 10 записей, а так же нарисовать меню навигации. Мы поняли, что, чтобы дойти до записи, с которой необходимо начать отдавать нам результаты, MySQL тратит много лишних действий. Единственное, как это избежать – сразу перейти к нужной, изменив условия выборки.
Рассмотрим все на простом примере: пусть записи выдаются отсортированные по id. В этом случае нам нужно вместе со ссылкой передать id записи, на которой мы остановились. А остановимся мы на записи с id=10. То есть, в параметрах ссылки на следующую страницу нам нужно передать 10. Соответственно, для второй страницы запрос будет выглядеть так:
SELECT SQL\_NO\_CACHE id FROM items WHERE id>10 ORDER BY id LIMIT 10;
Кстати, в обоих случаях Handler\_read\_next будет равен 9. То есть, прыгнули на первую соответствующую запросу запись (благодаря индексу) и сделали 9 переходов на следующую. Самое главное, что какое бы число вместо 10 в условие мы не подставили – мы всегда в результате SHOW STATUS увидим одно и то же, и время выполнения такого запроса уже не будет зависеть от того, где мы находимся, а будет зависеть только от того, сколько и чего мы выбираем.
Надеюсь, смысл Вам понятен. Давайте тогда решим, что делать с меню навигации, а потом перейдем к более сложной ситуации. Пусть в url мы используем ключевые слова next, previous и last. В каких случаях показывать ссылки «вперед», «назад» и «последняя»?
Каждый раз, когда нам приходит next (запрос следующей страницы), мы выбираем не 10 записей, а 11, начиная с id, переданного в параметрах запроса. Если нам вернулось 11 записей, то следует показать ссылку вперед с id 10-й записи, а 11-ю откинуть. Если вернулось меньше 11 записей, то ссылку вперед показывать не надо. При этом мы всегда (всегда, когда пришло next) показываем ссылку назад (previous) с id первой записи из выборки. Ссылки «в начало» и «последняя» всегда показываются вместе с «назад» и «вперед» соответственно. То есть, если мы решили показывать «назад», то должны показать и «в начало».
Каждый раз, когда нам приходит previous (запрос на предыдущую страницу), мы выбираем 11 записей, у которых id меньше указанного в запросе, отсортированные в обратном порядке. То же самое: если вернулось 11 записей, то ссылку «назад» показываем. Ссылку вперед показываем всегда.
Надеюсь, понятно написал…
Что если нам пришел запрос «last»? Просто показать 10 записей, начиная с самой последней. То есть:
SELECT id FROM items ORDER BY id DESC LIMIT 10;
Думаете, у кого-нибудь из пользователей хватит сил промотать несколько сотен, а то и тысяч страниц, для того, чтобы обвинить Вас во лжи, обнаружив в итоге на первой странице не 10 записей? Даже если и хватит, то Вы можете ответить, что он слишком долго мотал…
Предыдущий пример был прост тем, что id – уникален. А что если требуется сортировка по полю, значения которого могут повторяться? Например, height в нашем случае. Простым запросом было выяснено, что в таблице каждое значения height встречается примерно 800 раз. Просто передать последний выведенный height в параметрах запроса уже мало. Поможет нам всё тот же id. От нас просят отсортировать записи по высоте, но это ведь не мешает нам отсортировать их потом еще и по id?
Для этого нам понадобится новый индекс:
ALTER TABLE items ADD KEY height\_id\_idx (height, id);
Запрос для первой страницы будет такой:
SELECT SQL\_NO\_CACHE id, height FROM items ORDER BY height, id LIMIT 10;
В моих результатах у последней записи height=0, id=1174. Так и надо передать следующей странице. Например, next\_0\_1174 или next/0/1074 – как Вам удобнее.
Теперь нам нужно выбрать записи, у которых либо height больше 0, либо height=0, а id>1174 (именно для этого мы и сделали дополнительную сортировку).
То есть:
SELECT SQL\_NO\_CACHE \* FROM items WHERE (height>0) OR (height=0 AND id>1174) ORDER BY height, id LIMIT 10;
Надеюсь, пояснять, почему так, не нужно. Статус по-прежнему показывает всего 9 шагов вперед.
Таким образом, мы можем добавлять и другие сортировки. Например, если мы хотим вывести все записи, отсортированные по цене и высоте, запрос будет таким:
SELECT SQL\_NO\_CACHE \* FROM items WHERE (price>5) OR (price=5 AND height>0) AND (price=5 AND height=0 AND id>1174) ORDER BY price, height, id LIMIT 10;
Остается только передавать все необходимые данные, правильно их обрабатывать и подставлять в запрос. И про индекс не забудьте.
#### 4 Что делать с количеством результатов
Как быть, если мы хотим показать пользователям, сколько же результатов найдено? Так как речь идет о больших числах, то вряд ли нас кто-то будет проверять. Тот же гугл может выдать, что нашел 1000000 страниц, соответствующих запросу, но больше 1000 вы не увидите. Мы тоже можем выдать количество результатов лишь примерно. Где его взять и как оценить? Помните, мы выполняли запрос:
SELECT SQL\_NO\_CACHE COUNT(\*) FROM items FORCE INDEX(height\_idx) WHERE height>100;
А давайте сделаем так:
EXPLAIN SELECT SQL\_NO\_CACHE \* FROM items FORCE INDEX(height\_idx) WHERE height>100;
В результате получим что-то такое:
+----+-------------+-------+-------+---------------+------------+---------+------+-------+-------------+
| id | select\_type | table | type | possible\_keys | key | key\_len | ref | rows | Extra |
+----+-------------+-------+-------+---------------+------------+---------+------+-------+-------------+
| 1 | SIMPLE | items | range | height\_idx | height\_idx | 4 | NULL | 22616 | Using where |
+----+-------------+-------+-------+---------------+------------+---------+------+-------+-------------+
Столбец rows как раз показывает оценочное число записей, которые нужно просмотреть. 22616 и 16405 – разница совсем не велика. Можно округлить до ~20000, да и ладно. Сойдёт. Только помните, что если используете, например, подзапросы и/или объединения, то EXPLAIN вернет несколько строк. Их все надо прочитать и перемножить значения rows.
#### Заключение
Данная проблема уже освещалась вскользь на хабре, но не так подробно.
Статья получилась больше, чем ожидал, хотя текст и разбавлен вставками запросов и результатов. В данный момент некуда выложить использованный для генерации данных скрипт + sql файлы. В общем… На заключение сил не осталось:) | https://habr.com/ru/post/44608/ | null | ru | null |
# Привет из свободного от libc мира! (Часть 1)
*В качестве упражнения* я хочу написать программу на С. Достаточно простую для того, чтобы дизассемблировать ее и объяснить весь код самой себе.
Звучит несложно, правильно?
У читателя предполагается наличие опыта компиляции программ и работы в Линуксе. Небольшое умение читать ассемблерный код тоже пригодится.
Итак, вот наш простейший хелловорлд:
```
jesstess@kid-charlemagne:~/c$ cat hello.c
#include
int main()
{
printf("Hello World\n");
return 0;
}
```
Скомпилируем его и посчитаем количество символов:
```
jesstess@kid-charlemagne:~/c$ gcc -o hello hello.c
jesstess@kid-charlemagne:~/c$ wc -c hello
10931 hello
```
Фигасе! Откуда берутся эти 11 килобайт? `objdump -t hello` показывает 79 записей в таблице идентификаторов, за большинство из которых ответственна стандартная библиотека.
Так что мы не будем ее использовать. И `printf` мы тоже не будем использовать, чтобы избавиться от инклюда:
```
jesstess@kid-charlemagne:~/c$ cat hello.c
int main()
{
char *str = "Hello World";
return 0;
}
```
Перекомпилируем и пересчитаем количество символов:
```
jesstess@kid-charlemagne:~/c$ gcc -o hello hello.c
jesstess@kid-charlemagne:~/c$ wc -c hello
10892 hello
```
Почти ничего не изменилось? Ха!
Проблема в том, что gcc все ещё использует startup files (?) во время линкования. Доказательства? Скомпилируем с ключом [`-nostdlib`](http://gcc.gnu.org/onlinedocs/gcc-4.4.3/gcc/Link-Options.html#index-nodefaultlibs-893), после чего (в соответствии с документацией) gcc «не будет использовать при линковании системные библиотеки и startup files. Использоваться будут только явно переданные линкеру файлы».
```
jesstess@kid-charlemagne:~/c$ gcc -nostdlib -o hello hello.c
/usr/bin/ld: warning: cannot find entry symbol _start; defaulting to 00000000004000e8
```
Всего лишь предупреждение, все равно попробуем:
```
jesstess@kid-charlemagne:~/c$ wc -c hello
1329 hello
```
Выглядит неплохо! Мы уменьшили размер до значительно более вменяемого (аж на целый порядок!)…
```
jesstess@kid-charlemagne:~/c$ ./hello
Segmentation fault
```
…и заплатили за это сегфолтом. Блин.
Для развлечения сделаем нашу программу запускаемой до того, как начнем разбираться в ассемблере.
Что же делает символ `_start`, который похоже нужен для запуска программы? Где он обычно определяется при использовании libc?
По умолчанию с точки зрения [линкера](http://en.wikipedia.org/wiki/Linker_%28computing%29) именно `_start`, а не `main`, является настоящей точкой входа в программу. Обычно `_start` определяется в перемещаемом [ELF](http://en.wikipedia.org/wiki/Executable_and_Linkable_Format) `crt1.o`. Убедимся в этом, слинковав хелловорлд c `crt1.o` и заметив, что `_start` теперь обнаруживается (но взамен появились другие проблемы из-за того, что не определены другие startup symbols libc):
```
# компилируем исходники не линкуя
jesstess@kid-charlemagne:~/c$ gcc -Os -c hello.c
# теперь попытаемся слинковать
jesstess@kid-charlemagne:~/c$ ld /usr/lib/crt1.o -o hello hello.o
/usr/lib/crt1.o: In function `_start':
/build/buildd/glibc-2.9/csu/../sysdeps/x86_64/elf/start.S:106: undefined reference to `__libc_csu_fini'
/build/buildd/glibc-2.9/csu/../sysdeps/x86_64/elf/start.S:107: undefined reference to `__libc_csu_init'
/build/buildd/glibc-2.9/csu/../sysdeps/x86_64/elf/start.S:113: undefined reference to `__libc_start_main'
```
Проверка сообщила, что на этом компьютере`_start` живет в исходнике libc: `sysdeps/x86_64/elf/start.S`. Этот восхитительно комментированный файл экспортирует символ `_start`, инициализирует стек, некоторые регистры и вызывает `__libc_start_main`. Если посмотреть в самый низ `csu/libc-start.c`, можно увидеть вызов `_main` нашей программы:
```
/* Ничего особенного, просто вызвать функцию */
result = main (argc, argv, __environ MAIN_AUXVEC_PARAM);
```
… и поехало.
Так вот зачем нужен `_start`. Для удобства подытожим происходящее между `_start` и вызовом `main`: инициализировать кучу вещей для libc и вызвать `main`. А раз libc нам не нужен, экспортируем собственный символ `_start`, который только и умеет, что вызывать `main`, и слинкуем с ним:
```
jesstess@kid-charlemagne:~/c$ cat stubstart.S
.globl _start
_start:
call main
```
Скомпилируем и выполним хелловорлд с ассемблерной заглушкой `_start`:
```
jesstess@kid-charlemagne:~/c$ gcc -nostdlib stubstart.S -o hello hello.c
jesstess@kid-charlemagne:~/c$ ./hello
Segmentation fault
```
Ура, с компиляцией проблем больше нет. Но сегфолт никуда не делся. Почему? Скомпилируем с отладочной информацией и заглянем в gdb. Установим брейкпоинт на `main` и пошагово исполним программу до сегфолта:
```
jesstess@kid-charlemagne:~/c$ gcc -g -nostdlib stubstart.S -o hello hello.c
jesstess@kid-charlemagne:~/c$ gdb hello
GNU gdb 6.8-debian
Copyright (C) 2008 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law. Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-linux-gnu"...
(gdb) break main
Breakpoint 1 at 0x4000f4: file hello.c, line 3.
(gdb) run
Starting program: /home/jesstess/c/hello
Breakpoint 1, main () at hello.c:5
5 char *str = "Hello World";
(gdb) step
6 return 0;
(gdb) step
7 }
(gdb) step
0x00000000004000ed in _start ()
(gdb) step
Single stepping until exit from function _start,
which has no line number information.
main () at helloint.c:4
4 {
(gdb) step
Breakpoint 1, main () at helloint.c:5
5 char *str = "Hello World";
(gdb) step
6 return 0;
(gdb) step
7 }
(gdb) step
Program received signal SIGSEGV, Segmentation fault.
0x0000000000000001 in ?? ()
(gdb)
```
Что? `main` исполняется два раза? …Пришло время взяться за ассемблер:
```
jesstess@kid-charlemagne:~/c$ objdump -d hello
hello: file format elf64-x86-64
Disassembly of section .text:
00000000004000e8 <_start>:
4000e8: e8 03 00 00 00 callq 4000f0
4000ed: 90 nop
4000ee: 90 nop
4000ef: 90 nop
00000000004000f0 :
4000f0: 55 push %rbp
4000f1: 48 89 e5 mov %rsp,%rbp
4000f4: 48 c7 45 f8 03 01 40 movq $0x400103,-0x8(%rbp)
4000fb: 00
4000fc: b8 00 00 00 00 mov $0x0,%eax
400101: c9 leaveq
400102: c3 retq
```
Хех! Подробный разбор ассемблера оставим на потом, отметив вкратце следующее: после возврата из `callq` в `main` мы исполняем несколько `nop` и возвращаемся прямо в `main`. Поскольку повторный вход в `main` был осуществлен без установки указателя инструкции возврата на стеке (как части стандартной подготовки к вызову функции), второй вызов `retq` пытается достать из стека фиктивный указатель инструкции возврата и программа вылетает. Нужен способ завершения.
Буквально. После возврата из `callq` в `%eax` делается push `1`, [код системного вызова](http://git.kernel.org/?p=linux/kernel/git/torvalds/linux-2.6.git;a=blob;f=arch/x86/include/asm/unistd_32.h;h=3baf379fa8402a0df08a1ea6ab7f388e3fdac081;hb=60b341b778cc2929df16c0a504c91621b3c6a4ad) `sys_exit`, и т.к. нужно сообщить о правильном завершении кладем в `%ebx 0`, единственный аргумент `SYS_exit`. Теперь входим в ядро с прерыванием `int $0x80`.
```
jesstess@kid-charlemagne:~/c$ cat stubstart.S
.globl _start
_start:
call main
movl $1, %eax
xorl %ebx, %ebx
int $0x80
jesstess@kid-charlemagne:~/c$ gcc -nostdlib stubstart.S -o hello hello.c
jesstess@kid-charlemagne:~/c$ ./hello
jesstess@kid-charlemagne:~/c$
```
Ура! Программа компилируется, запускается, при прогоне через gdb даже нормально завершается.
Привет из свободного от libc мира!
Оставайтесь со мной, во второй части разберем ассемблерный код подробно, посмотрим что случится, если сделать программу более сложной, и еще немного разберемся в линковании, соглашениях о вызовах и структуре двоичного ELF файл в х86 архитектуре. | https://habr.com/ru/post/88101/ | null | ru | null |
# IPTables и удаленный доступ в сеть
Итак, сеть настроена, пакеты ходят, интернет работает, права режутся — в общем момент, когда можно перевести дух и заняться «доводкой» сервера для удобства не пользователя, но администратора. А что хочется правильному системному администратору? Конечно же! Чтобы его рабочие обязанности отнимали у него как можно меньше свободного времени. А что для этого служит лучше всего — естественно удаленный доступ.
Сегодня этим уже никого не удивишь — безлимитный интернет есть уже практически у всех, так что доступ к любимому серверу можно получить откуда угодно.
А что делать, если за одним IP-адресом «скрыта» обширная сеть с несколькими серверами, к каждому из которых может понадобиться доступ?
Естественно существует вариант установить что-нибудь вроде Radmin на каждый из них, и использовать один как «перевалочную базу». Однако Radmin не всегда может помочь — нужен полноценный «родной» терминал. Как поступить в таком случае? Нужно просто ввести разницу, на какой порт обращаться.
Немного опишу структуру сети, о которой пойдет речь. Внешний IP — один. Собственно к ADSL-модему подключен «шлюзовой» сервер под управлением Linux, второй интерфейс сервера — подключен в сеть. Интернет раздается на несколько подсетей, в каждой из которых стоит по серверу, на который можно зайти по RDP.
Примем за 192.168.100.1 — адрес внешнего интерфейса шлюзового сервера. eth0 — «внутренний» интерфейс, eth1 — «внешний». 192.168.1.1 — адрес первого сервера, 192.168.2.1 — второго, и т.д.
Я думаю, не стоит подробно описывать процесс правки правил IPTABLES. Поэтому сконцентрируемся на том, как дать доступ извне на несколько серверов.
Для начала нужно пробросить порты с ADSL-модема на сервер. Определяемся сколько нам их нужно. Например, шесть — настраиваем на проброс порты с 3384 по 3389.
Далее, нам нужно лишь обработать пакет, который примет модем, и отправить его на нужный нам сервер:
`iptables -t nat -A PREROUTING -p tcp -d 192.168.100.1 --dport 3385 -j DNAT to-destination 192.168.2.1:3389
iptables -t nat -A PREROUTING -p tcp -d 192.168.100.1 --dport 3386 -j DNAT to-destination 192.168.3.1:3389
iptables -t nat -A PREROUTING -p tcp -d 192.168.100.1 --dport 3389 -j DNAT to-destination 192.168.1.1:3389`
`iptables -A FORWARD -i eth1 -o eth0 -d 192.168.1.1 -p tcp --dport 3389 -j ACCEPT
iptables -A FORWARD -i eth1 -o eth0 -d 192.168.2.1 -p tcp --dport 3389 -j ACCEPT
iptables -A FORWARD -i eth1 -o eth0 -d 192.168.3.1 -p tcp --dport 3389 -j ACCEPT`
Что у нас получается? Если мы запустим RDP-клиент на внешний адрес модема — шлюз пробросит его на нужный сервер внутри сети, ориентируясь по портам. Если укажем адрес подключения без указания порта — подключимся на сервер 192.168.1.1.
Способ не идеальный, но вполне рабочий. А главное простой и не требует каких-либо усилий для реализации.
Благодарю за внимание. Буду рад, если кому-то это пригодится. | https://habr.com/ru/post/82559/ | null | ru | null |
# OTRS 4.0.10. Ставим на Ubuntu + AD + Kerberos + SSO (Часть первая)
Вииду того, что статья и так получилась слишком большая, а к тому же хочеться добавить к ней её пару нюансов разбиваю её на несколько частей, и дальнейшие дополнения буду публиковать как отдельные части.
[Часть первая: подготовка системы](http://habrahabr.ru/post/264617/)
[Часть вторая: установка и настройка OTRS](http://habrahabr.ru/post/265537/)
[Часть третья: исправляем косяки прикручиваем плюшки](http://habrahabr.ru/post/265541/)
#### Вместо введения
Любая достаточно крупная организация рано или поздно сталкивается с необходимостью внедрения системы тикетов или helpdesk. И наша организация не исключение, в связи с чем руководством была поставлена задача выбрать и внедрить систему.
Откровенно говоря сомнений по поводу выбора особых не было, по личным соображениям выбор пал на OTRS. Мощная и гибкая с огромным количеством отчётов, которые так любит руководство. Но как оказалось внедрить её совсем нетривиальная задача. Мучения продолжались две недели, были перелопачены тонны инофрмации, перепробовано куча различных мануалов, и складывалось впечатление, что я либо полный кретин, либо одно из двух, потому как во всех мануалах и в куче отзывов все в один голос утверждали что всё работает и отлично ставиться и настраивается, а у меня ни как.
На самом деле проблема всех этих мануалов в том, что всё вроде бы так же как у тебя, но где-то чуть-чуть не та версия пакета, чуть чуть не такая структура AD и т. д. Вот из-за всех этих чуть чуть и не складывается цветок каменный. Одним словом методом проб и ошибок, чтений документации и анализа мануалов был выработан свой, вполне рабочий метод, который я и хотел бы изложить.
#### Исходные данные и требования
* В организации поднят AD на двух контроллерах Win2008r2 и раз уж так, то нужна интеграция с AD, т. к. на мой взгляд интеграция всего и вся особенно с LDAP «is the true way»
* Много сервисов (такие как почта и Jabber) подняты на Linux, и в качестве ОС выбрана Ubuntu Server 14.04, и раз уж OTRS это OpenSource, то ставить её на проприетарную ОС это на мой взгляд моветон, поэтому будем ставить на Ubuntu. Кстати если будет интересно в следующих статьях попробуем расскажу о своем опыте поднятия этих сервисов и интеграции их c AD и OTRS. (Интеграция OTRS и Jabber вообще очень класная и полезная штука)
* Возможность быстро поднять на машине файлопомойку для сканирования служебок и пр.
* И последнее, раз у нас есть AD, и при включении компьютера пользователь все равно вводит свой пароль и система уже на этом этапе знает кто работает в системе, то надо бы избавить его лишних вводов паролей и логинов и реализовать сквозную авторизацию.
Вот стандартный набор требований, как я уже и сказал в сети работает корпоративная почта и Jabber, и доп требованием было интегрировать OTRS и с ними тоже. Но так-как статья и так получилась огромная об интеграции OTRS с ними расскажу когда буду писать о них.
На самом деле ставиться OTRS не сложно и даже с AD интегрируется на раз, вся загвоздка была именно в сквозной авторизации или (SSO). В сети было найдено куча мануалов на этот счёт, но ни один мне не подошел по разным причинам, в одном OTRS ставился на Windows, в другом слишком старая версия OTRS, в третьем использовался модуль-адаптер писанный неизвестно кем и когда.
В целом скажу, что есть 4 способа реализации сквозной авторизации.
1. Первый это SSPI, но он не подходит, потому как это модуль для OTRS под Windows
2. Второй это самописный модуль ADSSO, по сути просто допиленный модуль авторизации LDAP, что на мой взгляд костыль.
3. Третий это опять же самописный модуль NTLM авторизации для OTRS, что опять же костыль.
4. И последний — это штатный модуль OTRS HTTPBasicAuth в компании с Kerberos аутентификацией.
Вот последний как раз на мой взгляд (и думаю со мной многие согласятся) самый правильный и безопасный. Итак, исходные данные:
* Сеть 192.168.0.0/16
* Домен DOMAIN.RU
* Контроллеры домена на них же и DNS и NTP
* PDC — ad1.domain.ru (192.168.10.1)
* SDC — ad2.domain.ru (192.168.10.2)
* GATE 192.168.10.10
* Все пользователи домена находятся в организейшн юнит ORGANIZATION внутри которого раскиданы по группам.
* Создана группа OTRSagents, в которую включены сервисники, то есть те кто принимает заявки (в терминологии OTRS «Агенты»).
* Клиентами, то есть теми кто отправляет заявки (в терминологии OTRS «Кустомер») будут все пользователи домена без исключения.
Иная конфигурация тоже возможна из конфига OTRS вы сами поймете как его настроить на другие расположения пользователей и агентов.
Сервер OTRS будет читать информацию из LDAP от имени пользователя otrs.admin, на период настройки дадим ему права администратора домена, после настройки отберём и их и даже право логинеться на машинах, ему нужно просто иметь возможность читать информацию из LDAP.
#### 1.Подготовка системы
##### 1.1 Ставим Ubuntu Server с такими настройками (это мои настройки, у вас могут быть другие)
* IP: 192.168.10.14
* MASK: 255.255.0.0
* GATE: 192.168.10.10
* DNS: 192.168.10.1 192.168.10.2 8.8.8.8
* NAME: HELPDESK
* USER: helpdesk
* PASS: strongpass
На финальном этапе установка спросит хотим ли мы предустановить какое-то ПО, выбираем установку OpenSSH сервер.
##### 1.2. Цепляемся по SSH к новому серверу
```
ssh 192.168.10.14 -l helpdesk
```
Соглашаемся принять ключик и вводим пароль пользоваетля helpdesk
Повышаем права до root
```
sudo su
```
**! ВНИМАНИЕ! Все дальнейшие действия выполняем от su и после перезагрузок системы не забываем опять поднять права до root.**
Проверяем актуальность информации в файлах */etc/hostname* и */etc/hosts*: в первом должно быть имя нашей машины большими буквами, во втором должна быть запись типа: *127.0.0.1 helpdesk.domain.ru helpdesk*
Если что-то не так — исправляем. Теперь пробуем пинговать все контроллеры домена по IP, полному и сокращенному имени. Должны пинговаться по всякому. Если нет, разбираемся с настройками сети.
##### 1.3. Обновляемся и ставим mc
```
apt-get update && apt-get -y upgrade && apt-get install -y mc
```
для не искушенных можно выполнить команды по очереди
```
apt-get update
apt-get -y upgrade
apt-get install -y mc
```
#### 2. Вводим машину в домен и настраиваем доменную авторизацию. Настраиваем Samba, Kerberos и Winbind.
Отличная статья по этому поводу есть на сайте техподдержки Ubuntu: [help.ubuntu.ru/wiki/%D0%B2%D0%B2%D0%BE%D0%B4\_%D0%B2\_%D0%B4%D0%BE%D0%BC%D0%B5%D0%BD\_windows](http://help.ubuntu.ru/wiki/%D0%B2%D0%B2%D0%BE%D0%B4_%D0%B2_%D0%B4%D0%BE%D0%BC%D0%B5%D0%BD_windows)
##### 2.1. Ставим и настраиваем Kerberos
Ставим необходимые пакеты:
```
apt-get install krb5-user samba winbind libpam-krb5 libpam-winbind libnss-winbind ntp smbclient rlwrap
```
Для работы Kerberos очень важно что бы часы на компьютерах шли синхронно и разница во времени не превышала 5 минут. Настраиваем синхронизацию времени с контролером домена в файле */etc/ntp.conf*
Как понятно из названия файл отвечает за настройки демона *ntp*, который периодически проводит подстройку системных часов. Сервер точного времени задается директивой *server*, так что нам надо закомментировать все строчки с указанием серверов точного времени которые там есть и вписать свои.
```
mcedit /etc/ntp.conf
```
Комментируем все срочки начинающиеся на server:
```
#server 0.ubuntu.pool.ntp.org
#server 1.ubuntu.pool.ntp.org
#server 2.ubuntu.pool.ntp.org
#server 3.ubuntu.pool.ntp.org
# Use Ubuntu's ntp server as a fallback.
#server ntp.ubuntu.com
```
И вписываем свои:
```
server 192.168.10.1
server 192.168.10.2
```
У меня два контроллера домена и на каждом поднята служба точного времени. После этого сохраняем файл и перезапускаем демона с новыми настройками:
```
service ntp restart
```
Вывод должен быть таким:
```
root@HELPDESK:/home/helpdesk# service ntp restart
* Stopping NTP server ntpd [ OK ]
* Starting NTP server ntpd [ OK ]
```
Демон запустился с новыми настройками и синхронизирует часы. Настройка керберос происходит путем правки файла *krb5.conf*:
```
mcedit /etc/krb5.conf
```
Перво наперво включим логи, для этого добавим в самое начало файла секцию:
```
[logging]
default = FILE:/var/log/krb5libs.log
kdc = FILE:/var/log/krb5kdc.log
admin_server = FILE:/var/log/kadmind.log
```
А дальше надо объяснить kerberos в каком домене (в терминологии Kerberos — в каком реалме) он работает и кто этим реалмом рулит. Для этого правим секции:
```
[libdefaults]
default_realm = DOMAIN.RU #(Вписываем свой домен большими буквами)
[realms] #Добавляем информацию о контроллерах
DOMAIN.RU = { #домена. Думаю всё понятно. Если в сети
kdc = ad1.domain.ru #несколько контроллеров то вписываем их
kdc = ad2.domain.ru #все. Лишним не будет, как мне кажется
admin_server = ad1.domain.ru
admin_server = ad2.domain.ru
default_domain = domain.ru
}
[domain_realm] #Здесь мы сообщаем о возможных
.domain.ru = DOMAIN.RU #псевдонимах нашего домена(реалма)
domain.ru = DOMAIN.RU
```
Теперь надо проверить работоспособность нашего конфига, для этого попытаемся получить тикет kerberos в домене для какого-нибудь пользователя:
```
kinit username@DOMAIN.COM #здесь username — любой пользователь домена, !имя домена заглавными!
```
После чего она запросит пароль и попытается получить тикет. Если всё прошло успешно, то команда промолчит, то есть вывод будет пустой. Как-то так:
```
root@HELPDESK:/home/helpdesk# kinit otrs.admin@DOMAIN.RU
Password for otrs.admin@DOMAIN.RU:
root@HELPDESK:/home/helpdesk#
```
Проверим, получили ли мы тикет, вводим:
```
klist
```
И видим что-то такое:
```
root@HELPDESK:/home/helpdesk# klist
Ticket cache: FILE:/tmp/krb5cc_0
Default principal: test@DOMAIN.RU
Valid starting Expires Service principal
10.08.2015 15:46:01 11.08.2015 01:46:01 krbtgt/DOMAIN.RU@DOMAIN.RU
renew until 11.08.2015 15:45:57
```
Как видно, тикет мы получили успешно и всё ОК. Значит конфиг работает. Теперь грохнем тикет, пока что он нам не нужен.
```
Kdestroy
```
Вывод так же пустой, и значит тикет уничтожился (обратите внимание, команда уничтожает ВСЕ тикеты находящиеся в кеше).
##### 2.2 Пора настроить SAMBA и подключиться к домену.
Для этого правим файл */etc/samba/smb.conf*:
```
mcedit /etc/samba/smb.conf
```
Здесь правим секцию [global]:
```
[global]
# Эти две опции нужно писать именно в заглавном регистре, причём workgroup без
# последней секции после точки, а realm - полное имя домена
workgroup = RUS
realm = DOMAIN.RU
# Эти две опции отвечают как раз за авторизацию через AD
security = ADS
encrypt passwords = true
# Просто важные
dns proxy = no
socket options = TCP_NODELAY
# Если вы не хотите, чтобы самба пыталась при случае вылезти в лидеры в домене или рабочей группе,
# или даже стать доменконтроллером, то всегда прописывайте эти пять опций именно в таком виде
domain master = no
local master = no
preferred master = no
os level = 0
domain logons = no
# Отключить поддержку принтеров
load printers = no
show add printer wizard = no
printcap name = /dev/null
disable spoolss = yes
```
Проверяем корректность конфигурации коммандой:
```
testparm
```
Вывод будет приблизительно такой:
```
Load smb config files from /etc/samba/smb.conf
rlimit_max: increasing rlimit_max (1024) to minimum Windows limit (16384)
Processing section "[printers]"
Processing section "[print$]"
Loaded services file OK.
Server role: ROLE_DOMAIN_MEMBER
Press enter to see a dump of your service definitions
```
Нажав Enter, мы увидем скомпилированный *smb.conf* (то есть без комментариев):
Cообщение *«rlimit\_max:increasing rlimit\_max(1024) to minimum Windows limit(16384)»* возникает из-за разницы пула лимитов между Windows и Ubuntu, мы избавимся от него чуть позже, когда поправим лимиты.
Теперь пробуем неспосредственно войти в домен. Для этого исполняем комманду:
```
net ads join -U username -D DOMAIN #username - администратор домена
```
Она сначала запросит пароль пользователя и в случае если всё ОК, то вывод будет типа этого:
```
Using short domain name -- RUS
Joined 'HELPDESK' to dns domain 'domain.ru'
```
Проверить корректность подключения к домену можно коммандой:
```
net ads testjoin
```
Её вывод должен быть таким:
```
Join is OK
```
Проверить правильность настройки на этом этапе можно попробовав проиндексировать общие ресурсы любой машины в домене. Получаем билет:
```
kinit username@DOMAIN.COM
```
И пробуем посмотреть ресурсы любой машины, например файл-сервера:
```
smbclient -k -L //File-server
```
Ключик -k говорит, что нужно использовать kerberos, *File-server* — имя машины в домене имеющей расшареные ресурсы. В выводе команды вы должны увидеть список общих ресурсов указанной машины, если да, всё — ок, до настоящего момента всё сделано правильно. После чего уничтожаем тикеты командой:
```
kdestroy
```
##### 2.3 Настраиваем Winbind
Для этого правим всё тот же */etc/samba/smb.conf* и добавляем в секцию [global] следующие строки:
```
# Опции сопоставления доменных пользователей и виртуальных пользователей в системе через Winbind.
# Диапазоны идентификаторов для виртуальных пользователей и групп.
idmap config * : range = 10000-20000
idmap config * : backend = tdb
# Эти опции не стоит выключать.
winbind enum groups = yes
winbind enum users = yes
# Использовать домен по умолчанию для имён пользователей. Без этой опции имена пользователей и групп
# будут использоваться с доменом, т.е. вместо username - DOMAIN\username.
# Возможно именно это вам и нужно, однако обычно проще этот параметр включить.
winbind use default domain = yes
# Если вы хотите разрещить использовать командную строку для пользователей #домена, то добавьте следующую строку, иначе в качестве shell'а будет вызываться #/bin/false
template shell = /bin/bash
# Для автоматического обновления билета Kerberos модулем pam_winbind.so нужно добавить строчку
winbind refresh tickets = yes
# Так же надо объяснить самбе что она теперь будет пользоваться kerberos
# аутентификацией и показать где лежит ключик (его мы создадим на следеющем
# шаге), а для этого после строки «passdb backend = tdbsam» добавляем ещё две:
kerberos method = system keytab
dedicated keytab file = /etc/krb5.keytab
```
Проверяем корректность нашей конфигурации:
```
testparm
```
И если всё ок, перезапускаем демоны (именно в такой последовательности):
```
service winbind stop
service smbd restart
service winbind start
```
Если сервисы перезапустились нормально вывод будет приблизительно такой:
```
root@HELPDESK:/home/helpdesk# service winbind stop
winbind stop/waiting
root@HELPDESK:/home/helpdesk# service smbd restart
smbd stop/waiting
smbd start/running, process 4859
root@HELPDESK:/home/helpdesk# service winbind start
winbind start/running, process 4871
```
У вас так же? Тогда идём дальше. Пора поправить лимиты, на которые ругается самба. Правятся они в файле*/etc/security/limits.conf*. Надо дописать в конец файла две строчки:
```
* - nofile 16384
root - nofile 16384
```
После этой операции надо перезагрузить машину:
```
shutdown -r now
```
или
```
reboot
```
Кому как нравиться.
После перезагрузки проверяем установила ли наша машина доверительные отношения с доменом:
```
wbinfo -t
```
Вывод должен быть типа этого:
```
checking the trust secret for domain DCN via RPC calls succeeded
```
Напомню, что всё команды выполняются от root'а. Поначалу у меня происходил затык на этом этапе, потому как после ребута забывал повысить права до su. Все секреты (тикеты и пр.) хранятся в базхах самбы /var/lib/samba/private/\*.tdb доступ к которым имеет только root. Так что не забываем после перезагрузок повысить права и все команды выполняем от суперпользователя. Также проверяем, что winbind видит пользователей и группы в домене:
```
wbinfo -u
```
и
```
wbinfo -g
```
##### 2.4. Ну и ещё один бонус
Раз уж вводим машину в домен, добавим и возможность логиниться на машину под доменными учётками. Для этого в файле */etc/nsswitch.conf* добавляем источник данных *winbind*. Это так же даст нам возможность работать с доменными пользователями как с локальными, а значит назначать их владельцами объектов и давать права на доступ. Что даст возможность поднять шары на линуксовой машине. Приводим строки:
```
passwd: compat
group: compat
```
к виду
```
passwd: compat winbind
group: compat winbind
```
Так же рекомендуют добавить в конец файла строчку:
```
files: dns mdns4_minimal[NotFound=return] mdns4
```
Этот этап проверяем запрашивая список пользователей и групп командами:
```
getent passwd
```
и
```
getent group
```
В выводе ищем доменных пользователей и группы и если находим, значит всё ок. И последнее: дадим возможность открывать сессии доменным пользователям, в предыдущих версиях убунту для этого нужны были нетривиальные пляски с ударным инструментом, сейчас же с нашей задачей прекрасно справиться PAM.D, добавляем в файл */etc/pam.d/common-session* строчку:
```
session optional pam_mkhomedir.so skel=/etc/skel/ umask=0077
```
Теперь *reboot* и пробуем залогиниться под доменной учёткой, если получается, значит все предыдущие этапы выполнены правильно.
#### 3. Создаем ключить Kerberos и добавляем принципиала HTTP в домен.
На следующие 3 этапа я потратил 2 недели, пока разобрался что к чему. Как это часто бывает всё оказалось довольно просто и завелось с первого раза, нужно было просто проанализировать тонну информации и свести в единую последовательность действий
На этих трёх этапах мне очень помогла [вот эта статья](http://val-khmyrov.blogspot.ru/2011/04/apache-active-directory-kerberos.html).
Итак, протокол Kerberos, это протокол сетевой аутентификации основанный на принципе доверия третьей стороне, так нам говорит справочник. Что это значит? А это значит, что в процессе аутентификации фигурирует третья сторона, которой поумолчанию доверяют участники взаимодействия, такая сторона называется Key Distribution Center, если проще, прежде чем обратиться к серверу, клиент посылает сообщение KDC, а KDC в свою очередь направляет каждому участнику сеанса копии сеансового ключа, действующие в течение небольшого промежутка времени. Назначение этих ключей – проведение аутентификации клиента и сервера.
Для людей знакомых с криптографией скажу, что весь механизм Kerberos чуть более чем полностью копирует механизм PKI. Фактически это он и есть только заточенный под другие задачи. Только вместо центра сертификации данном случае Центр распространения ключей (KDC). Обычно располагается на контроллере домена.
Новое слово «принципиал», в терминологиий Kerberos так называются участники сетевого взаимодействия, то есть те кто обращаются к KDC за ключами.
Выполнить это шаг можно двумя способами сложным и попроще. Почему то все мануалы в сети описывают более сложный способ, а именно создание ключа Kerberos на контроллере домена при помощи утилиты *ktpass* (страшный зверь с неимоверным количеством ключей) и последующее копирование его на Linux-машину. Я не отрицаю канонической правильности данного пути, но извольте, команда получается в несколько строк и я так и не постиг дзен при её использовании.
Как оказалось есть способ проще — создание ключа непосредственно на Linux-машине. В сетия я нашел только одно упоминание о нём, возможно плохо искал, но он работает.
Так же для того что бы контролировать правильность на данном этапе нам потребуется кое-что сделать на контроллере домена.
Первым делом идём на контроллер и открываем оснастку «AD-пользователи и компьютеры», открываем контейнер с компьютерами и ищем нашу Linux-машину, она должна была там появиться после того как мы её включили в домен. Нашли — ок. Идём дальше.
Теперь нужен редактор ADSI, открываем командную строку, набираем:
```
adsiedit.msc
```
И жмём интер. Видим дерево консоли копирующее по своей структуре консоль AD. Находим тут нашу машину, открываем её свойства и ищем в списке атрибут *servicePrincipalName*. Сейчас там должно быть две записи типа *HOST/hepldesk.domain.ru* и *HOST/helpdesk*.
Обе начинаются на HOST в одной полное в другой сокращенное имя нашей машины, это значит что сейчас наша машина принципиал HOST, то есть рядовая машина в домене.
Теперь идём на Линукс-машины и исполняем команду:
```
net ads keytab create
```
Вывод у команды пустой, но после исполнения должен создаться файл /etc/krb5.keytab, или любой другой, смотря что вы указывали в файле *smb.conf* в директиве *dedicated keytab file.* Но ведь OTRS, это веб-приложение и наша линукс-машина будет предоставлять услуги http, а значит надо добавить ещё принципиала HTTP. Сказано — сделано:
```
net ads keytab add HTTP
```
Если вы теперь посмотрите в список принципалов, в свойствах машины на домене то заметите, что там добавлись еще два — "*HTTP/helpdesk.domain.ru*" и "*HTTP/helpdesk*" (маленький нюанс: информация в окне редактора ADSI не обновляется автоматически, поэтому закрываем свойства машины, жмём F5 и снова их открываем).
В принципе это уже значит что добавление прошло успешно. Тем не менее, давайте посмотрим что сейчас находится в keytab:
```
klist -ek /etc/krb5.keytab #тут вводим ваше имя файла keytab
Keytab name: FILE:/etc/krb5.keytab
KVNO Principal
---- --------------------------------------------------------------------------
2 host/helpdesk.domain.ru@DOMAIN.RU (DES cbc mode with CRC-32)
2 host/helpdesk.domain.ru@DOMAIN.RU (DES cbc mode with RSA-MD5)
2 host/helpdesk.domain.ru@DOMAIN.RU (ArcFour with HMAC/md5)
2 host/helpdesk@DOMAIN.RU (DES cbc mode with CRC-32)
2 host/helpdesk@DOMAIN.RU (DES cbc mode with RSA-MD5)
2 host/helpdesk@DOMAIN.RU (ArcFour with HMAC/md5)
2 HELPDESK$@DOMAIN.RU (DES cbc mode with CRC-32)
2 HELPDESK$@DOMAIN.RU (DES cbc mode with RSA-MD5)
2 HELPDESK$@DOMAIN.RU (ArcFour with HMAC/md5)
2 HTTP/helpdesk.domain.ru@DOMAIN.RU (DES cbc mode with CRC-32)
2 HTTP/helpdesk.domain.ru@DOMAIN.RU (DES cbc mode with RSA-MD5)
2 HTTP/helpdesk.domain.ru@DOMAIN.RU (ArcFour with HMAC/md5)
2 HTTP/helpdesk@DOMAIN.RU (DES cbc mode with CRC-32)
2 HTTP/helpdesk@DOMAIN.RU (DES cbc mode with RSA-MD5)
2 HTTP/helpdesk@DOMAIN.RU (ArcFour with HMAC/md5)
```
Для полной уверенности можно получить Kerberos билет от KDC для только что заведенных принципалов:
```
kvno HTTP/web.domain.ru@DOMAIN.RU HTTP/web@DOMAIN.RU
HTTP/web.domain.ru@DOMAIN.RU: kvno = 2
HTTP/web@DOMAIN.RU: kvno = 2
```
Смотрим билеты командой:
```
klist -e
```
В выводе будет полный список имеющихся в данный момент билетов, и среди них должны быть билеты HTTP, если есть, то всё ок, и если вы не перфекционист, можно переходить к следующему этапу.
А для остальных скажу, я как раз перфекционист и считаю несколько не правильным хранить все ключи в одном файле, давайте ка выделим всё что касательно HTTP в отельный ключевой файл.Сделать это можно с помощью *ktutil*. Расширеных функций редактирования она не поддерживает, поэтому его можно запустить через *rlwrap*.
```
rlwrap ktutil
```
Загружаем сожержимое keytab-файла:
```
ktutil: read_kt /etc/krb5.keytab
```
Просмотрим, что у нас сейчас есть в нём:
```
ktutil: list
```
Нас интересует всё что начинается с HTTP, всё лишнее удаляем:
```
ktutil: delent 1 #Вместо 1 пишем номер удаляемого ключа
```
Должно получится как-то так:
```
ktutil: list
slot KVNO Principal
---- ---- ---------------------------------------------------------------------
1 2 HTTP/helpdesk.domain.ru@DOMAIN.RU
2 2 HTTP/helpdesk.domain.ru@DOMAIN.RU
3 2 HTTP/helpdesk.domain.ru@DOMAIN.RU
4 2 HTTP/helpdesk.domain.ru@DOMAIN.RU
5 2 HTTP/helpdesk.domain.ru@DOMAIN.RU
6 2 HTTP/HELPDESK@DOMAIN.RU
7 2 HTTP/HELPDESK@DOMAIN.RU
8 2 HTTP/HELPDESK@DOMAIN.RU
9 2 HTTP/HELPDESK@DOMAIN.RU
10 2 HTTP/HELPDESK@DOMAIN.RU
```
Теперь сохраним всё что осталось в отдельный файл:
```
ktutil: write_kt /etc/httpd.keytab
```
И выходим из утилиты:
```
quit
```
#### 4. Ставим Apache2 и модули. (LAMP) + Perl
Отличный мануал по настройке сервисов в Ubuntu 14 [вот тут](http://www.server-world.info/en/note?os=Ubuntu_14.04&p=install).
Вот не знаю как для вас, а для меня если веб-сервер, то **LAMP**, так что ставим весь стек сразу, тем более что MySQL и Apache нам и так нужно, а в php есть удобная функция *phpinfo();* с помощью которой мы будем мониторить переменные окружения.
###### Итак, поехали. Ставим Apache
```
apt-get install mysql-server apache2 php5 libapache2-mod-php5 libapache2-mod-auth-mysql php5-mysql php5-cgi libapache2-mod-php5 php5-common php-pear
```
Во время установки *mysql-server* он попросит задать пароль для суперпользователя mysql (*root@localhost*), попрошу не путать с суперпользователем системным, хоть они и оба *root*, это разные пользователи. Хотя никто не запрещает указать одинаковые пароли для них. Так вот указываем этот пароль и запоминаем его, он нам ещё будет нужен.
После того как поставятся все пакеты нам надо будет сразу немного настроить MySQL, для этого открываем файл */etc/mysql/my.cnf*:
```
mcedit /etc/mysql/my.cnf
```
Находим в файле две строчки с указанием максимального размера принимаемых пакетов. Строчки начинаются *max\_allowed\_packet*. По умолчанию этот артибут выставлен в 16 мегабайт, меняем на 20 Мб в обеих строчках:
```
max_allowed_packet = 20M
```
А также надо изменить размер лог-файла *innodb*, насколько я понял это аналог лога транзакций в MS SQL. Для этого надо найти такую строку:
```
# * InnoDB
```
И добавить после неё ещё одну строчку следующего содержания:
```
innodb_log_file_size = 512M
```
Можно сделать и побольше, но OTRS рекомендует именно такой объем. Теперь маленький нюанс: пока старые лог-файлы есть, MySQL не сможет создать новые файлы и соответственно увеличить их объем, поэтому идем в папку */var/lib/mysql* и удаляем или перемещаем куда ни будь (лучше переместит, удалить всегда успеем) два файла с именами типа *ib\_logfile0 и ib\_logfile1*.
Теперь перезапускаем MySQL:
```
service mysql restart
```
Проверяем что на месте старых лог-файлов создались новые увеличенного объема, значит всё ОК. После этого открываем браузер на соседней машине и заходим по адресу *[helpdesk](http://helpdesk)*, должна открыться стартовая страница Apache2. Открылась? Значит всё ок —Apache установлен.
###### Теперь Perl.
`apt-get install perl libapache2-mod-perl2 libdbd-mysql-perl libnet-dns-perl libnet-ldap-perl libio-socket-ssl-perl libpdf-api2-perl libsoap-lite-perl libgd-text-perl libgd-graph-perl libapache-dbi-perl libyaml-libyaml-perl`
Объясним Апачу что делать со скриптами PHP и PERL, для этого в файле */etc/apache2/mods-enabled/mime.conf* раскоментируем 220-ую строчку AddHandler и приведём её к виду:
```
AddHandler cgi-script .cgi .pl
```
А так же добавим за ней ещё одну такого вида:
```
AddHandler php5-script .php
```
Теперь включаем модули php5, perl и cgi, а затем перезапустим Apache:
```
a2enmod php5
a2enmod perl
a2enmod cgi
service apache2 restart
```
Теперь проверим, всё ли работает. Для этого создадим две дирректории в */var/www/html*:
```
mkdir /var/www/html/php
mkdir /var/www/html/perl
```
И создадим по тестовому файлу в каждой:
```
touch /var/www/html/php/index.php
touch /var/www/html/perl/index.cgi
```
Первый файл (index.php) мы заполняем следующим образом:
```
cat /var/www/html/php/index.php
php
print Date("Y/m/d");
echo "<brPath :".$\_SERVER['PHP\_SELF'];
echo "
Remote User :".$\_SERVER['REMOTE\_USER'];
echo "
Auth type :".$\_SERVER['AUTH\_TYPE'];
echo "
Auth User :".$\_SERVER['PHP\_AUTH\_USER'];
?>
php
phpinfo();
?
``` | https://habr.com/ru/post/264617/ | null | ru | null |
# User Timing API
*Это перевод [статьи](http://www.html5rocks.com/en/tutorials/webperformance/usertiming/) Alex Danilo о User Timing API, опубликованной 21 января 2014.*
Высокая производительность веб-приложений является решающей для достижения хорошего user experience. В то время, как веб-приложения становятся все более сложными, понимание влияния производительности жизненно небходимо для создания конкурентноспособного user experience. За последние несколько лет в браузерах появились различные API, позволяющие анализировать производительность сети, время загрузки и т.д., но они не предоставляют необходимую информацию с достаточной гибкостью для поиска проблем, которые замедляют приложение. Использование [User Timing API](http://www.w3.org/TR/user-timing/) предоставляет механизм, позволяющий определить какая часть вашего приложения является наиболее медленной. В этой статье будет показана работа с User Timing API и примеры его использования.
##### Вы не можете оптимизировать то, что не можете измерить
Первый шаг в ускорении веб-приложения — это понимание того, где происходят потери времени. Измерение времени, затраченного на выполнение отдельных частей Javascript-кода — идеальный путь для определения горячих точек, а это — первый шаг в понимании того, как улучшить производительность. К счастью, [User Timing API](http://www.w3.org/TR/user-timing/) предоставляет способ внедрения вызовов API в различные участки кода с последующим получением детальной информации о времени выполнения.
##### High Resolution time и 'now()'
Точность — это основа верного измерения времени. Некогда можно было довольствоваться миллисекундной точностью измерения, но разработка сайта способного отрисовыватся со скоростью 60 FPS означает, что каждый фрейм должен быть отрендерен за 16мс. То есть, миллисекундной точности недостаточно для качественного анализа. Так был введен [High Resolution Time](http://www.w3.org/TR/hr-time/), новый тип измерения времени, встроенный в современные браузеры. High Resolution Time предоставляет timestamps в формате с плавающей точкой, что позволяет проводить измерения с точностью до микросекундного уровня — в тысячи раз лучше, чем ранее.
Чтобы получить текущее время в веб-приложении, вызовите метод '[now()](http://www.w3.org/TR/hr-time/#dom-performance-now)', [расширение](http://www.w3.org/TR/hr-time/#sec-extenstions-performance-interface) интерфейса [Performance](http://www.w3.org/TR/navigation-timing/#performance):
```
var myTime = window.performance.now();
```
Существует еще один интерфейс — [PerformanceTiming](http://www.w3.org/TR/navigation-timing/#sec-navigation-timing-interface), предоставляющий дополнительную информацию о том, как загружается приложение. Метод 'now()' возвращает время, прошедшее с момента, когда произошло событие [navigationStart](http://www.w3.org/TR/navigation-timing/#dom-performancetiming-navigationstart) в PerformanceTiming.
##### Тип DOMHighResTimeStamp
При попытке профайлинга веб-приложений в прошлом, скорее всего пришлось бы иметь дело с чем-то вроде Date.now(), который возвращает [DOMTimeStamp](http://www.w3.org/TR/DOM-Level-3-Core/core.html#Core-DOMTimeStamp). DOMTimeStamp представляет собой целое число миллисекунд. Для обеспечения более высокой точности, был введен новый тип [DOMHighResTimeStamp](http://www.w3.org/TR/hr-time/#sec-DOMHighResTimeStamp). Он является типом с плавающей запятой, также представляющим время в миллисекундах. Но, в силу своего типа, значение может представлять дробные части миллисекунд и дает возможность получить точность до одной тысячной миллисекунды.
##### Интерфейс User Timing
Теперь, имея в своем распоряжении отметки High Resolution time, можно воспользоваться интерфейсом User Timing для получения информации. Интерфейс User Timing предоставляет функции, позволяющие вызывать методы в различных местах нашего приложения, оставляя хлебные крошки подобно Гензелю и Гретель, чтобы отследить, где же происходят временные затраты.
##### Использование 'mark()'
Метод '[mark()](http://www.w3.org/TR/user-timing/#dom-performance-mark)' является основным инструментом в инструментарии временного анализа. Mark() позволяет сохранять временную метку. Особенно полезным является возможность именования временных меток.
Вызов mark() в различных участках кода, позволит определить сколько времени потребовалось, чтобы достичь этой метки.
Спецификация предусматривает ряд предопределенных меток, которые могут полезны — 'mark\_fully\_loaded', 'mark\_fully\_visible', 'mark\_above\_the\_fold'» и т.д.
Например, можно установить метку для определения момента полной загрузки приложения, используя следующий код:
```
window.performance.mark('mark_fully_loaded');
```
Установка именованных меток в веб-приложении поможет собрать больше информации о времени выполнения для анализа существующих временных затрат.
##### Расчет измерений с 'measure() '
Как только временные метки установлены, нужно измерить время, затраченное на выполнения приложения между ними. Для этого предназначен метод '[measure()](http://www.w3.org/TR/user-timing/#dom-performance-measure)'. Он также способен вычислить затраченное время между временными метками и любым известным событием в интерфейсе PerformanceTiming.
Например, можно измерить время между полной загрузкой DOM и моментом, когда ваше приложение полностью загружено:
```
window.performance.measure('measure_load_from_dom', 'domComplete', 'mark_fully_loaded');
```
*Примечание: в этом примере передается имя события "[domComplete](http://www.w3.org/TR/navigation-timing/#dom-performancetiming-domcomplete)" из интерфейса [PerformanceTiming](http://www.w3.org/TR/navigation-timing/#sec-navigation-timing-interface).*
Вызов measure() сохраняет результат измерения доступным для дальнейшего получения. Сохраняя данные во время работы, приложение остается работоспособным и данные могут быть получены позднее, после окончания работы.
##### Удаление меток с помощью ‘clearMarks()’
Иногда полезно иметь возможность избавиться от меток, которые уже созданы. Например, это может понадобится при проведении пакетных запусков приложения в рамках профайлинга, когданеобходимо обнулить результаты перед каждым запуском. С помощью вызова '[clearMarks()'](http://www.w3.org/TR/user-timing/#dom-performance-clearmarks) легко избавиться от любых меток, которые были установлены.
Этот код удалит все существующие отметки:
```
window.performance.clearMarks();
```
Конечно, есть некоторые ситуации, в которых не следует удалять все временные отметки. Если необходимо избавиться от конкретных меток, следует просто передать имя отметки, которую нужно удалить. Например, приведенный ниже код, удалит установленную в первом примере отметку, оставив все остальные:
```
window.peformance.clearMarks('mark_fully_loaded');
```
Возможно, также необходимо удалить сделанные ранее измерения, для того существует соответствующий метод 'clearMeasures()'. Принцип работы аналогичен clearMarks(), но вместо отметок удаляются измерения. Например, следующий код удалит измерения, установленные в предыдущем примере о measure():
```
window.performance.clearMeasures('measure_load_from_dom');
```
Если необходимо удалить все измерения, то следует просто вызвать clearMeasures() без аргументов.
##### Получение данных
Возможность устанавливать отметки и измерения полезна, но в какой-то момент появится необходимость получить данные для последующего анализа. Это также легко сделать, — все, что вам нужно, это использовать интерфейс [PerformanceTimeline](http://www.w3.org/TR/performance-timeline/#sec-performance-timeline).
Например, метод '[getEntriesByType()](http://www.w3.org/TR/performance-timeline/#dom-performance-getentriesbytype)' позволяет получить все временные метки или змерения в виде списка, для последующего перебора и выборки информации. Список составлен в хронологическом порядке, так что метки представлены в порядке их размещения в веб-приложении.
Приведенный ниже код возвращает список всех отметок, которые существуют в приложении:
```
var items = window.performance.getEntriesByType('mark');
```
В то время как следующий код, возвращает список всех измерений:
```
var items = window.performance.getEntriesByType('measure');
```
Также можно получить список именованных отметок. Например, следующий код вернет список с одной записью, содержащей отметку 'mark\_fully\_loaded' в свойстве startTime.
```
var items = window.performance.getEntriesByName('mark_fully_loaded');
```
##### Тестирование XHR-запроса (пример)
Теперь, после краткого ознакомления с User Timing API, можно воспользоваться им для анализа длительности [XMLHttpRequest](http://www.w3.org/TR/XMLHttpRequest/) в приложении.
Для начала, следует изменить все запросы [send()](http://www.w3.org/TR/XMLHttpRequest/#the-send()-method), чтобы вызвать установку временных отметок и заменить success callbacks на вызов функции, устанавливающей другую отметку и затем генерирующую измерение продолжительности запроса.
Обычный XMLHttpRequest будет выглядеть примерно так:
```
var myReq = new XMLHttpRequest();
myReq.open('GET', url, true);
myReq.onload = function(e) {
do_something(e.responseText);
}
myReq.send();
```
Для кода же примера, следует добавить глобальный счетчик для отслеживания количества запросов, а также использовать его для хранения измерений для каждого совершенного запроса:
```
var reqCount = 0;
var myReq = new XMLHttpRequest();
myReq.open('GET', url, true);
myReq.onload = function(e) {
window.performance.mark('mark_end_xhr');
reqCount++;
window.performance.measure('measure_xhr_' + reqCnt, 'mark_start_xhr', 'mark_end_xhr');
do_something(e.responseText);
}
```
Этот код генерирует измерения с уникальными именами для каждого посланного XMLHttpRequest. Предполагается, что запросы выполняются последовательно — код для параллельных запросов будет немногим сложнее. Это послужит упражнением для читателя.
После того, как веб-приложение сделало все запросы, можно вывести их в консоль с помощью следующего кода:
```
var items = window.performance.getEntriesByType('measure');
for (var i = 0; i < items.length; ++i) {
var req = items[i];
console.log('XHR ' + req.name + ' took ' + req.duration + 'ms');
}
```
##### Заключение
User Timing API предоставляет много отличных инструментов применимых к любому аспекту вашего веб-приложения. Уменьшение количества «горячих точек» в приложении может быть легко достигнуто с помощью вызовов API по всему приложению и пост-обработки полученных данных для получения картины задержек. Но что, если браузер не поддерживает эту API? Это не проблема, существует [хорошая эмуляция](https://gist.github.com/pmeenan/5902672), которая способна пройти тест [webpagetest.org](http://www.webpagetest.org). Так стоит ли ждать? Стоит попробовать User Timing API прямо сейчас, и появится новая возможность добиться большей производительности, а ваши пользователи скажут спасибо. | https://habr.com/ru/post/210564/ | null | ru | null |
# Яндекс практикум, отзыв мазохиста. Курс Аналитик данных
Прелюдия.
---------
Для справки, мазохизм - получение удовольствия человеком от унижений, мучений или насилия над собой, производимых самим собой или другим лицом.
В 2021 году имел «удовольствие» попасть на курсы от Яндекс Практикума, по гос программе от Цифровых Профессий. Теперь спустя почти год, спешу поделиться общими впечатлениями от прохождения данного курса. Не могу сказать, что курс совершенно бесполезный, но в целом, иначе, как постоянные мучением над самим собой данный курс охарактеризовать не могу. Хочу отметить, что к приверженцам мазохизма я себя не отношу, но закрадываются подобные подозрения в отношении тех, кто пишет восторженные отзывы о курсах от Яндекса. Впрочем, люди разные и о вкусах, как известно, не спорят, а вот о преимуществах и недостатках пройденного курса, я готов рассказать.
Все, что начинается хорошо заканчивается плохо, все что начинается плохо, заканчивается еще хуже. Закон Мерфи.
Рассказ достаточно подробный, если вы хотите сразу перейти к сути, можно просто прокрутить вниз, там будут мои выводы.
Знакомство.
-----------
Первое знакомство с курсами было достаточно радужным, о курсах именно от Яндекса, и именно по работе с данными, я узнал от хорошего знакомого по работе еще в 2020 году. Мы вместе работали в оптовых продажах в одной строительной сфере, знаем друг друга по работе больше десяти лет и, как это часто бывает у «продажников» в неформальной беседе за «сигаретной палкой» мы периодически делились всевозможными новостями и сплетнями. В очередной раз заведя разговор о кардинальной смене направления деятельности мы оба заговорили об IT и именно тогда, мой товарищ рассказал мне о больших данных, о том, что специалистов в этом направлении не хватает и, что это направление будет активно развиваться в ближайшее время т. к. объемы данных постоянно растут и постоянно будут нужны люди для обработки этих самых данных, не говоря уже о тех, кто может на более глубоком уровне работать с БД. В целом IT направление мне было всегда интересно, правда в тот момент я был зациклен на разработке игр и не особо смотрел на новые направления, но идея с анализом данных меня зацепила: логика проста, по сути это направление на стыке программирования и статистики. т. е. требуется не только писать код но и строить графики, делать выводы, искать закономерности и просто общаться с коллегами в конце концов, а так как люди в продажах, это мягко говоря совсем не «молчуны», возможность живого общения, а не только программирования меня сильно зацепила и как-то мысли сами-собой потекли в этом направлении: ролики на ютубе, пара статей и в целом общая моральная готовность пойти на курсы. Главное, что сильно смущало - цена курсов и необходимость платить за пол года. Двумя годами ранее я уже искал курсы по JavaScrip и тогда взял минималку от HtmlAcademy за 20000р исходя исключительно из тех соображений, что если не понравится то и не жалко. Не понравилось.
Эйфория от знакомства и первое свидание.
----------------------------------------
Поиск курсов по анализу данных начался с роликов по Python, установил платформу, начал решать задачки, чуть позже начал бесплатный ознакомительный курс от Яндекса, и как раз в этот самый момент на почтовый ящик прилетает письмо с гос услуг о том, что можно взять любой курс по обучению в IT сфере со скидкой 50% Ого! Вот это удача - сразу же подумал я. Хоть какая-то польза от нашего «любимого» государства. На выбор между Яндексом и хотя бы тем же СкилБокс я не потратил ни одной секунды, ведь Яндекс - узнаваемый бренд, думал я, полюбому любой HR знает про них даже за рубежом, а если знают про Яндекс, то и курсы от них будут некой благонадежной ассоциацией и с этим аргументом трудно поспорить.
Подача заявки на гос субсидию оказалась не такой муторной, как я ожидал: я предполагал, что потребуется гора бумажек и подача займет пару месяцев, но на деле до момента одобрения моей заявки с момента регистрации на сайте steps.2035.university прошла примерно неделя, дальше созвон с Яндексом, дружеские «похлопывания друг друга по плечу» по телефону:
* Как здорово, что появилась эта скидка! - говорю я.
* Как хорошо, что вы пришли именно к нам! - отвечают мне по телефону.
* Я точно будут успевать учиться и работать?
* Да у вас все получится, конечно будет иногда тяжеловато, но основная, часть наших студентов совмещают работу с учебой!
* Ура!
* Ура!
* У нас все получится!
Радостный вешаю трубку и оплачиваю, даже не глядя в договор оферты, о котором я узнал несколько позже.
Здесь хочу отдельно обратить внимание на стоимость курсов, которая на мой взгляд сильно завышена, при таком количестве студентов в группе по 30-40 человек стоимость от яндекса как раз могла бы быть на уровне 30 000 и при этом срок обязательных курсов можно было бы с легкостью сократить до трех месяцев, разместив остальной курс в качестве дополнения, это конечно мое личное субъективное мнение.
Первая опасная близость.
------------------------
Проходит две недели с момента оплаты, полная тишина: ни звонков ни писем от яндекса. Набираю сам:
* Здрасте, я вот оплатил курсы. По телефону говорили, что сразу распределят на курс - как будто стесняясь собственных слов произношу я.
* Да, конечно, оплату мы увидели, подождите, вам на почту придет письмо. Спасибо, что позвонили нам!
* Постойте, а можно узнать конкретней, когда должно прийти письмо?
* К сожалению точной информации у меня нет.
* Хотя бы примерно, в течении недели, месяца, года?
* К сожалению точной информации у меня нет. Ожидайте. Спасибо, что позвонили нам!
Первые тревожные мысли начали стучаться в мою бедную голову, через неделю тотальной тишины со стороны Яндекса поток тревожных мыслей стал прерываться матерными междометиями, беру трубку, звоню еще раз.
* Добрый день! Как хорошо, что вы позвонили нам! У вас какой-то вопрос?
* Да, хочу узнать когда начну обучение.
На мой взгляд, в 21 веке это довольно странная ситуация: звонить спустя три недели после оплаты и узнавать когда же мне окажут оплаченную услугу, но это же яндекс, прелюдии кончились, начинайте привыкать и учитесь получать удовольствие.
Ответ в трубке:
* У меня нет точной информации, ожидайте письмо.
* Постойте, я оплатил 3 недели назад и вы даже не можете мне сказать когда начнется обучение? У вас на сайте была информация о начале обучения через 2 недели после оплаты.
* Да, но сейчас очень много студентов, вам нужно подождать.
* Сколько?
* У меня нет точной информации, ожидайте письмо.
* Если меня это не устраивает?
* Вы можете написать нам, мы вернем деньги.
* Компенсация за потраченное время?
* Нет. Спасибо что позвонили нам!
Поток моих тревожных мыслей иссяк, пошли сплошные матерные междометия.
Итог: оплатил 03.11.2021 года, по телефону после пятого раза пообещали, что курс начнется, как раз перед новым годом, за 2 недели, я радостный, как дурак, взял отпуск рассчитывая спокойно начать обучение без лишней «дерготни» по работе, потом в планах была еще пара недель Новогодних каникул, во время которых так же можно было спокойно учиться, но это же Яндекс - доступ к тренажеру открыли 20.01.2022. Элементарные извинения или предложения компенсации? Вы смеетесь, это же яндекс. Начал привыкать...
«На крючке»
-----------
Доступ к тренажеру открыли, на почту прислали инструкции по Slack, по факту первое время я всегда натыкался на одно и то же: перевод стрелок т. е. мне всегда писали к кому обратиться вместо ответа.
Процесс обучения.
Главное, что мне не понравилось - совершенно наплевательское отношение к моему времени. До сих пор не могу понять, как так получается, но факт остается фактом. Я выбираю курсы и оплачиваю их с одной главной целью получить нужную информацию в удобной для меня форме и максимально быстро. На просторах интернета есть масса информации в открытом доступе и можно самостоятельно изучить и статистику, и Tableau, и Python, но на поиски этой информации, её систематизацию нужно потратить не так уж и мало времени. По логике именно за систематизацию этих данных я и плачу, т.е. в первую очередь я плачу за экономию своего времени, по факту все получается совсем не так.
Суть тренажера построена таким образом, что не решив одной задачи ты не можешь перейти к следующей, логика проста и понятна, никто не спорит, но по факту это оборачивается массой заданий по принципу «Выведите на экран ”Hello World!”», увы это не шутка, вот пара примеров из окончания курсов, на минутку, эти задания появляются спустя 4-5 месяцев обучения:
7.Сгруппируйте данные по столбцу 'month' и найдите среднюю позицию в выдаче по месяцам (level). Результат группировки выведите на экран. Подсказка: Последовательно вызовите методы groupby() и mean().
Код решения:
`print(position.groupby('month').mean())`
`>>>`
`level`
`month`
`2 1.750000`
`3 5.769231`
`4 6.214286`
Ответ не принят. Пишу в тех поддержку, ответ спустя 20 минут:
Приветствуем! В задаче нужно найти и вывести на экран среднюю позицию в выдаче(level) по месяцам. Для этого нам нужно сгруппировать столбец level по месяцам и применить агрегирующую функцию mean().
Немного поправьте код и задача решена.
Делаю какие-то правки, тренажер опять не принимает, отсылаю код, ответ спустя еще 20 минут:
В этой задаче не нужно создавать новый датафрейм. Из группировки по столбцу 'month' выберите столбец 'level' и примените к нему метод .mean().
Методом "научного тыка" все же нашел правильное решение:
print(position.groupby('month')['level'].mean())
`>>>`
`month`
`2 1.750000`
`3 5.769231`
`4 6.214286`
`Name: level, dtype: float64`
Конечно, кто-то может сказать, что ничего страшного, что именно так и учатся программированию, но почему за свой счет в течении часа, а то и двух я должен заниматься поиском подобных решений? На мой взгляд подобные мелочи должны решаться в течении пяти минут, и это максимум. По факту получается, что здесь час-полтора, там минут тридцать и в итоге не успевание по курсу, за которое я еще должен доплачивать. Забавно.
В курсе появился подраздел необязательный к прохождению «Продвинутый SQL» и здесь я совершенно согласен, если студенту понадобится в будущем информация по запросам, он в любой момент может открыть тренажер и не лазить по интернету в непонятном поиске. На мой взгляд половину пройденного курса можно было отправить в рекомендательный, а не обязательный раздел.
Тут же хочу отдельно отметить форму обращения в тех поддержку, никаких инструкций по данному поводу нет, и на начальном этапе на построение запросов в тех поддержку уходило немало нервов, по сути это напоминает переписку с гос органами или обычной тех поддержкой. Вполне возможно, что главный “Soft Skill” который вы можете прокачать на данном курсе это переписка с чатом поддержки. Конкретизирую:
* Мы очень рады, что вы к нам обратились но сейчас все заняты, вам нужно подождать.
* Пожалуйста скопируйте код и пришлите нам ссылку.
* Пожалуйста пришлите нам номер задания.
* Пожалуйста пришлите нам текст задания.
* Пожалуйста пришлите нам ссылку на Ваш курс.
Плюсуйте сюда ожидания в ответах по 10-20 минут и в итоге каждый день обучения это как минимум пол часа, а то и час-полтора потраченного времени на беспомощное ожидание. Получить общее время Вашего личного простоя за пол года, думаю каждый сможет самостоятельно.
Приплюсуйте сюда время работы чат с 10 утра по Москве до 7 вечера, позже сдвинули до 10 вечера, возможно уже сейчас внесли какие-то изменения. Благодаря такому графику я не один раз натыкался на ситуации, когда не могу пройти задание в 7 или 8 утра и приходилось ждать ответа в тех поддержке или в Slack. Оперативность в Slack так же мягко говоря не блещет и здесь я задавал вопросы если например уходил от компа на сутки - это подразумевало, что к моему возвращению там будет ответ, на большую оперативность рассчитывать не приходится по определению. Добавлю сюда «косяки» когда я просыпался пораньше на выходных (в целом привычка рано вставать) и часов в 6 утра садился за тренажер, а он просто «висит» к сожалению это так же не редкость и пару раз я на такое натыкался. В лучшем случае куратор в чате, вам напишет «Команда в курсе, команда чинит!» естественно даже без извинений, это же яндекс.
Еще один «ньюанс» про потраченное впустую время, в самом конце сдал последний проект, перед финальной работой, специально торопился, т. к. было указано, что курс откроют 5 августа, контрольную к этому времени сдал, и в планах было остаться дома на выходные, что бы заняться финальным проектом, хорошо, что уехал загорать, т. к. доступ открыли 8 августа, вместо пятницы только во вторник, впрочем этому я даже не удивился, но допускаю, что на курсе уже появились те, кто начал получать удовольствие от подобных «выходок».
Monkey Job.
-----------
Отдельно хочу обратить внимание тех, кто задумывается о покупке данных курсов, будьте готовы к тому, что вы платите в том числе за подобные «мелочи»
Задача 1.
Катя случайно высыпала 123 скрепки на лист в клетку. Размер клетки — 4 × 4 см. 98 скрепок пересекли линии на листе, а остальные — нет. С какой вероятностью упавшая на такой лист скрепка пересечёт линию?
В результате метода «научного тыка» правильный ответ был найдет
98/123 = 0.796 вместо вводимых мной 79.674%
Пол часа убитого времени, т.к. решал утром и тех поддержка еще спала.
Еще один пример.
Покупаем авиабилеты.Вы покупаете авиабилеты. Цена — 30 000 рублей. Есть две возможности сэкономить:
1) Воспользоваться промокодом на 4000 рублей;
2) Купить билет с карты банка-партнёра и получить скидку в 15%.
Промокод и скидка от банка не суммируются: можно выбрать только один вариант. Карточка банка у вас уже есть, оформлять её не нужно. Не раздумывая, что вы выберете?
Правильный ответ.
Скидку от банка. Оплачу только 85% стоимости билетов. 15% от 30 000 — целых 4500. На 500 рублей выгоднее промокода.
Все здорово, но зачем подобные задания вставлять в обязательный курс?
Задания из серии ctrl-c ctrl-v, скриншот ниже, справа пропуски в которые нужно вписать правильный ответ, надеюсь, вы догадаетесь. что нужно вставить вместо
`# ваш код здесь`
Знакомство перешедшее в длительные отношения.
---------------------------------------------
Проблема в структуре данных, а точнее, в постоянном перемешивании теории по статистике и синтаксиса Python.
Вполне возможно, что это проблема именно этого курса, т. к. переписывался с однокурсницей, которой данный курс так же крайне не понравился, хотя, до этого она проходила обучение по курсу Data Scientist и там все было ок.
Вполне очевидная на мой взгляд вещь - мухи отдельно, котлеты отдельно, но для яндекса это не так. Как итог по окончании курса мне пришлось все перепроверять исключительно для того, что бы сделать рабочий конспект по синтаксису Python. Базовые знания в теории Python так же хромают, данный вывод делаю, просто сравнивая яндекс и бесплатную лекцию в МФТИ от Тимофея Хирьянова.
Так же есть претензии к теории по статистике, например что бы понять достаточно часто используемую дисперсию пришлось залезть в гугл и найти экселевский файл с расчетами, сравните что понятней:
Определение от яндекса: Улучшенная метрика разброса — не просто среднее расстояние между значениями датасета и средним, а средний квадрат этого расстояния.
Эта величина называется дисперсия (лат. dispersio, «рассеяние»), её находят по формуле:
**D(X)=M(X−M(X))2**, которую также часто записывают в более удобном для расчетов виде: D(X)=M(X2)−(M(X))2
Чтобы понять, насколько сильно значения отличаются от среднего, вычисляют дисперсию. Для каждого значения находят расстояние от среднего до нужного значения, а затем возводят результат в квадрат.
Скриншот из формулы найденной на просторах интернета:
Еще один крайне негативный момент - это сам тренажер, некоторые моменты в синтаксисе описываются в ходе выполнения упражнения, а пройти упражнение второй раз нет технической возможности, скорее всего так яндекс страхует свои "научные открытия" от копипаста. Для меня же иногда появлялся пробел в данных, и спустя пару недель при необходимости еще раз разобраться во всей логике произошедшего по шагам, увы, ждало разочарование.
Да, конечно каждый может самостоятельно забраться в интернет и разобраться в тех моментах теории которые ему непонятны, но тут главный вопрос, а за что я тогда плачу?
Плюсы в курсе.
--------------
По большому счету платить приходится за три главных вещи:
* Сертификат в котором указано яндекс.
* Структура данных полученных на курсе и отдельно SQL
* Выполненные проекты.
Для объективности должен сказать, что в 2020 году проходил курсы RemoteAcademy по управлению командой, цена 60000р, конечно по сравнению с Яндексом там, просто выброшенные деньги но и от яндекса ожидал большего.
**В первую очередь**, я ожидал комфортных условия и понимания, что ты можешь заниматься именно тогда когда тебе удобно и делать то, что тебе интересно и нужно, а не вставлять скопированный код из конспекта в задание, а потом переправлять его в чат поддержки, в случае ошибки.
**Во вторую очередь**, хотелось больше самостоятельности. Конечно, самостоятельных проектов достаточно много и к концу курса успеваешь набить руку, что бы чувствовать себя достаточно уверенно глядя даже на объемное задание. Мне при этом сильно не хватало неформального общения с одним наставником на протяжении всего курса, всегда при проверке получались какие-то одноразовые переписки. Хотелось заданий и возможности делать то, что на твой взгляд приведет к нужным результатам, искать ошибки, закономерности, а в замен этого получаешь палочную систему, которая очень быстро надоедает. Все проекты - это набор однотипных заданий, которые проверяются по каждому пункту, и цель этих заданий сводится к «докапаться» со стороны проверяющего и «отписаться» со стороны проверяемого, мой порыв делать аккуратные работы и искать самостоятельно какие-то закономерности и аномалии в данных был на корню подрублен уже четвертой работой, на которую я потратил больше двух недель, а в итоге получил непонятные для меня комментарии от проверяющего, на переписку с которым я потратил еще наверное неделю. В итоге довольно сильно отстал т. к. на ковыряние в проекте еще и наложился больничный. Сомневаясь в своих возможностях догнать материал, написал куратору о возможности перехода в другую, более позднюю кагорту и тут меня ждал сюрприз: да, конечно, перевести могут, но больничный не учитывается и за мое отставание мне нужно будет доплачивать. На всякий случай уточнил, почему так, почти двух месячное ожидание открытия курсов никак не компенсируется, а тут только два переноса и доплачивай, ответ думаю вы уже знаете - это же яндекс, в договоре оферты все прописано.
Справедливости ради, нужно заметить, что несколько раз одноразовые код-ревьюверы давали прямые ответы на мои вопросы, вместо отписок, чем действительно помогали в работе, в целом же на мой взгляд проверки в основном больше походили на высасывание недочетов из пальца, не говоря уже про тот момент, когда проверка проекта занимала неделю и эта «дерготня» то правки в проекте, то новая теория сильно раздражали и подкашивали. Принцип когда ты сдаешь проект, делаешь паузу, «очищаешь голову» и идешь дальше здесь явно нарушен.
Огрехи в курсе так же сводятся к непонятной информации, иногда даже для самих преподавателей, здесь просто приведу цитату из Slack.
**Вопрос студента:**
— Поэкспериментировал, всё отлично работает. Хотелось бы ещё понять механизм этой работы. В теории написано, что декоратор используется чтобы выполнять дополнительные действия до и после основной функции. В нашем случае, как я понял, декоратор просто передаёт в основную функцию аргументы и в конце получает от неё значения на выходе. В чём смысл его работы?
**Ответ наставника:**
— Я понятия не имею, как работает конкретно этот декоратор под капотом. Чтобы с этим разобраться, нужно идти на гитахб и смотреть его реализацию. Так что я не могу тебе ответить на этот вопрос. Да и, вообще говоря, вряд ли тебе вообще понадобится это знание, так как я сильно сомневаюсь, что ты будешь строить дашборды с помощью кода, а не с помощью Табло.
Какие либо комментарии на мой взгляд, тут излишни, разве что не удержусь от смайлика =)
С другой стороны этими дашбордами «с помощью кода» занимались почти месяц, получается месяц бесполезной теории, за свой же счет и смайлик тогда нужно ставить в другую сторону =(
Теория которая разбилась о практику.
------------------------------------
Еще один немаловажный момент - зацикливание на теории, без оговорок. Подчеркну из курса фрагмент из теории, где речь идет про перцентили 90, 95, 99, очистку данных и отбрасывание выбросов. Обратился к своей знакомой из Пятерочки по данному поводу, поинтересовался, что она знает про перцентили и статистическую значимость, использует ли она эти «штуки» при расчете средних показателей и среднего чека в частности. Знакомая работает директором по рознице несколько лет, для понимания, в её подчинение было 17 директоров магазинов, и всевозможные отчеты и метрики по среднему чеку было её основной задачей, при этом про такие понятия она и не слышала.
Спрашиваю про выбросы при расчете среднего чека, в ответ получаю - нет, ничего не удаляем, просто разделяли оптовых покупателей и розницу, теперь это происходит полностью автоматически.
Вот здесь и почувствуйте разницу между отбрасыванием оптовых (аномальных) покупателей и отсеканием выбросов, про обработку которых так много было написано в курсе, а про опт и розницу, ни одной маленькой пометки. Поэтому после прохождения курсов от яндекса на собеседовании, если вы заявите что-то подобное, да еще и начнете бить себя в грудь, мол это правильно ведь так сам Великий яндекс написал, на вас могут посмотреть как минимум странно, не говоря уже о приеме на работу. Да, теория это хорошо, но на практике про статистическую значимость могут и не знать, а средний чек и сравнение средних чеков делают "по старинке" по общей выборке, сумме и количеству.
Для меня это просто яркий пример не соответствия теории и практики, не думаю, что это надо записывать исключительно на счет курса яндекса, но почему на платных(!) курсах про такой нюанс просто не упомянуть, помня о том, что на эти курсы могу попадать студенты без малейшего представления о том, как-там все происходит на работе, а не только в тренажере.
Опять же зачем в обязательном порядке убивать столько времени на подобную теорию, которая будет благополучно забыта через два месяца мне совершенно не понятно, не говоря о том, зачем за такую теорию нужно платить.
Так же отдельно хочу сказать, что данные курсы по своему духу больше напоминают платную стажировку в яндекс, что от части верно, по завершению курса вам могут предложить работу код-ревьювером за 30 000р в месяц (500 USD) с частичным трудоустройством, мне это почему-то напоминает старую шутку: ищем расклейщиков объявлений, для расклейки объявлений, о поиске расклейщиков объявлений.
На мой взгляд данные курсы так же несут крайний негатив и для преподавателей. Оклад 500$ как бы уже намекает, что преподаватели (код ревьюверы) здесь находятся на птичьих правах, что-то не нравится и сразу на выход. Преподаватели должны только монотонно выполнять свои действия, инициатива, а тем более внимание к жалобам студентов не приветствуется. Экономия времени студентов? Судя по придиркам преподавателей и отзывам в Слаке, главная задача код ревьювера, заставить студента потратить на работу, как можно больше времени.
На мой взгляд, это главная и вне гласная стратегия яндекса: Зачем получать со студента 70 000 за курс, если можно потянуть его время, сказать, что он "лошара" не успевает, а все успевают, с радостной улыбкой дать ему возможность продолжить обучение, но при этом "не забыв" получить со студента еще 12, 15, 30 к рублей за продление сроков обучения. Черный маркетинг, систему скрытых платежей никто не отменял.
Так же к черному маркетингу отнесу навязывание использование сервисом
[https://cloud.yandex.ru](https://cloud.yandex.ru/)
Это жесть, выяснилось, что я плачу за то, что бы яндекс тратил мое время на объяснение того, как правильно пользоваться их кривым интерфейсом, и если не пройдешь это "задание" тренажер дальше не пропустит. После завершения курса нужно было отдельно тратить время, что бы удалить аккаунт и отвязать карту, что бы яндекс "случайно" не слизал оплату данной услуги за месяц.
Вопрос поиска работы после курсов у меня еще не закрыт, по данному поводу постараюсь написать подробно но немного позже, т. к. эта процедура наложилась на вынужденную миграцию в Турцию.
Грустное расставание. Минусы курса.
-----------------------------------
Подведем итоги, минусы:
* Совершенно наплевательское отношение к Вам и вашему времени.
* Низкое качество структуры курса и представленных данных.
* Трудности в составлении конспекта курса.
* Большое количество бесполезной информации, которая могла быть в доступе для ознакомления, но никак не для обязательного изучения.
* Доплата за ваше не успевание, к которому яндекс очень активно подталкивает.
* Полное отсутствие даже намеков на компенсацию со стороны яндекса за свои «косяки».
Плюсы:
* Большой объем полезной информации.
* Большой опыт в написании самостоятельных работ.
* Прокачка «SoftSkil»: большой опыт в общении с чатом поддержки и подобные прелести.
В целом, для себя сделал вывод, что единственной панацеей от подобной ситуации может быть самостоятельная учеба или учеба с репетиром, ведь по сути на таких курсах яндекс является просто прокладкой между теми, кто обладает знаниями (код ревью) и теми, кто за эти знания готов заплатить (студенты). При этом «прокладка» не просто забирает большую часть денег себе, но еще и сталкивает стороны лбами, фиксируя в крайне "неприятных позах", командуя и ограничивая в действия. Хотя, "неприятные позы" это конечно, уже дело вкуса каждого, а о вкусах, как известно, не спорят.
p/s
Добавлено 29/10/2022
Отдельно хочу обратить внимание на закрепленный комментарий от представителя яндекс, с огромной кучей оправданий и просьбой убрать опубликованные примеры, при этом представитель ни то, что про компенсацию не спросил, элементарно не посчитал нужным извиниться от лица компании, это же яндекс. Без комментариев. | https://habr.com/ru/post/695136/ | null | ru | null |
# Система управления конфигурацией сети фильтрации Qrator
**TL;DR**: Описание клиент-серверной архитектуры нашей внутренней системы управления конфигурацией сети, QControl. В основе лежит двухуровневый транспортный протокол, работающий с упакованными в gzip сообщениями без декомпрессии между эндпойнтами. Распределенные роутеры и эндпойнты получают конфигурационные апдейты, а сам протокол позволяет установку локализованных промежуточных релеев. Система построена по принципу [дифференциального бэкапа](https://en.wikipedia.org/wiki/Differential_backup) (“recent-stable”, объясняется ниже) и задействует язык запросов JMESpath вместе с шаблонизатором Jinja для рендера конфигурационных файлов.
Qrator Labs управляет глобально распределенной сетью нейтрализации атак. Наша сеть работает по принципу anycast, а подсети анонсируются посредством BGP. Будучи BGP anycast-сетью, физически расположенной в нескольких регионах Земли мы можем обработать и отфильтровать нелегитимный трафик ближе к ядру интернета — Tier-1 операторам.
С другой стороны, быть географически распределенной сетью непросто. Коммуникация между сетевыми точками присутствия критически важна для провайдера услуг безопасности, для того чтобы иметь согласованную конфигурацию всех узлов сети, обновляя их своевременным образом. Поэтому с целью предоставить максимальный возможный уровень основной услуги для потребителя нам необходимо было найти способ надежно синхронизировать конфигурационные данные между континентами.
> В начале было Слово. Оно быстро стало коммуникационным протоколом, нуждающимся в апдейте.
Краеугольным камнем существования QControl и одновременно основной причиной траты значительного количества времени и ресурсов на построение такого рода протокола является необходимость получить единый авторитетный источник конфигурации и, в конечном счете, синхронизировать с ним наши точки присутствия. Само хранилище было лишь одним из нескольких требований в ходе разработки QControl. Помимо этого, нам также были необходимы интеграции с существующими и планируемыми сервисами на точках присутствия (ТП), умные (и настраиваемые) способы валидации данных, а также разграничение доступа. Помимо этого, мы также хотели управлять такой системой с помощью команд, а не внесением модификаций в файлы. До QControl, данные отправлялись на точки присутствия практически в ручном режиме. Если одна из точек присутствия была недоступна, и мы забывали обновить ее позже, конфигурация оказывалась рассинхронизированной — приходилось тратить время на возвращение ее в строй.
В итоге мы придумали следующую схему:
Конфигурационный сервер ответственен за валидацию данных и хранилище, у роутера есть несколько эндпойнтов, получающих и транслирующих конфигурационный апдейты от клиентов и команды поддержки на сервер, а с сервера на точки присутствия.
Качество интернет-соединения все еще значительно различается в разных уголках планеты — для иллюстрации данного тезиса, давайте посмотрим на простой MTR из Праги, Чешской Республики в Сингапур и Гонконг.
[](https://habrastorage.org/webt/ob/pl/vc/obplvcdpqlc8as-nra_jnpv4hbc.png)
MTR из Праги в Сингапур
[](https://habrastorage.org/webt/4z/xo/7s/4zxo7sr_qqrg6cdlipwwvujohto.png)
То же самое до Гонконга
Высокие задержки означают меньшую скорость. Помимо этого, есть потеря пакетов. Ширина каналов не компенсирует эту проблему, которая должна всегда приниматься во внимание при построении децентрализованных систем.
Полная конфигурация точки присутствия — это значительный объем данных, который необходимо переслать многим получателям по ненадежным соединениям. К счастью, хотя конфигурация и меняется постоянно, это происходит небольшими порциями.
### Дизайн recent-stable
Можно сказать, что построение распределенной сети по принципу инкрементальных обновлений является достаточно очевидным решением. Но с диффами связано большое количество проблем. Нам необходимо сохранять все диффы между опорными точками, а также уметь досылать их в случае, если кто-то упустил часть данных. Каждая точка назначения должна применять их в строго заданной последовательности. Обычно в случае нескольких точек назначения подобная операция может занимать продолжительное время. Получатель также должен быть в состоянии запросить упущенные части и, конечно же, центральная часть должна ответить на такой запрос корректно, посылая только пропущенные данные.
В итоге, мы пришли к довольно интересному решению — у нас есть только один опорный слой, фиксированный, назовем его stable, и только один дифф для него — recent. Каждый recent основан на последнем сформированном stable и является достаточным для перестроения конфигурационных данных. Как только свежий recent доезжает до места назначения, старый уже не нужен.
Остается только время от времени отправлять свежую stable конфигурацию, например из-за того, что recent стал слишком большим. Также важным здесь является и то, что мы рассылаем все эти обновления в режиме бродкаста/мультикаста, не беспокоясь об отдельных получателях и их способности собрать кусочки данных вместе. Как только мы убедились в том, что у всех находится корректный stable — мы отправляем только новые recent. Стоит ли уточнять, что это работает? Работает. Stable кэшируется на конфигурационном сервере и получателях, recent создается по необходимости.
### Архитектура двухуровневого транспорта
Почему мы построили наш транспорт на двух уровнях? Ответ достаточно прост — мы хотели отделить маршрутизацию от высокоуровневой логики, черпая вдохновение в модели OSI с ее транспортным уровнем и уровнем приложений. На роль транспортного протокола мы взяли Thrift, а для высокоуровневого формата управляющих сообщений — формат сериализации msgpack. Именно поэтому роутер (выполняющий multicast/broadcast/relay) не смотрит внутрь msgpack, не распаковывает и не упаковывает содержимое обратно и выполняет только пересылку данных.
*Thrift (с англ. — «бережливость», произносится как [θrift]) — язык описания интерфейсов, который используется для определения и создания служб под разные языки программирования. Является фреймворком к удалённому вызову процедур (RPC). Сочетает в себе программный конвейер с движком генерации кода для разработки служб, в той или иной степени эффективно и легко работающих между языками.*
Мы взяли фреймворк Thrift из-за RPC и поддержки многих языков. Как обычно, легкими частями стали клиент и сервер. Однако, роутер оказался крепким орешком, отчасти из-за отсутствия готового решения во время нашей разработки.
Существуют и другие опции, типа protobuf / gRPC, однако, когда мы начинали наш проект, gRPC был достаточно молодым и мы не решились взять его на борт.
Конечно, мы могли (и на самом деле, так и стоило поступить) создать собственный велосипед. Было бы проще создать протокол для того, что нам нужно, потому что клиент-серверная архитектура является относительно прямолинейной в реализации по сравнению с тем, чтобы построить роутер на Thrift. Так или иначе, к самописным протоколам и реализациям популярных библиотек (не зря) существует традиционное предвзятое отношение, кроме того, при обсуждении всегда поднимается вопрос: «А как мы будем это портировать на другие языки?». Поэтому мы сразу же выкинули идеи о велосипеде.
*Msgpack — аналог JSON, но быстрее и меньше. Это двоичный формат сериализации данных, позволяющий обмениваться данными между множеством языков.*
На первом уровне у нас находится Thrift с минимум необходимой роутеру информации для пересылки сообщения. На втором уровне — упакованные структуры msgpack.
Мы выбрали msgpack потому что оно быстрее и компактнее в сравнении с JSON. Но что еще важнее, он поддерживает кастомные типы данных, позволяя нам использовать крутые фичи типа передачи сырых бинарников или специальных объектов обозначающих отсутствие данных, что было важно для нашей схемы “recent-stable”.
**JMESPath**
*JMESPath это язык запросов к JSON.*
Именно так выглядит описание, которое мы получаем из официальной документации JMESPath, но на самом деле, он дает гораздо больше. JMESPath позволяет искать и фильтровать поддеревья в произвольной древовидной структуре, а также применять изменения к данным на лету. А ещё он позволяет добавлять специальные фильтры и процедуры преобразования данных. Хотя он, конечно, требует напряжения головного мозга для понимания.
**Jinja**
Для некоторых потребителей, нам необходимо превратить конфигурацию в файл — поэтому мы используем шаблонный движок и Jinja является очевидным выбором. С ее помощью мы генерируем конфигурационный файл из шаблона и данных, полученных в точке назначения.
Для генерации файла конфигурации нам нужен запрос JMESPath, шаблон для местоположения файла в ФС, шаблон для самого конфига. Также на этом этапе неплохо уточнить права доступа к файлу. Все это получилось удачным образом скомбинировать в одном файле — перед началом шаблона конфигурации мы ставим заголовок в формате YAML, описывающий остальное.
Например:
`---
selector: "[@][?@.fft._meta.version == `42`] | items([0].fft_config || `{}`)"
destination_filename: "fft/{{ match[0] }}.json"
file_mode: 0644
reload_daemons: [fft]
...
{{ dict(match[1]) | json(indent=2, sort_keys=True) }}`
Для того чтобы сделать конфигурационный файл для нового сервиса мы добавляем только новый файл шаблона. Не требуются никакие изменения исходного кода или ПО на точках присутствия.
Что изменилось после ввода QControl в операционную деятельность? Первое и самое важное — согласованная и надежная доставка обновлений конфигурации по всем узлам сети. Второе — получение мощного инструмента проверки конфигурации и внесения в нее изменений нашей командой поддержки, а также потребителями услуги.
Все это нам удалось сделать задействуя схему обновлений recent-stable для упрощения коммуникации между конфигурационным сервером и получателями конфигурации. Используя двухуровневый протокол для поддержки независимого от содержимого способа маршрутизации данных. Успешно интегрировав основанный на Jinja движок генерации конфигурации в распределенную сеть фильтрации. Данная система поддерживает широкий набор способов конфигурации для нашей распределенной и разношерстной периферии.
За помощь в написании материала спасибо [VolanDamrod](https://habr.com/ru/users/volandamrod/), [serenheit](https://habr.com/ru/users/serenheit/), [NoN](https://habr.com/ru/users/non/).
[Английская версия](https://habr.com/en/company/qrator/blog/463735/) поста. | https://habr.com/ru/post/463739/ | null | ru | null |
# Как быть, если твой провайдер Akado?
Под хабракатом приведены примеры скриптов, упрощающие жизнь :)
#### Часть 1. Проверка получаемого адреса
В своё время у Акадо наблюдались проблемы с авторизацией pppoe.
И поскольку при загрузке системы часть демонов привязывалась к получаемому ip адресу, то нужно было как-то автоматизировать процесс загрузки системы и исключить ситуацию простоя.
Идея заключалась в том, чтоб после запуска pppd проверять полученный от провайдера адрес.
Сам скрипт представляет из себя следующее:
`i=0
pppip=""
echo -e "waiting pppoe connection"
until [ "$i" -eq "30" ]
do
iconf=`/sbin/ifconfig tun0 | awk '/inet/ {print $2}'`
if [ "$iconf" = "$pppip" ]
then
echo -e "successful"
i="30"
break
else
i=`expr $i + 1`
echo -n "."
sleep 5
fi
done
if [ "$iconf" != "$pppip" ]
then
echo -e "pppoe not connected!\nSystem will be reboot"
reboot
fi`
и добавлен в /etc/rc.d/ppp.
Если не удалось получить требуемый адрес, то отправляем машинку в ребут.
Почему не пытаемся перезапустить сам демон ppp?
К моменту проверки ещё не многое запущено, поэтому исключаем версию о том, что перезагрузка будет долгой — до момента остановки процессов, а усложнять конструкцию очень не хотелось.
#### Часть 2. Проверка соединения
Помимо описанной выше ситуации могут случиться проблемы с потерей соединения.
Хочу оговориться, что полёт пакетов происходит след. образом:
* для работы локальной сети используется адрес, выдаваемый от dhcp сервера провайдера;
* для выхода во вне используется pppoe.
Скрипт запускается по крону с периодом в 10 минут и если пинг неудачен до внутренних адресов, то пытаемся переполучить адрес от dhcp, до внешних — рестартим pppd.
```
#!/usr/bin/perl
use strict;
use warnings;
use threads;
use Touch;
use Net::Ping;
use Net::Ifconfig::Wrapper qw(Ifconfig);
my @check_hosts = qw/ya.ru google.com/;
my @check_ips = qw/172.18.1.1 172.18.1.2/;
my $int_if = 're0';
my $ext_if = 're1';
sub get_ips {
my ($iface) = @_ ;
my @ifaces = ();
my $info = Ifconfig('list', '', '', '');
unless ( defined($info->{$iface}) ) {
die "Couldn't find ip address on $iface\n";
}
for ( sort keys %{$info->{$iface}{'inet'}} ) {
push(@ifaces,$_);
}
if ( scalar(@ifaces) > 0 ) {
return \@ifaces;
}
else {
return undef;
}
}
sub ping_state {
my ($dst_src,$proto,$iface) = @_;
die "Check params in sub ping_state"
unless ( defined($dst_src) && ref($dst_src) eq 'ARRAY' );
$proto = ''
unless ( defined($proto) );
my $p = Net::Ping->new($proto);
my $int_ips = undef;
$int_ips = get_ips($iface)
if ( defined($iface) );
$p->bind($int_ips->[0])
if ( defined($int_ips) );
my $i = 0;
for my $sources ( @{$dst_src} ) {
if ( $p->ping($sources,10) ) {
$i++; last;
}
}
$p->close();
if ($i > 0) { return 1; }
else { return 0; }
}
sub do_log {
my ($message,$log_file) = @_;
$log_file = '/var/log/ifaces.log'
unless ( defined($log_file) );
unless ( -e "$log_file" ) {
touch($log_file) or die("Failed touch $log_file");
}
open(LOG,">> $log_file");
my ($sec,$min,$hour,$mday,$mon,$year) = localtime(time);
print LOG '[' . ($year+1900) .
'-' . ( ( $mon < 10 ) ? ( '0'.$mon ) : $mon ) .
'-' . ( ( $mday < 10 ) ? ( '0'.$mday ) : $mday ) .
' ' . ( ( $hour < 10 ) ? ( '0'.$hour ) : $hour ) .
':' . ( ( $min < 10 ) ? ( '0'.$min ) : $min ) .
':' . ( ( $sec < 10 ) ? ( '0'.$sec ) : $sec ) .
']' . "$message\n";
close LOG;
}
my $thr = threads->create(sub {
unless ( ping_state(\@check_ips,'tcp',$int_if) ) {
do_log("Check connect to LAN resources : failed");
system("dhclient $ext_if");
}
});
unless ( ping_state(\@check_hosts,'icmp') ) {
do_log("Check connect to WAN resources : failed");
opendir(RUN,'/var/run');
for ( grep {/tun\w+\.pid/} readdir(RUN) ) {
open(PID,'/var/run/' . "$_");
local $/ = undef;
my $pid = ;
close(PID);
chop($pid);
kill(9,$pid);
}
closedir(RUN);
system("ppp -ddial akado");
}
foreach my $t ( threads->list(threads::all) ) {
$t->join();
}
```
Не забываем подставить свои значения проверяемых внутренних ресурсов (см. определение массива @check\_ips).
В /var/log/ifaces.log можем отслеживать проблемы.
Само собой, можно было убрать использование модуля Touch и по иному описать часть операций, но мне в момент написания хотелось именно так :)
P.S.: используется FreeBSD, Perl 5.10.
Перл 5.8 будет ругаться на использование threads->list(threads::all). | https://habr.com/ru/post/66644/ | null | ru | null |
# Строим систему доменных событий в модульном монолите
*Статья написана по мотивам* [*моего доклада на митапе*](https://youtu.be/8fu2jHpuZRs)*.*
Всем привет! В этой статье хочу поделиться опытом построения системы доменных событий (domain events) в нашем модульном монолите и микросервисах, рассказать о том, как мы гарантируем их доставку, следим за консистентностью в рамках транзакций, используя transactional outbox, чем доменные события отличаются от интеграционных и всё это в рамках multi tenant приложения.
История началась с того, что от бизнеса пришёл запрос на доработку одной из ключевых функций нашего приложения. Поскольку данный функционал в той или иной степени касался почти всех компонентов приложения, мы решили немного улучшить наш большой легаси проект и переписать часть с использованием нового фреймворка, новых подходов и новой архитектуры. Также важной частью запроса от бизнеса было увеличение количества команд разработки, одновременно работающих над разными частями продукта. Мы решили разделить наш монолит на модули используя принципы DDD, а также часть логики вынести в микросервисы на Go. В рамках модулей и микросервисов код было решено поделить их на слои в соответствии с гексагональной архитектурой (подробнее можно [почитать тут](https://habr.com/ru/company/ispring/blog/560074/)).
Данная статья нацелена на мидлов и сеньоров. Для джунов рекомендую сначала посмотреть в сторону этих двух книжек:
Давайте разберёмся, что такое ограниченный контекст (далее просто контекст). Контекст — это часть большого контекста предметной области, самодостаточная, со своими определениями, языком и доменной моделью. В рамках модульного монолита приложение можно разделить на модули в соответствии с контекстами, в микросервисной архитектуре - на микросервисы. Именно изменения доменной модели внутри контекста генерят события.
О доменных событиях нужно знать следующее:
* они обозначают события, произошедшие в прошлом;
* обрабатываются в текущем контексте;
* нужны для синхронизации нескольких агрегатов в контексте (то есть каждый агрегат предметной модели сам отвечает за свое консистентное состояние, но если у нас в контексте их несколько, то мы их должны синхронизировать и это делается с помощью доменных событий);
* не идут в брокер сообщений;
* обрабатываются синхронно.
В контекстe User могут быть следующие доменные события: пользователь добавлен в систему, пользователь добавлен в группу, у пользователя изменился пароль и так далее.
Теперь перейдём к тому, как мы реализовали схему диспатчинга. В контексте User есть агрегат User. Предположим, у него изменилось имя и сгенерировалось доменное событие, которое отправилось в Event Dispatcher.
Чтобы не нарушать чистую архитектуру, интерфейс Event Dispatcher Interface находится на уровне домена, а реализация лежит на уровне приложения. В реализацию попадает объект события, который передаётся всем подписчикам. Event Handler’ы вызывают нужные методы других агрегатов. Это и есть синхронизация двух агрегатов.
Перейдём к интеграционным событиям. Интеграционные события — это события, порождённые другим контекстом и преобразованные в формат, удобный для транспортировки. Они обрабатываются в других контекстах асинхронно. Именно они идут через брокер сообщений.
Разберём по схеме. Доменное событие через доменный Event Dispatcher попадает в Domain Event Handler, находящийся на уровне инфраструктуры. Этот Handler преобразовывает объект доменного события в сообщение (в нашем случае в JSON строку) и отправляет в брокер. После этого сообщение попадает в Message Handler в другом контексте. Данное сообщение, пришедшее из брокера и преобразованное в объект Integration Event, и есть интеграционное событие. Для обработки такого события используется Integration Event Handler, поскольку событие не из текущего контекста.
---
Давайте рассмотрим типичные ошибки, с которыми мы столкнулись во время реализации системы доменных событий.
1. Синхронная обработка событий в другом контексте.
Идея многомодульного монолита такова, что каждый модуль можно легко вынести в отдельный микросервис, потому что это маленькая предметная область взаимодействующая с другими контекстами через своё API. Если другой модуль подписывается на события синхронно, то он делает это в обход API и его уже не так легко вынести в микросервис. События же являются частью API модуля/микросервиса (хороший пример — <https://launchany.com/microservice-design-canvas/>). Дополнительные сложности могут принести синхронные транзакции в нескольких модулях.
2. Событие не доменное, а уровня приложения.
Разберём на примере — при добавлении пользователя в систему сам способ добавления (через форму или импорт файла) для предметной области может ничего не значить. Событие «завершен импорт файла» или «изменился прогресс выполнения задачи» чаще всего уровня приложения, а не доменного. Подобные ошибки мы отлавливали на Code Review.
3. События проектируются с учетом бизнес логики потребителей.
Со стороны внешнего сервиса бывает нужно только одно конкретное событие, но с точки зрения нашего контекста, генерирующего событие, оно общее. В таком случае правильным решением будет сделать общее событие, чтобы часть логики внешнего сервиса не проникла в наш контекст. Например, имеем список групп, который может редактироваться и пополняться через интерфейс приложения. Пользователь может быть добавлен в любую группу — группу администраторов, группу комментаторов и тд. Казалось бы это все одно и то же - «пользователь добавлен в группу», но с точки зрения внешнего контекста может быть важно лишь одно событие «пользователь добавлен в группу администраторов». Если мы будем отправлять событие добавления в конкретную группу администраторов, то часть бизнес логики внешнего контекста окажется в нашем контексте.
Ещё есть интересные задачи связанные с событиями:
1. Массовые и единичные события.
Например, добавили одним действием одного пользователя или тысячу пользователей. Сколько событий нужно сгенерировать: одно с тысячей пользователей или тысячу по одному?
2. Количество и набор данных в событии.
Когда событие обрабатывается в другом контексте, бывает нужно узнать что-то дополнительно из исходного контекста, например, сколько всего пользователей в группе администраторов. Все данные класть в событие бывает накладно, также как и не класть никаких данных вообще. Потому каждый раз необходимо решать, что же положить в конкретное событие.
3. Идемпотентность обработки события.
Брокер сообщений может гарантировать at least once доставку, то есть одно сообщение будет доставлено как минимум один раз. Это значит, что оно может быть доставлено и больше одного раза. Когда мы только написали свою систему событий, у нас одно событие бывало приходило и десяток раз. И если во время обработки события мы, например, к счетчику прибавляем два, а потом вновь пришло это событие и мы еще раз добавили два, то в итоге получили +4, а должны были получить только +2. За этим нужно следить.
Каждая из этих тем интересная и большая, подробнее их в статье мы рассматривать не будем. В целом стоит помнить, цитата из книги [«Fundamentals of Software Architecture: An Engineering Approach by Mark Richards and Neal Ford»](https://www.amazon.com/gp/product/B0849MPK73):
> *Everything in software architecture is a trade-off (First Law of Software Architecture)*
>
>
---
Теперь подробнее про диспатчинг.
Мы уже разобрали, что такое доменное событие и понимаем, какие данные в это событие нужно положить. Пришло время его диспатчить. Казалось бы — диспатчер вызвал и диспатчь, как в примере выше :) На самом деле это не так просто сделать.
Существует несколько подходов (вариантов диспатчинга):
1) Статический диспатчер, который используется напрямую из доменной модели
Плюсы: его легко реализовывать.
Минусы:
* сложнее покрыть и проверять тестами;
* события диспатчатся немедленно. Мы еще не завершили операцию, агрегат ещё что-то не доделал, а событие уже задиспатчилось. За этим нужно следить.
Например, переименование пользователя — в агрегате User в методе Rename сначала выполняется бизнес логика (проверяются инварианты, что имя корректно), а после этого статическим методом диспатчится доменное событие. Всё просто, но я бы посоветовал всё продумать, прежде чем так делать.
```
namespace User\Domain;
class User
{
public function rename(Name $name): void
{
$this->name = $name;
Dispatcher::dispatch(new UserRenamed($this->getId(), $name));
}
}
```
2) Агрегат коллекционирует все свои события (более популярный)
Плюсы:
* легко реализовывать обработку событий после сохранения агрегата. Сначала что-то сделали с агрегатом, он сохранил все события и только после этого мы обработали все события.
Минусы:
* лишние методы и данные у агрегата. В нашу предметную модель попали методы, которые не совсем относятся к предметной модели.
По этой теме существует компонент Messenger.
В агрегате user появляется массив с событиями. Когда выполняется операция «rename», в этот массив сохраняются все доменные события и появляется метод «getEvents». В момент сохранения агрегата получается список событий из агрегата и они сохраняются в базу. После успешного сохранения список событий в агрегате очищается.
```
namespace User\Domain;
class User
{
private $events = [];
public function rename(Name $name): void
{
$this->name = $name;
$this->events[] = new UserRenamed($this->getId(), $name);
}
public function getEvents(): array
{
return $this->events;
}
}
```
3) События диспатчит доменный сервис.
Плюсы:
* нет лишних методов и зависимостей у агрегатов, модель становится чистой;
* можно использовать анемичную или частично анемичную доменную модель. DDD рекомендует использовать богатую доменную модель (когда агрегат сам следит за своими инвариантами и не имеет сеттеров). Анемичная модель — это модель для хранения данных, за её инварианты отвечают внешние сервисы, а не она сама. Типичная анемичная модель имеет только поля и наборы сеттеров и геттеров. В данном случае, доменный сервис следит, чтобы инварианты доменной анемичной модели соблюдались внутри нашего уровня домена. Анемичная модель легка в реализации, но в рамках нашего решения не является обязательной.
Минусы:
* лишняя обёртка, то есть каждое действие с агрегатом выполняется только через обертку и нельзя напрямую работать с агрегатом из приложения.
Обычно доменный сервис — это редкий кейс, используется в случаях, когда какая-то логика не относится к конкретному агрегату. Хорошим примером доменного сервиса по DDD является [спецификация](https://martinfowler.com/apsupp/spec.pdf). Это доменная логика и она относится к предметной модели и области, но не имеет своего состояния и выполняется над агрегатом или над коллекцией агрегатов. Фактически, это сервис, который мы положили в домен.
```
namespace User\Domain;
class UserService
{
public function __construct(DomainEventDispatcherInterface $dispatcher)
{
$this->dispatcher = $dispatcher;
}
public function rename(User $user, Name $name): void
{
$user->rename($name);
$this->dispatcher->dispatch(new UserRenamed($user->getId(), $name));
}
}
```
Именно третий вариант мы выбрали у себя. Он позволил разделить доменную логику и обязанность отправки событий. Модель в таком случае отвечает только за своё состояние и правила его изменения.
Стоит уточнить, что когда у нас разрабатывается CRUD сервис, то для него далеко не всегда нужен DDD. Есть сложные контексты, где мы используем только DDD. Но также есть простые контексты, где можно использовать анемичную модель, которая может лежать на уровне приложения и события там будут только уровня приложения.
---
Итак, всё классно, мы задиспатчили событие и тут возникает следующий вопрос. У нас же есть транзакции и брокер сообщений и нам нужно в какой-то момент преобразовать доменное событие в сообщение и отправить его в наш брокер. Как это сделать, чтобы ничего не сломалось? Есть несколько вариантов.
Отправка событий и транзакции
Варианты отправки событий в брокер сообщений:
1. До закрытия транзакции.
Тогда у нас события преобразуются в сообщения и отправляются в брокер до того как мы закрыли транзакцию. Очевидные минусы — если с брокером соединение упало, то у нас падает весь кейс и надо откатить всю транзакцию, то есть фактически доменная логика зависит от брокера. Также событие может быть обработано внешним сервисом до того, как транзакция будет закрыта, что может привести к потере консистентности. Или транзакция может быть в целом отменена, а событие уже отправлено в брокер, тогда у нас данные могут в контекстах совсем разъехаться.
2. После закрытия транзакции.
Здесь тоже минус — если мы доменное событие диспатчим после закрытия транзакции, то есть вероятность, что возникнет ошибка при отправке, а транзакция закроется. Так можно потерять событие навсегда.
3. Сохранение события в event store в хранилище событий в той же самой транзакции, в которой сохраняются наши модели, и отправка в брокер после транзакции. Самый хороший вариант, известный как transactional outbox. Именно этот вариант мы реализовали у себя.
UPD: под event store подразумевается таблица в той же базе, где лежат данные агрегата, хранящая все его события. Таким образом появляется возможность в рамках одной транзакции записать в базу сразу и изменения агрегата, и новые доменные события.
Рассмотрим третий вариант на простой схеме.
 В данном случае алгоритм обработки доменного события:
1. После изменения модели User генерится доменное событие (в нашем случае в доменном сервисе)
2. Это доменное событие из Event Dispatcher’a синхронно попадает в Event Handler’ы
3. Первый Event Handler синхронно вызывает методы модели Group
4. Второй Event Handler синхронно передаёт доменное событие в Event Store
5. Это событие преобразуется в stored event в удобном виде для хранения в БД
6. Дальше происходит закрытие транзакции и в БД сохраняются изменения моделей User, Group и модели Stored Event
7. Stored Event Listener на событие коммита транзакции в базу выбирает все новые Stored Event’ы и отправляет в брокер сообщений
Таким образом мы сохраняем события в базу в одной транзакции с основной моделью, что гарантирует, что события не будут потеряны. Для определения, какие события нужно отправить, дополнительно в базе сохраняется ID последнего отправленного в брокер события.
7ой пункт у нас в таком виде реализован для PHP монолита. В БД есть отдельная таблица, хранящая ID последнего отправленного сообщения. При отправке считываются все неотправленные сообщения, при этом с блокировкой, чтобы не слать одно сообщение много раз. В рамках микросервисов на go мы не подписываемся на событие коммита, а проверяем с заданным интервалом наличие новых сообщений в горутине.
Подробнее про transactional outbox можно почитать в книге Chris Richardson «Microservices Patterns».
---
Следующий нюанс нашего приложения в том, что оно multi tenant. Клиентами для нас являются организации, для каждой из которых организована отдельная «песочница» с отдельной базой и отдельным набором пользователей и других сущностей внутри.
Один из интересных моментов, с которым мы столкнулись — один tenant мог нагенерить так много событий, что их обработка могла занять минуты, а иногда и часы. Ясно, что нам необходимо было работать над уменьшением времени обработки отдельного события. Но в рамках общей архитектуры такие наплывы всё равно могли произойти и мы решили сначала разобраться с основной проблемой - не дать наплыву событий из одного tenant повлиять время обработки событий из других. В multi tenant модели нам надо обрабатывать события последовательно в рамках одного tenant и параллельно для разных tenant, а также иметь регулируемое ограничение на количество одновременно обрабатываемых событий.
Мы искали, что есть в мире, ничего не нашли и написали свой маленький сервис, который является прослойкой до подписчиков.
У каждого tenant своя очередь событий в event store, которые попадают в брокер, и есть сервис, который на эти события подписан (в рамках монолитной архитектуры генерить и подписываться может один и тот же монолит). В изначальной реализации сервис сам подписывался на брокер и обрабатывал события.
В текущей нашей реализации появилась прослойка, которая сама подписывается на брокер, сохраняет все сообщения себе локально в хранилище и говорит брокеру, что сообщение обработано. Дальше этот сервис сам следит за всеми очередями в своей базе и для каждого tenant отправляет сообщение последовательно, потому что нам нужно гарантировать последовательность обработки событий. При этом для всех tenant оно отправляет параллельно. Мы ограничиваем и пишем в настройках, сколько нужно параллельно отправлять сообщений. Например, если установить лимит в 10, то только для 10 tenant будут параллельно отправляться сообщение.
Использование данного message limiter не является обязательным при подключении новых сервисов к брокеру, но если возникают инциденты, описанные выше, мы рекомендуем его использовать командам. Модульный монолит использует message limiter по умолчанию для всех модулей.
В итоге после реализации описанных выше решений мы:
* не теряем события (они сохраняются в одной транзакции с моделью);
* имеем единую шину событий на несколько контекстов и сервисов;
* обрабатываем события в multi tenant модели.
Полезные ссылки:
* [События предметной области: проектирование и реализация](https://docs.microsoft.com/ru-ru/dotnet/architecture/microservices/microservice-ddd-cqrs-patterns/domain-events-design-implementation)
* [Domain Events – Salvation](https://udidahan.com/2009/06/14/domain-events-salvation/)
* [Domain Events vs. Integration Events in Domain-Driven Design and microservices architectures](https://devblogs.microsoft.com/cesardelatorre/domain-events-vs-integration-events-in-domain-driven-design-and-microservices-architectures/)
* [Пятиминутка PHP про Domain Events](https://5minphp.ru/episode72/)
* [The Messenger Component](https://symfony.com/doc/current/components/messenger.html) | https://habr.com/ru/post/569648/ | null | ru | null |
# Затмение, лисичка и xdebug
#### Длинное и пространное вступление
Смена работы. Смена работы это всегда стресс, каким бы модным перцем
на предыдущем месте вы ни были. Спустя годы сладкой жизни опять надо
напрягаться, разбираться в ворохе написанного без тебя кода,
удивляться не тобою принятым решениям и ужасаться их иногда не просто
излишней сложности.
Все мы знаем как улетучивается фан от ковыряния в работающем
спагетти-коде, что бы добавить туда что-то или убрать. Однако придя
на новое место мы, как известно, первое время задачи не выбираем. Со
своим нежеланием заниматься разбором старого плохого кода я начал
бороться в нескольких направлениях:
1. Психологическом: Стараюсь не злиться на того кто это написал, а
просто разбираюсь с тем как это работает. Не поверите, в области
висков от этого становится непривычно легко, лицо становится более
доброжелательным и код выглядит более понятным.
2. Организационном: Применяю краткую выжимку из GTD: а) собирай все,
б)перечитывай то что собрал в)делай это. У этого направления есть
также техническая сторона, но о ней не сегодня. Главное при
перечитывании (пункт б) не «возвращать» дела не приняв каких-либо
внятных решений по их дальнейшей судьбе. К слову «разобраться с этим
позже» это вполне внятное решение.
3. Техническом: Вот об этом направлении моего селфимпрувмента вы
сможете наконец прочесть после столь длинного и, как обычно у меня
получается, пространного вступления.
#### Поствсупление
Не торопитесь с выводами, я не ошибся с названием статьи. PHP — технология парадоксальная. На ней иногда пишут наверное самый
непонятный код на свете. Объемы этого самого «уже написанного» кода
представить не возможно. Программистов тоже не мало. И что вы себе
думаете — вся эта пехота в основном до сих пор дебагает свои программы
при помощи старого доброго echo-debugging. У этого есть один
недостаток который мне усложняет жизнь, после каждой сессии такого
дебага, что бы убрать результаты своей деятельности я делаю revert и
если надо провести похожую сессию дебага спустя какое-то время все
надо начинать с начала. Чего уж там говорить о случаях когда без
любимого die() просто не обойтись.
На хабре уже не раз описывался этот инструмент. Также как минимум
дважды описывалась его установка и даже один раз упоминался XDebug
helper. Однако простого руководства настройки всего вместе в одном
документе я не нашел. Потому не привнеся ничего нового я просто стану
таким себе интегратором нескольких документов и статей дабы облегчить
жизнь всем кому это требуется, и их интернет провайдерам.
#### Установка XDebug
Что под windows, что под unix конфигурационная часть в общих случаях
одинакова:
`zend_extension_ts=full_path_to_xdebug.(so|dll)
xdebug.remote_enable=1
xdebug.remote_handler=dbgp
xdebug.remote_mode=req
xdebug.remote_port=9000
xdebug.remote_host=127.0.0.1
xdebug.idekey=eclipse`
Причем вам не стоит заботится об этих параметрах, как показывает
практика(3 установки на win, mac и ubuntu) все это работает без
изменений на вполне стандартных установках этих систем. Разве что есть
замечание про mac os x — поднятый из портов xdebug не захотел работать
с таким же образом установленными apache2+php. Потому там он был
собран ручками один в один как описано тут
[xdebug.org/docs/install](http://xdebug.org/docs/install) в разделе Compiling.
##### Что немаловажно:
Если вы используете apache2 и php как модуль, то вам надо качать
отсюда [xdebug.org/download.php](http://xdebug.org/download.php) threaded сборку, иначе(apache
1.3 + php as module или php как CGI) non-threaded сборку. Это все что
вызывало осложнение с установкой в моем случае.
Как водится перезапускаем apache и проверяем `php --re xdebug` — если
все в порядке — вы поймете это.
#### Установка XDebug helper
Все так же просто как если бы вы ставили обычное расширение firefox:
<https://addons.mozilla.org/en-US/firefox/addon/3960>
#### Настройка eclipse PDT
Смело идемте в Window/Preferences(для Mac Cmd+,) в фильтре вбиваем
Installed Debuggers. Выбираем в результатах(мало ли у кого как)
PHP/Debug/Installed Debuggers. И беремся за настройку XDebug:
единственное что надо сделать так это установить Accept remote session
(JIT) поле хотя бы в localhost или в любое что для вас более актуально
кроме off.
#### Финал
Это собственно все что надо сделать. Дальше один сплошной фан в
работе. Открываете Ваш продукт в firefox, жмете на иконку xdebug
helper и делаете что-то с вашим продуктом(один раз). Теперь
переключаетесь в PDT и о чудо там должно быть окно предлагающее вам
переключится в php debug перспективу. А дальше дело за малым — или
F6,(F6) и иногда F5 или ставьте брекпойнты и шагайте быстрее. Вообще
говоря дело не хитрое.
##### Возможные проблемы
(1) Иногда debug сессия не начинается
Решается в три шага: 1 чистите куки XDEBUG от вашего development
домена и если не помогло перестартовываете ff и дальше если все по
прежнему не работает — перезапускаете eclipse(к слову у меня такое
редко случается)
(2) Иногда debug сессия начинается и тут же прерывается с выпадением
окошка в eclipse о неожиданном останове сессии
Надо убрать все Expressions в одноименном окошке. Такое происходит
когда в пердыдущей сессии вы пользовались функцией Watch для того что
бы просмотреть значение какой-то переменной или выражения.
#### Финальный аккорд
Обратите внимание что все что предложено к настройке в этой статье
абсолютно свободно и бесплатно. Желаю всем что бы все что вам
действительно необходимо в работе было или свободным или по карману ;) | https://habr.com/ru/post/69954/ | null | ru | null |
# Продолжаем чистить память с three.js
Введение
--------
Недавно писал о своем [опыте очистки памяти в приложении, с использованием three.js](https://habr.com/ru/post/519008/). Напомню, что целью была перерисовка нескольких сцен с подгрузкой gltf моделей.
С тех пор я провел ряд экспериментов и считаю необходимым дополнить сказанное ранее этой небольшой статьей. Вот некоторые моменты, которые помогли мне улучшить производительность приложения.
Основная часть
--------------
Изучая различные примеры сборки мусора на three.js заинтересовал подход, предложенный на [threejsfundamentals.org](https://threejsfundamentals.org/threejs/lessons/threejs-cleanup.html). Однако, реализовав предложенную конфигурацию и завернув в this.track() все материалы и геометрию, выяснилось, что при загрузке новых сцен нагрузка на GPU продолжает расти. Более того, предложенный пример некорректно работает с EffectComposer и другими классами для постобработки, поскольку в этих классах track() использовать нельзя.
Решение с добавлением ResourceTracker во все используемые классы не привлекает, по очевидным причинам, поэтому решил дополнить метод очистки упомянутого класса. Вот некоторые приемы, которые были использованы:
### Прием 1. Грубый
Добавляем renderer.info после метода очистки. Поочередно убираем ресурсы из приложения, чтобы понять, какие из них составляют нагрузку и прячутся в текстурах или материалах. Это не способ решение проблем, а просто способ отладки о котором кто-то мог не знать.
### Прием 2. Долгий
Открыв код используемого класса (например AfterimagePass, который можно найти на [гитхабе three.js](https://github.com/mrdoob/three.js/blob/dev/examples/jsm/postprocessing/AfterimagePass.js)) смотрим, где создаются ресурсы, которые нам нужно очищать, чтобы поддерживать число геометрий и материалов в требуемых рамках.
```
this.textureComp = new WebGLRenderTarget( window.innerWidth, window.innerHeight, { ... }
```
То что надо. Согласно документации, WebGLRenderTarget имеет функцию dispose, на которой завязана очистка памяти. Получаем что-то вроде:
```
class Scene {
//...
postprocessing_init(){ // В нашем классе
this.afterimagePass = new AfterimagePass(0);
this.composer.addPass(this.afterimagePass);
}
//...
}
//...
class ResourceTracker {
//...
dispose() {
//...
sceneObject.afterimagePass.WebGLRenderTarget.dispose();
//...
}
}
```
### Прием 3
Работает, но код для очистки в таком случае раздувается. Попробуем использовать знакомый нам из предыдущей статьи подход. Напомню, в ней мы реализовали метод disposeNode(node), в котором ресурс перебирался на поиск того, что можно очистить. disposeNode() может выглядеть как-то так:
```
disposeNode(node) {
node.parent = undefined;
if (node.geometry) {
node.geometry.dispose();
}
let material = node.material;
if (material) {
if (material.map) {
material.map.dispose();
}
if (material.lightMap) {
material.lightMap.dispose();
}
if (material.bumpMap) {
material.bumpMap.dispose();
}
if (material.normalMap) {
material.normalMap.dispose();
}
if (material.specularMap) {
material.specularMap.dispose();
}
if (material.envMap) {
material.envMap.dispose();
}
material.dispose();
}
} else if (node.constructor.name === "Object3D") {
node.parent.remove(node);
node.parent = undefined;
}
}
```
Отлично, теперь возьмем все дополнительные классы, которые мы применяли, и дополним наш ResourceTracker:
```
dispose() {
for (let key in sceneObject.afterimagePass) {
this.disposeNode(sceneObject.afterimagePass[key]);
}
for (let key in sceneObject.bloomPass) {
this.disposeNode(sceneObject.bloomPass[key]);
}
for (let key in sceneObject.composer) {
this.disposeNode(sceneObject.composer[key]);
}
}
```
### Итоги
В результате всех этих действий я значительно повысил ФПС и уменьшил нагрузку GPU в своем приложении. Возможно, я некорректно применял ResourceTracker, однако он в любом случае не помог бы в работе с дополнительными классами. Про то, что перебор EffectComposer через наш disposeNode(node) влияет на число текстур, оказывающихся в памяти я нигде не видел (однако так оно и есть). Этот вопрос следует рассмотреть отдельно.
Для сравнения предыдущая версия останется [по старому адресу](https://sacri.ru/mmeta), а новую можно будет [посмотреть отдельно](http://meta.sacri.ru/).
Проект в некотором виде есть на [гитхабе](https://github.com/trtr7dr/ReMultiScene).
Буду рад услышать ваш опыт по работе с аналогичными проектами и обсудить детали! | https://habr.com/ru/post/521470/ | null | ru | null |
# Добавляем дополнительные особенности реализации на C++ с помощью «умных» оберток
Представляю сообществу библиотеку feature из состава разрабатываемых мной библиотек под общим названием [ScL](https://gitlab.com/ssoft-scl/complex/scl-kit). Сам набор библиотек ScL систематизирует достаточно скромный набор реализаций и подходов, которые на мой взгляд могут упростить процесс разработки программного обеспечения на С++.
Инструменты библиотеки feature позволяют наделить экземпляры объектов любого типа свойствами, которых у них изначально не существует. К таким свойствам можно отнести, например, ленивые вычисления (implicit shared и другое), потокобезопасность, выбор способа размещения объекта "по месту" или в "куче" и т.д.
Все перечисленные свойства добавляются с помощью реализации механизма "умных" оберток, базовый набор которых представлен в библиотеке feature и может быть легко расширен любыми пользовательскими решениями.
```
void foo ()
{
using namespace ::ScL::Feature;
using Tool = Implicit::Shared;
using Text = Wrapper< ::std::string, Tool >;
Text text = "Hello World!";
Text other = text; // implicit shared "Hello World!"
}
```
Хотите узнать как? Прошу под кат.
Мотивация
---------
Не возникает ли у вас чувство досады, если готовое решение не может быть использовано в вашем приложении из-за того, что не обладает необходимыми свойствами? И приходится формировать громоздкую, часто однотипную дополнительную функциональность поверх того, что есть. Или, что ещё чаще, писать собственную реализацию очередного велосипеда, отличающегося цветом, рамой или формой колес.
Вот некоторые случаи желательной дополнительной функциональности и примеры их реализации.
### Strong typedef
В программах часто один и тот же тип используется для декларации совершенно не совместимых между собой понятий. Например, типом std::string могут быть представлены url, e-mail, ФИО, адрес и т.д. И что делать, если для каждого из этих типов предусмотрен свой уникальный способ обработки? Подобный вопрос поднимался, например, на конференции [CppCon 2018](http://cppcon.org) в докладе [Erik Valkering. Smart References. There and Back Again](https://github.com/CppCon/CppCon2018/blob/master/Presentations/smart_references_there_and_back_again/smart_references_there_and_back_again__erik_valkering__cppcon_2018.pdf).
Такой код просто не соберется
```
using FileName = string;
using Url = string;
auto read ( FileName file_name ) { /*read from disk*/ }
auto read ( Url url ) { /*read from internet*/ }
auto test ()
{
auto filename = FileName{ "foobar.txt" };
auto url = Url{ "http://foobar.com/" };
cout << "From disk [" << filename << "]: " read(filename) << "\n";
cout << "From web [" << url << "]: " read(url) << "\n";
}
```
А подобный соберется запросто (пример с конференции модифицирован для демонстрации средств библиотеки feature)
```
using Filename = Wrapper< string, Inplace::Typedef< class Filename_tag > >;
using Url = Wrapper< string, Inplace::Typedef< class Url_tag > >;
auto read ( Filename filename ) { /*read from disk*/ }
auto read ( Url url ) { /*read from internet*/ }
auto test ()
{
auto filename = Filename{ "foobar.txt" };
auto url = Url{ "http://foobar.com/" };
cout << "From disk [" << filename << "]: " << read(filename) << "\n";
cout << "From web [" << url << "]: " << read(url) << "\n";
}
```
### Thread safe
А что, если хочется сделать любой объект потокобезопасным? Тогда можно использовать подобное решение
```
using Map = map< string, pair< string, int > >;
using AtomicMutexMap = Wrapper< Map, ThreadSafe::Atomic >;
void func ()
{
test_map[ "apple" ]->first = "fruit";
test_map[ "potato" ]->first = "vegetable";
for ( size_t i = 0; i < 100000; ++i )
{
test_map->at( "apple" ).second++;
test_map->find( "potato" )->second.second++;
}
auto read_ptr = &as_const( test_map );
cout
<< "potato is " << read_ptr->at( "potato" ).first
<< " " << read_ptr->at( "potato" ).second
<< ", apple is " << read_ptr->at( "apple" ).first
<< " " << read_ptr->at( "apple" ).second
<< "\n";
}
void example ()
{
AtomicMutexMap test_map;
vector< thread > threads( thread::hardware_concurrency() );
for ( auto & t : threads ) t = thread( func, test_map );
for ( auto & t : threads ) t.join();
}
```
Пример взят и модифицирован из статьи [Делаем любой объект потокобезопасным](https://habrahabr.ru/post/328348/)
### Implicit Sharing
Eсли появилось желание применить технику [Copy-on-write (COW)](https://wikipedia.org/wiki/Copy-on-write), известную также как неявное обобщение [Implicit Sharing](https://doc.qt.io/qt-5/implicit-sharing.html), широко применяемое в известной библиотеке Qt, то средства библиотеки feature легко позволяют это сделать простой декларацией собственного типа String.
```
using String = Wrapper< std::string, Implicit::Shared >;
void example ()
{
String first{ "Hello" };
String second = first; // implicit sharing
first += " World!"; // copying on write
}
```
### Optional
В стандарте C++17 в обиход введен весьма полезный класс-обертка [std::optional](https://en.cppreference.com/w/cpp/utility/optional) для удобной работы с опциональными значениями. Подобная функциональность может быть достигнута с помощью средств библиотеки feature так же легко:
```
using OptionalString = Wrapper< std::string, Inplace::Optional >;
OptionalString create( bool b )
{
if (b)
return "Godzilla";
return {};
}
int example ()
{
cout << "create(true) returned "
<< create( true ).value() << "\n";
cout << "create(false) returned "
<< create( false ).valueOr( "empty" ) << "\n";
}
```
Дополнительный интерфейс value и valueOr реализуется с помощью приема "подмешивания" функциональности [MixIn](https://wikipedia.org/wiki/Mixin), реализацию которого рассмотрим чуть ниже.
По своей сути, прием "подмешивания" функциональности позволяет реализовать любой интерфейс для объекта типа Wrapper, в том числе адаптировать или полностью рефлексировать интерфейс для конкретного типа и/или инструмента.
### Еще что-то?
Конечно! Здесь рассмотрены далеко не все возможные особенности, которые могут быть дополнительно применены к типам. Средства библиотеки feature позволяют пользователю довольно гибко добавлять собственные дополнительные особенности, например, использовать отложенные или фоновые вычисления, управлять распределением объектов в памяти, реализовывать кеширование данных и формировать любую другую функциональность.
Для этого необходимо реализовать свой собственный так называемый инструмент применения особенностей, который подробнее рассмотрим в разделе с описанием архитектуры feature.
Суперпозиция особенностей
-------------------------
А что если требуется применить сразу несколько дополнительных особенностей? В этом случае средства библиотеки feature позволяют использовать их суперпозицию.
Например, если требуется определить тип для потокобезопасного (thread safe) неявно обобщённого (implicit shared) объекта типа std::string, то это может быть сделано так
```
using String = Wrapper< Wrapper< std::string, Implicit::Shared > ThreadSafe::Mutex >;
```
либо так (результат эквивалентный)
```
using String = Wrapper< std::string, Implicit::Shared, ThreadSafe::Mutex >;
```
Можно перечислить любое количество дополнительных особенностей, применение которых происходит в порядке "от последнего к первому".
То есть, если определить такой тип
```
using String = Wrapper< std::string, ThreadSafe::Mutex, Implicit::Shared >;
```
то его следует читать, как неявное обобщение потокобезопасного объекта типа std::string, что не является эквивалентом определенного выше, и, в конечном счете, не гарантирует его потокобезопасность из-за того, что последним применено непотокобезопасное свойство неявного обобщения.
Архитектура feature
-------------------
### Тип умной ссылки Wrapper
Основным типом данных, который предоставляет библиотека feature, является тип Wrapper из пространства имен ScL::Feature.
```
namespace ScL { namespace Feature {
template < typename _Value, typename ... _Tools >
using Wrapper; // computable type
}}
```
Тип `Wrapper` представляет собой умную обертку с рефлексией всех конструкторов и всех видов операторов, кроме оператора извлечения адреса `operator &`.
Функциональность типа `Wrapper` определяется реализацией инструмента `_Tools`, которые указываются в качестве параметров шаблона следующими после типа `_Value`. Собственно, экземпляр типа `Wrapper` агрегирует экземпляр типа `_Value`, владеет им, управляет временем его жизни, обеспечивает применение дополнительных свойств и предоставляет доступ к экземпляру типа `_Value` посредством механизмов, реализованных в инструментах `_Tools`.
### Инструмент
Тип инструмента введен для удобства и компактности определения `Wrapper` и по сути играет роль пространства имен, в котором должен быть реализован шаблонный тип `Holder`
```
template < typename _Value >
struct Holder;
```
Интерфейс типа `Holder` должен иметь все возможные виды реализации конструкторов, которые могут потребоваться при его использовании. Как правило, это означает обеспечение наличия конструктора для любого типа данных `_Value`.
```
template < typename _Value >
struct Holder
{
using ThisType = Holder< _Value >;
using Value = _Value;
template < typename ... _Arguments >
Holder ( _Arguments && ... arguments );
// ...
};
```
Для обеспечения доступа к значению типа `_Value` реализация `Holder` должна иметь реализацию методов `value` на все возможные случаи использования
```
template < typename _Value >
struct Holder
{
using ThisType = Holder< _Value >;
using Value = _Value;
static Value && value ( ThisType && holder );
static const Value && value ( const ThisType && holder );
static volatile Value && value ( volatile ThisType && holder );
static const volatile Value && value ( const volatile ThisType && holder );
static Value & value ( ThisType & holder );
static const Value & value ( const ThisType & holder );
static volatile Value & value ( volatile ThisType & holder );
static const volatile Value & value ( const volatile ThisType & holder );
};
```
Эти методы обеспечивают доступ к значению с сохранением квалификаторов доступа `const`, `volatile` и типа ссылки `rvalue`/`lvalue`. Допускается реализация в виде шаблона, но с сохранением вышеперечисленных свойств.
Теперь самое интересное! Обеспечение реализации той или иной дополнительной особенности достигается с помощью опциональной реализации соответствующих методов `guard`/`unguard`.
```
template < typename _Value >
struct Holder
{
using ThisType = Holder< _Value >;
using Value = _Value;
static void guard ( ThisType && );
static void guard ( const ThisType && );
static void guard ( volatile ThisType && );
static void guard ( const volatile ThisType && );
static void guard ( ThisType & );
static void guard ( const ThisType & );
static void guard ( volatile ThisType & );
static void guard ( const volatile ThisType & );
static void unguard ( ThisType && );
static void unguard ( const ThisType && );
static void unguard ( volatile ThisType && );
static void unguard ( const volatile ThisType && );
static void unguard ( ThisType & );
static void unguard ( const ThisType & );
static void unguard ( volatile ThisType & );
static void unguard ( const volatile ThisType & );
};
```
Методы реализуются только на случаи их особого использования. При отсутствии их реализации не вызывается ничего.
Для доступа к значению для экземпляра объекта умной ссылки типа Wrapper реализуется следующий порядок вызовов методов:
* определяется контекст использования умной ссылки - квалификаторы доступа и тип ссылки;
* вызывается соответствующий метод `guard` (при наличии реализации), который обеспечивает реализацию какого-либо свойства;
* вызывается соответствующий метод `value`;
* осуществляется работа с экземпляром значения типа `_Value` в месте вызова;
* вызывается соответствующий метод `unguard` (при наличии реализации), который обеспечивает утилизацию свойства, реализованного в `guard`.
Синтаксис
---------
Для реализации работы с экземплярами умной ссылки типа `Wrapper` можно добиться использования синтаксиса, полностью совместимого с внутренним типом `_Value`. Достигается это с помощью вспомогательного типа умного указателя `ValuePointer`
```
template < typename _WrapperRefer >
class ValuePointer;
```
Реализация оператора извлечения адреса `operator &` для типа `Wrapper` возвращает значение типа `ValuePointer`, в конструкторе которого вызывается метод `guard`, а в деструкторе `unguard`.Таким образом, во время существования экземпляра значения типа `ValuePointer` гарантируется применение свойств, реализованных в соответствующих инструментах.
В свою очередь, применение оператора разыменования `operator *` к указателю типа `ValuePointer` предоставляет доступ к внутреннему значению, для которого сохраняются все свойства квалификаторов `const`, `volatile` и типа ссылки `rvalue`/`lvalue`.
Следующий пример демонстрирует возможность применения умной обертки Wrapper с сохранением синтаксиса, совместимого с внутренним типом данных.
```
struct MyType
{
int m_int{};
double m_double{};
string m_string{};
};
template < typename _Type >
void print ( const _Type & value )
{
using namespace std;
cout << "int: " << (*&value).m_int << "\n"
<< "double: " << (*&value).m_double << "\n"
<< "string: " << (*&value).m_string << "\n";
}
void foo ()
{
using namespace ScL::Feature;
print( MyType{} );
print( Wrapper< MyType >{} );
print( Wrapper< MyType, Implicit::Raw >{} );
}
```
### Доступ к членам экземпляра объекта
Доступ к членам экземпляра объекта осуществляется для ссылки с помощью `operator .`, а для указателя с помощью `operator ->`. При этом оператор доступа для указателя может быть перегружен и имеет уникальное свойство - его вызов будет многократно разворачиваться до тех пор, пока это возможно, что позволяет использовать широко известную [Execute Around Pointer Idiom](https://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Execute-Around_Pointer).
Подобная возможность отсутствует для `operator .`, хотя на этот случай имеются несколько предложений в стандарт С++, например, [P0416(N4477)](http://www7.open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0416r1.pdf) или [P0352](https://isocpp.org/files/papers/p0352r1.pdf). Пока ни одно из предложений не реализовано, доступ к членам экземпляра объекта через обертку типа `Wrapper` реализован с помощью оператора `operator ->`, как и для обертки из стандартной библиотеки [std::optional](https://en.cppreference.com/w/cpp/utility/optional).
```
struct MyType
{
int m_int{};
double m_double{};
string m_string{};
};
void bar ()
{
Wrapper< MyType > value{};
value->m_int = 1;
value->m_double = 2.0;
value->m_string = "three";
}
```
Такой синтаксис не совместим с базовым и не отражает, что значение `value` является умной ссылкой, а не указателем.
### Рефлексия операторов
Чтобы сохранять привычный синтаксис при использовании экземпляров значений типа `Wrapper` в алгебраических выражениях, средства библиотеки feature реализуют полную рефлексию всех операторов, доступных для внутреннего типа данных. Операторы возвращают умные обертки над возвращаемым результатом оператора базового типа, которые гарантируют применение всех свойств для внутреннего значения на всем протяжении своего существования.
```
void foo ()
{
using Map = Wrapper< map< int, string > >;
Map m;
m[1] = "one";
m[2] = "two";
}
void foo ()
{
using Int = Wrapper< int >;
Int v{ 16 };
v += 16; // 32
v /= 2; // 16
v <<= 1; // 32
v = ( v * v + 1 ) + v; // 1057
}
```
### Методы std::begin, std::end
Для возможности использования умных оберток для циклов `for`, основанных на диапазоне, а также в стандартных алгоритмах, для них реализованы методы `std::begin`, `std::end` и другие. Эти методы возвращают умные обертки над соответствующими итераторами, которые гарантируют применение всех свойств для контейнера во время существования этих итераторов.
```
void foo ()
{
using Vector = Wrapper< ::std::vector< int > >;
Vector values{ { 0, 1, 2, 3, 4 } };
for ( const auto & value : values )
cout << value << "\n";
}
```
### Адаптация к произвольному интерфейсу
В реализацию типа Wrapper библиотеки feature встроена возможность добавления дополнительного интерфейса с помощью приема "подмешивания" функциональности [MixIn](https://wikipedia.org/wiki/Mixin).
Используя концепцию примесей MixIn имеется возможность подмешать дополнительный интерфейс к реализации "умной" обертки `Wrapper`. При этом интерфес может быть подмешан к определенному типу и/или инструменту путем специализации следующего класса
```
template< typename _Type >
class MixIn {}
```
Например, для обертки, реализующей опциональность, реализована такая специализация
```
template< typename _Type >
class MixIn< Detail::Wrapper< _Tool, Inplace::Optional > { /*...*/ }
```
что позволило добавить методы к интерфейсу `value`, `valueOr`, `emplace`, `reset`, `swap`, `hasValue` и оператор приведения к `bool`.
### Заключение
Реализация "умных" оберток из состава библиотеки feature позволяют достаточно легко добавлять различные особенности применения к любым пользовательским типам.
Рефлексия операторов и некоторых других методов позволяет использовать функциональность оберток с небольшими изменения кодовой базы.
Реализация библиотеки в виде только заголовочных файлов позволяет легко интегрировать решение в любой проект.
[Проект инструментов ScL доступен по ссылке](https://gitlab.com/ssoft-scl/complex/scl-kit) | https://habr.com/ru/post/650701/ | null | ru | null |
# Делаем простую RC-аэролодку
Иногда в интернете вижу вопросы от новичков, которые хотят с нуля построить квадрокоптер и написать к нему прошивку. Сам являюсь таким и чтобы попрактиковаться в создании RC моделей решил начать с чего-то более простого.
В статье в подробностях для самых маленьких описал алгоритм работы лодки, пульта управления и выбор компонентов.
Почему аэролодка?
-----------------
1. Просто;
2. Дёшево;
3. Она может двигаться в природных условиях;
4. Можно тренироваться настраивать разные варианты управления, включая ПИД-регулятор.
Летающие аппараты — это здорово, но сложно. В воздухе нельзя так просто выключить винты, если что-то пойдёт не так. Да и удельная тяга нужна весьма приличная даже для самолётов не говоря уже про мультикоптеры.
Платформы по типу этой
([тут](http://informatik-m.ru/mir_robototehniki/kak-sdelat-mini-robota-svoimi-rukami.html) есть более подробное описание).
умеют двигаться только по, в большинстве случаев, искусственной ровной поверхности, да и управление у них сильно отличается.
А вот на воде мы можем плыть куда угодно, что в дальнейшем может дать нам возможность сделать автопилот с использованием GPS. Классическая конструкция с гребным винтом для меня сложна узлом выхода вала из корпуса — не представляю как его загерметизировать.
Ещё преимущества воздушного движителя:
1. Его можно ставить на разные платформы: лодку, сани, кусок пенопласта...
2. Он не зацепится за дно или водоросли.
Надо чтобы аппарат мог поворачивать. Есть 3 варианта:
1. [Один винт + руль для поворотов](https://www.youtube.com/watch?v=b3DOPYeYqZY);
2. [Один винт + система его поворачивающая](https://www.youtube.com/watch?v=8LyCP_28QAg);
3. Два жёстко закреплённых винта. Поворачивать меняя их тягу — самый простой способ. Его и использовал.
Пульт дистанционного управления
-------------------------------
### Принцип действия
1 джойстик + несколько переключателей. Задача пульта — несколько раз в секунду посылать в эфир данные о положении ручки джойстика и переключателей.
### Из чего делать
Во-первых, нужен радиопередатчик. Самый дешёвый вариант — это NRF24L01+, стоит [$0.85](http://www.ebay.com/itm/2PCS-Hot-Sell-NRF24L01-2-4GHz-Antenna-Wireless-Transceiver-Module-for-Arduino-/221746847061).
Во-вторых, нужен джойстик. Ещё [$1](http://www.ebay.com/itm/Hot-Sale-JoyStick-Breakout-Module-Shield-PS2-Joystick-Game-Controller-Arduino-/201416176593).
Несколько переключателей — [$0.12](http://www.ebay.com/itm/10Pcs-Slide-Type-Switch-Module-2-54mm-4-Bit-4-Position-Way-DIP-Red-Pitch-FKS-/321897494822).
Ну и всё это закрепить на куске текстолита за [$0.13](http://www.ebay.com/itm/10Pcs-5-x-7-cm-DIY-Prototype-Paper-PCB-fr4-Universal-Board-prototyping-pcb-kit-/181846671646).
Уже насчитали $2.1, а нужен ещё МК и питание. Тут всё не так однозначно.
Забегая вперёд, скажу, что вполне достаточно ATmega8 или STM8S103F3P6, но так как начинал этот проект я давно и опыта было мало, влепил в пульт управления Arduino Pro Mini, а в лодку Arduino Nano (везде ATmega32P).
В пульт ещё понадобились:
1. Преобразователь питания 0.9 — 5 В -> 5 В для питания Arduino за [$0.35](http://www.ebay.com/itm/5PCS-0-9V-5V-to-5V-DC-DC-Booster-USB-Mobile-Step-up-Power-Supply-Module-/181916952600) (разъём USB, вместе с куском платы, можно отломать для компактности);
2. Стабилизатор 3.3 В AMS1117-3.3 для питания радиомодуля, стоят они по [$0.03 в пересчёте на штуку](http://www.ebay.com/itm/100PCS-AMS1117-3-3-LM1117-1A-3-3V-SOT-223-Voltage-Regulator-/181930531943);
3. Батарейный отсек для одного пальчикового аккумулятора за [$0.15](http://www.ebay.com/itm/10Pcs-1-5V-Plastic-Hard-Storage-Holder-Case-Box-For-1-AA-Battery-With-Wire-Leads-/262239973732);
Всего плюс $0.53. Не считая контроллера, пары конденсаторов и проводов, стоимость компонентов пульта получается $2,63.
Начинка радиоуправляемой модели
-------------------------------
### Компоненты
Тут всё идёт от двигателей. Какие двигатели купите, такой мощности электронику и придётся ставить, и база (судно, сани) потребуются соответствующей грузоподъёмности. Да и идеологически, всё остальное нужно лишь для того, чтобы вращать винты с нужной скоростью.
Я купил вот такие моторчики с пропеллерами
по [$2.88 за пару](http://www.ebay.com/itm/2PCS-DC-3-7V-22000RPM-Coreless-Motor-Propeller-for-RC-Aircraft-Helicopter-Toy-/381374910740).
В качестве драйвера моторов взял L293D — ещё [$0.35](http://www.ebay.com/itm/5PCS-Push-Pull-Four-Channel-Motor-Driver-IC-ST-DIP-16-L293D-/272041696769).
**И тут огрёб проблем**
Для L293D коммутируемое напряжение должно быть не ниже напряжения питания логики. А эти моторчики весьма сильно просаживали напряжение в результате чего ток от питания логики перетекал в моторы и питание логики вместе с питанием микроконтроллера тоже просаживалось вплоть до того, что МК отключался.
Питание. Нам потребуются аж три напряжения питания:
1. 5 В для всей электроники кроме радиомодуля;
2. 3.3 В для радиомодуля;
3. для моторчиков сколько им нужно (моим 4.2 В).
1 и 2 получим также как в пульте управления, а для моторчиков поставим MT3608 за [$0.86](http://www.ebay.com/itm/MT3608-DC-DC-Step-Up-Power-Apply-Module-Booster-Power-Module-for-Arduino-WF-R4-/141881461656).
Теперь самое интересное: гироскоп. Модуль MPU-6050 [стоит $1.53](http://www.ebay.com/itm/MPU-6050-3-Axis-Gyroscope-Acce-lerometer-Module-3V-5V-Compatible-Arduino-/181922780294). Было желание использовать ещё и акселерометр, чтобы при движении ручки джойстика в сторону судно разворачивалось на месте. Но в итоге от этой идеи отказался: небольшой наклон по тангажу, и система начинает думать, что она ускоряется вперёд или назад. Проще оказалось разворачивать судно на месте просто компенсируя джойстиком движение вперёд/назад.
Добавим к этому $0.4 за батарейный отсек на 2 элемента AA и получим компонентов на $6.4 без контроллера и проводов.
### Программа
И снова пойдём от двигателей. Каждый из двух двигателей управляемый L293D может ~~копать, а может не копать~~:
1. Крутить вперёд;
2. Крутить назад;
3. Не крутить.
Чтобы код легче читался, напишем
**6 функций**
```
inline void motLeftStop(){
PORTD &= ~(1 << MOT_LEFT_PLUS);
PORTD &= ~(1 << MOT_LEFT_MINUS);
}
inline void motLeftForward(){
PORTD |= 1 << MOT_LEFT_PLUS;
PORTD &= ~(1 << MOT_LEFT_MINUS);
}
inline void motLeftBackward(){
PORTD &= ~(1 << MOT_LEFT_PLUS);
PORTD |= 1 << MOT_LEFT_MINUS;
}
inline void motRightStop(){
PORTD &= ~(1 << MOT_RIGHT_PLUS);
PORTD &= ~(1 << MOT_RIGHT_MINUS);
}
inline void motRightForward(){
PORTD |= 1 << MOT_RIGHT_PLUS;
PORTD &= ~(1 << MOT_RIGHT_MINUS);
}
inline void motRightBackward(){
PORTD &= ~(1 << MOT_RIGHT_PLUS);
PORTD |= 1 << MOT_RIGHT_MINUS;
}
```
Теперь мы хотим управлять скоростью вращения винтов. Конечно, делать это будем при помощи ШИМ. Не знаю, можно ли такую ШИМ сделать аппаратно… я сделал программно на прерываниях. Объявим пару глобальных переменных
```
int8_t motLeft = 0, motRight = 0; // -127..+127
```
Пусть значения этих переменных < 0 означают, что крутить надо назад, значения > 0 — вперёд, а если они равны 0, то крутить не надо.
**Напишем обработчики прерываний таймера**
```
ISR(TIMER2_OVF_vect)
{
if(motLeft > 0)
motLeftForward();
else if(motLeft < 0)
motLeftBackward();
if(motRight > 0)
motRightForward();
else if(motRight < 0)
motRightBackward();
}
ISR(TIMER2_COMPA_vect)
{
motLeftStop();
}
ISR(TIMER2_COMPB_vect)
{
motRightStop();
}
```
Теперь, чтобы изменить скорость вращения пропеллера, нам надо сделать 2 действия:
1. Записать положительное, отрицательное или нулевое значение в motLeft/motRight (модуль не важен);
2. Записать «скорость вращения» в OCR2A/OCR2В.
**Напишем для этого ещё пару функций**
```
void setMotLeft(int8_t v){ // -127..+127
if(abs(v) < 5) v = 0;
motLeft = v;
OCR2A = abs(v) * 2;
}
void setMotRight(int8_t v){ // -127..+127
if(abs(v) < 5) v = 0;
motRight = v;
OCR2B = abs(v) * 2;
}
```
Строки
```
if(abs(v) < 5) v = 0;
```
нужны чтобы лодка не тратила энергию на попытку крутить винты записывая в OCR2x значение меньшее 5 (они при этом всё равно не крутятся).
**Теперь осталось настроить пины МК и таймер**
```
void motInit(){
DDRD |= (1 << MOT_LEFT_PLUS) | (1 << MOT_LEFT_MINUS) | (1 << MOT_RIGHT_PLUS) | (1 << MOT_RIGHT_MINUS);
//TCCR2B |= (1 << CS22)|(1 << CS21)|(1 << CS20); // set up timer with prescaler = 1024. Переполнение каждые 16 мс
//TCCR2B |= (1 << CS22)|(0 << CS21)|(0 << CS20); // set up timer with prescaler = 64. Переполнение каждую 1 мс
TCCR2B |= (0 << CS22)|(1 << CS21)|(0 << CS20); // set up timer with prescaler = 8. Переполнение 128 мкс
//TCCR2B |= (0 << CS22)|(0 << CS21)|(1 << CS20); // set up timer with prescaler = 1. Переполнение 16 мкс
TIMSK2 |= (1 << TOIE2)|(1 << OCIE2A)|(1 << OCIE2B); // enable overflow interrupt
TCCR2A &= ~(3); // set WGM20 = 0, WGM21 = 0
TCCR2B &= ~(1 << 3); // set WGM22 = 0
setMotLeft(0);
setMotRight(0);
sei();
}
```
И можно управлять моторчикам просто вызывая функции setMotLeft(int8\_t v) и setMotRight(int8\_t v).
Но мы же хотим управлять лодкой не так! Мы хотим давать команды типа «вперёд/назад» и «вправо/влево»! И пусть она сама разбирается, какие пропеллеры ей для этого куда придётся крутить. Более того, хочется, чтобы лодка сама компенсировала поворачивающее действие ветра, течения и… криво поставленных пропеллеров!
Пойдём теперь с другой стороны. Со стороны ПДУ. В простейшем случае алгоритм его работы следующий:
1. При включении питания запомнить начальное положение джойстика;
2. В цикле считывать положение джойстика, вычитать из него нулевое положение и отправлять данные на лодку.
Наш радиомодуль поддерживает пакеты до 32 байт. Чтобы не запоминать смещения, будем использовать запись
```
struct ControlStatus{
int16_t x,y;
} controlStatus;
```
**Следующим образом**
```
uint8_t packet[MAX_BUFF];
memset(packet, 0, MAX_BUFF);
controlStatus.x = (int16_t)analogRead(1) - x0;
controlStatus.y = (int16_t)analogRead(0) - y0;
memcpy(packet, &controlStatus, sizeof(controlStatus));
Mirf.send(packet);
while(Mirf.isSending()){;};
```
На стороне приёмника объявим точно такую же запись и
**будем её заполнять**
```
while (Mirf.dataReady()) {
uint8_t data[MAX_BUFF];
Mirf.getData(data);
memcpy(&controlStatus, data, sizeof(controlStatus));
setMotRot(-controlStatus.x);
setMotForward(controlStatus.y);
}
```
В функциях setMotRot и setMotForward
**запишем значения в глобальные переменные motRot и motForward**
```
void setMotRot(int16_t v){
if(abs(v)<10) v = 0;
motRot = (int32_t)v;
}
void setMotForward(int16_t v){
if(abs(v)<10) v = 0;
motForward = (int32_t)v;
}
```
И перейдём к самому интересному. К тому, как преобразовать «поворачивать налево со скоростью 5 градусов в секунду и чуть-чуть двигаться вперёд!» в «левый двигатель 10% назад, правый 20% вперёд!».
Про то, что такое [ПИД регуляторы](https://ru.wikipedia.org/wiki/%D0%9F%D0%98%D0%94-%D1%80%D0%B5%D0%B3%D1%83%D0%BB%D1%8F%D1%82%D0%BE%D1%80) написано достаточно много. Я использовал для вращения всего две составляющие:
1. Пропорциональную;
2. Интегральную.
А для движения вперёд-назад регулятор не стал использовать.
Разберём на примере:
```
int32_t iDeltaRot = 0;
void motTick(){
int32_t rot = getRotAvg(); // получаем реальную скорость вращения лодки
int32_t deltaRot = rot - motRot * rotMaxSpeed / 512;
iDeltaRot += deltaRot;
int32_t motRight = (int32_t)motForward * forwardMult - deltaRot * rotMult - iDeltaRot * iDeltaRotMult,
motLeft = (int32_t)motForward * forwardMult + deltaRot * rotMult + iDeltaRot * iDeltaRotMult;
int32_t motMax = max(abs(motRight), abs(motLeft));
if(motMax > 127){
motRight = (int32_t)motRight * 127 / motMax;
motLeft = (int32_t)motLeft * 127 / motMax;
}
setMotRight(motRight);
setMotLeft(motLeft);
}
```
Код упростил, чтобы сконцентрировать внимание на важных частях, в архиве будет полная версия.
Что же мы тут делаем?
1. Вычисляем разницу между реальной скоростью вращения лодки (rot) и желаемой (motRot \* rotMaxSpeed);
2. Вычисляем желаемые скорости вращения винтов motRight и motLeft;
3. Если желаемые скорости вращения превышают максимально возможные, уменьшаем их сохраняя соотношение между ними;
4. Вызываем уже знакомые нам setMotRight/setMotLeft.
Всё!
Это весь алгоритм управления лодкой!
Сложно? Мне кажется, нет. Но, тем не менее, в ходе испытаний и настроек возникала целая куча проблем, которая привела бы к многочисленным крушениям, если бы это был летательный аппарат.
В описанной функции есть 4 коэффициента:
1. forwardMult — чувствительность к движению джойстика вперёд/назад;
2. rotMaxSpeed — желаемая скорость поворота при наклоне джойстика до упора вправо/влево;
3. rotMult — коэффициент пропорциональной составляющей (насколько отклонение текущей скорости вращения от желаемой влияет на поворот);
4. iDeltaRotMult — коэффициент интегральной составляющей (насколько отклонение текущего угла разворота от желаемого влияет на поворот).
Эти коэффициенты настраиваем экспериментально, и от них будет зависеть реакция лодки на джойстик и внешние разворачивающие воздействия.
Индикация состояния
-------------------
При отладке/настройке будут возникать непонятки из серии «почему лодка реагирует на джойстик не так, как мне этого хочется?». Некоторые моменты можно отладить, выводя отладочную информацию на ПК, но было бы удобнее прямо на месте понимать, что происходит. Вначале я рассматривал 2 варианта:
1. Ноутбук;
2. **Дисплей Nokia 5110**
Недостатки и того, и другого понятны: ноутбук большой и его неудобно с собой таскать, а дисплей Nokia 5110 не позволит наглядно отобразить одновременно большое количество параметров состояния лодки.
Я взял нечто среднее между ними: [Nextion Enhanced NX4827K043 — Generic 4.3'' HMI Touch Display](https://www.itead.cc/nextion-nx4827k043.html). Благодаря сенсорному дисплею, можно прям на ходу быстро и удобно настраивать параметры лодки. Это своеобразный компьютер состоящий из:
1. Микроконтроллера GD32F103R8T6;
2. SDRAM Winbond W9864G6KH-6 (8 МБ);
3. Флеш памяти Winbond W25Q256FVFG (32 МБ, 100 000 циклов перезаписи, что весьма радует);
4. ПЛИС Altera MAX II EPM570T144C5N.
Всё в сборе выглядит вот так (кликабельно):
[](https://habrastorage.org/files/423/e3a/006/423e3a006a824678ade4d5a5ad52c99d.JPG)
Является этот компьютер/дисплей чёрным ящиком и заточен на взаимодействие с человеком. Даже имеющийся GPIO заточен для подключения кнопок и индикаторов. Их же [Expansion Board](https://www.itead.cc/nextion-expansion-board.html) это подтверждает. Так что использовать встроенный контроллер в качестве пульта управления лодкой (считывать показания джойстика, обмениваться данными с радиомодулем NRF24L01+) не получится. Для взаимодействия с микроконтроллером есть UART и… и всё.
О том, как и что можно делать при помощи этого дисплея можно делать, написано куча + есть ролики на Youtube. Посмотрите, например, [вот это](https://www.youtube.com/watch?v=D-zgtylBKUc) — там всё понятно показано. Но так как этот дисплей стоит дороже, чем все остальные компоненты лодки и пульта вместе взятые, опишу подробнее свои впечатления от работы с ним. Возможно, это кому-то поможет понять подходит ли ему этот вариант или ноутбук/дисплей Nokia 5110 будут предпочтительнее. Достоинства Nextion Enhanced NX4827K043:
1. Очень легко использовать. Есть простая документация, примеры, ролики на Youtube,… За пару часов можно разобраться с нуля. Почти всё, что надо про него знать находится на двух страницах: [вики страничка](https://www.itead.cc/wiki/NX4827K043) и [Instruction Set](https://www.itead.cc/wiki/Nextion_Instruction_Set)
2. Очень быстрая разработка. Визуальный редактор по типу Visual Studio (только проще). Накидал компонентов и всё работает.
3. Весьма качественные компоненты. Та же флеш память на 100k циклов перезаписи.
4. Отладчик, который может имитировать дисплей при помощи ПК и общаться с вашим МК через COM порт. Позволяет полностью разработать устройство, отладить и покупать дисплей, только если всё устроит.
**Хотя есть с ним проблема**
При частых обновлениях показаний дисплея отладчик не успевает даже на весьма неплохом компе. Железка работает гораздо быстрей. Впрочем, если в вашем случае удастся всё сделать в отладчике, то при переносе на железо ситуация ухудшиться не должна.
5. Резистивный сенсор. Можно создавать достаточно мелкие элементы управления и тыкать в них ногтем или любым стилусом.
Недостатки:
1. Цена. $50 всё-таки очень много для 4.3'' дисплея.
2. Существующих компонентов мало, настроек компонентов мало, как создавать свои непонятно. Частично это компенсируется функциями рисования примитивов (линии, прямоугольники, круги, ...).
3. Стандартный компонент Gauge мерцает при обновлении.
4. Нет (по крайней мере, я не нашёл) прозрачности.
5. Требования к источнику питания: 4.75-7 В и средний ток 250 мА. При просадке напряжения, дисплей начинает мигать.
6. Только UART. Могли бы сделать общение с ним ещё по SPI и I²C.
7. Вывод GPIO только под шлейф (нет гребёнки 2,54 мм), нет АЦП.
В целом, дисплей создаёт впечатление весьма качественного изделия, с которым легко и приятно работать.
Дисплей может выполнить сразу две задачи:
1. Индикация состояния. Меня в первую очередь интересуют:
* «Скорости вращения» винтов;
* Значение переменной iDeltaRot — насколько желаемый угол разворота отличается от желаемого;
* Скорость вращения лодки;
* Угол поворота лодки;
* Частота получения пакетов от пульта;
* Частота вызовов функции motTick.
2. Настройка параметров, а именно описанных выше forwardMult, rotMaxSpeed, rotMult, iDeltaRotMult.
Сделал 2 странички (кликабельны для оценки качества):
1. Индикации:
[](https://habrastorage.org/files/410/664/348/41066434884347ac96f56f486ea6b597.JPG)
2. Настройки параметров:
[](https://habrastorage.org/files/1c6/46b/725/1c646b72566e431ab7b4b0e98a2302b5.JPG)
Первые 4 колонки слева направо: forwardMult, rotMult, iDeltaRotMult, rotMaxSpeed.
Видео теста лодки на полу:
Реакция лодки на внешнее разворачивающее воздействие при различных iDeltaRotMult (интегральных коэффициентах):
Демонстрация влияния параметров на воде:
Видео на открытой воде заснять не удалось. Можете принять на веру, что управляемость у него хорошая, а максимальная скорость не очень.
Характеристики
--------------
* Тяга 9 г;
* Масса 115 г, из которых аккумуляторы весят 52г;
* Максимальное ускорение получаем в 0.77 м/с^2. До человеческих 5 км/ч, если бы не было сопротивления воды, лодка бы разгонялась за 1.8 с;
* Стоимость компонентов около $15 если использовать Arduino Nano и в пульте и в лодке (без дисплея и аккумуляторов).
Заключение
----------
Тем, у кого есть желание собрать что-то радиоуправляемое, рекомендую начать с судна с двумя фиксированными воздушными винтами. На мой взгляд, это самое простое, что можно сделать в этой области.
[Архив с проектами](https://dl.dropboxusercontent.com/u/46112531/DIY/toHabr/rcboat.zip)
Ну и напоследок, чтобы было к чему стремиться, вот видео удивительного аппарата: | https://habr.com/ru/post/390429/ | null | ru | null |
# Безумные умения фанатов графических калькуляторов
В середине-конце 2000-х в любой школе США всегда был какой-нибудь ребёнок, записывавший на графический калькулятор игры. Возможно, вас не удивит, что некоторые такие люди не находились в полном вакууме. На самом деле, существовала процветающая сцена хакеров, подчинявших эти калькуляторы своей воле; они писали игры, математическое ПО и в целом *хакали* платформу просто ради самого этого процесса.
В этой статье я расскажу о хакинге калькуляторов Texas Instruments, которым занимались в течение последних двух с половиной десятков лет, а также объясню, *почему* эти проекты настолько впечатляют с технической точки зрения.
*Это xkcd №768. 768 байт — это ещё и буфер ОЗУ, использовавшийся для хранения битовых изображений дисплея TI. Это не совпадение, потому что у xkcd никогда не бывает совпадений.*
Платформа
---------
В 90-х и 2000-х TI выпустила ряд графических калькуляторов на основе процессора Z80. Возможно, вы слышали о Z80 — это улучшенная версия Intel 8080, разработанная Zilog. Да, этот процессор настолько стар. [Существует разновидность [популярных хобби-проектов](https://hackaday.com/tag/z80) — создание собственного компьютера на Z80, именно потому, что он настолько прост, что вы можете понять основы системы. Лично мне больше всего нравится [красивый минималистичный Z80 Джима Макартура](https://hackaday.com/2014/12/01/a-z80-computer-with-switches-and-blinkenlights/) в вырезанном лазером корпусе и с *кнопкой* для пошагового выполнения команд!]
Когда эти процессоры выпустили (*45 лет назад*! ), они были довольно неплохи. Все калькуляторы TI обычно имели схожие маломощные характеристики:
* **Процессор Z80**, обычно имеющий частоту 8 или 10 МГц; к тому же стоит учесть, что Z80 способен завершать одну команду только каждые 4 такта.
* Чёрно-белый **ЖК-дисплей** с разрешением 96x64 (некоторые модели имели экран побольше, но это был самым распространённым. Поздние модели наконец-то обзавелись цветными экранами большего разрешения.)
* **Линк-порт (порт связи)**, в котором использовался 2,5-миллиметровый разъём от наушников
* Обычно **32 КБ ОЗУ**, а начиная с 83+ и далее от 100 КБ до 2 МБ **флеш-памяти** («архива»)
* Операционная система TI по прозвищу TI-OS (официально её название EOS, но никто кроме компании её так не называл). TI-OS имела:
+ Движок арифметических вычислений и построения графиков
+ Скриптовый язык TI-BASIC
+ В моделях с флеш-памятью — поддержка запуска больших «приложений», хранившихся целиком на флеше
Всё это даёт понять, что среда была очень ограниченной по возможностям.
Разумеется, самым популярным графическим калькулятором был TI-83/84 Plus, который, вероятно, видел каждый американский студент, учившийся за последние двадцать пять лет. В этой статье я буду использовать TI-84 Plus, потому что эта модель вам скорее всего знакома; однако её часто называют TI-83 Plus, потому что по сути они были одинаковыми. 84 Plus имел USB и изменённый дизайн корпуса, но система оставалась той же.
### Модель программирования
Среда программирования на ассемблере Z80 была довольно спартанской: не имелось ни супервизора. ни защиты памяти, поэтому при возникновении бага он с большой вероятностью приводил к зависанию калькулятора (зловещее сообщение «RAM Cleared»). [Как правило, Z80 сильно усложнял жизнь людей, пытавшихся создать для него хороший компилятор C. Наверно, у меня есть единственная оставшаяся копия HITECH-C для DOS, который был довольно приличным компилятором C. Подробнее я расскажу об этом в ещё одной статье.] Z80 — это 8-битная машина с 16-битными указателями, поэтому хотя архив, строго говоря, был отображён на память, его невозможно было уместить целиком и он был разбит на страницы по 16 КБ:
*Схема сильно упрощена, но недостаток мощи всё равно очевиден.*
Существовало множество руководств по изучению ассемблера, но лучший был написан Шоном Маклафлином («eeems») — [*Learn TI-83 Plus Assembly in 28 Days*](https://tutorials.eeems.ca/ASMin28Days/welcome.html). TI предоставляла очень хорошую [документацию по SDK](https://education.ti.com/en/guidebook/details/en/830D08FF31804AEAA2F03B8F5E89AD14/83psdk) о подпроцедурах, имеющихся в TI-OS (и об официальной поддержке программ `Asm()`); благодаря всему этому вы получали полную власть над системой.
Программные проекты
-------------------
Те, кто следил за новостями хакинга калькуляторов, наверняка узнает упоминаемых здесь людей или по их имени, или, что вероятнее, по нику. Лично я почти всегда просто читал информацию, в основном из-за влияния своих родителей, которые не очень приветствовали общение с людьми онлайн. (Не забывайте, я был в старшей школе.) Однако я был достаточно хорошим программистом-самоучкой калькуляторов (подробнее об этом в ещё одной статье).
> **Примечание**: довольно многие ссылки начинают «протухать», потому что разработка велась двадцать лет назад. Большое спасибо Web Archive за сохранение всего этого!
### Phoenix
Самой популярной игрой для графических калькуляторов была [*Phoenix*](https://www.ocf.berkeley.edu/~pad/game-ti83p-phoenixz.html) разработчика [Патрика Дэвидсона](https://www.ocf.berkeley.edu/~pad/). Это был космический шутер с видом сверху, похожий на аркадную игру Galaxian. Она была популярной не из-за увлекательности (хоть она и увлекательна) и не из-за качества реализации (хоть она и качественно сделана). Скорее, она знаменита, потому что была одной из первых, а Патрик и другие люди портировали её почти на каждый калькулятор с Z80.
### Оттенки серого на TI-84 Plus
Помню, что первой поразившей меня игрой стала RPG Патрика Прендергаста (tr1p1ea) под названием [*Desolate*](https://www.ticalc.org/archives/files/fileinfo/331/33153.html), которая могла похвастаться *четырьмя уровнями серого*. К тому же игра не просто была технологическим демо; она имела полноценный сценарий и достаточно неплохую спрайтовую графику. [Игра оказалась настолько хорошей, что получила несколько фанатских портов для [ZX Spectrum](https://github.com/nzeemin/spectrum-desolate) и некоторых [старых советских компьютеров](https://github.com/nzeemin/uknc-desolate).]
*Большинство эмуляторов способно понять, что приложение реализует оттенки серого, и обеспечивать их чёткий рендеринг*
Как это было возможно на устройстве с чёрно-белым экраном? Дело в том, что если включать и отключать пиксели достаточно быстро, то они будут *казаться* серыми. Наивные попытки реализации приводили к ужасному мерцанию и не могли дать больше, чем три цвета (чёрный, белый и серый). [Библиотека оттенков серого](https://www.ticalc.org/archives/files/fileinfo/295/29520.html) Дарка Кингма, которая использовалась в *Desolate*, позволяла получать красивую графику в четырёх уровнях серого благодаря точно подобранным таймингам и дизерингу мерцающих пикселей для того, чтобы не все они включались и отключались одновременно. Графика потребляла основную часть бюджета вычислительных ресурсов игры, но такова судьба большинства видеоигр!
### Эмулятор Game Boy для TI-84 Plus
TI — не единственная компания, использовавшая процессоры Z80. Они были установлены и в первом Game Boy! Возникает естественный вопрос: вероятно, есть возможность запустить игру для Game Boy на калькуляторе в неком гипервизоре?
Брендан Флетчер (calc84maniac) применил *кучу* инженерных решений для создания [TI-Boy SE](https://github.com/calc84maniac/tiboyse), который выполняет как раз эту задачу! Картридж Game Boy достаточно велик — ROM *Pokémon Red* занимает 1 МБ — поэтому TI-Boy решает эту проблему, запаковывая ROM в приложение-«оболочку» во флеш-памяти. Это приложение создаётся при помощи программы для PC. Разумеется, для этого нужен ROM вашего собственного картриджа Game Boy.
Ещё одна проблема заключается в том, что многие картриджи Game Boy имеют больше ОЗУ (до 128 КиБ), чем TI-84 Plus (32 КиБ). (В Game Boy было встроено всего 8 КиБ, но картриджи могли добавлять память.) Кажется, что это тупик: как возможно эмулировать дополнительную ОЗУ?
Ксавье Андреани заметил, что калькуляторы TI на самом деле имели дополнительную ОЗУ, потому что содержащая Z80 специализированная интегральная схема содержала больше ОЗУ, чем по умолчанию видно. TI-Boy выполнил реверс-инжиниринг специальных команд оборудованию для переключения этой памяти в адресное пространство по принципу банков.
Результат впечатляет:
*TI-Boy с запущенной *Legend of Zelda**
### Оболочки
На калькуляторах, выпущенных до TI-83 Plus, не существовало официального способа запуска программ на языке ассемблера. Эти калькуляторы приходилось хакать при помощи различных техник. Решением для конечных пользователей была *оболочка* — программа-лончер, занимавшаяся всей трудоёмкой работой по перехвату управления от ОС. Многие оболочки также предоставляли дополнительные процедуры, которые могла вызывать программа.
На TI-82 [оболочка Ash](https://www.ticalc.org/archives/files/fileinfo/14/1411.html) выполняла эту задачу отправкой специально созданной резервной копии памяти в калькулятор. При следующей обработке нажатия клавиши калькулятором образ памяти перенаправлял ЦП к коду настройки. В каком-то смысле эта техника является одним из старейших эксплойтов калькуляторов TI.
Оболочка, которая вам скорее всего запомнилась — это MirageOS для 84+. MirageOS была популярным компаньоном игр, передаваемых между пользователями по линк-кабелю, потому что игры нужно было как-то запускать. Кроме того, это приложение, хранившееся во флеш-памяти, поэтому оно сохранялось при очистке ОЗУ. Помню, что когда я его видел, мне было не совсем понятен смысл сложности экрана заставки, но теперь я ценю эту графику!
Со временем оболочки становились сложнее, и кульминацией этого стала [Doors CS](https://dcs.cemetech.net/index.php?title=Main_Page) Кристофера Митчелла (KermMartian), в которой имелись значки для ассемблерных программ, UI с курсором и множество процедур, которые могли использовать программы.
### USB-драйвер для использования TI-84+ в качестве накопителя
84+ имел очень странный USB-порт: это был порт On-the-Go, на момент выпуска которого информации о нём почти не было. Строго говоря, это означало, что 84+ мог работать в качестве USB-хоста. Usb8x Дэна Энглендера предоставляла отсутствующий код драйвера, позволяя использовать мышь (функция сомнительной полезности), клавиатуру и, что более важно, флеш-накопитель.
Загрузочный код калькулятора предоставлял низкоуровневые процедуры USB для отправки/получения, но самое удивительное заключалось в верхнем стеке USB — драйвер запоминающего устройства и FAT16 (msd8x). И всё это, разумеется, было написано [на ассемблере Z80](http://usb8x.sourceforge.net/)!
Среди прочего, Usb8x позволял запускать забавное демо: Майкл Винсент, вероятно, был одним из немногих людей, впервые посмотревших *«Матрицу»* на калькуляторе.
### KnightOS
[Дрю Деволт](https://drewdevault.com/) (SirCmpwn) работал над многообещающим проектом по полной *замене* TI-OS на совершенно новую многозадачную систему в стиле Unix под названием [KnightOS](https://knightos.org/). Интересно в этой системе то, что она многое позаимствовала из парадигм многозадачности, которые на компьютере с Mac или Linux кажутся чем-то само собой разумеющимся, но реализовано всё это было почти без помощи оборудования. Программы можно было перемещать, имелась приоритетная многозадачность и загружаемые библиотеки, которые работали точно так же, как разделяемые объекты в Unix. Также присутствовали «реальная» файловая система с папками, выравнивание износа флеш-памяти и протокол для подключения к компьютеру. (У него даже был [собственный USB PID](https://pid.codes/1209/CA1C/) — `CA1C`.)
Разумеется, всё это было аккуратно написано на ассемблере Z80, а процедуры ядра и библиотек документировали содержимое каждого регистра.
Это не vaporware — существуют автоматически сгенерированные сборки, которые можно скачать и установить на калькулятор, а исходники выложены [на GitHub](https://github.com/KnightOS/KnightOS). К сожалению, широкий спектр возможностей не позволил ОС достичь стабильного релиза, но скелет уже существовал, и он был прекрасен.
Я сам сделал вклад в этот проект: помню, что только что узнал о примитивах синхронизации (мьютексах и условных переменных) и уже знал достаточно много о Z80 для того, чтобы [реализовать их для KnightOS](https://github.com/KnightOS/kernel/blob/master/src/00/concurrency.asm).
### Проект Axe Parser
Как вы можете понять, при написании ассемблерных программ существует две проблемы. Во-первых, чтобы качественно писать код, обычно требовался PC, а большинство моих «коллег»-программистов большую часть дня находилось в школе. Во-вторых, ассемблер Z80 кажется довольно загадочным, если вы до этого работали с BASIC.
При помощи [Axe Parser](https://www.ticalc.org/archives/files/fileinfo/456/45659.html) Кевин Хоровитц попытался решить эти проблемы — он создал новый язык программирования, компилировавшийся в нативный код *на* самом калькуляторе. Axe — это приложение, считывающее «программу TI-BASIC», написанную с помощью встроенного редактора, однако Axe переопределял грамматику и семантику так, чтобы новый язык очень хорошо подходил для написания игр.
Это довольно изящное решение: благодаря использованию встроенного редактора приложению Axe не нужно было предоставлять редактор для своего языка. Axe больше похож на *компилятор* — он использует все свои возможности для улучшения ассемблерного кода, а про его оптимизацию уже существует [множество страниц](https://www.omnimaga.org/the-axe-parser-project/assembly-programmers-help-axe-optimize!/) на форумах. Более того, Axe *расширяем* при помощи новых примитивов, создаваемых в виде «аксиом» — плагинов, ещё больше видоизменяющих грамматику языка.
Вот как выглядит программа «hello world» на Axe.
Токен `Str1` преобразован в 16-битную переменную-указатель — внутри калькулятора это компилируется в ассемблерную программу под названием HELLO!
> `:.HELLO
>
> :"Hello World"→Str1
>
> :Disp Str1`
### Unity: нативный код на TI-81
TI-81 был совершенно слабым калькулятором. У него не было не только памяти архива, но и линк-порта, и команды `Asm()`, а это значит, что пользователю оставался только TI-BASIC.
Оставался, но до тех пор, пока Бен Муди (floppusmaximus) не выпустил [Unity](https://www.ticalc.org/archives/files/fileinfo/425/42572.html) — *загрузчик*, эксплойтивший переполнение буфера в примитивной TI-OS, а затем устанавливавший себя, чтобы помогать в загрузке других ассемблерных программ.
Если линк-порта не было, то как Unity или другие ассемблерные программы попадали в калькулятор?
Их вводили вручную!
Инструкции по установке напоминали перепечатывание программ на BASIC из журнала BYTE:
Подозреваю, что Рэнди Комптон, [первым обнаруживший](https://www.ticalc.org/archives/news/articles/14/145/145220.html) баг ОС, смог это сделать при помощи дампа ROM с физическим дизассемблированием. Ассемблер Z80 очень легко реверс-инжинирить, потому что он написан вручную.
Хаки операционной системы
-------------------------
Большинство проектов выполняется в TI-OS, но некоторые выполняются *параллельно* с TI-OS, чтобы проделывать с оборудованием вещи, которые компания TI предпочла бы запретить.
Пользователи этого опасались. Большинство людей хотело избежать гнева Texas Instruments, потому что (а) даже малейшая угроза юридического преследования могла охладить пыл студентов и (б) люди обычно не хотели очернять образ сообщества. Поэтому существовал список недопустимых приложений, в частности, программы, созданные для жульничества на экзаменах.
### Ключи подписи
Главное, к чему стремились все — возможность запуска собственного кода на своём оборудовании. У TI была грубая, но эффективная проверка криптографической подписи для приложений и операционных систем, которая использовала [криптосистему Рабина](https://en.wikipedia.org/wiki/Rabin_cryptosystem). Компания выпустила ключ подписи приложений для TI-83 Plus в рамках SDK. Однако другие ключи, позволявшие подписывать образы ОС для 83+, 84+, а также приложения и операционные системы для TI-89, по-прежнему оставались тайной.
Использовать *математику* против *фанатов калькуляторов* — да на что вообще рассчитывала TI?! Бен Муди осознал, что технологий 2009 года было достаточно для прямого взлома 512-битных ключей, созданных десять лет назад. В его [посте](https://web.archive.org/web/20090805011013/http://www.unitedti.org/index.php?showtopic=8888) (загадочно названном “Fun Number Theory Facts”) рассказывалось, что он нашёл простые множители публичного ключа для операционной системы 83+.
Поражённое сообщество собрало кластер BOINC, который за несколько недель без проблем взломал все оставшиеся ключи.
Texas Instruments закатила истерику и начала угрожать юридическими карами, которые, если честно, на 100% были злоупотреблением DMCA. Electronic Frontier Foundation выступил от лица сообщества фанатов, [объяснив TI](https://www.eff.org/deeplinks/2009/09/ti-leave-those-kids-alone), что в знании простых множителей конкретных целых чисел нет ничего незаконного. Всё это разбирательство даже получило собственную [статью на Википедии](https://en.wikipedia.org/wiki/Texas_Instruments_signing_key_controversy).
Сегодня можно запросто найти эти ключи на любом фанатском сайте, в том числе и [у меня](https://www.thirtythreeforty.net/posts/2021/10/ti-calculator-innovation/keys.zip).
### arTIfice
Достаточно недавно (в конце 2020 года) TI решила, что всем нужен холодный душ и [объявила](https://www.hackster.io/news/texas-instruments-under-fire-for-removing-asm-c-programming-features-from-ti-83-ti-84-calculators-ba55bdcb0547), что отключает все эти ассемблерные дела с обновлениями ПО для TI-84+ CE (самого нового цветного калькулятора), сомнительно аргументировав решение тем, что это улучшит безопасность на экзаменах и т.д., и т.п. [Такое ощущение, что им дала совет [команда Playstation Linux](https://en.wikipedia.org/wiki/OtherOS).]
[Процитируем](https://www.ticalc.org/archives/news/articles/14/149/149342.html) Лайонела Дебру:
> Этот удар стал завершением золотого века более чем двух десятков лет официальной поддержки нативного кода как минимум на одном активно поддерживаемом графическом калькуляторе TI.
>
>
>
> Как и все истинные фанаты калькуляторов, мы тяжело восприняли это решение. Сообщество всегда было мягким по отношению к TI — за двадцать с лишним лет не было выпущено ничего, реально вредящего бизнесу! Но сегодня, вероятно, моральный барьер был разрушен...
В качестве жеста примирения компания предложила Python-обвязки, но все сразу же возмутились тем, что Python чертовски медленнен во встроенных окружениях и совершенно не может повторить то, на что способен нативный код. [Насколько я могу судить, компания использовала MicroPython — реализация Python была бы огромной задачей, но мне не удалось найти никакого раскрытия информации о лицензии MIT.] Как вы уже наверно поняли, это был не первый раз, когда TI оказалась глуха к желаниям фанатов.
На сцене появляется [arTIfice](https://yvantt.github.io/arTIfiCE/) — настоящий джейлбрейк для этих калькуляторов. Достаточно просто установить геометрическое приложение CabriJr и открыть с его помощью *специальные* данные, после чего вы внезапно видите меню, позволяющее запустить что угодно.
Круто здесь то, что это *джейлбрейк*, а не просто хак, использующий оборудование. Как и при джейлбрейке iPhone или Xbox, вы начинаете внутри «песочницы» и выбираетесь из неё, используя баги очень сложного геометрического приложения CabriJr (подписанного и благословлённого на запуск компанией TI) для возврата возможности исполнения произвольного кода, запуска оболочки или установки хуков в ОС. [Стоит заметить, что все эти хуки уже были возможны и по-прежнему поддерживаются самой ОС; именно благодаря им работают приложения наподобие Inequalz (строящего графики неравенств) — они позволяют привязывать экраны графиков и процедуры отрисовки при помощи официальных API.]
Эксплойт arTIfice занимает всего 927 байта и скрывает за шелл-кодом простой UI с загрузчиком. Благодаря своему размеру эксплойт проще всего использовать во многих взломах zero-day этого и другого программного обеспечения TI.
Так что да, теперь экзамены в полной безопасности.
Куда двигаться дальше?
----------------------
На каждый упомянутый мной проект есть десяток других, которые не вошли в статью. Ширина и глубина поисков потрясают: я даже не коснулся сцены исследователей Nspire на основе ARM.
В вузах и старших школах у Texas Instruments всегда были конкуренты — в частности, несколько интересных устройств создала Casio. Фанатская сцена выпустила скромное количество релизов и для калькуляторов Casio.
Стартап [Numworks](https://www.numworks.com/) создаёт калькуляторы на основе очень мощного микроконтроллера STM32F429. До недавнего времени у Numworks была операционная система в open-source, и у меня зародилась надежда, что это может привести к ренессансу портативных калькуляторов. Оборудование доступно и достаточно удобно, но разработчики закрыли лицензию на исходный код, поэтому не думаю, что их продукция завоюет любовь сцены любителей калькуляторов.
Но какой бы ни была платформа, стабильный поток скучающих нердов в вузах никогда не иссякнет, и к тому же они имеют поддержку умных инженеров со свободным временем. Верный духу истинного хакера, я считаю, что люди будут продолжать расширять возможности любого оборудования, которое попадёт к ним в руки.
### Дополнительное чтение
Читатели могут изучить [новости **ticalc.org**](https://www.ticalc.org/) (первые из которых [появились ещё в 1997 году](https://www.ticalc.org/archives/news/)) или погрузиться в исследование огромных архивов. Или же нырнуть в кроличьи норы форумов сообществ на phpBB — некоторые из них уже мертвы, но другие вполне процветают!
* [**ticalc.org**](https://ticalc.org): форум, источник новостей и огромный архив почти всего ПО, выпущенного для каждого из калькуляторов TI
* [**Cemetech**](https://cemetech.net): довольно формальный, с умеренной активностью, но с достаточно хорошим соотношением «сигнал-шум» и очень подкованными пользователями. По-прежнему очень активный.
* [**Omnimaga**](https://omnimaga.org): менее формальный, множество проектов, с огромным разделом болтовни вне тем и изощрёнными форумными подписями.
* [**Datamath**](http://www.datamath.org/): большой «онлайн-музей» с препарированием оборудования, реверс-инжинирингом и документацией на почти каждый выпущенный в мире калькулятор.
* [**TI-Planet**](https://tiplanet.org): французский форум, на который активно ссылались, с большим разделом скачиваемых файлов и активным сообществом; к сожалению, знаю о нём не очень много, потому что не говорю на французском.
* [**calc.org**](https://web.archive.org/web/20000520035955/http://www.calc.org/) (ссылка на Web Archive): также назывался Dimension-TI. Ныне неработающий форум и хост для скачиваемых файлов. К сожалению, он существовал до моего времени и я почти ничего о нём не знаю. | https://habr.com/ru/post/582156/ | null | ru | null |
# Проблемы с установкой начального загрузчика на флеш-накопитель
В статье содержатся 5 вопросов и ответов по следующим темам:
**1.** Очистка mbr флешки в Windows
**2.** Конвертирование ISO-файла в гибридный ISO-файл (только Linux)
**3.** Создание загрузочной флешки с сохранением изменений (Linux, Windows, Mac OS X)
**4.** Создание мультизагрузочной флешки (Windows)
**5.** Восстановление таблицы разделов и загрузчика mbr (Hiren's BootCD).
Для применения всех приведенных в статье решений (кроме 2 — работает только в Linux) потребуются операционные системы Microsoft Windows и Linux (или Mac OS X), утилиты Windows USB DVD Download Tool и RMPrepUSB (Windows), dd (Linux, Mac OS X), isohybrid (Linux), Unetbootin (Windows, Linux, Mac OS X), md5sum (Linux, Mac OS X), пустая флешка объемом не менее 8 Гб, а также «спасательная» флешка Hiren's BootCD 15.2.
**1.** Вопрос. Когда я устроился на новую работу, первые дни были посвящены обучению. На обучении всем ученикам было выдано по жесткому диску, содержащему инструкции и программное обеспечение. В одной из инструкций был приведен пример использования утилиты Windows 7 USB/DVD Download tool. С ее помощью в этом примере на флеш-накопитель записывался специальный ISO-образ операционной системы Windows 7. На практике этот способ не работал. Что делать?
Ответ. Конечно, проводить диагностику и решать проблему. Она может быть в неисправном ISO-файле (проверить его поможет утилита md5sum), неисправной флешке (открывается ли она в файловом менеджере Windows?) и неправильном коде mbr. В последнем случае перед использованием WUDT полезно будет очистить mbr. Это можно сделать с помощью командной строки, используя следующие команды:
```
diskpart
list disk
select disk N
clean
create partition primary
select partition 1
active
format FS=FAT32 QUICK
assign
exit
```
Здесь N — номер флеш-накопителя в списке всех устройств, отображаемых с помощью команды list disk
**2.** Я захотел установить на домашний компьютер еще одну операционную систему — Mageia4.1. Для этого я скачал с офицального веб-сайта ISO-образ CD диска и записал его на флешку с помощью команды dd. Но при попытке загрузить с ее помощью компьютер выдается сообщение об ошибке: isolinux.bin missing or corrupt.
Ответ. Похоже, скаченный Вами ISO-образ не является гибридным, т.е. он предназначен только для записи на CD и не подходит для записи на флеш-накопитель. Решить эту проблему можно с помощью утилиты isohybrid, входящей в состав syslinux. Она позволяет сконвертировать указанный ISO-образ для CD/Dvd в гибридный ISO-образ с таким же именем.
**3.** В ночную смену бывает время, когда нет работы и нечего делать. Чтобы как-то себя занять, я решил взять с собой Linux-LiveUSB, чтобы с пользой использовать свободное время (что запрещено по регламенту). Записав с помощью команды
```
dd if=elementaryos-0.4-stable-amd64.20160909.iso of=/dev/sdb bs=4096, где /dev/sdb - имя флешки
```
на флешку гибридный ISO-образ ElementaryOS 0.4 'Loki', я загрузил эту операционную систему на компьютере. Далее я создал в каталоге Документы пустой файл, чтобы узнать, сохранится ли он после перезагрузки, как это было с загрузочной флешкой openSUSE 13.1 GNOME, созданной аналогичным образом, с которой я смог не только создать такой файл, но и установить необходимые программы, не исчезнувшие после перезагрузки компьютера. Но с Elementary OS 0.4 такой трюк не прошел. Можно ли сделать так, чтобы при использовании загрузочной флешки с Elementary OS 0.4 изменения сохранялись также, как и в случае использования openSUSE 13.1 GNOME? Почему в openSUSE это работает, а в Elementary OS — нет?
При первой загрузке флешки openSUSE создается новый раздел с именем hybrid, содержащий файловую систему, в которой сохраняются все изменения, сделанные при работе с LiveUSB, включая созданные файлы и установленные программы. Elementary OS 0.4 самостоятельно так делать не умеет, но ей можно в этом помочь.
Во-первых, можно создать такой раздел, используя для записи iso-образа Elementary OS 0.4 на флешку утилиту Unetbootin. Для этого в ней можно указать место, используемое для сохранения изменений после перезагрузки (только для ubuntu и основанных на ней дистрибутивов), например 4096 Мбайт (см. картинку).
*Изображение 1. Окно Unetbootin*
Второй способ — вручную создать на флешке второй раздел с именем «casper-rw» (например, с помощью GParted) и указать в параметрах загрузки ядра ключевое слово «persistent», как это сделано в следующем ответе.
**4.** Я научился записывать на флеш-накопитель гибридные ISO-образа дистрибутивов ElementaryOS 0.4, Mageia4.1 и openSUSE 13.1 GNOME с помощью команды dd, но этот способ не подходит для того, чтобы создать мультизагрузочную флешку. Как создать такую флешку?
Ответ. Это можно сделать, добавив новую операционную систему в загрузочное меню установленного на флешку загрузчика операционной системы. Такие загрузчики бывают разные, также как и способы их установки на флеш-накопитель. С помощью конфигурационного файла меню загрузчика можно сделать так, чтобы при выборе в меню операционной системы загрузчик передавал управление ее ядру и создавал временную файловую систему с помощью ее начального ram-диска, а ядро загружало операционную систему, использовуя при этом файл iso-образа операционной системы. Для этого можно скопировать на флешку файлы iso-образа, ядра и начального ram-диска этой операционной системы. Таким образом, количество загружаемых с помощью такой флешки операционных систем, которые умеет загружать установленный на ней загрузчик, ограничено только ее объемом.
Файлы ядра и начального ram-диска обычно можно получить, распаковав их из файла iso-образа операционной системы с помощью архиватора. В Elementary OS, также как и в Ubuntu, они называются casper/vmlinuz и casper/initrd.lz
Один из способов установки загрузчика операционной системы на флешку заключается в использовании утилиты RMPrepUSB. Эта утилита имеет графический интерфейс и работает в Windows. Она позволяет установить загрузчики grub4dos и syslinux, обнулить таблицу разделов, создать первичный раздел, отформатировать его и даже проверить работоспособность загрузочного флеш-накопителя в эмуляторе QEMU.
*Изображение 2. Окно RMPrepUSB*
Для того, чтобы загрузить Elementary OS 0.4 загрузчиком grub4dos, установленным с помощью RMPrepUSB, необходимо добавить в загрузочное меню пункт, при выборе которого начинается загрузка этой операционной системы. Для этого создаем конфигурационный файл меню загрузчика grub4dos, который называется menu.lst, и, предполагая, что iso-образ, файлы ядра и начального ram-диска находятся на флешке в каталоге elementaryos, добавляем в него следующие строки:
```
timeout 10
default 0
title Elementary OS 0.4 'Loki'
find --set-root /elementaryos/elementaryos-0.4-stable-amd64.20160909.iso
kernel /elementaryos/vmlinuz file=/cdrom/preseed/ubuntu.seed boot=casper persistent iso-scan/filename=/elementaryos/elementaryos-0.4-stable-amd64.20160909.iso splash
initrd /elementaryos/initrd.lz
title Reboot
reboot
```
В openSUSE файлы ядра и начального ram-диска называются boot/i386/loader/linux и boot/i386/loader/initrd. Для добавления в загрузочное меню запуска openSUSE 13.1 достаточно добавить в конфигурационный файл меню перед строкой title Reboot следующие строки (предполагая, что iso-образ, файлы ядра и начального ram-диска находятся на флешке в каталоге opensuse):
```
title openSUSE-13.1-GNOME-Live-i686.iso
uuid () > nul
set UUID=%?%
set ISO=openSUSE-13.1-GNOME-Live-i686.iso
kernel /opensuse/linux isofrom=/dev/disk/by-uuid/%UUID%:/opensuse/%ISO% isofrom_device=/dev/disk/by-uuid/%UUID% isofrom_system=/opensuse/%ISO% loader=syslinux splash=silent quiet
initrd /opensuse/initrd
```
В такое загрузочное меню можно добавлять не только операционные системы, но и утилиты для проверки оперативной памяти компьютера, поверхности жесткого диска, сброса или изменения пароля Windows и т.п. Например, можно добавить в него вызов программы для проверки памяти MemTest86+, скопировав в корневой каталог флешки файл memtest.img и добавив в конфигурационный файл menu.lst перед title Reboot следующие строки:
```
title memtest86+ v5.01
find --set-root /memtest.img
map /memtest.img (fd0)
map --hook
chainloader (fd0)+1
rootnoverify (fd0)
map --floppies=1
```
Файл memtest.img можно скачать с веб-сайта memtest.org в откомпилированном загрузочном iso-файле, содержащимся в zip- или gz-архиве.
**5.** Я использовал утилиту parted для этого, чтобы очистить таблицу разделов в mbr флешки, но по ошибке очистил таблицу разделов своего жесткого диска. После перезагрузки система не загрузилась. К счастью у меня оказалось несколько загрузочных флешек, содержащих различные дистрибутивы Linux. Как восстановить систему?
Ответ. Этот ситуации можно было бы избежать, при вызове parted сразу указав устройство, с которым Вы будете работать, например так:
```
sudo parted /dev/sdb
```
Для восстановления таблицы разделов можно использовать утилиту TestDisk, которая входит в состав некоторых «спасательных» дистрибутивов Linux, таких как Parted Magic LiveCD или SystemRescueCD. Сейчас дистрибутив Parted Magic является платным, но можно использовать его бесплатную устаревшую версию, которая входит в состав Hiren's BootCD. В меню Hiren's BootCD она называется «Linux based rescue environment (Parted Magic 2012-10-10)». С помощью этих дистрибутивов можно восстановить не только таблицу разделов, но и загрузчик mbr, используя команду chroot.
Использование chroot для восстановления загрузчика Linux достаточно популярно и подробности об этом можно узнать на различных ресурсах в Интернете, включая видео на YouTube.
Используемые источники:
1. [LiveUSB](https://ru.wikipedia.org/wiki/Live_USB)
2. [Мультизагрузка](https://ru.wikipedia.org/wiki/Мультизагрузка)
3. Колонка «Вопросы и ответы» в русском LINUX FORMAT #203 (12/2015), #205 (3/2016) и #207 (5/2016)
4. [Установка Linux из iso-образа под Windows](https://habrahabr.ru/post/67270/)
5. [SDB:Create a Live USB stick using Windows](https://en.opensuse.org/SDB:Create_a_Live_USB_stick_using_Windows)
6. [20 — Add MEMTEST86+ memory test program to your grub4dos menu.lst file](http://www.rmprepusb.com/tutorials/memtest86)
7. [LiveCD/Persistence](https://help.ubuntu.com/community/LiveCD/Persistence) | https://habr.com/ru/post/313730/ | null | ru | null |
# Использование MagicalRecord при разработке iOS приложений
Хабралюди, добрый день!
Сегодня Вашему вниманию хочу представить очередной перевод, не судите строго :) Надеюсь, Вам этот материал пригодится в работе.
В течение многих лет, Core Data была неотъемлемой частью многих OS X и iOS-приложений, обеспечивая сохранение и запрашивая пользовательские данные. Компания Apple тратит много усилий для того, чтобы API Core Data было проще в использовании и облегчала разработчикам процесс интегрирования в приложения.
Этот факт указывает на то, что Core Data является сложно-модифицируемой проектом. Даже если вы знаете как пользоваться Data Core, выполнение простых, ежедневных задач может показаться вам сложной и объемной работой. Хорошо, что существует MagicalRecord – независимая библиотека для Core Data, созданная MagicalPanda. А это учебное пособие научит Вас, как ускорить работу с MagicalRecord быстро и легко.
MagicalRecord – прост в использовании, хорошо разработан и популярен. Авторы проекта заявил, что основная задача MagicalRecord – очистка кода который Вам нужно писать для использования Core Data и с помощью одной простой строки кода сделать выборку данных, одновременно позволяя пользователю оптимизировать производительность. «Как это возможно?» — подумаете Вы. Это возможно благодаря удобной технологии, которая использует один и тот же шаблон для настройки, запросов и обновления Core Data. Особенностью дизайна является влияние Ruby on Rails’ системы хранения данных ActiveRecord.
Достаточно теории! Следуйте инструкциям, и вы увидите, как работает MagicalRecord. В этой статье рассказывается о том, как создать приложение которое отследит какое же пиво Ваше любимое. Это позволит Вам:
Добавить пиво по вкусу.
* Оценить пиво.
* Сделать заметки о пиве.
* Сделать фотографию пива (на тот, случай, если вы перебрали, а заметку сделать нужно)
**Начнем**
Для полного понимание этой статьй, Вы уже должны владеть базовой пониманием CoreData, на уровне учебного пособия по CoreData. Кроме этого, Вам не требуется какого-либо предварительного опыта работы с CoreData.
*Если у вас отсутствует даже базовый опыт работы с Core Data, я рекомендую все же сначала ознакомиться с этим [учебным руководством Core Data](http://www.raywenderlich.com/934/core-data-tutorial-for-ios-getting-started), а затем вернуться сюда.*
Для начала, загрузите [этот](http://cdn5.raywenderlich.com/wp-content/uploads/2014/01/BeerTracker-Starter.zip) стартовый проект. Как только он загрузится, распакуйте архив и запустите приложение, что бы проверить его.
Приложение имеет базовый навигационный контроллер с кнопкой «Добавить», так же таблицу, поисковую строку (если вы потяните вниз пустую таблицу) и cегментный выбор для сортировки по алфавиту или по рейтингу. Если Вы нажимаете кнопку «Добавить», вы перейдете к интерфейсу, где Вам нужно будет ввести название пива и просмотреть информацию о нем. Если вы попытаетесь ввести что-нибудь, то пока что оно не будет сохраняться.
Теперь осмотрите код. В Project Navigator Вы увидите:
* Все контроллеры, которые вы используете для работы приложения.
* Служебный класс ImageSaver
* Изображения, которые вам пригодятся в дальнейшем для заполнения исходных данных
* Библиотека Images.xcassets, в которой уже есть несколько изображений, использующихся UI
* AMRating — удобный для рейтинг-контроля в других библиотеках
Просматривая, вы можете заметить, что отсутствует CoreData модель, а так и в AppDelegate.m не содержится кода для установки. Это идеальный сценарий для любого проекта, который Вы начали без Core Data. Но понимание, что без Core Data – никуда, придет только потом.
**Знакомство с MagicalRecord**
В Project Navigator выбирите и раскройте группу MagicalRecord. Внутри Вы увидите группы Categories и Core, а также CoreData+MagicalRecord.h. Раскройте группу Categories и откройте файл под названием NSManagedObjectModel+MagicalRecord.h.
Вы заметите, что, все названия начинаются с префикса MR\_. На самом деле, если Вы заходите через какие-либо файлы в группу Categories, Вы обратите внимание на то, что все названия, начинающиеся именно с префикса MR\_.
Я не знаю как вам, но мне кажется довольно странным начинать каждое название одними и теми же буквами. Хорошо что MagicalRecord позволяет с легкостью изменять их используя Shorthand Support.
Опять же, в Project Navigator, раскройте группу Supporting Files, и откройте файл BeerTracker-Prefix.pch. Это предкомпилированный заголовок для проекта. Добавьте две строки кода в «стартовый проект» в этот файл:
```
#define MR_SHORTHAND
#import “CoreData+MagicalRecord.h”
```
Эти две строки активируют MagicalRecord для вашего проекта:
1. MR\_SHORTHAND рассказывает MagicalRecord, что Вы не хотите вводить MR\_ перед каждым методом с MagicalRecord. Зайдя в MagicalRecord+ShorthandSupport.m Вы можете узнать больше о том, как это работает. Но это выходит за рамки этой статьй, и потому здесь обсуждаться не будет :)
2. Путем импорта CoreData+MagicalRecord.h, теперь Вы можете получить доступ к любому из MagicalRecord API в проектных файлах, и Вам больше не придется импортировать их снова и снова в каждый файл.
*Примечание: если Вы хотите добавить MagicalRecord в свой проект, Вы можете воспользоваться дополнительными советами на их странице GitHub.*
Также Вы можете добавить MagicalRecord тем же образом, как и я добавил его в проект:
1. Скачать проект MagicalRecord с GitHub
2. Перетащить MagicalRecord (содержащий CoreData+MagicalRecord.h, Categories, and Core) приямиком в ваш Xcode проект
3. Убедитесь, что CoreData база добавлена в настройки проекта в Build Phases\Link Binary with Libraries
4. В Вашем предкомпилированном заголовке, добавьте следующее #ifdef \_\_OBJC\_\_:
```
#define MR_SHORTHAND
#import “CoreData+MagicalRecord.h”
```
**Модель «Пива»**
Чтобы начать отслеживать Ваши любимые сорта, Вам потребуется создать для этого модель, потому как Вы наврядли сможете всех их запомнить, так ведь? В в меню Xcode выберите File\New\File… из списка слева, выбирите Core Data и выбирайте — Data Model.
Назовите файл BeerModel.xcdatamodeld и переместите его в группу BeerTracker.
В project navigator выбирите новый комплект BeerModel.xcdatamodeld и начните его редактирование. Добавьте объект и назовите его «Beer». Добавить свойсво — name типа String.
Добавите другой объект, с названием BeerDetails. Этот объект будет следить за такими показателями как: пользовательский рейтинг, заметки и где найти изображение. Добавьте следующие свойства BeerDetails, соответствующих типов:
* Свойство: Изображение. тип: String
* Свойство: Примечание. тип: String
* Свойство: Рейтинг. тип: Integer 16
Далее создайте связь между двумя обьектами, поэтому что объект пиво должен знать, что BeerDetails принадлежит ему. В BeerDetails, создайте новые отношения и назовите его “пиво” с целевой пива. Выбрав назначения пива, Вы создали первую часть отношений между субъектами.
Завершить настройку взаимосвязи путем выбора объекта Beer. Добавите взаимосвязь с наименованием beerDetails, с назначением BeerDetails и инвертируйте Beer. Теперь ваш объект Beer будет иметь объект BeerDetails, чтобы отличать такие же сорта.
Следующий шаг — это классифицировать данные для представления объектов. Для этого используйте Xcode, но Вы должны быть осторожны, потому что Xcode иногда глючит.
Во-первых, измените модель CoreData выбрав ее в Xcode project navigator; убедитесь, что Вы выделили объект Beer, в панели “объекты” а не среди объектов BeerDetails.
Далее, в меню Xcode зайдите в Editor\Create NSManagedObject Subclass… проверьте BeerModel, затем нажмите Next. Под субъектами управления, установите флажки для Beer и BeerDetails, если они не выставлены по умолчанию, и проверьте дважды, что Beer выделяется. Нажмите «Next» и потом «Create». Таким образом Вы создадите новые классы, Beer и BeerDetails с соответствующими объектами и именами. Посмотрите на новые классы, и Вы увидите, что каждый класс имеет свойства, соответствующие свойства объектов, которые Вы определили.
Проверьте еще раз свойства, которые представляют взаимосвязь между сущностями. Вы должны увидеть, что класс Beer содержит свойство beerDetails типа BeerDetails\*object. Но, вы также увидите, что класс BeerDetails содержит свойство пива сорта NSManagedObject\*. Почему свойства не имеют Тип пива\*? Это из-за ограничений в команде «Xcode Create NSManagedObject Subclass». Он не влияет на этот проект, так что просто игнорируйте ее.
***Примечание:** Пытали любопытство? Интересно, почему Xcode не создает cdjqcndf\*Beer? По-видимому, это — результат ограничений в команде Xcode-а CreateNSManagedObjectSubclass. С тех пор как Xcode распознает CoreData Model, логично предположить, что команда должна быть в состоянии сделать вывод, о том, что свойства каждого класса должны иметь взамоствязь друг с другом.*
*Однако, эта команда не только генерирует свойства разных типов классов. Она также генерирует имена классов, используемых для определения этих типов, и команда не достаточно правильна, чтобы полностью выполнить обе задачи. Во-первых, можно просто сгенерированный код и установить точное свойство типа и подкласса (добавляя по мере необходимости описание). Другой способ — это уменьшить количество выполняемых задач для Xcode. Если вы четко определили имя класса для каждого объекта в Data Model Inspector, прежде чем создать сами классы, тогда Xcode создаст правильные свойства типов.*
*Если Вам интересны, более сложные инструменты для создания классов из Xcode data models, один из них — [mogenerator](https://github.com/rentzsch/mogenerator).*
Теперь, когда Вы создали классы для объектов данных, пришло время инициализации стэка Core Data. Откройте файл AppDelegate.m, и в метод делегата application:didFinishLaunchingWithOptions: добавьте следующие строки кода перед оператором return:
```
// Setup CoreData with MagicalRecord
// Step 1. Setup Core Data Stack with Magical Record
// Step 2. Relax. Why not have a beer? Surely all this talk of beer is making you thirsty…
[MagicalRecord setupCoreDataStackWithStoreNamed:@"BeerModel"];
```
Если Вам доводилось работать с проектом Xcode, созданным Core Data, Вы вероятно, видели, сколько кодов требуется для подключения Core Data, и ее инициализации в файле AppDelegate. С MagicalRecord, все, что вам нужно — всего одна строчка кода!
MagicalRecord предоставляет несколько альтернативных способов настройки стека Core Data, в зависимости от следующего:
* Тип резервного хранилища
* Хотите ли Вы использовать auto-migration
* И имя вашего файла Core Data Model
Если в Ваш файл Model имеет то же базовое имя, что и имя проекта (например, файл модели BeerTracker.xcdatamodeld, в рамках проекта, названного BeerTracker), то Вы MagicalRecord можете воспользоваться одной из трех удобных способов -setupCoreDataStack, setupCoreDataStackWithInMemoryStore, или setupAutoMigratingCoreDataStack.
Но, поскольку ваши модели называется по-другому, то вы должны использовать один из двух других видов установки: setupCoreDataStackWithStoreNamed: или setupCoreDataStackWithAutoMigratingsqlitestorenamed:
Используя метод настройки AutoMigrating, Вы можете изменить свою модель, и если есть возможность автоматического переноса вашего хранилища, MagicalRecord будет делать это за Вас. Как правило, Core Data требует от Вас добавления кода, чтобы обработать небольшие изменения, внесенные в модель.
Пивоварение (entity)
Теперь, ваша модель и стек Core Data — настроины. Вы можете начать добавлять пиво в свой список. Откройте файл BeerViewController.h, и после [class](https://habrahabr.ru/users/class/) AMRatingControl, добавьте:
```
@class Beer;
```
А также можно добавить свойства пива после [interface](https://habrahabr.ru/users/interface/):
```
@property (nonatomic, strong) Beer *beer;
```
Потом перейдите к файлу BeerViewController.m и импортируйте Beer.h и BeerDetails.h:
```
#import "Beer.h"
#import "BeerDetails.h"
```
В viewDidLoad, добавьте следующий блок кода:
```
- (void)viewDidLoad {
// 1. If there is no beer, create new Beer
if (!self.beer) {
self.beer = [Beer createEntity];
}
// 2. If there are no beer details, create new BeerDetails
if (!self.beer.beerDetails) {
self.beer.beerDetails = [BeerDetails createEntity];
}
// View setup
// 3. Set the title, name, note field and rating of the beer
self.title = self.beer.name ? self.beer.name : @"New Beer";
self.beerNameField.text = self.beer.name;
self.beerNotesView.text = self.beer.beerDetails.note;
self.ratingControl.rating = [self.beer.beerDetails.rating integerValue];
[self.cellOne addSubview:self.ratingControl];
// 4. If there is an image path in the details, show it.
if ([self.beer.beerDetails.image length] > 0) {
// Image setup
NSData *imgData = [NSData dataWithContentsOfFile:[NSHomeDirectory() stringByAppendingPathComponent:self.beer.beerDetails.image]];
[self setImageForBeer:[UIImage imageWithData:imgData]];
}
}
```
***Устранение неполадок:** если у Вас возникли ошибки после копирования предыдущего блока кода в свой проект, и сделайте Clean для Вашего проекта, нажмите Shift+Command+K, или перейдите в Product\Clean.*
BeerViewController загружается потому что:
* Или выбрано пиво, или ….
* Нажали кнопку добавить из MasterViewController
Теперь, когда view загрузился Вам нужно будет сделать следующее:
1. Проверьте загружен ли объект Beer. Если нет, то это означает, что Вам нужнно добавить новый сорт пива.
2. Если Beer не имеет каких-либо BeerDetails, создайте BeerDetails объекта.
3. Для настройки просмотра, введите название пива, его рейтинг и обратите внимание на содержание. Если у этого пива еще нет названия (в случае нового ввода нового пива, проект даст ему название “новое пиво”).
4. Если пиво содержит путь к изображению, оно будет загружать изображения в UIImageView.
Есть несколько вещей, которые должны установить таким образом, чтобы Вы могли редактировать и добавлять новые сорта пива. Во-первых, вы должны быть в состоянии добавить или изменить имя. Редактировать textFieldDidEndEditing: так, чтобы он выглядел, как показано ниже:
```
- (void)textFieldDidEndEditing:(UITextField *)textField {
if ([textField.text length] > 0) {
self.title = textField.text;
self.beer.name = textField.text;
}
}
```
Теперь, когда Вы завершите добавление именем textField, он установит название пива и все содержимое textField, пока поле не заполнится.
Чтобы сохранить содержимое заметки, пиво нужно оценить, найти textViewDidEndEditing:, и измените содержимое мотода, чтобы оно выглядело, как показано ниже:
```
- (void)textViewDidEndEditing:(UITextView *)textView {
[textView resignFirstResponder];
if ([textView.text length] > 0) {
self.beer.beerDetails.note = textView.text;
}
}
```
Далее, убедитесь, что рейтинг пива обновлен, после того как пользователь изменяет его в меню: View Controller. Найти метод updateRating, и добавьте следующее:
```
- (void)updateRating {
self.beer.beerDetails.rating = @(self.ratingControl.rating);
}
```
Когда пользователь нажимает на UIImageView на странице «детали», это позволяет ему добавить или изменить фото. В UIActionSheet displays, который позволяет пользователю выбрать изображение сделанное своей камерой, или сделать новый снимок. Если пользователь хочет, сфотографировать, он должен убедиться, что изображение, сохраняется и на диске. Вместо сохранения изображения в CoreData (что может вызвать проблемы с производительностью компьютера) сохраните изображение в документах пользователя, со остальными фотографиями, а этот путь используется только для Core Data.
Управления взаимодействием между камерой и библиотекой фотоснимков приводится путем внедрения методов протокола UIImagePickerControllerDelegate. Вам нужно сделать BeerViewController делегатом для UIImagePickerController, поскольку это контроллер обработки storyboard. Найдите метод imagePickerController:didFinishPickingMediaWithinfo:, и добавьте следующее:
```
- (void)imagePickerController:(UIImagePickerController *)picker didFinishPickingMediaWithInfo:(NSDictionary *)info {
// 1. Grab image and save to disk
UIImage *image = info[UIImagePickerControllerOriginalImage];
// 2. Remove old image if present
if (self.beer.beerDetails.image) {
[ImageSaver deleteImageAtPath:self.beer.beerDetails.image];
}
// 3. Save the image
if ([ImageSaver saveImageToDisk:image andToBeer:self.beer]) {
[self setImageForBeer:image];
}
[picker dismissViewControllerAnimated:YES completion:nil];
}
```
Вот что происходит в коде, приведенном выше:
1. imagePickerController:didFinishPickingMediaWithInfo: косвенно передает ссылку на изображение выбранное пользователем, где само изображение уже находится в info-словаре, под UIImagePickerControllerOriginalImage ключом ...
2. Если объект Beer уже содержит изображение, приложение удалит его с диска, так чтобы хранилище Пользователя без необходимости не было переполненным.
3. А затем новое изобржение сохраняется на диск и путь его добавляется к BeerDetails в свойства изображения. Откройте ImageSaver и найдите saveImageToDisk:andToBeer чтобы увидеть, как это выглядит. После того, как изображение успешно сохранено, оно отображается в UIImageView.
4. После чего picker скрывается.
Вам потребуется немного изменить ImageSaver, чтобы приступить к работе. Теперь, когда класс Beer создан, Вы можете не комментировать строку импорта, и строку, которая задает путь к объекту изображения. Откройте файл ImageSaver.m и изменить инструкции импорта:
```
#import "ImageSaver.h"
#import "Beer.h"
#import "BeerDetails.h"
```
Теперь Вам нужно раскомментировать строку с if инструкцией.
```
if ([imgData writeToFile:jpgPath atomically:YES]) {
beer.beerDetails.image = path;
}
```
В класс ImageSaver теперь полностью готовы к тому, чтоб принять изображение и сохраните его на телефоне, документов, каталогов, и пути в BeerDetails объекту.
Исходя из этого у пользователя есть два варианта: отменить или добавить новое пиво. При создании view, объект Beer был создан, и вставлен в managedObjectContext. Отмена должна удалить объект Beer. Найдите метод cancelAdd, и добавьте следующее:
```
- (void)cancelAdd {
[self.beer deleteEntity];
[self.navigationController popViewControllerAnimated:YES];
}
```
MagicalRecord обеспечивает хороший способ удаления объекта, который автоматически удаляет объекты из ManagedObjectContext. После удаления, пользователь вернется к основному списку пива.
Если пользователь нажмет кнопку Done, это позволит сохранить пиво и вернуться к основному списку. Найти метод addNewBeer. Он просто отображает контроллера представления и вернется к списку. Когда view закрывается, то вызвиться метод viewWillDisapper:. Это, в свою очередь сделает вызов callssaveContext.
Прямо сейчас метод saveContext пуст, так что Вам потребуется добавить некоторый код, чтобы сохранить объект. Добавьте следующий код в метод saveContext:
```
- (void)saveContext {
[[NSManagedObjectContext defaultContext] saveToPersistentStoreWithCompletion:^(BOOL success, NSError *error) {
if (success) {
NSLog(@"You successfully saved your context.");
} else if (error) {
NSLog(@"Error saving context: %@", error.description);
}
}];
}
```
Здесь всего несколько строк кода! В AppDelegate.m, Вы настраиваете основные данные стека WithMagicalRecord. Это создало доступ к приложение по-умолчанию с managedObjectContext. При создании объектов Beer и BeerDetails, их добавили в defaultContext. MagicalRecord позволяет сохранить managedObjectContext, с помощью saveToPersistentStoreWithCompletion:. Завершение блока дает Вам доступ к объекту NSError, в случает, если не удалось сохранить. Здесь, Вы добавили простой if/else блок, который регистрирует на то, что происходит после того, как Вы сохраните defaultContext.
Вы готовы, проверить свое творение? Теперь, запустите свое приложение! Нажмите кнопку "+", заполните любую информацию, которую Вы хотите. Затем нажмите «готово».
После того, как Вы сделаете это, Вы заметите, что новое пиво не отображается в списке. Не волнуйтесь, оно не сломано, и Вы узнаете, как это поправить это все чуть позже. Вы также могли заметить, что отладчик имеет целую кучу информации. Вопреки тому, что Ваша логика может сказать, это действительно неплохо.
**Волшебный отладчик**
Когда приложение запущено, MagicalRecord вводит четыре вещи при входе в Core Data стек установки. Это показывает, что настройка Core Data произошла, и что defaultContext был создан. Тот же defaultContext, который упоминался выше, когда Вы сохранили объект Beer.
После того как Вы нажимаете кнопку Done и сохраняете MagicalRecord появляются еще несколько протоколов. В процессе сохранения было произведено такие протоколы:
1. В defaultContext сохранена основная нить.
2. Все исходные материалы будут сохранены и отмечены флажком 1.
3. Синхронизация не будет проходить одновременно и все сохраненные файлы будут отмечены флажком 0.
4. Окончательные протоколы показывают, что MagicalRecord знает, о двух объектах, которые должны быть сохранены (объекты Beer и BeerDetails), и что они успешно сохранены.
MagicalRecord протоколирует большое количество информации. Если у вас возникли проблемы, или что-то не работает должным образом, Вы должны проверить ваши протоколы, т.к. они несут много полезной информации.
***Примечание:**
Хотя я не рекомендую, но если вы действительно не хотите видеть что происходит, когда протоколы MagicalRecord, войдите в MagicalRecord.h и замените строку 17:
```
#define MR_ENABLE_ACTIVE_RECORD_LOGGING 1
```
на
```
#define MR_ENABLE_ACTIVE_RECORD_LOGGING 0
```*
**Еще одно пиво, пожалуйста!**
Если это приложение стоит всех затраченных усилий, Вы сможете просматривать все сорты пива, которые Вы добавили. Открыть MasterViewController.m, и импортировать Beer.h, и BeerDetails.h.
Для того, чтобы получить все сорта пива сохранены в CoreData, Вы должны будете сделать выборку. Добавьте выборку В viewWillAppear: перед вызовом метода reloadData.
```
- (void)viewWillAppear:(BOOL)animated {
[super viewWillAppear:animated];
// Check if the user's sort preference has been saved.
...
[self fetchAllBeers];
[self.tableView reloadData];
}
```
При первом просмотре загрузок, или при возвращении после просмотра или добавления Пива, стоит загрузить все виды пива в таблицу.
Найдите метод fetchAllBeers, и добавьте следующее:
```
- (void)fetchAllBeers {
// 1. Get the sort key
NSString *sortKey = [[NSUserDefaults standardUserDefaults] objectForKey:WB_SORT_KEY];
// 2. Determine if it is ascending
BOOL ascending = [sortKey isEqualToString:SORT_KEY_RATING] ? NO : YES;
// 3. Fetch entities with MagicalRecord
self.beers = [[Beer findAllSortedBy:sortKey ascending:ascending] mutableCopy];
}
```
MasterViewController позволяет пользователю сортировать пиво по рейтингу с оценкой от 5 до 1 за пиво, или в алфавитном порядке (A-Я). Первый раз, когда приложение запускается, оно создает NSUserDefault (значение сортировки по рейтингу) и устанавливает его по умолчанию. В таком случае Вы:
1. Восстановленный ключ сортировки хранится в NSUserDefaults
2. Если ключ сортировки-это “рейтинг”, то возрастанию переменного значения нужно отметить как " нет". Если по алфавиту, то значение — " да".
3. Выполняеться fetch.
Да, это действительно все, что нужно сделать!
Еще раз, Вы используете MagicalRecord как способ взаимодействия с Core Data. findAllSortedBy: по возрастанию-это лишь один из многих способов выполнения выборки основных данных субъектов, использующих MagicalRecord. Некоторые другие включают (обратите внимание — вы должны будете использовать один из них позже):
* indAllInContext: — найдете все объекты типа в контексте, при условии,
* findAll — найдете все объекты в контекст текущего потока
* findAllSortedBy: по возрастанию:inContext: — подобно той, что использовалась ранее, но ограничивается их-ха, контекста
* findAllWithPredicate: — позволяет перейти в NSPredicate для поиска объектов.
* findAllSortedBy: по возрастанию:withPredicate:inContext: — позволяет сортировать сделанное, с отметкой флагом, в определенном контексте. Это также позволяет Вам передавать в NSPredicate для фильтрации.
Есть многое другое, чем вы можете воспользоваться — просто проверьте NSManagedObject+MagicalFinders.m.
Чтобы название пива и рейтинг отобразить в ячейке, следуйте configureCell:atIndex:, и добавьте следующее:
```
- (void)configureCell:(UITableViewCell*)cell atIndex:(NSIndexPath*)indexPath {
// Get current Beer
Beer *beer = self.beers[indexPath.row];
cell.textLabel.text = beer.name;
// Setup AMRatingControl
AMRatingControl *ratingControl;
if (![cell viewWithTag:20]) {
ratingControl = [[AMRatingControl alloc] initWithLocation:CGPointMake(190, 10) emptyImage:[UIImage imageNamed:@"beermug-empty"] solidImage:[UIImage imageNamed:@"beermug-full"] andMaxRating:5];
ratingControl.tag = 20;
ratingControl.autoresizingMask = UIViewAutoresizingFlexibleLeftMargin;
ratingControl.userInteractionEnabled = NO;
[cell addSubview:ratingControl];
} else {
ratingControl = (AMRatingControl*)[cell viewWithTag:20];
}
// Put beer rating in cell
ratingControl.rating = [beer.beerDetails.rating integerValue];
}
```
А сейчас найдите метод prepareForSegue:sender:, и в if который проверяет, является ли переход идентификатором “editBeer,” добавьте:
```
if ([[segue identifier] isEqualToString:@"editBeer"]) {
NSIndexPath *indexPath = [self.tableView indexPathForSelectedRow];
Beer *beer = self.beers[indexPath.row];
upcoming.beer = beer;
}
```
Это передавать объект Beer в BeerViewController, чтобы он отображал сведения о пиве, позволяет Вам его редактировать.
Попробуйте запустить проект еще раз.
Теперь Вы увидите пиво, которое добавили ранее, с его рейтингом. Также, Вы можете выбрать пиво и редактировать информацию. Когда Вы вернетесь, таблица будет обновлена! Очень хорошо!
Попробуйте просмотреть объект Beer по-отдельности, и без редактирования информации, вернуться к основному списку. Взгляните на журнал. Вы должны увидеть:
```
-[NSManagedObjectContext(MagicalSaves) MR_saveWithOptions:completion:](0x8b6bfa0) NO CHANGES IN ** DEFAULT ** CONTEXT - NOT SAVING
```
Когда Вы закончите просмотр деталей, код, который Вы написали, будет сохранен в контексте по умолчанию в viewWillDisappear:. Однако, поскольку были внесены изменения, MagicalRecord признает, что нет необходимости выполнять операцию сохранения, и поэтому он пропускает процесс. Благо в этом нет необходимости для, думать о том, нужно ли Вам сохранить — просто попробуйте и сохранить, и пусть MagicalRecord сделает это для вас.
**Последние штрихи**
Есть несколько функций, которые Вы, наверняка, захотите добавить в свое приложение, например — возможность удалять пиво, предварительно заполнив список любимых сортов пива и выполнив поиск.
**Удаление**
В MasterViewController.m, найти метод делегата tableView:commitEditingStyle:forRowAtIndexPath:, и добавьте следующий код:
```
- (void)tableView:(UITableView *)tableView commitEditingStyle:(UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath *)indexPath {
if (editingStyle == UITableViewCellEditingStyleDelete) {
Beer *beerToRemove = self.beers[indexPath.row];
// Remove Image from local documents
if (beerToRemove.beerDetails.image) {
[ImageSaver deleteImageAtPath:beerToRemove.beerDetails.image];
}
// Deleting an Entity with MagicalRecord
[beerToRemove deleteEntity];
[self saveContext];
[self.beers removeObjectAtIndex:indexPath.row];
[tableView deleteRowsAtIndexPaths:@[indexPath] withRowAnimation:UITableViewRowAnimationFade];
}
}
```
Обратите внимание, есть специальный вызов saveContext. Вам необходимо добавить код и убедиться, что удаление завершилось. Если Вы уже сделали это один раз — Вы можете выяснить, как заставить его работать? Готовы......? Вперед!
Добавьте следующий код метод saveContext:
```
// Save ManagedObjectContext using MagicalRecord
[[NSManagedObjectContext defaultContext] saveToPersistentStoreAndWait];
```
Поскольку технически Вам не нужно знать, когда он закончится, вы можете использовать одину из возможностей MagicalRecord сохранить managedObjectContext.
Запустите приложение и удалите пиво (традиционно используя ячейки). Если Вы повторно запустите приложение, а пива там не оказалось, Вы сделали что-то очень нужное! Вы сохранили изменения, а это означает, что Вы использовали MagicalRecord правильно.
Похлопайте себе!
**Демо-Данные**
Было бы неплохо дать пользователям некоторые исходные данные, чтобы они могли видеть, как легко они могут отслеживать свои любимые сорта. В файле AppDelegate.m, сделайте импорт файлов Beer.h, BeerDetails.h. Затем, сразу после установки Core Data стека, добавьте следующее:
```
// Setup App with prefilled Beer items.
if (![[NSUserDefaults standardUserDefaults] objectForKey:@"MR_HasPrefilledBeers"]) {
// Create Blond Ale
Beer *blondAle = [Beer createEntity];
blondAle.name = @"Blond Ale";
blondAle.beerDetails = [BeerDetails createEntity];
blondAle.beerDetails.rating = @4;
[ImageSaver saveImageToDisk:[UIImage imageNamed:@"blond.jpg"] andToBeer:blondAle];
// Create Wheat Beer
Beer *wheatBeer = [Beer createEntity];
wheatBeer.name = @"Wheat Beer";
wheatBeer.beerDetails = [BeerDetails createEntity];
wheatBeer.beerDetails.rating = @2;
[ImageSaver saveImageToDisk:[UIImage imageNamed:@"wheat.jpg"] andToBeer:wheatBeer];
// Create Pale Lager
Beer *paleLager = [Beer createEntity];
paleLager.name = @"Pale Lager";
paleLager.beerDetails = [BeerDetails createEntity];
paleLager.beerDetails.rating = @3;
[ImageSaver saveImageToDisk:[UIImage imageNamed:@"pale.jpg"] andToBeer:paleLager];
// Create Stout
Beer *stout = [Beer createEntity];
stout.name = @"Stout Lager";
stout.beerDetails = [BeerDetails createEntity];
stout.beerDetails.rating = @5;
[ImageSaver saveImageToDisk:[UIImage imageNamed:@"stout.jpg"] andToBeer:stout];
// Save Managed Object Context
[[NSManagedObjectContext defaultContext] saveToPersistentStoreWithCompletion:nil];
// Set User Default to prevent another preload of data on startup.
[[NSUserDefaults standardUserDefaults] setBool:YES forKey:@"MR_HasPrefilledBeers"];
[[NSUserDefaults standardUserDefaults] synchronize];
}
```
Стартовое приложение, которое Вы скачали в начале этой статьй, включает в себя четыре изображения холодного пива. Тут Вы можете не просто создаете четыре разных сорта пива, но и сохраняете их. Сохраните флажки в NSUserDefaults разрешая приложению предварительно заполнять DataModel только один раз, когда он запускается впервые.
Снова запустите приложение, так чтобы Вы могли видеть все новые сорта пива. Попробуйте удалить один и повторного запустить приложение; оно не вернется. Если вы хотите увидеть все образцы пива снова, удалите приложение в симулятора или устройства и запустите заново.
**Поиск**
Теперь, когда у вас больше одного сорта пива, протестируйте возможности поиска. Стартовое приложение уже включена в строке поиска — выделите верхнюю часть таблицы, чтобы увидеть его. Единственное, что нужно добавить логику, для поиска в списке пива.
Ранее Вы использовали MagicalRecord как вспомогательный метод, чтобы сделать выборку всех сортов пива, и просто возращали все пиво. Итак, если Вы хотите получить все сорта пива, которые соответствуют определенному условию поиска.
Для этого вам нужно будет использовать NSPredicate. Ранее в пособии говорилось о методе выборки с NSPredicate. Можете Вы догадались, как сделать поиск? Логика должна быть внутри doSearch в MasterViewController.m file.
Добавьте следующий код в метод doSearch:
```
- (void)doSearch {
// 1. Get the text from the search bar.
NSString *searchText = self.searchBar.text;
// 2. Do a fetch on the beers that match Predicate criteria.
// In this case, if the name contains the string
self.beers = [[Beer findAllSortedBy:SORT_KEY_NAME ascending:YES withPredicate:[NSPredicate predicateWithFormat:@"name contains[c] %@", searchText] inContext:[NSManagedObjectContext defaultContext]] mutableCopy];
// 3. Reload the table to show the query results.
[self.tableView reloadData];
}
```
Для других методов для извлечения результатов, проверить файлы заголовков MagicalRecord.
Снова запустите приложение и проскрольте список пива вниз, до тех пор, пока строка поиска не появиться. Ищите один из сортов пива, в списке, затем найдите тот, который не в списке. Получается ли у вас добиться желаемого результата?
**Что дальше?**
Надеюсь, эта статья о MagicalRecord показало Вам, как легко работать с MagicalRecord. Это действительно помогает сократить количество написанного кода! Основы, которые Вы изучили в этом уроке помогут Вам в разработке всех видов приложений, которые помогают пользователям следить за вещами, так как позволяет использовать картинки, заметки и рейтинги. Наслаждайтесь!
Вы можете скачать готовый проект [здесь](http://cdn2.raywenderlich.com/wp-content/uploads/2014/01/BeerTracker-Finished.zip). Он может пригодиться, если на каком-то этапы возникли трудности.
Если Вы хотите развивать проект BeerTracker, ниже приводятся несколько идей, которые помогут Вам развить это приложение:
* Добавить сообщение “нет пива, созданных еще” на MasterViewController — использование поиск hasAtLeastOneEntity метод в MagicalRecord.
* Добавить сообщение, указывающее, сколько пива есть для поиска. для контроллера поиска — используйте метод countOfEntitiesWithPredicate:.
* Реализации баз данных функция reset — метод поиска truncateAll от MagicalRecord
* Для удовольствия открыть файл MagicalRecordShorthand.h и прочитать имена методов — большинство из них довольно понятны, этот заголовочный файл должен дать вам еще больше идей, как использовать MagicalRecord | https://habr.com/ru/post/236707/ | null | ru | null |
# Avira Antivir
Однажды вечером бродил я по сайтам, и набрел на одном форуме на пост довольного пользователя, благодаря которому я собственно и решил ознакомится с данным продуктом:). Так же заставило меня быстрей опробовать продукт возможность получить официально лицензию на 6 месяцев, что не могло не радовать.
И вот я клацаю по ярлычку браузера, и ввожу в великий google слова «avira antivir», и попадаю на , откуда и ставлю на закачку «Avira AntiVir Premium», и жду эти долгие 12 минут… скорость ведь у меня 256 кбит/с. Параллельно с закачкой удаляю свой старый антивирус, думаю многим знакомый «NOD», и вот оно чудо закачка завершена, и «NOD» удален, жму restart.
После загрузки винды сразу запускаю браузер и перехожу на , где пользуясь не хитрой инструкцией(т.к. у меня с немецким херово)
`Не пугайтесь немецкого языка, форма регистрации достаточно простая. Anrede = как вас величать; Bitte wählen = пожалуйста, выберите; Frau = госпожа; Herr = господин; Vorname = имя; Nachname = фамилия; Email-Adresse = адрес электронной почты; Land = страна. Заполните анкету и нажмите кнопку "Lizenz anfordern". На открывшейся страничке - подтвердите отправку анкеты нажатием на ещё одну кнопку. Откроется страница с получением лицензии.
Кликните кнопку Verschicken и спешите проверить ваш почтовый ящик. После регистрации на ваш почтовый ящик придёт письмо с подтверждением (а также с KEY-файлом полугодовой лицензии), кликнув на первый линк в котором - вы снова попадёте на страничку, скриншот которой приведён выше. Две иконки, на которую указывает стрелочка - скачать продукт и загрузить KEY-файл лицензии. Пользуйтесь на здоровье!`, получаю долгожданный ключик. И начинаю процесс установки нового защитника моей системы… Установка ни чем не отличается от установки других антивирусов. Жду буквально пару минут, и вооля установлено, после установки даже не потребовалась перезагрузка. Сразу начинаю проверку своего пк, что в итоге дает два вируса которые нод не видел, что меня сразу обрадовало.
По производительности авира не чем не уступала нод, а в некоторых моментах даже шустрей работала(особенно было заметно с архивами, с которыми нод у меня притормаживал). За два месяца работы на моей пк в связке с комодо, не было не одного BSOD'a, ни разу не повисала винда(тестировалось в xp, и vista). Из минусов могу отметить, что антивирус сильно пуглив может ругаться на безобидные вещи, к примеру лаунчер WOW'a, но этот минус перекрывается остальными его плюсами, что позволяет мне предложить вам опробовать, этот замечательный продукт:) И напоследок есть так же бесплатная версия, которую можно скачать на вышеупомянутом сайте.
p.s. сильно не ругать т.к. мой первый топик;) | https://habr.com/ru/post/53231/ | null | ru | null |
# Команда плагинов для настройки JavaFX компонент в настольном приложении
Всегда приятно общаться с приложением, которое запоминает твои повадки и словно чувствует тебя, того, что ты хочешь. Любая UI библиотека или платформа обладает увы лишь базовым функционалом и набором компонент. Например, если колонка в таблице не перемещается или по ней нельзя отсортировать, то такое приложение, в котором она используется сложно назвать дружелюбным. К счастью, сегодня таким функционалом никого не удивишь. Однако, не каждая программа запомнит положение этой колонки и в следующем сеансе отобразит ее именно на том же месте. Возможно, также будет раздражать каждый раз устанавливать положение разделителя в *SplitPane* или вводить одни и те же параметры фильтра. Как правило, такие удобства приходится обеспечивать самим разработчикам.
Примеров таких на первый взгляд маленьких доработок множество, но предлагаемых платформой решений всего два, и по сути они похожи: создать свой компонент на основе базового, создать свой *Skin* к базовому компоненту, переопределив поведение. Ни тот, ни другой способ не является простым в реализации, к тому же на каждый компонент необходимо будет писать свой компонент-адаптер. Я встречал не мало людей, кому этот способ был более знаком и понятен.
Но он далеко не единственный. Что, если взять возможности платформы, которая поддерживает шаблон обозреватель для дочерних *Node*, и при добавлении или удалении подграф *Node* прогонять через набор плагинов, каждый из которых занимается своей специфической работой? Один умеет все запоминать и восстанавливать при повторном сеансе, другой — указанным компонентам меняет контекстное меню, добавляя функцию копирования текста. Кто-то из них добавляет три точки в конце текста, если он не умещается, а при наведении мыши показывает подсказку с полным текстом, только если он не уместился. Самое главное, что не важно из какой библиотеки этот компонент, можем ли мы от него наследоваться и переопределить нужное нам поведение. Все что нам в таком случае надо — научить плагин работать с нужными компонентами при необходимости по разному.
Таким мог бы быть слушатель коллекции дочерних элементов:
```
private final ListChangeListener changeListener = (ListChangeListener) (ListChangeListener.Change extends Node c) -> {
if (c.next()) {
c.getAddedSubList().forEach(this::applySettingsForNodeAndAddListenerForItsChild);
}
};
```
Таким бы — код обработки каждой измененной *Node*-ы:
```
private void applySettingsForNodeAndAddListenerForItsChild(Node n) {
if (!checkApplySettings(n)) {
apply(n);
ObservableList children = getChildren(n);
if (children != null) {
addListnerForUpdateChildren(children);
}
markNodePropertyApplied(n);
}
}
```
А таким — непосредственно код вызова самого плагина, который зарегистрирован на этот тип компонент:
```
public Node apply(Node node) {
List settingsPlugins = settingsMap.get(Node.class);
if (settingsPlugins != null) {
for (SettingsPlugin plugin : settingsPlugins) {
node = plugin.apply(node, userSettings.getSettings());
}
}
List settingList = settingsMap.get(node.getClass());
if (settingList != null) {
for (SettingsPlugin plugin : settingList) {
node = plugin.apply(node, userSettings.getSettings());
}
}
return node;
}
```
Вот интерфейс самого плагина:
```
public interface SettingsPlugin {
public Node apply(Node node, Map userSettings);
}
```
Необходимо только на коллекции дочерних элементов *Root* элемента *Scene* один раз зарегистрировать слушателя, а на остальном подграфе он зарегистрируется сам...
Последнее время провожу аналогию по возможностям платформ для настольных и веб приложений. Было бы интересно узнать, как подобный функционал можно реализовать на разных фреймворках. | https://habr.com/ru/post/422693/ | null | ru | null |
# Сравнение строк в C# (по умолчанию)
Часто бывает, что мы соединяем 2 коллекции или группируем коллекцию при помощи [LINQ to Objects](https://msdn.microsoft.com/en-us/library/bb397919.aspx). При этом происходит сравнение ключей, выбранных для группировки или связывания.
К счастью, стоимость этих операций равна O(n). Но в случае больших коллекций нам важна эффективность самого сравнения. Если в качестве ключей выбраны строки, то какая из реализаций сравнения будет использована по умолчанию, подходит ли эта реализация для ваших строк и можно ли, [указав IEqualityComparer явно](https://msdn.microsoft.com/en-us/library/bb549267(v=vs.110).aspx), сделать эту операцию быстрее?
```
clients.Join(orders,
c => c.Name,
o => o.ClientName,
(c, o) => CreateOrederDto(c, o));
```
Как же выбирается реализация компаратора, если пользователь не указал её явно?
В [исходном коде метода Join](https://github.com/dotnet/corefx/blob/3d8569f7f2c8dd387366cbd2ef1b1cc4edab7038/src/System.Linq/src/System/Linq/Enumerable.cs#L938) можно увидеть следующее поведение:
```
public static IEnumerable Join(this IEnumerable outer, IEnumerable inner, Func outerKeySelector, Func innerKeySelector, Func resultSelector) {
if (outer == null) throw Error.ArgumentNull("outer");
if (inner == null) throw Error.ArgumentNull("inner");
if (outerKeySelector == null) throw Error.ArgumentNull("outerKeySelector");
if (innerKeySelector == null) throw Error.ArgumentNull("innerKeySelector");
if (resultSelector == null) throw Error.ArgumentNull("resultSelector");
return JoinIterator(outer, inner, outerKeySelector, innerKeySelector, resultSelector, null);
}
static IEnumerable JoinIterator(IEnumerable outer, IEnumerable inner, Func outerKeySelector, Func innerKeySelector, Func resultSelector, IEqualityComparer comparer) {
Lookup lookup = Lookup.CreateForJoin(inner, innerKeySelector, comparer);
foreach (TOuter item in outer) {
Lookup.Grouping g = lookup.GetGrouping(outerKeySelector(item), false);
if (g != null) {
for (int i = 0; i < g.count; i++) {
yield return resultSelector(item, g.elements[i]);
}
}
}
}
```
Хорошо, в метод JoinIterator передаётся null, внутри не происходит никаких проверок и значение null передаётся в качестве параметра при создании Lookup в метод CreateForJoin.
*Использование [Lookup](https://msdn.microsoft.com/en-us/library/bb460184(v=vs.110).aspx) нечасто можно встретить в явном виде. Этот класс представляет собой коллекцию с доступом к элементам по ключу, при этом для каждого ключа может храниться несколько элементов, а в случае попытки доступа по несуществующему ключу просто [вернётся пустая коллекция](https://msdn.microsoft.com/en-us/library/bb292716(v=vs.110).aspx).*
Нас интересует метод [CreateForJoin](https://github.com/dotnet/corefx/blob/3d8569f7f2c8dd387366cbd2ef1b1cc4edab7038/src/System.Linq/src/System/Linq/Enumerable.cs#L3250):
```
internal static Lookup CreateForJoin(IEnumerable source, Func keySelector, IEqualityComparer comparer) {
Lookup lookup = new Lookup(comparer);
...
}
Lookup(IEqualityComparer comparer) {
if (comparer == null) comparer = EqualityComparer.Default;
this.comparer = comparer;
groupings = new Grouping[7]; // 7 - хорошее число, пусть здесь будет 7
}
```
#### EqualityComparer
Generic-интерфейс [IEqualityComparer](https://msdn.microsoft.com/en-us/library/ms132151(v=vs.110).aspx) имеет базовую реализацию в виде абстрактного класса [EqualityComparer](https://github.com/dotnet/corefx/blob/3d8569f7f2c8dd387366cbd2ef1b1cc4edab7038/src/System.Collections/src/System/Collections/Generic/EqualityComparer.cs), который в свою очередь имеет статическое свойство [Default](https://msdn.microsoft.com/en-us/library/ms224763(v=vs.110).aspx) для выбора умолчательного компаратора конкретного класса T. То есть, для любого T, класса, структуры или простого типа, будет выбран актуальный компаратор объектов этого типа.
[Полный код выбора](https://github.com/dotnet/coreclr/blob/ef1e2ab328087c61a6878c1e84f4fc5d710aebce/src/mscorlib/src/System/Collections/Generic/EqualityComparer.cs#L43) в зависимости от типа довольно витиеват, но интересен с точки зрения понимания работы наших Join и GroupBy.
1. Для byte будет выбран свой особенный ByteEqualityComparer. Этот класс создан с целью повышения производительности при сравнении массивов байт, поскольку содержит реализацию IndexOf для байтового массива.
2. Если T реализует интерфейс IEquatable, то будет выбран [GenericEqualityComparer](https://github.com/dotnet/coreclr/blob/ef1e2ab328087c61a6878c1e84f4fc5d710aebce/src/mscorlib/src/System/Collections/Generic/EqualityComparer.cs#L129), который сравнивает объекты на основе вызова их реализаций метода IEquatable.Equals(T). Кроме того, перед вызовом оба параметра будут проверены на неравенство null.
3. Если T представляет собой Nullable, значение которого реализует IEquatable, будет использован класс NullableEqualityComparer, аналогичный предыдущему и содержащий дополнительные проверки HasValue.
4. Для перечислений в зависимости от базового типа будет выбрана одна из реализаций EnumEqualityComparer (для типа long есть своя особенная реализация), которые отличаются только JIT-оптимизациями того, как значение перечисления будет приведено к числовому значению.
5. Во всех остальных случаях используется ObjectEqualityComparer, который сравнивает объекты на основе [Object.Equals](https://msdn.microsoft.com/en-us/library/bsc2ak47(v=vs.110).aspx). Здесь всё как обычно — для ссылочных типов проверяется равенство ссылок, для значимых — совпадение типов объектов (в случае с ObjectEqualityComparer всегда true) и совпадение значений всех полей объектов.
Класс [String](https://msdn.microsoft.com/en-us/library/system.string(v=vs.110).aspx) реализует интерфейс IEquatable и потому при сравнении строк будет вызвана реализация этого интерфейса.
*Для .NET Core реализация выбора компаратора по умолчанию [другая](https://github.com/dotnet/corefx/blob/3d8569f7f2c8dd387366cbd2ef1b1cc4edab7038/src/System.Collections/src/System/Collections/Generic/EqualityComparer.cs#L21) — в случае со строками будет выбран [EqualityComparerForString](https://github.com/dotnet/corefx/blob/3d8569f7f2c8dd387366cbd2ef1b1cc4edab7038/src/System.Collections/src/System/Collections/Generic/EqualityComparer.cs#L321), который использует при сравнении только оператор проверки равенства ==.*
#### Сравнение строк
Метод [String.Equals(string value)](https://github.com/dotnet/coreclr/blob/ef1e2ab328087c61a6878c1e84f4fc5d710aebce/src/mscorlib/src/System/String.cs#L518) проверяет равенство ссылок строк, равенство длины строк, и в случае, если вычислить равенство на основе этих свойств не получилось, вызывает (почти) [побайтовое сравнение буферов строк](https://github.com/dotnet/coreclr/blob/ef1e2ab328087c61a6878c1e84f4fc5d710aebce/src/mscorlib/src/System/String.cs#L356):
```
[System.Security.SecuritySafeCritical] // auto-generated
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
private unsafe static bool EqualsHelper(String strA, String strB)
{
int length = strA.Length;
fixed (char* ap = &strA.m_firstChar)
fixed (char* bp = &strB.m_firstChar)
{
char* a = ap;
char* b = bp;
// размотка цикла
#if AMD64
// Для платформы AMD64 размотка по 12 байт и сравнение 3 qword за итерацию.
while (length >= 12)
{
if (*(long*)a != *(long*)b) return false;
if (*(long*)(a+4) != *(long*)(b+4)) return false;
if (*(long*)(a+8) != *(long*)(b+8)) return false;
a += 12; b += 12; length -= 12;
}
#else
while (length >= 10)
{
if (*(int*)a != *(int*)b) return false;
if (*(int*)(a+2) != *(int*)(b+2)) return false;
if (*(int*)(a+4) != *(int*)(b+4)) return false;
if (*(int*)(a+6) != *(int*)(b+6)) return false;
if (*(int*)(a+8) != *(int*)(b+8)) return false;
a += 10; b += 10; length -= 10;
}
#endif
// Для строк с нечётной длиной последнее сравнение будет включать \0
while (length > 0)
{
if (*(int*)a != *(int*)b) break;
a += 2; b += 2; length -= 2;
}
return (length <= 0);
}
}
```
Для повышения производительности в Microsoft даже [размотали циклы](https://ru.wikipedia.org/wiki/Размотка_цикла).
Итак, **по умолчанию, для сравнения строк используется побайтовое сравнение содержимого этих строк**. Эффективно? Наверное. А как ещё можно сравнивать строки?
#### StringComparer
Для класса String в .net есть своя абстрактная реализация компаратора [StringComparer](https://msdn.microsoft.com/en-us/library/system.stringcomparer(v=vs.110).aspx) и ряд унаследованных от него классов, доступ к экземплярам которых можно получить через статические свойства этого класса. Есть 6 реализаций сравнения строк 3 видов с учётом и без учёта регистра символов каждый:
* CurrentCulture/CurrentCultureIgnoreCase — сравнение по словам с учётом правил текущей культуры и языка (культуры текущего Thread)
* InvariantCulture/InvariantCultureIgnoreCase — сравнение по словам без учёта правил языка и культуры и языка (используется CultureInfo.InvariantCulture)
* Ordinal/OrdinalIgnoreCase — побайтовое сравнение
*Так как StringComparer реализует IEqualityComparer, то все его наследники можно указывать в качестве параметра там, где ожидается IEqualityComparer.*
Я неоднократно встречал описания этих методов сравнения, но ни разу по-настоящему не задумывался, что значит «сравнение по словам с учётом текущей культуры».
Будет ли побайтовое сравнение идентично таковому при выборе EqualityComparer.Default или явному вызову метода Equals? За сравнение в этом случае отвечает класс [OrdinalComparer](https://github.com/dotnet/coreclr/blob/bc146608854d1db9cdbcc0b08029a87754e12b49/src/mscorlib/src/System/StringComparer.cs#L275):
```
public override bool Equals(string x, string y) {
if (Object.ReferenceEquals(x ,y)) return true;
if (x == null || y == null) return false;
if( _ignoreCase) {
if( x.Length != y.Length) {
return false;
}
return (String.Compare(x, y, StringComparison.OrdinalIgnoreCase) == 0);
}
return x.Equals(y);
}
```
В случае учёта регистра символов отличие заключается в дублировании проверок равенства ссылок объектов и проверки на null. Это не очень много, хотя с точки зрения MSIL это пара десятков инструкций:
```
IL_0000: nop
IL_0001: ldarg.0
IL_0002: ldarg.1
IL_0003: call bool [mscorlib]System.Object::ReferenceEquals(object, object)
IL_0008: ldc.i4.0
IL_0009: ceq
IL_000b: stloc.1
IL_000c: ldloc.1
IL_000d: brtrue.s IL_0013
IL_000f: ldc.i4.1
IL_0010: stloc.0
IL_0011: br.s IL_003e
IL_0013: ldarg.0
IL_0014: brfalse.s IL_001f
IL_0016: ldarg.1
IL_0017: ldnull
IL_0018: ceq
IL_001a: ldc.i4.0
IL_001b: ceq
IL_001d: br.s IL_0020
IL_001f: ldc.i4.0
IL_0020: nop
IL_0021: stloc.1
IL_0022: ldloc.1
IL_0023: brtrue.s IL_0029
IL_0025: ldc.i4.0
IL_0026: stloc.0
IL_0027: br.s IL_003e
```
Как насчёт сохранения без учёта регистра? Признаться, я и не ожидал увидеть что-то вроде [ToLower](https://msdn.microsoft.com/en-us/library/system.string.tolower(v=vs.110).aspx), поскольку эта операция зависит от культуры. Но результат всё-таки превзошёл ожидания. Для вызова String.Compare(x, y, StringComparison.OrdinalIgnoreCase) выполняется следующая [ветвь кода](https://github.com/dotnet/coreclr/blob/bc146608854d1db9cdbcc0b08029a87754e12b49/src/mscorlib/src/System/String.cs#L1798):
```
case StringComparison.OrdinalIgnoreCase:
if (this.Length != value.Length)
return false;
// Если обе строки содержат только ASCII символы, мы можем пойти по быстрому пути.
if (this.IsAscii() && value.IsAscii()) {
return (CompareOrdinalIgnoreCaseHelper(this, value) == 0);
}
#if FEATURE_COREFX_GLOBALIZATION
return CompareInfo.CompareOrdinalIgnoreCase(strA, 0, strA.Length, strB, 0, strB.Length);
#else
// Медленное решение
return TextInfo.CompareOrdinalIgnoreCase(strA, strB);
#endif
```
Интересно, на сколько хуже должно быть медленное решение чтобы проверка IsAscii была оправдана?
В случае с ASCII-строками проверка осуществляется действительно посимвольно, каждый символ проверяется на регистр и, при необходимости, переводится в верхний регистр простым вычитанием 0x20.
```
private unsafe static int CompareOrdinalIgnoreCaseHelper(String strA, String strB)
{
int length = Math.Min(strA.Length, strB.Length);
fixed (char* ap = &strA.m_firstChar)
fixed (char* bp = &strB.m_firstChar)
{
char* a = ap;
char* b = bp;
while (length != 0)
{
int charA = *a;
int charB = *b;
Contract.Assert((charA | charB) <= 0x7F, "strings have to be ASCII");
// Перевод обоих символов в верхний регистр чтобы получить результат одним сравнением
if ((uint)(charA - 'a') <= (uint)('z' - 'a')) charA -= 0x20;
if ((uint)(charB - 'a') <= (uint)('z' - 'a')) charB -= 0x20;
if (charA != charB)
return charA - charB;
// Следующий символ
a++; b++;
length--;
}
return strA.Length - strB.Length;
}
}
```
Для не ASCII строк вызывается [нативный код](https://github.com/dotnet/coreclr/blob/bc146608854d1db9cdbcc0b08029a87754e12b49/src/classlibnative/nls/nlsinfo.cpp#L2546) на C++ и далее в зависимости от условий может вызываться метод сравнения строк из ядра Windows или (судя по комментариям, это возможно только для Windows XP) [метод](https://github.com/dotnet/coreclr/blob/bc146608854d1db9cdbcc0b08029a87754e12b49/src/utilcode/downlevel.cpp#L1593), который проводит такое же посимвольное сравнение, переводя каждый символ в верхний регистр на основе таблиц символов операционной системы.
*Это действительно вызывает интерес к вопросу производительности, поскольку производительность одного и того же компаратора может отличаться в зависимости от входных данных, в вырожденном случае — от изменения одного символа в строке.*
А что на счёт культур? Класс [CultureAwareComparer](https://github.com/dotnet/coreclr/blob/bc146608854d1db9cdbcc0b08029a87754e12b49/src/mscorlib/src/System/StringComparer.cs#L129) принимает на вход культуру, на основании которой будет сравнивать строки и флаг, сообщающий о том, будет ли игнорироваться регистр символов. Информация о культуре содержит свойство [CompareInfo](https://msdn.microsoft.com/en-us/library/system.globalization.compareinfo(v=vs.110).aspx), объект которого содержит методы для сравнения строк с учётом данной культуры, которые и используются в CultureAwareComparer.
```
return (_compareInfo.Compare(x, y, _ignoreCase? CompareOptions.IgnoreCase : CompareOptions.None) == 0);
```
К сожалению, внутри нет ничего интересного, поскольку по факту вызывается [нативный код](https://github.com/dotnet/coreclr/blob/bc146608854d1db9cdbcc0b08029a87754e12b49/src/classlibnative/nls/nlsinfo.cpp#L1648), который снова лезет в ядро для вызова функции сортировки строк. Чтобы компенсировать отсутствие кода вот вам отрывок, который неоднократно встречается в функциях работы со строками в coreclr:
```
// TODO: Remove this workaround after Vista SP2 &/or turkic CompareStringEx() gets fixed on Vista.
// If its Vista and we want a turkik sort, then call CompareStringW not CompareStringEx
LPCWSTR pLingLocaleName = AvoidVistaTurkishBug ? GetLingusticLocaleName((LPWSTR)lpLocaleName, dwCmpFlags) : lpLocaleName;
// TODO: End of workaround for turkish CompareStringEx() on Vista/Win2K8
```
То есть, **сравнение строк .net с учётом культуры и языка всегда происходит на уровне ядра операционной системы**.
#### Тесты производительности
После такого путешествия я не смог не заинтересоваться реальной разницей в производительности. Изначально моим сценарием было объединение последовательностей, поскольку в результате происходит большое количество сравнений. Для чистого теста я оставил только сравнение строк без дополнительных операций. Исходный код теста можно посмотреть или сграбить на [GitHub](https://github.com/Vadimyan/StringComparationBenchmark). Результаты немного плавали, но я решил, что 10.000 итераций по 1.000.000 будет достаточно и без доверительного интервала.
| Сценарий | Миллисекунд/1.000.000 операций | Относительная разница |
| --- | --- | --- |
| string.Equals | 25.8 | 1x |
| EqualityComparer.Default | 33.5 | 1.3x |
| StringComparer.Ordinal | 29.8 | 1.16x |
| StringComparer.OrdinalIgnoreCase | 50.3 | 1.95x |
| StringComparer.OrdinalIgnoreCase non ASCII | 82.2 | 3.19x |
| StringComparer.CurrentCulture | 136 | 5.27x |
| StringComparer.CurrentCulture non ASCII | 174.3 | 6.76x |
| StringComparer.CurrentCultureIgnoreCase | 134.5 | 5.21x |
| StringComparer.CurrentCultureIgnoreCase non ASCII | 172.1 | 6.67x |
| StringComparer.InvariantCulture | 132.2 | 5.12x |
| StringComparer.InvariantCulture non ASCII | 189.5 | 7.34x |
| StringComparer.InvariantCultureIgnoreCase | 134.1 | 5.2x |
| StringComparer.InvariantCultureIgnoreCase non ASCII | 188 | 7.29x |
Результаты подтверждают код — явный вызов string.Equals быстрее всего, GenericEqualityComparer медленнее за счёт дополнительных проверок входных параметров. В OrdinalComparer тоже есть дополнительные проверки. А далее вызываются либо не размотанные циклы, либо методы неуправляемого кода, которые, вообще говоря, ведут себя по-разному на разных платформах, но в случае работы с культурой вызывают методы из ядра операционной системы.
#### Сравнение в других операциях над строками
Казалось бы, по умолчанию используется самое быстрое и простое сравнение, программисту можно не беспокоиться. На самом деле всё не совсем так. Есть ещё ряд операций над строками. Например, определение того, [начинается ли строка с определенной подстроки](https://github.com/dotnet/coreclr/blob/bc146608854d1db9cdbcc0b08029a87754e12b49/src/mscorlib/src/System/String.cs#L2516):
```
public Boolean StartsWith(String value) {
return StartsWith(value, StringComparison.CurrentCulture);
}
```
В то же время [проверка вхождения подстроки](https://github.com/dotnet/coreclr/blob/bc146608854d1db9cdbcc0b08029a87754e12b49/src/mscorlib/src/System/String.cs#L2133) (казалось бы, тоже самое) снова осуществляется побайтово:
```
public bool Contains( string value ) {
return ( IndexOf(value, StringComparison.Ordinal) >=0 );
}
```
А проверка вхождения подстроки, [которая вернёт индекс начала этой подстроки](https://github.com/dotnet/coreclr/blob/bc146608854d1db9cdbcc0b08029a87754e12b49/src/mscorlib/src/System/String.cs#L2269) — снова с текущей культурой:
```
public int IndexOf(String value) {
return IndexOf(value, StringComparison.CurrentCulture);
}
```
LastIndexOf вообще вызывает нативный код. Что в нём происходит? Только Сатья знает.
#### Выводы
Что же делать со всей этой информацией?
* Во-первых, при большом числе сравнений можно получить прирост производительности этих операций примерно на 10%, реализовав свой компаратор строк, который не будет дублировать проверки, которые уже есть в методе string.Equals.
* Во-вторых, если строки представляют собой ключи, то можно принять решение об использовании только Ascii-символов, что даст выигрыш около 20% для большинства сравнений.
* В-третьих, нужно хорошо понимать и ограничивать случае, когда применяется сравнение с учётом культуры. Часто в коде я встречал именно опцию StringComparer.InvariantCulture поскольку автор считал именно такое сравнение наиболее общим. Но чаще всего достаточно использовать StringComparer.Ordinal или, в особенных случаях, StringComparer.OrdinalIgnoreCase.
* Используя различные методы класса String лучше перепроверить их поведение в исходниках. Возможно, вас ждёт неожиданность после тестов с «TestString» и «AnotherTestString», когда код уйдёт в production. | https://habr.com/ru/post/274491/ | null | ru | null |
# Развёртывание django приложения на OpenShift хостинге от Red Hat
Преимущества облачного хостинга в наше время объяснять не приходиться, а Red Hat предлагает нам ещё и опробовать все вкусности бесплатно (естественно с некоторыми ограничениями).
Вы не платите за хостинг и получаете?
* 1 Gb дискового пространства
* возможность создать 3 приложения
* поддержку php 5.3, Ruby 1.9, Node.js 0.6, Perl 5.10, python 2.6 (3.3), Zend Server 5.6 и это ещё не полный список.
Ну а если необходимого языка не нашлось можно создать Do-It-Yourself приложение и настроить его как душе угодно.
Мы же рассмотрим развёртывание Django приложения.
Мануалов в интернете мной было найдено предостаточно, но подводные камни заставили повозиться. Опишу ниже.
Итак после регистрации на [openshift.com](https://www.openshift.com/) лучше установить rhc — тулзу для управления выделенными для нас ресурсами. Почему лучше? Да просто можно настраивать всё и из веб браузера, но через консоль много проще и быстрее особенно в linux.
Установить rhc в ubuntu можно так:
```
$ sudo yum install rubygems git
$ sudo gem install rhc
```
Теперь выполните логин через консоль:
```
$ rhc setup
```
Готово. Мы в сети.
Создаём python приложение:
```
$ rhc app create habr python-2.6
```
habr — это конечно же имя приложения.
Утилита сообщает, что наше приложение создано и доступно по адресу: <http://habr-lamazavr.rhcloud.com/>, а также адрес git нашего приложения (скопируйте его куданибуть).
Видим такую страницу:
Теперь переходим к установке django. Переходим в каталог wsgi и создаём django приложение:
```
$ cd habr/wsgi/
$ django-admin startproject habr
```
Редактируем файл application в каталоге wsgi:
```
#!/usr/bin/env python
# some original codes we need
import os
virtenv = os.environ['APPDIR'] + '/virtenv/'
os.environ['PYTHON_EGG_CACHE'] = os.path.join(virtenv, 'lib/python2.6/site-packages')
virtualenv = os.path.join(virtenv, 'bin/activate_this.py')
try:
execfile(virtualenv, dict(__file__=virtualenv))
except:
pass
# new codes we adding for Django
import sys
import django.core.handlers.wsgi
os.environ['DJANGO_SETTINGS_MODULE'] = os.environ['OPENSHIFT_APP_NAME']+'.settings'
sys.path.append(os.path.join(os.environ['OPENSHIFT_REPO_DIR'], 'wsgi', os.environ['OPENSHIFT_APP_NAME']))
application = django.core.handlers.wsgi.WSGIHandler()
```
Для установки django раскоментируйте строку
```
install_requires=['Django>=1.3'],
```
в файле setup.py в корне приложения openshift.
Теперь нужно всё это залить на сервер.
Войдя в каталог wsgi добавим папку приложения в git:
```
$ git add habr
$ git commit -a -m "Initialization"
$ git push
```
В ходе выполнения на сервер установился и django (в моём случае 1.5.1, т.е. последняя на сегодня версия).
По окончании видим стартовую страницу django:
Но какоеже приложение без базы данных.
Добавим базу данных mysql, phpmyadmin и настроим django проект для работы с ней.
Добавляем катридж mysql к приложению habr:
```
$ rhc cartridge add mysql-5.1 -a habr
```
Cохраните для себя имя пользователя и пароль базы данных из вывода rhc:
```
Added mysql-5.1 to application habr
MySQL 5.1 database added. Please make note of these credentials:
Root User: пользователь
Root Password: пароль
Database Name: habr
Connection URL: mysql://$OPENSHIFT_MYSQL_DB_HOST:$OPENSHIFT_MYSQL_DB_PORT/
You can manage your new MySQL database by also embedding phpmyadmin-3.4.
The phpmyadmin username and password will be the same as the MySQL credentials above.
```
Добавляем phpmyadmin:
```
$ rhc cartridge add phpmyadmin-3.4 -a habr
```
Будет опять выведен пароль и имя для вохода phpmyadmin, хотя это дубль пароля и имени к базе.
Важна тут только ссылка для входа в админа. [habr-lamazavr.rhcloud.com/phpmyadmin](https://habr-lamazavr.rhcloud.com/phpmyadmin/)
Phpmyadmin я добавляю для того, чтобы импортировать готовую базу данных на сервер. Выполнять syncdb там не очень удобно.
Настраиваем django для работы с базой данных в файле settings.py нашего django приложения.
```
'ENGINE': 'django.db.backends.mysql', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
'NAME': os.environ['OPENSHIFT_APP_NAME'], # Or path to database file if using sqlite3.
'USER': os.environ['OPENSHIFT_MYSQL_DB_USERNAME'], # Not used with sqlite3.
'PASSWORD': os.environ['OPENSHIFT_MYSQL_DB_PASSWORD'], # Not used with sqlite3.
'HOST': os.environ['OPENSHIFT_MYSQL_DB_HOST'], # Set to empty string for localhost. Not used with sqlite3.
'PORT': os.environ['OPENSHIFT_MYSQL_DB_PORT'], # Set to empty string for default. Not used with sqlite3.
```
Естественно нужно импортировать модуль os в начале файла.
Коммитим изменения и заливаем:
```
$ git commit -a -m "db init"
$ git push
```
После окончания заходим на страничку нашего приложения. Всё нормально. Значит база данных подключена, иначе видим 501 ошибку. Тогда смотрим логи командой:
```
$ rhc tail habr
```
Создадим также django-приложение внутри нашего проекта:
```
$ django-admin startapp habrapp
```
Добавляем строчку:
```
'habrapp',
```
в INSTALLED\_APPS в файле settiongs.py проекта django.
Сделаем view с css и media файлами соответственно.
Создаём в каталоге habr/habr (рядом с файлом settings.py) папку templates и в ней файл index.html:
```
{{title}}
### {{text}}
```
Вьюху пишем во views.py:
```
from django.shortcuts import render_to_response
def index(request):
c = { 'title': 'Habratitle', 'text': 'Hello habrahabr from OpenShift!',}
return render_to_response('index.html',c)
```
Указываем url в urls.py:
```
(r'^$','habrapp.views.index'),
```
Теперь указываем каталог с шаблонами нашему проеку в файле settings.py:
```
TEMPLATE_DIRS = (
os.path.join(os.path.dirname(__file__),'templates').replace('\\','/'),
)
```
Добавляем в git созданную нами папку с шаблоном и приложение django:
```
$ git add templates/
$ git add habrapp/
```
С путями примеры не привожу, ниже архив с примером.
Коммитим и заливаем
```
$ git commit -a -m 'views add'
$ git push
```
Заходим видим нашу страницу.
Ну а теперь только вкусности с media файдами.
Во первый добавляем статик файлы админки. Собираем их:
```
$ python manage.py collectstatic
```
Получаем папку admin, которую ложим в каталог static в каталоге wsgi.
В каталоге wsgi создаём файл .htaccess:
`RewriteEngine On
RewriteRule ^application/media/(.+)$ /static/media/$1 [L]`
Причём именно так! application нужен, а не ошибка.
Создаём папку media/css/ в ней файл style.css и вносим в него цвет нашего приветствия.
```
h3 {
color: #6DA3BD;
}
```
Не забываем добавить созданное в git:
```
$ git add .
$ git add .
$ git add .htaccess
$ git commit -a -m 'media files'
$ git push
```
Заходим на страницу. Текст изменил цвет.
Как обещал [проект](https://www.dropbox.com/s/76yemj21dmgb3ue/habr.zip). | https://habr.com/ru/post/177243/ | null | ru | null |
# Нестандартный подход к стандартной разработке дополнения (Add-In’а) на C#
С помощью Add-In'a можно реализовать дополнительную функциональность, серьезно облегчающую повседневное использование приложения. Типовой подход прост – изучаем API приложения для разработки дополнения и реализуем его в виде отдельной библиотеки. На выбор обычно предлагается несколько языков, С# скорее всего будет в данном списке из-за его распространенности и популярности для разработки приложений под Windows на платформе .Net.
Однако часто бывает необходимо, чтобы дополнение постоянно отображало какую-то визуальную информации, нужную при использовании приложения. При простом решении данной проблемы — создание пользовательского окна и отображении его либо поверх всех окон, либо перемещением его на передний план — мы получаем некоторые неудобства с организацией пользовательского пространства. С ними можно кое-как мириться, но что делать, если таких окон должно быть несколько?
Как правило в самой среде приложения все организовано как надо — нужные действия реализованы в виде дополнительных окон, расположение и размер которых пользователь как хочет, так и настраивает для себя. Можно предположить, что API должен содержать данную функциональность интеграции пользовательских окон в среду, но как ни странно, скорее всего такой функционал будет отсутствовать. Но, если очень нужно, это можно реализовать.
В основе работы любого приложения под Windows лежит событийная модель – приложение получает сообщения (как от пользователя, так и от операционной системы) и реагирует на них, например, отрисовывает свое содержимое. Вся данная функциональность реализована в оконной процедуре, таким образом, заменив данную процедуру своей пользовательской, мы можем полностью изменить алгоритм функционирования окна. Для выполнения такой низкоуровневой задачи необходимо обратиться к функциям операционной системы – WinAPI. Связь C# (.NET Framework) и WinAPI реализована с помощью Platform Invoke сервисов – возможности из управляемого кода (C#) вызывать неуправляемый код процедур WinAPI (С).
Рассмотрим на примере разработку дополнения для профессиональной САПР Eplan. Предполагается, что уже есть опыт разработки типового дополнения (если нет, то можно ознакомиться с основами [здесь](http://habrahabr.ru/post/271671/)), поэтому будут комментироваться только действия, связанные с реализацией визуального окна дополнения. Рассмотрим, для начала, вариант дополнения, отображающего в отдельном окне (на переднем плане) список текущих открытых страниц.
Основной программный файл дополнения, main.cs.
```
//@file main.cs
//@brief Классы, реализующие дополнение.
// @par Текущая версия:
// @$Rev: 1 $.\n
// @$Author: idimm $.\n
// @$Date:: 2015-12-03 12:05:13#$.
using System;
using System.Windows.Forms;
using Eplan.EplApi.ApplicationFramework;
using Eplan.EplApi.Gui;
using Eplan.EplApi.DataModel;
using Eplan.EplApi.HEServices;
namespace SimpleAddIn
{
public class AddInModule : IEplAddIn
{
public bool OnRegister( ref bool bLoadOnStart )
{
bLoadOnStart = true;
return true;
}
public bool OnUnregister()
{
return true;
}
public bool OnInit()
{
return true;
}
public bool OnInitGui()
{
Eplan.EplApi.Gui.Menu oMenu = new Eplan.EplApi.Gui.Menu();
uint menuID = oMenu.AddMainMenu(
"eplaner", Eplan.EplApi.Gui.Menu.MainMenuName.eMainMenuHelp,
"Окно помощи", "showWndAction",
"Окно помощи по проекту", 0 /*inserts before*/ );
return true;
}
public bool OnExit()
{
return true;
}
}
public class Action_Test : IEplAction
{
public Action_Test()
{
frm = new System.Windows.Forms.Form();
rtbox = new System.Windows.Forms.RichTextBox();
rtbox.Dock = System.Windows.Forms.DockStyle.Fill;
rtbox.Location = new System.Drawing.Point( 0, 0 );
frm.Controls.Add( rtbox );
}
public bool OnRegister( ref string Name, ref int Ordinal )
{
Name = "showWndAction";
Ordinal = 20;
return true;
}
public bool Execute( ActionCallingContext oActionCallingContext )
{
SelectionSet set = new SelectionSet();
Page[] pages = set.OpenedPages;
rtbox.Clear();
foreach ( Page pg in pages )
{
rtbox.AppendText( pg.Name + "\n" );
}
frm.ShowDialog();
return true;
}
public void GetActionProperties( ref ActionProperties actionProperties )
{
}
System.Windows.Forms.Form frm;
System.Windows.Forms.RichTextBox rtbox;
}
}
```
Здесь реализовано простейшее дополнение, в процессе выполнения действия (Action Action\_Test) заполняем текстовое поле нужной информацией и отображаем форму в диалоговом режиме. Результаты приведены на рисунках ниже.
Как видим, окно отображается поверх среды Eplan, работа в котором возможна только после закрытия окна. Это очень неудобно. Рассмотрим второй вариант дополнения, отображающего информацию в обычном отдельном окне. Для этого заменим строку frm.ShowDialog() на frm.Show() в методе Execute для класса Action\_Test. Теперь можно переключаться между окном дополнения и средой. Но для корректной работы после закрытия окна дополнения необходимо модернизировать код класса Action\_Test:
```
public class Action_Test : IEplAction
{
public Action_Test()
{
frm = new System.Windows.Forms.Form();
rtbox = new System.Windows.Forms.RichTextBox();
rtbox.Dock = System.Windows.Forms.DockStyle.Fill;
rtbox.Location = new System.Drawing.Point( 0, 0 );
frm.Controls.Add( rtbox );
frm.FormClosing += FormClosing;
}
public bool OnRegister( ref string Name, ref int Ordinal )
{
Name = "showWndAction";
Ordinal = 20;
return true;
}
private void FormClosing( object sender, FormClosingEventArgs e )
{
e.Cancel = true;
( sender as System.Windows.Forms.Form ).Hide();
}
public bool Execute( ActionCallingContext oActionCallingContext )
{
SelectionSet set = new SelectionSet();
Page[] pages = set.OpenedPages;
rtbox.Clear();
foreach ( Page pg in pages )
{
rtbox.AppendText( pg.Name + "\n" );
}
frm.Show();
return true;
}
public void GetActionProperties( ref ActionProperties actionProperties )
{
}
System.Windows.Forms.Form frm;
System.Windows.Forms.RichTextBox rtbox;
}
```
Как видно необходимо было добавить корректную обработку закрытия окна (метод FormClosing). Такое решение может использоваться, но все равно оно не самое удобное для пользователя. Для того, чтобы формы вела себя как встроенная, поместим ее на какое-либо стандартное окно среды, предварительно скрыв ее содержимое. Для реализации данной функциональности окна будем использовать функции WinApi. Код дополнения приведен ниже. Алгоритм работы подробно расписан в комментариях метода ShowDlg() класса EplanWindowWrapper.
Основной программный файл дополнения, main.cs.
```
//@file main.cs
//@brief Классы, реализующие дополнение.
// @par Текущая версия:
// @$Rev: 1 $.\n
// @$Author: idimm $.\n
// @$Date:: 2015-12-03 12:05:13#$.
using System;
using System.Windows.Forms;
using Eplan.EplApi.ApplicationFramework;
using Eplan.EplApi.Gui;
using Eplan.EplApi.DataModel;
using Eplan.EplApi.HEServices;
namespace SimpleAddIn
{
public class AddInModule : IEplAddIn
{
public bool OnRegister( ref bool bLoadOnStart )
{
bLoadOnStart = true;
return true;
}
public bool OnUnregister()
{
return true;
}
public bool OnInit()
{
return true;
}
public bool OnInitGui()
{
Eplan.EplApi.Gui.Menu oMenu = new Eplan.EplApi.Gui.Menu();
uint menuID = oMenu.AddMainMenu(
"eplaner", Eplan.EplApi.Gui.Menu.MainMenuName.eMainMenuHelp,
"Окно помощи", "showWndAction",
"Окно помощи по проекту", 0 /*inserts before*/ );
return true;
}
public bool OnExit()
{
return true;
}
}
public class Action_Test : IEplAction
{
public Action_Test()
{
rtbox = new System.Windows.Forms.RichTextBox();
rtbox.Dock = System.Windows.Forms.DockStyle.Fill;
rtbox.Location = new System.Drawing.Point( 0, 0 );
}
public bool OnRegister( ref string Name, ref int Ordinal )
{
Name = "showWndAction";
Ordinal = 20;
return true;
}
private void FormClosing( object sender, FormClosingEventArgs e )
{
e.Cancel = true;
( sender as System.Windows.Forms.Form ).Hide();
}
public bool Execute( ActionCallingContext oActionCallingContext )
{
if ( eww == null )
{
eww = new EplanWindowWrapper( rtbox, new ToolStrip(), "Стр" );
}
if ( !wasInit )
{
SelectionSet set = new SelectionSet();
Page[] pages = set.OpenedPages;
rtbox.Clear();
foreach ( Page pg in pages )
{
rtbox.AppendText( pg.Name + "\n" );
}
}
eww.ShowDlg();
return true;
}
public void GetActionProperties( ref ActionProperties actionProperties )
{
}
System.Windows.Forms.RichTextBox rtbox;
EplanWindowWrapper eww;
bool wasInit = false;
}
}
```
Дополнительный программный модуль, EplanWindowWrapper.cs.
**Развернуть**
```
///@file EplanWindowWrapper.cs
///@brief Классы, реализующие минимальную функциональность, необходимую для
///отображения пользовательских окон поверх окон среды Eplan.
///
/// @par Текущая версия:
/// @$Rev: 1$.\n
/// @$Author: idimm$.\n
/// @$Date:: 2012-04-07 16:45:35#$.
///
using System;
using System.Windows.Forms;
using System.Runtime.InteropServices;
///
/// Окно, отображающееся в Eplan'е и ведущее себя как встроенное в среду.
///
public class EplanWindowWrapper
{
private IntPtr wndHandle = IntPtr.Zero; ///Найденное окно.
private IntPtr dialogHandle = IntPtr.Zero; ///Найденный диалог.
private IntPtr panelPtr; ///Найденная панель.
IntPtr oldDialogWndProc = IntPtr.Zero; ///Старая оконная процедура.
IntPtr oldPanelProc = IntPtr.Zero; ///Старая оконная процедура.
pi.Win32WndProc newWndProc; ///Новая оконная процедура.
Control mainCntrl; ///Пользовательское окно.
byte[] newCaption; ///Новый заголовок окна.
string newCaptionStr;
private string windowName;
private int panelDlgItemId;
private int dialogDlgItemId;
private int panelToHideDlgItemId;
private int menuClickId;
///
/// Новая оконная процедура для обработки перехваченных сообщений
/// диалогового окна Eplan'а.
///
private IntPtr DialogWndProc( IntPtr hWnd, int msg, int wPar, IntPtr lPar )
{
if ( hWnd == panelPtr )
{
switch ( ( pi.WM ) msg )
{
case pi.WM.MOVE:
case pi.WM.SIZE:
IntPtr dialogPtr = pi.GetParent( mainCntrl.Handle );
pi.RECT rctDialog;
pi.RECT rctPanel;
pi.GetWindowRect( dialogPtr, out rctDialog );
pi.GetWindowRect( panelPtr, out rctPanel );
int w = rctDialog.Right - rctDialog.Left;
int h = rctDialog.Bottom - rctDialog.Top;
int dx = rctPanel.Left - rctDialog.Left;
int dy = rctPanel.Top - rctDialog.Top;
mainCntrl.Location =
new System.Drawing.Point( dx, dy );
mainCntrl.Width = w - dx;
mainCntrl.Height = h - dy;
break;
}
return pi.CallWindowProc( oldPanelProc, panelPtr, msg, wPar, lPar );
}
if ( hWnd == dialogHandle )
{
switch ( ( pi.WM ) msg )
{
case pi.WM.GETTEXTLENGTH:
return ( IntPtr ) newCaption.Length;
case pi.WM.SETTEXT:
return IntPtr.Zero;
case pi.WM.DESTROY:
dialogHandle = IntPtr.Zero;
pi.SetParent( mainCntrl.Handle, IntPtr.Zero );
mainCntrl.Hide();
System.Threading.Thread.Sleep( 1 );
break;
case pi.WM.GETTEXT:
System.Runtime.InteropServices.Marshal.Copy(
newCaption, 0, lPar, newCaption.Length );
return ( IntPtr ) newCaption.Length;
}
}
return pi.CallWindowProc( oldDialogWndProc, hWnd, msg, wPar, lPar );
}
///
/// Конструктор с параметрами окна, содержимое которого будет
/// изменена на пользовательское.
///
///
/// Визуальный пользовательский компонент, отображающийся на форме.
///
///
/// Новый заголовок окна.
///
///
/// Заголовок окна (окна-основы), содержимое которого будет изменена на
/// пользовательское.
///
///
/// Идентификатор панели-контейнера окна-основы.
///
///
/// Идентификатор диалогового представления окна-основы.
///
///
/// Идентификатор панели с элементами среды Eplan, которую необходимо
/// скрыть.
///
///
/// Идентификатор пункта меню для вызова окна-основы.
///
public EplanWindowWrapper( Control mainCntrl,
string caption, string windowName = "Пространство листа",
int panelDlgItemId = 0xE81F, int dialogDlgItemId = 0x3458,
int panelToHideDlgItemId = 0xBC2, int menuClickId = 35506 )
{
this.mainCntrl = mainCntrl;
mainCntrl.Hide();
newCaptionStr = caption;
newCaption = System.Text.Encoding.GetEncoding( 1251 ).GetBytes(
caption + '\0' );
this.windowName = windowName;
this.panelDlgItemId = panelDlgItemId;
this.dialogDlgItemId = dialogDlgItemId;
this.panelToHideDlgItemId = panelToHideDlgItemId;
this.menuClickId = menuClickId;
newWndProc = DialogWndProc;
}
///
/// Инициализация формы данными для редактирования.
///
/// Так как данная форма отображается как внутреннее окно, то алгоритм
/// следующий:
/// 1 Поиск окна (по умолчанию "Пространство листа", меню Пространство
/// листа -> Навигатор).
/// 1.1 Поиск плавающего представления: через FindWindowByCaption ,
/// потом для поиска панели и диалога DlgItemId (0xE81F - базовая панель,
/// 0x3458 - диалог). Если окно найдено, то переходим к 4, иначе к 1.2.
/// 1.2 Поиск закрепленного представления: через GetDlgItem для всех
/// дочерних окон (GetChildWindows) приложения Eplan по DlgItemId
/// (0x3458 - диалог).
/// Если окно найдено, то переходим к 4, иначе к 2.
/// 2 Симулируем нажатие пункта меню (Пространство листа -> Навигатор)
/// для его отображения.
/// 3 Повторяем поиск окна (1.1 и 1.2). Если окно не найдено выводим
/// сообщение об ошибке, завершаем редактирование, иначе к 4.
/// 4 Скрываем панель с элементами управления Eplan'а
/// (GetDlgItem, 0xBC2 - родительская панель, ShowWindow).
/// 5. Переносим на найденное окно свои элементы (SetParent) и подгоняем
/// их размеры и позицию.
/// 6. Устанавливаем свою оконную процедуру (для изменения размеров
/// своих элементов, обработки закрытия окна).
///
public void ShowDlg()
{
if ( mainCntrl.Visible )
{
return;
}
bool isDocked = false;
System.Diagnostics.Process oCurrent =
System.Diagnostics.Process.GetCurrentProcess();
IntPtr res = pi.FindWindowByCaption( IntPtr.Zero, windowName );//1.1
if ( res != IntPtr.Zero )
{
res = pi.GetDlgItem( res, panelDlgItemId );
wndHandle = pi.GetParent( res );
dialogHandle = pi.GetDlgItem( res, dialogDlgItemId );
}
else //1.2
{
System.Collections.Generic.List resW =
pi.GetChildWindows( oCurrent.MainWindowHandle );
foreach ( IntPtr panel in resW )
{
dialogHandle = pi.GetDlgItem( panel, dialogDlgItemId );
if ( dialogHandle != IntPtr.Zero )
{
isDocked = true;
res = dialogHandle;
break;
}
}
if ( res == IntPtr.Zero )
{
pi.SendMessage( oCurrent.MainWindowHandle,
( uint ) pi.WM.COMMAND, menuClickId, 0 ); //2
res = pi.FindWindowByCaption( IntPtr.Zero, windowName );//3
if ( res != IntPtr.Zero )
{
res = pi.GetDlgItem( res, panelDlgItemId );
wndHandle = pi.GetParent( res );
dialogHandle = pi.GetDlgItem( res, dialogDlgItemId );
}
else
{
resW = pi.GetChildWindows( oCurrent.MainWindowHandle );
foreach ( IntPtr panel in resW )
{
dialogHandle = pi.GetDlgItem( panel, dialogDlgItemId );
if ( dialogHandle != IntPtr.Zero )
{
isDocked = true;
break;
}
}
if ( dialogHandle == IntPtr.Zero )
{
System.Windows.Forms.MessageBox.Show(
"Не удалось найти окно!" );
return;
}
}
}
}
panelPtr = pi.GetDlgItem( dialogHandle, panelToHideDlgItemId ); //4
if ( panelPtr == IntPtr.Zero )
{
System.Windows.Forms.MessageBox.Show( "Не удалось скрыть окно!" );
return;
}
pi.ShowWindow( panelPtr, 0 );
pi.SetParent( mainCntrl.Handle, dialogHandle ); //5
mainCntrl.Show();
int dy = 0;
if ( isDocked )
{
dy = 17;
}
pi.RECT dialogRect;
pi.GetWindowRect( dialogHandle, out dialogRect );
mainCntrl.Location = new System.Drawing.Point( 0, dy );
int w = dialogRect.Right - dialogRect.Left;
int h = dialogRect.Bottom - dialogRect.Top - dy;
mainCntrl.Width = w;
mainCntrl.Height = h;
oldDialogWndProc = pi.SetWindowLong( dialogHandle, pi.GWL\_WNDPROC,
newWndProc );
oldPanelProc = pi.SetWindowLong( panelPtr, pi.GWL\_WNDPROC,
newWndProc );
pi.SetWindowText( dialogHandle, newCaptionStr );
pi.SetWindowText( wndHandle, newCaptionStr );
}
}
///
/// Platform Invoke functions.
///
public class pi
{
///
/// Window procedure.
///
public delegate IntPtr Win32WndProc( IntPtr hWnd, int msg, int wParam,
IntPtr lParam );
public const int GWL\_WNDPROC = -4;
///
/// Changes an attribute of the specified window. The function also sets
/// the 32-bit (long) value at the specified offset into the extra window
/// memory.
///
///
/// A handle to the window and, indirectly, the class to which the window
/// belongs.
///
/// The zero-based offset to the value to be set.
/// Valid values are in the range zero through the number of bytes of
/// extra window memory, minus the size of an integer. To set any other
/// value, specify one of the following values: GWL\_EXSTYLE,
/// GWL\_HINSTANCE, GWL\_ID, GWL\_STYLE, GWL\_USERDATA, GWL\_WNDPROC
///
/// The replacement value.
///
/// If the function succeeds, the return value is the previous value of
/// the specified 32-bit integer. If the function fails, the return value
/// is zero. To get extended error information, call GetLastError.
///
[DllImport( "user32" )]
public static extern IntPtr SetWindowLong( IntPtr hWnd, int nIndex,
Win32WndProc newProc );
///
/// Set window text.
///
[DllImport( "user32.dll", SetLastError = true, CharSet = CharSet.Auto )]
public static extern bool SetWindowText( IntPtr hwnd, String lpString );
///
/// Find window by Caption only. Note you must pass IntPtr.
/// Zero as the first parameter.
///
[DllImport( "user32.dll", EntryPoint = "FindWindow", SetLastError = true )]
public static extern System.IntPtr FindWindowByCaption( IntPtr ZeroOnly,
string lpWindowName );
///
/// Windows Messages
/// Defined in winuser.h from Windows SDK v6.1
/// Documentation pulled from MSDN.
///
public enum WM : uint
{
///
/// The WM\_NULL message performs no operation. An application sends
/// the WM\_NULL message if it wants to post a message that the
/// recipient window will ignore.
///
NULL = 0x0000,
///
/// The WM\_CREATE message is sent when an application requests that
/// a window be created by calling the CreateWindowEx or CreateWindow
/// function. (The message is sent before the function returns.)
/// The window procedure of the new window receives this message
/// after the window is created, but before the window becomes visible.
///
CREATE = 0x0001,
///
/// The WM\_DESTROY message is sent when a window is being destroyed.
/// It is sent to the window procedure of the window being destroyed
/// after the window is removed from the screen.
/// This message is sent first to the window being destroyed and then
/// to the child windows (if any) as they are destroyed. During the
/// processing of the message, it can be assumed that all child
/// windows still exist.
/// ///
DESTROY = 0x0002,
///
/// The WM\_MOVE message is sent after a window has been moved.
///
MOVE = 0x0003,
///
/// The WM\_SIZE message is sent to a window after its size has changed.
///
SIZE = 0x0005,
//...
///
/// An application sends a WM\_SETTEXT message to set the text of a
/// window.
///
SETTEXT = 0x000C,
///
/// An application sends a WM\_GETTEXT message to copy the text that
/// corresponds to a window into a buffer provided by the caller.
///
GETTEXT = 0x000D,
///
/// An application sends a WM\_GETTEXTLENGTH message to determine the
/// length, in characters, of the text associated with a window.
///
GETTEXTLENGTH = 0x000E,
//...
///
/// The WM\_COMMAND message is sent when the user selects a command
/// item from a menu, when a control sends a notification message to
/// its parent window, or when an accelerator keystroke is translated.
///
COMMAND = 0x0111,
}
///
/// Get window parent.
///
[DllImport( "user32.dll", ExactSpelling = true, CharSet = CharSet.Auto )]
public static extern IntPtr GetParent( IntPtr hWnd );
///
/// Set window parent.
///
[DllImport( "user32.dll", SetLastError = true )]
public static extern IntPtr SetParent( IntPtr hWndChild,
IntPtr hWndNewParent );
///
/// Windows rectangle structure.
///
[StructLayout( LayoutKind.Sequential )]
public struct RECT
{
public int Left; // x position of upper-left corner
public int Top; // y position of upper-left corner
public int Right; // x position of lower-right corner
public int Bottom; // y position of lower-right corner
}
///
/// Get window rectangle.
///
[DllImport( "user32.dll" )]
[return: MarshalAs( UnmanagedType.Bool )]
public static extern bool GetWindowRect( IntPtr hWnd, out RECT lpRect );
///
/// Calls window procedure.
///
[DllImport( "user32.dll" )]
public static extern IntPtr CallWindowProc( IntPtr lpPrevWndFunc,
IntPtr hWnd, int Msg, int wParam, IntPtr lParam );
///
/// Gets dialog item by its ID.
///
[DllImport( "user32.dll" )]
public static extern IntPtr GetDlgItem( IntPtr hDlg, int nIDDlgItem );
///
/// Delegate for the EnumChildWindows method
///
/// Window handle
///
/// Caller-defined variable; we use it for a pointer to our list
///
/// True to continue enumerating, false to bail.
public delegate bool EnumWindowProc( IntPtr hWnd, IntPtr parameter );
///
/// Returns a list of child windows
///
/// Parent of the windows to return
/// List of child windows
public static System.Collections.Generic.List GetChildWindows(
IntPtr parent )
{
System.Collections.Generic.List result =
new System.Collections.Generic.List();
GCHandle listHandle = GCHandle.Alloc( result );
try
{
EnumWindowProc childProc = new EnumWindowProc( EnumWindow );
EnumChildWindows( parent, childProc, GCHandle.ToIntPtr( listHandle ) );
}
finally
{
if ( listHandle.IsAllocated )
listHandle.Free();
}
return result;
}
///
/// Callback method to be used when enumerating windows.
///
/// Handle of the next window
///
/// Pointer to a GCHandle that holds a reference to the list to fill
///
/// True to continue the enumeration, false to bail
public static bool EnumWindow( IntPtr handle, IntPtr pointer )
{
System.Runtime.InteropServices.GCHandle gch =
System.Runtime.InteropServices.GCHandle.FromIntPtr( pointer );
System.Collections.Generic.List list =
gch.Target as System.Collections.Generic.List;
if ( list == null )
{
throw new InvalidCastException(
"GCHandle Target could not be cast as List" );
}
list.Add( handle );
return true;
}
[DllImport( "user32" )]
[return: MarshalAs( UnmanagedType.Bool )]
public static extern bool EnumChildWindows( IntPtr window,
EnumWindowProc callback, IntPtr i );
[DllImport( "user32.dll" )]
public static extern IntPtr SendMessage( IntPtr hWnd, UInt32 Msg,
Int32 wParam, Int32 lParam );
[DllImport( "user32.dll" )]
[return: MarshalAs( UnmanagedType.Bool )]
public static extern bool ShowWindow( IntPtr hWnd, Int32 nCmdShow );
}
```
Основная функциональность реализована в классе EplanWindowWrapper. При создании экземпляра класса необходимо указать все необходимое для корректной замены содержимого стандартного окна. Для получения необходимых идентификаторов можно использовать утилиту Spy++, которая входит в состав Visual Studio. Для удобства, все необходимые обертки WinApi функций (Platform Invoke) вынесены в отдельный класс pi.
Результат работы такой реализации приведен ниже.
Видим, что теперь окно ведет себя также, как и любое другое стандартное окно среды, но содержит пользовательскую информации, и инженеру по автоматизации максимально удобно с ним теперь работать.
Таким подобным образом можно добавить в принципе любую функциональность для приложения, если его API для разработки дополнения имеет ограниченный функционал. | https://habr.com/ru/post/272805/ | null | ru | null |
# 10 приёмов работы в терминале Linux, о которых мало кто знает
Близкое знакомство с возможностями терминала — один из признаков человека, который хорошо разбирается в Linux. Хотя некоторые вещи запомнить сложно, есть довольно-таки простые, но эффективные приёмы, которые способны повысить качество и скорость работы в терминале. Пожалуй, каждый пользователь Linux рано или поздно обзаводится собственным списком ценных мелочей. Надеемся, некоторых из тех десяти приёмов работы в командной строке Linux, которыми мы хотим с вами поделиться, попадут в ваш личный список полезных команд.
[](https://habrahabr.ru/company/ruvds/blog/336060/)
№1. Переход в предыдущую директорию
-----------------------------------
Все мы используем команду `cd ..` для перехода в родительскую директорию. А для перехода к предыдущей директории можно использовать команду `cd -`. Этот приём похож на кнопку «Назад».
```
test@linoxide:~/Downloads$ cd -
/home/eyramm
test@linoxide:~$ cd -
/home/eyramm/Downloads
test@linoxide:~/Downloads$
```
Тут мы сначала находились в директории `Downloads`, затем переместились в директорию `Home`, и, наконец, снова вернулись в директорию `Downloads`.
№2. Повтор последней команды
----------------------------
Для того, чтобы повторить предыдущую команду, просто введите `!!`. В этом примере мы повторим предыдущую команду с правами суперпользователя.
```
$ apt install vlc
E: Could not open lock file /var/lib/dpkg/lock - open (13: Permission denied)
E: Unable to lock the administration directory (/var/lib/dpkg/), are you root?
$ sudo !!
sudo apt install vlc
vlc is already the newest version (2.2.2-5ubuntu0.16.04.3).
```
Этот приём весьма полезен именно в ситуациях, подобных рассмотренной, когда команду, введённую ранее, надо выполнить с правами суперпользователя.
№3. Многократное выполнение команды до её успешного завершения
--------------------------------------------------------------
Для того, чтобы выполнять команду до тех пор, пока она не будет успешно завершена, используйте код возврата команды в такой конструкции:
```
while ! [command]; do sleep 1; done
```
Например:
```
$ while ! ./run.sh; do sleep 1; done
cat: run.sh: No such file or directory
cat: run.sh: No such file or directory
linoxide.com
```
Команда в этом примере будет повторяться до тех пор, пока не будет найден файл `run.sh` и его содержимое не будет выведено на экран.
№4. Просмотр сведений о ходе передачи файла
-------------------------------------------
Для того, чтобы наблюдать за ходом передачи файла, воспользуйтесь командой `pv`:
```
$ pv access.log | gzip > access.log.gz
611MB 0:00:11 [58.3MB/s] [=> ] 15% ETA 0:00:59
```
№5. Планирование заданий
------------------------
Планировать задания в Linux можно с помощью команды `at`:
```
echo wget https://sample.site/test.mp4 | at 2:00 PM
```
Для того, чтобы посмотреть ожидающие выполнения задания, воспользуйтесь командой `atq`.
№6. Вывод данных в виде таблицы
-------------------------------
Вызвав команду `ls`, или что-нибудь ещё, выводящее данные на экран, можно столкнуться с длинными списками, для просмотра которых требуется продолжительный скроллинг. То, что выводится на экран, легко можно организовать в виде таблицы с помощью команды `column -t`. Например:
```
$ cat /etc/passwd | column -t
```
Вот как выглядит то, что у нас получилось.
*Вывод команды, организованный в виде таблицы*
№7. Полезные комбинации клавиш
------------------------------
Команда `clear` очищает экран терминала. Комбинация клавиш `Ctrl + L` позволяет добиться того же самого быстрее.
Комбинация клавиш `Alt + .` позволяет перемещаться по ранее введённым командам. Комбинация клавиш `Ctrl + U` убирает из строки всё то, что уже в неё введено. Например, можете это попробовать для очистки введённого в командной строке пароля.
Для инкрементального обратного поиска по истории команд используйте комбинацию клавиш `Ctrl + R`.
№8. Сжатие, разбиение и шифрование файлов
-----------------------------------------
Передача больших файлов между компьютерами — задача непростая. Упростить её можно, сжав файлы с помощью команды `zip`, или, если файлы ну просто очень большие, создав многотомный архив. Если при этом файлы нужно ещё и зашифровать — воспользуйтесь ключом `-e`.
```
$ zip -re test.zip AdbeRdr11010_en_US.exe run.sh Smart_Switch_pc_setup.exe
Enter password:
Verify password:
adding: AdbeRdr11010_en_US.exe (deflated 0%)
adding: run.sh (stored 0%)
adding: Smart_Switch_pc_setup.exe (deflated 2%)
```
№9. Стресс-тест батареи ноутбука
--------------------------------
Хотите узнать, как долго батарея вашего ноутбука продержится при полной нагрузке на процессор? Попробуйте следующую команду:
```
$ cat /dev/urandom > /dev/null
```
№10. Переименование или перемещение файлов
------------------------------------------
Если вам нужно быстро переименовать или переместить множество файлов с суффиксами — попробуйте команду следующего вида:
```
$ cp /home/sample.txt{,-old}
```
Вот как её можно расшифровать:
```
$ cp /home/sample.txt /home/sample.txt-old
```
Ниже приведён пример переименования файлов с определённым расширением в пакетном режиме:
```
$ ls
text_comes_here_1.txt
text_comes_here_2.txt
text_comes_here_3.txt
text_comes_here_4.txt
$ rename 's/comes_here/goes_there/' *.txt
$ ls
text_goes_there_1.txt
text_goes_there_2.txt
text_goes_there_3.txt
```
Итоги
-----
Мы рассказали о нескольких приёмах взаимодействия с командной строкой Linux. Надеемся, вы нашли здесь то, что поможет вам упростить и ускорить повседневную работу.
Уважаемые читатели! Что вы добавили бы к нашему списку неочевидных полезностей командной строки Linux? | https://habr.com/ru/post/336060/ | null | ru | null |
# Рефакторинг при помощи композиции Клейсли
В течение довольно длительного времени мы поддерживали приложение, которое обрабатывает данные в форматах XML и JSON. Обычно поддержка заключается в исправлении дефектов и незначительном расширении функциональности, но иногда она также требует рефакторинга старого кода.
Рассмотрим, например, функцию `getByPath`, которая извлекает элемент из XML дерева по его полному пути.
```
import scala.xml.{Node => XmlNode}
def getByPath(path: List[String], root: XmlNode): Option[XmlNode] =
path match {
case name::names =>
for {
node1 <- root.child.find(_.label == name)
node2 <- getByPath(names, node1)
} yield node2
case _ => Some(root)
}
```
Эта функция отлично работала, но требования поменялись и теперь нам нужно:
* Извлекать данные из JSON и, возможно, других древоподобных структур, а не только из XML;
* Возвращать сообщение об ошибке, если данные не найдены.
В этой статье мы расскажем, как осуществить рефакторинг функции `getByPath`, чтобы она соответствовала новым требованиям.
Композиция Клейсли
-------------------
Давайте выделим тот фрагмент кода, который извлекает дочерний элемент по имени. Мы можем назвать ее `createFunctionToExtractChildNodeByName`, но давайте назовем ее для краткости просто `child`.
```
val child: String => XmlNode => Option[XmlNode] = name => node =>
node.child.find(_.label == name)
```
Теперь мы можем сделать ключевое наблюдение: наша функция `getByPath` является последовательной композицией функций, извлекающих дочерние элементы. Приведенная ниже функция compose реализует такую композицию двух функций: `getChildA` and `getChildB`.
```
type ExtractXmlNode = XmlNode => Option[XmlNode]
def compose(getChildA: ExtractXmlNode,
getChildB: ExtractXmlNode): ExtractXmlNode =
node => for {a <- getChildA(node); ab <- getChildB(a)} yield ab
```
К счастью, библиотека [Scalaz](https://github.com/scalaz/scalaz) предоставляет более общий, абстрактный способ реализовать композицию функций вида `A => M[A]`, где M является *монадой*. Библиотека определяет `Kleisli[M, A, B]`, обертку для `A => M[B]`, у которой есть метод >=> для реализации последовательной композиции этих `Kleisli`, подобно композиции обычных функций при помощи `andThen`. Эту композицию мы будем называть *композицией Клейсли*. Приведенный ниже код демонстрирует пример такой композиции:
```
val getChildA: ExtractXmlNode = child(“a”)
val getChildB: ExtractXmlNode = child(“b”)
import scalaz._, Scalaz._
val getChildAB: Kleisli[Option, XmlNode, XmlNode] =
Kleisli(getChildA) >=> Kleisli(getChildB)
```
Обратите внимание на [бесточечный стиль](https://wiki.haskell.org/Pointfree), который мы здесь используем. Функциональные программисты любят записывать функции как композиции других функций, без упоминания аргументов.
Композиция Клейсли – это именно то, что нам нужно, чтобы реализовать нашу функцию `getByPath`как композицию функций `child`, извлекающих дочерние элементы.
```
import scalaz._, Scalaz._
def getByPath(path: List[String], root: XmlNode): Option[XmlNode] =
path.map(name => Kleisli(child(name)))
.fold(Kleisli.ask[Option, XmlNode]) {_ >=> _}
.run(root)
```
Обратите внимание на использование `Kleisli.ask[Option, XmlNode]` в качестве нейтрального элемента метода fold. Этот нейтральный элемент нужен нам для обработки специального случая, когда path пуст. `Kleisli.ask[Option, XmlNode]` – это просто другое обозначение функции из любого node в `Some(node)`.
Абстрагируемся от XmlNode
--------------------------
Давайте обобщим наше решение и абстрагируем его от XmlNode. Мы можем переписать его в виде следующей обобщенной функции
`getByPathGeneric`:
```
def getByPathGeneric[A](child: String => A => Option[A])
(path: List[String], root: A): Option[A] =
path.map(name => Kleisli(child(name)))
.fold(Kleisli.ask[Option, A]) {_ >=> _}
.run(root)
```
Теперь мы можем повторно использовать `getByPathGeneric` для извлечения элемента из JSON (мы используем здесь [json4s](https://github.com/json4s/json4s)):
```
import org.json4s._
def getByPath(path: List[String], root: JValue): Option[JValue] = {
val child: String => JValue => Option[JValue] = name => json =>
json match {
case JObject(obj) => obj collectFirst {case (k, v) if k == name => v}
case _ => None
}
getByPathGeneric(child)(path, root)
}
```
Мы написали новую функцию, `child: JValue => Option[JValue]`, чтобы работать с JSON вместо XML, но функция `getByPathGeneric` осталась неизменной и работает как с XML, так и с JSON.
Абстрагируемся от Option
-------------------------
Мы можем обобщить `getByPathGeneric` еще больше и абстрагировать её от `Option` при помощи библиотели [Scalaz](https://github.com/scalaz/scalaz), которая предоставляет экземпляр (instance) монады для `Option -- scalaz.Monad[Option]`. Так что мы можем переписать `getByPathGeneric` следующим образом:
```
import scalaz._, Scalaz._
def getByPathGeneric[M[_]: Monad, A](child: String => A => M[A])
(path: List[String], root: A): M[A]=
path.map(name => Kleisli(child(name)))
.fold(Kleisli.ask[M, A]) {_ >=> _}
.run(root)
```
Теперь мы можем реализовать нашу исходную функцию `getByPath` при помощи функции `getByPathGeneric`:
```
def getByPath(path: List[String], root: XmlNode): Option[XmlNode] = {
val child: String => XmlNode => Option[XmlNode] = name => node =>
node.child.find(_.label == name)
getByPathGeneric(child)(path, root)
}
```
Таким образом, мы можем повторно использовать `getByPathGeneric`, чтобы возвращать сообщение об ошибке, если элемент не найден. Для этого мы используем [scalaz.\/](https://github.com/scalaz/scalaz/blob/scalaz-seven/core/src/main/scala/scalaz/Either.scala) (т.н. “дизъюнкцию”) которая является правосторонней версией `scala.Either`.
В дополнение, `Scalaz` предоставляет “неявный” (implicit) класс `OptionOps` с методом `toRightDisjunction[B](b: B)`, который преобразует `Option[A]` в `scalaz.B\/A`, так, что `Some(a)` становится `Right(a)` и `None` становится `Left(b)`.
Так, мы можем написать функцию, которая повторно использует `getByPathGeneric`, чтобы вернуть сообщение об ошибке вместо `None`, если искомый элемент не найден.
```
type Result[A] = String\/A
def getResultByPath(path: List[String], root: XmlNode): Result[XmlNode] = {
val child: String => XmlNode => Result[XmlNode] = name => node =>
node.child.find(_.label == name).toRightDisjunction(s"$name not found")
getByPathGeneric(child)(path, root)
}
```
Исходная функция `getByPath` обрабатывала только данные в формате XML и возвращала None, если искомый элемент не найден. Нам понадобилось, чтобы она также работала с форматом JSON и возвращала сообщение об ошибке вместо None.
Мы видели, как использование композиции Клейсли, которую предоставляет библиотека `Scalaz`, позволяет написать обобщенную функцию `getByPathGeneric`, используя параметризированные типы (generics) для поддержки как XML так и JSON, а также [scalaz.\/](https://github.com/scalaz/scalaz/blob/scalaz-seven/core/src/main/scala/scalaz/Either.scala) (дизъюнкцию) для абстрагирования от `Option` и выдачи сообщений об ошибках.
Разработчик [конструктора сайтов](http://ru.wix.com) Wix,
Михаил Дагаев
Оригинал статьи: [блог инженеров компании Wix](http://blog.wix.engineering/2015/09/01/example-of-refactoring-with-kleisli-composition/). | https://habr.com/ru/post/304622/ | null | ru | null |
# Обратимая транслитерация кириллицы
Возможно, кто-то еще помнит, как писали SMS, а иногда и письма, «транслитом». Но зачем транслитерация сегодня, когда везде уже unicode? К сожалению, унаследованные приложения выходят из эксплуатации намного медленнее, чем хотелось бы. Например, и сегодня используются томографы, не допускающие кириллицу в именах пациентов. При том, что информационная система, используемая тем же отделением, прекрасно кириллицу понимает. И оператору томографа нужно не просто позвать пациента на исследование, но и правильно записать его фамилию в какие-нибудь документы. Похожие ситуации могут встретится в разных местах.
То есть, возникает задача как-то передать текстовые данные в унаследованную систему, чтобы:
* человек — оператор унаследованной системы смог прочесть полученный текст «по звучанию»
* при необходимости можно было бы однозначно восстановить исходный кириллический текст
Чтобы не было скучно, добавим более подробных требований, связанных с совместимостью и простотой для человека:
1. использовать только буквы в узком смысле, без знаков препинания и диакритических элементов (это заодно позволит сохранить регистр)
2. каждую исходную букву преобразовывать независимо от остальных (без сложностей вроде «в начале / в конце слова» и т.п.)
3. замены как можно более короткие, в идеале одно-буквенные
4. правила обратного преобразованния как можно проще, например, замены должны соответствовать [условию Фано](https://ru.wikipedia.org/wiki/%D0%A3%D1%81%D0%BB%D0%BE%D0%B2%D0%B8%D0%B5_%D0%A4%D0%B0%D0%BD%D0%BE)
5. близкие по звучанию замены, в представлении «обычного человека» — на практике это некая смесь из латыни, английской, французской, немецкой и, иногда, испанской фонетики
Конечно, перечисленное не совсем требования (кроме первых двух), а, скорее, эвристики.
Можно найти много готовых вариантов транслитерации кириллицы в латиницу. Но среди них не нашлось ничего, что бы удовлетворяло всем требованиям в приемлемой степени. То использует диакритические символы, как стандарты, то выбрасывает буквы (обычно «Ъ»), то предлагают необратимые (щ —> shch) или фонетически дикие (ш —> w) варианты замены, или имеют другие [фатальные недостатки](http://www.drdobbs.com/windows/a-brief-history-of-windows-programming-r/225701475).
Значит, делаем свой велосипед. Собственно, нужно составить таблицу соответствия, и описать алгоритм преобразования туда и обратно.
Таблица
-------
Начнем со всем очевидных одно-буквенных замен:
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| А | Б | В | Г | Д | Е | Ё | Ж | З | И | Й | К | Л | М | Н | О | П | Р | С | Т | У | Ф | Х | Ц | Ч | Ш | Щ | Ъ | Ы | Ь | Э | Ю | Я |
| A | B | V | G | D | E | | | Z | I | | K | L | M | N | O | P | R | S | T | U | F | | | | | | | | | | | |
Помня о требовании возможно коротких замен, и поскольку для «С» используем «S», с чистой совестью используем для «Ц» символ «C».
Для оставшихся букв традиция (и просто нехватка символов латиницы) велит нам использовать двух-буквенные сочетания. Для простоты прямого и, в особенности, обратного преобразования, хорошо бы, чтобы сочетания образовывали символы, не используемые вне сочетаний. По условию Фано, такой особый символ должен стоять в начале сочетания, но традиция слишком сильна и букву «H» будем писать все-таки в конце сочетания. Но, если отдельно символ «H» не использовать и разрешить алгоритму преобразования «возвращаться» (на самом деле, — запоминать) к предыдущему входному символу, для постфиксных сочетаний можно считать выполненным «перевернутый» аналог условия Фано. То есть алгоритм сможет их однозначно определять.
Особый символ для согласных везде один — «H». А для гласных есть два варианта: «Y» и «J». Хотя «Y» привычнее, он также часто используется отдельно, для «Й» или для «Ы». А «J» скорее воспринимается как чисто вспомогательный символ.
Решено, используем для гласных «J». А кстати освободившийся «Y» используем для «Й».
Раз «J» теперь особый символ, использовать его для «Ж» нельзя, и остается только «ZH». Аналогично, для «Х» нельзя использовать «H», и остается только «KH».
Теперь можем записать общепринятые и выбранные сочетания и одиночные символы:
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| А | Б | В | Г | Д | Е | Ё | Ж | З | И | Й | К | Л | М | Н | О | П | Р | С | Т | У | Ф | Х | Ц | Ч | Ш | Щ | Ъ | Ы | Ь | Э | Ю | Я |
| A | B | V | G | D | E | | **ZH** | Z | I | **Y** | K | L | M | N | O | P | R | S | T | U | F | **KH** | **C** | **CH** | **SH** | | | | | **EH** | **JU** | **JA** |
Распространенные и хорошие (в смысле наших требований) замены здесь кончились, и мы вступаем на зыбкую почву «отсебятины», аналогий и компромиссов.
Начнем с «Ы». «Y» уже занят (помним про обратимость), да и фонетически это плохая замена. Посмотрим на решение для «Э» (взято, между прочим, из ISO/R 9, 1968 г.). По аналогии «Ы» должно заменятся на «IH». Странно, что такой вариант нигде не встретился.
С «Ё» ситуация тоже странная. Есть понятный, но не подходящий нам вариант «E». И есть фонетический вариант «JO». Но в русском алфавите «Ё» не случайно сделана на основе «Е», а не «О». «Ё» часто чередуется с «Е», например «кл**ё**н — кл**е**новый», и никогда не чередуется с «О». Это получается еще одна эвристика — «алфавитная» (не фонетическая и не графическая) близость букв. В результате для «Ё» конструируем замену «JE».
Сделаем паузу:
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| А | Б | В | Г | Д | Е | Ё | Ж | З | И | Й | К | Л | М | Н | О | П | Р | С | Т | У | Ф | Х | Ц | Ч | Ш | Щ | Ъ | Ы | Ь | Э | Ю | Я |
| A | B | V | G | D | E | **JE** | ZH | Z | I | Y | K | L | M | N | O | P | R | S | T | U | F | KH | C | CH | SH | | | **IH** | | EH | JU | JA |
Как хорошо было бы на этом остановится и сказать, что задача в первом приближении решена. Но остались еще три буквы, без которых никак не обойтись. Для оставшихся букв нет никаких адекватных вариантов. Знаки обычно заменяют апострофами, а буквенные замены либо просто произвольны, либо «остроумны», вроде «ь» —>«q». Для «Щ» замена без диакритических знаков обычно длиной в 3 — 4 символа, и с ней еще будут проблемы.
После долгих исканий и страданий, пришлось остановится на таком рассуждении: для букв, которым не соответствуют звуки, нельзя использовать буквы, для которых звуки есть. И нам остаются только «специальные» символы для образования сочетаний. Но по условию Фано их нельзя использовать отдельно, сочетания станут неоднозначны.
Выход — использовать сочетания специальных символов друг с другом. Это, видимо, еще немного усложнит алгоритм преобразования, но кажется возможным сохранить однозначность.
Для твердого знака (он у нас только разделительный) интуитивно кажется уместной замена «HH» (не читается, как пауза, разделение).
А для мягкого знака цепочки ассоциаций («J» —> йотированные гласные —> смягчение предыдущей согласной) + («H» —> разделение) приводят к замене «JH».
Не назовешь красивым решением, но среди гнилых яблок выбор не велик.
К сожалению, такой выбор делает невозможным использовать замену «Щ» —> «SHH». Последовательность «SHH» будет означать «СЪ», и такое сочетание встречается в русском языке (например, «съезд»). Тут снова нет симпатичных решений, и надо искать хоть как-то мотивированные. Звук «Щ» близок к смягченному «Ш», и по аналогии с мягким знаком можно это изобразить префиксным «J». Понимаю, что сейчас ссылаюсь сам на себя, что код все равно длинны 3 и не стандартный. Но, как говорится, «других писателей у нас для вас нЭт».
В результате:
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| А | Б | В | Г | Д | Е | Ё | Ж | З | И | Й | К | Л | М | Н | О | П | Р | С | Т | У | Ф | Х | Ц | Ч | Ш | Щ | Ъ | Ы | Ь | Э | Ю | Я |
| A | B | V | G | D | E | JE | ZH | Z | I | Y | K | L | M | N | O | P | R | S | T | U | F | KH | C | CH | SH | **JSH** | **HH** | IH | **JH** | EH | JU | JA |
Алгоритм
--------
Преобразование из кириллицы в латиницу тривиально. На регистр не обращаем внимания для краткости.
**Код на Java**
```
public class Translit {
public static String cyr2lat(char ch){
switch (ch){
case 'А': return "A";
case 'Б': return "B";
case 'В': return "V";
case 'Г': return "G";
case 'Д': return "D";
case 'Е': return "E";
case 'Ё': return "JE";
case 'Ж': return "ZH";
case 'З': return "Z";
case 'И': return "I";
case 'Й': return "Y";
case 'К': return "K";
case 'Л': return "L";
case 'М': return "M";
case 'Н': return "N";
case 'О': return "O";
case 'П': return "P";
case 'Р': return "R";
case 'С': return "S";
case 'Т': return "T";
case 'У': return "U";
case 'Ф': return "F";
case 'Х': return "KH";
case 'Ц': return "C";
case 'Ч': return "CH";
case 'Ш': return "SH";
case 'Щ': return "JSH";
case 'Ъ': return "HH";
case 'Ы': return "IH";
case 'Ь': return "JH";
case 'Э': return "EH";
case 'Ю': return "JU";
case 'Я': return "JA";
default: return String.valueOf(ch);
}
}
public static String cyr2lat(String s){
StringBuilder sb = new StringBuilder(s.length()*2);
for(char ch: s.toCharArray()){
sb.append(cyr2lat(ch));
}
return sb.toString();
}
}
```
Для примера результата пара известных панграмм:
> SHirokaja ehlektrifikacija juzhnihkh guberniy dast mojshnihy tolchok podhhjemu seljhskogo khozjaystva.
>
> Shheshjh zhe ejshje ehtikh mjagkikh francuzskikh bulok da vihpey chaju.
>
>
Выглядит не очень, но основное назначение этого варианта транслитерации все-таки ФИО:
> Aleksandr Ivanovich Lebedjh
>
> Georgiy Konstantinovich ZHukov
>
>
С обратным преобразованием куда интереснее. Особенно учитывая, что его хорошо бы объяснить человеку (не из IT) для выполнения «в уме».
Видимо, начать надо с особых случаев.
* Поскольку читаем мы слева направо, первым дело обращаем внимание на символ «J». За ним обязательно должен идти один из пяти символов: «E», «H», «U», «A» или «S» (за «S» должен в этом случае обязательно быть еще «H»), и получается то, что в таблице для двух-трех буквенных сочетаний.
* Если «J» нет, смотрим, не идет ли *следом* за символом буква «H». Тут самый тяжелый для внимания момент: в этот случай *не* должен попасть вариант, когда *третьим* символом снова идет «H» (это код «HH»). То есть видеть и анализировать надо три символа подряд. Вот где нарушение условия Фано аукнулось (хорошо, что один раз).
* Если ни «J», ни одиночного «H» поблизости от символа не обнаружилось, смело заменяем его по таблице как отдельную букву.
После недолгой тренировки, как показывает практика, люди способны выполнять обратное преобразования вручную. Но заставлять их это делать без особой необходимости, конечно, не надо. Можно и автоматизировать (опять же для простоты только для строки и в верхнем регистре):
**Код на Java**
```
public static String lat2cyr(String s){
StringBuilder sb = new StringBuilder(s.length());
int i = 0;
while(i < s.length()){// Идем по строке слева направо. В принципе, подходит для обработки потока
char ch = s.charAt(i);
if(ch == 'J'){ // Префиксная нотация вначале
i++; // преходим ко второму символу сочетания
ch = s.charAt(i);
switch (ch){
case 'E': sb.append( 'Ё'); break;
case 'S':
sb.append( 'Щ');
i++; // преходим к третьему символу сочетания
if(s.charAt(i) != 'H') throw new IllegalArgumentException("Illegal transliterated symbol at position "+i);// вариант третьего символа только один
break;
case 'H': sb.append( 'Ь'); break;
case 'U': sb.append( 'Ю'); break;
case 'A': sb.append( 'Я'); break;
default: throw new IllegalArgumentException("Illegal transliterated symbol at position "+i);
}
}else if(i+1 < s.length() && s.charAt(i+1)=='H' && !(i+2 < s.length() && s.charAt(i+2)=='H')){// Постфиксная нотация, требует информации о двух следующих символах. Для потока придется сделать обертку с очередью из трех символов.
switch (ch){
case 'Z': sb.append( 'Ж'); break;
case 'K': sb.append( 'Х'); break;
case 'C': sb.append( 'Ч'); break;
case 'S': sb.append( 'Ш'); break;
case 'E': sb.append( 'Э'); break;
case 'H': sb.append( 'Ъ'); break;
case 'I': sb.append( 'Ы'); break;
default: throw new IllegalArgumentException("Illegal transliterated symbol at position "+i);
}
i++; // пропускаем постфикс
}else{// одиночные символы
switch (ch){
case 'A': sb.append( 'А'); break;
case 'B': sb.append( 'Б'); break;
case 'V': sb.append( 'В'); break;
case 'G': sb.append( 'Г'); break;
case 'D': sb.append( 'Д'); break;
case 'E': sb.append( 'Е'); break;
case 'Z': sb.append( 'З'); break;
case 'I': sb.append( 'И'); break;
case 'Y': sb.append( 'Й'); break;
case 'K': sb.append( 'К'); break;
case 'L': sb.append( 'Л'); break;
case 'M': sb.append( 'М'); break;
case 'N': sb.append( 'Н'); break;
case 'O': sb.append( 'О'); break;
case 'P': sb.append( 'П'); break;
case 'R': sb.append( 'Р'); break;
case 'S': sb.append( 'С'); break;
case 'T': sb.append( 'Т'); break;
case 'U': sb.append( 'У'); break;
case 'F': sb.append( 'Ф'); break;
case 'C': sb.append( 'Ц'); break;
default: sb.append(ch);
}
}
i++; // переходим к следующему символу
}
return sb.toString();
}
```
Итог
----
Казалось бы, простая и давно решенная задача, а какой простор для творчества и обсуждений.
Если серьезно, получился рабочий алгоритм обратимой транслитерации всех букв русской кириллицы в буквы латиницы. При этом результат, со скидкой на жесткость требований, приемлемо читаем. Можно использовать для интеграции с унаследованными системами и библиотеками, для генерации идентификаторов.
Надеюсь, кому-нибудь решение покажется полезным, а путь к нему — занятным.
Дополнение
----------
По мотивам обсуждения в комментариях. Надо быть короче и формальнее.
Есть *не отменяемые* требования:
1. В результате транслитерации должны получаться *только* буквы основной латиницы **(их всего 26)**abcdefghijklmnopqrstuvwxyz
2. Транслитерация должна быть *полностью* обратима
Есть [стандарты](https://clck.ru/9a9Ft). Ни один не соответствует требованиям.
Надо выбрать один стандарт и минимально его модифицировать, *только* для соответствия требованиям.
Модификации однозначно определяются по цепочке. Если Вам не нравится результат, напишите, пожалуйста, с какого пункта цепочки Вы не согласны.
**Для обоснования решений немного теории.**[Транслитерация](https://ru.wikipedia.org/wiki/%D0%A2%D1%80%D0%B0%D0%BD%D1%81%D0%BB%D0%B8%D1%82%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D1%8F) — точная передача *знаков* одной письменности знаками другой письменности.
Не путать с [фонетической транскрипцией](https://ru.wikipedia.org/wiki/%D0%A4%D0%BE%D0%BD%D0%B5%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%82%D1%80%D0%B0%D0%BD%D1%81%D0%BA%D1%80%D0%B8%D0%BF%D1%86%D0%B8%D1%8F) — передача звучания поощряется, но не гарантирована.
Самый низкий приоритет имеют соображения графического сходства символов. Например передача буквы ха как икс — фонетически не приемлема.
Транслитерацию можно рассматривать как кодирование символов исходного алфавита кодами переменной длинны из символов целевого алфавита. Кодом может быть:
1. одиночные символы
2. некий префикс и следующий за ним базовый символ
3. базовый символ и следующий за ним некий постфикс
4. базовый символ и c префиксом и с постфиксом
Префикс и постфикс могут быть разной длины, разумеется, чем короче, тем лучше. И конечно, хорошо бы поменьше разных префиксов и постфиксов.
Для кириллицы и латиницы вполне можно ограничится одним префиксом и одним постфиксом, оба по одному символу.
Для «легкой обратимости» кодов введем такое условие:
> никакой код не должен начинаться с постфикса и не должен заканчиваться префиксом.
>
>
Это моё обобщение [префиксного кода](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D1%84%D0%B8%D0%BA%D1%81%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BE%D0%B4).
При соблюдении такого условия можно утверждать, что в любом фрагменте результирующей последовательности не будет длинных «ложных кодов». То есть понятно, что можно отрезать префикс или постфикс, и оставшийся базовый символ совпадет с одиночным.
Этого не избежать и это придется помнить. Но не случится такого, что кусочек составного года считается вместе с соседним одиночным символом как незапланированный составной код.
Например, пусть мы используем код «S», код «SH» и код «HH» (нарушает условие, начинается с постфикса). Тогда в последовательности «SHH» (третий и первый коды) можно выделить фрагмент «SH» (соответствует второму коду).
Для префиксов нарушение условия «легкой обратимости» не так неприятно (разница потому, разбор идет слева направо). Но тоже затрудняет восприятие «на глаз» — при беглом просмотре мы считываем слово целиком, а не последовательно, и можем «зацепиться» за случайное сочетание.
Частным следствием введенного условия является запрет на использование префикса или постфикса как одиночных символов.
Для кириллицы и латиницы постфикс — это без вариантов «H».
Префикс бывает «Y» или «J». Если использовать префикс «Y», его нельзя будет применять для передачи «Й» или «Ы». То есть для двух букв (а «Й» довольно частая) придется придумать не стандартные, далекие от фонетики, и скорее всего длинные коды.
С «J» проблем нет. Отдельно этот символ применять и не хотелось.
I. Выберем отправной стандарт.
Самый фонетически верный, конечно, BGN. Но BGN принципиально (даже нарочито) не обратимый.
Самый близкий к базовой латинице и к обратимости, на мой взгляд, «ГОСТ 16876-71 / таблица 2», его и выберем. **...?**Спросите, почему не актуальный сейчас «ГОСТ 7.79-2000 / система Б». В основном за «Х» --> «X» и «Й» --> «J». Ну и сегодня актуальный — а завтра, как предыдущий ГОСТ.
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| А | Б | В | Г | Д | Е | Ё | Ж | З | И | Й | К | Л | М | Н | О | П | Р | С | Т | У | Ф | Х | Ц | Ч | Ш | Щ | Ъ | Ы | Ь | Э | Ю | Я |
| A | B | V | G | D | E | JO | ZH | Z | I | **JJ** | K | L | M | N | O | P | R | S | T | U | F | KH | C | CH | SH | SHH | **″** | **Y** | **′** | EH | JU | JA |
Схема не идеальна в плане наших требований. Придется менять.
II. Первым бросается в глаза «JJ». Почему это плохо, можно посмотреть в «теоретическом» спойлере. Следуем правилу «в любой непонятной ситуации смотри на BGN». То есть «Й» --> «Y».
III. Теперь осталась без кода «Ы». BGN не помогает. Есть фонетическая аналогия в парах «И-Ы» и «Е-Э». Для получения кода буквы «Э» стандарт добавляет к коду «Е» постфикс. Поступим также: «Ы» --> «IH».
IV. Остались не-буквенные замены для «Ь» и «Ъ». Чтобы не разрушить фонетику, можем использовать только префиксы и постфиксы.
V. Заметим, что никто не запрещал (в «теоретическом» спойлере) использовать постфикс в качестве базового символа в сочетаниях с префиксом (как минимум), и наоборот. То есть у нас есть коды «JH», «JHH» и «JJH».
VI. Осталось распределить это богатство. Более частому «Ь» — самый короткий код: «Ь» --> «JH».
VII. У «Ъ» нет звука, «Н» легче не озвучивать при чтении. Так что выберем из оставшегося код, где больше «Н»: «Ъ» --> «JHH».
Получилось:
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| А | Б | В | Г | Д | Е | Ё | Ж | З | И | Й | К | Л | М | Н | О | П | Р | С | Т | У | Ф | Х | Ц | Ч | Ш | Щ | Ъ | Ы | Ь | Э | Ю | Я |
| A | B | V | G | D | E | JO | ZH | Z | I | **Y** | K | L | M | N | O | P | R | S | T | U | F | KH | C | CH | SH | SHH | **JHH** | **IH** | **JH** | EH | JU | JA |
Код «SHH» единственный использует постфикс длины 2. Но общая длина кода всего 3, буква редкая. Обратимость не нарушается (и даже «легкая обратимость»).
Больше ничего в стандарте трогать нет необходимости.
**Код на Java для иллюстрации**
```
package tools;
import static java.lang.Character.toUpperCase;
/**
* Обратимая транслитерация кириллицы в латиницу
* Created by vladimir on 25.08.15.
*/
public class Translit {
public static String lat2cyr(String s){
StringBuilder sb = new StringBuilder(s.length());
int i = 0;
while(i < s.length()){// Идем по строке слева направо. В принципе, подходит для обработки потока
char ch = s.charAt(i);
boolean lc = Character.isLowerCase(ch); // для сохранения регистра
ch = toUpperCase(ch);
if(ch == 'J'){ // Префиксная нотация вначале
i++; // преходим ко второму символу сочетания
ch = toUpperCase(s.charAt(i));
switch (ch){
case 'O': sb.append(ch('Ё', lc)); break;
case 'H':
if(i+1 < s.length() && toUpperCase(s.charAt(i+1))=='H') { // проверка на постфикс (вариант JHH)
sb.append(ch('Ъ', lc));
i++; // пропускаем постфикс
}else{
sb.append(ch('Ь', lc));
}
break;
case 'U': sb.append(ch('Ю', lc)); break;
case 'A': sb.append(ch('Я', lc)); break;
default: throw new IllegalArgumentException("Illegal transliterated symbol '"+ch+"' at position "+i);
}
}else if(i+1 < s.length() && toUpperCase(s.charAt(i+1))=='H' ){// Постфиксная нотация, требует информации о двух следующих символах. Для потока придется сделать обертку с очередью из трех символов.
switch (ch){
case 'Z': sb.append(ch('Ж', lc)); break;
case 'K': sb.append(ch('Х', lc)); break;
case 'C': sb.append(ch('Ч', lc)); break;
case 'S':
if(i+2 < s.length() && toUpperCase(s.charAt(i+2))=='H') { // проверка на двойной постфикс
sb.append(ch('Щ', lc));
i++; // пропускаем первый постфикс
}else{
sb.append(ch('Ш', lc));
}
break;
case 'E': sb.append(ch('Э', lc)); break;
case 'I': sb.append(ch('Ы', lc)); break;
default: throw new IllegalArgumentException("Illegal transliterated symbol '"+ch+"' at position "+i);
}
i++; // пропускаем постфикс
}else{// одиночные символы
switch (ch){
case 'A': sb.append(ch('А', lc)); break;
case 'B': sb.append(ch('Б', lc)); break;
case 'V': sb.append(ch('В', lc)); break;
case 'G': sb.append(ch('Г', lc)); break;
case 'D': sb.append(ch('Д', lc)); break;
case 'E': sb.append(ch('Е', lc)); break;
case 'Z': sb.append(ch('З', lc)); break;
case 'I': sb.append(ch('И', lc)); break;
case 'Y': sb.append(ch('Й', lc)); break;
case 'K': sb.append(ch('К', lc)); break;
case 'L': sb.append(ch('Л', lc)); break;
case 'M': sb.append(ch('М', lc)); break;
case 'N': sb.append(ch('Н', lc)); break;
case 'O': sb.append(ch('О', lc)); break;
case 'P': sb.append(ch('П', lc)); break;
case 'R': sb.append(ch('Р', lc)); break;
case 'S': sb.append(ch('С', lc)); break;
case 'T': sb.append(ch('Т', lc)); break;
case 'U': sb.append(ch('У', lc)); break;
case 'F': sb.append(ch('Ф', lc)); break;
case 'C': sb.append(ch('Ц', lc)); break;
default: sb.append(ch(ch, lc));
}
}
i++; // переходим к следующему символу
}
return sb.toString();
}
public static String cyr2lat(char ch){
switch (ch){
case 'А': return "A";
case 'Б': return "B";
case 'В': return "V";
case 'Г': return "G";
case 'Д': return "D";
case 'Е': return "E";
case 'Ё': return "JO";
case 'Ж': return "ZH";
case 'З': return "Z";
case 'И': return "I";
case 'Й': return "Y";
case 'К': return "K";
case 'Л': return "L";
case 'М': return "M";
case 'Н': return "N";
case 'О': return "O";
case 'П': return "P";
case 'Р': return "R";
case 'С': return "S";
case 'Т': return "T";
case 'У': return "U";
case 'Ф': return "F";
case 'Х': return "KH";
case 'Ц': return "C";
case 'Ч': return "CH";
case 'Ш': return "SH";
case 'Щ': return "SHH";
case 'Ъ': return "JHH";
case 'Ы': return "IH";
case 'Ь': return "JH";
case 'Э': return "EH";
case 'Ю': return "JU";
case 'Я': return "JA";
default: return String.valueOf(ch);
}
}
public static String cyr2lat(String s){
StringBuilder sb = new StringBuilder(s.length()*2);
for(char ch: s.toCharArray()){
char upCh = toUpperCase(ch);
String lat = cyr2lat(upCh);
if(ch != upCh){
lat = lat.toLowerCase();
}
sb.append(lat);
}
return sb.toString();
}
/**
* Вспомогательная функция для восстановления регистра
*/
private static char ch(char ch, boolean toLowerCase){
return toLowerCase? Character.toLowerCase(ch): ch;
}
/**
* Пробы
*/
public static void main(String[] args) {
String s1 = cyr2lat("Александр Иванович Лебедь");
String s2 = cyr2lat("Веснушчатый Щавелевый");
String s3 = cyr2lat("Широкая электрификация южных губерний даст мощный толчок подъёму сельского хозяйства");
String s4 = cyr2lat("Съешь же ещё этих мягких французских булок да выпей чаю.");
String s5 = cyr2lat("А Б В Г Д Е Ё Ж З И Й К Л М Н О П Р С Т У Ф Х Ц Ч Ш Щ Ъ Ы Ь Э Ю Я");
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
System.out.println(s4);
System.out.println(s5);
System.out.println();
System.out.println(lat2cyr(s1));
System.out.println(lat2cyr(s2));
System.out.println(lat2cyr(s3));
System.out.println(lat2cyr(s4));
System.out.println(lat2cyr(s5));
}
}
```
Код приведен только для экспериментов и наглядного описания алгоритма обратного преобразования.
**Для промышленных нужд транслитерации есть соответствующие решения (хотя готового решения по требованиям 1 и 2 нет).**Из промышленных стандартов транслитерация входит в [Unicode Common Locale Data Repository Project (CLDR)](http://cldr.unicode.org/).
Есть очень мощная реализация в том числе CLDR: [International Components for Unicode](http://site.icu-project.org/).
Конкретно Java-версия ICU: [ICU4J](http://mvnrepository.com/artifact/com.ibm.icu/icu4j/55.1).
Там есть фреймворк для описания и выполнения транслитерации (и много чего еще).
Для российской кириллицы там есть готовые реализации:
1. ISO 9. Обратимая, но с диакритами.
2. BGN. Без диакритов, но с пунктуационными знаками и необратимая.
Есть «неопределенный план» добавить ГОСТ.
Если будет время и силы разобраться, сделаю и выложу реализацию своей схемы средствами ICU4J.
Благодаря конструктивной критике в комментариях, решение изменилось. Моё понимание проблемы стало глубже. Задумался о «взрослой» реализации.
Всем спасибо! Хабр делает вещи лучше. | https://habr.com/ru/post/265455/ | null | ru | null |
# Функция К.O'Nsole.log для отладки в разных браузерах
[](http://radikal.ru/F/i043.radikal.ru/1107/3c/248e35ed17e1.png)Хорош *console.log*, а нахваливать дальше некуда. И поддерживается не везде, и многобуквием страдает. И появляется задача иметь несложную функцию, настолько же гибкую, как console.log (или более), но приспособленную к разным браузерам без переделок, чтобы вывести одно или несколько значений. В отладке часто нужны текстовые поясняющие заголовки в строке, поэтому оказалось удобным иметь метод, добавленный к строке (объект String) с именем *Alert*, выполняющий то же самое, что и *console.log* и выводящий контекст-строку впереди списка аргументов. (Строку в апострофах, потому что удобно затем копировать и искать по кодам, где такой заголовок написан.)
Углубляться в многообразие команд в реализациях каждого браузера оказывается ненужным, потому что это теряет смысл при проверках в другом браузере. А долгое допиливание идеального продукта — попросту невыгодно, требует профессионального углубления в особенности и слежения затем за новинками, ошибками и их устранением. Нужна совершенно простая схема работы, которая легко доработается, если что-либо надо дополнительно и использующая базовые возможности консолей отладки.
Система чуть сложнее, чем доопределение самого console.log (внутренняя функция *alertInner*), и имеет такие достоинства:
1) новых слов всего 2, и те — знакомы;
2) слова — короче, чем К.О'Ns… (и т.д.);
3) не замещает других используемых имён,
4) гораздо проще других сложных скриптов,
5) код легко читается и кастомизируется.
Обычный *alert()* в этой системе участвует как наихудшая альтернатива вывода. Но и он может за один раз выдать несколько значений, разделённых запятой (например, в IE8 без включённого DebugBar-а).
Часто требуются 2 основных действия: запретить всю отладку одной командой; отключить бОльшую часть отладки, если вынужден смотреть алерты в малых объёмах или просто есть желание посмотреть часть сообщений. Строки-контексты для этого хорошо подходят. Будем включать только те сообщения, в заголовках которых найдутся образцы (жадного) регулярного выражения:
```
Alert.go =''; //- разрешить все; аналог типичного DEBUG = true; , но без лишней переменной;
Alert.go ='.'; //- разрешить только методы-Алерты, кроме ''.Alert() (простые функции Alert запрещены искусственно по признаку - так удобно, исключение 1);
Alert.go ='.*'; //разрешить и с пустой строкой, но без простых алертов, исключение 2;
delete Alert.go; //- запретить все;
Alert.go ='fthghhfgh'; //запретить методы-Алерты;
Alert.go ='^(aab|xaa==|test45:|xxx|__)$'; //- выполнять только перечисленное (и функции-Алерты).
```
(Для удобства в код вшиты 2 исключения и 1 кастомизация. Последнюю можно выбросить или наоборот, развить, но исключения — полезные и понятные. Надо иметь весь спектр действий: запретить всё, разрешить функции, разрешить методы, разрешить то и другое, разрешать методы с фильтром и без — не увеличивая систему команд.)
Запускаем:
```
Alert(aaa, bbb,'==переменные==', ссс); //обычный аналог console.log()
'xaa=='.Alert(xaa, xx.element, xaa(1)); //всё, что хотим - под своим заголовком в начале строки
'-test-'.Alert('вывод текста самого себя, например', Alert);
```
Таким образом, запускать на разных отладочных страницах разные выдачи оказывается удобно и наглядно. Инструмент остаётся крайне простым (всего 3 функции под одним именем, каждая из которых знакома и востребована), хотя есть резервы повышения монстрообразности — если в контекст ставить имя функции-обработчика или хеш, описывающий таблицу выдачи, можно далеко зайти. Или, например, я добавил в код ососбый вывод для сообщений вида *Alert({from:'-test-', xx: прочие параметры… });*. Обычно этот формат не нужен, т.к. забывается; но плюс его в том, что первый аргумент, хеш — просматривается разобранным, иногда бывает нужен для показа в простых алертах и в HTML.
Такую же систему сообщений можно внедрить в рабочий проект как приложение для других событий, под другим именем и выдавать не в консоль, а в хорошо оформленный блок, если они — для пользователя, или передавать на сервер.
Для консоли раньше в Опере нужно было так, сейчас не обязательно (есть Dragonfly-консоль, Ctrl-Shift-I, затем значок ">\_"):
```
...else if (window.opera && opera.postError) {opera.postError(arguments);}
```
… Недавно тут FF5 (или firebug?) испортил картину, отказавшись понимать console.log.apply, пришлось дописать некрасивую альтернативу. Как обойти баг, не придумал, да и не обязательно. Редко число аргументов больше 7 и всегда их можно собрать в массив.
Код функции:
```
/**
* Функция/метод "Лог-отладка-фильтр", spmbt0, 30.07.2011
* @context (String) : начальные слова, описывающие строку отладки
* @property go: рег.выражение для фильтра лога или undefined, если запретить выдачу
* @param o: аргументы, выводящиеся в 1 строке в консоли отладки
*/
Alert = function(o){
if(Alert.go===undefined) return; //===быстрый общий запрет===
var alertInner = function(x, xx,a,b,c,d,e){ //x: аргументы (в FF5 - до 7, особенность Firebug для этой версии)
var aL = arguments.length;
if(!window.console){
for(var i =0, args =[]; i < aL; i++)
args[i] = arguments[i];
alert(args);
}else if(console.log.apply)
console.log.apply(console, arguments);
else{ //иначе - 5-й FF не умеет понимать console.log.apply
if(aL ==1) console.log(x);
else if(aL ==2) console.log(x, xx);
else if(aL ==3) console.log(x, xx, a);
else if(aL ==4) console.log(x, xx, a, b);
else console.log(x, xx, a, b, c, d, e);
}
}, hasContext = this !== window
, context = this;
if(hasContext && context instanceof String){
if(!RegExp(Alert.go,'g').test(context)) //===фильтрация по разрешениям===
return;
for(var i =1, args =[]; i <= arguments.length; i++)
args[i] = arguments[i -1];
args[0] = "'"+ context +"':";
alertInner.apply(window, args); //===console.log с текстовым контекстом на первом месте===
}else{ //место для кастомизации. Пример с {from:'имя', ...}
if(Alert.go =='.' || Alert.go =='.*') return; //===запретить обычные алерты===
if(o && o.from && o.from !=''){ //если в хеше в первом аргументе есть ключ "from", он оформляется особо
var args =[], j =1;
for(var i in o)
if(i !='from'){
args[j++] = '{'+ i +'}';
args[j++] = o[i];
}
if(arguments.length >1) //разделитель
args[j++] ='}; ';
for(var i = 1, aL = arguments.length; i < aL; i++) //вывод следующих аргументов
args[j++] = arguments[i];
args[0] = "'"+ o.from +"':";
alertInner.apply(window, args); //===console.log со значение ключа "from" на первом месте===
}else
alertInner.apply(window, arguments); //===обычный console.log===
}
}
String.prototype.Alert = Alert;
Alert.go =''; //разрешить всё
//Alert.go ='test-'; //разрешить только с таким фрагментом в контексте (и все простые Alert() )
```
Для просмотра получившегося содержимого в консоли — сделать:
**Firefox**: при наличии Firebug — Ctrl-Shift-L (командная строка); без него — никто не знает :);
**Chrome**: Ctrl-Shift-J (консоль Javascript);
**Safari**: Ctrl-Alt-C (консоль ошибок);
**IE**: чтобы не выводилось это алертами, открыть DebugBar или что-то аналогичное;
**Opera**: сообщения видны в консоли ошибок (Ctrl-Shift-O), но там — с мусором; удобнее — в Dragonfly (Ctrl-Shift-I, затем значок ">\_").
Работу скрипта с примерами смотреть здесь: [spmbt.kodingen.com/function/testAlert.htm](http://spmbt.kodingen.com/function/testAlert.htm).
Вопрос (опрос): кто какие немонстровидные решения для отладки использует?
\*) К литературе от себя добавлю, что есть у Firebug фича, которую крайне сложно найти в описаниях, если не знаешь, как она называется. Называется она "[debugger;](http://getfirebug.com/wiki/index.php/Debugger;_keyword)". Если такое имя встретится в джаваскрипте, Firebug остановится как на обычном брейкпойнте, дальнейший старт программы — из вкладки «Script» кликом на «Continue (F8)».
*[weirdan](http://habrahabr.ru/users/weirdan/) написал:* *--Эта фича есть в ECMA-262-5 и поддерживается как в Fx, так и в IE.*
**0.** Firebug [Command Line API](http://getfirebug.com/wiki/index.php/Command_Line_API).
**0.1** [Вышел релиз Firebug 1.8](http://blog.getfirebug.com/2011/07/29/firebug-1-8-0/) (поддерживается в Firefox 5.0). [Детальная информация (на Хабре) по новым возможностям версии](http://habrahabr.ru/blogs/firefox/125321/).
О консоли на Хабре:
**1.** [«Отладка Javascript в различных браузерах и средах»](http://habrahabr.ru/blogs/javascript/50096/), 24 января 2009, [lomaster](http://habrahabr.ru/users/lomaster/)
**2.** [Используем console на полную](http://habrahabr.ru/blogs/javascript/114483/), 26 февраля 2011, Ryan Seddon
**3.** [Удалённая отладка Javascript](http://habrahabr.ru/blogs/javascript/114811), 3 марта 2011, youtu.be…
**4.** [Современная отладка JavaScript](http://habrahabr.ru/blogs/javascript/51354/), 7 февраля 2009, Chris Mills, Hallvor…
**5.** [Использование средств отладки](http://habrahabr.ru/blogs/personal/38284/), 27 августа 2008, Pamela Fox, Google M… | https://habr.com/ru/post/125308/ | null | ru | null |
# How does Rust treat Strings and Vectors internally
1. Strings
----------
In Rust strings can be represented in two ways:
a) String type
b) String slice
**String type:**
String type is defined as a struct of the following structure:
Depending on arch (in my case x86 64bit it is 24byte)
*{*
*pointer to the address where string characters are stored (8b)*
*capacity (8b)*
*length (8b)*
*}*
Example:
```
let my_string = String::from("hello");
```
**String slice (String slice has type &str):**
There are two types of slices:
***a) built from Strings***
```
let my_string_slice = &my_string[3..];
```
The goal of such slice is to point on some part of the string
The structure of such slice similar to String:
*{*
*pointer to the address where string characters are stored (8b)*
*length (8b)*
*starting index (8b)*
*}*
***b) built from string literals***
```
let my_str = "Hello";
```
It has reduced size:
*{*
*pointer to the address where string characters are stored (8b)*
*length (8b)*
*}*
**Memory layout:**
So let’s have a look how does these two types lays on memory:
Let’s consider couple definitions:
```
let my_str :&str = "hello";
let my_string1: String = my_str.to_string();
let my_string2: String = String::from("hello");
let my_string_slice: &str = &my_string2[1..4];
```
We have defined 4 local variables:
my\_str – is a slice defined from string literals “hello”. Such string literals are part of the code(data segment more precisely)
my\_string1 – result of creation String from the slice using to\_string method;
my\_string2 – string creation using from method.
my\_string\_slice – slice from string
The following picture shows memory layout for each variable:
As you can see first variable(&str) is created in stack and pointing to the static location of our code where string literals of “hello” are placed
Then when we call to\_string() the new variable my\_string1 is created and memory on heap is allocated to place “hello” chars there.
Same happens when we create my\_string2 variable.
Creation of my\_string\_slice from my\_string2 leads to pointing to the same area in heap where my\_string2 characters are placed but with shift in address considering starting index
2. Vectors
--------------
Vectors in rust are dynamically extended data structures;
They have similar structure as String:
*{*
*pointer to the address in the heap where data are stored (8b)*
*capacity (8b)*
*length (8b)*
*}*
Let’s have a look what happens when we create new vector and push some data to it (continue of the previous example with strings).
```
let mut str_vec = Vec::new();
str_vec.push(my_string1);
str_vec.push(my_string2);
```
So as we see when we created str\_vec variable of type Vec the new memory were allocated in heap. To be more precise during variable creation using new() method pointer of the vector doesn’t point to real heap space. This happen only with first push:
Memory dump:
```
let mut str_vec = Vec::new();
```
pointer = 0x3a772ff2f8 (&str\_vec)
08 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
```
str_vec.push(my_string1);
```
50 5e ca db db 01 00 00 04 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00
```
str_vec.push(my_string2);
```
50 5e ca db db 01 00 00 04 00 00 00 00 00 00 00 02 00 00 00 00 00 00 00
So as you can see real address pointing to the heap(0x000001dbdbca5e50) appears only after first push. Initial capacity 4 is reserved at this time as well. When more the 4 elements will be pushed the new area will be allocated with extended size.
When *my\_string1* and *my\_string2* were pushed to the vector two things happened:
1) Memory allocation in heap for storing two string variables. Pay attention that pointers of the strings still point to same addresses were chars were stored.
2) Move of ownership: *my\_string*1 and *my\_string*2 are no more accessible as local variables. (see more details from official rust tutorial regarding transfer ownership). Moving variables to heap space is shown with dot arrow on the pic.
3. Magic transformation during procedure call
-------------------------------------------------
Let’s consider the following code:
```
fn main() {
let args: Vec = env::args().collect();
let ptr: \*mut u8 = unsafe { mem::transmute(&args) };
print\_mem(ptr, 24 );
let (query, filename) = parse\_config(&args);
}
fn parse\_config(args: &[String]) -> (&str, &str) {
println!("args val {:p}", args);
let query = &args[1];
let filename = &args[2];
(query, filename)
}
```
Here we can see declaration of vector variable “args” that takes incoming parameters of main function in vector format.
```
let args: Vec = env::args().collect();
```
As result we have local variable “args” created on stack.
Let’s print it’s content (execute the program with two args: cargo run param1 param2):
```
let ptr: *mut u8 = unsafe { mem::transmute(&args) };
print_mem(ptr, 24 );
```
pointer = 0xfa9a4ff730
40 2a 6f b3 6a 02 00 00 03 00 00 00 00 00 00 00 03 00 00 00 00 00 00 00
So as we can see “args” has three parts:
1) Pointer to heap 0x26ab36f2a40 where strings with argument values are allocated
2) Capacity of the vector (03)
3) Length of the vector (03)
Now let’s have a look at function call:
```
let (query, filename) = parse_config(&args);
```
and function definition:
```
fn parse_config(args: &[String]) -> (&str, &str) {
…
}
```
You can notice some mismatch in calling params type and param definition in function.
The function is defined with ***&[String])*** parameter but is called with address of local variable “args” that has ***Vec*** type.
So let’s try to understand how it can be?
Here some magic of rust compiler happens: as “args” variable in main function is local variable it’s address itself(address in stack) is not transferred to calling function (actually technically it can be but not done in this way) overwise compiler analyze that expected param of calling function is address of String array ***&[String]****)* and sends address of start of String array in heap where pointer in “args” is referring(0x26ab36f2a40 in our example)
We can see it if will print value of incoming parameter “args” in parse\_config function:
```
println!("args val {:p}", args);
```
output: 0x26ab36f2a40
***Note: in rust it is called "Implicit Deref Coercions with Functions and Methods". It is related to Deref trait and you can read about it in more details from official tutorial.*** | https://habr.com/ru/post/657547/ | null | en | null |
# Реализация остальных возможностей PEG
После того, как я собрал все части генератора PEG-парсеров воедино в предыдущем посте, я готов показать как реализовать и некоторые другие интересные штуки.
**Содержание серии статей о PEG-парсере в Python*** [PEG парсеры](https://habr.com/ru/post/471860/)
* [Реализация PEG парсера](https://habr.com/ru/post/471862/)
* [Генерация PEG парсера](https://habr.com/ru/post/471864/)
* [Визуализация работы PEG парсера](https://habr.com/ru/post/471866/)
* [Леворекурсивные PEG грамматики](https://habr.com/ru/post/471986/)
* [Добавление экшенов в грамматику PEG](https://habr.com/ru/post/471988/)
* [Мета-грамматика для PEG парсера](https://habr.com/ru/post/471990/)
* [Реализация остальных возможностей PEG](https://habr.com/ru/post/471992/)
* [PEG на Core Developer Sprint](https://habr.com/ru/post/471994/)
Мы рассмотрим следующие фичи PEG:
* Именованные элементы: `NAME=item` (имя можно использовать в экшене)
* Lookaheads: `&item` (положительный) и `!item` (отрицательный)
* Группировка элементов в скобках: (`item item ...`)
* Опциональные элементы: `[item item ...]` и `item?`
* Повторяющиеся предметы: `item*` (ноль или более) и `item+` (один или несколько)
Именованные аргументы
---------------------
Давайте начнём с именованных элементов. Это удобно, когда у нас есть их несколько штук в одной альтернативе для одного и того же правила, например:
```
expr: term '+' term
```
Мы можем сосылаться на второй `term`, добавляя цифру `1` к имени переменной, чтобы в экшене получилось так:
```
expr: term '+' term { term + term1 }
```
Но это не всем нравится, и лично я предпочел бы написать что-то вроде такого:
```
expr: left=term '+' right=term { left + right }
```
Это легко поддержать в мета-грамматике, изменив правило для `item` следующим образом:
```
item:
| NAME = atom { NamedItem(name.string, atom) }
| atom { atom }
atom:
| NAME { name.string }
| STRING { string.string }
```
(Где `atom` это просто старый `item`)
Это требует от нас добавления определения класса `NamedItem` в `grammar.py`. Он является ещё одним из тех классов данных, о которых я уже говорил ранее — у него тоже есть атрибуты `name` и `item`.
Нам также нужно внести небольшие изменения в генератор кода, которые я оставлю в качестве упражнения для читателя (или вы можете заглянуть в мой репозиторий :-). Сгенерированный код теперь назначит результат сопоставления каждого элемента переменной с указанным именем, а не с именем, полученным из названия правила элемента. Это также сработает для элементов, которые являются токенами (либо формы `NAME`, либо строковых литералов, таких как `':='`).
Lookahead
---------
Далее следуют lookahead. Вы наверняка встречались с этим понятием в регулярных выражениях. В процессе предварительного просмотра вперёд (lookahead) может быть сразу отклонена или принята разбираемая альтернатива, без сдвига указателя токенизатора.
На самом деле, lookahead можно использовать в качестве более изящного способа устранения путаницы с исключениями парсера, о которых я писал в предыдущей статье. Вместо того, чтобы разрешать экшенам отклонять уже принятую альтернативу, возвращая None, мы можем добавить перед `OP` инструкцию для исключения `"}"`. Старое правило выглядело так:
```
| OP { None if op.string in ("{", "}") else op.string }
```
Новая версия выглядит так:
```
| !"}" OP { op.string }
```
Это переносит обработку фигурной скобки из экшена в грамматику, где ей и место. Нам не нужно проверять `"{"`, так как она соответствует более ранней альтернативе (на самом деле это верно и для старой версии, но я об этом забыл :-).
Мы добавляем грамматику для lookaheads в правило для `item` следующим образом:
```
item:
| NAME = atom { NamedItem(name.string, atom) }
| atom { atom }
| "&" atom { Lookahead(atom, True) }
| "!" atom { Lookahead(atom, False) }
```
Ещё раз, мы должны добавить датакласс `Lookahead` в `grammar.py` (и импортировать его в `@subheader`!) И немного изменить генератор, добавив в него следующий вспомогательный метод:
```
def lookahead(self, positive, func, *args):
mark = self.mark()
ok = func(*args) is not None
self.reset(mark)
return ok == positive
```
В нашем случае сгенерированный код для этой альтернативы выглядит так:
```
if (True
and self.lookahead(False, self.expect, "}")
and (op := self.expect(OP))
):
return op . string
```
Как видно из приведённого выше фрагмента грамматики, lookahead не могут получить собственные имена. Это легко поправить, но я пока не представляю как бы это пригодилось. Кроме того, для негативных прогнозов значение всегда будет `None`.
Группировка в скобках
---------------------
Теперь давайте реализуем группы со скобками. Лучшее место для добавления их в метаграмму — правило для `atom`:
```
atom:
| NAME { name.string }
| STRING { string.string }
| "(" alts ")" { self.synthetic_rule(alts) }
```
Первые две альтернативы не изменились. Экшен для новой альтернативы использует хак (чья реализация останется необъяснённой), которая позволяет мета-парсеру добавлять новые правила в грамматику на лету. Эта вспомогательная функция (определённая в мета-парсере) возвращает имя нового объекта правила. Оно будет состоять из фиксированного префикса, за которым следует число, что делает его уникальным, например, `_synthetic_rule_1`.
Вы можете спросить, что произойдёт, если синтетическое правило в конечном итоге будет отброшено. Я не знаю как этого избежать, но тут проблем быть не должно — в худшем случае в грамматике будет неиспользуемое правило. А благодаря мемоизации один и тот же экшен никогда не будет выполнен дважды для одной и той же позиции ввода, так что это тоже не проблема (но даже если бы это было так, в худшем случае у нас было бы мёртвое правило).
Использование `alts` внутри скобок означает, что мы можем определить вертикальную черту как разделитель внутри группы. Например, что наше новое решение для экшена не будет случайно совпадать с `{`, мы могли бы изменить отрицание на такое:
```
| !("{" | "}") OP { op.string }
```
Более того, группы также могут содержать экшены! Это не помогло бы при решении проблемы с экшенами, но в других ситуациях вполне может оказаться полезным. И поскольку мы в любом случае генерируем синтетическое правило, для его реализации не требуется никакой дополнительной работы (кроме реализации `synthetic_rule` :-).
Опциональные элементы
---------------------
Как и в старом pgen, я использую квадратные скобки для обозначения группы необязательных токенов. Это много где оказывается полезным. Например, правило грамматики, описывающее цикл Python `for`, может использовать её, чтобы указать, что может существовать продолжение `else`. И мы снова можем расширить грамматику для `atom` следующим образом:
```
atom:
| NAME { name.string }
| STRING { string.string }
| "(" alts ")" { self.synthetic_rule(alts) }
| "[" alts "]" { Maybe(self.synthetic_rule(alts)) }
```
Здесь `Maybe` — другой класс данных, с единственным атрибутом `item`. Мы модифицируем генератор кода так, чтобы результат выполнения синтетической функции не завершается ошибкой, если это значение равно `None`. Для этого можно добавить `or True` в реализации. Например, для `[term]`:
```
if (True
and ((term := self.term()) or True)
):
return term
```
Повторяющиеся элементы
----------------------
Переход к повторениям — ещё одна полезная функция PEG (нотация заимствована из регулярных выражений и также используется в pgen). Существует две формы: добавление `*` к атому означает «ноль или более повторений», в то время как добавление `+` — «одно или несколько повторений». По иным причинам мне пришлось переписать правила грамматики для `item` и `atom`, добавив промежуточное правило, которое я назвал `molecule`:
```
item:
| NAME '=' molecule { NamedItem(name.string, molecule) }
| "&" atom { Lookahead(atom) }
| "!" atom { Lookahead(atom, False) }
| molecule { molecule }
molecule:
| atom "?" { Maybe(atom) }
| atom "*" { Loop(atom, False) }
| atom "+" { Loop(atom, True) }
| atom { atom }
| "[" alts "]" { Maybe(self.synthetic_rule(alts)) }
atom:
| NAME { name.string }
| STRING {string.string }
| "(" alts ")" { self.synthetic_rule(alts) }
```
Заметьте, что это вводит альтернативный синтаксис для опциональных элементов (`atom?`). Он не требует дополнительных усилий по реализации, поскольку это просто ещё один способ создания узла `Maybe`.
Рефакторинг этих правил был необходим, потому что я не хочу делать допустимыми некоторые ситуации:
* необязательные повторения (так как это просто повторение ноль или более);
* повторные повторения (внутреннее захватило бы все совпадения, поскольку PEG всегда использует жадный алгоритм)
* повторные опциональные значения (которые прервали бы анализ, если опциональный элемент не совпадает).
Однако, это всё ещё не идеальное решение, так как вы можете написать что-то вроде `(foo?)*`. В генератор парсера нужно будет добавить проверку и на эту ситуацию, но я сделаю это вне статьи.
Класс данных `Loop` имеет два атрибута: `item` и `nonempty`. Сгенерированный код будет использовать вспомогательный метод парсера `loop()`. Он весьма похож на метод `lookahead()`, показанный ранее:
```
def loop(self, nonempty, func, *args):
mark = self.mark()
nodes = []
while node := func(*args) is not None:
nodes.append(node)
if len(nodes) >= nonempty:
return nodes
self.reset(mark)
return None
```
Если `nonempty` равно `False` (в смысле в грамматике была `*`), то это не приведёт к ошибке. Ни одного вхождения не будет найдено, и вернётся пустой список. Чтобы так получилось, мы реализуем генератор парсера таким образом, чтобы добавлялось `is not None`. Более мягкая проверка из предыдущего поста вернула бы `False` в случае пустого списка.
На сегодня всё! Я собирался обсудить оператор «вырезать» (`~`), присутствующий в TatSu, но мне пока не довелось с ним столкнутся. Я не готов даже пока его обсуждать — документация TatSu приводит только простой пример, который меня мало интересует. Я не нашёл его и в других генераторах PEG-парсеров, так что, возможно, эта фича есть только TatSu. Может быть, я когда-нибудь расскажу и про него. (Тем временем я его реализовал на всякий случай, мало ли. :-)
Я думаю, что следующая статья будет о моём опыте написания грамматики PEG, которая сможет анализировать грамматику Python. Я расскажу как прошёл спринт разработчиков ядра Python, который был на этой неделе в Лондоне при материально-технической поддержке Bloomberg и финансовой поддержке PSF и некоторых других компаний (например, Dropbox оплатил мне отель и перелёт). Особая благодарность Эмили Морхауз и Пабло Галиндо Сальгадо, которые очень помогли в реализации инструментов и тестов. Далее мы напишем тесты производительности, а потом собираемся добавить экшены к этой грамматике, чтобы она могла создавать деревья AST, которые могут быть скомпилированы компилятором байт-кода CPython. Впереди ещё столько всего интересного!
Лицензия на эту статью и приведенный код: [CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) | https://habr.com/ru/post/471992/ | null | ru | null |
# Сравниваем async/await и then/catch с примерами
 В JavaScript есть два основных способа обработки асинхронного кода: Promise (ES6) и async / await (ES7). Эти синтаксисы дают нам равные базовые функции, но по-разному влияют на читаемость и область видимости. В этой статье мы увидим, как один синтаксис помогает, а другой отправляет нас в callback hell! Материал адаптирован на русский язык совместно с Тимофеем Тиуновым, системным архитектором в Сбермегамаркете и автором курса “JavaScript” в Skillbox.
**Тимофей Тиунов:** *“На самом деле основных способов обработки асинхронного кода три,* — *есть ещё коллбэки. Суть третьего подхода в том, что вы просто передаете функцию как аргумент при вызове другой функции. Например, так работает addEventListener. В современном JavaScript этот способ занял свое место именно в обработке событий, а для написания кода, в котором нужно дождаться выполнения какой-то операции, он оказался неудобным и громоздким. Поэтому с развитием языка появился сначала Promise, а затем синтаксис с async/await”.*
JavaScript запускает код построчно, переходя к следующей строке кода только после выполнения предыдущей. Но это может стать проблемой. Иногда нам нужно реализовать задачи, которые требуют длительного или непредсказуемого времени для выполнения: например, получение данных через API.
К счастью, блокировать основной поток нет необходимости, JavaScript позволяет выполнять задачи параллельно. В ES6 был представлен объект Promise, с методами then, catch и finally. Год спустя, в ES7, в язык добавили еще один подход и два новых ключевых слова: async и await.
Эта статья не ставит своей целью объяснить асинхронный JavaScript; для этого есть много хороших источников. Вместо этого освещается менее раскрытая тема: какой синтаксис — then / catch / finally или async / await — лучше?
**Тимофей Тиунов, автор курса “**[**JavaScript**](https://skillbox.ru/course/javascript/)**” в Skillbox:** *“В действительности оба способа используются и часто сочетаются друг с другом. Автор создает ложное впечатление, что один лучше другого, но это не так”.*
Сначала обратимся к главным функциям каждого синтаксиса, а затем перейдем к примерам.
then, catch и finally
---------------------
then, catch и finally—методыобъекта Promise, они объединены в цепочку и идут один за другим. Каждый принимает функцию обратного вызова в качестве аргумента и возвращает Promise.
Создадим простой Promise:
```
const greeting = new Promise((resolve, reject) => {
resolve("Hello!");
});
```
Используя then, catch и finally можно выполнить серию действий, в зависимости от того, разрешен (then) или отклонен (cach) Promise. В то время, как finally позволяет нам выполнять код после выполнения Promise, независимо от того, было ли оно разрешено или отклонено.
```
greeting
.then((value) => {
console.log("The Promise is resolved!", value);
})
.catch((error) => {
console.error("The Promise is rejected!", error);
})
.finally(() => {
console.log("The Promise is settled, meaning it has been resolved or rejected.");
});
```
**Тимофей Тиунов:** *“Пример не совсем корректный, так как если сам коллбэк в catch не выкинет ошибку через throw или return Promise.reject, после него можно снова писать then. То есть в данном случае finally бессмысленный”.*
В соответствии с целью статьи, использовать можно then. Объединив несколько then методов, мы получаем возможность выполнять последовательные операции над разрешенным Promise. Типичный шаблон для выборки данных с использованием then будет выглядеть примерно так:
```
fetch(url)
.then((response) => response.json())
.then((data) => {
return {
data: data,
status: response.status,
};
})
.then((res) => {
console.log(res.data, res.status);
});
```
**Тимофей Тиунов:** *“Код в последнем примере написан некорректно, так как response недоступен”.*
async и await
-------------
async и await — это синтаксический сахар поверх Promise, который позволяет писать асинхронный код так, как будто инструкции выполняются сверху вниз одна за другой, местами значительно упрощает структуру кода и повышает читаемость.
**Тимофей Тиунов:** *“Ключевое слово async ставится перед функцией при ее объявлении. Это позволяет внутри такой функции использовать другое ключевое слово* — *await. await же даёт возможность остановить выполнение функции, чтобы дождаться разрешения promise'а или завершения другой async-функции”.*
Обратите внимание, как размещение ключевого слова async зависит от того, используем ли мы обычные или стрелочные функции:
```
async function doSomethingAsynchronous() {
// logic
}
const doSomethingAsynchronous = async () => {
// logic
};
```
await можно написать перед любой асинхронной функцией или объектом Promise. Таким образом выполнение кода асинхронной функции “зависнет” на этой строке кода до окончания выполнения операции. Пример с greeting:
```
async function doSomethingAsynchronous() {
const value = await greeting;
}
```
Переменную value можно использовать после этого, как будто бы она часть нормального синхронного кода. Что касается обработки ошибок, мы можем заключить любой асинхронный код в оператор try ... catch ... finally, например:
```
async function doSomethingAsynchronous() {
try {
const value = await greeting;
console.log("The Promise is resolved!", value);
} catch((error) {
console.error("The Promise is rejected!", error);
} finally {
console.log("The Promise is settled, meaning it has been resolved or rejected.");
}
}
```
Для возвращения Promise в рамки функции async не нужно использовать await. Пример:
```
async function getGreeting() {
return greeting;
}
```
**Тимофей Тиунов:** *“В данном примере async не нужен. Вот пример, где как бы есть await, но в конце возвращается promise:*
```
const res = await fetch(...);
return await res.json(); // тут await можно убрать”.
```
Однако есть одно исключение из этого правила: вам действительно нужно написать return await, если вы хотите обработать Promise, отклоненный в блоке try ... catch.
```
async function getGreeting() {
try {
return await greeting;
} catch (e) {
console.error(e);
}
}
```
Использование абстрактных примеров может помочь нам понять каждый синтаксис, но без наглядных примеров сложно осознать, почему один может быть предпочтительнее другого.
Проблема
--------
Представим, что нам нужно выполнить операцию с большим набором данных для книжного магазина. Наша задача — найти всех авторов, написавших более 10 книг, в нашем наборе данных и вернуть их биографические данные. У нас есть доступ к библиотеке с тремя асинхронными методами:
* `getAuthors` - returns all the authors in the database;
* `getBooks` - returns all the books in the database;
* `getBio` - returns the bio of a specific author.
Объекты выглядят следующим образом:
* `Author: { id: "3b4ab205", name: "Frank Herbert Jr.", bioId: "1138089a" }`
* `Book: { id: "e31f7b5e", title: "Dune", authorId: "3b4ab205" }`
* `Bio: { id: "1138089a", description: "Franklin Herbert Jr. was an American science-fiction author..." }`
Также нам понадобится вспомогательная функция filterProlificAuthors, которая принимает все записи и все книги в качестве аргументов и возвращает идентификаторы авторов с более чем 10 книгами:
```
function filterProlificAuthors(authors, books, minBookCount = 10) {
return authors.filter(
({ id }) => books.filter(({ authorId }) => authorId === id).length > minBookCount
);
}
```
### Решение
#### Часть 1.
Чтобы решить эту проблему, нам нужно получить всех авторов и все книги, отфильтровать результаты на основе заданных критериев, а затем получить биографические данные всех авторов, которые соответствуют этим критериям. В псевдокоде наше решение может выглядеть примерно так:
```
FETCH all authors
FETCH all books
FILTER authors with more than 10 books
FOR each filtered author
FETCH the author’s bio
```
Каждый раз, когда мы видим FETCH, нужно выполнить асинхронную задачу. Итак, как мы могли превратить это в JavaScript? Во-первых, давайте посмотрим, как мы можем закодировать эти шаги, используя then:
```
getAuthors().then((authors) =>
getBooks()
.the((books) => {
const prolificAuthorIds = filterProlificAuthors(authors, books);
return Promise.all(prolificAuthorIds.map((id) => getBio(id)));
})
.then((bios) => {
// Do something with the bios
})
);
```
Этот участок действительно делает, что требуется. Но вот вложенность затрудняет понимание кода с первого взгляда. Второй then вкладывается в первый then, а третий then параллелен второму.
**Тимофей Тиунов:** *“Это скорее должно выглядеть так (ниже). Получение авторов и книг происходит последовательно, хотя ничего не мешает сделать это параллельно. Для этого можно передать вызовы getAuthors/Books в Promise.all, который вернёт promise, разрешающийся тогда, когда все переданные в него promise'ы тоже разрешатся.*
```
Promise.all([
getAuthors(),
getBooks(),
]).then(([authors, books]) => {
const prolificAuthorIds = filterProlificAuthors(authors, books);
return Promise.all(prolificAuthorIds.map((id) => getBio(id)));
}).then(bios => {
// …
})”
```
Код мог бы стать немного более читаемым, если использовать then для возврата даже синхронного кода. Можно дать filterProlificAuthors собственный метод then, как показано ниже:
```
getAuthors().then((authors) =>
getBooks()
.then((books) => filterProlificAuthors(authors, books))
.then((ids) => Promise.all(ids.map((id) => getBio(id))))
.then((bios) => {
// Do something with the bios
})
);
```
У этой версии есть преимущество - каждый then помещается в одну строку. Правда, и это не избавляет от нескольких уровней вложенности.
Ну а что насчет async и await? Вот примерно такое решение:
```
async function getBios() {
const authors = await getAuthors();
const books = await getBooks();
const prolificAuthorIds = filterProlificAuthors(authors, books);
const bios = await Promise.all(prolificAuthorIds.map((id) => getBio(id)));
// Do something with the bios
}
```
Это решение кажется уже более простым. Здесь нет вложенности, и всего четыре строки. Но преимущества async / await станут еще более очевидными по мере изменения критериев.
**Тимофей Тиунов:** *“А вот это очень вредный пример. Вызовы с await, которые идут подряд сверху вниз, будут исполняться последовательно, хотя в данном случае можно параллельно. Здесь подойдёт гибридное решение на основе promise'ов и await:*
```
const [authors, books] = await Promise.all([
getAuthors(),
getBooks(),
]);”
```
#### Часть 2
Введем новое требование. На этот раз, когда у нас есть массив bios, мы хотим создать объект, содержащий bios, общее количество авторов и общее количество книг.
Сразу начнем с async/await:
```
async function getBios() {
const authors = await getAuthors();
const books = await getBooks();
const prolificAuthorIds = filterProlificAuthors(authors, books);
const bios = await Promise.all(prolificAuthorIds.map((id) => getBio(id)));
const result = {
bios,
totalAuthors: authors.length,
totalBooks: books.length,
};
}
```
Легко и просто. С кодом ничего не нужно делать, поскольку все переменные уже есть. Стоит просто определить результирующий объект в конце.
С then это непросто. В решении из предыдущей части переменные books и bios находятся на разных уровнях. В принципе, можно было бы ввести еще и переменную books, но это усложнило бы ситуацию. Одно из решений - ввести третий уровень вложенности:
```
getAuthors().then((authors) =>
getBooks().then((books) => {
const prolificAuthorIds = filterProlificAuthors(authors, books);
return Promise.all(prolificAuthorIds.map((id) => getBio(id))).then(
(bios) => {
const result = {
bios,
totalAuthors: authors.length,
totalBooks: books.length,
};
}
);
})
);
```
Кроме того, можно деструктурировать массив для передачи books по цепочке на каждом этапе:
```
getAuthors().then((authors) =>
getBooks()
.then((books) => [books, filterProlificAuthors(authors, books)])
.then(([books, ids]) =>
Promise.all([books, ...ids.map((id) => getBio(id))])
)
.then(([books, bios]) => {
const result = {
bios,
totalAuthors: authors.length,
totalBooks: books.length,
};
})
);
```
Мне кажется, ни одно из этих решений не является хорошо читаемым. Сложно определить с первого взгляда переменные и их доступность.
**Тимофей Тиунов:** *“А вот тут прям классный пример, где действительно async/await сильно упрощает код. В коде на async/await все значения находятся в рамках одной фукнции, то есть в одной области видимости. Это значит, что в любом месте функции после объявления нужного значения мы имеем к нему доступ. В случае с promise'ами результаты вычислений одного блока then/catch нам нужно явно передавать в другой, если это необходимо. В таких ситуациях, конечно, async/await может сильно выручить.”*
#### Часть 3
В качестве оптимального варианта можно улучшить предыдущее решение, немного его очистив. Для этого можно использовать Promise.all, что дает возможность выбрать и авторов и книги параллельно.
```
Promise.all([getAuthors(), getBooks()]).then(([authors, books]) => {
const prolificAuthorIds = filterProlificAuthors(authors, books);
return Promise.all(prolificAuthorIds.map((id) => getBio(id))).then((bios) => {
const result = {
bios,
totalAuthors: authors.length,
totalBooks: books.length,
};
});
});
```
Это может быть лучшим решением для then. Код работает быстрее, нет многоуровневой вложенности.
```
async function getBios() {
const [authors, books] = await Promise.all([getAuthors(), getBooks()]);
const prolificAuthorIds = filterProlificAuthors(authors, books);
const bios = await Promise.all(prolificAuthorIds.map((id) => getBio(id)));
const result = {
bios,
totalAuthors: authors.length,
totalBooks: books.length,
};
}
```
### Вывод
Использование методов chained then во многих случаях может потребовать утомительных изменений, особенно когда хочется убедиться, что определенные переменные находятся в области видимости. Даже для простого сценария, подобного тому, который указан выше, не было очевидного лучшего решения. Так, каждое из пяти решений, где использовалось then, имело разные компромиссы для удобочитаемости. Напротив, async / await предоставил самое удобочитаемое решение, которое практически нет необходимости модифицировать.
В реальных приложениях требования нашего асинхронного кода часто будут более сложными, чем сценарий, представленный здесь. В то время как async / await предоставляет нам простую для понимания основу для написания более сложной логики, добавление множества методов then может легко подтолкнуть нас дальше по пути к callback hell — со множеством скобок и уровней отступов. В итоге становится неясно, где заканчивается один блок и начинается следующий.
**Тимофей Тиунов, автор курса “**[**JavaScript**](https://skillbox.ru/course/javascript/)**” в Skillbox:** *“Утверждать, что один инструмент лучше другого — не совсем корректно, что показано на примерах выше. Promise и async/await существуют вместе и часто дополняют друг друга. Бывают ситуации, когда удобно одно, а когда другое. Вы вольны смешивать оба подхода для максимальной читаемости и эффективности кода. Ниже еще один пример в контексте краткости кода:*
```
// на await
const res = await fetch('...');
const json = await res.json();
// на promise + await
const json = await fetch('...').then(res => res.json());
```
*Второй вариант гибридный и просто компактнее.”* | https://habr.com/ru/post/651781/ | null | ru | null |
# Инкрементальные бэкапы PostgreSQL с pgBackRest. Часть 2. Шифрование, загрузка в S3, восстановление на новый сервер, PITR
Данная статья — продолжение статьи [«Инкрементальные бэкапы postgresql с pgbackrest — курс молодого бойца от разработчика».](https://habr.com/ru/post/476206/)
В первой части мы научились делать инкрементальные бэкапы, загружать их на удаленный сервер (репозиторий с бэкапами) и откатываться на последний бэкап.
> В этой статье мы научимся шифровать бэкапы, загружать их в S3-совместимое хранилище (вместо второго сервера-репозитория), восстанавливаться на чистый кластер и, наконец, восстанавливаться на определенный момент времени (point in time recovery, PITR).
**Момент**
Автор не претендует на роль DBA, но иногда любит настроить и посмотреть все сам.
Подготовка
----------
Для воспроизведения данного мануала нам понадобится:
1. Cервер с базой данных (на него мы установим pgbackrest);
2. S3 хранилище (вы можете использовать Amazon или любое S3 совместимое, я буду использовать Amazon S3);
3. Третий сервер. По желанию. На нем мы потренируемся разворачивать postgresql и pgbackrest с нуля, разворачивая существующий бекап из S3 хранилища (сервер сгорел, переезд и т.п.);
Подразумевается, что postgresql у вас уже установлен, а следовательно пользователь postgres тоже имеется.
Процесс установки pgbackrest я описал в предыдущей статье, но на всякий случай продублирую еще раз (напоминаю: перед установкой создайте себе sudo пользователя — я буду использовать sudo пользователя с юзернеймом pgbackrest).
Чтобы у вас было меньше проблем при воспроизведении инструкции — *курсивом я прописываю где, каким пользователем и с какими правами* я исполнял команду во время написания и проверки статьи.
Пойдем мы по такому пути:
Настроим postgresql и pgbackrest
Настроим шифрование бэкапов (две строчки)
Научимся делать бэкап и отправлять в S3 хранилище (пять строчек)
Сделаем бэкап
Представим, что сломали кластер, развернемся на новом сервере, подключим существующий S3 репозиторий и накатим бэкап
Посмотрим на PITR (Point In Time Recovery): восстановимся на определенный момент времени (допустим, pgbackrest забэкапил уже drop table, а нам нужно откатиться на 4 часа назад, когда табличка еще существовала)
Поехали!
Установка pgBackRest
--------------------
*sudo пользователь или root:*
1. Скачиваем архив с pgbackrest и переносим его содержимое в папку /build:
```
sudo mkdir /build
sudo wget -q -O - \
https://github.com/pgbackrest/pgbackrest/archive/release/2.18.tar.gz | \
sudo tar zx -C /build
```
2. Устанавливаем необходимые для сборки зависимости:
```
sudo apt-get update
sudo apt-get install build-essential libssl-dev libxml2-dev libperl-dev zlib1g-dev \
libpq-dev
```
3. Собираем pgbackrest:
```
cd /build/pgbackrest-release-2.18/src && sudo ./configure
sudo make -s -C /build/pgbackrest-release-2.18/src
```
4. Копируем исполняемый файл в директорию /usr/bin:
```
sudo cp /build/pgbackrest-release-2.18/src/pgbackrest /usr/bin
sudo chmod 755 /usr/bin/pgbackrest
```
5. pgBackRest требует наличие perl. Устанавливаем:
```
sudo apt-get install perl
```
6. Создаем директории для логов, даем им определенные права:
```
sudo mkdir -p -m 770 /var/log/pgbackrest
sudo chown postgres:postgres /var/log/pgbackrest
sudo mkdir -p /etc/pgbackrest
sudo mkdir -p /etc/pgbackrest/conf.d
sudo touch /etc/pgbackrest/pgbackrest.conf
sudo chmod 640 /etc/pgbackrest/pgbackrest.conf
sudo chown postgres:postgres /etc/pgbackrest/pgbackrest.conf
```
7. Проверяем:
```
pgbackrest version
```
Настройка postgresql и pgBackRest
---------------------------------
*sudo пользователь или root:*
1. Внесем необходимые настройки в postgresql.conf (он находится в папке /etc/postgresql/11/main) для работы pgBackRest:
```
archive_command = 'pgbackrest --stanza=main archive-push %p' # Где main - название кластера. При установке postgres автоматически создает кластер main.
archive_mode = on
max_wal_senders = 3
wal_level = replica
```
2. Внесем необходимые настройки в файл конфигурации pgbackrest (/etc/pgbackrest/pgbackrest.conf):
```
[main]
pg1-path=/var/lib/postgresql/11/main
[global]
log-level-file=detail
repo1-cipher-pass=tr5+BXdfdoxeyUqfo6AzLTrW+c+Jfd/1QbQj2CDMMBwtB0YGH3EJajry4+Eeen6D
repo1-cipher-type=aes-256-cbc
repo1-path=/var/lib/pgbackrest
repo1-retention-full=2 # Параметр, указывающий сколько хранить полных бэкапов. Т.е. если у вас есть два полных бэкапа и вы создаете третий, то самый старый бэкап будет удален. Можно произносить как "хранить не более двух полных бэкапов" - по аналогии с ротациями логов.
repo1-type=s3
repo1-s3-bucket=pgbackrest-part2-tutorial
repo1-s3-endpoint=s3.us-east-1.amazonaws.com
repo1-s3-region=us-east-1
repo1-s3-key=9wdS3G8U5wz7kNsFWVGck7DDZ7DtVDtbM
repo1-s3-key-secret=A9zRmW16zXKt2vVA8mmNsFWy2mUAPYHa
start-fast=y
[global:archive-push]
compress-level=3
```
Как вы поняли, тут мы сразу настроили шифрование и настроили поддержку S3 хранилища.
P.S. Комментариев в конфиге быть не должно.
P.S. Чтобы сгенерировать надежный ключ шифрования можно воспользоваться командой:
```
openssl rand -base64 48
```
Создание хранилища
------------------
*sudo пользователь или root:*
```
sudo mkdir -m 770 /var/lib/pgbackrest
sudo chown -R postgres /var/lib/pgbackrest/
sudo -u postgres pgbackrest --stanza=main stanza-create
```
Если все получилось, то в S3-бакете вы увидите файлы, которые сгенерировал pgbackrest.
Делаем бэкап:
-------------
*sudo пользователь или root:*
```
sudo -u postgres pgbackrest --log-level-console=info --stanza=main backup
```
pgBackRest создаст первый полный бэкап. При желании вы можете запустить команду бэкапа повторно и убедиться, что система создаст инкрементальный бэкап.
Если вы хотите повторно сделать полный бэкап, то укажите дополнительный флаг:
```
sudo -u postgres pgbackrest --log-level-console=info --stanza=main --type=full backup
```
Посмотреть список бэкапов можно с помощью команды:
```
sudo -u postgres pgbackrest --stanza=main info
```
Восстанавливаем бэкап:
----------------------
*sudo пользователь или root:*
1. Останавливаем работающий кластер:
```
sudo pg_ctlcluster 11 main stop
```
2. Восстанавливаемся из бэкапа:
```
sudo -u postgres pgbackrest --stanza=main --log-level-console=info --delta --recovery-option=recovery_target=immediate restore
```
Чтобы восстановить базу в состояние последнего ПОЛНОГО бэкапа используйте команду без указания recovery\_target:
```
sudo -u postgres pgbackrest --stanza=main --log-level-console=info --delta restore
```
Важно! После восстановления может оказаться так, что база зависнет в режиме восстановления (будут ошибки в духе ERROR: cannot execute DROP DATABASE in a read-only transaction). Решается следующим образом (нужно будет малость подождать после исполнения команды):
```
sudo -u postgres psql -c "select pg_wal_replay_resume()"
```
UPD: Как я понял, данная ошибка возникает из-за того, что после восстановления с указанием recovery\_target=immediate pgbackrest [ставит БД на паузу](https://pgbackrest.org/1/command.html#command-restore/category-command/target-action). Чтобы этого не было, нужно дополнительно указать некоторые флаги (их значение можете прочитать [тут](https://pgbackrest.org/1/command.html#command-restore/category-command/target-action) и [тут](https://pgbackrest.org/1/command.html#command-restore/category-command/type)):
```
sudo -u postgres pgbackrest --stanza=main --log-level-console=info --delta --recovery-option=recovery_target=immediate --target-action=promote --type=immediate restore
```
На самом деле, есть возможность восстановить конкретный бэкап по его имени. Здесь я лишь [укажу ссылку на описание данной фичи в документации](https://pgbackrest.org/command.html#command-restore/category-command/option-set). Разработчики советуют использовать данный параметр с осторожностью и объясняют почему. От себя могу добавить, что я его использовал. Главное убедитесь, что после восстановления база вышла из recovery mode (select pg\_is\_in\_recovery() должен показать «f») и на всякий случай сделайте полный бэкап после восстановления.
3. Запускаем кластер:
```
sudo pg_ctlcluster 11 main start
```
После восстановления бэкапа выполним повторный бэкап:
```
sudo -u postgres pgbackrest --log-level-console=info --stanza=main backup
```
Восстанавливаем бэкап на чистый кластер:
----------------------------------------
Давайте представим, что произошло что-то ужасное — сервер сгорел (упал, затопило, потеряли доступ). Нужно восстановить все на новый, чистый сервер. На новом сервере мы уже завели sudo пользователя, установили pgbackrest, установили postgresql и у нас появился чистый и свежий main кластер.
Все, что нам нужно сделать — настроить конфиг postgresql и pgBackRest аналогично тем, что были на прежнем сервере, перезапустить postgresql и выполнить порядок команд, аналогичный восстановлению:
*sudo пользователь или root:*
1. Останавливаем работающий кластер:
```
sudo pg_ctlcluster 11 main stop
```
2. Восстанавливаемся из бэкапа:
```
sudo -u postgres pgbackrest --stanza=main --log-level-console=info --delta --recovery-option=recovery_target=immediate --target-action=promote --type=immediate restore
```
P.S. Нюансы и тонкости данной команды я описал выше.
3. Запускаем кластер:
```
sudo pg_ctlcluster 11 main start
```
После восстановления бэкапа нам необходимо выполнить повторный бэкап:
```
sudo -u postgres pgbackrest --log-level-console=info --stanza=main backup
```
Вот, собственно, и все. Пожар потушен.
Point In Time Recovery (PITR)
-----------------------------
Давайте представим такую ситуацию, что в 16:00 был создан бэкап, а в 18:05 мы случайно стерли важную табличку в которую за 2 часа успело попасть очень много важных данных, которые не хотелось бы потерять. PgBackRest за счет PostgreSQL предоставляет нам такую возможность: мы можем откатиться на конкретный момент времени, при условии, что у нас достаточное кол-во информации для восстановления.
Работает это так:
1. Мы говорим, что хотим откатиться на момент времени 18:04;
2. pgBackRest ищет последний актуальный бэкап (16:00);
3. Восстанавливает его, но накатывает не все, а лишь то, что мы успели сделать до 18.04;
P.S. построен этот механизм на WAL логах. Почитать можно [здесь](https://pgbackrest.org/user-guide.html#concept/wal).
Выполнить восстановление на конкретный момент времени (предварительно остановив кластер) можно данной командой:
```
sudo -u postgres pgbackrest --stanza=main --log-level-console=info --delta --type=time "--target=2020-09-06 18:27:24.561458+02" --target-action=promote restore
```
Важное замечание — PostgreSQL может воспроизводить WAL логи только вперед, но не назад. Что это значит на практике?
Допустим, в 16:00 был создан бэкап. В 18:05 мы случайно удалили таблицу, а в 18:10 снова был создан бэкап с уже удаленной таблицей. Когда вы попытаетесь сделать PITR — pgBackRest возьмет бэкап, который был создан в 16:00 и накатит сверху все то, что было до 18:05, а не возьмет бэкап, который был создал в 18:10 и будет откатывать все назад. Это важно понимать. Более подробно данный механизм описан [здесь](https://pgbackrest.org/user-guide.html#pitr).
Предположим, вы сделали бэкап, в который уже попала информации о удалении таблицы. С помощью флага --set скажем, какой бэкап нужно использовать за базу (тот, в котором таблица еще была). pgBackRest возьмет данный бэкап и накатит все то, что было до удаления таблицы.
```
sudo -u postgres pgbackrest --stanza=main --log-level-console=info --delta --type=time --set=20200905-183838F_20200906-182612I "--target=2020-09-06 18:27:24.561458+02" --target-action=promote restore
```
P.S. Команду для получения списка бэкапов я показал выше.
Запустим кластер. После запуска изучим файл /var/log/postgresql/postgresql-11-main.log. В нем нас интересуют следующие строки, показывающие, что восстановление на указанный момент времени произошло успешно:
```
starting point-in-time recovery to 2020-09-07 11:26:52.493127+02
...
recovery stopping before commit of transaction 576, time 2020-09-07 11:27:14.584496+02
...
last completed transaction was at log time 2020-09-07 11:24:09.583761+02
```
Вот и все. Настоятельно советую поэкспериментировать с данным инструментом перед применением его в бою. | https://habr.com/ru/post/518232/ | null | ru | null |
# Windows 7 Federated Search
Windows Vista включала в себе улучшенный поиск, который позволял пользователям искать локальные файлы, письма и другие необходимые вещи. С выходом Windows Search 4.0, эффективность поиска возрасла, предоставляя дополнительные поисковые настройки.
В Windows 7 помоимо локального поиска, представлен новый вид поисковой системы [**Federated Search**](http://en.wikipedia.org/wiki/Federated_search), при помощи которого ваши поисковые запросы могут выйти за пределы вашего локального компьютера. Вы можете задавать поиск по удаленным репозиториям прямо из оболочки системы. Этот поиск основан на технологиях [**OpenSearch**](http://en.wikipedia.org/wiki/OpenSearch) и RSS. Так как этот продукт основан на открытых приложениях, он становится очень доступным и легким для понимания, вы сможете сделать собственные “search connectors” для поиска по сайтам, которые вам нужны.
Federated Search выглядит многообещающим, так как многие сайты уже начали интегрировать поддержку OpenSearch.
Но эта технология для Microsoft не является новой. OpenSearch уже был интегрирован в Internet Explorer 7 и SharePoint Search.
**“Search connectors”** – это файлы формата OSDX, который пользоватся RSS, Federated Searches прямо из оболочки Windows 7. Позволяя использовать Explorer для поиска удаленных файлов, баз данных, так как если бы они находились у вас на локальном компьютере.
Типичный OSDX файл выглядит таким образом:
`xml version="1.0" encoding="UTF-8"?
Amazon
Amazon
/>`
**“Search connectors”** уже поделили на две категории **“basic”** и **“advanced”**.
**Basic search connectors** – это те, которые выводят только базовый результат с веб страницы, без всях дополнительных навороток, таких как: иконки, видео, документы, картинки и другие файлы.
**Advanced search connectors** – в отличии от basic search connectors, advanced выводят богатую поисковую картину. Результат поиска будет содержать картинки, видео, другие документы, с которыми можно будет работать, как если бы они находились на вашем компьютере.
Стоит всего лишь два раза кликнуть на файл OSDX, как он загрузится в оболочку, и вы готовы начать поиск по удаленной репозитории.
Так как многие сайты пока еще не поддерживают OpenSearch, на выручку приходит Microsoft Live Search, с помощью которого вы сможете создать basic search connector.
Инструкции по созданию собственного поискового провайдера:
**1. Скопируйте этот код в Notepad**
`xml version="1.0" encoding="UTF-8"?
Habrahabr
Habrahabr
/>
/>`
**2. Замените жирный текст в коде** на название, ссылку, описание того сайта на котором вы ходите искать.
**3. Сохраните файл.** Для этого зайдите в диалог Save as => замените Save as Type, с .txt на All files (важно!). Затем в имени файла введите – имя-файла.osdx. Теперь Windows 7 сможет распознать этот файл, как файл поискового провайдера, search connector.
**4. Два раза кликните по файлу** и ваша система готова начать поиск по указанному сайту который вы указали с помощью свойства LiveSearch, webite RSS Search.
**Списки search connectors на различные сайты:**
**Advanced:**
[Youtube](http://www.sevenforums.com/sfp/youtube.osdx)
[Flickr Search](http://www.sevenforums.com/attachments/tutorials/5619d1236618069-windows-7-search-federation-providers-flickr.osdx)
[ISOHunt.com Search](http://www.sevenforums.com/attachments/tutorials/3804d1233149355-windows-7-search-federation-providers-isohunt.osdx)
[MiniNova Search](http://www.sevenforums.com/attachment.php?attachmentid=4010&stc=1&d=1233549703)
[Deviant Art](http://www.sevenforums.com/attachments/tutorials/5615d1236617616-windows-7-search-federation-providers-deviant-art.osdx)
[Yahoo Image Search](http://www.sevenforums.com/attachments/tutorials/5616d1236617616-windows-7-search-federation-providers-yahoo-image-search.osdx)
[Yahoo Video](http://www.sevenforums.com/attachments/tutorials/5617d1236617616-windows-7-search-federation-providers-yahoo-video.osdx)
[TechNet-Edge](http://www.sevenforums.com/attachments/tutorials/5618d1236617616-windows-7-search-federation-providers-technet-edge.osdx)
[Msdn Channel 9](http://channel9.msdn.com/winsearchxml.ashx)
**Basic:**
[Yahoo](http://www.sevenforums.com/sfp/yahoo.osdx)
[MSNSearch](http://www.sevenforums.com/sfp/msnsearch.osdx)
[eBay Search](http://www.sevenforums.com/sfp/ebay.osdx)
[Amazon Search](http://www.sevenforums.com/sfp/amazon.osdx)
[Digg](http://www.sevenforums.com/attachments/tutorials/4009d1233549703-windows-7-search-federation-providers-digg.osdx)
[Technet](http://www.sevenforums.com/attachments/tutorials/4011d1233549703-windows-7-search-federation-providers-technet.osdx)
[Techrepublic](http://www.sevenforums.com/attachments/tutorials/4012d1233549703-windows-7-search-federation-providers-techrepublic.osdx)
[Wired](http://www.sevenforums.com/attachments/tutorials/4013d1233549703-windows-7-search-federation-providers-wired.osdx)
Twitter *(который пропал)*
GOOGLE: обещал что технология OpenSearch на основе RSS, будет доступна не раньше чем 2010-2011 годах (одчень жаль). А покамись предлагаю basic поиски
[Google Blogs](http://www.sevenforums.com/sfp/googleblogs.osdx)
[Google News](http://www.sevenforums.com/sfp/googlenews.osdx)
Также, уже появилось руководство для разрабов:[Windows 7 Federated Search Provider Implementer's Guide](http://www.microsoft.com/downloads/details.aspx?FamilyID=C709A596-A9E9-49E7-BCD4-319664929317&displaylang=en) | https://habr.com/ru/post/58630/ | null | ru | null |
# Telegram боты: в помощь редактору
— Синоним к слову «своенравный»? — раздался голос жены из соседней комнаты.
Треск клавиатуры стих и кот, воспользовавшись паузой, решительно заявил о своем жалком полуголодном существовании, видимо надеясь, что вот сейчас уж точно хозяева наконец-то оторвут свой зад от кресла и покормят несчастного.
— Дык посмотри у этого… как его…
— Да-да, я тоже забыла. Ну так что, скажешь мне синоним?
Но увы, я не ходячая энциклопедия, и даже не ее сидячий вариант, поэтому я не нашел ничего лучше, чем отправить жену гуглить словарь.
— Так это долго! Я думала, ты быстрее вспомнишь…
Кот, буридановым ослом метавшийся между мной и женой, в конце концов выбрал меня в качестве бОльшего добра (интересно — по весу или по каким-то другим параметрам?) и мне не оставалось ничего делать, как пойти на кухню покормить несчастную животинку. Попутно размышляя о том, как довести до жены тот факт, что “закладки" в браузере предназначены не для повального сохранения всех ее френдов из Вкантактика, а для запоминания действительно нужных ссылок. Все предыдущие попытки научить ее пользоваться закладками заканчивались сохранением если не френдов, то выложенную френдами музыку; но те ссылки, которые сохранил для нее я, оказывались окончательно погребены под этими завалами.
Но если она научилась пользоваться Вкантактиком и Телеграмом, значит… значит она уже умеет пользоваться Телеграмом и Вкантактиком! Эврика!
Кто-то говорил, что боты для Telegram это просто? А вот cейчас возьмем и попробуем…
Как регистрировать пользовательскую часть нового бота, вы скорее всего уже знаете. Если нет — просто добавьте [@BotFather](https://telegram.me/BotFather) в Telegram и начните с ним разговор.
> *@BotFather — официальный интерфейс управления ботами. Кроме него по запросам о создании ботов прогугливаются Manybot, YourBot, и еще несколько. Судя по описанию, это какие-то прокладки, т.к. при работе с ними все равно придется обращаться к @BotFather. Я не разбирался с ними и буду благодарен за разъяснение пользы от них.*
Первая проблема, с которой пришлось столкнуться при создании синоним-бота — поиск словаря синонимов.
Большинство нагугленных словарей пестрят грозными надписями и подписями с перечислением ужасных кар, которые непременно свалятся на голову несчастного, осмелившегося использовать “не по назначению” творение авторов. У которых, судя по количеству смачно расписанных угроз, имеется “копирайт на русский язык” целиком, полностью и безо всяких исключений. Причем “назначение” на таких ресурсах порой не определено нигде и никак, а объемы их словарей как правило составляют жалкие 5000…40 000 слов.
Часть словарей представляют собой алфавитные списки: первая страница со словами на букву “а”, вторая на “б” и так далее. Здесь не то что парсинг, даже загрузка адовой портянки превращается в отдельно стоящую проблему.
> *И, разумеется, ни о каком API нет даже и речи.*
В конце концов мне удалось найти [адекватный словарь](http://www.trishin.ru/left/dictionary) объемом, как сказано в описании “591 тыс. слов и фразеологизмов и 2166 тыс. синонимических связей”, который к тому же свободно распространяется. Единственным его недостатком оказалось полное отсуствие API, что компенсировалось возможностью легально скачать сам словарь (правда в ужасном формате) и стабильно работающей онлайн-версией.
Мне показалось еще, что в этом конкретном словаре слишком много устаревших, вышедших из оборота слов и наоборот слишком мало современных. Но жена отметила, что о новомодных “селфи”, “кавер” и “транспарентность” через пять лет все забудут, зато “непременно”, “чуточку” и “капитулировать” будут жить в языке вечно, несмотря на проделки лингвистов от властей.
> *В который раз убеждаюсь, что у хорошего продукта как правило ужасная упаковка, а за красивыми “ле-ендингами” с большими кнопками и воздушными полями прячется обыкновенное фуфло.*
На этом месте уже сытый кот оторвался от вылизывания своих теплых аналоговых идентификаторов и утвердительно мявкнул как бы подтверждая, что он не собирается изменять классическому “мяу”, несмотря на то, что кто-то может заявить, что это “некруто” или “отстой”.
Вторая проблема — скорее всего подходящие вам имена ботов будут заняты. Я перепробовал целую кучу благозвучных коротких имен и все они оказались занятыми и — тадааам — ожидаемо мертвыми. В результате пришлось регистировать длинное и трудное для запоминания имя [@synonim\_bot](https://telegram.me/synonim_bot): по какой-то причине сквоттеры до него не добрались и оно оказалось свободным.
Если вкратце, вся схема работает так:
**0.** Вы устанавливаете вебхук — сообщаете API Telegram адрес скрипта на своем сервере (HTTPS!), к которому он будет обращаться, когда юзер что-нибудь напишет вашему боту.
И далее реализуете свою логику. На схеме — урезанный вариант логики [бота Синоним](https://telegram.me/synonim_bot).
> *Я намеренно не привожу ни строчки кода, дабы исключить холивары и взаимополивание. Пишите на том, что знаете — боту все равно.*
Теперь текстом:
**1.** Юзер пишет вашему боту что-нибудь — команду или слово.
**2.** API Telegram дергает ваш скрипт (он уже знает его урл из п.0) и передает ему примерно следующее:
```
{
"update_id":12345678,
"message":
{
"message_id":1234,
"from":
{
"id":0123456789,
"first_name":"Vasya",
"username":"vapupkin"
},
"chat":
{
"id":1234567890,
"first_name":"Vasya",
"username":"vapupkin",
"type":"private"
},
"date": 1451606400,
"text":"preved"
}
}
```
**3.** Далее ваш скрипт должен разобраться что ему прислали и выдать ответ:
`https://api.telegram.org/bot123456789:boLshoiogRomnIycOLlaideR/sendMessage?chat_id=1234567890&text=Taki%20Preved`
> *Наверное правильнее будет переписать это в POST дабы иметь запас по размеру отправляемого текста, но в моем случае вполне хватает и этого: все-таки мессенджеры не предназначены для лонгридов.*
**4.** API Telegram пришлет в ответ нечто подобное:
```
{
"ok":true,
"result":
{
"message_id”:1234,
"from":
{
"id”:9876543210,
"first_name":"Бот",
"username":"my_bot"
},
"chat":
{
"id": 0123456789,
"first_name":"Vasya",
"username":"vapupkin",
"type":"private"
},
"date": 1451606500,
"text":"Taki Preved"
}
}
```
Я понял так, что с этим ответом я могу поступать как заблагорассудится (если неверно — поправьте). Теоретически на его основе можно собирать статистику, но я собираю ее на более раннем этапе: мне так удобнее.
Пара слов об отличиях присылаемых юзером команд от, сорри за каламбур, слов.
Вы можете заготовить стандартные ответы бота на стандартные вопросы юзера, оформив это хозяйство в виде команд с помощью @BotFather — они будут видны юзеру если тот начнет строку со слэша. В скрипте бота будет достаточно отловить эти команды (API Telegram их так и передает, со слэшем спереди), выдать ответ и тут же прекратить дальнейшее выполнение скрипта.
Процедура общения бота со словарем не представляет художественной ценности и я с вашего позволения ее опущу. Единственно, что потребовалось сделать — отловить отсутствие результата, когда словарь не находил синонима на введенное слово.
…а также случай, когда юзер вводил целую фразу — ведь словарь этого не умеет:
Третья проблема поджидала меня, когда ботом начали пользоваться реальные люди:
Да уж… Современные технологии порой позволяют нам творить чудеса, но начисто лишают нас познаний о фундаментальных вещах. Практически половина запрашиваемых слов содержали ошибки и опечатки и с этим нужно было что-то делать.
С робкой надеждой я сразу же кинулся к любимой Dadata, но обломался: она прекрасно выполняет свои задачи и не замахивается на весь языковой корпус. Гугление, как ни странно, не принесло никакого адекватного результата и я по-быстрому прикрутил Яндекс.Спеллер как временный вариант. Теоретически, пока он не стал платным и не потребовал нотариально заверенной копии паспорта, им тоже можно как-то пользоваться.
> *Буду благодарен за подсказку: требуется бесплатный сервис проверки орфографии в русском языке с API.*
Здесь обнаружилась четвертая проблема: если слово набрано без ошибок, Яндекс.Спеллер не выдает ничегошеньки. Просто молчит как партизан, что немного затрудняет ведение статистики.
Было бы неплохо как-то обозначить исправление пользовательского ввода, не крича об этом во всю ивановскую. Из-за скудного html-инструментария бота я выбрал вот такой вариант оповещения (возможно, в будущем подкорректирую):
Посадил жену тестировать, попросил раздать по сети коллегам. Если бот окажется кому-то нужным, буду его развивать.
**P.S.:** При написании бота кот Юникс (реальный персонаж) не голодал. А также ни до, ни после.
**Пруф**
---
Ссылки:
Бот Синоним: [telegram.me/synonim\_bot](https://telegram.me/synonim_bot)
Словарь синонимов Тришина: [www.trishin.ru/left/dictionary](http://www.trishin.ru/left/dictionary)
API Telegram: [tlgrm.ru/docs/bots/api#authorizing-your-bot](https://tlgrm.ru/docs/bots/api#authorizing-your-bot) | https://habr.com/ru/post/312886/ | null | ru | null |
# Анализ тональности текста с использованием фреймворка Lightautoml
Сентиментный анализ (анализ тональности) – это область компьютерной лингвистики, занимающаяся изучением эмоций в текстовых документах, в основе которой лежит машинное обучение.
В этой статье я покажу, как мы использовали для этих целей внутреннюю разработку компании – фреймворк LightAutoML, в котором имеется всё для решения поставленной задачи – предобученные готовые векторные представления слов FastText и готовые текстовые пресеты, в которых необходимо только указать гиперпараметры.
Задача
------
При возникновении трудностей в работе с автоматизированными системами внутренние клиенты оставляют обращения нейтрального или же негативного характера (положительный не учитывается по причине того, что таких обращений очень мало).
Анализ тональности текста позволит понять, что в обращении пытается донести пользователь – что-то нейтральное или негативное. Нас интересуют случаи, где напрямую описываются проблемы в автоматизированной системе и на что требуется внимание и проведение дальнейшего анализа.
Первым этапом мы загружаем и обезличиваем данные. Теперь можно приступать к ручной разметке обращений и формированию датасета, на основе которого модель будет обучаться и тестироваться. В состав этого датасета вошли 1500 вручную размеченных экземпляров. В дальнейшем мы добавили в выборку еще 2300 сэмплов из числа правильно размеченных моделью обращений.
Предобработка данных
--------------------
Предобработаем данные с помощью регулярных выражений, убрав лишние символы и стоп-слова. Кроме того, приведем слова к нормальной форме с помощью библиотеки pymorphy2.
```
data['text'] = data['text'].replace("[0-9!#()$\,\'\-\.*+/:;<=>?@[\]^_`{|}\"]+", ' ', regex=True)
data['text'] = data['text'].replace(r'\s+', ' ', regex=True)
data['text'] = data['text'].apply(lambda x: ' '.join([word for word in x.split() if word not in (stop_words)]))
data['text'] = data['text'].apply(lambda x: ' '.join([morph.parse(word)[0]. normal_form for word in x.split()]))
```
Описание модели
---------------
Далее мы формируем на основе размеченного датасета обучающую (65% от его размера) и тестовую (35% соответственно) выборки и задаем гиперпараметры для модели. Мы будем использовать текстовый пресет, который был реализован специально для выполнения NLP задач.
```
automl = TabularNLPAutoML(task=Task('binary', metric = f1_binary),
timeout=2000,
memory_limit=16,
cpu_limit=4,
text_params={'lang': 'ru'},
general_params={'nested_cv': False,
'use_algos': [['linear_l2', 'lgb']]},
reader_params={'cv': 3, 'random_state': 42}
```
* *task=Task(‘binary’, metric = f1\_binary)* – в качестве задачи мы выбираем бинарную классификацию и метрики функцию, которая вычисляет F1-score
* *timeout=2000* – ставим ограничение работы модели по времени на 2000 секунд
* *memory\_limit=16* – обозначаем объем выделяемой RAM
* *cpu\_limit=4* – обозначаем число выделяемых ядер
* *text\_params={‘lang’: ‘ru’}* – в качестве текстовых параметров выбираем русский язык
* *general\_params={‘nested\_cv’: False* – обозначаем, что нам нет необходимости в выполнении оптимизации гиперпараметров
* *‘use\_algos’: [[‘linear\_l2’, ‘lgb’]]}* – в качестве используемых алгоритмов мы обозначаем ридж-регрессию и ансамбль LightGBM
Обучение модели:
----------------
Код обучения модели выглядит следующим образом:
```
roles = {'target': 'sentiment', 'text': ['review']}
pred = automl.fit_predict(train_data, roles=roles, verbose=3)
print('oof_pred:\n{}\nShape = {}'.format(pred, pred.shape))
class_result = classification_report(y_true=train_data['sentiment'].values, y_pred=np.where(pred.data[:, 0] >= 0.5, 1, 0), target_names=['Neutral', 'Negative'])
print(class_result)
```
* *roles = {‘target’: ‘sentiment’, ‘text’: [‘review’]}* – описываем ключевое и текстовое поля
* *pred = automl.fit\_predict(train\_data, roles=roles, verbose=3)*– обучаем модель на основе обучающей выборки, передаем затрагиваемые поля
На выходе мы имеем одномерный массив, который показывает вероятность отнесения обращения к негативному классу
При обучении модели значение метрики F1-score достигло 0.894, соответственно можно сделать вывод о том, что модель хорошо справляется с задачей определения нейтральных и негативных обращений.
Также одним из способов оценить работу модели в целом можно по кривой ROC-AUC, которая описывает площадь под кривой (Area Under Curve – Receiver Operating Characteristic).
Объяснение работы модели
------------------------
В качестве подтверждения вышесказанного можно привести работу встроенного в LAMA модуля – LIME, который раскрывает работу модели окрашивая слова в тот или иной цвет, в зависимости от их эмоционального окраса.Реализация данной возможно представлена на коде ниже:
```
lime = LimeTextExplainer(automl, feature_selection='lasso', force_order=False)
exp = lime.explain_instance(data.iloc[1013], labels=(0, 1), perturb_column='review')
```
* *lime = LimeTextExplainer(automl, feature\_selection=’lasso’, force\_order = False)*– вызываем функцию LIME и в качестве параметров передаем нашу обученную модель, в качестве алгоритма отбора фич – LASSO (least absolute shrinkage and selection operator – наименьшее абсолютное сжатие и оператор выбора)
* *exp = lime.explain\_instance (data.iloc[1013], labels=(0, 1), perturb\_ column= ‘review’)* – далее в качестве параметров передаем случайную строку нашего датасета, обозначаем подписи классов и затрагиваемый столбец
Применяем его к обращению, которое не содержится в размеченных данных и получим следующий результат:
Рассматривая данный пример, мы видим, что модель наиболее явно выделяет относящиеся к негативу слова – вход и ошибка, которые сигнализируют о том, что в данной автоматизированной системе имеются какие-то проблемы со входом.Теперь рассмотрим пример, где встречаются слова обоих классов:
Мы видим, что слова спасибо и пожалуйста, правильно распознаны в нейтральный класс, слова маршрут сигнализируют о проблемах с подключением, которое занимает длительное время, что правильно относится к негативному классу.
На что ещё способен фреймворк
-----------------------------
Прежде всего стоит выделить мультиклассовую классификацию, синтаксис реализации которой идентичен с бинарной, но в качестве задачи мы выбираем *multiclass*:
```
automl = TabularNLPAutoML(task=Task('multiclass', metric = f1_score)
. . .
```
Доразметив нашу выборку третьим (положительным) классом и обучив на ней модель, мы получим следующий результат:
Где первый столбец означает вероятность негативного окраса обращения, второй – нейтрального, третий – позитивного.
Также фреймворк может решать задачи регрессионного анализа, целью которого является определение зависимости между переменными и оценкой функции регрессии.
```
automl = TabularAutoML(task = Task ('reg', loss = 'rmsle', metric = rmsle_metric, greater_is_better = False)
. . .
```
Работа с текстом
----------------
В LightAutoML имеется большое количество вариантов разработки той или иной модели, работающей с текстом. Библиотека предоставляет не только получение стандартных признаков на основе TF-IDF, но и на основе эмбеддингов:1) На основе встроенного FastText, который можно тренировать на том или ином корпусе2) Предобученных моделей Gensim3) Любой другой объект, который имеет вид словаря, где на вход подается слово, а на выходе его эмбеддинги
Среди используемых стратегий извлечения представлений текстов из эмбеддингов слов, можно выделить:
1) Weighted Average Transformer (WAT) – взвешивается каждое слово с некоторым весом
```
TabularNLPAutoML(task = task,
autonlp_params = {'model_name': 'wat',
'transformer_params': {'weight_type': 'idf',
'use_svd': True}}
)
```
2) Bag of Random Embedding Projections (BOREP) – строится линейная модель со случайными весами
```
TabularNLPAutoML(task = task,
autonlp_params = {'model_name': 'wat',
'transformer_params': {'model_params':
{'proj_size': 300, 'pooling': 'mean',
'max_length': 200, 'init': 'orthogonal',
'pos_encoding': False},
'dataset_params':
{'max_length': 200}}}
)
```
3) Random LSTM – LSTM со случайными весами
```
TabularNLPAutoML(task = task,
autonlp_params = {'model_name': 'random_lstm',
'transformer_params': {'model_params':
{'embed_size': 300, 'hidden_size': 256,
'pooling': 'mean', 'num_layers': 1},
'dataset_params':
{'max_length': 200, 'embed_size': 300}}}
)
```
4) Bert Pooling – получение эмбеддинга с последнего выхода модели Transformer
```
TabularNLPAutoML(task = task,
autonlp_params = {'model_name': 'pooled_bert',
'transformer_params': {'model_params':
{'pooling': 'mean'},
'dataset_params':
{'max_length': 256}}}
)
```
За препроцессинг текста отвечает класс токенайзера, по умолчанию применяется только для TF-IDF.
Что выполняется для русского языка:
1. Производится замена ё на е
2. Удаляются знаки препинания, отдельно стоящие цифры
3. Токенизация происходит по пробелу
4. Текст приводится к нижнему регистру
5. Удаляются слова, состоящие из одного символа
6. Опционально удаляются стоп-слова
Подводя итоги стоит сказать, что LightAutoML благодаря встроенному инструментарию способен показывать достаточно хорошие результаты в задачах бинарной или мультиклассовой классификации и регрессии.
Конкретно в нашем случае нам удалось создать модель сентиментного анализа, которая с 89% точностью определяет эмоциональный окрас обращения и слова, которые оказывают на это наибольшее влияние. | https://habr.com/ru/post/646129/ | null | ru | null |
# Интерфейсы контроллеров HPE Aruba и Cisco
Оборудование HPE Aruba не очень распространено в России, однако на американском рынке вендор достаточно тесно конкурирует с Cisco. Беспроводные решения этих производителей имеют схожий набор функций и дополнительных сервисов. Оборудование сравнимо по стоимости.
Существует множество маркетинговых тестов, сравнений технических характеристик, производительности и технологий каждого решения. Изучив документацию, убеждаешься, что по функциям решения очень похожи. Однако, кроме функционального сходства присутствует немного разный подход производителя к настройке, принципам работы, архитектурные отличия. Именно на это и хотелось бы обратить внимание. Это заметка о том, как цисководы настраивали HPE Aruba и что из этого вышло.
### Функциональность. Архитектура сети
Оба вендора предлагают различные варианты построения сети. Кроме автономных точек доступа это может быть:
* централизованное решение с контроллером (или кластером контроллеров) для управления и мониторинга;
* решение для небольшого офиса с контроллером на базе точки (точек) доступа;
* распределенное решение с множеством удаленных точек (контроллер в центре; связь по VPN);
* контроллер в облаке.
Кроме базового Wi-Fi для предприятий, есть ещё множество продуктов, позволяющих внедрить различные сервисы в беспроводную сеть компании. Например, это может быть сервис позиционирования устройств в помещении, сервис идентификации\доступа в сеть на базе политик для BYOD-устройств, аналитика подключающихся устройств и др.
В качестве оборудования я рассматривал классические контроллеры (централизованное решение, контроллер управляет всеми точками доступа) для беспроводной сети начального уровня и типовые офисные точки доступа с интегрированными антеннами.
**Оборудование**Cisco — контроллер 2504, точки доступа 2600i.
Aruba — контроллер 7010, точки доступа 205.
Сравним наличие основных функций в решении на базе контроллеров Cisco и HPE:
| | | |
| --- | --- | --- |
| **Функция** | **Cisco** | **Aruba** |
| Автоматическое управление радиосредой | RRM | ARM |
| Мониторинг интерференции | CleanAir | Spectrum Analysis |
| Обнаружение соседних ТД | Rogue Detection | Rogue Detection |
| Мониторинг и контроль приложений | AVC | AppRF + URL Filtering |
| Оптимизация роуминга | Optimized Roaming | Client Match |
| Шифрование данных (точка-контроллер) | DTLS | IPSec |
| Резервирование | SSO,N+1 | Active/Active, Active/Standby |
| Предотвращение вторжений | wIPS | wIPS |
| Позиционирование | Hyperlocation | -(только BLE) |
| Оптимизация передачи сигнала | ClientLink | - |
| Межсетевой экран | - | Stateful Firewall |
| Маршрутизация | - | Static, OSPF |
| Удаленный доступ IPsec/SSL VPN | - | Virtual Intranet Access (VIA) |
Из таблицы видно, что по основным функциям WiFi у Cisco и Aruba есть что противопоставить друг другу. По сути это схожие технологии с разными названиями, хотя у каждого есть свои дополнительные “фишки”, поддержка технологий\протоколов. У Cisco – это, например, технология ClientLink, позволяющая оптимизировать downlink передачу (от точки доступа к клиенту). У HPE – это полноценный межсетевой экран, поддержка протоколов динамической маршрутизации, URL фильтрация. Отметим, у HPE дополнительные функции не являются именно “беспроводными”, что делает контроллер более универсальным сетевым устройством.
**Лицензирование**
Обычно Cisco отличается довольно сложными схемами лицензирования, лицензированием отдельных функций. Но не в случае с беспроводной сетью. Тут всё ровно наоборот, HPE выходит на “первое” место.
**HPE Aruba**
На контроллере есть с [десяток](http://www.arubanetworks.com/techdocs/ArubaOS_80_Web_Help/Content/LicenseGuide/License_Usage.htm) различных лицензий. Любая важная функция лицензируется отдельно (тот же межсетевой экран, анализ спектра или анализ приложений (DPI)). Если вы захотите протестировать у себя контроллер от Aruba, вам необходимо будет вручную запросить временную лицензию (сертификат), как уже было сказано, на каждую фичу отдельно.
**Cisco**
Все функции доступны в базовой лицензии. Есть временная на 12 недель.
### Настройка GUI
**HPE Aruba**
На контроллере HPE Aruba настройка осуществляется через профили. Разветвленная структура профилей для настройки беспроводных параметров на точке\группе точек представлена ниже. Логично и понятно.
*Профили в Aruba*
Например, чтобы создать беспроводную сеть, необходимо создать профиль Virtual AP, затем прикрепить к нему AAA profile и SSID profile. Есть меню упрощенной настройки с указанием основных профилей (управление радиосредой, QoS, AAA и др).
В меню раздела Configuration присутствуют вкладки для настройки разных функций.
Из-за обилия детальных настроек, предварительно настроенных политик и профилей, при настройке в первый раз можно запутаться. Тут может помочь кнопка Show reference, показывающая связи различных сущностей (профиль, политика) друг с другом.
*Меню настройки WLAN в Aruba*
Когда заходишь во вкладку All Profiles, видишь, насколько много различных тонких деталей можно настроить на контроллере Aruba. Кастомизация здесь более детальная нежели в Cisco.
*Профили на контроллере Aruba*
**Cisco**
Интерфейс поделен на разделы (WLANs, SECURITY, MANAGEMENT и др.). В каждом — меню с вкладками. Нет профилей и референсов. Интерфейс выглядит более удобным и интуитивно понятным. Однако здесь нет такого числа детальных настроек и дополнительных функций как в Aruba.
Например, меню настройки WLAN.
*Настройка WLAN на контроллере Cisco*
**HPE Aruba**
Каждому подключенному клиенту привязывается определенную роль со своими политиками доступа (User-centric network, Stateful Firewall). На контроллере есть предустановленные профили и правила фаервола. С одной стороны, это очень удобно: например, не нужно настраивать с нуля политики гостевого доступа, можно только добавлять конкретные правила для данной роли.
*Пример предустановленных профилей в Aruba*
С другой, если у вас нет лицензии на межсетевой экран (PEFNG), то роли теряют смысл. При этом в настройках (профили ААА, например) они всё равно остаются, так как это одна из ключевых сущностей, используемых при конфигурировании.
*Роли пользователей в профиле AAA*
Раз уж мы коснулись настройки межсетевого экрана, ниже представлено меню общих параметров. Весьма обширное. Есть разделы со списками доступа (ACL), сервисами, ограничения полосы пропускания и др.
*Настройка общих параметров МЭ на контроллере Aruba*
**Cisco**
На контроллере нет функции межсетевого экрана. Полноценный МЭ можно реализовать на отдельном устройстве. Однако, для анализа трафика в беспроводной сети одной из ключевых функций является разбор трафика по приложениям (DPI), возможность его приоритезации или блокировки. Эта опция есть у обоих вендоров. У Cisco она называется AVC (Application Visibility and Control), у HPE Aruba — AppRF. Также на контроллере Cisco можно настроить (кроме стандартных ACL) политики ограничения доступа для определенного типа устройств.
Cisco, как и Aruba, умеет определять тип клиента (profiling) по заголовкам HTTP, DHCP. Для определенного типа клиентов (например, iPad или Android-Samsung) на контроллере можно создать политику доступа (local policy) с необходимыми параметрами и ограничениями — ACL, VLAN, QoS, часы работы и др.
*Локальные политики на контроллере Cisco*
### Настройка CLI
Настраивать контроллер беспроводной сети комфортнее через графический интерфейс. В командной строке скорее удобно делать выборку по параметрам или выполнять отладку проблемы. Для сравнения, приведу пример конфигурации WLAN на контроллерах. Многие знают, что CLI на контроллерах Cisco мало похож на обычную командную строку Cisco IOS (привет Aironet), привычную многим. Так вот, когда смотришь на пример ниже, закрадывается мысль, что Aruba больше похожа на Cisco IOS.
**HPE Aruba**
```
aaa profile "tst-dot1x-peap"
mac-default-role "employee"
authentication-dot1x "ad-users-radius"
dot1x-default-role "employee"
dot1x-server-group "default"
!
wlan ssid-profile "test123"
essid "test123"
opmode wpa2-aes
!
wlan virtual-ap "virt-ap"
aaa-profile "tst-dot1x-peap"
ssid-profile "test123"
vlan 21
```
**Cisco**
```
config radius auth add 1 1.1.1 1645 ascii secret123
config wlan create 3 test123 test123
config wlan interface 3 users_vlan21
config wlan security wpa akm 802.1x enable 3
config wlan radius_server auth add 3 1
config wlan broadcast-ssid enable 3
config wlan enable 3
```
### Мониторинг
В плане мониторинга оба решения выглядят хорошо. Если использовать только контроллер (без дополнительных серверов), Aruba предоставляет более детальную информацию. У Cisco данных по мониторингу сети меньше. Связано это как с отсутствием некоторых функций в принципе (например, межсетевой экран), так и с общим подходом Cisco, когда для мониторинга беспроводной сети, хранения статистики, нам предлагают установить отдельную систему (разумеется, от Cisco).
У HPE Aruba система управления и мониторинга, конечно, тоже есть. Но при этом в базе много вещей, которые у Cisco можно получить только с дополнительным сервером. Например, гостевой доступ с распечаткой информации по подключению, отправкой по почте, статистика по трафику (адреса, url, категории). В последней версии ПО у Aruba появились также средства проактивного мониторинга трафика и беспроводной сети.
**Мониторинг радиопараметров**
**HPE Aruba**
Aruba предоставляет общую картину по всем беспроводным пользователям сети. Тут мы видим распределение по диапазонам, скорости подключения, уровень сигнала и пр.
*Общая информация по сети (клиенты, распределение по диапазонам, скорости)*
**Cisco**
У Cisco мы также видим общую статистику подключений на данный момент.
*Информация по утилизации сети на контроллере Cisco*
**Мониторинг трафика (приложения, пользователи, сессии)**
Здесь сравнивать решения не совсем корректно, так как у Aruba есть Stateful Firewall, а значит и более детальная информация о сессии.
**HPE Aruba**
Aruba предоставляет информацию по используемым приложениям. Есть сигнатуры для наших ресурсов вроде vkontakte и yandex. Присутствуют данные по сессиям, распределение по ролям пользователей, информация по URL.
*Информация по используемым приложениям*
*Общее представление по категориям сайтов, ролям, WLAN, типам устройств и др.*
**Cisco**
Тут все скромнее — только приложения и тип устройств. Можно посмотреть статистику по конкретному пользователю. Сигнатуры для российских приложений тоже есть.
*Общая статистика использования приложений у Cisco*
### Логирование
**HPE Aruba**
Основным протоколом для ведения системных сообщений является syslog. В системе используется распределение логов по категориям (системные, AAA, фаервол и т.п.). Для каждой настраивается необходимый уровень логирования. Хранятся они в отдельных файлах.
*Системные сообщения в GUI Aruba*
**Cisco**
Системные логи собираются в единой консоли syslog. Важным инструментом для отслеживания событий в беспроводной сети являются уведомления snmp. Сбор сообщений можно настроить по типам (auth\deauth и т.п.) и категориям (ap, security и т.п.).
*SNMP сообщения Cisco и настройка их фильтрации*
### Вывод
Материал — субъективный взгляд на разницу подходов, интерфейсов управления двух решений. Описана лишь небольшая часть функций, которые предоставляют устройства. По беспроводным функциям решения схожи. Cisco показалось более интуитивно понятно и логично в настройке (хотя, возможно, дело привычки). Aruba сложнее, но не стоит забывать, что там больше различных дополнительных сервисов (VPN, FW, Routing). Конечно, при выборе решения стоит ориентироваться и на другие стороны: надежность решения; стабильность его работы, обслуживания пользователей; техподдержка вендора и др. | https://habr.com/ru/post/324112/ | null | ru | null |
# Модель эффективности медиа рекламы для интернет-магазинов
Мы в агентстве [People & Screens](https://www.facebook.com/peoplescreens/) много лет работаем с онлайн-бизнесами в качестве рекламного партнера. Когда у нас появилась идея оценить вклад медийной рекламы в продажи интернет-магазинов, она казалась нереализуемой и даже безумной. Как только мы поняли, что все элементы мозаики можно найти и сложить вместе, то решили попробовать. Первые гипотезы начали подтверждаться, вместе с компанией [Data Insight](http://www.datainsight.ru/) мы углубились в эту историю и за несколько месяцев кропотливой работы создали такое исследование, которое, по сути, является прикладным рабочим инструментом – модель оценки эффективности рекламы в 12 товарных категориях e-commerce. В этой статье мы расскажем о результатах и используемых методах анализа.
### Цели исследования и результаты
Ключевая гипотеза нашего исследования: медийная реклама, развивая бренд интернет-магазина, увеличивает конверсию во всей воронке продаж. В ходе анализа данных о продажах, о размещении рекламы и внешних данных за последние четыре года гипотеза подтвердилась. В итоге мы построили эконометрические модели продаж для 60 интернет-магазинов в 12 товарных категориях.
1. Только краткосрочный вклад медийной рекламы составил 39% роста интернет-магазинов при динамике рынка в среднем на 50-60%.
2. Медийная реклама позволяет поддерживать продажи за счет роста знания.
3. Наибольшую отдачу в целом в e-commerce приносит онлайн видеореклама.
4. Эффективность медиа сильно зависит от категории: в категориях одежды и интернет-гипермаркетов высокую эффективность показал ТВ, в электронике и автотоварах – онлайн-видеореклама.
### Что мы анализировали
Сбор данных для исследования происходил силами обоих компаний, учавствующих в исследовании. Со стороны People & Screens были собраны следующие данные:
1. Данные о выходах медийной рекламы. Мы использовали выгрузки из баз данных компании [Mediascope](https://mediascope.net/) доступ к которым есть у всех рекламных групп. Мы выгружали рекламные затраты по всем медиа и рекламные контакты на широкую целевую аудиторию (Все 18+) в детализации по дням (для рекламы на ТВ, радио, в прессе, интернете) и по месяцам (для наружной рекламы) за период с января 2016 года по июнь 2019 года. Для максимизации скорости работы на этом этапе мы пользовались внутренними разработками Dentsu Aegis Network Russia для работы с индустриальными данными, в частности платформу Atomizer.
2. Выгрузка данных из [SimilarWeb](https://www.similarweb.com/) по дням за последние 18 месяцев. Смотрели на динамику по дням Visits по Desktop/Mobile, динамику по дням десктоп трафика в разбивке по источникам (каналам) и динамику установок на Android.
3. Динамика знания/посещения/покупок из базы данных TGI/Marketing Index за 2016-2019 год по кварталам. Это выгрузка из индустриального софта Gallileo компании Mediascope.
4. Поисковые запросы [Google Trends](https://trends.google.ru/) за январь 2016 – июль 2019 по России.
Со стороны Data Insight были собраны и предоставлены следующие данные:
1. Динамика заказов по 72 интернет-магазинам из [ТОП-100](https://www.top100.datainsight.ru/) рейтинга по месяцам за период с января 2016 по август 2019 года.
2. Данные счётчика [li.ru](https://www.liveinternet.ru/rating) за период с января 2018 по август 2019 (трафик на сайт, отдельно суммарный, только по России и только мобайл) по ТОП-11 сайтам.
3. Данные счетчика [mail.ru](https://top.mail.ru/) за период с июня 2017 по сентябрь 2019 по 53 сайтам.
4. Данные счетчика [Rambler](https://top100.rambler.ru/) за период с июня 2017 по сентябрь 2019 по 38 сайтам.
5. Данные поисковых запросов [Yandex Wordstat](https://wordstat.yandex.ru/) за 24 месяца с октября 2017 по сентябрь 2019.
6. Оценка средних чеков интернет-магазинов ТОП-100 по состоянию на 2018 год.
### Алгоритм работы с данными
Сбор данных для исследования проводился в несколько этапов. Мы оставим за рамками статьи ту работу, которую провели наши коллеги из Data Insight, чтобы сформировать необходимые для исследования данные, но расскажем, какая работа была подела на стороне People&Screens:
* Поиск всех интернет-магазинов из рейтинга [ТОП-100](https://www.top100.datainsight.ru/) в доступных нам индустриальных базах и составление словарей соответствия названий. Для этого мы использовали движок семантического поиска [Elasticsearch](https://www.elastic.co/products/elasticsearch).
* Формирование шаблонов и выгрузка данных по ним. На этом этапе самым важным было заранее продумать архитектуру таблиц данных.
* Объединение данных из всех источников в единый набор данных (датасет).
Для этого мы использовали обработку выгруженных данных в Python с использованием пакетов **pandas** и **sqlalchemy**. Набор лайфхаков тут достаточно стандартный:
при обработке сырых данных из csv таблиц размером более 1 млн. строк мы вначале прогружали названия столбцов таблиц запросом вида:
```
col_names = pd.read_csv(FILE_PATH,sep=';', nrows=0).columns
```
затем типы данных добавляли через словарь:
```
types_dict = {'Cost RUB' : int }
types_dict.update({col: str for col in col_names if col not in types_dict})
```
и сами данные грузили функцией
```
pd.read_csv(FILE_PATH, sep=';', usecols=col_names, dtype=types_dict, chunksize=chunksize)
```
Результаты преобразований выгружались в PostgreSQL.
* Кросс-валидация динамики заказов на основе анализа динамики трафика, поисковых запросов и фактических продаж по пулу клиентов агентства People & Screens. Здесь мы строили корреляционные матрицы с помощью **df.corr()** по разным наборам данных в рамках фиксированного сайта, затем детально анализировали «подозрительные» ряды с выбросами. Это один из ключевых этапов исследования, на котором мы проверяли надёжность динамики исследуемых показателей.
* Построение эконометрических моделей на валидированных данных. Здесь мы использовали прямое и обратное преобразование Фурье из пакета **numpy** (функции **np.fft.fft** и **np.fft.ifft**) для извлечения сезонности, кусочно-гладкую аппроксимацию для оценки тренда и модели линейной регрессии (**linear\_model**) пакета **sklearn** для оценки вклада рекламы. При выборе класса моделей для этой задачи мы исходили из того, что результат моделирования должен быть легко интерпретирован и использован для численной оценки эффективности рекламы с учётом качества данных. Надежность моделей мы исследовали через разделение данных на обучающую и тестовую выборки переменного временного интервала. Т.е. мы сравнивали как на тестовом временном интервале с января по август 2019 года ведёт себя модель, обученная на данных с января 2016 по декабрь 2018, потом обучали модель на временном интервале с января 2016 по январь 2019 и смотрели как ведёт себя модель на данных с февраля по август 2019. Качество моделей исследовалось по стабильности вклада рекламных факторах на разных обучающих выборках качестве прогноза на тестовой выборке
* Заключительным этапом была подготовка презентации на основе полученных выводов. Здесь мы прокладывали мост математических моделей к практическим бизнес-выводам и ещё раз проверяли модели с точки зрения здравого смысла полученных результатов.
### Специфика анализа e-commerce и сложности, которые возникают в процессе
1. На этапе сбора данных возникли трудности с корректной оценкой поискового интереса к ресурсу. В Google Trends нет возможности группировать поисковые запросы и использовать минус-слова как в Yandex Wordstat. Важно было изучить семантическое ядро каждого интернет-магазина и выгружать центральный запрос. Например, М.Видео нужно писать по-русски – это центральный запрос для этой площадки.
Для магазинов, которые продают товары и в онлайне, и в офлайне, в данных по Yandex wordstat коллеги из Data Insight придерживались следующего подхода:
Убедиться в отсутствии нерелевантных вопросов (главное – не оценка объема спроса, а отслеживание изменений динамики). Мы достаточно жестко подходили к фильтрации поисковых слов. Там, где по имени бренда был риск подцепить нецелевые запросы, брали статистику по ключевым комбинациям. Например, «магазин озон» вместо «озон» – при таком подходе поисковая популярность ритейлера занижается, зато динамика спроса измеряется надежнее и становится очищенной от “шумов”. Применительно к поисковой статистике есть методологическая проблема, у которой по всей видимости нет надежного решения — по многим ритейлерам эта статистика искажена SEO-инструментами, которые оптимизируют поисковые выдачи через поведенческие факторы, но искажают статистику по реальному спросу.
2. На этапе объединения данных из разных источников возникла необходимость приведения данных к единой гранулярности: данные по ТВ-рекламе и трафику из SimilarWeb были по дням, данные поисковых запросов – по неделям, а данные по заказам и данные счетчиков – по месяцам. В итоге мы сформировали отдельную базу с полями дат, позволяющими агрегировать данные на необходимом уровне, и кэшированную базу данных месячной агрегации для дальнейшей работы со всей детализацией данных продаж.
3. На этапе кросс-валидации данных мы обнаружили заметные расхождения в динамике продаж с нашими собственными данными. Это потребовало обсуждения ситуации с коллегами из Data Insight. В итоге благодаря точному пониманию, в какие месяцы возникают наибольшие ошибки, аналитики выявили две ошибки, засевшие глубоко «внизу» алгоритма оценки месячной динамики продаж.
4. На этапе разработки моделей возникло несколько сложностей. Для корректной оценки эффекта рекламы было необходимо изолировать внешние факторы. Любая динамика продаж (и e-commerce не исключение) связана не только с рекламой, но и с множеством других факторов: UX/UI изменения на сайте, цены, ассортимент, конкуренция, колебания курса валют и т.д.
Для решения этой задачи мы использовали подход на основе регрессионного анализа данных за длинный период – с января 2016 года по август 2019 года. В рамках этого подхода мы анализировали изменения (всплески) в динамике заказов, которые могут быть атрибуцированы к рекламе в этот период.
Важно понимать, что если в какой-то момент запустилась реклама, но ожидаемое значение продаж, согласно модели, было не выше фактического, то модель покажет, что эта реклама в этот период не сработала. Конечно, такое поведение продаж может быть суперпозицией влияния нескольких факторов (например, рост цен/запуск конкурентов одновременно со стартом рекламной кампании, или «упавший» от притока клиентов сайт).
Поскольку мы усредняем эффекты на длинном периоде времени на большом количестве брендов, то эффект таких случайных совпадений должен нивелироваться на большой выборке, хотя и может приводить к переоценённым или недооценённым эффектам по отдельным брендам. В итоге это позволило определить общие правила и закономерности для категории e-commerce в целом. При этом для детального анализа влияния рекламы в рамках отдельных брендов, конечно, по-прежнему необходимо исследовать всю совокупность факторов влияния.
### Вывод
В рамках данного исследования мы ставили перед собой цель получить как можно более надежные результаты на основе данных из разнородных источников. Сами по себе эти данные не являются точными значениями, а лишь оценкой этих значений средствами стороннего наблюдения (мониторинг выходов рекламы, динамика трафика, поисковый интерес и, наконец, заказы).
В каждом из звеньев есть ограничения по качеству данных, и это та проблема, с которой аналитики и исследователи сталкиваются в том или ином масштабе каждый день. Надеемся, что в рамках данной статьи нам удалось показать, какие методы позволяют обеспечить надежность выводов аналитического исследования, сохранив объяснительную силу результатов. | https://habr.com/ru/post/479960/ | null | ru | null |
# История Linux (1993–2003): испытание дистрибутивов
Уникальная особенность опенсорсных проектов заключается в том, что жизнь их никогда по-настоящему не заканчивается. Образы дисков, по большей части, доступны для загрузки из интернета, их лицензии не истекают. Поэтому довольно просто совершить прыжок в прошлое, установив Linux из 90-х на виртуальной машине.
[](https://habrahabr.ru/company/ruvds/blog/335898/)
Как это было? Как воспринимаются сегодня древние дистрибутивы Linux? Что изменилось за годы развития? Выясним это. Первым пунктом нашего путешествия станет ОС Slackware 1.01, оправленная в группу новостей comp.os.linux.announce 20 лет назад.
Slackware 1.01 (1993)
---------------------
*Slackware 1.01*
Пожалуй, из рассматриваемых сегодня дистрибутивов, Slackware 1.01 попробовать проще всего. Дело в том, что в серии [бесплатных образов](http://www.qemu-advent-calendar.org/2014) Qemu 2014-го года имеется готовый к использованию образ, поэтому выполнять установку системы вручную не придётся (однако, к такой роскоши лучше не привыкать).
```
$ qemu-kvm -m 16M -drive if=ide,format=qcow2,file=slackware.qcow2 \
-netdev user,id=slirp -device ne2k_isa,netdev=slirp \
-serial stdio -redir tcp:22122::22
```
Многое в Linux 1993-го года выглядит именно так, как можно ожидать. Все основные команды, такие, как `ls` и `cd`, работают, все базовые инструменты (`gawk`, `cut`, `diff`, `perl`, и конечно `elvis` — любимец [Патрика Фолькердинга](http://www.slackware.com/~volkerdi/)) присутствуют и функционируют, однако, кое-какие мелочи меня удивили. Например, то, как ведёт себя BASH при автозаполнении, и то, что в дистрибутиве уже имеются инструменты для исследования сжатых файлов (такие как `zless`, `zmore` и `zcat`). Система, во многом, выглядит на удивление современной. Собственно говоря, этого я и ожидал.
Чего тут не хватает, так это хоть какого-нибудь средства для управления пакетами. Все инсталляции и деинсталляции выполняются полностью вручную, никаких вспомогательных механизмов нет.
В целом, Slackware 1.01 воспринимается как довольно современная UNIX-система, или, если говорить точнее, так, как современная UNIX-система может восприниматься пользователем Linux. Практически всё в ней знакомо, но тут и там попадаются и различия. Причём, их далеко не так много, как можно было бы ожидать от операционной системы, выпущенной в 1993-м году.
Debian 0.91 (1994)
------------------
Для того, чтобы испытать Debian 0.91, я воспользовался образами дискет, которые появились в 1994-м, из [Ibiblio digital archive](https://ibiblio.org/pub/historic-linux/distributions/debian-0.91/debian-0.91/dist). Вот команды, которые понадобились для того, чтобы загрузить систему.
```
$ gunzip bootdsk.gz basedsk1.gz basedsk2.gz
$ qemu-system-i386 -M pc -m 64 -boot order=ac,menu=on \
-drive file=bootdisk,if=floppy,format=raw \
-drive file=debian.raw,if=ide,format=raw \
-device ne2k_isa,netdev=slirp \
-serial msmouse -vga std \
-redir tcp:22122::22 \
-netdev user,id=slirp
```
Загрузочный диск для Debian 0.91 запускает простую оболочку, содержащую чёткие инструкции.
Процесс установки прошёл на удивление гладко. Он предусматривает использование системы меню, направленной на выполнение семи шагов — от разбиения на разделы жёсткого диска и форматирования его в файловой системе ext2, до копирования образов `basedsk`. После этого в нашем распоряжении оказывается минимальная установка Debian, соответствующая множеству знакомых соглашений, которые любой современный пользователь Linux может ожидать от своей ОС.
Сегодня Debian знаменита своей системой управления пакетами, но в этом раннем релизе были лишь слабые намёки на эту систему. Команда `dpkg` присутствует, но это интерактивная система, основанная на меню — нечто вроде неуклюжего `aptitude` с несколькими уровнями меню, и, что неудивительно, лишь с частью доступных пакетов.
Даже при таком раскладе, в том, как спроектирована система, можно ощутить заботу об удобстве пользователя. Для того, чтобы стать владельцем рабочей ОС, надо лишь загрузить три образа дискет, а затем, используя простое текстовое меню, установить дополнительные программы. Я совершенно точно вижу причину сильного влияния Debian на Linux-индустрию.
Jurix/S.u.S.E (1996)
--------------------
*Установка Jurix*
ОС Jurix, предшественница SUSE, поставлялась с бинарными `.tgz`-пакетами, организованными в директориях, что напоминает структуру установочных пакетов Slackware. Да и сам установщик напоминает установщик Slackware.
```
$ qemu-system-i386 -M pc -m 1024 \
-boot order=ac,menu=on \
-drive \
file=jurix/install,if=floppy,format=raw \
-drive file=jurix.img,if=ide \
-drive file=pkg.raw,if=ide,format=raw \
-device ne2k_isa,netdev=slirp \
-serial msmouse -vga std \
-redir tcp:22122::22 \
-netdev user,id=slirp
```
Так как я не занимался специальными поисками самого раннего релиза, дистрибутив Jurix оказался первым из найденных дистрибутивов, который был предназначен для работы в режиме графического окружения. [XFree86](http://www.xfree86.org/) установлен по умолчанию, поэтому, если им не собирались пользоваться, его надо было убрать.
Там был файл с примером настроек, `/usr/lib/X11/XF86Config`, позже он стал называться `Xorg.conf`. 90% настроек графической подсистемы я выполнил благодаря этому файлу, однако, тонкая настройка `vsync`, `hsync` и переназначения цветовой карты `ramdac` отняли у меня целые выходные, после чего я сдался.
Установка новых пакетов на Jurix проста. Нужно найти файл `.tgz` на диске с пакетами и выполнить следующую команду:
```
$ su -c 'tar xzvf foo.tgz -C /'
```
Пакет будет готов к использованию после разархивирования в корневой раздел. Я установил так несколько пакетов, которые не были установлены после инсталляции системы, и нашёл этот способ работы с пакетами простым, быстрым и надёжным.
SUSE 5.1 (1998)
---------------
*Оконный менеджер FVWM, запущенный на SuSE 5.1*
Я установил SUSE 5.1 с CD-ROM InfoMagic, купленного в компьютерном магазине в Мэриленде в 1998-м году.
```
$ qemu-system-i386 -M pc-0.10 -m 64 \
-boot order=ad,menu=on \
-drive file=floppy.raw,if=floppy,format=raw \
-cdrom /dev/sr0 \
-drive file=suse5.raw,if=ide,format=raw \
-vga cirrus -serial msmouse
```
Процесс установки был не таким уж и простым в сравнении с тем, с чем я уже сталкивался. YaST разбросал конфигурационные файлы и настройки между дискетой и загрузочным CD-диском, что потребовало нескольких перезагрузок. Мне понадобилось несколько раз начинать всё сначала, пока я пытался понять, какой последовательности действий ожидает от меня система. После того, как я пару раз всё испортил, я понял принцип работы YaST и третий раз прошёл хорошо. Это было как намёк на то, что приходилось делать пользователю Linux в более поздние годы.
В SUSE 5.1 моей главной целью было графическое окружение. Процесс настройки был знакомым, выполнялся с помощью нескольких приятных графических инструментов (включая хорошее средство `X86Setup`), предназначенных для проверки мыши и монитора и устранения неполадок. Для того, чтобы графический интерфейс нормально заработал, понадобилось меньше часа, причём, основное время ушло на мои собственные изыскания, направленные на выяснение того, какое разрешение и глубину цвета поддерживает виртуальная видеокарта Qemu.
Среди оконных менеджеров были `fvwm`, `fvwm2` и `ctwm`. Я воспользовался `fvwm` и работал он так, как и ожидалось. Я даже нашёл `tkDesk` — многофункциональный пакет, реализующий функции файлового менеджера, который оказался очень похожим на оболочку `Unity` из Ubuntu.
В целом, работа с SUSE 5.1 оставила положительные впечатления, особенно мне понравилось удобство и скорость настройки графического рабочего окружения.
Red Hat 6.0 (1999)
------------------
*GIMP 1.x, запущенный в Red Hat*
На следующем установочном диске, который мне посчастливилось найти, была ОС Red Hat 6.0. Обратите внимание — не RHEL 6.0, а просто Red Hat 6.0. Это был настольный дистрибутив, который продавался в магазинах ещё до того, как появились RHEL или Fedora. Диск, который я использовал, был куплен в 1999-м.
```
$ qemu-system-i386 -M pc-0.10 -m 512 \
-boot order=ad,menu=on \
-drive file=redhat6.raw,if=ide,format=raw \
-serial msmouse -netdev user,id=slirp \
-vga cirrus -cdrom /dev/sr0
```
Процесс установки был хорошо организованным и быстрым. Его не приходилось прерывать ни при выборе пакетов для установки (они собраны в группы `Workstation`, `Server` и `Custom`), ни при разбиении диска, ни после начала установки.
Red Hat 6 включала в себя приложение `xf86config`, предназначенное для организации пошагового процесса настройки оконной системы X, хотя, что не очень понятно, оно давало возможность включить некоторые параметры эмуляции мыши, на неправильность которых позже жаловалась X. Проблема решилась редактированием файла `X86Config`, но правильную настройку X всё ещё нельзя было назвать простой задачей.
Средой рабочего стола Red Hat 6 была, как, впрочем и сейчас, GNOME, но оконным менеджером был ранний [Enlightenment](http://enlightenment.org/), из которого брался и главный демон звука. В качестве менеджеров входа в систему предлагались и `xdm`, и `gdm`, в результате обычный пользователь мог войти в систему, не имея при этом разрешений на запуск или остановку самого X, что особенно важно в многопользовательских системах.
Надо отметить, что в дистрибутиве не было некоторых важных приложений. Так, тогда ещё не существовал `gedit`, не было многофункционального офисного приложения, не было менеджера пакетов, о котором стоило бы говорить. `GnoRPM`, графический интерфейс для установки, просмотра и удаления RPM-пакетов, был ближе всего к тому, что дают `yum` или `PackageKit`. Текстовым редактором, с которым можно было работать в графическом интерфейсе, был `gnotepad+` (и без Emacs, конечно, не обошлось).
В целом, однако, рабочий стол интуитивно понятен. В отличие от более поздних реализаций GNOME, эта ранняя версия обладала панелью в нижней частью экрана, содержащей меню приложений и значки лаунчера, было там и средство для управления виртуальным рабочим столом. Не могу представить себе среднестатистического пользователя тех времён, который заблудился бы в этом графическом окружении.
Red Hat 6 была сильным игроком в сфере Linux. Очевидно, это серьёзно продвинуло её на пути превращения в хорошую настольную ОС.
Mandrake 8.0 (2001)
-------------------
*Mandrake: поворотная точка в мире Linux*
Mandrake 8.0 была выпущена в 2001 году, поэтому её можно было сравнивать, например, с Apple OS 9.2 и Windows ME.
Для того, чтобы установка прошла нормально, я решил использовать в эмуляторе достаточно старое аппаратное обеспечение.
```
$ qemu-system-i386 \
-M pc-0.10 -m 2048 \
-boot order=ad,menu=on \
-drive file=mandrake8.qcow2 \
-usb -net nic,model=rtl8139 \
-netdev user,id=slirp \
-vga cirrus \
-cdrom mandrake-8.0-i386.iso
```
Я думал, что процесс установки Red Hat было достаточно хорош, но в случае с Mandrake всё прошло просто замечательно. Установщик был дружелюбным, простым и быстрым, давал пользователю возможность проверить конфигурацию перед тем, как продолжить. Мне даже не пришлось импортировать мой конфигурационный файл `XF86Config`, так как установщик Mandrake всё сделал правильно.
*Установщик Mandrake 8.0*
Использование рабочего стола Mandrake, на самом деле, весьма напоминает то, что было в других подобных системах. Я был слегка удивлён тем, насколько всё оказалось похожим. Я чувствовал уверенность в том, что если бы я в то время попробовал Mandrake Linux, я вполне смог бы в ней работать, даже учитывая мой возраст, и то, что я был не особенно хорошо подкованным пользователем.
Понятный интерфейс, адекватная документация, хороший менеджер пакетов, учитывая то, что в те времена загрузка установочных файлов программ с сайтов ещё не стала всеобщей привычкой.
Fedora 1 (2003)
---------------
*Blue Fedora, Red Hat*
В 2003-м был выпущен новый дистрибутив Fedora Core. Он был основан на Red Hat, на него, после того, как флагманским продуктом компании стала Red Hat Enterprise Linux (RHEL), возлагалась роль настольного Linux.
Для загрузки старого диска Fedora Core 1 ничего особенного не потребовалось.
```
$ qemu-system-i386 -M pc \
-m 2048 -boot order=ac,menu=on \
-drive file=fedora1.qcow2 -usb \
-net nic,model='rtl8139' -netdev user \
-vga cirrus -cdrom fedora-1-i386-cd1.iso
```
Установка Fedora 1 оказался простой и знакомой. Тут был тот же установщик, что использовался в Fedora и Red Hat следующие 9 лет. Это — понятный, лёгкий в использовании графический интерфейс.
*Графический интерфейс Anaconda*
Ощущения от работы в Fedora Core серьёзно отличаются от Red Hat 6 или 7. Рабочий стол GNOME доведён до совершенства, тут присутствуют все основные вспомогательные приложения, всё это лаконично и профессионально представлено.
Значок `Start Here` ведёт пользователя к трём местам. Это — папка `Applications`, панель `Preferences` и настройки — `System Settings`. Значок с красной шляпой указывает на меню приложений, а панель GNOME позволяет запускать приложения, в том числе — офисный пакет OpenOffice и браузер Mozilla.
Итоги: о прошлом и будущем
--------------------------
В начале 2000-х было ясно, что ОС, основанные на Linux, уже достаточно хороши и двигаются в правильном направлении. Рабочие столы выглядели лучше, чем когда либо, имелись все необходимые приложения, установка была проще и эффективнее, чем у других операционных систем. На самом деле, начиная с 2000-х, между пользователем и операционной системой наладился такой способ взаимодействия, который остался практически неизменным до наших дней. Конечно, кое-что изменилось и улучшилось, появились кое-какие новшества.
Вот что можно сказать о развитии некоторых дистрибутивов Linux.
* ОС Mandrake превратилась в Mandriva, а потом стала называться [Mageia](http://mageia.org/).
* Дистрибутив Fedora Core стал называться просто [Fedora](http://fedoraproject.org/).
* Из ОС [Debian](http://debian.org/) возникла [Ubuntu](http://ubuntu.com/), которая помогла продвинуть Linux в массы.
* Valve сделала SteamOS официальной основой для своей игровой платформы.
* [Slackware](http://slackware.com/) тихо живёт и по сей день.
Думаю, возможность взглянуть на то, как развивался самый большой опенсорсный проект в мире, будет полезна и новичкам, и тем, у кого скриншоты из этой статьи ассоциируются не с «историей Linux», а с их собственной компьютерной биографией. Linux продолжает развиваться, поэтому взгляд в прошлое позволяет каждому из нас лучше разглядеть направление движения Linux, и, что просто восхитительно, стать частью этого движения.
Уважаемые читатели! С какого дистрибутива началось ваше знакомство с Linux? | https://habr.com/ru/post/335898/ | null | ru | null |
# Ogre 3D. Серия обучающих статей. Выпуск 1
В [топике](http://habrahabr.ru/blogs/open_source/85932/) прозвучала просьба написать какие-нибудь статьи про Ogre 3D.
В первой статье я расскажу о установке Ogre и создании простейшего приложения использующего Ogre.
#### Установка
Самый простой вариант, это скачать sdk с [ogre3d.org](http://www.ogre3d.org/download/sdk), но sdk есть только последняя стабильная версия, а все новые вкусности есть только в trunk.
Опишу в кратце сборку и установку из исходников.
Понадобится:
Исходники огра из [svn.ogre3d.org/svnroot/ogre/trunk](https://svn.ogre3d.org/svnroot/ogre/trunk)
Зависимости: качаем [отсюда](http://www.ogre3d.org/download/source) Microsoft Visual C++ Dependencies Package (как Вы поняли, я буду описывать работу под VC++)
Cmake (возможно вы использовали для других проектов): [http://cmake.org/](http://www.cmake.org/)
DirectX SDK (если вы хотите использовать в качестве рендера DirectX 3D, для OpenGL не требуется): <http://msdn.microsoft.com/directx>
Распаковываем архив с зависимостями в папку, куда сделали checkout исходников (в моем случае D:/TestGameEngine/ogre\_trunk/) и собираем зависимости (проект для студии лежит в \ogre\_trunk\Dependencies\src\ выберете проект для своей версии студии)
Теперь можно приступить к сборке самого огра.
Запустим Cmake, в верхнем поле укажем папку с исходниками, а в нижней куда сложить файлы проекта и результаты конфигурации, после чего нажимаем configure и указываем компилятор, которым будем собирать.
Возможно лог будет пестрить ошибками о не найденных зависимостях, тогда укажем в параметра Ogre→OGRE\_DEPENDENCIES\_DIR папку /ogre\_trunk/Dependencies, после чего Cmake пропишет пути к lib и include файлам разных библиотек. Как видите, есть некоторые зависимости, которые не обязательны, но нужны для какой либо фичи в движке. Например можете указать путь к doxygen, для генерации документации, хотя ее можно посмотреть [здесь](http://www.ogre3d.org/docs/api/html/)
Я немного поменял опции сборки (например мне не нужен OpenGL рендер и проекты для сборки примеров)
Если вы поменяли опции то нажимаем Configure, и если не нашлось ошибок, то нажимаем Generate.
Теперь открываем сгенерированный проект в студии, у меня это \ogre\_build\OGRE.sln
Можно собрать какой-либо отдельный компонент или сразу собрать ALL\_BUILD. Проект Package собирать не нужно, это сборка установщика.
Когда устанавливаем SDK пути инклудов и lib файлов прописываются в студии автоматически, при сборке из исходников это надо сделать руками.
Прописываем в настройках студии пути инклудов:
`\ogre_trunk\OgreMain\include
\ogre_build\include
\ogre_trunk\Dependencies\include`
Файлы библиотек:
`\ogre_build\lib\[Release|Debug](надо указать оба путя, но я использую только Release версию, поэтому указал только ее)`
Так-же в последствии не забудем указать OgreMain.lib в опциях линкера у проекта.
На этом сборку огра можно считать законченной.
#### Создание простейшего приложения
Теперь создадим простой проект на Ogre.
Создадим Win32 Console Application.
Добавляем в код #include «Ogre.h»
и в код функции main добавляем
> `1. Ogre::Root\* mRoot = new Ogre::Root(); //создаем главный объект огра
> 2. mRoot->showConfigDialog(); //Показываем диалог конфигурации огра, выбор настроек.
> 3. Ogre::RenderWindow\* mWindow = mRoot->initialise(true); //создаем окно рендеринга, параметр true говорит, о том, что нужно создать это окно, иначе его нужно создать вручную
> 4. Ogre::SceneManager\* mSceneMgr = mRoot->createSceneManager(Ogre::ST\_GENERIC); //создаем сцену со стандартным менеджером сцены.
> 5. while (1)
> 6. {
> 7. MSG msg;
> 8. while (PeekMessage(&msg, NULL, 0U, 0U, PM\_REMOVE))
> 9. {
> 10. TranslateMessage(&msg);
> 11. DispatchMessage(&msg);
> 12. }
> 13. if (!mRoot->\_fireFrameStarted())
> 14. break;
> 15. mRoot->\_updateAllRenderTargets();
> 16. if (!mRoot->\_fireFrameEnded())
> 17. break;
> 18. if (mWindow->isClosed())
> 19. break;
> 20. }
> 21. window->destroy();
> 22. root->shutdown();`
Скопируем в папку с exe файлом файлы OgreMain.dll, и файл рендер системы, например RenderSystem\_Direct3D9.dll
так-же создадим plugins.cfg, в котором укажем
`PluginFolder=.
Plugin=RenderSystem_Direct3D9`
это укажет огру, какие дополнительные плагины загрузить во время инициализации
После запуска видим простейшее приложение на огре, которое показывает пустое окно.
На всякий случай выложу исходники и скомпилированный пример:
[Исходник](http://narod.ru/disk/18403234000/example1.src.7z.html)
[Скомпилированные бинарники](http://narod.ru/disk/18403385000/example1.bin.7z.html) (сама программ+OgreMain.dll+RenderSystem\_Direct3D9.dll)
В следующей статье расскажу о создание простейший сцены в огре. | https://habr.com/ru/post/86017/ | null | ru | null |
# Code-review тестового задания junior react разработчиков
Что это такое?
--------------
Это код-ревью решений [второго тестового задания](https://github.com/maxfarseer/tz-webinars/tree/tz-2-react-redux-router-async). На видео отмечены удачные решения и указаны ошибки, а так же советы по их исправлению. В данной заметке отмечены общие проблемы и даны ссылки с "отметкой времени".
**Видео**
Общие проблемы
--------------
* Плохое Readme;
* Остаются eslint предупреждения, лишние `console.log` (redux-логгер не в счет);
* Иконка Web не вынесен вперед (невнимательное чтение задачи);
* Иконка Web выносится вперед в компоненте (а лучше бы в редьюсере, или экшене);
* Пароль не очищается, если запрос вернулся с ошибкой;
* Submit кнопка в форме логина доступна, если поля пустые (или одно из полей);
* Submit кнопка в форме логина не поддерживает нажатие Enter;
* Нет деления на компоненты/контейнеры (не относится к тем, кто делил по другим подходам);
* URL-адрес для запросов на сервер полностью передается (нет оформления повторяющейся части строки в константу);
* Ошибка/уведомление "неправильное имя пользователя/пароль" — не очищается;
* Ошибка "неправильное имя пользователя/пароль" — выводится константой с сервера;
* Текст ошибки "захардкожен" в коде. Нет обращения в словарик по константе с сервера;
* Не удален "старый код", то есть такой код, который нигде не используется;
* Нет блока catch у промисов, нет обработки ошибок, если сервер отвечает не `ok`;
* Компоненты размещены в node\_modules;
* Отсутствуют или недостаточно подробно описаны Prop Types.
* Экшены и редьюсеры в куче в одном файле (или в одном все экшены, в другом все редьюсеры). Нет деления на "модули", то есть каждой сущности — свои экшены и свои редьюсеры;
Все решения с отметками по времени
----------------------------------
Здесь указаны только ошибки, и **не отмечены** хорошие моменты, которых великое множество, поэтому крайне рекомендую посмотреть все подряд тем, кто считает себя "джуном" в разработке на react.
---
[6m00s](https://youtu.be/EWaNgM4mv-A?t=6m00s) — Артур Донковцев [Commit](https://github.com/DonkovtsevArthur/testTask/tree/4dbebf493427450e310591ad72cf51150c7c57c6)
[7m40s](https://youtu.be/EWaNgM4mv-A?t=7m40s) — опечатка в названии функции
[8m07s](https://youtu.be/EWaNgM4mv-A?t=8m07s) — асинхронные запросы не вынесены в экшены
---
[9m30s](https://youtu.be/EWaNgM4mv-A?t=9m30s) — Павел Пимкин [Commit](https://github.com/paxarpp/react_training/tree/26d8d60b424742415be38deb76afc4d682bc6cfc)
[10m07s](https://youtu.be/EWaNgM4mv-A?t=10m07s) — все экшены в одном файле. Нет деления на модули.
[10m25s](https://youtu.be/EWaNgM4mv-A?t=10m25s) — вынос иконки (перебор данных) сделан в компоненте. Лучше в редьюсере или экшене.
---
[11m42s](https://youtu.be/EWaNgM4mv-A?t=11m42s) Сергей ZackFox [Commit](https://github.com/ZackFox/frontend-react-jt2/tree/f92b48d988f250ef3feb16a4270f8437c8f1f3ee)
[12m28s](https://youtu.be/EWaNgM4mv-A?t=12m28s) — "прикольные" надписи. Лучше делать "нейтрально", чтобы затем подобные задания можно было сразу посылать работодателю.
[13m05s](https://youtu.be/EWaNgM4mv-A?t=13m05s) — лишний экшен, указывающий что "загрузка" завершилась. То есть вместо трех экшенов: REQUEST / SUCCESS / STOP, можно уложиться в два: REQUEST / SUCCESS.
---
[16m16s](https://youtu.be/EWaNgM4mv-A?t=16m16s) — Дмитрий Петров [Commit](https://github.com/Junglecrew/Forge-2/tree/765d97ddee2437bd2dae2480dc2a4724f89684fa)
[18m16s](https://youtu.be/EWaNgM4mv-A?t=18m16s) — использование var
[18m34s](https://youtu.be/EWaNgM4mv-A?t=18m34s) — не вынесена часть URL адреса в константу
---
[21m15s](https://youtu.be/EWaNgM4mv-A?t=21m15s) — Ефим Хлебный [Commit](https://github.com/Chicloon/react-test/tree/de178ab0988a02d8a800b65516eb0c4fd2d2ef7b)
[21m17s](https://youtu.be/EWaNgM4mv-A?t=21m17s) — плохое сообщение в коммите
[22m15s](https://youtu.be/EWaNgM4mv-A?t=22m15s) — одинаковые названия экшенов.
---
[24m16s](https://youtu.be/EWaNgM4mv-A?t=24m16s) — Кацура Владислав [Commit](https://github.com/missilev/Maxpfrontend-Test-Task-2/tree/cbc20fb02f54230c81c8bf46109684f4f8c05d00)
[25m17s](https://youtu.be/EWaNgM4mv-A?t=25m17s) — (не ошибка) — данные приготовлены в редьюсере
[27m38s](https://youtu.be/EWaNgM4mv-A?t=27m38s) — использование `e.target`, лучше `e.currentTarget`
[28m20s](https://youtu.be/EWaNgM4mv-A?t=28m20s) — `==`, а надо бы `===`
[28m33s](https://youtu.be/EWaNgM4mv-A?t=28m33s) — использование componentWillUnmount
[29m00s](https://youtu.be/EWaNgM4mv-A?t=29m00s) (не ошибка) — рассуждение про "до серверную валидацию".
[30m05s](https://youtu.be/EWaNgM4mv-A?t=30m05s) — код не отфморатирован (на любителя)
---
[30m33s](https://youtu.be/EWaNgM4mv-A?t=30m33s) — Максим Сафин [Commit](https://github.com/A4ron5/apptest/tree/71d57ea574b5c1197d4ea45887523a1cab4440c9)
[31m35s](https://youtu.be/EWaNgM4mv-A?t=31m35s) — использование "не универсального" обработчика, там где это уместно.
---
[32m02s](https://youtu.be/EWaNgM4mv-A?t=32m02s) — Сергей Regies Linkas [Commit](https://github.com/sinneren/tz-webinars/tree/04c84bdac0466e5b85b9607f554cc5e63a42dc41)
[33m42s](https://youtu.be/EWaNgM4mv-A?t=33m42s) — нет экшена для прелоадера
[34m30s](https://youtu.be/EWaNgM4mv-A?t=34m30s) — порядок методов в компоненте. ([eslint плагин](https://github.com/yannickcr/eslint-plugin-react/blob/master/docs/rules/sort-comp.md))
[35m30s](https://youtu.be/EWaNgM4mv-A?t=35m30s) — не существующий PropTypes
---
[35m57s](https://youtu.be/EWaNgM4mv-A?t=35m57s) — Кононов Виталий [Commit](https://github.com/vital2207/ReactTestProject/tree/d0d8308eb21af0392c38965598f843e2dbfbc1e5)
---
[38m02s](https://youtu.be/EWaNgM4mv-A?t=38m02s) — Ренат Рысаев [Commit](https://github.com/RenatRysaev/knowledge-test/tree/c4a31d57689f12637820b9868e57369ab4c15e13)
[39m45s](https://youtu.be/EWaNgM4mv-A?t=39m45s) — не делаем то, что не интересно
---
[40m31s](https://youtu.be/EWaNgM4mv-A?t=40m31s) — Евгений Санжиев [Commit](https://github.com/seaone/react-test/tree/f72e490a9d0a12f99c55ae3fb35b54757b835cfa)
[41m20s](https://youtu.be/EWaNgM4mv-A?t=41m20s) (не ошибка) — словарик для работы с ошибками
---
[42m46s](https://youtu.be/EWaNgM4mv-A?t=42m46s) — Виталий Набережный [Commit](https://github.com/vvnab/maxpfrontend/tree/9e7b689ff5cf8f546ef73fac7fe6a5fc805a3a65)
[42m54s](https://youtu.be/EWaNgM4mv-A?t=42m54s) — не убраны тестовые данные
---
[44m50s](https://youtu.be/EWaNgM4mv-A?t=44m50s) — Вениамин Трепачко [Commit](https://github.com/miniven/news-tutorial/tree/34b82a5a505b45535f7ec1f0f476cb8d70fca298)
Ачивка: очень классный дизайн.
[47m42s](https://youtu.be/EWaNgM4mv-A?t=47m42s) — redux версия не полноценная.
---
[47m57s](https://youtu.be/EWaNgM4mv-A?t=47m57s) — Ingvarr6 (Игорь) [Commit](https://github.com/ingvarr6/Test_2/tree/ebe89e4739a14ef1987740082cb5c0a455656c39)
[48m21s](https://youtu.be/EWaNgM4mv-A?t=48m21s) — нет 404 роута
---
[51m20s](https://youtu.be/EWaNgM4mv-A?t=51m20s) — Екатерина Н [Commit](https://github.com/NKaty/React_test_task2_maxpfrontend/tree/3df7c3f033cc0b659ba15e4e3b4ca5735d8b837d)
[51m30s](https://youtu.be/EWaNgM4mv-A?t=51m30s) — не очищается ошибка
---
[54m48s](https://youtu.be/EWaNgM4mv-A?t=54m48s) — Роман Палесика [Commit](https://github.com/shesperfect/paca/tree/2973b398b5566c4d4a4a3ae0ef6e2a9b1605afbb)
[55m30s](https://youtu.be/EWaNgM4mv-A?t=55m30s) — не хватает экшенов на загрузку/ошибку
[56m49s](https://youtu.be/EWaNgM4mv-A?t=56m49s) — использование side-effects в редьюсере
[58m10s](https://youtu.be/EWaNgM4mv-A?t=58m10s) — (не ошибка) вынос иконки web с помощью css (sick!)
---
[58m53s](https://youtu.be/EWaNgM4mv-A?t=58m53s) — Умяр Юсупов [Commit](https://github.com/umyar/react/tree/78c8887e0479c565568101aeffb3ef265efd3539)
[59m15s](https://youtu.be/EWaNgM4mv-A?t=59m15s) — использование callback'a в setState, что приводит к лишней перерисовке. Лучше валидировать прямо в рендере.
[61m01s](https://youtu.be/EWaNgM4mv-A?t=61m01s) — неуместное использование else if
---
[62m13s](https://youtu.be/EWaNgM4mv-A?t=62m13s) — dsfcv d (boortcore) [Commit](https://github.com/Boortcore/tz-webinars/tree/c8af4f7b247bd9ca555641ee8e0d7de1b1907425)
---
[63m15s](https://youtu.be/EWaNgM4mv-A?t=63m15s) Константин Липский [Commit](https://github.com/KonstantinLypskyi/TZ_2/tree/4c283d96e2779a4688155faa2a3d84a896571892)
[65m11s](https://youtu.be/EWaNgM4mv-A?t=65m11s) — в экшен передается URL целиком, лучше просто id передавать в данном варианте.
---
[67m14s](https://youtu.be/EWaNgM4mv-A?t=67m14s) — Ikaow Ikaow [Commit](https://github.com/ikaow/front/tree/aa27bef13c475de0ecebcba17f0e053fff302617)
[67m50s](https://youtu.be/EWaNgM4mv-A?t=67m50s) — сложное условие в shouldComponentUpdate, можно проще (сразу проверить на props.data и все)
[69m32s](https://youtu.be/EWaNgM4mv-A?t=69m32s) — `e.preventDefault` не первый в обработчике
---
[70m01s](https://youtu.be/EWaNgM4mv-A?t=70m01s) — Ali Gasymov [Commit](https://github.com/alik0211/socgram/tree/109f8cd7e976a8f9e442aa68c0027cfaaeea7df2)
---
[71m50s](https://youtu.be/EWaNgM4mv-A?t=71m50s) — Ахметанов Альберт [Commit](https://github.com/adacs897642/react_test_pr/tree/cb6ace56b9b4f5d8650dc395255fc2b858ed0558)
[72m20s](https://youtu.be/EWaNgM4mv-A?t=72m20s) — компоненты в node\_modules
[73m15s](https://youtu.be/EWaNgM4mv-A?t=73m15s) — дублирование обращений к переменным
---
[74m04s](https://youtu.be/EWaNgM4mv-A?t=74m04s) — Женя Белый [Commit](https://github.com/white1984j/task-from-maxpfrontend/tree/e07405396f6188fb679250dfbb9e28863d5027c7)
[76m04s](https://youtu.be/EWaNgM4mv-A?t=76m04s) — privateRoute не вынесен в отдельный компонент
[76m33s](https://youtu.be/EWaNgM4mv-A?t=76m33s) — сложный код для перемещения иконки web
[76m56s](https://youtu.be/EWaNgM4mv-A?t=76m56s) — избыточное свойство *loaded*
---
[77m35s](https://youtu.be/EWaNgM4mv-A?t=77m35s) — Аладьин Александр [Commit](https://github.com/sanchos86/test-2/tree/161e01e0c440763476f4f8bd207c2a620f94d1f8)
[80m33s](https://youtu.be/EWaNgM4mv-A?t=80m33s) — ошибка не вынесена в словарик
---
[81m19s](https://youtu.be/EWaNgM4mv-A?t=81m19s) — Misha Mihail [Commit](https://github.com/MichaelSedov/frontend-react-test2/tree/90d75e3a36e6bddbc2afb6723fa8a37682d1e207)
[81m43s](https://youtu.be/EWaNgM4mv-A?t=81m43s) — избыточное использование `withRouter`
---
[83m04s](https://youtu.be/EWaNgM4mv-A?t=83m04s) — Dmitrii Shapovalenko [Commit](https://github.com/ShapovalenkoD/react-authorization-test/tree/943eb5e5f7461d2ecfa7d60db3dbacaa373c2f0e)
---
[84m00s](https://youtu.be/EWaNgM4mv-A?t=84m00s) — Даниил [Commit](https://github.com/skyskysky11/tz2/tree/67ae81378a0bcd48e89d5923a0534c86e24ac19e)
[84m58s](https://youtu.be/EWaNgM4mv-A?t=84m58s) — избыточное деление экшенов
[85m55s](https://youtu.be/EWaNgM4mv-A?t=85m55s) — ошибка в названии lifecycle-метода
---
[86m58s](https://youtu.be/EWaNgM4mv-A?t=86m58s) — Порошин Роман [Commit](https://github.com/mkitez/react-redux-test-app/tree/4e6c62cf6f464ba2b679cb38e43d5c6fd64adf66)
[87m15s](https://youtu.be/EWaNgM4mv-A?t=87m15s) — семантически неверное использование тэга `article`
[90m46s](https://youtu.be/EWaNgM4mv-A?t=90m46s) — лишний вызов метода массива
---
[91m10s](https://youtu.be/EWaNgM4mv-A?t=91m10s) — Артем Бочков [Commit](https://github.com/artbocha/react-redux-test-task-2/tree/146f0d4f1972aaa325318fb630d432b384c61540) | https://habr.com/ru/post/413135/ | null | ru | null |
# Лучшая приоритизация HTTP/2 для ускорения веба
HTTP/2 обещал заметно ускорить веб, и Cloudflare давным-давно развернула доступ по HTTP/2 для всех клиентов. Но одна особенность HTTP/2, приоритизация, не соответствовала ожиданиям. Не потому, что она принципиально сломана, а из-за реализации в браузерах.
Сегодня Cloudflare предлагает изменить приоритизацию HTTP/2, что даёт нашим серверам контроль над решениями о приоритизации, которые действительно заметно ускоряют интернет.
Исторически именно браузер контролирует, как и когда загружать веб-контент. Сегодня для всех платных планов мы вносим радикальные изменения в эту модель. Они передают контроль напрямую владельцу сайта. На вкладке «Скорость» в панели мониторинга Cloudflare клиенты могут включить «Расширенную приоритизацию HTTP/2»: она переопределяет настройки браузера по умолчанию на улучшенную схему планирования, что значительно ускоряет доступ для посетителей (в некоторых случаях мы видели ускорение на 50%). С воркерами Cloudflare владельцы сайтов могут пойти ещё дальше и полностью подобрать настройки под свои конкретные нужды.
Нынешняя ситуация
=================
Веб-страницы состоят из [десятков (иногда сотен)](https://discuss.httparchive.org/t/whats-the-distribution-of-requests-per-page/21/10?u=patmeenan) отдельных ресурсов, которые загружаются и собираются браузером в конечный отображаемый контент. Это включает в себя видимый контент, с которым взаимодействует пользователь (HTML, CSS, изображения), а также логику приложения (JavaScript) для самого сайта, рекламу, аналитику и маркетинговые следящие маячки. С точки зрения пользователя очень важна последовательность, в которой загружаются эти ресурсы: это влияет на время, когда он увидит содержимое и сможет взаимодействовать со страницей.
Браузер — это, по сути, движок обработки HTML, который проходит через HTML-документ и следует инструкциям по порядку: от начала до конца HTML, выстраивая страницу по мере продвижения. Ссылки на таблицы стилей (CSS) сообщают браузеру, как стилизовать содержимое страницы, и браузер задержит отображение контента до тех пор, пока не загрузит таблицу стилей. У скриптов на странице могут быть разные варианты поведения. Если скрипт помечен как «асинхронный» или «отложенный», браузер может продолжать обработку документа и просто запустить скрипт, когда он станет доступен. Если скрипт не помечен как асинхронный или отложенный, браузер [ДОЛЖЕН](https://html.spec.whatwg.org/) прекратить обработку документа до тех пор, пока скрипт не загрузится и не выполнится. Такие скрипты называются «блокирующими», поскольку они блокируют браузеру возможность продолжать обработку документа.
HTML-документ делится на две части. Заголовок документа находится в начале и содержит таблицы стилей, скрипты и другие инструкции для браузера, необходимые для отображения содержимого. После заголовка идёт тело документа , оно содержит фактический контент, отображаемый в окне браузера (хотя скрипты и таблицы стилей также могут быть в теле). Пока браузер не доберётся до тела документа, пользователю нечего показывать, и страница останется пустой. Поэтому важно как можно быстрее обработать заголовок. Если вам интересны подробности, на сайте *HTML5 Rocks* есть [отличный учебник](https://www.html5rocks.com/en/tutorials/internals/howbrowserswork/), как работают браузеры.
Браузер обычно отвечает за порядок загрузки различных ресурсов, необходимых для построения страницы и дальнейшей обработки документа. В HTTP/1.x действуют ограничения, сколько объектов браузер может запросить с любого сервера за один раз (обычно 6 подключений и только один ресурс за раз на соединение), поэтому порядок запросов строго контролируется браузером. В HTTP/2 ситуация совершенно иная. Браузер может запросить сразу все ресурсы (по крайней мере, как только узнает о них), и предоставляет серверу подробные инструкции, как доставлять эти ресурсы.
Оптимальный порядок загрузки ресурсов
=====================================
Для большинства частей в цикле загрузки страницы есть оптимальный порядок, который максимально ускоряет доступность страницы для пользователя (а разница между оптимальным и неоптимальным порядком загрузки может достигать 50% и более).
Как описано выше, прежде чем браузер сможет отобразить какой-либо контент, его блокируют CSS и JavaScript в разделе . На этом этапе выгоднее задействовать 100% канала для загрузки блокирующих ресурсов, а не загружать их по порядку, как они прописаны в HTML-коде. Это позволяет браузеру анализировать и запускать каждый элемент во время загрузки следующего блокирующего ресурса, что создаёт оптимальный конвейер.
Время загрузки скриптов при параллельной или последовательной загрузке не отличается, но при последовательной загрузке первый скрипт можно обработать и выполнить во время загрузки второго.
После загрузки блокирующих ресурсов ситуация становится немного интереснее. Здесь оптимальная загрузка может зависеть от конкретного сайта или даже бизнес-приоритетов (выбор пользовательского контента или рекламы, или аналитики и т. д.). Отдельная проблема со шрифтами, поскольку браузер обнаруживает нужные шрифты после применения таблицы стилей к отображаемому контенту. Поэтому к моменту, когда браузер узнает о шрифте, необходимо отобразить текст, который уже готов к выводу на экран. Любые задержки в загрузке шрифта приводят к отсутствию текста на экране (или текст отображается неправильным шрифтом).
Как правило, необходимо учитывать некоторые компромиссы:
* Пользовательские шрифты и изображения в видимой части страницы (viewport) следует загрузить как можно быстрее. Они напрямую влияют на визуальный опыт пользователя при загрузке страницы.
* Неблокирующий JavaScript следует загружать последовательно относительно других ресурсов JavaScript, чтобы выполнение каждого из них можно было поставить в конвейер. JavaScript может включать пользовательскую логику приложений, а также маячки отслеживания для аналитики и маркетинга, а их задержка может привести к снижению показателей, отслеживаемых бизнесом.
* Изображения можно загружать параллельно. Первые несколько байт файла изображения содержат его размеры, что может понадобиться для макета браузера, а параллельная загрузка прогрессивных изображений может обеспечить визуальную завершённость после передачи примерно всего 50% общего объёма.
С учётом компромиссов, в большинстве случаев хорошо работает такая стратегия:
* Пользовательские шрифты загружаются последовательно и делят доступную полосу пропускания с изображениями в области видимости.
* Видимые изображения загружаются параллельно, разделяя между собой часть полосы пропускания, выделенную на них.
* Когда больше нет шрифтов или видимых изображений:
+ Неблокирующие скрипты загружаются последовательно и разделяют доступную полосу пропускания с невидимыми изображениями (которые находятся вне области видимости).
+ Невидимые изображения загружаются параллельно, разделяя между собой часть полосы пропускания, выделенную на них.
Таким образом, видимый пользователю контент загружается как можно быстрее, логика приложения задерживается по минимуму, а невидимые изображения загружаются таким образом, чтобы как можно быстрее завершить макет.
Пример
======
Для иллюстрации используем упрощённую страницу категории продукта с типичного сайта электронной коммерции:
* **Синий** — HTML-файл самой страницы.
* **Зелёный** — Одна внешняя таблица стилей (CSS-файл).
* **Оранжевый** — Четыре внешних скрипта (JavaScript). Два блокирующих скрипта в начале страницы и два асинхронных. Блокирующие скрипты показаны более тёмным оттенком оранжевого.
* **Красный** — один пользовательский веб-шрифт.
* **Фиолетовый** — 13 изображений. В окне просмотра отображаются логотип страницы и четыре изображения продукта, ещё 8 изображений продукта требуют прокрутки. Пять видимых изображениях обозначены более тёмным оттенком фиолетового.
Для простоты предположим, что у всех ресурсов одинаковый размер и каждый загружается за 1 секунду. Загрузка всех ресурсов занимает в общей сложности 20 секунд, но крайне важны порядок и метод загрузки.
Вот как будет выглядеть в браузере оптимальная загрузка ресурсов:
* Страница пуста в течение первых 4 секунд, пока загружаются HTML, CSS и блокирующие скрипты: все они используют 100% соединения.
* На 4-секундной отметке фон и структура страницы отображаются без текста или изображений.
* Через секунду, на отметке в 5 секунд, отображается текст страницы.
* В промежутке 5−10 секунд загружаются изображения, сначала размытые, но очень быстро они становятся чёткими. Примерно на 7 секунде результат почти неотличим от окончательной версии.
* На отметке 10 секунд завершена загрузка всего визуального содержимого в видимой части страницы.
* В течение следующих двух секунд загружается и выполняется асинхронный JavaScript, выполняя любую некритическую логику (аналитика, маркетинговые теги и т. д.).
* В течение последних 8 секунд загружаются остальные изображения на случай прокрутки страницы пользователем.
Текущая приоритизация в браузерах
=================================
Все текущие браузерные движки реализуют [различные стратегии приоритизации](https://calendar.perfplanet.com/2018/http2-prioritization/), ни одна из которых не является оптимальной.
**Microsoft Edge и Internet Explorer** [не поддерживают приоритизацию](https://calendar.perfplanet.com/2018/http2-prioritization/#microsoft_edge_internet_explorer), поэтому работают с настройками HTTP/2 по умолчанию, который всё загружает параллельно, равномерно распределяя пропускную способность между всеми ресурсами. Microsoft Edge в будущих версиях переходит к использованию движка Chromium, что может улучшить ситуацию. Но пока в нашем примере браузер большую часть времени застрянет в заголовке страницы, так как изображения замедляют передачу блокирующих скриптов и таблиц стилей.
Визуально это приводит к довольно болезненному опыту: пользователь в течение 19 секунд смотрит на пустой экран, а затем происходит задержка на 1 секунду для отображения текста. При просмотре анимации внизу будьте терпеливы, потому что в течение 19 секунд может показаться, что на пустом экране ничего не происходит (хотя так и есть):
**Safari** [загружает все ресурсы параллельно](https://calendar.perfplanet.com/2018/http2-prioritization/#safari), разделяя пропускную способность на основе их важности, по мнению Safari (блокирующие ресурсы, такие как скрипты и таблицы стилей, важнее, чем изображения). Изображения загружаются параллельно, но также одновременно с блокирующим контентом.
Хотя Safari похож на Edge в том смысле, что всё загружается одновременно, но выделение большей полосы для блокирующих ресурсов позволяет отобразить контент намного раньше:
* Примерно через 8 секунд завершается загрузка таблицы стилей и скриптов, поэтому можно начинать рендеринг страницы. Поскольку изображения загружались параллельно, их тоже можно отобразить частично (размыто для прогрессивных изображений). Это всё ещё в два раза медленнее оптимального сценария, но намного лучше, чем в Edge.
* Примерно через 11 секунд загружается шрифт. Можно отобразить текст. К этому моменту загружается больше данных для изображений, и они становятся немного резче. Это сопоставимо с ситуацией в районе 7-секундной отметки для оптимального сценария загрузки.
* В течение оставшихся 9 секунд изображения становятся более чёткими, поскольку загружается больше данных, пока, наконец, процесс не завершается за 20 секунд.
**Firefox** создаёт дерево зависимостей, которое группирует ресурсы, а затем планирует группы либо загружать одну за другой, либо совместно разделить пропускную способность между группами. В пределах данной группы ресурсы совместно используют пропускную способность и загружаются одновременно. Изображения планируется загружать после таблиц стилей, блокирующих рендеринг, и загружать параллельно, но сценарии и таблицы стилей, блокирующие рендеринг, также загружаются параллельно и не получают преимуществ конвейерной обработки.
В нашем примере это происходит немного быстрее, чем в Safari, так как изображения ждут завершения загрузки таблиц стилей:
* На отметке 6 секунд исходный контент страницы отображается с фоном и размытыми версиями изображений продукта (по сравнению с 8 секундами у Safari и 4 секундами в оптимальном случае).
* На 8 секунде загрузился шрифт, и можно отобразить текст вместе с немного более чёткими изображениями продукта (по сравнению с 11 секундами у Safari и 7 секундами в оптимальном случае).
* В течение оставшихся 12 секунд изображения становятся более чёткими по мере загрузки оставшегося содержимого.
**Chrome** (и все браузеры на основе Chromium) приоритизирует ресурсы по [списку](https://calendar.perfplanet.com/2018/http2-prioritization/#chrome). Это очень хорошо работает для блокирующих ресурсов, которые оптимально загружать по порядку, но не так хорошо для изображений. Каждое изображение загружается до 100% перед началом загрузки следующего.
На практике это почти оптимальный сценарий загрузки, с той лишь разницей, что изображения загружаются по одному, а не параллельно:
* До отметки 5 секунд загрузка Chrome идентична оптимальному сценарию, отображая фон на 4-й секунде и текстовое содержимое на 5-й.
* В течение следующих 5 секунд изображения области видимости загружаются по одному, пока процесс не завершится на отметке 10 секунд (по сравнению с оптимальным сценарием, когда они отображаются в немного размытом виде на отметке 7 секунд и становятся более чёткими в течение оставшихся трёх секунд).
* После завершения визуальной части страницы за 10 секунд (идентично оптимальному сценарию), оставшиеся 10 секунд тратятся на запуск асинхронных скриптов и загрузку скрытых изображений (так же, как и в оптимальном сценарии).
Визуальное сравнение
====================
Визуальная разница довольно сильно отличается, хотя технически загрузка всего контента занимает одинаковое время:
Приоритизация на стороне сервера
================================
Приоритизация HTTP/2 запрашивается клиентом (браузером), и сервер должен решить, что делать на основе запроса. [Большое количество серверов не вообще не поддерживают эту функцию](https://github.com/andydavies/http2-prioritization-issues), а остальные выполняют запрос клиента. Другой вариант — принять решение о наилучшей приоритизации на стороне сервера с учётом запроса клиента.
Согласно [спецификации](https://http2.github.io/http2-spec/#StreamPriority), приоритизация HTTP/2 — это дерево зависимостей, которое требует полного знания всех текущих запросов, чтобы иметь возможность приоритизировать ресурсы друг относительно друга. Это позволяет реализовать невероятно сложные стратегии, но такое трудно хорошо реализовать на стороне браузера или сервера (о чём свидетельствуют различные стратегии браузера и различные уровни поддержки сервера). Чтобы упростить управление приоритизацией, мы разработали более простую схему, которая по-прежнему обладает всей гибкостью, необходимой для оптимального планирования.
Схема приоритизации Cloudflare состоит из 64 приоритетных «уровней», а внутри каждого уровня есть группы ресурсов, которые определяют, как разделить между собой соединение:
Сначала скачиваются все ресурсы на более высоком уровне приоритета, затем происходит переход на более низкий уровень.
В пределах заданного уровня приоритета существует три различных группы параллелизма (concurrency):
* **0**: все ресурсы в группе “0” отправляются последовательно в том порядке, в котором они были запрошены, используя 100% пропускной способности. Только после загрузки всех ресурсов группы “0” рассматриваются другие группы на том же уровне.
* **1**: все ресурсы в группе параллелизма “1” отправляются последовательно в том порядке, в котором были запрошены. Доступная полоса пропускания равномерно распределяется между группой параллелизма “1” и группой параллелизма “n”.
* **n**: ресурсы в группе параллелизма “n” передаются параллельно, разделяя между собой доступную пропускную способность.
На практике группа параллелизма “0” полезна для критического контента, который необходимо обрабатывать последовательно (скрипты, CSS и т. д.). Группа “1” полезна для менее важного контента, который может совместно использовать пропускную способность с другими ресурсами, но где сами ресурсы по-прежнему выигрывают от последовательной обработки (асинхронные скрипты, непрогрессивные изображения и т. д.). Группа параллелизма “n” полезна для ресурсов, которые выигрывают от параллельной обработки (прогрессивные изображения, видео, аудио и т. д.).
Приоритизация по умолчанию в Cloudflare
=======================================
При опции расширенной приоритизации реализуется «оптимальный» порядок загрузки ресурсов, описанный выше. Применяемые конкретные приоритеты выглядят следующим образом:
Эта схема позволяет последовательно отправлять ресурсы, блокирующие рендеринг, затем параллельно отправлять видимые изображения, а потом — остальную часть содержимого страницы с некоторым уровнем совместного использования полосы для балансировки загрузки приложения и содержимого. Предостережение *\* If Detectable* заключается в том, что не все браузеры различают различные типы таблиц стилей и скриптов, но всё равно это будет значительно быстрее во всех случаях. Ускорение на 50%, особенно для посетителей Edge и Safari, не станет чем-то необычным:
[](https://habrastorage.org/webt/u_/1n/px/u_1npxrzhg0svmgdyzelnamxj84.png)
Настройка приоритизации с воркерами
===================================
Более быстрая работа по умолчанию — это отлично, но всё становится действительно интересным благодаря возможности настройки приоритизации с поддержкой Cloudflare Workers, так что сайты могут переопределить приоритет по умолчанию для ресурсов или реализовать свои собственные схемы приоритизации.
Если воркер добавляет к ответу заголовок `cf-priority`, то граничные серверы Cloudflare применят указанный приоритет и параллелизм. Формат заголовка — /, поэтому заголовок `response.headers.set('cf-priority', “30/0”);` установит для данного ответа приоритет 30 и параллелизм 0. Аналогично, “30/1” установит параллелизм “1”, а “30/n” установит параллелизм на n.
С такой гибкостью сайт может настроить произвольный приоритет ресурсов для своих потребностей. Например, повысить приоритет некоторых важных асинхронных скриптов или главных изображений: они скачаются ещё до того, как браузер определил, что они находятся в зоне видимости.
Для информирования о решениях приоритизации рантайм воркеров также указывает запрошенную браузером информацию о приоритизации в объекте запроса, который передаётся приёмнику событий воркера (request.cf.requestPriority). Входящие приоритеты представляют собой список атрибутов, разделённых точкой с запятой. Он выглядит примерно так: `weight=192;exclusive=0;group=3;group-weight=127`.
* **weight**: вес для приоритизации HTTP/2.
* **exclusive**: эксклюзивный флаг HTTP/2 (1 для браузеров на основе Chromium, 0 для других).
* **group**: идентификатор потока HTTP/2 для группы запросов (ненулевой для Firefox).
* **group-weight**: вес HTTP/2 для группы запросов (ненулевой для Firefox).
Это только начало
=================
Способность настраивать и контролировать приоритетность ответов является основным строительным блоком для большой будущей работы. Мы намерены внедрять собственные передовые оптимизации поверх этой, но с поддержкой воркеров все сайты и исследователи могут экспериментировать с различными стратегиями приоритизации. Через Apps Marketplace компании также могут создавать новые сервисы оптимизации поверх рабочей платформы и предоставлять их для использования другим сайтам.
Если вы находитесь на плане Pro или выше, перейдите на вкладку «Скорость» в панели мониторинга Cloudflare и включите «расширенную приоритизацию HTTP/2» для ускорения своего сайта.
 | https://habr.com/ru/post/452020/ | null | ru | null |
# SPM: модуляризация проекта для увеличения скорости сборки
Привет, Хабр! Меня зовут [Эрик Басаргин](https://twitter.com/Puasonych), я iOS-разработчик в [Surf](https://surf.ru/).
На одном большом проекте мы столкнулись с низкой скоростью сборки — от трёх минут и более. Обычно в таких случаях студии практикуют модуляризацию проектов, чтобы не работать с огромными монолитами. Мы в Surf решили поэкспериментировать и модуляризовать проект с помощью Swift Package Manager — менеджера зависимостей от Apple.
О результатах [разработки приложения](https://surf.ru/) расскажем в другой статье, а сейчас ответим на главные вопросы: зачем это всё нужно, почему мы выбрали SPM и как делали первые шаги.
Почему именно SPM
-----------------
Ответ прост — это нативно и ново. Он не создает overhead в виде xcworkspace, как Cocoapods, к примеру. К тому же SPM — [open-source проект](https://github.com/apple/swift-package-manager), который активно развивается. Apple и сообщество исправляют в нем баги, устраняют уязвимости, обновляют вслед за Swift.
Делает ли это сборку проекта быстрее
------------------------------------
Теоретически сборка ускорится из-за самого факта разделения приложения на модули — framework'и. Это значит, что каждый модуль будет собираться только в том случае, когда в него внесли изменения. Но утверждать точно можно будет только по окончанию эксперимента.
*Note: Эффективность модуляризации напрямую зависит от правильного разбиения проекта на модули.*
Как сделать эффективное разбиение
---------------------------------
Метод разбиения зависит от выбранной архитектуры, типа приложения, его объема и планов на дальнейшее развитие. Поэтому я расскажу о трёх правилах, которых мы стараемся придерживаться при разбиении.
**Разделять обобщённую функциональность.** Каждый модуль отвечает за какую-то категорию, к примеру:
* CommonAssets — набор ваших Assets'ов и public интерфейс для доступа к ним. Обычно он генерируется с помощью SwiftGen.
* CommonExtensions — набор расширений, к примеру Foundation, UIKit, дополнительные зависимости.
**Разделять flow'ы приложения.** Рассмотрим древовидную структуру, где MainFlow — главное flow приложения. Представим, что у нас новостное приложение.
* NewFlow — экраны новостей и обзора конкретной новости.
* FavoritesFlow — экран со списком избранных новостей и экран обзора конкретной новости с дополнительным функционалом.
* SettingsFlow — экраны настроек приложения, аккаунта, категорий и т. д.
**Выносить reusable компоненты в отдельные модули:**
* CommonUIComponents — модуль, который содержит в себе любые небольшие UI-компоненты. Обычно они влезают в один файл.
* Далее список бесконечен и зависит от количества внутренних кастомных UI компонентов. К примеру, нужно создать модули для генерации экранов результата, кастомной коллекции, билдера кастомных алертов и т. д.
Когда нужно выносить компонент в отдельный модуль
-------------------------------------------------
Допустим, у нас есть конкретный flow, и мы хотим добавить в него новые функции. Если компонент будет переиспользоваться или это теоретически возможно в будущем — лучше вынести его в отдельный модуль или аналог CommonUIComponents. В других случаях можно оставить компонент локальным.
Такой подход решает проблему с потерей компонентов. Это происходит в больших проектах, и если компонент не задокументировали, то его поддержка и отладка впоследствии станет убыточной.
Создаём проект с использованием SPM
-----------------------------------
Рассмотрим создание тривиального тестового проекта. Я использую Multiplatform App project на SwiftUI. Платформа и интерфейс тут не имеют значения.
*Note: Чтобы быстро создать Multiplatform App, нужен XCode 12.2 beta.*
Создаём проект и видим следующее:
Теперь создадим первый модуль Common:
* добавляем папку Frameworks без создания директории;
* создаём SPM-пакет Common.
* Добавляем поддерживаемые платформы в файл Package.swift. У нас это `platforms: [.iOS(.v14), .macOS(.v10_15)]`
* Теперь добавляем наш модуль в каждый таргет. У нас это SPMExampleProject для iOS и SPMExampleProject для macOS.
*Note: Достаточно подключать к таргетам только корневые модули. Они не добавлены как подмодули.*
Подключение завершено. Теперь достаточно настроить модуль с public интерфейсом — и вуаля, первый модуль готов.
Как подключить зависимость у локального SPM-пакета
--------------------------------------------------
Добавим пакет AdditionalInfo — как Common, но без добавления к таргетам. Теперь изменим Package.swift у Common пакета.
Добавлять больше ничего не нужно. Можно использовать.
Пример, приближенный к реальности
---------------------------------
Подключим к нашему тестовому проекту SwiftGen и добавим модуль Palette — он будет отвечать за доступ к палитре цветов, утвержденной дизайнером.
1. Создаем новый корневой модуль по инструкции выше.
2. Добавляем к нему корневые каталоги Scripts и Templates.
3. Добавляем в корень модуля файл Palette.xcassets и пропишем какие-либо color set'ы.
4. Добавляем пустой файл Palette.swift в Sources/Palette.
5. Добавим в папку Templates шаблон [palette.stencil](https://gist.github.com/Puasonych/9a630a2d86b78fbf75b334f1dc8da783).
6. Теперь нужно прописать конфигурационный файл для SwiftGen. Для этого добавим файл swiftgen.yml в папку Scripts и пропишем в нем следующее:
```
xcassets:
inputs:
- ${SRCROOT}/Palette/Sources/Palette/Palette.xcassets
outputs:
- templatePath: ${SRCROOT}/Palette/Templates/palette.stencil
params:
bundle: .module
publicAccess: true
output: ${SRCROOT}/Palette/Sources/Palette/Palette.swift
```
*Итоговый внешний вид модуля Palette*
Модуль Palette мы с вами настроили. Теперь надо настроить запуск SwiftGen, чтобы палитра генерировалась при старте сборки. Для этого заходим в конфигурацию каждого таргета и создаем новую Build Phase — назовём ее Palette generator. Не забудьте перенести эту Build Phase на максимально высокую позицию.
Теперь прописываем вызов для SwiftGen:
```
cd ${SRCROOT}/Palette
/usr/bin/xcrun --sdk macosx swift run -c release swiftgen config run --config ./Scripts/swiftgen.yml
```
*Note: `/usr/bin/xcrun --sdk macosx` — очень важный префикс. Без него при сборке вылетит ошибка: «unable to load standard library for target 'x86\_64-apple-macosx10.15».*
*Пример вызова для SwiftGen*
Готово — доступ к цветам можно получить следующим образом:
`Palette.myGreen` (Color type in SwiftUI) и `PaletteCore.myGreen` (UIColor/NSColor).
Подводные камни
---------------
Перечислю то, с чем мы успели столкнуться.
* Всплывают ошибки архитектуры и портят всю логику разбиения на модули.
* SwiftLint & SwiftGen не уживаются вместе при подгрузке их через SPM. Причина в разных версиях yml.
* В крупных проектах не получится сразу избавиться от Cocoapods. А разбивать уже созданный проект с закреплёнными версиями подов — настоящее испытание, потому что SPM только развивается и не везде поддерживается. Но SPM и Cocoapods более-менее работают параллельно: разве что поды могут кидать ошибку «MergeSwiftModule failed with a nonzero exit code». Это происходит довольно редко, а решается очисткой и пересборкой проекта.
* На данный момент SPM не позволяет прописать пути поиска библиотек. Приходится явно указывать их с завязкой на `-L$(BUILD_DIR)`.
SPM — замена Bundler?
---------------------
В этом вопросе предлагаю помечтать и подискутировать в комментариях. Тему нужно хорошо изучить, но выглядит она очень интересно. Кстати, уже есть интересная довольно близкая [статья](https://artsy.github.io/blog/2019/01/05/its-time-to-use-spm/) о плюсах и минусах SPM.
SPM дает возможность вызывать swift run, если добавить Package.swift в корень вашего проекта. Что это нам дает? К примеру, можно вызвать fastlane или swiftlint. Пример вызова:
```
swift run swiftlint --autocorrect.
``` | https://habr.com/ru/post/527460/ | null | ru | null |
# Lazydocker — GUI для Docker прямо в терминале
Два года назад мы уже [делали](https://habr.com/ru/company/flant/blog/338332/) обзор GUI-интерфейсов для работы с Docker, однако мир любителей подобных решений не стоит на месте. На днях до версии 0.2 обновился, а вместе с тем и получил широкую огласку, молодой проект [lazydocker](https://github.com/jesseduffield/lazydocker), позиционирующий себя как «более ленивый путь управлять всем в Docker». Утилита стремительно набирает популярность — ещё вчера количество его GitHub stars не достигало 3000, а уже сегодня перевалило за 4000.
Возможности
-----------
Авторы lazydocker так поясняют появление своего детища:
> *«Запоминать команды `docker` тяжело. Запоминать алиасы чуть менее тяжело. Следить за состоянием контейнеров по многочисленным окнам терминала практически невозможно. А что, если вся требуемая информация была бы в одном окне, а каждая типовая команда — доступна по нажатию на одну клавишу (и имелась возможность добавлять свои команды)? Цель lazydocker — превратить эту мечту в реальность».*
Итак, lazydocker делает из терминала интерактивный интерфейс для Docker и Docker Compose, позволяющий быстро и удобно переключаться между сервисами, запущенными в разных контейнерах, и связанными с ними ресурсами (образами, томами), просматривать их статус и выполнять различные команды. Поскольку «иногда лучше один раз увидеть», авторы позаботились о весьма самодостаточной gif'ке-иллюстрации:
Навигация по интерфейсу поддерживается как с помощью клавиатуры, так и мыши. При выборе нужного элемента для него доступно контекстное меню:
*Пример контекстного меню для выбранного контейнера*
Как видно, для каждой команды также предопределена клавиша для быстрого выполнения популярных действий. Полный их список можно увидеть [здесь](https://github.com/jesseduffield/lazydocker/blob/master/docs/keybindings/Keybindings_en.md) (кстати, у меню есть [локализации](https://github.com/jesseduffield/lazydocker/tree/master/docs/keybindings) для нескольких языков, среди которых всё ещё отсутствует русский).
Отдельного уважения заслуживает то внимание, которое уделено просмотру состояния контейнеров: тут не только вывод логов и конфига, но и графически отображаемая статистика (по умолчанию это потребление CPU/памяти), и top процессов. Эти возможности распространяются и на произвольные метрики, для наглядного просмотра которых тоже настраиваются графики (см. секцию `stats` в [конфиге](https://github.com/jesseduffield/lazydocker/blob/master/docs/Config.md)).
Для выбранных образов можно увидеть выполняемые при их запуске команды из `Dockerfile`, унаследованные слои. Предусмотрена очистка неиспользуемых контейнеров, образов, томов (`prune`).
Доступные команды можно модифицировать, а также дополнять своими. Как это делать, легко увидеть в блоках `commandTemplates` и `customCommands` [конфига](https://github.com/jesseduffield/lazydocker/blob/master/docs/Config.md) (к слову, конфиг тоже можно редактировать прямо из самой утилиты):
```
commandTemplates:
dockerCompose: docker-compose
restartService: '{{ .DockerCompose }} restart {{ .Service.Name }}'
stopService: '{{ .DockerCompose }} stop {{ .Service.Name }}'
…
customCommands:
containers:
- name: bash
attach: true
command: docker exec -it {{ .Container.ID }} /bin/sh
serviceNames: []
…
```
Инсталляция
-----------
Lazydocker написан на Go с использованием библиотеки [gocui](https://github.com/jroimartin/gocui), предназначенной для создания консольных интерфейсов. Требуется версия Go 1.12. Исходный код распространяется на условиях свободной лицензии BSD 3-Clause (New).
Установка сводится к простой команде:
```
go get github.com/jesseduffield/lazydocker
```
В остальном — проще попробовать и увидеть своими глазами.
Перспективы
-----------
Разработкой lazydocker до сих пор преимущественно занимался один человек, но его популярность принесла «свежую кровь» в лице более широкого сообщества. Например, сейчас обсуждаются инициированные менее суток назад PR по [переработанному Dockerfile](https://github.com/jesseduffield/lazydocker/pull/36) и [упрощённой установке](https://github.com/jesseduffield/lazydocker/pull/45) бинарного релиза утилиты в Linux-дистрибутивах.
В issues проекта можно увидеть такие запросы на улучшения, как [настраиваемые keybindings](https://github.com/jesseduffield/lazydocker/issues/48) и [поддержка команды](https://github.com/jesseduffield/lazydocker/issues/47) `docker stack`. Опять же, они появились менее суток назад.
Всё это говорит о том, что уже в ближайшее время можно ожидать созревания lazydocker до более функционального и удобного решения, на которое у Docker-сообщества оказался явный спрос.
P.S.
----
Читайте также в нашем блоге:
* «[Обзор GUI-интерфейсов для управления Docker-контейнерами](https://habr.com/ru/company/flant/blog/338332/)»;
* «[docker-pretty-ps — наконец-то удобный для чтения docker ps](https://habr.com/ru/company/flant/blog/436896/)»;
* «[Шпаргалка с командами Docker](https://habr.com/ru/company/flant/blog/336654/)». | https://habr.com/ru/post/446700/ | null | ru | null |
# Установка приложений Google в эмулятор Android
В этой статье описано как установить дополнительные программы (в частности, Google Apps) в эмулятор Android. Это может понадобиться если вы хотите на эмуляторе:
1. Настроить синхронизацию с аккаунтом Google.
2. Установить календарь и календарь провайдер.
3. Установить Android Market.
4. И прочее…
Несмотря на то, что можно создать эмулятор Android с Google API, в нём отсутствуют такие важные вещи как адаптеры синхронизации контактов, календарей и прочее…
#### Подготовка
Итак, помимо Android SDK, нам понадобится:
1. [Google Apps](http://wiki.cyanogenmod.com/index.php?title=Latest_Version) (в конце, я брал от CyanogenMod 7).
2. Утилита для создания нового образа системы [mkfs.yaffs2.arm](http://code.google.com/p/android-group-korea/downloads/list?can=2&q=mkfs.yaffs2.arm&colspec=Filename+Summary+Uploaded+ReleaseDate+Size+DownloadCount).
3. Если необходимо иметь полноценную работу с календарём, то добыть Calendar.apk и CalendarProvider.apk. Их можно найти как на просторах Интернет, так и откомпилировать из исходников Android.
Для удобства в системную переменную PATH добавить пути к android-sdk\tools и android-sdk\platform-tools.
#### Создание эмулятора
Создать эмулятор со следующими параметрами:
Обратить особое внимание!
SD карту создать не менее 200Мб!
Все последующие команды предполагают, что в данный момент активен только один эмулятор. Если у вас запущено несколько эмуляторов/устройств, то к командам с утилитой adb необходимо добавлять параметр -s.
#### Подготовка к установке пакетов
Запустить эмулятор с увеличенным системным разделом
```
emulator -avd emulator_2.3.3 -partition-size 150
```
Перемонтировать системный раздел для записи (спасибо за лёгкий способ перемонтирования [ArtRoman](https://habrahabr.ru/users/artroman/)):
```
adb remount
```
Удалить пакет от SDK, который при загрузке эмулятора возвращает все настройки к дефолтным:
Войти в шелл:
```
adb shell
```
```
rm /system/app/SdkSetup.apk
```
Выйти из шелла
```
exit
```
#### Установка необходимых пакетов
Извлечь приложения из архива с Google Apps (папка system\app).
Установить пакеты:
```
adb push CarHomeGoogle.apk /system/app
adb push FOTAKill.apk /system/app
adb push GenieWidget.apk /system/app
adb push GoogleBackupTransport.apk /system/app
adb push GoogleCalendarSyncAdapter.apk /system/app
adb push GoogleContactsSyncAdapter.apk /system/app
adb push GoogleFeedback.apk /system/app
adb push GooglePartnerSetup.apk /system/app
adb push GoogleQuickSearchBox.apk /system/app
adb push GoogleServicesFramework.apk /system/app
adb push LatinImeTutorial.apk /system/app
adb push MarketUpdater.apk /system/app
adb push MediaUploader.apk /system/app
adb push NetworkLocation.apk /system/app
adb push OneTimeInitializer.apk /system/app
adb push SetupWizard.apk /system/app
adb push Talk.apk /system/app
adb push Vending.apk /system/app
```
Подобным образом устанавить дополнительные приложения (например, Calendar.apk и CalendarProvider.apk).
#### Создание нового образа системы
Загрузить в эмулятор утилиту создания образа:
```
adb push mkfs.yaffs2.arm /system/app
```
Дать права на запуск этой утилиты
```
adb shell
```
```
chmod 777 /system/app/mkfs.yaffs2.arm
```
Проверить, что все пакеты попали в /system/app:
```
ls /system/app
```
Сделать образ системы на SD карту
```
/system/app/mkfs.yaffs2.arm /system /sdcard/system.img
```
Выйти из шелла
```
exit
```
Теперь придётся набраться терпения, и слить полученный образ «adb pull /sdcard/system.img d:\temp». Скорость примерно 59Кб/с, примерно 25 минут для 100Мб образа.
Закрыть эмулятор.
Из c:\Users\\.android\avd\emulator\_2.3.3.avd\ удалить cache.img и userdata-qemu.img (если они есть). Залить в эту папку полученный образ system.img.
Эмулятор готов!
#### Первый запуск
Запустить эмулятор
```
emulator -avd emulator_2.3.3
```
Нас встречает робот
Меняем язык на русский
Войти под аккаунтом Google из этого мастера настроек у меня не получилось. Не смог выдвинуть клавиатуру :).
В итоге пришлось настраивать синхронизацию позже
#### Заключение
Вот и всё! Всем успехов в разработке! | https://habr.com/ru/post/134509/ | null | ru | null |
# Kali Linux получил режим визуальной мимикрии под Windows и другие особенности версии 2019.4
В последнем обновлении популярный среди безопасников и хакеров дистрибутив Kali Linux получил любопытный режим «Undercover» — «под прикрытием», суть которого сводится к визуальной мимикрии под графическую оболочку Windows.
*Привет, я Kali Linux!*
Сами разработчики объяснили необходимость новой фичи Kali достаточно просто: «Undercover» нужен для работы в публичных местах, чтобы при этом не смущать окружающих и не вызывать подозрений. Ведь что может быть безобиднее, чем человек, который ковыряется в ноутбуке под управлением Windows?
Так как Kali Linux популярен как среди хакеров, так и среди специалистов, проводящих независимый аудит безопасности организаций, новая фича выглядит хоть и немного нелепо, но вполне жизнеспособно. Кроме этого, [обновление Kali 2019.4](https://www.kali.org/news/kali-linux-2019-4-release/) принесло еще ряд изменений в систему, о которых ниже.
Вот краткий список обновлений:
* Новое окружение рабочего стола по умолчанию (Xfce).
* Новая тема GTK3 (для Gnome и Xfce).
* Режим «Undercover».
* Kali Documentation перемещены и теперь работают с Git.
* Public Packaging — мануал для всех желающих, как добавлять новые инструменты в Kali.
* Kali NetHunter KeX — полноценный запуск Kali из под Android.
* BTRFS во время настройки.
* Добавлен PowerShell.
* Обновление [ядра до версии 5.3.9](https://pkg.kali.org/pkg/linux).
Самый сок после режима «под прикрытием» — это Kali NetHunter KeX.
### Устройство с Kali Linux в твоем кармане
Когда вопрос касается взлома или аудита, пронести с собой собственный ноутбук не всегда представляется возможным. Намного проще со смартфоном: он не вызывает ни у кого никаких опасений.
Разработчики Kali Linux вдохновились системой, которая ранее уже была реализована на устройствах под управлением Windows Phone и реализовали запуск полноценной версии Kali Linux на устройствах под управлением Android.
*Вот как выглядел коробочный USB-хаб [Microsoft Display Dock](https://en.wikipedia.org/wiki/Microsoft_Display_Dock) для аппаратов Microsoft Nokia 950 и 950XL, который превращал смартфон в практически полноценную рабочую станцию под управлением Windows при наличии периферийных устройств. Также такие же док-станции поставлялись вместе с Microsoft Surface Go, Microsoft Surface Book 2 и другими устройствами компании, которые поддерживали стандарт [MyDP](https://en.wikipedia.org/wiki/DisplayPort)*
Для полноценного использования системы потребуется USB-хаб описанного выше типа, любая клавиатура и мышь (можно Bluetooth). По желанию можно раздобыть даже HDMI-монитор или подключиться к телевизору в конференц-зале, если вглядываться в небольшой экран нет никакого желания.
Короче говоря, возможности нового режима по обеспечению комфортной работы с борта смартфона ограничиваются лишь комплектом периферии вокруг вас в конкретный момент времени и количеством портов на USB-хабе.
Более-менее подробный мануал, который позволит разобраться с тем, как запустить NetHunter KeX на Android-устройстве, разработчики [опубликовали тут](https://www.kali.org/docs/nethunter/nethunter-kex-manager/).
### Встречайте PowerShell и новую версию ядра
Разработчики наконец-то реализовали запуск PowerShell-скриптов прямо из коробки, без каких-либо костылей и дополнительных инструментов, которые приходилось использовать ранее.
Теперь касательно ядра. Текущий релиз 2019.4 — последняя версия Kali Linux, которая будет из коробки поддерживать SD-карты объемом 8 Гб. Начиная с последующих версий дистрибутива, минимальный поддерживаемый объем будет установлен на отметке в 16 Гб. Вероятно, связано это с трудностями поддержи целого зоопарка устройств, начиная от мощных рабочих станций и заканчивая «малинкой», раритетными ПК и вообще любым устройством с ARM-процессором.
Во время тестов наблюдались некоторые проблемы с интерфейсом, так что разработчики рекомендуют дообновиться вручную:
```
apt update && apt dist-upgrade
```
А после через консоль введите:
```
rm -rf .cache/ .config/ .local/ && sync && reboot
```
Чтобы обновиться на версию 2019.4 выполните:
```
root@kali:~# cat
```
Если хотите переключиться на новый Xfce:
```
root@kali:~# apt -y install kali-desktop-xfce
```
Теперь выполним быструю проверку, на самом ли деле мы обновились до сборки 2019.4:
```
root@kali:~# grep VERSION /etc/os-release
VERSION="2019.4"
VERSION_ID="2019.4"
VERSION_CODENAME="kali-rolling"
root@kali:~#
root@kali:~# uname -v
#1 SMP Debian 5.3.9-3kali1 (2019-11-20)
root@kali:~#
root@kali:~# uname -r
5.3.0-kali2-amd64
root@kali:~#
```
Примечание: вывод «uname -r» может отличаться в зависимости от архитектуры платформы.
### Резюме
Новая версия Kali Linux и основные завезенные в него фишки ориентированы, в первую очередь, на тех специалистов, которые в ходе взломов используют элементы социальной инженерии — то есть проникают на атакуемый объект лично.
Режим Undercover изначально выглядит как некое баловство, но если задуматься, что вызовет больше подозрений у окружающих: Kali Linux в своем истинном виде, либо стандартное окружение Windows? Первый привлечет внимание, по второму — лишь скользнут взглядом и никто даже не заметит минимальных отличий в окне проводника или не обратит внимания на консоль.
В копилку социнженеров можно положить и идею с USB-хабом для Android-устройств. Тут разработчики Kali Linux ничего нового не придумали, но мы уверены, что эта функция придется по душе ряду специалистов.
Команда разработки постепенно отказывается от поддержки совсем слабых устройств и первый звоночек — грядущий отказ от поддержки карт памяти меньше 16 Гб. Но, как сказали сами девелоперы: вы всегда можете пересобрать ядро самостоятельно и так, как вам нужно. | https://habr.com/ru/post/478314/ | null | ru | null |
# Как остановить DDoS-атаку + анализ кода WireX Botnet
[](https://habrahabr.ru/company/cloud4y/blog/336614/)
17 августа 2017 года несколько контент-провайдеров и сетей доставки контента (CDN) подверглись масштабным атакам ботнета, получившего название WireX. Ботнет WireX включает в себя в основном Android-устройства и предназначен для создания DDoS-трафика. Несколько дней назад Google удалил сотни заражённых приложений, которые были доступны для скачивания в Play Маркет, и запустил процесс их удаления со всех устройств.
Исследователи из Akamai, Cloudflare, Flashpoint, Google, Oracle Dyn, RiskIQ, Team Cymru и других организаций сотрудничали, объединившись для борьбы с этим ботнетом. Доказательства указывают на то, что ботнет, возможно, был активен уже 2 августа, но именно атака 17 августа привлекла внимание. Эта статья включает в себя совокупные знания и описывает усилия исследователей, работающих над нейтрализацией ботнета.
### Детали атаки
Первые следы ботнет WireX оставил 2 августа в виде атак, которые в то время оставались незамеченными. Обнаружить их удалось, когда исследователи начали поиск записей User-Agent, состоящих из 26 символов в журналах. Первоначальные атаки были минимальными и вероятно, что вредоносное ПО находилось в разработке или на ранних этапах развертывания. Более длительные атаки были выявлены начиная с 15 августа, при этом в некоторых участвовало как минимум 70 000 IP-адресов (рисунок 1).
WireX — это DDoS-атака на уровне приложения. Трафик, создаваемый узлами атаки, является в основном HTTP GET запросами, хотя некоторые варианты приложений, похоже, способны выдавать POST запросы. Другими словами, ботнет создает трафик, напоминающий настоящие запросы от обычных HTTP-клиентов и веб-браузеров.
*Рисунок 1: Предполагаемый рост бот-сети на основе количества уникальных IP-адресов, наблюдаемых при атаках в час.*
Большая часть трафика из этого ботнета отличалась использованием HTTP-запросов User-Agent в виде случайной последовательности строчных букв английского алфавита.
Некоторые из записей User-Agent:
`User-Agent: jigpuzbcomkenhvladtwysqfxr
User-Agent: yudjmikcvzoqwsbflghtxpanre
User-Agent: mckvhaflwzbderiysoguxnqtpj
User-Agent: deogjvtynmcxzwfsbahirukqpl
User-Agent: fdmjczoeyarnuqkbgtlivsxhwp
User-Agent: yczfxlrenuqtwmavhojpigkdsb
User-Agent: dnlseufokcgvmajqzpbtrwyxih`
Также были обнаружены варианты вредоносного ПО, испускающие записи User-Agent различной длины с расширенным набором символов. Вот несколько примеров:
`User-Agent: xlw2ibhqg0i
User-Agent: bg5pdrxhka2sjr1g
User-Agent: 5z5z39iit9damit5czrxf655ok060d544ytvx25g19hcg18jpo8vk3q
User-Agent: fge26sd5e1vnyp3bdmc6ie0
User-Agent: m8al87qi9z5cqlwc8mb7ug85g47u
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; nl; rv:1.9.1b3)
Gecko/20090305 Firefox/3.1b3 (.NET CLR 3.5.30729)
User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.1.7)
Gecko/20071018 BonEcho/2.0.0.7
User-Agent: Mozilla/5.0 (Macintosh; U; PPC Mac OS X 10_5_7; en-us)
AppleWebKit/530.19.2 (KHTML, like Gecko) Version/4.0.2`
### Отслеживание узлов атаки
Анализ данных о DDoS-атаке 17 августа показал, что участвовали устройства из более чем 100 стран мира, что является нехарактерной чертой для бот-сетей. Распределение атакующих IP-адресов наряду с особой записью User-Agent привело исследователей к догадке о том, что другие организации, возможно, тоже заметили или стали жертвами подобных атак. Начавшие расследования специалисты обратились к коллегам из других организаций для проверки этой гипотезы. Совместными усилиями расследование начало быстро развиваться. Анализ журналов показал связь между атакующими IP-адресами и вредоносными Android-приложениями.
Первые и последующие атаки включали запросы от приложения с одной и той же подписью. Это вывело исследователей на Android-приложение «twdlphqg\_v1.3.5\_apkpure.com.apk», которое они начали изучать, чтобы понять, как работает ботнет, и определить связанные приложения. Поиски выявили ещё несколько приложений от тех же авторов или авторов с аналогичным именем и сопоставимым описанием (рисунок 2). Когда новые приложения были найдены, началась работа по анализу их функционала.
*Рисунок 2: Скриншот поисковой выдачи с аналогичными вредоносными программами.*
Было несколько случаев, когда эти приложения были найдены в известных магазинах приложений для мобильных устройств. В ответ на уведомление о вредоносных приложениях Google предоставил следующий комментарий:
> Мы идентифицировали приблизительно 300 приложений, связанных с проблемой, и заблокировали их в Play Маркет. Мы в процессе удаления их со всех заражённых устройств. Выводы исследователей в сочетании с нашим собственным анализом позволили нам лучше защитить пользователей Android .
### Обзор вредоносных программ
Многие из приложений были в категориях медиа/видеоплееров, рингтонов или утилит, таких как менеджеры файлов и магазины приложений с дополнительными функциями, скрытыми для конечных пользователей. При запуске приложений вредоносные компоненты начинали свою работу, запрашивая у командного сервера, которым чаще всего был g.axclick.store, команду на начало и направление атаки.
Приложения с функциями участия в DDoS-атаках были доброкачественными для пользователей, которые их установили. Эти приложения также пользовались функциями сервисной архитектуры Android, позволяющей приложениям использовать системные ресурсы, даже находясь в фоновом режиме. Таким образом, атаки могли быть запущены, когда приложение не используется. В настоящее время антивирусы распознают эту вредоносную программу как троян «Android Clicker», но она не имеет ничего общего с мошенничеством на кликах. Вероятно, это вредоносное ПО было связано с подобным мошенничеством, но было перепрофилировано для DDoS-атак.
### Анализ вредоносных программ
При проверке различных декомпилированных приложений было обнаружено несколько поддоменов одного корневого домена (axclick.store), которые, как предполагалось, были частью command and control (C2) инфраструктуры для бот-сети.
```
$ grep http * -R
com/twdlphqg/app/ExplorationActivity.smali: const-string v3, "http://u[.]axclick[.]store/"
com/twdlphqg/app/services/Ryiidrxcjmfb.smali: const-string v1, "http://g[.]axclick[.]store/"
```
Первый домен (u [.] Axclick [.] Store) не возвращал контент, а передавал пустой ответ **200 OK** и, по-видимому, использовался для тестирования подключения к Интернету.
Второй домен (g [.] Axclick [.] Store) оказался связанным с DDoS-компонентами вредоносного ПО. Компонент приложения, ссылающийся на этот домен, отвечал за создание службы Android, оснащенной двумя экземплярами WebView. Android позволяет создать собственное окно для просмотра веб-страниц или даже создать свой клон браузера при помощи элемента WebView. Первый экземпляр WebView служил в качестве маяка, опрашивая сервер C2 для получения директив атаки. Второй служил ссылкой для клонирования WebView с целью атаки. Этот компонент также содержит логику для настройки этих атакующих экземпляров.
### Обзор компонентов
Ниже, используя псевдокод на основе знаний, полученных из декомпилированных APK, отдельно рассмотрены части компонентов.
**ServiceRunner**
Цель компонента — продолжение работы приложения в фоновом режиме. Выполнение будет прекращено только в том случае, если приложение остановлено пользователем мобильного устройства или в случае перезагрузки устройства.
*Псевдокод Service Runner*
```
Class ServiceRunner extends Object {
Public function run() {
DDoS_Service->poll_c2();
}
}
```
**Синтаксический анализатор C2**
AttackCommandParser запускается, когда C2 WebView обнаруживает, что произошла загрузка страницы. Парсер загружает содержимое страницы и извлекает тело в качестве команды для атаки. На основе наблюдаемых образцов полезная нагрузка от C2 выглядит следующим образом:
```
https://A\_TARGETED\_WEBSITE/snewxwriA\_USER\_AGENT\_STRINGsnewxwrihttps://A\_REFER\_HEADER\_VALUE/
```
*Пример команды к атаке*
Значение, извлеченное из тега title, затем проверяется с помощью String-> contains (), чтобы убедиться, что оно содержит разделитель snewxwri. Если он найден, содержимое разделяется. Затем полученное используется в качестве параметров, которые должны быть переданы методу DDoS\_Service-> attack ().
*Псевдокод парсинга ответов*
```
Class AttackCommandParser extends WebViewClient {
Public function onPageFinished(C2_WebView,C2_url) {
String pageTitle = C2_WebView->getTitle();
if (pageTitle->contains(“snewxwri”) == true) {
pageTitle = pageTitle->trim();
Array commandParts = pageTitle.split(“snewxwri”);
String target = commandParts[0];
String userAgent = commandParts[1];
String referer = commandParts[2];
DDoS_Service->attack(target, userAgent, referer);
}
}
}
```
**Служба DDoS**
Основной функцией компонента DDoS\_Service является создание WebView, чтобы загружать любой указанный URL, выбранный в C2 WebView, в сам контейнер WebView, а не запускать браузер. После этого запускается атака.
*Псевдокод DDoS Service*
```
Class DDoS_Service extends Object {
Public function onCreate() {
Handler OS_Handler = new Handler();
Object Runner = new ServiceRunner();
OS_Handler->postDelayed(Runner,2);
}
Public function poll_c2() {
WebViewClient C2_Parser = new AttackCommandParser();
WebView C2_WebView = new WebView();
WebViewSettings C2_WebView_Settings = C2_WebView->getSettings();
C2_WebView_Settings->setCacheMode(LOAD_NO_CACHE);
C2_WebView->clearCache(true);
C2_WebView->clearHistory();
C2_WebView->setWebViewClient(C2_Parser);
C2_WebView->loadUrl(“http://g[.]axclick[.]store”);
}
Public function attack(String target, String userAgent, String referer) {
HashMap WebViewHeaders = new HashMap();
WebViewHeaders->put(“Referer”,referer);
WebViewHeaders->put(“X-Requested-With”,””);
WebView[] AttackerViews = new WebView[100];
for (int i=0; iclearHistory();
AttackerViews[i]->clearFormData();
AttackerViews[i]->clearCache(true);
WebViewSettings AttackWebViewSettings = AttackerViews[i]->getSettings();
AttackWebViewSettings->setJavaScriptEnabled(true);
AttackWebViewSettings->setUserAgentString(userAgent);
AttackWebViewSettings->setCacheMode(LOAD\_NO\_CACHE);
this->deleteDatabase(“webview.db”);
this->deleteDatabase(“webviewCache.db”);
AttackerViews[i]->loadUrl(target,WebViewHeaders);
}
}
}
```
Метод onCreate () создает новый экземпляр android/os/Handler и ServiceRunner. Метод poll\_c2 () отвечает за постоянную перезагрузку WebView с помощью URL-адреса C2. Перед опросом доменов C2 служба очистит и отключит кэш, а также очистит историю экземпляров WebView. Эти шаги выполняются для обеспечения того, чтобы клиент всегда получал актуальную информацию и не обрабатывал запросы с помощью кэша. Метод attack () отвечает за создание фактического трафика атаки.
### Пользовательский опыт при работе с вредоносным ПО
Хотя многие из заражённых приложений уже были удалены из Google Play Маркет, в сети остались зеркала, из которых возможно загрузить файлы APK. Мы загрузили «twdlphqg» (одно из атакующих приложений) на физический Samsung Galaxy S4 с Android Lollipop и патчами безопасности 2015 года.
Это приложение, как и остальные, которые мы тестировали, имело безобидные названия, такие как «Device Analysis», «Data Storage» «Package Manager» и прочее.
Когда приложение запускается, оно выглядит простым приложением для рингтонов. Предусмотрены только три мелодии звонка. Оно может воспроизводить и устанавливать рингтоны и не имеет других функций.
Это приложение запускает дополнительные процессы в фоновом режиме, которые продолжают работать и могут участвовать в DDoS-атаке, даже когда экран телефона заблокирован. Когда мы поставили телефон на зарядное устройство в режиме сна, процессы, отвечающие за DDoS-атаку, не прекращались.
Примечательно, что на данный момент устанавливать эти приложения невозможно, поскольку функция PlayProtect от Google блокирует их. Все приложения, которые были выявлены, стали частью кампании по удалению проблемных и уже установленных приложений с устройств. Теперь для запуска этого вредоносного ПО требуется отключение PlayProtect в настройках.
### Вывод
Эти открытия были возможны только благодаря сотрудничеству между различным IT-организациями. У каждого был свой кусочек головоломки: без вклада каждой компании, этот ботнет, возможно, надолго остался бы загадкой.
Лучшее, что могут сделать организации при DDoS-атаке — делиться подробными метриками, связанными с атакой. С этой информацией те, кто специализируется на [защите от DDoS](https://cloud4y.ru/cloud-hosting/anti-ddos/), смогут узнать гораздо больше и минимизировать негативные последствия.
Полезные сведения могут включать в себя захваченные пакеты, списки атакующих IP-адресов, записи о выкупе, заголовки запросов и любые подозрительные шаблоны. Такие данные не должны содержать легитимного клиентского трафика, чтобы минимизировать проблемы конфиденциальности, а также потому, что подобный трафик может замедлить анализ. И самое главное, дать разрешение на передачу этих данных доверенным контактам в широком сообществе IT-безопасности, которые могут обладать необходимым опытом.
**Выражаем благодарность исследователям из Akamai, Cloudflare, Flashpoint, Google, RiskIQ, Team Cymru, ФБР и других организаций, которые не попали в список.***Tim April: Senior Security Architect @ Akamai
Chris Baker: Principal of Threat Intelligence @ Oracle Dyn
Matt Carothers
Jaime Cochran: Security Analyst @ Cloudflare
Marek Majkowski: Enthusiastic Geek @ Cloudflare
Jared Mauch: Internetworking Research and Architecture @ Akamai
Allison Nixon: Director of Security Research @ Flashpoint
Justin Paine: Head Of Trust & Safety @ Cloudflare
Chad Seaman: Sen. Security Intelligence Response Team Engineer @ Akamai SIRT
Darren Spruell: Threat Researcher @ RiskIQ
Zach Wikholm: Research Developer @ Flashpoint
и другие.* | https://habr.com/ru/post/336614/ | null | ru | null |
# Как подружить дизайнера, верстальщика и «Фигму» с помощью дизайн-системы, ломика и какой-то матери™
Привет, Хабр. Недавно я [выпендрился](https://habr.com/post/463061/#comment_20495397) в комментариях и пообещал подробно ответить на вопрос о том, как дизайн-система упрощает взаимоотношения и нейтрализует конфликты между дизайнерами и верстальщиками (разработчиками). Плюс рассказать о некоторых вариантах стандартизации именования слоёв. Вот и отвечаю. *Подробно*. Про сетки. Про компоненты. Про иконки. Про язык. Про БЭМ. Про «фигмин» слэш и её же плагины. Про артборды и вьюпорты. Про типографику. Про стили и палитры. Про эффекты. Про экспорт растра. Про «мультиплеер». Про распределение обязанностей. Ну и немножко «о жизни, вселенной и вообще». Осторожно, трафик: внутри много картинок, есть gif-анимации. А ещё много, *действительно много* нудного текста. Я предупредил.
**Дисклеймер, ради возможной экономии вашего времени:**Автор — абсолютный ноунейм и не имеет опыта работы в крупных претенциозных организациях. Всё описанное — сугубо личное мнение, не подкрепленное никакими научными изысканиями. Весь мой субъективный опыт получен при работе над сравнительно небольшими проектами с гуманоидным ресурсом до 10 человек, плюс от волонтёрства в паре зарубежных проектов из тех, которые community-driven. Я не готов нести ответственность за ваше потерянное время, возможные убытки или упущенную прибыль. И не буду возвращать вам ваши лучшие годы в случае, если вы их на меня потратите :) Что есть, тем и делюсь. Поехали.
Дизайн-система как средство разрешения конфликтов
-------------------------------------------------
Некоторые дизайнеры думают, что *дизайн-система* — это библиотека стилей. Договоренность о том, что «кнопки делаем красненькими, плашки — синенькими, а текст пишем Гельветикой». Кое-кто считает, что это набор заготовок из которых собираются макеты. Мол, вот так должно выглядеть модальное окно, а вот так — карточка товара. Фронтендеры идут дальше и включают в понятие техническую реализацию. Скажем, библиотеку компонентов на React’е. Всё это по-своему верно. Но это частности. Если копнуть, основная функция дизайн-системы — это выработка стандартов взаимодействия людей, которые работают над проектом. Поэтому она изначально призвана устранять конфликты. По крайней мере, я в это верю и хочу обосновать, пройдясь по всем основным больным мозолям.
Конфликт первый. Расстояния, размеры и отступы
----------------------------------------------
***Суть.** Дизайнер лепит размеры неточно, верстальщик постоянно натыкается на разнородные и дробные значения. Непонятно, какие из них правильные, а какие ошибочные. «Фигма» не даёт измерять расстояния «линейкой».*
**Типичное «решение».** Все пинают дизайнера, пытаются заставить его быть внимательнее и тщательнее выцеливать пиксели. Результат: задёрганный злой диз тратит часы на то, чтобы подвинуть на 1-2 пикселя сотни блоков на сотне артбордов. Итог всё равно не идеален, верстальщик всё равно недоволен, сроки уезжают, клиент теряет деньги, все переругиваются и разбредаются жаловаться друг на друга по профильным форумам.
**Реальное решение.** Создать дизайн-систему и принять её. Продумать или постепенно наработать удобные сетки, унифицировать макеты (в техническом смысле), правильно использовать библиотеки стилей и компонентов. Результат: дизайнер Акела по-прежнему регулярно промахивается, но верстальщик может определить большинство расстояний даже на глаз, не глядя в свойства блока. Кроме того, чем дальше, тем больше у обоих накапливается готовых компонентов и стилей/миксинов, которые просто копируются из проекта в проект.
Если у вас хорошо продуманы [сетки](https://habr.com/ru/post/344910/) и вы используете компонентный подход, то все числа либо унифицированы, либо вычисляются элементарной арифметикой. Чтобы не быть голословным, для примера ниже покажу одну из сеточных систем, на которой собирается львиная доля моих проектов. Это личный велосипед, но, пользуясь аналогичными принципами, вы можете наизобретать сколько угодно своих на любой вкус.
### 4px. Крат**н**ость — сестра таланта
Первый слой сетки всегда одинаковый: **4px grid.** По сути, я работаю с «масштабными пикселями», которые состоят из 4x4 обычных. В результате любой элемент макета, кроме линий (обводок, бордюров, аутлайнов, hr и т.п.) всегда имеет размер, кратный четырём.
Это автоматически снимает все вопросы по случайным смещениям, дробным пикселям и т.п. Если верстальщик видит в макете нечто совсем не кратное четырём и без дополнительных комментариев, то с вероятностью 99% это просто косяк — он может спокойно заменить цифру на ближайшее кратное, даже не вдаваясь в детали.
Это не значит, что можно расслабиться и лепить макеты левой пяткой мимо сетки. Случайности неизбежны, но наличие системы позволяет верстальщику отличать косяки от умышленных изменений.
#### Почему именно 4?
Потому что. В принципе, это может быть любое число: хоть 5, хоть 3, хоть 10. Единственный критерий: удобство использования. Чётные числа удобнее, поскольку размеры вьюпортов и носителей почти всегда выражены в чётных числах (и нередко кратны четырём). Кроме того, есть ещё интерполяция при масштабировании растра, но это не так уж важно.
Главное, что число 4 достаточно мелкое, чтобы быть универсальным, и достаточно крупное, чтобы существенно снизить разброс всевозможных значений в макете. Если взять больше, будет проблемно верстать мелкие элементы. Например, при базе в 10px паддинги внутри полей ввода получились бы довольно конскими, а выбор интерлиньяжа для текста — скудным. Это излишне крупный шаг, хочется мельче. Эмпирически все давно распробовали 4px, и вряд ли вы изобретёте что-то более универсальное. Но решать вам.
### Вертикальный ритм
#### Базовый интерлиньяж
Теперь нужно определиться с базовым интерлиньяжем — **высотой строки**, которая создаст вертикальный ритм и в дальнейшем будет влияет на высоту большинства элементов. В результате мы «разлинеиваем» макеты по вертикали.
*(Если вы не знакомы с понятиями вертикального ритма, базового шрифта и модуля, опять же, посмотрите [статью про сетки](https://habr.com/ru/post/344910/) — там написано даже нуднее, чем тут, но зато всё есть).*
Интерлиньяж может отличаться в разных проектах. Но чаще всего я использую **либо 16px**, **либо 24px**. Вы можете придумать что-то своё, держа в уме, что числа должны быть кратны вашей базовой пиксельной сетке.
Обратите внимание, что при 16px текст фактически занимает не в одну строку, а в две. Так что формально мы используем интерлиньяж 32px. Но с точки зрения ритма это одно и то же. Просто разбиваем каждую строку пополам, чтобы было удобнее работать с мелкими элементами.
#### Стандартные значения высот
В результате разлиновки получается ряд **«магических» чисел**, которые и будут считаться стандартными размерами блоков по вертикали. При этом не забываем о возможности использования половинчатых и полуторных интервалов для промежуточных случаев, вроде паддингов или мелкого текста. Это обычная практика со времен бумажной верстки.
На случай проблем с загрузкой картинок и арифметикой:
| Интерлиньяж | Целые интервалы | Дробные интервалы |
| --- | --- | --- |
| 16px / 32px | 32px, 48px, 64px, 80px, 96px, … | 8px, 24px, ... |
| 24px | 24px, 48px, 72px, 96px, ... | 12px, 36px, ... |
Еще одна причина любить именно эти две разлиновки заключается в том, что они пропорциональны друг другу: три строки по 16px равны двум строкам по 24px (16 \* 3 = 24 \* 2). Это позволяет тягать некоторые компоненты между ними, не теряя общий ритм. Например, иконки размером 48x48 прекрасно ложатся на обе сетки. Как нетрудно догадаться, универсальными будут и все числа, кратные 48: 96, 144, 192 и т.д.
Не нужно бояться тьмы непривычных чисел. На практике после 2-3 проектов они порабощают ваш мозг и намертво впечатаются в подкорку.
#### Высота модуля и гаттера
Замечу, что стандартизация не означает тотальное однообразие. Мы регулируем базовые значения, да. Но никто не мешает варьировать *пропорции* модуля как угодно. Вот для сравнения два примера:
Слева мы сделали высоту модуля равной двум строкам и получили очень «плоскую» сетку, которая удобна для верстки форм, таблиц, списочных интерфейсов и прочих подобных вещей. А справа модуль повыше, 5 строк. Подойдет в тех макетах, где много галерей, горизонтальных карточек, баннерных блоков, картинок.
**Гаттер** [англ. Gutter — «желоб», «канавка»] — это то, что обычно называют *межмодульным расстоянием*. Его высоту тоже всегда делаем кратной базовому интерлиньяжу. Чаще всего это будет 1 строка. Но если, например, макет пафосный и состоит по большей части из из огромных картинок, можно разделять их высоким гаттером в несколько строк.
Как видите, мы по-прежнему создаём довольно разнообразные сетки, но все они сочетаются друг с другом и библиотеками компонентов, потому что у них общая *ритмическая база.*
Важно, что с точки зрения верстки разницы практически нет. Все числа по-прежнему кратны базовому интерлиньяжу (16px) и входят в наш «магический» стандарт. Так что модуль это просто визуальная пропорция, которая помогает быстрее набрасывать элементы на макет и вычислять их габариты на глазок.
**Давайте потестим** на небольшом примере. Итак, есть 2 стандартные сетки с интерлиньяжем 16px. Высота гаттера — 1 строка (16px). Высота модуля в левом макете 2 строки, в правом — 5 строк. Можем ли мы теперь определить правильные *вертикальные* размеры/отступы элементов, не глядя в их свойства?
Я думаю, можем. Тут нет ничего особо сложного: прикинуть число строк и умножить на базовый интерлиньяж. Всё. Причем эти числа гарантированно будут входить в «стандартный» ряд. То есть по мере практики арифметика быстро доводится до автоматизма. Обязательна ли фотошоповская «линейка» здесь? Думаю, тоже нет. Даже если что-то трудно сосчитать в уме, то подсмотреть в свойства не проблема.
Теперь давайте представим, что дизайнер ошибается где-то на пиксель или даже два. Влияет ли это на работу верстальщика? Нет, не влияет. Верстальщик видит сетку, верстальщик собирает проект по ней. Точка. И бог с ним, с тремором дизайнера. *Нет проблемы*, нет конфликта)
### Горизонтальный ритм: гаттер, колонки, поля
#### Гаттер
Схожим образом, выбираем горизонтальный размер гаттера, кратный 4px. Чаще всего я делаю гаттер **квадратным (16x16).** Но если нужны более широкие отступы между колонками, можно взять любое другое значение: 20px, 24px, 28px, 32px… и т.д.
При этом гаттер становится базой для горизонтальных расстояний по аналогии с интерлиньяжем. Если сделать его ширину равной 20px, то весь «магический стандарт» для горизонталей изменится на «10, 20, 30, 40...». Но, честно говоря, это неудобные цифры, будет сильно не хватать мелких паддингов и всякого прочего. В целом, я бы рекомендовал не мудрить и делать гаттер либо квадратным, либо кратным интерлиньяжу. Проще работать с одним набором стандартных чисел, чем с двумя.
#### Колонки и их респонсивность
Определившись с «магическим стандартом», настраиваем колонки в соответствии с размером холста или брейкпоинтами, о которых поговорим чуть ниже.
Сетку можно сделать полностью респонсивной, тогда колонки будут резиновыми: ширина «stretch», количество произвольное — например, 12.
А можно руками задать ширину колонки, чтобы получить разное число колонок на разных вьюпортах (классика: 4 на мобильных, 8 на «таблетках», 12 на десктопах, 16 на широких экранах). В настройках сетки это выглядит так: количество «auto», ширина — произвольное число, которое подбирается исходя из размеров артборда и гаттера.
При этом на уровне верстки колонки могут быть как резиновыми, так и полностью фиксированными. В последнем случае у макета появляются «уши» — поля, которые не используются контентом, но, как правило, перекрываются общим фоном страницы. При желании, это можно показать за счёт настройки «margin» при центральном выравнивании колонок.
#### Кто решает, как ведёт себя сетка
В идеале — дизайнер. Если он UI/UX. Потому зачастую дизайн *адаптивный*, а не просто резиновый, и желательно, чтобы было какое-то единообразное поведение всего лейаута. Но важно, чтобы верстальщик заранее получал информацию о том, какую из схем вы решили применять в конкретном проекте, и мог при необходимости высказать своё мнение.
На практике бывают ситуации, когда решение лучше принимать верстальщику. Например, если заранее согласовано использование какого-то фреймворка, типа бутстрапа или ещё чего-то там. Всякое бывает: требование клиента, легаси, ограничение по срокам или даже возможностям самого верстальщика. К этому надо относиться спокойно. Мы все не боги, у каждого есть предел возможного. В таких случаях уже дизайнер отталкивается от требований верстальщика, обеспечивая соответствие макета. Тут нет ничего криминального, т.к. мы занимаемся прикладными задачами, а не чистым искусством.
Итак, имея представление о размере гаттера + принципе разбиения колонок + «магическом стандарте», мы, опять же, можем определять горизонтальные размеры элементов чистой арифметикой. Особых конфликтов тут возникать больше не должно.
### Брейкпоинты и размеры основных фреймов
Еще один возможный камень преткновения: каких размеров должны быть макеты, как выбирать брейкпоинты, какие вьюпорты нужно отрисовывать, а где «и так всё понятно».
В эпоху «Фотошопа», и даже всего год назад, это было проблемой для многих:
С «Фигмой» стало на порядок проще, потому что холст респонсивный. В просторечии «резиновый», тянется. Но часть вопросов всё равно осталась.
Кто-то берёт стандартные разрешения экранов прямо из «Фигмы». Кто-то подгоняет артборды под дефолтные значения «Бутстрапа», кто-то отталкивается от контента. Я же в этом вопросе немного велосипедист. Подгоняю размеры холстов так, чтобы они чётенько легли в сетку и всегда работали всё с теми же «магическими» числами.
#### Почему делаю артборды произвольных размеров
Во-первых, я уже не считаю правильным рисовать резиновый макет точно под вьюпорт. Пару лет назад прочёл отличную статью «[The 100% correct way to do CSS breakpoints](https://www.freecodecamp.org/news/the-100-correct-way-to-do-css-breakpoints-88d6a5ba1862/)». Долго прожёвывал, но в итоге принял точку зрения автора. Вкратце: при обычном подходе в точках брейкпоинтов все элементы макетов оказываются в экстремальных состояниях (минимальная ширина или максимальная ширина), тогда как для популярных вьюпортов хотелось бы получить «нормальные» средние значения, более естественные. Поэтому брейкпоинты лучше располагать *между* популярными ширинами экранов, а не точно на них. Соответственно, минимальная ширина макета берется чуть меньше вьюпорта, а тянется она чуть дальше. Звучит заморочено, но смысл там есть.
Во-вторых, я почти не сталкиваюсь с бутстрапами и нет проблем с ручной разметкой, поэтому не приходится жёстко ориентироваться на какие-то внешние стандарты.
В третьих, вопреки стереотипам, те верстальщики, с которыми я работаю, чаще просят пояснений для широких экранов, чем для узких. То есть адаптировать макеты под вьюпорт они и сами умеют. Их больше волнует, чем и как будем заполнять «лишнюю» площадь.
Таким образом, удобнее положить артборд точно в сетку, которая наглядно демонстрирует *принципы* масштабирования и все расстояния, чем клепать строго по размерам вьюпортов и потом возиться с дробными корявыми числами ширин колонок и элементов. Это и есть решение конфликта.
#### Расчёт оптимальной ширины макета
1. Определяем *приблизительно* желаемую ширину под ближайший вьюпорт. Например, в качестве минимального экрана меня устраивает любая ширина в диапазоне 290-320 px, а для десктопа, скажем 1100—1300px. Интересует в основном нижняя планка, т.к. растянуть колонки в плюс или добавить «уши» не проблема.
2. Прикидываем желаемое число колонок. Для мобильного обычно беру 3 или 4 (от контента, какого там больше: чётного или нечётного), а для десктопа — 12. (В статье про сетки уже рассказывал про интересный 24-колоночный вариант, но он специфичен, для простоты не берем его в расчёт).
3. Вычитаем из желаемой ширины все гаттеры и поля (гаттеров получится на 1 меньше, чем колонок, а поля два — примечание Кэпа).
4. Оставшееся число делим на число колонок, получаем примерную необходимую ширину колонки.
5. Округляем примерную ширину колонки до ближейшего стандартного «магического» числа. Получаем *удобную* ширину колонки.
6. Считаем оптимальную ширину макета: все *удобные* колонки + все гаттеры + поля.
В результате ширина макета всегда кратна базе, все колонки и отступы ложатся точнёхонько на направляющие, всё удобно и понятно.
Чаще всего, для веба я использую колонки шириной **80px.** И квадратный гаттер 16px. В результате типовая ширина артбордов будет: **304px,** 592px, **1168px,** 1552px. Естественно, каждый макет без проблем тянется в большую сторону. Фоновые растровые картинки готовятся с запасом. Довольно удобно, претензий по этому поводу обычно нет.
#### Дополнительные слои сетки
Иногда поверх обычной сетки накладываются дополнительные направляющие, которые помогают более гибко управлять расстояниями или показывают какие-то ограничения. Например, в один из моих стандартных мобильных артбордов (304px) входят «рельсы» отступов 16px и 48px, чтобы удобнее ложились иконки и текст. А условно безопасная область «первого экрана» отмечена зеленой горизонтальной линией.
Принцип всё тот же: проектировать шаблоны и сетки так, чтобы для всех типовых ситуаций, решений и компонентов находилось готовое место.
### Иконки
Иконки хранятся на отдельной сетке с собираются через промежуточный компонент-обертку. Сами картинки иконок — масштабируются. Иногда это нужно, чтобы использовать некоторые из них в качестве иллюстрации, буллита и т.п. Но обертка всегда фиксирует их размер и обеспечивает поля безопасности. Когда компонент иконки (обертка) тянется, сама иконка остается нормальной, т.к. внутри обертки всё выравнивается по «center», a не «scale». Обертки могут быть нескольких размеров.
Такой подход позволяет подгонять оптические размеры иконок, не ломая компоненты, плюс легко менять иконки внутри любого компонента, просто выбирая их из списка.
(Как сгруппировать — см. раздел про именование слоёв).
### Кое-что незачем класть в сетку
Очевидно, что из всех «красивостей» существуют исключения. Например, нет никакого резона вымерять отступы между элементами инлайнового меню, если сама их длина варьируется («grow horizontally»). Эти расстояния вычисляются автоматически и на уровне «Фигмы» (когда вы используете «Arrange -> Ditribute horizontal spacing») и на уровне вёрстки (flex’ом, например). То есть никому их точные значения вообще не нужны. Единственное, что требуется — это как-то дать понять верстальщику, какого поведения вы ждёте от этих пунктов. Для этого есть комментарии. (Или метки в именах слоёв, или сопроводительные письма, или просто предварительные договоренности — главное, чтобы канал коммуникации был всеми принят).
Поскольку «Фигма» не идеальна, некоторые вещи проще делать на уровне верстки, не заморачиваясь их отрисовкой. Поэтому комментарии имеют приоритет над тем, что нарисовано. Например, в макете меню выглядит как space-between, но я пишу space-around. В идеальном мире, верстальщик учтёт это. В неидеальном — может и не заметить, но тогда пофиксит позже по моей просьбе, потому что я использую ленту комментариев как чеклист. Опять же, без конфликтов.
### Как использовать компоненты так, чтобы все были довольны
* Надо назначать каждому слою правильное поведение (выравнивание и способ масштабирования). Проверять поведение, потягав туда-сюда не только сам компонент, но и весь артборд (бывают нюансы с группами). Это снимает большинство вопросов по респонсивности макета, плюс помогает найти проблемные места как в самом дизайне, так и в архитектуре компонентов.
* Не надо пытаться загнать в компоненты абсолютно всё. В любом проекте есть специфические вещи, которые используются однократно или имеют риск погибнуть в боях с правками заказчиков — не завязывайте на них родительские библиотечные компоненты, чтобы не зависеть от ненадёжных и слишком нетипичных узлов.
* В мастер-компонентах нужно особенно тщательно следить за всеми отступами и настройками Если вы случайно собъёте выравнивание иконки в экземпляре (копии) — это ерунда, которая не повлияет на вёрстку. Если же вы косякнёте в мастер-компоненте, ошибка может переползти в библиотеку и все зависящие компоненты.
* Верстальщик должен работать только с мастер-компонентами. (Или некими их эталонными копиями, если вы боитесь за сохранность оригиналов). Лично я обычно делаю в проекте специальную страницу для верстальщика, и выношу туда все мастер-компоненты, а заодно и всякие комментарии к ним.
* Если вы осознанно модифицируете компонент, то его нужно оборачивать в новый мастер-компонент. Либо создавать эталонную копию в какой-то специальной области (странице, фрейме, библиотечном проекте).
Общий смысл в том, чтобы случайные огрехи и визуальные костыли не попадали в вёрстку. Я могу, например, в каком-то отдельном макете поэкспериментировать со шрифтом компонента, а потом просто забыть вернуть всё назад. Если верстальщик будет изучать каждую копию отдельно, то со ста экранов он наверняка насобирает по 3-5 версий любого компонента) Поэтому проще придерживаться обратного принципа: что не вынесено осознанно в перечень компонентов, то не существует в природе и является галлюцинацией) Или, например, «читингом» — идеализированным кейсом для оформления презентаций, который к боевой вёрстке не имеет никакого отношения.
Конфликт второй. Именование (слоёв, артбордов, стилей, файлов)
--------------------------------------------------------------
***Суть.** Дизайнер не заморачивается именованием слоёв или именует их от балды. Верстальщику трудно находить нужные слои в списках вида «Rectangle1, Rectangle2, ...». Проекты не структурированы или плохо структурированы. Непонятно, где искать тот или иной экран или компонент.*
**Решение.** Договориться о самых общих принципах (язык, структура страниц). Выбрать одну из готовых существующих систем именования (например, БЭМ). Использовать возможности «Фигмы» и плагинов для группировки, поиска и переименований. Собирать дизайн на компонентах.
### Английский язык, латиница
Если у вас более-менее англоговорящая команда, сильно рекомендую именовать всё на английском языке и избегать кириллицы. Даже если вы в данный момент работаете только на внутренний рынок.
Во-первых, это позволяет приблизить макеты к верстке: синхронизировать имена компонентов с классами, а стилей — с миксинами.
Во-вторых, сильно поможет, если вы когда-нибудь в будущем захотите поделиться своим опытом с более широкой аудиторией или, допустим, возникнет необходимость показать какой-то кейс на международном ресурсе.
Мне понятны контраргументы, но я к этому пришел на практике. Тут как в той шутке: «No one thinks a toilet paper is a perfect gift until they need one».
### Именование. БЭМ-нотация
[Соглашение по именованию БЭМ.](https://ru.bem.info/methodology/naming-convention/)
#### Почему именно оно?
* Потому что именование разработано для вёрстки (CSS), а дизайн в «Фигме» это по сути не что иное, как вёрстка, упрощённая и урезанная ради возможности управления CSS-свойствами через GUI.
* Потому что эта нотация довольно распространена. К синтаксису привык и я, и все верстальщики, с которыми я работаю. (Это не значит, что БЭМ должен всем нравиться; речь о том, что эта нотация большинству коллег понятна. Если у вас есть альтернатива — пользуйтесь, да и всё. Главное, чтобы удобно было всей команде, а не кому-то одному).
* Потому что синтаксис не конфликтует с фишками самой «Фигмы» (группировкой слоёв и др., см. ниже).
* Потому что это позволяет приблизить структуру проектов в «Фигме» к структуре проекта на фронтенде (общие имена компонентов, миксинов, модификаторов и т.д.).
* Потому что принцип универсален и работает на любых строках: можно именовать хоть артборды, хоть файлы, хоть страницы.
Важно то, что мы ищем не *идеальную* систему, а *универсальную*. Такое именование слоёв не имеет практического смысла в плане экспорта CSS: мы всё равно не можем конвертировать их в готовую разметку. Но мы этого и не добиваемся.
Нам нужно, чтобы дизайнер(ы) и верстальщик(и) просто понимали друг друга и работали на одной волне. Чтобы в меню не вываливалось по 10 слоёв или компонентов с одинаковым названием. Чтобы, увидев в переписке «nav-menu-item\_active», верстальщик сразу понимал, о каком конкретно компоненте идёт речь. Чтобы людям не приходилось ломать голову, придумывая свои названия для одних и тех же вещей. Чтобы компоненты в библиотеке «Фигмы» совпадали с библиотекой компонентов в исходниках сборки, хотя бы по ключевым позициям. Короче, стандарт, а не идеал.
Вы можете пытаться изобрести что-то другое, более «простое». Но скорее всего, в итоге всё равно придёте к чему-то подобному. Хотя решать вам, безусловно. Если у вас есть *обкатанное* альтернативное решение, форма комментария в вашем полном распоряжении :)
#### Как примерно это выглядит на практике
Пусть вас не смущают слэши и прочие странные значки. Это не так сложно, как выглядит.
Амперсанды (&) я заимствовал из синтаксиса Stylus (sass/less), где они эквивалентны родительскому селектору. Связка «&\_\_» означает, что слой является «**Э**лементом» (в терминах Б**Э**М). Это совершенно не обязательный префикс, мне просто так удобнее и привычнее, потому что в Stylus структура блока выглядит аналогично:
```
.widget-heading
&__title
…
&__icon-menu
…
```
Каждый компонент в терминах **Б**ЭМ считается **Б**локом. Поэтому в названии используются только дефисы и латиница, если вы используете классический синтаксис.
Одинарное нижнее подчеркивание («\_») в том же классическом синтаксисе БЭ**М** используется для обозначения **М**одификатора. Например, «block\_hover» — это компонент «блок» в состоянии :hover, а «widget\_collapsed» — это компонент «виджет» в свернутом состоянии.
Разумеется, структура слоёв в «Фигме» не соответствует вёрстке в точности. Поэтому некоторые вещи довольно условны. Например, компонент с модификаторами приходится заворачивать в новый компонент — появляется лишняя вложенность, тогда как в вёрстке эти классы присваиваются блоку вместе, находятся на одном уровне. Но, повторюсь, нет цели точно эмулировать вёрстку.
Слэши — это зарезервированные «Фигмой» символы, которые позволяют группировать компоненты. См. ниже. Их я вставляю, чтобы было удобно переключать состояния элементов (ховер, фокус и т.д.).
Ну а квадратные скобки — просто техническая метка, которая говорит о том, что этот слой является визуальным костылём (типа скругления уголков у бэкграунда) и что его не надо добавлять в разметку.
#### Что и когда нужно именовать, а на что можно забить
Теоретики рекомендуют именовать каждый слой при создании. В реальности, это было бы бессмысленным куском работы. Слои в проектах постоянно добавляются и исчезают, склеиваются и переносятся туда-сюда. Поэтому у меня принципы проще.
**Строго именуются:**
* Артборды (фреймы корневого уровня).
* Мастер-компоненты.
* Все слои, которые входят в мастер-компонент. (Лайфхак: это делается **не** на этапе творческого поиска, а в момент создания компонента, когда вы уже наигрались и более-менее окончательно определились со структурой).
* Стили текста, эффекты, именованные цвета — то, что структурируется «Фигмой» или используется в препроцессорах в качестве переменных или миксинов.
* Те слои, смысл которых важен, но не ясен из контекста. Например, если вы хотите положить на бэкграунд гигантскую буквицу или использовать «x» в качестве иконки (такое себе) — такой слой лучше осмысленно именовать, т.к. это специальный элемент разметки, а не просто текст из одной буквы.
* Контент-содержащие слои, которые непосредственно используются для экспорта и вёрстки: растровые картинки, SVG и т.д.
* Фреймы, которые при верстке должны войти в разметку (обертки флексов, логические части макетов, типа сайдбара, aside, section и т.п.).
**Вообще не именуются:**
* Визуальные костыли, которые не входят в компоненты и реализуются стилями и CSS-свойствами без доп. разметки (всякие там размывающие заглушки, плашки).
* Текстовые слои, которые не являются частью мастер-компонентов.
* «Рыбные» и декоративные слои, которые не нуждаются в экспорте. Типа стоковых фоток в имитациях контентной страницы.
* Всякие обёртки и артборды, которые нужны только для удобной организации пространства или демонстрации каких-то технических заметок.
* Внутренние слои SVG-графики, фигуры в составных контурах (union) и фреймах, составные части иконок и т.д. Они не считаются независимыми слоями, поэтому именуются только родительские объекты. (Если планируется внедрять инлайном и, например, анимировать, то такую графику лучше готовить в отдельных артбордах).
* Копии компонента в больших наборах (типа элементов в списке) — они наследуют общее название от мастер-компонента, а индивидуализировать их бессмысленно.
#### «Я не могу, у меня лапки»
Иногда дизайнерам лень вникать в техчасть.
На мой личный взгляд, UX-дизайнер должен если не уметь в вёрстку, то хотя бы понимать основные принципы и процессы. БЭМ, помимо прочего, помогает научиться думать компонентами, *системно*. Так что имеет смысл потратить время на изучение даже не ради каких-то там слоёв, а просто чтобы уметь делать технологичный живучий дизайн, который легко переносить из проекта в проект и «перепродавать» раз за разом.
Но отмечу, что сам я дизайнер довольно посредственный: квадратно-гнездовой и далёкий от искусства. Возможно, моя позиция обусловлена недостатком таланта. Так что если вы великий творец и вольный креативщик, который далёк от технических подробностей, но при этом вас терпят — возможно, вам это всё и не нужно. Хотя рискну предположить, что даже в этом случае у вас под рукой всё равно есть какой-то верный технохолоп, который терпеливо приводит ваши прогрессивные идеи в соответствие со стеком простых смертных верстальщиков. В этом случае можно просто отдать эту статью ему и продолжить парить в эмпиреях.
### Фишки «Фигмы» и плагинов
Предполагается, что вы знакомы с «[Best practices: components, styles, and shared libraries](https://www.figma.com/blog/component-styles-and-shared-library-best-practices/)». И что вы уже достаточно взрослый мальчик/девочка, чтобы на многие из них забить и кататься на двухколёсных велосипедах.
#### Группировка компонентов, стилей и эффектов
В любом случае, от «Фигмы» мы обязательно берём слэши. Слэши — наше всё:
> To make finding and selecting styles easier, you can also organize your styles into groups by naming them with a slash naming convention. In the Styles menu, you will see your Local Styles and any Styles shared via the Team Library. Styles will be ordered alphabetically by Team name, then File name. ([Источник](https://help.figma.com/article/186-styles-creating-styles))
Итак, слэш разделяет «группу» и собственно «имя».
*[Исключение составляет Слэш Хадсон, который разделяет «Gun’s & Roses» на группу и собственное имя, но потом передумывает].*
Например, слои «buttons/ghost» и «buttons/cta» декларируют именованную группу «buttons», а «mobile/paragraph» и «mobile/h1» — группу «mobile». В принципе, ежели вы шибко умный, эту систему можно назвать таксономией, а группы — таксонами. Тогда вы не будете путать всё это с обычной группировкой слоёв, которая делается простым «Ctrl/Cmd + G».
Группы, созданные за счёт именования, автоматически подтягиваются в интерфейс, превращаясь в выпадающие списки (для компонентов) или секции во всплывающих слоях-окошках (для стилей и эффектов).
#### Нейминг в плагинах
С появлением плагинов наметился некий тренд, когда названия слоёв используются ещё и в качестве данных выборки для всяких фильтров.
Яркий пример — мощный с виду плагин [Google Sheets Sync](https://www.figma.com/c/plugin/735770583268406934/Google-Sheets-Sync), который позволяет подтягивать в разные слои компонентов (!) данные из открытых таблиц Google. То есть берём десяток экземпляров компонента с десятком слоёв, именуем всё в соответствии с требованиями плагина, а он подтягивает последовательно в них значения из таблицы: тексты, числа и даже картинки. Синтаксис простой: решетка (ладно, октоторп) + название слоя. Я пока не пользовался этим плагином, но выглядит очень круто и перспективно. Сразу решает уйму проблем с ручным заполнением товарных карточек, пользовательских профайлов и прочей повторяющейся «рыбы». В принципе, мою систему он не ломает, т.к. добавить решётку в начало строки нетрудно.
Есть плагины для работы с (пере)именованием слоёв: [Rename it](https://www.figma.com/c/plugin/731271836271143349/Rename-It), [Layer names transform](https://www.figma.com/c/plugin/734746297902924375/Layer-Names-Transfom), разные нумераторы и др. Я не осилю обозреть их здесь, да и не всеми пользовался вплотную пока. Но очевидно, что при открытом API мы очень скоро получим уйму инструментов для автоматизации. Больше скажу, всё, что я тут накатал про сетки и остальное, в принципе можно воплотить в виде одного-единственного плагина, который будет сам генерировать соответствующие фреймы и стили на основе десятка настроек.
Плагины появились совсем недавно, от силы пару месяцев, но там уже полно вещей, которые облегчают жизнь в разы. При этом открытое API наверняка приведёт к появлению новых аспектов именования и др. Поэтому сильно рекомендую время от времени поглядывать в этот раздел.
### Страницы и фреймы
#### Иерархия компонентов
Названия страниц и фреймов, помимо прочего, включается в иерархию компонентов. На некоторых из скринов, взятых из прототипа моей дизайн-системы (которую я не допилю, наверное, никогда, потому что вместо этого пишу вот эту бесконечную статью), видно, что компоненты там разложены в том числе по страницам.
Первый уровень вложенности в этой цепочке берётся из страницы, второй — из корневого фрейма, третий из названия компонента до слэша, а четвертый — после слэша. Таким образом получается локальная иерархия внутри отдельно взятого файла, даже без подключения внешних библиотек. Всё это можно учитывать при выработке системы именования.
#### Префиксы страниц
Как уже говорилось, я использую квадратные скобки как метки — там, где нужно показать, что нечто не относится непосредственно к главному контексту и является каким-то техническим моментом. В том числе, это касается префиксов страниц. Они бывают разные: [figma], [draft], [components], [prototype] и др. Каждый из них что-то значит для верстальщика.
Например, «[draft]» (черновик), означает, что страница не закончена — всё может в любой момент поменяться, а значит, её содержимое пока нужно игнорировать. “[Prototype]” обычно содержит кучу однотипных фреймов, которые демонстрируют логику отдельно взятого узла (корзины, пользовательского кабинета, системы регистрации и т.п) с использованием встроенных инструментов «Фигмы» для прототипирования.
А «[Figma]» означает, что данная страница нужна исключительно в целях совместимости с какими-то фишками самой «Фигмы». Обычно на первом месте у меня находится «обложка» проекта — страница под названием «[figma] cover». Оттуда берётся превьюшка файла в общем списке + иногда там делается что-то пафосное для презентации клиенту.
Названия без префиксов соответствуют страницам (или темплейтам) сайта. При редизайнах я беру их прямо из ссылочной структуры исходника. Если структура сложная или корявая, иногда дублирую в названии всю цепочку, разделяя уровни чем-нибудь понятным и редкоупотребимым, типа стрелки:
#### Корневые фреймы
С фреймами примерно та же история. что с компонентами. В названиях используются «блок» + «модификатор». Например, на скрине выше «cart», «cart\_empty», «cart\_thanks» и т.п., потому что логически корзина у меня является блоком, а остальные экраны — её модифицированными состояниями. Фреймы вьюпортов называются без затей: mobile, tablet, desktop, desktop+ и обычно хранятся в пределах одной страницы. Исключения бывают, но это уже слишком глубокие частности.
#### Типографика (стили текста)
Опять же, слэш. Группирую в три основных набора:
* desktop — собственно типографика для обычного контента на десктопе;
* mobile — угадайте;
* ui — это стили текстов, которые используются в специфических элементах интерфейса и не зависят от вьюпорта (ну, например, цифры секундомера или шрифт инпута).
Соответственно, имена выглядят как «desktop/paragraph», «mobile/h2», «ui/timer», «ui/basefont», «ui/widget-heading\_active» и др.
### Палитра цветов, стили эффектов
Палитры у меня встречаются следующие:
* theme — стилеобразующие цвета, основная гамма;
* neutral — оттенки условно-серого, которые используются для текста, плашек, границ;
* functional — цвета, имеющие функциональный смысл («ошибка», «успех», состояния ссылок и кнопок);
* additional — комплект по возможности разнообразных оттенков, более-менее сочетающихся с основной гаммой, который используется в интерфейсах для маркировки статусов, индикаторов, выделения всяких списочных элементов, баннеров и т.п.
* gradients — иногда градиенты и фоны выделяются в отдельную группу, просто чтобы не путать их с обычной заливкой и удобнее выносить в переменные CSS.
Именование всё то же: группа + слэш + название + модификатор. Например, «theme/primary», «theme/page-background», «func/link\_visited», «func/warning\_light».
Эффекты группируются по типу. Я использую не так уж много, по большей части тени двух-трёх видов глубины «shadow/\_depth\_deep» (всплывающие окна), «shadow/\_depth\_minimal» (мелкие тени у кнопок и т.п.), «shadow/\_depth\_mid» (средние тени, у выпадающих списков, панелей). Для внутренних теней добавляется модификатор inset.
К слову, второй модификатор везде отделяю плюсом («block/\_mod1+\_mod2+\_mod3»), чтобы не путался со стандартной конструкцией «\_модификатор\_значение». Но, в целом, такой порнографии лучше избегать. Если в проекте подобного много, то можно заменить кучу модификаторов одним общим осмысленным названием. А ля «shadow/\_active-button».
#### Чего надо старательно избегать
* Крайне не рекомендуется привязывать названия (идентификаторов) цветов к конкретным значениям цвета («красный», «телесный», «лазурный» и т.п.). Название должно отражать функцию или область применения, а не фактический оттенок. Значение цвета может измениться в любой момент: редизайн, ребрендинг, новый менеджер у клиента. Поэтому имена типа «button/red» или «bg/yellow» не катят в большинстве случаев.
* Не надо использовать цвета из одной палитры в целях другой. Например, если у вас есть белый цвет в бренде и такой же белый цвет в нейтральной гамме — технически это должны быть два разных цвета (две переменные). Сейчас они совпадают, да. А через год? А в тёмной теме?
* Желательно также не допускать совпадения брендовых цветов с функциональными. Не надо «брендировать» ссылки — оставляйте их классическими сине-голубыми, подгоняйте только оттенок. Если гамма бренда всё-таки с чем-то совпала (красный бренд и красное соощение об ошибке), желательно максимально отдалить их оттенки хотя бы по насыщенности и яркости.
### Конфликт третий. «Неверстабельные» стили и эффекты
***Суть.** Дизайнер создаёт цвета и градиенты путём наложения эффектов или изменения прозрачности. В результате верстальщик запутывается, вынужден сам всё проверять, брать цвета пипеткой и т.п.*
**Решение.** В верстку попадают только те значения, которые вынесены в «официальную» библиотеку стилей и эффектов. Если в макете встречается какая-то отсебятина без внятных комментариев, нужно уведомить дизайнера. Если реакции нет, верстальщик использует наиболее близкий стиль из числа стандартных. Причем ответственность за это перед клиентом лежит на дизайнере. Общий принцип такой: если дизайнер что-то не проработал, значит отдал это на усмотрение верстальщика. А верстальщик вправе применить любой инструмент из принятого стандарта.
#### Как помогает здесь дизайн-система
Вообще, подобное случается со всеми, поскольку прозрачность — самый удобный способ «разбавить» цвет или градиент. А поскольку оттенок редко удаётся подобрать с первого раза, набрасываешь варианты, а потом откатываешь несколько шагов то вперёд, то назад — кое-где промахиваешься, остаются «последствия экспериментов».
Но. Когда точно знаешь, что в вёрстку пойдут только зафиксированные стили, невольно становишься внимательнее. Число вариаций оттенков снижается до адекватного. Да, огрехи могут остаться где-то в копиях, на каких-то отдельных артбордах, но сам экспортируемый стиль обычно приводится в приемлемый вид. При необходимости проверку можно просто включить в чеклист. Тогда перед сдачей макета в вёрстку дизайнер проходится по всему списку стилей и подправляет шероховатости.
Верстальщик же, повторюсь, работает с готовой палитрой. Его не волнуют частности и аномалии, если только они не оговорены специально (но уж в этом-то случае вероятность ошибки минимальна).
#### Стили «Фигмы» — это личинки переменных для сборки
Палитры и эффекты можно использовать в качестве переменных при сборке. В этом случае они выносятся в какой-нибудь соответствующий конфигурационный файл и подтягиваются в стили компонентов каким-ниудь образом, в зависимости от структуры проекта. То есть никаких цветов/градиентов/эффектов кроме «стандартных» в CSS-правилах в идеале быть не должно. Получается, нечто приближенно подобное этому:
```
// named colors
$clr-aqua = #057f99
$clr-aqua-light = #3ebca6
$clr-aqua-dark = #006B81
$clr-violet = #89288f
$clr-violet-deep = #361946
$clr-white = #fff
$clr-white-alt = #f1f4f6
$clr-gray-lightest = #e0f1f1
$clr-gray-light = #dde9f0
$clr-indigo = #5f2d7b
$clr-purple-pink = #a93897
$clr-purple = #89288f
// default theme palette
$clr-primary = $clr-aqua
$clr-primary_light = $clr-aqua-light
$clr-primary_dark = $clr-aqua-dark
$clr-secondary = $clr-violet
$clr-secondary_dark = $clr-violet-deep
$clr-bg-primary = $clr-white
$clr-bg-primary_interlaced = $clr-white-alt
// typography
$clr-basefont = #1b262d
$clr-basefont_mid = #465666
$clr-basefont_light = #607080
$clr-basefont_pale = #b9c0c0
$clr-basefont_invert = #f1f4f6
$clr-link = #1383B4
$clr-headings = $clr-violet-deep
// gradients
$grad-primary = linear-gradient(
-45deg,
$clr-primary-light 0%,
$clr-primary 50%,
$clr-primary-dark 100%
)
// Transparent main gradient is used as an overlay
$grad-primary_overlay = linear-gradient(
-45deg,
rgba($clr-primary-light,.5) 0%,
rgba($clr-primary,.5) 50%,
rgba($clr-primary-dark,.5) 100%
)
// shadows
$shadow-glow_mid = 0px 8px 16px rgba($clr-primary-dark, 0.3)
//...
```
Как видите, система префиксов немножко отличается, чтобы не удлиннять ещё больше селекторы и др. Но идентификаторы цветов по-прежнему фигурируют, поэтому система сохраняется.
Ещё момент: там есть «именованные цвета», которые принимают hex-значение, а потом присваиваются уже «стандартным» цветам. Это делается просто для наглядности, чтобы по контексту файла «видеть» текущую цветовую гамму проекта/темы. Те именованные цвета, в принципе, могут безопасно использоваться где-то и напрямую для каких-то специфических целей, т.к. их hex-значения не меняются никогда. Но по этой же причине их лучше и не плодить.
#### О несовершенстве и перфекционизме
Вообще, палитры у меня пока плохо причёсаны, по историческим причинам: далеко не сразу пришёл к нынешней системе, много переходных проектов. Если кто-то вдруг дочитал досюда внимательно, то мог заметить, что на скринах встречаются отличия в названиях и формулировках, не совсем совпадающие с текстом. Се ля ви. Принципиально не вылизываю, чтобы ни у кого не возникало лишних иллюзий. Дизайн-система не всегда будет идеальной. Она решает много проблем, но то, что вы её применяете, не означает, что в макетах сплошь скачут единороги и порхают бабочки. Есть ещё легаси, цейтнот, человеческий фактор и прочее. Но верстальщики с дизайнерами, как минимум, перестают собачиться по пустякам.
В целом, на мой взгляд, если в работе всё ну очень уж комфортно, правильно, просто и логично, то её должен делать скрипт. Человек тем и хорош, что может обрабатывать непредусмотренные исключения не вываливаясь в синий экран. К тому же, доля здорового пофигизма спасает практичного перфекциониста от превращения в паталогического.
Конфликт четвертый. Экспорт графики
-----------------------------------
***Суть.** Дизайнер отдаёт макет, но у верстальщика не получается выковырять оттуда нужные графический материалы (растровые иллюстрации, фоны, иконки). Фигма не даёт забрать исходники, только обработанный экспорт, чего иногда недостаточно.*
**Решение.** Дизайнер открывает папочку с исходниками и заливает полноразмерные оригиналы картинок (без компрессии) в директорию проекта на рабочем сервере (или в облаке) команды. Верстальщик открывает папочку, находит необходимые материалы по названиям и генерит из них всё, что ему нужно: размерные вариации, спрайты и т.д.
К этому я пришел относительно недавно, когда выяснилось, что фигма никак не отдаёт исходники jpeg/png файлов, которые я заливаю туда с винта. Иногда они нужны.
### Откуда дизайнер берёт «папочку с исходниками»
Дизайнер достаёт её из того места, в котором готовил графику. Растровые картинки из растрового редактора. Векторную — из векторного. Не важно из какого конкретно, это дело дизайнера. Важно другое: полноразмерные файлы должны быть. Даже если что-то сделано в той же «Фигме» с помощью тюнинга изображения, надо экспортнуть оттуда и сохранить файлом. Векторную тоже, просто на всякий случай — пусть в облаке лежит. Это несложно.
### А с чего это вдруг экспортом занимается дизайнер?
Потому что это его компетенция, он в ней сильнее (об этом ещё поговорим ниже). Во-первых, у него есть доступ к исходникам. Во-вторых, он лучше знает свой макет и понимает, что откуда берётся (версии, стоки, лицензии-копирайты и т.п.). В-третьих, если где-то что-то как-то неправльно обрезалось, наложилось, размылось, сплющилось — дизайнеру всё это виднее. Визуальная часть на нём.
### А с чего это вдруг верстальщик должен сам сжимать картинки?
Потому что это его компетенция, он в ней сильнее. Ну да, сейчас это уже скорее вопрос риторический, для симметрии. Кто у нас на сборке, алё. Кто, как не верстальщик, знает требования всех платформ и может автоматизировать своим могучим «Галпом» всё на свете? Конечно, это его вопросы. Дизайнеру туда не нужно лезть без необходимости.
### Как немного упростить себе жизнь и тут
* Хорошо спроектировать структуру проектов в облаке, чтобы всем всё было понятно.
* Настроить синхронизацию. Дизайнер сейвит всё в свою папочку для экспорта, она автоматом летит в облако, а оттуда верстальщик тянет её себе в assets или ещё куда-то там. Это реализуется при желании даже на Гугл.Драйве.
* [Спорно] Использовать версионность в именах файлов — тот же [semver](https://semver.org/lang/ru/) вполне применим и для графики. Грубо говоря, косметическая правка — это патч, смена содержимого — это минор, а изменение размеров и пропорций — это мажор. При необходимости такие файлы можно подтягивать в билды условной логикой и т.п. Но это уже сильно пахнет переинжинирингом.
Конфликт пятый. «Мультиплеер»: доступ к макетам, эффект наблюдателя
-------------------------------------------------------------------
***Суть.** Дизайнер не даёт верстальщику прямого доступа к макету из опасания за сохранность дизайна. «Фигма» хочете денег за каждого нового дизайнера («редактора»). Дизайнеру не нравится работать, когда кто-то в мультиплеере наблюдает за его работой и елозит своим немытым курсором по священным артбордам.*
**Решение.** Изолировать мастер-компоненты (вынести на отдельную глухую и забытую богом страницу и залочить «замками»), а для верстальщика приготовить вместо них «эталонные копии» — проверенные по чеклистам экземпляры, которые он сможет спокойно препарировать. Ну, либо «как всегда»: отдавать ссылку, чтобы верстальщик копировал файл себе в черновики кнопкой «Duplicate to drafts», что бесплатно и снимает вопросы по добавлению «редактора». Стеснительный дизайнер по такому же принципу спокойно работает в своих локальных файлах, а по готовности вываливает изменения в общедоступный файл. Обладатели командных pro-аккаунтов «Фигмы» (насколько я слышал об этих олигархах :) имеют возможность пользоваться библиотеками компонентов по всем проектам и настраивать доступ к каждому, так что там проблема снимается.
Естественно, все эти подходы не лишены недостатков, но если вы используете систему сеток и прочее описанное выше, то работа верстальщика в «Фигме» становится намного проще. И несмотря на все разговоры о былах временах и жалобы на времена и нравы, верстать макет, собранный на компонентах по дизайн-системе, в любом случае удобнее, чем 99% того хаоса, который приходил раньше в .psd-шках.
Да, к слову, ещё момент для верстальщиков, мигрирующих из «Фотошопа», которые не распробовали «Фигму» и испытывают проблемы с производительностью труда. От души рекомендую: изучите её горячие клавиши, особенно те, что предназначены для навигации по слоям и компонентам. Это не блажь в данном случае. Я хорошо помню, что в первые дни знакомства с «Фигмой» сильнее всего раздражала именно необходимость «прокликиваться вглубь» компонентов ради выделения конкретного вложенного слоя. Прямо на стену лез. Но позже, когда освоился с «Ctrl/Cmd + Click», «Enter», «Shift + Enter» и прочим, всё стало *намного* комфортнее и удобнее. Здесь хоткеи это абсолютный must have.
Конфликт шестой. Кто должен делать то или это
---------------------------------------------
***Суть.** Дизайнер пытается сваливать работу на верстальщика, в надежде, что тот будет чистить хвосты и устранять огрехи. А верстальщик навязывает свои потребности и живёт в надежде, что дизайнер «переучится» и начнёт жить и думать как технарь.*
**Решение.** (Помимо всего, что выше). Разделить сферы ответственности, но объединить интересы.
Изначально всё зачастую наоборот: люди пересекают свои сферы ответственности, но выделяют личные интересы. То есть оба постоянно стремятся влезть в процессы друг друга и футболить задачи туда-сюда, но при этом не брать ответственность за эти самые процессы, потому что «это не моя работа». Это можно изменить, если придерживаться пары принципов и понять, что:
### Дружба дизайнера и верстальщика неизбежна
Потому что в конечном счёте они друг от друга очень сильно зависят. Не важно, откуда «спорная» задача возникла. Важно, что она будет висеть *над обоими* и тормозить процессы обоих. И чем быстрее она закроется, тем лучше *обоим*. Дизайнер и верстальщик всегда в одной упряжке, интерес у них общий процентов так на 80: сроки, правки, доход (если есть % со сделки), да даже портфолио — всё взаимозависимо.
Единственное, что может помешать этим людям действовать сообща (помимо организационных косяков руководства) — это непонимание или фрагментарное понимание специфики работы друг друга.
Показательно, что если у верстальщика есть более-менее заметный прикладной опыт дизайна, а у дизайнера — вёрстки, то между ними почти не возникает конфликтов. Они лучше понимают возможности и проблемы друг друга, поэтому ищут оптимальное решение, а не требуют условно невозможного.
### Задачу выполняет не тот, кто «должен» или «виноват», а тот, кому *удобнее* и *проще* добиться нужного результата
Если нужно визуально переколбасить структуру документа, двигая блоки туда-сюда, меняя их местами и т.д. — это делает дизайнер в своем редакторе, потому что это проще, чем переверстывать лейаут. Если нужно пошаманить с числовыми значениями, сжать большую пачку jpeg’ов или, скажем, поэкспериментировать с таймингом анимации, это делает верстальщик, потому что средствами CSS/JS это удобнее.
Классическая надуманная проблема из серии «кто должен экспортировать иконки» у полноценных специалистов сама по себе превращается в «Так, давай я щас всё сам экспортну быстренько, а ты пока допили вон ту хрень, чтобы мы к выходным смогли всё сдать». Это типичнейший расклад. Я уже забыл, когда в последний раз ругался с верстальщиками, хотя на клиентов ору регулярно (шутка с долей шутки :)
### Компетентность проактивна
Никто не любит, когда кто-то вмешивается в его дела. Это само по себе отличная мотивация. Если ты не хочешь, чтобы верстальщик «портил» твой гениальный дизайн, сделай так, чтобы ему пришлось как можно меньше с ним взаимодействовать. И наоборот, если ты действительно прошаренный верстальщик, не дури дизайнеру голову своими заморочками — ты из любого куска торфа конфетку сделаешь быстрее, чем диз поймёт, что ты от него хотел) Так в чём тут повод для конфликтов?
### Как работает эта логика
Пример № 1
Предположим, «Фигма» — мой инструмент. Я решил делать проект в ней. Если у верстальщика что-то с ней не склеится, то он вправе спросить у меня, как выйти из ситуации. И именно я должен буду найти для него решение. При необходимости пролистывая соответствующие мануалы, загугливая и даже тестируя. Почему так? Да потому, что это моя «епархия». Предполагается, что из нас двоих именно я в ней царь-боженька. А значит и ответственность за эту сторону коммуникации на мне.
И обратная сторона медали: верстальщика вообще не должно волновать, как я рисую макеты: в «Фигме», в «Люстре», в «Пэинте» или какашками на стенах. Это мой творческий процесс. Но при этом я должен обеспечить соответствие между моим процессом и каким-то универсальным стандартом, который его устроит.
Сферы разделены, интересы общие — нет конфликта.
Пример № 2
Тру стори. Однажды я решил стать образцово-показательным пионером и пошел к одному хорошему верстальщику с вопросом: как мне лучше структурировать для него макеты. Мол, чего тебе надобно, старче. Проси, что хочешь. Ответ цитирую дословно (извините): «Да пох\*й. Я хоть с пээнгэшки заверстаю. Ты, главное, нарисуй». И восхитился я тогда мудростью святого старца и ушёл, просветлённый.
Сферы разделены, интересы общие — нет конфликта.
Думаю, примеры пояснят, почему мне диковато слышать жалобы верстальщиков на то, что их дизайнер где-то там пару пикселей не вымерил микрометром. Или наоборот: нытьё дизайнеров о том, что злой верстак заставил их переименовать «Rectangle 1» в «Button».
Итого
-----
Принципы дизайн-системы для решения конфликтов:
* Используем «магические» стандарты для числовых значений.
* Именуем всё правильно.
* Фиксируем стили и палитры.
* Храним исходники картинок.
* Изолируем мастер-компоненты (если нужно).
* Разделяем компетенции.
(Да, я раскатал это на несколько десятков экранов. Но иначе не получалось).
Спасибо всем, кто осилил хотя бы часть. Надеюсь, вы сумеете извлечь из этого какую-то пользу для себя.
Рекламировать мне нечего, но если вам непременно хочется пройти по ссылке в описании, то сходите, например, к этим людям:
[kamushken](https://habr.com/ru/users/kamushken/) — статьи про дизайн-системы и «Фигму»;
[mkoloskov](https://habr.com/ru/users/mkoloskov/) — статьи про БЭМ;
[vasyay](https://habr.com/ru/users/vasyay/) — статьи про управление студией.
P.S. Если статья была для вас полезной, не стесняйтесь сказать об этом в комментариях — они помогут понять, есть ли какой-то смысл писать для Хабра подобные талмуды.
Успехов! | https://habr.com/ru/post/464115/ | null | ru | null |
# Вещание онлайн-видео с помощью nginx
#### Что такое онлайн-видео?
Под термином онлайн-видео я понимаю длительное вещание какого-то живого видеосигнала (к примеру, из телестудии). Традиционные средства отдачи видео (flv- и mp4-стриминг) в данном случае не работают, просто потому что файла, содержащего весь видеопоток, не существует.
В этой статье речь будет идти не об организации видеохостинга, а об организации видеовещания в прямом эфире. Это две принципиально разные задачи, и обычно способы их решения существенно отличаются друг от друга.
#### RTMP-протокол
RTMP — Real Time Messaging Protocol ([вики](http://ru.wikipedia.org/wiki/RTMP)) — протокол, который обычно используется для раздачи живого видео- и аудиоконтента клиентам. Он удобен тем, что в AS3 есть его поддержка из коробки, требует не слишком много ресурсов на клиенте и поддерживает множество плюшек (например, трансляцию с переменными битрейтами и переключение клиентов на более высокое качество при наличии свободного канала).
###### NB: Помимо RTMP существует набор других протоколов вещания медиапотоков (RTSP, Apple HTTP Live Streaming и др.), но в этой статье они не рассматриваются.
Протокол RTMP — детище компании Adobe. Единственным официальным сервером, которым можно вещать RTMP-поток, является Adobe Flash Media Server. Его цена и производительность, к сожалению, оставляют желать лучшего, поэтому различными разработчиками были предприняты попытки создать более или менее совместимые альтернативные реализации протокола. К сожалению, у RTMP-протокола есть известные проблемы с лицензированием, к примеру, его официальная спецификация, если следовать ей строго, не позволяет написать работающий RTMP-сервер. Тем не менее, существует несколько реализаций:
* [Red5](http://www.red5.org/) — один из первых RTMP-серверов, написан на Java
* [Wowza](http://www.wowza.com/) — проприетарный RTMP-сервер, написан на Java. Помимо RTMP, поддерживает также RTSP, Apple HLS, и Smoothstreaming (Silverlight).
* [erlyvideo](http://erlyvideo.org/) — свободный RTMP-сервер с отдельно распространяющимися проприетарными модулями, написан на Erlang. Проект пишется русскими программистами и активно развивается.
#### Java тормозит
В тестах, которые я проводил, Red5 и Wowza показали неприлично низкую производительность. При мегабитном видеопотоке Wowza при 1000 зрителей онлайн съедала уже около 300% процессорного времени (Intel Xeon E5607). Если требуется вещать хотя бы для 20000 человек онлайн, то нужно закупать 20 серверов? Это слишком дорого.
#### Что же делать?
Использовать неблокирующие операции. Тормоза в Wowza и Red5 следуют из-за далеко не самой оптимальной схемы обработки событий. Для реализации действительно быстрого стримингового сервера, нужно использовать эффективный метод обработки событий (для linux это epoll). Именно такую схему работы и реализовал Роман Арутюнян ([блог](http://rarut.wordpress.com/), [github-профиль](https://github.com/arut/), [rarutyunyan](http://habrahabr.ru/users/rarutyunyan/)) в [своём RTMP-сервере](https://github.com/arut/nginx-rtmp-module), реализованном как модуль к nginx.
#### nginx-rtmp-module
Достоинства:
* Нереально шустрый. На том же физическом сервере, который я использовал для тестов Wowza, nginx выдержал 2500 мегабитных соединений на ядро, т.е. 10000 на весь сервер целиком.
* Удобные конфиги :). После километровых XML-конфигов Wowza эти выглядят спасением.
* Отзывчивость автора к фичреквестам.
Недостатки:
* Проект молодой, наличествуют баги, которые, впрочем, оперативно исправляются.
* Небольшая функциональность. Сервер вещает только в RTMP, перекодировка появилась буквально несколько дней назад, имеет статус экспериментальной и фактически является обёрткой над ffmpeg. UNIX-way во всей своей красе.
* Нет многопоточности. Модуль может работать только в том случае, если nginx запускается с одним воркером. Для утилизации всех процессорных ядер нужно запускать несколько воркеров на разных IP-адресах и/или портах.
Многопоточность можно реализовать с помощью примерно такого костыля (Ubuntu):
```
for ip in $(cat /etc/network/interfaces | grep address | awk '{print $2}') ; do
touch /etc/nginx/nginx.$ip.conf
cp /etc/nginx/nginx.conf.skel /etc/nginx/nginx.$ip.conf
sed -i "s/%IPADDR%/${ip}/g" /etc/nginx/nginx.$ip.conf
/usr/sbin/nginx -c /etc/nginx/nginx.$ip.conf
done
```
При этом у вас должен быть написан скелет конфига с указанием %IPADDR% вместо IP-адреса. Например, такой:
```
worker_processes 1;
error_log logs/error.%IPADDR%.log debug;
pid /var/run/nginx.%IPADDR%.pid;
worker_rlimit_nofile 65536;
events {
worker_connections 16384;
}
rtmp {
server {
listen %IPADDR%:1935;
chunk_size 4000;
application live {
live on;
pull live stream %masterIP%;
}
}
}
http {
server {
listen %IPADDR%:8080;
location /stat {
rtmp_stat all;
rtmp_stat_stylesheet stat.xsl;
}
location /stat.xsl {
root /srv/nginx/html;
}
}
}
```
Впрочем, автор обещает реализовать нормальную многопоточность в будущих релизах.
С помощью nginx-rtmp-module мне удалось полностью утилизировать 10-гигабитный канал. При этом основной проблемой стала вовсе не прожорливость самого nginx, а необходимость тюнинга сетевой карты и параметров ядра, чтобы software interrupts не съедали 100% CPU.
#### Ссылки по теме:
[RTMP на Википедии](http://ru.wikipedia.org/wiki/RTMP)
[Wowza — официальный сайт](http://www.wowza.com/media-server)
[Erlyvideo — официальный сайт](http://erlyvideo.org/)
[Nginx-rtmp-module — проект на GitHub](https://github.com/arut/nginx-rtmp-module) | https://habr.com/ru/post/145867/ | null | ru | null |
# Зачем использовать статические типы в JavaScript? (Преимущества и недостатки)
Мы о многом рассказали в [первой части](https://habrahabr.ru/post/326304/). Теперь с синтаксисом покончено, давайте наконец перейдём к самому интересному: изучению преимуществ и недостатков использования статических типов.
### Преимущество № 1: Вы можете заблаговременно находить баги и ошибки
Статическая проверка типов позволяет проверять, что определённый нами инвариант принимает значение `true`, даже не запуская программу. И если имеется какое-то нарушение этих инвариантов, оно будет обнаружено перед запуском программы, а не во время её работы.
Небольшой пример: предположим, что у нас небольшая функция, которая берёт радиус и вычисляет площадь:
```
const calculateArea = (radius) => 3.14 * radius * radius;
var area = calculateArea(3);
// 28.26
```
Теперь если мы захотим передать функции радиус, который не является числом (типа «злоумышленник»)…
```
var area = calculateArea('im evil');
// NaN
```
Нам вернётся `NaN`. Если какая-то функциональность основана на том, что функция `calculateArea` всегда возвращает число, то это приведёт к уязвимости или сбою. Не очень приятно, правда?
Если бы мы использовали статические типы, то определили бы конкретный тип передаваемых параметров и возвращаемых значений для этой функции:
```
const calculateArea = (radius: number): number => 3.14 * radius * radius;
```
Попробуйте теперь передать что-нибудь кроме числа функции `calculateArea` — и Flow вернёт удобное и симпатичное сообщение:
```
calculateArea('Im evil');
^^^^^^^^^^^^^^^^^^^^^^^^^ function call
calculateArea('Im evil');
^^^^^^^^^ string. This type is incompatible with
const calculateArea = (radius: number): number => 3.14 * radius * radius;
^^^^^^ number
```
Теперь у нас есть гарантия, что функция будет принимать только валидные числа на входе и возвращать результат только в виде валидных чисел.
Поскольку контролёр типов сообщает вам об ошибках прямо во время написания кода, это намного удобнее (и намного дешевле), чем поиск бага после того, как код отправлен заказчику.
### Преимущество № 2: У вас появляется живая документация
Типы работают как живая, дышащая документация и для вас, и для других.
Чтобы понять каким образом, посмотрим на метод, который я однажды нашла в большой кодовой базе, с которой работала:
```
function calculatePayoutDate(quote, amount, paymentMethod) {
let payoutDate;
/* business logic */
return payoutDate;
}
```
На первый взгляд (и на второй, и на третий), совершенно непонятно, как использовать эту функцию.
Является ли quote числом? Или логическим значением? Платёжный метод — это объект? Или это может быть строка, которая представляет тип платёжного метода? Возвращает ли функция дату в строковом виде? Или это объект `Date`?
Без понятия.
В то время я решила провести оценку всей деловой логики и делала grep по кодовой базе до тех пор, пока всё не выяснила. Но это слишком много работы только для того, чтобы понять, как работает простая функция.
С другой стороны, если бы написали что-то вроде такого:
```
function calculatePayoutDate(
quote: boolean,
amount: number,
paymentMethod: string): Date {
let payoutDate;
/* business logic */
return payoutDate;
}
```
то немедленно стало бы ясно, какой тип данных функция принимает, а какой тип возвращает. Это пример того, как можно использовать статические типы для сообщения того, что функция *намерена* делать. Мы можем сообщить другим разработчикам, чего ожидаем от них, и можем увидеть, чего они ожидают от нас. Следующий раз, если кто-то соберётся использовать эту функцию, вопросов не возникнет.
Можно поспорить, что эта проблема решается добавлением комментариев к коду или документации:
```
/*
@function Determines the payout date for a purchase
@param {boolean} quote - Is this for a price quote?
@param {boolean} amount - Purchase amount
@param {string} paymentMethod - Type of payment method used for this purchase
*/
function calculatePayoutDate(quote, amount, paymentMethod) {
let payoutDate;
/* .... Business logic .... */
return payoutDate;
};
```
Это работает. Но здесь гораздо больше слов. Кроме многословности, такие комментарии в коде трудно поддерживать, потому что они ненадёжные и не имеют структуры — некоторые разработчики пишут хорошие комментарии, а другие могут написать что-то непонятное, а некоторые вообще могут забыть оставить комментарий.
Особенно легко забыть обновить комментарий после рефакторинга. С другой стороны, у аннотаций типов чётко определённый синтаксис и структура, и они никогда не устареют, потому что закодированы в самом коде.
### Преимущество № 3: Устраняется обработка запутанных ошибок
Типы помогают устранить обработку в коде запутанных ошибок. Давайте вернёмся к нашей функции `calculateArea` и посмотрим, каким образом это происходит.
На этот раз я передам ей массив радиусов для вычисления площадей для каждого радиуса:
```
const calculateAreas = (radii) => {
var areas = [];
for (let i = 0; i < radii.length; i++) {
areas[i] = PI * (radii[i] * radii[i]);
}
return areas;
};
```
Эта функция работает, но неправильно обрабатывает некорректные входные аргументы. Если мы захотим убедиться, что функция правильно обрабатывает ситуации, когда входные аргументы не являются валидными массивами чисел, то придём к функции примерно такого вида:
```
const calculateAreas = (radii) => {
// Handle undefined or null input
if (!radii) {
throw new Error("Argument is missing");
}
// Handle non-array inputs
if (!Array.isArray(radii)) {
throw new Error("Argument must be an array");
}
var areas = [];
for (var i = 0; i < radii.length; i++) {
if (typeof radii[i] !== "number") {
throw new Error("Array must contain valid numbers only");
} else {
areas[i] = 3.14 * (radii[i] * radii[i]);
}
}
return areas;
};
```
Ого. Тут много кода для такого маленького кусочка функциональности.
А со статическими типами мы просто напишем:
```
const calculateAreas = (radii: Array): Array => {
var areas = [];
for (var i = 0; i < radii.length; i++) {
areas[i] = 3.14 \* (radii[i] \* radii[i]);
}
return areas;
};
```
Теперь функция действительно выглядит так, как она выглядела перед добавлением всего визуального мусора из-за обработки ошибок.
Легко понять преимущества статических типов, правда?
### Преимущество № 4: Вы можете увереннее осуществлять рефакторинг
Объясню это историей из жизни. Однажды я работала с очень большой кодовой базой, и нужно было обновить метод, установленный в классе `User`. В частности, изменить один из параметров функции со `string` на `object`.
Я произвела изменение, но мне было страшно отправлять коммит — по всему коду разбросано так много вызовов к этой функции, что я не была уверена, что правильно обновила все экземпляры. Что если какой-то вызов остался где-то глубоко в непроверенном вспомогательном файле?
Единственный способ проверить — это отправить код и молиться, что он не взорвётся кучей ошибок.
При использовании статических типов такой проблемы не возникнет. Там у меня будет мир и спокойствие в душе: если я обновлю функцию и определения типов, то контролёр типов будет рядом и обнаружит все ошибки, которые я могла упустить. Останется только пройтись по этим ошибкам типов и исправить их.
### Преимущество № 5: Разделение данных и поведения
Одно редко упоминаемое преимущество статических типов состоит в том, что они помогают отделяют данные от поведения.
Ещё раз посмотрим на нашу функцию `calculateArea` со статическими типами:
```
const calculateAreas = (radii: Array): Array => {
var areas = [];
for (var i = 0; i < radii.length; i++) {
areas[i] = 3.14 \* (radii[i] \* radii[i]);
}
return areas;
};
```
Подумайте, как бы мы подошли к составлению этой функции. Поскольку мы указываем типы данных, то вынуждены в первую очередь думать о типах данных, которые собираемся использовать, чтобы можно было соответствующим образом установить типы для передаваемых параметров и возвращаемых значений.
Только после этого мы реализуем логику:
Возможность точно выразить данные отдельно от поведения позволяет явно указать наши предположения и более точно передать намерение, что снимает определённую ментальную нагрузку и даёт программисту определённую ясность ума. Иначе остаётся держать всё в уме каким-то образом.
### Преимущество № 6: Устранение целой категории багов
Ошибки типов во время выполнения программы — одна из самых распространённых ошибок или багов, с которыми сталкиваются JavaScript-разработчики.
Например, предположим, что изначальное состояние приложения было установлено так:
```
var appState = {
isFetching: false,
messages: [],
};
```
И предположим, что затем мы делаем вызов API, чтобы забрать сообщения и заполнить наш `appState`. Далее, у нашего приложения есть чрезмерно упрощённый компонент для просмотра, который забирает `messages` (указанные в состоянии выше) и отображает количество непрочитанных сообщений и каждое сообщение как элемент списка:
```
import Message from './Message';
const MyComponent = ({ messages }) => {
return (
You have { messages.length } unread messages
=============================================
{ messages.map(message => )}
);
};
```
Если вызов API для забора сообщений не сработал или вернул `undefined`, то вы столкнётесь с ошибкой типа в продакшне:
```
TypeError: Cannot read property ‘length’ of undefined
```
…и ваша программа завершится со сбоем. Вы потеряете клиента. Занавес.
Посмотрим, как могут помочь статические типы. Начнём с добавления типов Flow к состоянию приложения. Я использую псевдоним типа `AppState` для определения состояния:
```
type AppState = {
isFetching: boolean,
messages: ?Array
};
var appState: AppState = {
isFetching: false,
messages: null,
};
```
Поскольку известно, что API для забора сообщений работают ненадёжно, то укажем для значения `messages` тип `maybe` для массива строк.
Так же как в прошлый раз, мы забираем сообщения через ненадёжный API и используем их в компоненте просмотра:
```
import Message from './Message';
const MyComponent = ({ messages }) => {
return (
You have { messages.length } unread messages
=============================================
{ messages.map(message => )}
);
};
```
Но в этот момент Flow обнаружит ошибку и пожалуется:
```
You have {messages.length} unread messages
===========================================
^^^^^^ property `length`. Property cannot be accessed on possibly null value
You have {messages.length} unread messages
===========================================
^^^^^^^^ null
You have {messages.length} unread messages
===========================================
^^^^^^ property `length`. Property cannot be accessed on possibly undefined value
You have {messages.length} unread messages
===========================================
^^^^^^^^ undefined
{ messages.map(message => )}
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call of method `map`. Method cannot be called on possibly null value
{ messages.map(message => )}
^^^^^^^^ null
{ messages.map(message => )}
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call of method `map`. Method cannot be called on possibly undefined value
{ messages.map(message => )}
^^^^^^^^ undefined
```
Погоди, приятель!
Поскольку мы определили `messages` как тип `maybe`, мы разрешаем ему быть `null` или `undefined`. Но это не даёт нам права проводить операции с ним (вроде `.length` или `.map`) без осуществления проверки на `null`, потому что если значение `messages` на самом деле `null` или `undefined`, то выскочит ошибка типа при попытке проведения операции с ним.
Так что вернёмся и обновим нашу функцию для просмотра примерно таким образом:
```
const MyComponent = ({ messages, isFetching }: AppState) => {
if (isFetching) {
return Loading...
} else if (messages === null || messages === undefined) {
return Failed to load messages. Try again.
} else {
return (
You have { messages.length } unread messages
=============================================
{ messages.map(message => )}
);
}
};
```
Теперь Flow знает, что мы учли все ситуации, где `messages` равно `null` или `undefined`, так что проверка типов кода завершается с 0 ошибок. Прощайте, ошибки во время выполнения программы!
### Преимущество № 7: Уменьшение количества юнит-тестов
Раньше мы видели, как статические типы помогают избавиться от разбора запутанных ошибок, потому что они гарантируют типы передаваемых функции параметров и возвращаемых значений. Как следствие, статические типы также уменьшают количество юнит-тестов.
Например, вернёмся к нашей функции `calculateAreas` с динамическими типами и обработкой ошибок.
```
const calculateAreas = (radii) => {
// Handle undefined or null input
if (!radii) {
throw new Error("Argument is missing");
}
// Handle non-array inputs
if (!Array.isArray(radii)) {
throw new Error("Argument must be an array");
}
var areas = [];
for (var i = 0; i < radii.length; i++) {
if (typeof radii[i] !== "number") {
throw new Error("Array must contain valid numbers only");
} else {
areas[i] = 3.14 * (radii[i] * radii[i]);
}
}
return areas;
};
```
Если бы мы были прилежными программистами, то могли бы подумать о тестировании недействительных передаваемых параметров для проверки, что они корректно обрабатываются нашей программой:
```
it('should not work - case 1', () => {
expect(() => calculateAreas([null, 1.2])).to.throw(Error);
});
it('should not work - case 2', () => {
expect(() => calculateAreas(undefined).to.throw(Error);
});
it('should not work - case 2', () => {
expect(() => calculateAreas('hello')).to.throw(Error);
});
```
… и так далее. Но очень вероятно, что мы забудем протестировать какие-то граничные случаи, — и наш заказчик будет тем, кто обнаружит проблему. :(
Поскольку тесты основаны исключительно на ситуациях, какие мы придумали протестировать, то они экзистенциальные, а на практике их легко обойти.
С другой стороны, когда нам требуется установить типы:
```
const calculateAreas = (radii: Array): Array => {
var areas = [];
for (var i = 0; i < radii.length; i++) {
areas[i] = 3.14 \* (radii[i] \* radii[i]);
}
return areas;
};
```
… мы не только получаем гарантию, что наша цель соответствует реальности, но такие тесты попросту надёжнее. В отличие от тестов на эмпирической основе, типы универсальны и их труднее обойти.
Если взглянуть в целом, то картина такова: тесты хороши для проверки логики, а типы — для проверки типов данных. Когда они сочетаются, то сумма частей даёт ещё больший эффект.
### Преимущество № 8: Инструмент моделирования предметной области
Один из моих любимых примеров использования статичных типов — моделирование предметной области (domain modeling). В этом случае создаётся модель, которая включает в себя и данные, и поведение программы на этих данных. В данном случае лучше всего понять на примере, как использовать типы.
Предположим, что в приложении пользователю предлагается один или больше платёжных методов для совершения покупок на платформе. Пользователю разрешено выбрать из трёх платёжных методов (Paypal, кредитная карта, банковский счёт).
Итак, сначала применим псевдонимы типов для трёх платёжных методов:
```
type Paypal = { id: number, type: 'Paypal' };
type CreditCard = { id: number, type: 'CreditCard' };
type Bank = { id: number, type: 'Bank' };
```
Теперь можно установить тип `PaymentMethod` как непересекающееся множество с тремя случаями:
```
type PaymentMethod = Paypal | CreditCard | Bank;
```
Теперь составим модель состояния нашего приложения. Чтобы не усложнять, предположим, что данные приложения состоят только из платёжных методов, доступных пользователю.
```
type Model = {
paymentMethods: Array
};
```
Это приемлемо? Ну, мы знаем, что для получения платёжных методов пользователя нужно сделать запрос к API и, в зависимости от результата и этапа процесса, приложение может принимать разные состояния. В реальности, возможно четыре состояния:
1) Мы не получили платёжные методы.
2) Мы в процессе получения платёжных методов.
3) Мы успешно получили платёжные методы.
4) Мы попытались получить платёжные методы, но возникла ошибка.
Но наш простой тип `Model` с `paymentMethods` не покрывает все эти случаи. Вместо этого он предполагает, что `paymentMethods` всегда существует.
Хм-м-м. Существует ли способ составить модель, чтобы состояние приложения принимало одно из этих четырёх значений, и только их? Давайте посмотрим:
```
type AppState
= { type: 'NotFetched' }
| { type: 'Fetching' }
| { type: 'Failure', error: E }
| { type: 'Success', paymentMethods: Array };
```
Мы использовали тип непересекающегося множества для установки `AppState` в одно из четырёх состояний, описанных выше. Заметьте, как я использую свойство `type` для определения, в каком из четырёх состояний находится приложение. Именно это свойство `type` и является тем, что создаёт непересекающееся множество. Используя его мы можем осуществить анализ и определить, когда у нас есть платёжные методы, а когда нет.
Вы также заметите, что я передаю параметризованный тип `E` и `D` в состояние приложения. Тип `D` будет представлять собой платёжный метод пользователя (`PaymentMethod`, определённый выше). Мы не установили тип `E`, который будет нашим типом для ошибки, так что сделаем это сейчас:
```
type HttpError = { id: string, message: string };
```
Теперь можно смоделировать предметную область приложения:
```
type Model = AppState;
```
В целом, подпись для состояния приложения теперь `AppState`, где `E` имеет форму `HttpError`, а `D` — это `PaymentMethod`. И у `AppState` есть четыре (и только эти четыре) возможных состояния: `NotFetched`, `Fetching`, `Failure` и `Success`.
Такие модели предметной области мне кажутся полезными для размышлений и разработки пользовательских интерфейсов в соответствии с определёнными бизнес-правилами. Бизнес-правила говорят нам, что приложение может быть только в одном из этих состояний, и это позволяет нам явно представить AppState и гарантировать, что оно будет только в одном из этих заранее установленных состояний. И когда мы разрабатываем по этой модели (например, создаём компонент для просмотра), становится абсолютно очевидно, что нужно обработать все четыре возможных состояния.
Более того, код документирует сам себя — достаточно посмотреть на непересекающиеся множества, и немедленно становится понятно, как структурирован AppState.
Недостатки использования статических типов
==========================================
Как и всё остальное в жизни и программировании, проверка статических типов требует некоторых компромиссов.
Важно понять и признать эти недостатки, чтобы мы могли принять информированное решение, когда имеет смысл использовать статические типы, а когда они просто не стоят того.
Вот некоторые из этих соображений:
### Недостаток № 1: Статические типы требуют предварительного изучения
Одна причина, почему JavaScript — такой фантастический язык для начинающих, состоит в том, что новичкам не требуется изучать полную систему типов перед началом продуктивной работы.
Когда я только выучила Elm (функциональный язык со статической типизацией), типы часто мешали. Я постоянно сталкивалась с ошибками компилятора из-за своих определений типов.
Изучение эффективного использования типов — это была половина успеха в изучении самого языка. В итоге, из-за статических типов кривая обучения Elm круче, чем у JavaScript.
Это особенно важно для начинающих, у которых максимально велика когнитивная нагрузка от изучения синтаксиса. Добавление синтаксиса в этот набор может сокрушить новичка.
### Недостаток № 2: Можно увязнуть в многословии
Из-за статических типов программы часто выглядят более многословными и загромождёнными.
Например, вместо этого:
```
async function amountExceedsPurchaseLimit(amount, getPurchaseLimit){
var limit = await getPurchaseLimit();
return limit > amount;
}
```
Нам приходится писать:
```
async function amountExceedsPurchaseLimit(
amount: number,
getPurchaseLimit: () => Promise
): Promise {
var limit = await getPurchaseLimit();
return limit > amount;
}
```
А вместо этого:
```
var user = {
id: 123456,
name: 'Preethi',
city: 'San Francisco',
};
```
Приходится писать такое:
```
type User = {
id: number,
name: string,
city: string,
};
var user: User = {
id: 123456,
name: 'Preethi',
city: 'San Francisco',
};
```
Очевидно, что добавляются лишние строки кода. Но есть парочка аргументов против того, чтобы считать это недостатком.
Во-первых, как мы упомянули раньше, статические типы уничтожают целую категорию тестов. Некоторые разработчики могут посчитать это совершенно разумным компромиссом.
Во-вторых, как мы видели раньше, статические типы иногда могут устранить необходимость обработки сложных ошибок, и это, в свою очередь, значительно уменьшает загромождённость кода.
Сложно сказать, является ли многословность реальным аргументом против типов, но стóит держать его в уме.
### Недостаток № 3: Требуется время для достижения мастерства в использовании типов
Требуется много времени и практики, чтобы научиться наилучшим образом выбирать типы в программе. Более того, выработка хорошего чутья на то, что стоит отслеживать статически, а что лучше оставить в динамическом виде, тоже требует аккуратного подхода, практики и опыта.
Например, один из подходов такой: закодировать критическиую бизнес-логику статическими типами, но оставить краткосрочные или неважные фрагменты логики динамическими, чтобы избежать излишней сложности.
Понять разницу бывает трудно, особенно если менее опытному разработчику приходится принимать решения на лету.
### Недостаток № 4: Статические типы могут задержать быструю разработку
Как я упоминала ранее, я слегка споткнулась о типы, когда изучала Elm — особенно когда добавляла код или делала изменения в нём. Постоянно отвлекаясь на ошибки компилятора, трудно делать работу и чувствовать прогресс.
Здесь аргумент в том, что из-за проверки статических типов программист может слишком часто терять концентрацию — а вы знаете, концентрация является ключевым фактором для написания хорошей программы.
Дело не только в этом. Контролёры статических типов тоже не всегда идеальны. Иногда возникает ситуация, когда вы знаете что делать, а проверка типов вмешивается и мешает.
Уверена, что я упустила какие-то ещё недостатки, но это самые важные для меня.
Нужно использовать статические типы в JavaScript или нет?
=========================================================
Первыми языками программирования, которые я изучила, были JavaScript и Python, оба языка с динамической типизацией.
Но освоение статических типов добавило новое измерение в то, как я думаю о программировании. Например, хотя я считала постоянные сообщения об ошибках компилятора в Elm подавляющими в первое время, потом определение типов и «угождение компилятору» стало второй натурой и на самом деле улучшило мои навыки программирования. Вдобавок, нет ничего более освобождающего, чем умный робот, который говорит мне, что я делаю что-то не так и как это исправить.
Да, есть неизбежные компромиссы статических типов, такие как излишняя многословность и необходимость тратить время на их изучение. Но типы добавляют безопасность и корректность в программы, что устраняет значимость этих «недостатков» для меня лично.
Динамические типы кажутся более быстрыми и простыми, но они могут подвести, когда вы реально запускаете программу в деле. В то же время можете поговорить с любым Java-разработчиком, который имеет дело с более сложными параметризованными типам — и он скажет, как сильно их ненавидит.
В конечном счёте, здесь нет универсального решения. Лично я предпочитают использовать статические типы при следующих условиях:
1. Программа критически важна для вашего бизнеса.
2. Программа, вероятно, подвергнется рефакторингу, в соответствии с новыми потребностями.
3. Программа сложна и имеет много подвижных частей.
4. Программу поддерживает большая группа разработчиков, которым нужно быстро и точно понять код.
С другой стороны, я бы отказалась от статических типов в следующих условиях:
1. Код недолговечный и не является критически важным.
2. Вы делаете прототип и стараетесь продвигаться как можно быстрее.
3. Программа маленькая и/или простая.
4. Вы единственный разработчик.
Преимущество разработки на JavaScript в наши дни состоит в том, что благодаря инструментам вроде Flow и TypeScript у нас наконец-то появился выбор — использовать статические типы или старый добрый JavaScript.
Заключение
==========
Надеюсь, эти статьи помогли вам понять важность типов, как их использовать и, самое главное, *\*когда\** их использовать.
Возможность переключаться между динамическими и статическими типами — это мощный инструмент для JavaScript-сообщества, и захватывающий :)
Об авторе: Прити Касиредди (Preethi Kasireddy), сооснователь и ведущий инженер компании Sapien AI, Калифорния | https://habr.com/ru/post/326394/ | null | ru | null |
# Удаленное выполнение кода на EBay
В мире информационной безопасности пока еще не всё так гладко, как хотелось бы. Примеров этому много, стоит посмотреть последние новости на тематических сайтах, как в голову приходит мысль о том, что, порой даже крупнейшие компании уделяют ИБ недостаточно внимания. В этот раз под прицел попал EBay.
Для тех, кто не знаком с EBay, советую перейти по [ссылке](http://ru.wikipedia.org/wiki/EBay), а мы продолжаем.
13 декабря этого года David Vieira-Kurz, [обнаружил на одном из поддоменов ебэя](http://secalert.net/2013/12/13/ebay-remote-code-execution/), удалённое выполнение кода, или попросту — RCE.
Уязвимый участок кода находился на домене sea.ebay.com, в функционале поиска. Типичная ссылка для поиска выглядит примерно так: `sea.ebay.com/search/?q=david&catidd=1`. Но тут не все так просто, поскольку php использует динамическую типизацию, значит, возможно появление подводных камней. Первым делом Дэвид отправил вместо строки массив q[]. Но в ответ пришел нормальный результат, характерный для запроса типа строки. После чего ресерчер решил передать сразу несколько элементов массива q[], а в качестве, одного из элементов передать php код для вызова функции phpinfo. В результате строка запроса приобрела вид: `sea.ebay.com/search/?q=1&catidd=1&q[0]=2&q[1]={${phpinfo()}}`
Отлично, результат получен.
Учитывая, что данная уязвимость является критичной, можно предположить, что будь на месте Дэвида «чёрный» хакер, веб сервер был бы у него в кармане, не исключен и доступ к базе данных основного домена.
Поскольку Дэвид не преследовал корыстных целей, он сообщил об уязвимости тех. поддержке ебэя, которая в течении короткого времени ликвидировала данную дырку. Так как автор не смотрел исходный код скрипта, появилось предположение, что уязвимый участок кода выглядит примерно так:
```
foreach($_GET['q'] as $data)
{
if ($data проходит по некоторым фильтрам) {
eval("происходит выполнение $data");
}
}
```
Кроме текста есть еще и видео с демонстрацией:
**Проверяйте свой код на наличие подобных участков, это может обезопасить вас в будущем.** | https://habr.com/ru/post/206566/ | null | ru | null |
# Что, черт возьми, такое гидратация и регидратация?
*Если процесс frontend разработки привёл вас к вопросу SEO оптимизации, то почти наверняка, вы столкнётесь с понятием Server Side Rendering (SSR) и тесно связанной с ним **гидратацией** (или регидратацией). Представленная ниже информация является переводом в очень свободной форме и дополненным некоторыми особенностями, с целью прояснить subject.*
### Рассвет одностраничных приложений SPA
Модель одностраничных приложений The Single Page Application (SPA) набрала высокую популярность за последние несколько лет. Оно и понятно, этот подход даёт определённый профит по скорости, качеству обслуживания и создаёт основу для новых паттернов клиентской веб-разработки.
Как все, я думаю, прекрасно знают, SPA работает внутри браузера и не требует перезагрузки страницы во время использования.
Супер идея! Но, конечно, есть «подводные камни».
В числе самых распространённых случаев (если взять любой tutorial по react или vue) главная страница index.html содержит практически пустой HTML-файл с небольшим количеством глобальных для всего проекта ссылок CSS, JavaScript, шрифты и т.п.
И это проблема:
* В процессе первоначальный рендеринг пользователю придётся ждать загрузки всей кодовой базы и всех ресурсов (конечно, есть исключения, и можно реализовать динамическую подгрузку так называемых js / css чанков, но это отдельная история)
* Некоторые сканеры или парсеры, которые не умеют дожидаться подгрузки асинхронных запросов, просто увидят все страницы пустыми
Ну вы поняли:
```
My first SPA app
...
бла бла бла, регистрация приложения
...
```
### Рендеринг на стороне сервера SSR
В отличие от рендеринга на стороне клиента Client Side Rendering (CSR), который использует браузер для рендеринга всего содержимого приложения и получения данных с API и т.п., SSR использует… сервер. То есть, всё тот же рендеринг и получение данных обрабатывается сервером (NodeJS с помощью фреймворков Express, Next, Vue SSR, Nuxt или что там ещё...), а затем ответ с разметкой HTML, стилями, скриптами и полученными данными с API, отправляется браузеру.
Таким образом, вы можете использовать преимущества двух подходов: скорость / SEO и интерактивность / UX.
### И так, всё же, что такое гидратация / регидратация?
Регидратация — это своего рода мост между SSR и CSR.
Существует такой показатель производительности веб страницы, как First Contentful Paint (FCP) — в приближённом переводе будет звучать как 'первая значимая отрисовка' — время, когда браузер начал отображать любой текст, изображения (включая фоновые). Это первые элементы, которые пользователь увидит на странице. Создав отчёт с помощью Lighthouse в Chrome, в закладке performance, вы сразу же увидите этот показатель.
Время, потраченное на генерацию содержимого на сервере и будет являться First Contentful Paint временем.
Сразу после этого, клиентский JavaScript начинает выполнение по созданию полноценного клиентского приложения (в большинстве случаев популярных фреймворков — virtual dom и binding интерфейса управления им).
В этот момент нет необходимости заново рендерить весь DOM на клиенте, но необходимо добавить недостающие события, методы, а в некоторых случаях и элементы, которые не рендерились на сервере.
Именно этот процесс и называется **гидратацией или регидратацией** (hydration / re-hydration). Немного более подробное описание можно найти в Руководстве Vue SSR (которое также есть на русском языке), но, соответственно, с некоторыми особенностями конкретно этого фреймворка.
### Производительность
А вот в этой части появляются некоторые проблемы. Регидратация имеет определённый недостаток — это время до взаимодействия или Time to Interactive, которое можно увидеть во всё том же, известном нам, Lighthouse Chrome. Даже если вы организовали всё идеально на стороне сервера и страница имеет быструю первую отрисовку содержимого, пользователь сможет с ней взаимодействовать только после CSR регидратации, которая иногда выполняется довольно медленно. Это большой минус в части UX.
Ещё один показатель Max Potential First Input Delay — задержка первого ввода (англ. First input delay, FID) — одна из метрик производительности веб-страниц, которая описывает время, прошедшее с момента, когда пользователь впервые начал взаимодействовать с веб-страницей, т.е. нажал на ссылку, кнопку или использует элемент управления на основе JavaScript, до момента, когда веб-браузер может ответить на данное взаимодействие (определение с сайта mozilla).
И время регидратации напрямую влияет на этот показатель. И чем больше компонентов и логики на вашей странице — тем стремительнее увеличивается этот показатель.
Одним из способов решения является lazy load для hydration.
Примером реализации подобного подхода на Vue SSR / NuxtJS является пакет *vue-lazy-hydration* (в npm репозитории), который реализует выполнение гидратации только в видимой части viewport браузера и «гидрирует» остальную часть только в случае скролла страницы. Рекомендации по использованию этого пакета были найдены также на хабре в tutorial [Создаем интернет-магазин на Nuxt.js](https://habr.com/ru/post/490496/), за что автору [AntonMoskalchenko](https://habr.com/ru/users/antonmoskalchenko/) хочу выразить отдельную благодарность. В его статье были достигнуты показатели Performance в Lighthouse Chrome равные 100%. | https://habr.com/ru/post/515100/ | null | ru | null |
# Автоматизация Android. Супер простое руководство по созданию первого Espresso-теста
Здравствуйте, друзья. В преддверии старта курса [«Mobile QA Engineer»](https://otus.pw/1sNg/), хотим поделиться с вами переводом интересного материала.
---
### Что такое Espresso?
Нет, это не напиток, который вы пьете каждый день, чтобы взбодриться. Espresso — это тестовый фреймворк с открытым исходным кодом, разработанный Google. Он позволяет выполнять сложные тесты пользовательского интерфейса на реальном устройстве или эмуляторе. Потребуется ли время, чтобы начать писать сложные тесты для Android?
Возможно. Но ничего не мешает вам сделать первый шаг и научиться писать простые тест-кейсы для Android с помощью фреймворка Espresso прямо сейчас.
### Расскажите поподробнее об автоматизации?
Конечно. Автоматизация — это способ ускорить выполнение тестов, сделать их более эффективным и масштабируемым. Ручное тестирование очень важно, но наличие автоматических тестов — гораздо лучший вариант в перспективе.
Существует в основном два типа тестовых фреймворков:
1. Фреймворки, которым не нужен доступ к исходному коду и которые не интегрированы как часть проекта. Например, **WebDriver, Appium, QTP**.
2. Фреймворки, которым нужен доступ к исходному коду. Например, **Espresso, KIF (Keep It Functional)**.
Espresso — это фреймворк, которому нужен доступ к исходному коду, поэтому для автоматизации нам потребуется доступ к коду проекта. Так как нам нужен проект для работы, давайте создадим его!
### Основные компоненты Espresso
Есть три типа методов, доступных в Espresso:
1. **ViewMatchers** — позволяют найти объект в текущей иерархии представлений
2. **ViewAssertions** — позволяют проверить состояние объекта и подтвердить, что состояние соответствует критериям
3. **ViewActions** — эти методы позволяют выполнять различные действия с объектами.
Давайте копнем глубже и посмотрим, как все это работает на реальном примере.
#### Создание простого приложения для автоматизации
Первое, что нам нужно сделать, — это создать приложение, которое мы будем автоматизировать. Давайте создадим проект в Android Studio. Для этого, конечно, необходимо, чтобы Android Studio был установлен у вас на компьютере.
**1. Откройте Android Studio и создайте Bottom Navigation Activity.**
*Android Studio. Окно «Create New Project»*
**2. Назовите проект и выберите язык программирования.**
*Android Studio. Указание имени проекта*
**3. Перейдите в папку androidTest**
*Android Studio. Инструментальный тест.*
Как вы можете видеть, там написан только один тест, и это не UI-тест, а JUnit-тест.
Сейчас нам нужно добавить простой тест пользовательского интерфейса. Для этого сначала создадим правило для открытия *MainActivity*.
Давайте добавим импорт аннотации **JUnit** Rule:
```
import org.junit.Rule;
```
Следующее, что нужно сделать, — это добавить строку кода, указанную ниже, в дополнение к аннотации **RunWith**:
```
@Rule
public ActivityTestRule activityActivityTestRule = new ActivityTestRule<>(MainActivity.class);
```
Теперь мы видим, что **ActivityTestRule** выделен красным. Это означает, что нам необходимо импортировать функцию **ActivityTestRule**. Но прежде нам нужно добавить библиотеку, способную сделать это. В двух словах, для этой задачи нам нужна помощь **Gradle** — системы автоматизации сборки, созданной специально для этой цели.
Давайте перейдем к файлу конфигурации **Gradle** и добавим эту библиотеку. Откройте файл с именем **build.gradle (Module: app)** и добавьте строку, указанную ниже:
```
androidTestImplementation 'com.android.support.test:rules:1.0.2'
```
*Android Studio. Добавление зависимости.*
После добавления, нужно нажать кнопку для синхронизации проекта и затем вернуться к файлу с реализацией теста.
Теперь, когда библиотека добавлена, следующим шагом будет ее импортирование в файле с инструментальным тестом:
```
import androidx.test.rule.ActivityTestRule;
```
*Android Studio. Импорт ActivityTestRule.*
Хорошо, теперь мы готовы добавить наш первый тест. Введите этот код в **ExampleInstrumentedTest**:
```
@Test
public void clickButtonHome(){
onView(withId(R.id.navigation_home)).perform(click()).check(matches(isDisplayed()));
}
```
*Android Studio. Добавление теста и импортирование дополнительных элементов*
Для нашего теста требуется импортировать дополнительные элементы, прежде чем он начнет работать. Нажмите кнопку **«ОК»**, и мы, собственно, готовы к запуску нашего теста!
### Запуск Espresso-тестов
Щелкните правой кнопкой мыши на нашем тесте слева и выберите **«Run ExampleInstrumentedTest»**.
Поскольку это **UI-тест**, а не **модульный** тест, дальше мы увидим окно с выбором устройства, на котором мы хотели бы запустить его. У меня уже есть «Nexus 5X» в качестве устройства, поэтому мне нужно просто выбрать его.
В вашем случае, если вы никогда не развертывали Android-проект, выберите ваше реальное Android-устройство или нажмите **«Create New Virtual Device»** и создайте новое эмулируемое устройство для запуска тестов. Это может быть любое устройство из списка, на котором бы вы хотели запустить тесты.
Нажмите **«ОК»** и приготовьтесь увидеть магию!
*Android Studio. Результаты выполнения теста*
Как вы можете видеть, у нас есть набор из двух пройденных тестов: модульного теста, который уже был там, после создания проекта, и нашего теста *«clickHomeButton»*, который мы только что написали.
*Android Studio. Выполненный тест.*
Как видно из названия, мы нажали только одну кнопку в нижней панели навигации, которая называется **«navigation\_home»** в иерархии **MainActivity**.
Давайте проанализируем что мы делали в этой цепочке методов:
```
public void clickButtonHome(){
onView(withId(R.id.navigation_home)).perform(click()).check(matches(isDisplayed()));
}
```
1. 1. Вызываем «**onView**». Этот метод является методом типа **ViewMatchers**. Мы находим объект в нашем Activity для выполнения чего-либо.
2. 2. Далее мы вызываем **perform(click())**. Этот метод является методом типа **ViewActions**. Мы указываем конкретное действие, которое нужно выполнить в этом случае — сделать одно нажатие (click). В Espresso доступно еще много методов действий, например:
3. 3. Последнее, что нам нужно сделать, это подтвердить, что действие, которое мы сделали, действительно соответствует нашим критериям, и для этого мы выполняем метод **check(isDisplayed())**, который является методом типа **ViewAssertions**. В этом случае мы проверяем, что этот объект (представление) действительно отображался на экране после выполнения действия нажатия.
### Иерархия представлений в Android
Уважаемый читатель, я надеюсь, что смог объяснить вам, как писать базовые **UI-тесты для Android** с помощью Espresso.
Однако, вероятно, не так просто понять, что именно здесь произошло, если не знать, где все эти кнопки расположены и откуда они берутся. Для того, чтобы это узнать, нам нужно перейти в папку **«res»** с левой стороны, открыть папку **«menu»** и выбрать **«bottom\_nav\_menu.xml»**.
Вот что мы увидим там:
*Android Studio. Иерархия представления нижнего меню навигации.*
Как видите, это строка, которая присваивает имя элементу меню:
```
android:id="@+id/navigation_home"
```
Именно это мы используем в нашем коде для запуска тестов. Также есть кнопки меню **“navigation\_dashboard”** и **“navigation\_notifications”**, доступные внизу, так что давайте продолжим и используем их в наших тестах.
### Еще больше Espresso-тестов
Нам нужно вернуться к файлу **ExampleInstrumentedTest** и добавить туда еще пару тестовых функций:
```
@Test
public void clickButtonDashboard(){
onView(withId(R.id.navigation_dashboard)).perform(click()).check(matches(isDisplayed()));
}
@Test
public void clickButtonNotification(){
onView(withId(R.id.navigation_notifications)).perform(click()).check(matches(isDisplayed()));
}
```
Единственное, что мы добавили, — это проверка еще нескольких элементов меню: **“navigation\_dashboard”** и **“navigation\_notifications”**.
*Android Studio. Добавляем еще два теста.*
Конечно, эти тесты можно было бы еще больше упростить, но для того, чтобы показать, как все это работает, допустим, что они прекрасно подходят для наших целей.
Давайте продолжим и запустим эти тесты еще раз. Нажмите кнопку **«Run»**.
*Android Studio. Результаты выполнения тестов.*
Все 4 теста пройдены. Все представления были найдены, нажаты и подтверждены в иерархии представлений.
### Заключение
Espresso — это мощное решение для запуска UI-тестов. Теперь, когда вы знаете, как они создаются, вы готовы писать намного более мощные и сложные тесты.
Удачного тестирования! | https://habr.com/ru/post/472372/ | null | ru | null |
# Серверная валидация пользовательских данных
Доброго времени, хаброчеловеки!
===============================
Мне хотелось бы поднять тему серверной валидации пользовательских данных. Поискав на хабре топики данной тематики и погуглив, пришёл к выводу, что люди часто изобретают свои собственные велосипеды для реализации механизма валидации. В данной статье хочу рассказать о простом и красивом решении, которое успешно применяется в нескольких проектах.
Проблема
========
Часто замечаю, что разработчики активно используют исключения (exceptions) для уведомления об ошибках валидации данных. Продемонстрирую примером (поскольку C# мне ближе, буду использовать его):
> `public void Validate(string userName, string userPassword)
>
> {
>
> if (/\*проверяем имя пользователя\*/)
>
> throw new InvalidUsernameException();
>
> if (/\*проверяем пароль\*/)
>
> throw new InvalidPasswordException();
>
> }`
Далее это используется примерно так:
> `public void RegisterUser (string username, string password) {
>
> try {
>
> ValidateUser(username, password);
>
> }
>
>
>
> catch(InvalidUsernameException ex) {
>
> //добавляем в коллекцию ошибок
>
> }
>
>
>
> catch(InvalidPasswordException ex) {
>
> //добавляем в коллекцию ошибок
>
> }
>
>
>
> //что-то дальше делаем
>
> }`
**Что плохого в этом примере?**
— используются исключения (exceptions) на этапе бизнес валидации. Важно помнить, что ошибки валидации данных != ошибкам работы приложения;
— использование исключений на этапе бизнес валидации может привести к падению приложения. Такое может произойти, например, если человек забудет написать ещё один блок catch для новых правил валидации;
— код выглядит некрасиво;
— подобное решение сложно тестировать и поддерживать.
Решение
=======
Механизм валидации данных можно реализовать при помощи паттерна [Composite (компоновщик)](http://ru.wikipedia.org/wiki/Composite).
Нам потребуется непосредственно сам объект валидатор, который непосредственно проверяет данные на соответствие определённым правилам, композитный валидатор, который инкаплусирует в себе коллекцию валидаторов, а также дополнительный класс, используемый в
качестве хранилища результата валидации и коллекции ошибок — **ValidationResult**. Рассмотрим вначале последний:
> `public class ValidationResult{
>
> private bool isSucceedResult = true;
>
> private readonly List resultCodes = new List();
>
>
>
> protected ValidationResult() {
>
> }
>
>
>
> public ValidationResult(ResultCode code) {
>
> isSucceedResult = false;
>
> resultCodes.Add(code);
>
> }
>
>
>
> public static ValidationResult SuccessResult {
>
> get { return new ValidationResult(); }
>
> }
>
>
>
> public List GetResultCodes {
>
> get { return resultCodes; }
>
> }
>
>
>
> public bool IsSucceed {
>
> get { return isSucceedResult; }
>
> }
>
>
>
> public void AddError(ResultCode code) {
>
> isSucceedResult = false;
>
> resultCodes.Add(code);
>
> }
>
>
>
> public void Merge(ValidationResult result) {
>
> resultCodes.AddRange(result.resultCodes);
>
> isSucceedResult &= result.isSucceedResult;
>
> }
>
> }`
Теперь перейдём непосредственно к механизму валидации. Нам необходимо создать базовый класс **Validator**, от которого будут наследоваться все валидаторы:
> `public abstract class Validator {
>
> public abstract ValidationResult Validate();
>
> }`
У объектов-валидаторов существует 1 метод, который запускает процедуру проверки и возвращает результат.
**CompositeValidator** — класс, содержащий в себе коллекцию валидаторов и запускающий механизм проверки у всех дочерних объектов:
> `public class CompositeValidator : Validator {
>
> private readonly List validators = new List();
>
>
>
> public void Add(Validator validator) {
>
> validators.Add(validator);
>
> }
>
>
>
> public void Remove(Validator validator) {
>
> validators.Remove(validator);
>
> }
>
>
>
> public override ValidationResult Validate() {
>
> ValidationResult result = ValidationResult.SuccessResult;
>
> foreach (Validator validator in validators) {
>
> result.Merge(validator.Validate());
>
> }
>
> return result;
>
> }
>
> }`
Используя эти классы, мы получили возможность создавать валидаторы с определёнными правилами, комбинировать их и получать результаты проверки.
Использование
=============
Перепишем приведённый в начале статьи пример с использованием этого механизма. В нашем случае необходимо создать 2 валидатора, которые проверяют имя пользователя и пароль на соответствие определённым правилам.
Создаём объект для проверки имени пользователя **UserNameValidator**:
> `public class UserNameValidator: Validator {
>
> private readonly string userName;
>
>
>
> public UserNameValidator(string userName) {
>
> this.userName= userName;
>
> }
>
>
>
> public override ValidationResult Validate() {
>
> if (/\*параметр не прошёл проверку на условие, например userName = null\*/) {
>
> return new ValidationResult(ResultCode.UserNameIncorrect);
>
> }
>
>
>
> return ValidationResult.SuccessResult;
>
> }
>
> }`
Аналогично получаем **UserPasswordValidator**.
Теперь у нас есть всё, чтобы использовать новый механизм валидации данных:
> `public ValidationResult ValidateUser(string userName, string userPassword)
>
> {
>
> CompositeValidator validator = new CompositeValidator();
>
> validator.add(new UserNameValidator(userName));
>
> validator.add(new UserPasswordValidator(userPassword));
>
>
>
> return validator.Validate();
>
> }
>
>
>
> public void RegisterUser (string username, string password) {
>
> ValidationResult result = ValidateUser(username, password);
>
>
>
> if (result.IsSucceed) {
>
> //успешная валидация
>
> }
>
>
>
> else {
>
> //получаем ошибки валидации result.GetResultCodes() и обрабатываем соответствующим образом
>
> }
>
>
>
> }`
Выводы
======
**Какие преимущества мы получили, используя данный подход:**
— расширяемость. Добавление новых валидаторов стоит дешево;
— тестируемость. Все валидаторы могут быть модульно протестированы, что исключает наличие ошибок в общем процессе валидации;
— сопровождаемость. Валидаторы можно выделить в отдельную сборку и использовать во многих проектах с незначительными изменениями;
— красота и правильность. Данный код выглядит красивее, изящнее и правильнее, первоначального варианта, исключения не используются для бизнес валидации.
Заключение
==========
**В дальнейшем можно применить несколько улучшений к механизму валидации, а именно:**
— инкапсулировать все валидаторы в одну сборку и создать фабрику, которая будет возвращать готовый механизм валидации для различных условий (проверка данных для регистрации пользователя, проверка данных при авторизации и т.д.);
— базовый класс Validator можно заменить на интерфейс, кому как нравится;
— правила валидации можно хранить в одном месте, для более удобного управления;
— можно написать обработчик ошибок валидации, который будет сопоставлять коды ошибок и сообщения, выводимые пользователям на UI, в таком случае ещё сильнее упрощается процесс добавления новых валидаторов. Также отпадает проблема локализации сообщений.
P.S.
====
Просьба сильно не пинать за возможные ошибки в написании и изложении. Я очень старался)
С удовольствием выслушаю критику и пожелания по поводу реализации и архитектуры.
> \* All source code was highlighted with [Source Code Highlighter](http://virtser.net/blog/post/source-code-highlighter.aspx). | https://habr.com/ru/post/41772/ | null | ru | null |
# TDD для микроконтроллеров. Часть 2: Как шпионы избавляют от зависимостей
> [TDD для микроконтроллеров. Часть 1: Первый полет](https://habr.com/ru/company/ntc-vulkan/blog/487966/)
>
> [TDD для микроконтроллеров. Часть 2: Как шпионы избавляют от зависимостей](https://habr.com/ru/company/ntc-vulkan/blog/488370/)
>
> [TDD для микроконтроллеров. Часть 3: Запуск на железе](https://habr.com/ru/company/ntc-vulkan/blog/489186/)
[В предыдущей статье](https://habr.com/ru/company/ntc-vulkan/blog/487966/) мы начали освещать тему эффективности применения методологии TDD для микроконтроллеров (далее – МК) на примере разработки прошивки для STM32. Мы выполнили следующее:
1. Определили цель и инструменты разработки.
2. Настроили IDE и фреймворк для написания тестов.
3. Написали тест-лист для разрабатываемого функционала.
4. Создали первый простой тест и запустили его.
В этой статье расскажем, как мы применили методологию TDD для реализации тестов из тест-листа и написания кода прошивки для их успешного выполнения. При написании тестов будем использовать специальные тестовые объекты для ликвидации зависимостей разрабатываемой логики от других программных модулей. В конце статьи мы представим бизнес-логику проекта и проанализируем особенности применения методологии TDD для реализации прошивки МК. Подробности – под катом.
#### Тест-лист
Вспомним тест-лист [из прошлой статьи](https://habr.com/ru/company/ntc-vulkan/blog/487966/):
*1. При получении команды **read** возвращаются данные, размещенные по указанному адресу на флеш-памяти.*
*2. При получении команды **write*** *производится запись данных по указанному адресу во флеш-память.*
*3. При получении команды **erase*** *производится стирание страницы с указанным номером.*
*4. При получении команды **help*** *выводится список поддерживаемых команд.*
*5. При получении **неизвестной** команды возвращается сообщение об ошибке.*
Теперь приступим к реализации этих тестов с помощью CppUTest.
#### Цели проекта
Цель проекта – реализация возможности напрямую работать с энергонезависимой памятью МК: считывать, записывать значения ячеек и стирать страницы флеш-памяти с помощью UART-интерфейса. Команды будут передаваться по UART-интерфейсу в виде строк с кодировкой ASCII. Вышеперечисленный функционал будет использоваться непосредственно для работы с флеш-памятью МК. При этом пользователь должен помнить об основах работы с флеш-памятью: для корректной записи данных необходимо предварительно произвести стирание.
Основная идея проекта – привести простой пример использования методологии TDD для разработки прошивки МК. В нашем проекте сценарии достаточно просты, для каждого из них мы привели только один тест (мы не рассматривали тестирование граничных случаев). Этого может быть недостаточно для более сложных проектов.
#### Тест для команды *help*
Начнем с простого теста – теста № 4 для команды **help**. Для обработки **help** на МК достаточно отправить строку со списком поддерживаемых команд по UART-интерфейсу.
За основу написания тестов мы взяли алгоритм обработки команд от ПК по интерфейсу UART:
1. Прием команды от ПК.
2. Обработка команды.
3. Отправка ответа на ПК.
P.S. Этот алгоритм идентичен для каждой команды.
Исходя из этого, бизнес-логика всего проекта заключается в обработке полученной от ПК команды с помощью вызова обработчика: основного метода класса `Configurator`.
Прием и отправку данных можно реализовать в отдельном модуле `Serial`, однако для разработки такого модуля следует использовать платформозависимый код для конкретного МК (в нашем случае – *STM32F103C8T6*). Но мы решили на данном этапе разработать платформонезависимую логику, для достижения этой цели использовали тестовый шпион `SerialSpy`.
Написание теста для команды **help**:
```
TEST(Configurator, ShouldHandleHelpCommand)
{
// Arrange – установка входящей команды от ПК в буфер приема UART
char helpCommand[] = "help\r\n";
LONGS_EQUAL(OK, SerialSpy_SetReceiveBuffer(serial, helpCommand, sizeof(helpCommand)));
// Act – вызов обработчика команд
Status status = Configurator_Handler(configurator);
// Assert – проверка статуса обработки
LONGS_EQUAL(OK, status);
// проверка ответа, отправленного обратно на ПК по UART
char * sendBufferPtr = NULL;
LONGS_EQUAL(OK, SerialSpy_GetSendBuffer(serial, &sendBufferPtr));
STRCMP_EQUAL(HELP_OUTPUT, sendBufferPtr);
}
```
Структура теста:
* в блоке *Arrange* для установки буфера приема команды по UART используется тестовый шпион `SerialSpy`, а именно метод `SerialSpy_SetReceiveBuffer`;
* в блоке *Act* вызывается обработчик `Configurator_Handler`, в котором будет производиться обработка входящей команды, полученной из буфера приема по UART. Далее отправляется ответ с помощью функции отправки по UART;
* в блоке *Assert* выполняется проверка статуса обработки команды. Для проверки ответа получаем указатель на буфер отправки с помощью метода `SerialSpy_GetSendBuffer`, а затем с помощью макроса `STRCMP_EQUAL` сравниваем строку `HELP_OUTPUT` и строку в буфере отправки.
Как видно, в тесте три нереализованных метода: `SerialSpy_SetReceiveBuffer`, `Configurator_Handler` и `SerialSpy_GetSendBuffer`. Поэтому для завершения этапа *test fails* необходимо написать пустые реализации этих методов (заглушки). Добавляем метод `Configurator_Handler` в наш класс `Configurator` и оставляем тело метода пустым.
Методы `SerialSpy_SetReceiveBuffer` и `SerialSpy_GetSendBuffer` реализуются с помощью тестового шпиона, который обычно применяется для проверки логики тестируемого объекта без использования зависимого объекта. Тестовый шпион заменяет зависимый объект, поэтому основной его функцией является запись данных или вызовов, поступающих из тестируемого объекта, с целью последующей проверки корректности взаимодействия тестируемого и зависимого объектов.
Мы использовали `SerialSpy`, чтобы убрать зависимость основной логики класса `Configurator` от драйвера `Serial`. В файл `SerialSpy.h` добавили прототипы методов, а в `SerialSpy.c` – реализацию этих методов. Тестовые шпионы, как правило, содержат только минимально необходимый код для реализации тестов. В случае с `SerialSpy` мы использовали два буфера:
•`receiveBuffer` для входящих сообщений от ПК по UART;
•`sendBuffer` для исходящих сообщений на ПК по UART.
Эти два буфера используются каждый раз при исполнении теста в методе `Configurator_Handler`: в теле обработчика считывается и обрабатывается входящая команда, затем отправляется ответ на ПК. Поэтому с целью тестирования мы реализовали два метода:
• `SerialSpy_SetReceiveBuffer` для установки входящей команды;
• `SerialSpy_GetSendBuffer` для получения указателя на буфер исходящих сообщений, чтобы проверить корректность ответа.
**Добавляем пустой Configurator\_Handler и SerialSpy**
```
// Common.h
typedef enum
{
OK = 0,
FAIL = -1,
INVALID_PARAMETERS = -4,
OUT_OF_BOUNDS = -13,
} Status;
// Configurator.h
Status Configurator_Handler(Configurator * self);
// Configurator.c
Status Configurator_Handler(Configurator * self)
{
}
// SerialSpy.h
#include "Common.h"
Status SerialSpy_SetReceiveBuffer(Serial * self, char * data, uint32_t len);
Status SerialSpy_GetSendBuffer(Serial * self, char ** bufferPtr);
//SerialSpy.c
#include "SerialSpy.h"
typedef struct SerialStruct
{
char receiveBuffer[SERIAL_RECEIVE_BUFFER_SIZE];
char sendBuffer[SERIAL_SEND_BUFFER_SIZE];
} SerialStruct;
Serial * Serial_Create(void)
{
Serial * self = (Serial*)calloc(1, sizeof(SerialStruct));
return self;
}
void Serial_Destroy(Serial * self)
{
if (self == NULL)
{
return;
}
free(self);
self = NULL;
}
Status SerialSpy_SetReceiveBuffer(Serial * self, char * data, uint32_t len)
{
if (self == NULL || data == NULL)
{
return INVALID_PARAMETERS;
}
if (len > SERIAL_RECEIVE_BUFFER_SIZE)
{
return OUT_OF_BOUNDS;
}
memcpy(self->receiveBuffer, data, len);
return OK;
}
Status SerialSpy_GetSendBuffer(Serial * self, char ** bufferPtr)
{
if (self == NULL || bufferPtr == NULL)
{
return INVALID_PARAMETERS;
}
*bufferPtr = self->sendBuffer;
return OK;
}
```
Можно сказать, что `SerialSpy` симулирует работу драйвера UART. Подобные методы часто используются в TDD и unit-тестировании для быстрого написания и запуска тестов на локальном ПК. Это необходимо для обеспечения непрерывной итеративной разработки. Такие шпионы позволяют тестировать логику класса `Configurator` с помощью локального ПК без использования отладочной платы с МК STM32. При этом нет необходимости заливать прошивку, чтобы убедиться в корректности работы написанной бизнес-логики, достаточно нажать на кнопку «Запуск» в Visual Studio и получить результат.
#### Из test-fails в test-passes
Для перехода к *test-passes* нужно заполнить тело метода `Configurator_Handler`. При каждом его вызове будем проверять наличие входящих данных от ПК с помощью метода приема данных по UART `Serial_ReceiveCommand` и в случае получения новых данных будем производить их обработку. Для команды *help* достаточно проверить, что в буфер поступила строка `help`, после этого следует отправить ответ с помощью метода `Serial_SendResponse`.
Взаимодействие основной логики класса `Configurator` по UART осуществляется с помощью `Serial`, поэтому в этот класс мы добавили поле Serial, а в конструктор `Configurator_Create` – параметр `Serial*`. После этого обновили блоки кода `setup()` и `teardown()` в соответствии с перечисленными изменениями.
**Написание логики для обработки команды help**
```
// Configurator.h
// Добавляем вывод команды `help` и в конструктор параметр `Serial`
#include "Serial.h"
#define HELP_OUTPUT \
"Command list:\r\n \
- help\r\n \
- read: \r\n \
- write: \r\n \
- erase: \r\n>"
Configurator \* Configurator\_Create(Serial \* serial);
// Configurator.c
// Для приема и отправки с помощью UART добавим Serial в Configurator
typedef struct ConfiguratorStruct
{
char command[SERIAL\_RECEIVE\_BUFFER\_SIZE];
Serial \* serial;
} ConfiguratorStruct;
static const char helpCommand[] = "help";
// Добавим инициализацию Serial в конструктор (и не забудем про деструктор)
Configurator \* Configurator\_Create(Serial \* serial)
{
if (serial == NULL)
{
return NULL;
}
Configurator \* self = (Configurator\*)calloc(1, sizeof(ConfiguratorStruct));
if (self == NULL)
{
return NULL;
}
self->serial = serial;
return self;
}
// Реализуем тело метода Configurator\_Handler
Status Configurator\_Handler(Configurator \* self)
{
if (self == NULL)
{
return INVALID\_PARAMETERS;
}
// Получаем команду из буфера приема UART
Status status = Serial\_ReceiveCommand(self->serial, self->command);
if (status != OK)
{
// При отсутствии данных UART вернется статус NO\_DATA
return status;
}
// Обработка полученной команды
if (strstr(self->command, helpCommand) == NULL)
{
return UNSUPPORTED;
}
Status status = Serial\_SendResponse(self->serial, HELP\_OUTPUT);
return status;
}
// ConfiguratorTests.cpp
TEST\_GROUP(Configurator)
{
Configurator \* configurator = NULL;
Serial \* serial = NULL;
void setup()
{
serial = Serial\_Create();
configurator = Configurator\_Create(serial);
}
void teardown()
{
Configurator\_Destroy(configurator);
}
};
```
На данном этапе нам необходимо было реализовать методы приема и отправки драйвера `Serial`, т. к. они используются в обработчике `Configurator_Handler`. Мы реализовали их в `SerialSpy`, чтобы исключить платформозависимый код и запускать тесты на локальном ПК. Для `SerialSpy.c` и драйвера `Serial.c` на конкретном МК используется один и тот же заголовочный файл – `Serial.h`:
```
#pragma once
#include "Common.h"
#define SERIAL_RECEIVE_BUFFER_SIZE 32 // Размер буфера приема команды
#define SERIAL_SEND_BUFFER_SIZE 256 // Размер буфера для отправки ответа
typedef struct SerialStruct Serial;
Serial * Serial_Create(void);
void Serial_Destroy(Serial * self);
// Проверка наличия данных в буфере приема UART
// self – указатель на объект типа Serial
// commandPtr – указатель на буфер, в который будут скопированы все принятые данные
// Возвращаемые значения:
// OK – в случае наличия данных в буфере приема
// NO_DATA – при отсутствии данных в буфере приема
Status Serial_ReceiveCommand(Serial * self, char * commandPtr);
// Отправка данных по UART
// self – указатель на объект типа Serial
// responsePtr – указатель на данные для отправки
// Возвращаемые значения:
// OK – в случае успешной отправки, иначе – FAIL
Status Serial_SendResponse(Serial * self, char * responsePtr);
// Очистка буфера приема UART
// self – указатель на объект типа Serial
// Возвращаемые значения:
// OK – в случае успешного выполнения, иначе – FAIL
Status Serial_Clear(Serial * self);
```
Мы добавили файл `Serial.h` в проект *ProductionCodeLib*. В проект *Tests* добавили файл `SerialSpy.c` и в нем реализовали методы `Serial_ReceiveCommand` и `Serial_SendResponse`, которые позволяют симулировать работу драйвера UART с целью последующей проверки корректности обработки команды.
**Реализация методов приема/отправки в SerialSpy.c**
```
// ... some code
static bool IsEndOfString(char * buffer)
{
for (int i = 0; i < SERIAL_RECEIVE_BUFFER_SIZE; i++)
{
if (buffer[i] == '\n')
{
return true;
}
}
return false;
}
Status Serial_ReceiveCommand(Serial * self, char * commandPtr)
{
if (self == NULL || commandPtr == NULL)
{
return INVALID_PARAMETERS;
}
// Проверяем наличие данных в буфере приема UART
uint32_t commandLen = strlen(self->receiveBuffer);
if (commandLen == 0)
{
return NO_DATA;
}
// Проверяем наличие символа новой строки `\n`
bool isEndOfString = IsEndOfString(self->receiveBuffer);
if (isEndOfString == false)
{
return NO_DATA;
}
// При завершении приема очередной строки с символом `\n` копируем полученную строку в буфер приема UART
strncpy(commandPtr, self->receiveBuffer, commandLen);
self->receiveBuffer[SERIAL_RECEIVE_BUFFER_SIZE – 1] = 0;
return OK;
}
Status Serial_SendResponse(Serial * self, char * responsePtr)
{
if (self == NULL || responsePtr == NULL)
{
return INVALID_PARAMETERS;
}
// Проверка длины строки для отправки
uint32_t responseLen = strlen(responsePtr);
if (responseLen > SERIAL_SEND_BUFFER_SIZE)
{
return OUT_OF_BOUNDS;
}
// Копируем данные в буфер отправки
strncpy(self->sendBuffer, responsePtr, responseLen);
self->sendBuffer[SERIAL_SEND_BUFFER_SIZE – 1] = 0;
return OK;
}
// ... some code
```
Мы написали простейшую реализацию методов приема/отправки в `SerialSpy.c` с целью успешного выполнения теста. Для симуляции работы драйвера UART с помощью тестового шпиона достаточно:
* для отправки – скопировать данные в буфер в отправки с помощью `strncpy`;
* для приема – проверить наличие входящих данных с помощью `strlen` и признак завершения приема команды (символ `\n`). В случае завершения приема команды скопировать с помощью `strncpy` принятые данные в буфер, переданный через параметр метода.
Далее мы запустили тест и получили положительный результат:
```
..
OK (2 tests, 2 ran, 5 checks, 0 ignored, 0 filtered out, 0 ms)
```
Обработчик команды **help** реализован, и тест успешно выполняется. На этом завершается фаза *test-passes*. Перейдем к фазе *refactor*.
#### Фаза refactor
После того как тест успешно завершен, следует выполнить рефакторинг разработанного кода. Это могут быть мелкие правки, например: изменение имен переменных, методов или оптимизация повторного использования кода. А могут быть и более серьезные: перенос части функционала из одного программного модуля в другой с целью улучшения дизайна.
Несмотря на масштабы этих правок, мы можем оценить их корректность, нажав на горячую клавишу запуска тестов. Если в процессе рефакторинга что-то «сломается», то можно откатить изменения. На данном этапе лучше запускать тесты как можно чаще, ведь это занимает всего долю секунды и помогает своевременно предотвратить внесение ошибок в код.
На этапе рефакторинга мы вынесли обработчик команд из `Configurator_Handler` в отдельный `static` метод `HandleCommand`. Этот метод выполняет единственную операцию: парсит входящую команду и вызывает нужный обработчик полученной команды (на данном шаге реализовали только одну команду `help`).
**Вынесение обработчика команд в отдельный метод**
```
// Configurator.c
static Status HandleHelpCommand(Configurator * self)
{
if (self == NULL)
{
return INVALID_PARAMETERS;
}
Status status = Serial_SendResponse(self->serial, HELP_OUTPUT);
return status;
}
static Status HandleCommand(Configurator * self)
{
if (self == NULL)
{
return INVALID_PARAMETERS;
}
// Обработка команды help
if (strstr(self->command, helpCommand) != NULL)
{
return HandleHelpCommand(self);
}
// Обработка неизвестной команды
return UNSUPPORTED;
}
Status Configurator_Handler(Configurator * self)
{
if (self == NULL)
{
return INVALID_PARAMETERS;
}
// Получаем команду из буфера приема UART
Status status = Serial_ReceiveCommand(self->serial, self->command);
if (status != OK)
{
// При отсутствии данных UART вернется статус NO_DATA
return status;
}
// Обработка полученной команды
status = HandleCommand(self);
if(status != OK)
{
return status;
}
return status;
}
```
На этом у нас завершилась фаза *refactor*, теперь можно приступить к новой итерации *fails-passes-refactor*.
Для завершения обработчика `Configurator_Handler` мы добавили следующие команды:
• `read` – чтение флеш-памяти;
• `write` – запись флеш-памяти;
• `erase` – стирание флеш-памяти.
Разработка этого функционала производилась похожим образом, в этом можно убедиться, скачав готовый проект на [*gitlab*](https://gitlab.com/RaccoonSecurity/tddforembedded).
Для разработки функционала вышеперечисленных команд нам также потребовалось симулировать драйвер для работы с флеш-памятью.
#### Тест для команды записи во флеш-память
Здесь приведен пример теста и описание применения тестового шпиона `FlashSpy` для реализации логики класса `Configurator` с целью успешного выполнения теста. В качестве примера мы выбрали команду **write** следующего формата:
`write: \r\n`
Написание теста для команды **write**:
```
TEST(Configurator, ShouldHandleWriteFlashCommand)
{
// Arrange
// Ожидаемые данные после обработки команды write
uint32_t expectedFlashData = 0x11223344;
// Устанавливаем входящую команду от ПК в буфер приема UART
char writeFlashCommand[] = "write: 0x10000 0x11223344\r\n";
LONGS_EQUAL(OK, SerialSpy_SetReceiveBuffer(serial, writeFlashCommand, sizeof(writeFlashCommand)));
// Act
Status status = Configurator_Handler(configurator);
// Assert
// Проверяем статус
LONGS_EQUAL(OK, status);
// Проверяем данные, записанные во флеш-память
uint32_t * flashPtr = NULL;
LONGS_EQUAL(OK, FlashSpy_GetFlashPtr(&flashPtr, 0x10000));
LONGS_EQUAL(expectedFlashData, *flashPtr);
}
```
Мы решили производить чтение и запись по 4 байта. Помним, что перед записью следует стереть флеш-память МК. В итоге мы получили следующий заголовочный файл `Flash.h`:
```
// Flash.h
#pragma once
#include "Common.h"
#define FLASH_PAGE_COUNT 0x80
#define FLASH_PAGE_SIZE 0x400
#define FLASH_SIZE FLASH_PAGE_COUNT * FLASH_PAGE_SIZE // 128 Kb
Status Flash_Init(void);
Status Flash_DeInit(void);
Status Flash_Write(uint32_t address, uint32_t data);
Status Flash_Read(uint32_t address, uint32_t * dataPtr);
Status Flash_Erase(uint8_t pageNumber);
```
Для запуска тестов на локальном ПК достаточно реализовать методы из `Flash.h` в `FlashSpy.c` простым способом: флеш-память можно представить как массив байтов `uint8_t flash[FLASH_SIZE]`, где `FLASH_SIZE` равен произведению количества страниц на их размер. Поэтому для симуляции работы драйвера флеш-памяти на локальном ПК достаточно выделить массив размером `FLASH_SIZE`, который будем читать с помощью метода `Flash_Read`, записывать с помощью `Flash_Write` и производить стирание с помощью `Flash_Erase`.
Мы добавили `FlashSpy.c` в проект *Tests* и реализовали в нем единственный шпионский метод `FlashSpy_GetFlashPtr` для получения указателя на массив с заданным в `address` смещением. Таким образом мы сможем проверить содержимое массива в тестах.
Также для реализации тестового шпиона добавляем упрощенную реализацию методов инициализации, деинициализации, записи, чтения и стирания флеш-памяти в файл *FlashSpy.c*. В каждом методе производятся несложные операции с массивом `flashMemory` (размер которого равен размеру флеш-памяти в МК STM32F103C8):
* `Flash_Read` возвращает значение ячейки памяти размером 32 бита, которая находится по нужному смещению массива `flashMemory`.
* `Flash_Write` устанавливает значение ячейки памяти размером 32 бита в заданном смещении массива `flashMemory`.
* `Flash_Erase` заполняет срез массива `flashMemory` размером одной страницы памяти МК STM32F103C8 значениями 0xFF с помощью `memset`.
Этого достаточно для написания тестов и реализации бизнес-логики в классе `Configurator`.
**Написание методов чтения, записи, стирания и шпионского метода во `FlashSpy`**
```
// FlashSpy.h
#pragma once
#include "Flash.h"
Status FlashSpy_GetFlashPtr(uint32_t ** flashMemoryPtr, uint32_t address);
// FlashSpy.c
static uint8_t * flashMemory = NULL;
// Метод-шпион
Status FlashSpy_GetFlashPtr(uint32_t ** flashMemoryPtr, uint32_t address)
{
if (flashMemory == NULL)
{
return WRONG_CONDITION;
}
if (flashMemoryPtr == NULL || address >= FLASH_SIZE)
{
return INVALID_PARAMETERS;
}
*flashMemoryPtr = (uint32_t*)&flashMemory[address];
return OK;
}
// Методы для симуляции работы драйвера
Status Flash_Init(void)
{
flashMemory = (uint8_t*)malloc(FLASH_SIZE);
if (flashMemory == NULL)
{
return FAIL;
}
// Считаем, что флеш-память предварительно стерта (все биты равны 0b1)
memset(flashMemory, 0xFF, FLASH_SIZE);
return OK;
}
Status Flash_DeInit(void)
{
if (flashMemory == NULL)
{
return OK;
}
free(flashMemory);
flashMemory = NULL;
return OK;
}
Status Flash_Write(uint32_t address, uint32_t data)
{
if (flashMemory == NULL)
{
return WRONG_CONDITION;
}
if (address >= FLASH_SIZE)
{
return INVALID_PARAMETERS;
}
// Можем изменять биты: значение 0b1 на 0b0, а обратно только с помощью Flash_Erase
*(uint32_t*)(flashMemory + address) &= data;
return OK;
}
Status Flash_Read(uint32_t address, uint32_t * dataPtr)
{
if (flashMemory == NULL || dataPtr == NULL)
{
return WRONG_CONDITION;
}
if (address >= FLASH_SIZE)
{
return INVALID_PARAMETERS;
}
*dataPtr = *(uint32_t*)(flashMemory + address);
return OK;
}
Status Flash_Erase(uint8_t pageNumber)
{
if (flashMemory == NULL)
{
return WRONG_CONDITION;
}
if (pageNumber >= FLASH_PAGE_COUNT)
{
return INVALID_PARAMETERS;
}
uint32_t offset = pageNumber * FLASH_PAGE_SIZE;
memset(flashMemory + offset, 0xFF, FLASH_PAGE_SIZE);
return OK;
}
```
В методе `Flash_Write` запись данных производится с помощью побитовой операции «И», потому что данные могут быть записаны только на предварительно стертую страницу флеш-памяти (после стирания страницы все биты принимают значение 0b1).
Далее добавили *инициализацию* и *деинициализацию* флеш-памяти в блоки кода `setup()` и `teardown()` в файле *ConfiguratorTests.cpp*.
**Добавление инициализации и деинициализации Flash в тестах**
```
TEST_GROUP(Configurator)
{
Configurator * configurator = NULL;
Serial * serial = NULL;
void setup()
{
serial = Serial_Create();
configurator = Configurator_Create(serial);
Flash_Init();
}
void teardown()
{
Configurator_Destroy(configurator);
Flash_DeInit();
}
};
```
После запуска тестов мы получили ошибку со статусом `UNSUPPORTED`, т. к. в `Configurator_Handler` отсутствует обработка команды **write**. Это была фаза *test fails*.
```
d:\exampletdd\tests\tests\configuratortests.cpp(66): error: Failure in TEST(Configurator, ShouldHandleWriteFlashCommand)
expected < 0 0x00000000>
but was <-9 0xfffffff7>
...
Errors (1 failures, 3 tests, 3 ran, 8 checks, 0 ignored, 0 filtered out, 5 ms)
```
Для перехода на стадию *test-passes* добавили обработку команды **write** в *Configurator.c*. Обработчик команды записи *HandleWriteCommand*:
* парсит входящую строку, которая содержит адрес и значение размером 32 бита для записи;
* проверяет адрес (не выходит ли за границы флеш-памяти);
* записывает полученное значение во флеш-память с помощью метода `Flash_Write`;
* отправляет ответ на хост о статусе выполнения команды с помощью `Serial_SendResponse`.
**Обработчик команды записи**
```
// Configurator.c
#include "Flash.h"
// ... some code
#define LEN_MIN_ARG sizeof("0x0")
#define LEN_WRITE_COMMAND sizeof(writeCommand) + LEN_MIN_ARG + LEN_MIN_ARG
// ... some code
static const char writeCommand[] = "write:";
static const char writeResponse[] = "Written successfully\r\n>";
// ... some code
static Status HandleWriteCommand(Configurator * self)
{
if (self == NULL)
{
return INVALID_PARAMETERS;
}
// Проверка корректности длины команды
uint32_t commandLen = strlen(self->command);
if (commandLen < LEN_WRITE_COMMAND)
{
return INVALID_PARAMETERS;
}
// Парсинг адреса флеш-памяти
char * flashAddressPtr = self->command + sizeof(writeCommand);
uint32_t flashAddress = strtol(flashAddressPtr, (char**)NULL, 16);
if (flashAddress > FLASH_SIZE)
{
return INVALID_PARAMETERS;
}
// Парсинг данных для записи во флеш-память
char * dataAddressPtr = strchr(self->command + sizeof(writeCommand), ' ');
uint32_t data = strtol(dataAddressPtr, (char**)NULL, 16);
// Запись во флеш-память
Status status = Flash_Write(flashAddress, data);
if (status != OK)
{
return status;
}
// Отправка ответа на ПК по UART
status = Serial_SendResponse(self->serial, (char*)writeResponse);
return status;
}
static Status HandleCommand(Configurator * self)
{
if (self == NULL)
{
return INVALID_PARAMETERS;
}
// Команда help
if (strstr(self->command, helpCommand) != NULL)
{
return HandleHelpCommand(self);
}
// Команда write
else if (strstr(self->command, writeCommand) != NULL)
{
return HandleWriteCommand(self);
}
// Неизвестная команда
return UNSUPPORTED;
}
```
В итоге после запуска тестов мы получили результат *test-passes*.
```
...
OK (3 tests, 3 ran, 9 checks, 0 ignored, 0 filtered out, 0 ms)
```
Для завершения итерации нужно провести *refactoring*, как мы делали это выше. Разработка функционала для *чтения* и *стирания* флеш-памяти выполняется аналогично.
#### Выводы
Таким образом, мы разработали всю бизнес-логику нашего проекта. Сначала мы выделили 5 минут на составление тест-листа (за это время мы продумали код). Такой подход позволил погрузиться в суть проекта до написания первой строчки кода.
**Финальное дерево проекта**
Далее согласно методологии TDD мы последовательно реализовали каждый тест и бизнес-логику для его успешного завершения. Каждый завершенный тест позволил нам оценить прогресс разработки. При написании нового функционала можно было проверять его корректность, запуская периодически готовые тесты, что помогало предотвратить внесение бага в уже существующий код.
При реализации класса `Configurator` мы использовали два тестовых шпиона `SerialSpy` и `FlashSpy` для симуляции работы драйвера UART и драйвера флеш-памяти.
Благодаря этому у нас появилась возможность запускать тесты разработанной бизнес-логики на ПК, не загружая при этом каждый раз код в МК для проверки его корректности. Однако это привело к увеличению объема разрабатываемого кода.
Код основной логики у нас получился независимым от платформы, т. е. его можно запустить на любом МК, нужно только написать реализацию драйвера в соответствии с нашими заголовочными файлами `Serial.h` и `Flash.h`.
Конечно, данных тестов недостаточно, чтобы полностью проверить весь разработанный функционал. Например, для большей эффективности применения unit-тестов можно дублировать тест `ShouldHandleWriteFlashCommand` и выставить граничное значение адреса. Затем можно еще раз дублировать тест и проверить, что при превышении верхней границы адреса флеш-памяти вернется ошибка. При желании каждый может скачать проект и дополнить его своими тестами.
[В следующей статье](https://habr.com/ru/company/ntc-vulkan/blog/489186/) мы реализуем драйверы `Serial.c` и `Flash.c` для STM32F103C8, а также запустим наш код, представленный в этой статье, на отладочной плате. Если тебе интересны вопросы «железной» разработки и безопасного кода, [присоединяйся к нашей команде](https://raccoonsecurity.ru/vacancies/).
**Дополнительная информация****Ссылки**
* [TDD для микроконтроллеров. Часть 1: Первый полет](https://habr.com/ru/company/ntc-vulkan/blog/487966/)
* [TDD для микроконтроллеров. Часть 3: Запуск на железе](https://habr.com/ru/company/ntc-vulkan/blog/489186/)
* Проект на [GitLab](https://gitlab.com/RaccoonSecurity/tddforembedded)
* [CppUTest](https://cpputest.github.io/)
* [Visual Studio](https://visualstudio.microsoft.com/)
* [STM32CubeMX](https://www.st.com/en/ecosystems/stm32cube.html)
* [Atollic TrueStudio](https://atollic.com/truestudio/)
**Литература**
* Test Driven Development for Embedded C, James Grenning
* [STM32F103C8 Programming manual](https://www.st.com/content/ccc/resource/technical/document/programming_manual/10/98/e8/d4/2b/51/4b/f5/CD00283419.pdf/files/CD00283419.pdf/jcr:content/translations/en.CD00283419.pdf)
* [STM32F103C8 Reference manual](https://www.st.com/content/ccc/resource/technical/document/reference_manual/59/b9/ba/7f/11/af/43/d5/CD00171190.pdf/files/CD00171190.pdf/jcr:content/translations/en.CD00171190.pdf)
[](https://raccoonsecurity.ru/)
*Raccoon Security – специальная команда экспертов НТЦ «Вулкан» в области практической информационной безопасности, криптографии, схемотехники, обратной разработки и создания низкоуровневого программного обеспечения.* | https://habr.com/ru/post/488370/ | null | ru | null |
# Travis CI: автоматическая загрузка собранных модулей на GitHub
В этой очень небольшой заметке я расскажу об очень небольшом усовершенствовании процесса автоматической сборки приложения в Travis CI. Я это проделал на примере Андроид-приложения, но, естественно, это будет работать и для других языков. Постановка задачи очень проста — участники сообщества попросили автоматически собирать в выкладывать приложение после каждого коммита в репозитории на GitHub. То есть речь идёт не о сборке фиксированных версий, а именно о «ежедневных» сборках, которые можно сразу же установить и тестировать, не дожидаясь официальной версии. Я, как разработчик, подобную заинтересованность могу только приветствовать, так как это сильно повышает качество обратной связи. Реализация этого процесса очень проста, только штатные средства GitHub и Travis CI, никакой магии. Так что я до сих пор сомневаюсь, стоит ли вообще о таком писать и отвлекать уважаемых хаброжителей от более серьёзных тем. Но если кто заинтересовался — прошу под кат.
Я, как разработчик под Android, с интересом и удовольствием мониторю некоторые Open Source проекты на GitHub, которые прошли успешное испытание временем и активно развиваются, например: [good-weather](https://github.com/qqq3/good-weather), [AFWall+](https://github.com/ukanth/afwall), [Timber](https://github.com/naman14/Timber), [Pedometer](https://github.com/j4velin/Pedometer), [AmazeFileManager](https://github.com/TeamAmaze/AmazeFileManager), [ConnectBot](https://github.com/connectbot/connectbot), [K-9 Mail](https://github.com/k9mail/k-9).
У всех этих репозиториев есть два общих момента — в них настроена автоматическая сборка приложения на сервере Travis CI после каждого коммита, и результаты этой автоматической сборки так и остаются на сервере Travis CI, то есть собранное проложение просто удаляется. Я же, как уже сказал во введении, хочу извлечь пользу из этого собранного APK-файла и поместить его обратно в GitHub репозиторий, чтобы он был сразу же доступен участникам сообщества для тестирования.
Travis CI предоставляет [штатный метод загрузки собранного приложения](https://docs.travis-ci.com/user/deployment/releases) на GitHub, но он предназначен для работы с тегами, то есть эта сборка, во первых, запускается при создании нового тега в GitHub-репозитории, и, во-вторых, позволяет загрузить APK-файл только в раздел GitHub Releases, но не в ветку репозитория. Так как создавать тег для каждого коммита — это, на мой взгляд, насилие над здравым смыслом, то этот метод я отбросил как несоответствующий духу и сути задачи.
Командный файл Travis CI (.travis.yml), расположенный в корне репозитория, имеет простую структуру:
```
language: android
jdk: oraclejdk8
android:
components:
- platform-tools
- tools
- build-tools-25.0.2
- android-25
- extra-android-m2repository
branches:
only:
- master
install:
- chmod +x ./gradlew
script: ./gradlew clean assembleDebug
notifications:
email:
on_success: change
on_failure: always
```
Этот скрипт выполняется на виртуальной машине в корне git-репозитория, который клонирован в т.н. "detached HEAD" режиме, то есть не позволяет напрямую закоммитить что-либо в мастер-ветку удалённого (то есть оригинального) GitHub-репозитория.
Если внимательно посмотреть лог выполнения этого скрипта на виртуальной мишине, то в самом начале (секция git скрипта, которая в данном примере не сконфигурирована) Travis делает вот что:
```
$ git clone --depth=50 --branch=master https://github.com/user/repo.git user/repo
Cloning into 'user/repo'...
$ cd user/repo
$ git checkout -qf d7d29a59cef70bfce87dc4779e5cdc1e6356313a
```
Именно git checkout -qf и переводит локальную ветку в "detached HEAD" режим.
После того, как секция script отработала (в моём примере ./gradlew clean assembleDebug), и в директории ./app/build/outputs/apk появился сгенерированный APK-файл, вызывается секция after\_success, где можно средствами Git закоммитить этот файл. Вопрос только, куда?
Есть несколько вариантов.
1) Можно использовать GitHub-Pages и помещать APK-файл туда, то есть коммитить в ветку gh-pages. Основной минус такого подхода в том, что GitHub-Pages рассчитаны на конечных пользователей, которые должны загружать приложение из официальных магазинов. Участники сообщества работают всё же с самим репозиторием, а не с GitHub-Pages. Поэтому я такой вариант не рассматриваю.
2) Можно коммитить обратно в мастер-ветку GitHub-репозитория, например, в папку autobuild. В этом случае, нужно деактивировать "detached HEAD", закоммитить файл, авторизоваться в удалённом репозитории и выполнить push.
```
install:
- git checkout master
- chmod +x ./autobuild/push-apk.sh
after_success:
- ./autobuild/push-apk.sh
```
где push-apk.sh выглядит так:
```
#!/bin/sh
mv ./app/build/outputs/apk/snapshot.apk ./autobuild/
git config --global user.email "travis@travis-ci.org"
git config --global user.name "Travis CI"
git remote add origin-master https://${AUTOBUILD_TOKEN}@github.com/user/repo > /dev/null 2>&1
git add ./autobuild/snapshot.apk
# We don’t want to run a build for a this commit in order to avoid circular builds:
# add [ci skip] to the git commit message
git commit --message "Snapshot autobuild N.$TRAVIS_BUILD_NUMBER [ci skip]"
git push origin-master
```
В данном варианте после каждого коммита в мастер-ветке GitHub-репозитория Travis будет делать ещё один коммит, где файл snapshot.apk будет также помещён в мастер-ветку. С одной стороны, удобно, что все в одном месте. С другой, этот файл также нужно постоянно синхронизировать в локальных репозиториях, что не очень удобно для разработчиков.
3) Посте всех экспериментов мне больше всего понравился третий вариант. В репозитории создаётся ветка autobuild, но из неё удаляются все файлы и директории за исключением папки autobuild. Этот огрызок полноценной веткой не является, так как её нельзя синхронизировать с мастер-веткой. Скрипт push-apk.sh будет выглядеть в этом случае так:
```
#!/bin/sh
# Checkout autobuild branch
cd ..
git clone https://github.com/user/repo.git --branch autobuild --single-branch repo_autobuild
cd repo_autobuild
# Copy newly created APK into the target directory
mv ../repo/app/build/outputs/apk/snapshot.apk ./autobuild
# Setup git for commit and push
git config --global user.email "travis@travis-ci.org"
git config --global user.name "Travis CI"
git remote add origin-master https://${AUTOBUILD_TOKEN}@github.com/user/repo > /dev/null 2>&1
git add ./autobuild/snapshot.apk
# We don’t want to run a build for a this commit in order to avoid circular builds:
# add [ci skip] to the git commit message
git commit --message "Snapshot autobuild N.$TRAVIS_BUILD_NUMBER [ci skip]"
git push origin-master
```
Последняя пара слов про авторизацию. За неё отвечает переменная окружения AUTOBUILD\_TOKEN. Эта переменная задаётся в разделе
```
env:
global:
secure:
```
Данный раздел содержит зашифрованный персональный ключ, который нужно сгенерировать на странице [Personal access tokens](https://github.com/settings/tokens). После чего он шифруется и добавляется в файл .travis.yml с помощью утилиты travis:
```
sudo gem install travis
echo AUTOBUILD_TOKEN= | travis encrypt --add -r user/repo
```
Вот такое небольшое усовершенствование. Кому интересно, можно посмотреть рабочий вариант в [этом репозитории](https://github.com/mkulesh/microMathematics).
Удачного всем прогрева серверов непрерывной интеграции! | https://habr.com/ru/post/338126/ | null | ru | null |
# Операции над IPv6-адресами — краткий экскурс
Введение
--------
Данная статья является переводом конкретного раздела, описывающего базовые операции над IPv6-адресами из учебника CCNA 200-301 Volume 1 от автора *Wendell Odom.*
Сокращение IPv6 адресов
-----------------------
Базовые правила:
* Два двоеточия подряд - это 2 или более гекстета адреса с нулями.
* Их "::" можно использовать всего один раз на весь IPv6-адрес.
Можно так `3124::DEAD:CAFE:0:0:0` или так `3124:0:0:DEAD:CAFE::`, но нельзя вот так 3124::DEAD:CAFE::
Например: 210F::CCCC:0:0:D - считаем, у нас 210F - первый гекстет, далее двойное двоеточие, далее идут CCCC:0:0:D - это еще 4 гекстета, итого 5 гекстетов. Так всего в IPv6-адресе 8 гекстетов, то 8-5=3 гекстета недостающих, заполняем их нулями и получаем 210F:0000:0000:0000:CCCC:0000:0000:000D
* Если перед буквами (hex) или цифрами, кроме нуля в гекстете идут нули, то их можно отсекать.
* Если нули идут после букв (hex) или цифр - их оставляем , иначе после обратного процесса мы получим другой адрес.
Например: `ABCD:0020` - в сокращенном виде выглядит как `ABCD:20`, а `ABCD:2000` - не сокращается.
**Разберем несколько примеров:**
| | |
| --- | --- |
| **Дано** | **С сокращением** |
| 2340:0000:0010:0100:1000:ABCD:0101:1010 | 2340:0:10:100:1000:ABCD:101:1010 |
| 30A0:ABCD:EF12:3456:0ABC:B0B0:9999:9009 | 30A0:ABCD:EF12:3456:ABC:B0B0:9999:9009 |
| 2222:3333:4444:5555:0000:0000:6060:0707 | 2222:3333:4444:5555:0:0:6060:707 |
| 3210:0000:0000:0000:0000:0000:0000:0000 | 3210:: |
| 210F:0000:0000:0000:CCCC:0000:0000:000D | 210F::CCCC:0:0:D |
| 34BA:000B:000B:0000:0000:0000:0000:0020 | 34BA:B:B::20 |
| FE80:0000:0000:0000:DEAD:BEFF:FEEF:CAFE | FE80::DEAD:BEFF:FEED:CAFE |
| FE80:0000:0000:0000:FACE:BAFF:FEBE:CAFE | FE80::FACE:BAFF:FEBE:CAFE |
Нахождение части подсетей IPv6-адреса
-------------------------------------
Допустим, на ПК клиента установлен такой адрес: 2000:1234:5678:9ABC:1234:5678:9ABC:1111/64. Так как максимальный префикс для IPv6 =128, то 64 - есть половина - то есть 4 гекстета из 8, таким образом, 2000:1234:5678:9ABC - часть подсети, а 1234:5678:9ABC:1111 - часть хостов.
Для написания номера подсети приводим часть хостов к нулю и получаем такое: 2000:1234:5678:9ABC:0000:0000:0000:0000/64, а в сокращенном виде: 2000:1234:5678:9ABC::/64
**Разберем несколько примеров:**
| | | |
| --- | --- | --- |
| **Дано** | **Подсеть** | **С сокращением** |
| 2340:0:10:100:1000:ABCD:101:1010/64 | 2340:0:10:100:0000:0000:0000:0000/64 | 2340:0:10:100::/64 |
| 30A0:ABCD:EF12:3456:ABC:B0B0:9999:9009/64 | 30A0:ABCD:EF12:3456:0000:0000:0000:0000/64 | 30A0:ABCD:EF12:3456::/64 |
| 2222:3333:4444:5555::6060:707/64 | 2222:3333:4444:5555:0000:0000:0000:0000/64 | 2222:3333:4444:5555::/64 |
| 3210::ABCD:101:1010/64 | 3210:0000:0000:0000:0000/64 | 3210:0:0:0:0/64 |
А теперь разберем несколько более сложных примеров:
**Дано:** 2000:1234:5678:9ABC:1234:5678:9ABC:1111/56
Каждый гекстет есть 16 бит, так как всего 8 гекстетов и 128 бит, таким образом 16\*8 = 128, значит половина гекстета = 8 бит.
В данном случае, нам нужно отсчитать 3 целых гекстет и половину 4-го, получаем 3\*16+8=56 бит.
Итого получаем такую часть подсети: 2000:1234:5678:9A00:0000:0000:0000:0000/56
или в сокращенном виде: 2000:1234:5678:9A00::/56
Тут можно легко допустить ошибку, посчитав, что, так как у нас префикс=56 бит, то после 9A мы должны были отсечь 2 символа, но это не так. Они остаются: 9A00, потому что, если отсечь два нуля в конце в дальнейшем может превратится в 009А, что является уже другим адресом.
**Разберем несколько примеров с различными префиксами:**
| | |
| --- | --- |
| **Дано** | **С сокращением** |
| 34BA:B:B:0:5555:0:6060:707/80 | 34BA:B:B:0:5555::/80 |
| 3124::DEAD:CAFE:FF:FE00:1/80 | 3124:0:0:DEAD:CAFE::/80 |
| 2BCD::FACE:BEFF:FEBE:CAFE/48 | 2BCD:0000:0000::/48 |
| 3FED:F:E0:D00:FACE:BAFF:FE00:0/48 | 3FED:F:E0::/48 |
| 210F:A:B:C:CCCC:B0B0:9999:9009/40 | 210F:A:0::/40 |
| 34BA:B:B:0:5555:0:6060:707/36 | 34BA:B:0::/36 |
| 3124::DEAD:CAFE:FF:FE00:1/60 | 3124:0:0:DEA0::/60 |
| 2BCD::FACE:1:BEFF:FEBE:CAFE/56 | 2BCD:0000:0000:FA00::/56 |
Учимся понимать как работает механизм по автоматической выдаче IPv6-адресов на основе MAC-адресов хостов
--------------------------------------------------------------------------------------------------------
**Дано:** 2001:DB8:1:1::/64
**MAC:** B8:0C:BE:EF:CA:FE, в дальнейшем буду разделять точкой на 3 октета: B80C.BEEF.CAFE
Первым делом необходимо разделить MAC-адрес пополам
и добавить посередине значение: **FFFE**, по итогу получаем такую запись: B80C:BE**FF**:**FE**EF:CAFE
Далее, берем первые 2 символа получившейся записи - это B8, очевидно, что это в шестнадцатеричном (HEX) формате.
Необходимо перевести B8 в двоичный вид, получаем: 1011 10**0**0, но это еще не все. Из двоичной записи берем **7-й бит** и инвертируем его (1 в 0 или 0 в 1) и получаем такую запись: 1011 10**1**0, а теперь обратно переводим в HEX-формат, получаем BA (B=1011, A=10**1**0). Наконец-то подставляем вместо B8 наш результат BA и получаем: BA0C:BEFF:FEEF:CAFE, а эту запись добавляем в конец адреса из **Дано** и получаем результат: 2001:DB8:1:1:BA0C:BEFF:FEEF:CAFE
**Разберем несколько примеров:**
| | | | |
| --- | --- | --- | --- |
| **Префикс** | **MAC-адрес** | **Результат** | **Мои расчеты** |
| 2001:DB8:1:1::/64 | 0013.ABAB.1001 | 2001:DB8:1:1:0213:ABFF:FEAB:1001 | |
| 2001:DB8:1:1::/64 | AA13.ABAB.1001 | 2001:DB8:1:1:A813:ABFF:FEAB:1001 | AA=1010 1010=1010 1000, 1010=A, 1000=8 |
| 2001:DB8:1:1::/64 | 000С.BEEF.CAFE | 2001:DB8:1:1:020C:BEFF:FEEF:CAFE | |
| 2001:DB8:1:1::/64 | B80C.BEEF.CAFE | 2001:DB8:1:1:BA0C:BEFF:FEEF:CAFE | B8=1011 1000=1011 1010, BA |
| 2001:DB8:FE:FE::/64 | 0C0C.ABAC.CABA | 2001:DB8:FE:FE:0E0C:ABFF:FEAC:CABA | 0C=0000 1100=0000 1110, 0E |
| 2001:DB8:FE:FE::/64 | 0A0C.ABAC.CABA | 2001:DB8:FE:FE:080C:ABFF:FEAC:CABA | 0A=0000 1010=0000 1000, 08 | | https://habr.com/ru/post/546814/ | null | ru | null |
# React Native — сохранение фотографий и видео в галерею устройства
Сохранение фотографий и видео на устройство android/ios вызывает у многих разработчиков React Native сложность. В этой статье я покажу как можно легко и безболезненно сохранять фотографии по url на устройство.
Для начала нам понадобятся две библиотеки:
1. **@react-native-community/cameraroll** — обеспечивает доступ к галерее(у меня получилось только с версией 1.4.0. На версиях «посвежее» были общеизвестные ошибки, напишите если у вас получилось с другой версией)
2. **rn-fetch-blob** — доступ к локальным файлам приложения. Стоить отметить, что данная библиотека работает с react native версии 0.60 и выше
#### IOS
На ios все оказалось очень просто:
1. Добавляем в Info.plist
```
NSCameraUsageDescription
NSPhotoLibraryAddUsageDescription
NSPhotoLibraryUsageDescription
```
2. Реализация
```
import CameraRoll from '@react-native-community/cameraroll';
const saveImageInDevice = async (url) => {
await CameraRoll.saveToCameraRoll(url, 'photo');
}
```
Вот и все! Функция saveImageInDevice принимает на вход адрес ссылки. CameraRoll.saveToCameraRoll загружает файл и сохраняет в галерею устройства. Второй параметр метода saveToCameraRoll может быть так же «video»
#### Android
На устройствах под android немного посложнее. Дело в том, что на android метод saveToCameraRoll не умеет работать с внешним url. Нам нужно сначала загрузить файл во внешнее хранилище, а дальше уже в галерею:
```
import {PermissionsAndroid} from 'react-native';
import CameraRoll from '@react-native-community/cameraroll';
import RNFetchBlob from 'rn-fetch-blob';
// запрашиваем разрешение на запись внешнему хранилищу
const checkAndroidPermission = async () => {
const permission = PermissionsAndroid.PERMISSIONS.WRITE_EXTERNAL_STORAGE;
await PermissionsAndroid.request(permission);
};
const saveImageInDevice = async (url) => {
await checkAndroidPermission();
let res = await RNFetchBlob
.config({
fileCache : true,
appendExt : 'jpg'
})
.fetch('GET', url);
url = res.path();
await CameraRoll.saveToCameraRoll(url, 'photo');
}
```
RNFetchBlob.fetch по GET запросу загрузит файл во внешнее хранилище и передаст url этого файла. Далее CameraRoll.saveToCameraRoll загрузит этот файл в галерею.
На этом все. Спасибо за внимание!
Ссылки:
[github.com/react-native-community/react-native-cameraroll](https://github.com/react-native-community/react-native-cameraroll)
[github.com/joltup/rn-fetch-blob](https://github.com/joltup/rn-fetch-blob) | https://habr.com/ru/post/501890/ | null | ru | null |
# Offline-first приложение с Hoodie & React. Часть вторая: авторизация
Наша цель, написать offline-first приложение — SPA которое загружается и сохраняет полную функциональность в отсутствии интернет-соединения. В [первой части](https://habrahabr.ru/post/309166/) повествования мы научились пользоваться браузерной базой данных. Сегодня мы настроим синхронизацию с серверной бд и подключим авторизацию. В результате мы получим возможность редактировать наши данные на разных устройствах даже в оффлайне с последующей синхронизацией при появлении соединения.
CouchDB
-------
Да, на сервере нам потребуется именно эта база данных. В настоящий момент активно разрабатывается [Pouchdb-Server](https://github.com/pouchdb/pouchdb-server), который на базе [LevelDB](https://github.com/google/leveldb) имитирует API [CouchDB](http://couchdb.apache.org/). Hoodie по умолчанию работает с ним, это сделано с целью упрощения установки для новичков. Но он сыр даже для целей разработки. Возможно, мне просто повезло, но я потратил 3 дня впервые пытаясь завести Hoodie и натыкаясь на странные ошибки, 3 дня issues и pull-request-ов. И на грани разочарования решил-таки установить нормальную CouchDB и все мои проблемы кончились. Поэтому я предлагаю вам сразу поставить последнюю, разве что вы тоже хотите предварительно внести посильный вклад в opensource.
В большинстве дистрибутивов CouchDB ставится штатными средствами.
**Если же вы тоже используете debian**Вот [инструкция](http://verbally.flimzy.com/install-couchdb-1-6-1-debian-8-2-jessie/) которой пользовался я. Однако, база постоянно падала пока я не удалил `/etc/init.d/coucdb` и не отдал её под надзор supervisord-а, вот конфиг последнего:
```
[program:couchdb]
user=couchdb
environment=HOME=/usr/local/var/lib/couchdb
command=/usr/local/bin/couchdb
autorestart=true
stdout_logfile=NONE
stderr_logfile=NONE
```
Поставив базу создаём админа:
```
curl -X PUT $HOST/_config/admins/username -d '"password"'
```
И включаем CORS:
```
npm install -g add-cors-to-couchdb
add-cors-to-couchdb -u username -p password
```
Теперь остаётся лишь немного поправить команду для запуска сервера в `package.json`:
```
"server": "hoodie --port 8000 --dbUrl 'http://username:password@127.0.0.1:5984'"
```
Надеюсь, у вас всё получилось :)
Авторизация
-----------
В AppBar-е у нас будет иконка авторизации со контекстным меню. Поэтому мы вынесем его в отдельную компоненту и будем использовать её в `App.js` вместо `AppBar`:
```
import NavBar from './NavBar'
```
Туда мы передаём `hoodie.account` который предоставляет нам API для авторизации:
* `hoodie.account.SignUp({username, password)}`
* `hoodie.account.SignIn({username, password)}`
* `hoodie.account.SingOut()`
И события на которые можно подписаться:
* `hoodie.account.on('signin', callback)`
* `hoodie.account.on('signout', callback)`
А вот и сама компонента:
**NavBar.js**
```
import React from 'react'
import AppBar from 'material-ui/AppBar'
import FlatButton from 'material-ui/FlatButton'
import IconButton from 'material-ui/IconButton'
import IconMenu from 'material-ui/IconMenu'
import MenuItem from 'material-ui/MenuItem'
import KeyIcon from 'material-ui/svg-icons/communication/vpn-key'
import AccountIcon from 'material-ui/svg-icons/action/account-circle'
import AuthDialog from './AuthDialog'
export default class NavBar extends React.Component {
constructor(props) {
super(props)
this.state = {
isSignedIn: this.props.account.isSignedIn(),
openedDialog: null
}
}
signOutCallback = () => this.setState({isSignedIn: false})
signInCallback = () => this.setState({isSignedIn: true})
componentDidMount() {
this.props.account.on('signout', this.signOutCallback)
this.props.account.on('signin', this.signInCallback)
}
componentWillUnmount() {
this.props.account.off('signout', this.signOutCallback)
this.props.account.off('signin', this.signInCallback)
}
render () {
let authMenu;
if (this.state.isSignedIn) {
authMenu = (
}
targetOrigin={{horizontal: 'right', vertical: 'top'}}
anchorOrigin={{horizontal: 'right', vertical: 'top'}}
>
this.props.account.signOut()} />
)
} else {
authMenu = (
}
targetOrigin={{horizontal: 'right', vertical: 'top'}}
anchorOrigin={{horizontal: 'right', vertical: 'top'}}
>
this.setState({openedDialog: 'signup'})} />
this.setState({openedDialog: 'signin'})} />
)
}
return (
this.setState({openedDialog: null})}
/>
)
}
}
```
В `state` у нас лежит текущее состояние авторизации для отрисовки иконки и меню. И открытый в данный момент диалог (регистрация, вход или `null` — если всё закрыто). В `componentDidMount` мы подписываемся на события входа и выхода. И в `render` отображаем нужную иконку в соответствии с состоянием авторизации. Осталось нарисовать диалог авторизации:
**AuthDialog.js**
```
import React from 'react';
import Dialog from 'material-ui/Dialog';
import FlatButton from 'material-ui/FlatButton';
import TextField from 'material-ui/TextField';
export default class AuthDialog extends React.Component {
constructor(props) {
super(props);
this.state = {
username: '',
password: '',
};
}
handleConfirm = () => {
const account = this.props.account;
const username = this.state.username.trim();
const password = this.state.password.trim();
if (!username || !password) {
return;
}
if (this.props.action == 'signup') {
account.signUp({username, password})
.then(() => {
return account.signIn({username, password})
})
.catch(console.error)
} else {
account.signIn({username, password})
.catch(console.error)
}
this.props.handleClose();
this.clearState();
}
handleCancel = () => {
this.props.handleClose();
this.clearState();
}
handleSubmit = (e) => {
e.preventDefault();
this.handleConfirm();
}
clearState = () => {
this.setState({
username: '',
password: ''
})
}
render () {
const buttons = [
,
];
return (
this.setState({username: e.target.value})}
/>
this.setState({password: e.target.value})}
/>
);
}
}
```
Диалоги регистрации и входа у нас имеют идентичные поля формы, поэтому мы объединим их в один. Логика компоненты элементарна: в `handleConfirm` мы либо входим либо сначала регистрируемся, а затем входим.
Осталось перезагрузить сами loop-ы при авторизации. Добавим реакцию на события в `App.js`:
```
componentDidMount() {
hoodie.store.on('change', this.loadLoops);
hoodie.account.on('signin', this.loadLoops)
hoodie.account.on('signout', this.loadLoops)
}
componentWillUnmount() {
hoodie.store.off('change', this.loadLoops);
hoodie.account.off('signin', this.loadLoops)
hoodie.account.off('signout', this.loadLoops)
}
```
Конец
-----
Итак, авторизация готова. Наибольшим вызовом этой части была, вероятно, установка CouchDB. Теперь наше приложение сохранит свою функциональность при разрыве соединения, а при появлении синхронизируется. Однако, если совсем закрыть сайт, открыть его без интернета не получится. Мы исправим это в следующей, финальной части.
» Код этой части доступен тут: <https://github.com/imbolc/action-loop> под тегом part2. | https://habr.com/ru/post/309572/ | null | ru | null |
# Необычная Java: StackTrace Extends Throwable
#### Прочтите эту статью и узнайте о необычных вещах в Java, которые могут оказаться на удивление полезными.
Есть вещи, которые вы можете делать в Java, но вы их редко видите. В основном потому, что в них нет смысла. Однако в Java есть несколько необычных вещей, которые могут оказаться на удивление полезными.
[Chronicle Software](https://chronicle.software/) обычно использует ряд различных шаблонов в своих низкоуровневых библиотеках, с которыми большинство разработчиков вообще не сталкивается.
Один из них — это класс, который расширяет Throwable, но не является ошибкой или исключением.
StackTrace Extends Throwable
----------------------------
```
package net.openhft.chronicle.core;
/**
* Throwable created purely for the purposes of reporting a stack trace.
* This is not an Error or an Exception and is not expected to be thrown or caught.
*/
public class StackTrace extends Throwable {
public StackTrace() { this("stack trace"); }
public StackTrace(String message) { this(message, null); }
public StackTrace(String message, Throwable cause) {
super(message + " on " + Thread.currentThread().getName(), cause);
}
public static StackTrace forThread(Thread t) {
if (t == null) return null;
StackTrace st = new StackTrace(t.toString());
StackTraceElement[] stackTrace = t.getStackTrace();
int start = 0;
if (stackTrace.length > 2) {
if (stackTrace[0].isNativeMethod()) {
start++;
}
}
if (start > 0) {
StackTraceElement[] ste2 = new StackTraceElement[stackTrace.length - start];
System.arraycopy(stackTrace, start, ste2, 0, ste2.length);
stackTrace = ste2;
}
st.setStackTrace(stackTrace);
return st;
}
}
```
Некоторые важные примечания, чтобы для начала:
* Это не тот класс исключения, которое, как я рассчитываю, когда-либо может возникнуть. Классы, непосредственно расширяющие Throwable, проверяются, как и Exception, поэтому компилятор поможет вам обеспечить эту проверку.
* Трассировка стека Throwable определяется при создании Throwable, а не там, где она возникает. Обычно это одна и та же строка, но это не обязательно. Чтобы получить трассировку стека, Throwable не должно вызвать исключение.
* Объекты элементов трассировки стека не создаются до тех пор, пока они не потребуются. Вместо этого метаданные добавляются к самому объекту, чтобы уменьшить накладные расходы, а массив StackTraceElements заполняется при первом использовании.
Однако давайте рассмотрим этот класс более подробно. Класс будет протоколировать как трассировку стека, где он был создан, так и поток, который его создал. Позже вы увидите насколько это полезно.
Этот класс также можно использовать для хранения трассировки стека другого запущенного потока.
Трассировка стека другого потока берется только тогда, когда поток достигает безопасной точки. Это может произойти через некоторое время после того, как вы попытаетесь получить его.
Связано это с тем, что JVM останавливает поток, и обычно JVM ждут, чтобы остановить каждый поток, поэтому он может проверить стек потока, который вы пытаетесь захватить. Т.е. это имеет высокие накладные расходы, но может быть очень полезным.
StackTrace как отложенное исключение
------------------------------------
Мы не предполагаем, что этот Throwable класс будет вызван, но он может записать причину исключения, которое может быть вызвано позже.
### Почему был закрыт ресурс
```
public class EgMain {
static class MyCloseable implements Closeable {
protected transient volatile StackTrace closedHere;
@Override
public void close() {
closedHere = new StackTrace("Closed here"); // line 13
}
public void useThis() {
if (closedHere != null)
throw new IllegalStateException("Closed", closedHere);
}
}
public static void main(String[] args) throws InterruptedException {
MyCloseable mc = new MyCloseable(); // line 27
Thread t = new Thread(mc::close, "closer");
t.start();
t.join();
mc.useThis();
}
}
```
При запуске код выдает следующее исключение:
Обычно вы увидите исключение IllegalStateException и место, где ваш код пытался использовать закрытый ресурс, но это не говорит вам, почему он был закрыт без дополнительной информации.
Поскольку StackTrace является Throwable классом, вы можете указать его в качестве причины последующего исключения или ошибки.
Вы можете увидеть поток, который закрыл ресурс. Таким образом вы узнаете, что это исключение или ошибка произошло в другом потоке. И вы можете увидеть трассировку стека с причиной, по которой он был закрыт. Это может помочь очень быстро диагностировать трудно обнаруживаемые проблемы связанные с преждевременным закрытием ресурсов.
### Какой ресурс был закрыт?
Долгоживущие объекты Closeable могут иметь сложный жизненный цикл, и обеспечение их закрытия, когда это необходимо, может быть трудно отследить. Что может привести к утечке ресурсов.
Некоторые ресурсы не удаляются, когда GC освобождает объект, например, объект RandomAccessFile освобождается в GC вместе с файлом, который он представляет, и не закрывается, пока вы его не закроете, что приводит к потенциальной утечке ресурсов файловых дескрипторов.
```
public class CreatedMain {
static class MyResource implements Closeable {
private final transient StackTrace createdHere = new StackTrace("Created here");
volatile transient boolean closed;
@Override
public void close() throws IOException {
closed = true;
}
@Override
protected void finalize() throws Throwable {
super.finalize();
if (!closed)
Logger.getAnonymousLogger().log(Level.WARNING, "Resource discarded but not closed", createdHere);
}
}
public static void main(String[] args) throws InterruptedException {
new MyResource(); // line 27
System.gc();
Thread.sleep(1000);
}
}
```
Код выводит следующее:
Что позволяет вам не только видеть, где был создан ресурс, что дает возможность определить, почему он не был закрыт, но и просто вести лог так, как понимает ваша IDE. Это возможно потому, что ваш объект Logger будет поддерживать выдачу трассировки стека. например, вы можете кликнуть по номеру строки, чтобы просмотреть код, создавший ее.
Мониторинг производительности критического потока в рабочей среде
-----------------------------------------------------------------
В некоторых средах вам нужен способ мониторинга критических событий в рабочей среде с низкими издержками без запуска профилировщика.
Этого можно добиться, включив свой собственный мониторинг, чтобы производить трассировку стека только тогда, когда превышен некоторый порог. Это поможет найти проблемы, которые вы не можете воспроизвести в среде тестирования или разработки, поэтому это может быть бесценно.
После того как мы добавили эту возможность в нашу инфраструктуру, количество мистических задержек, о которых сообщили нам наши клиенты, резко сократилось, поскольку клиенты могли сами диагностировать проблему по трассировке стека.
```
public class JitteryMain implements Runnable {
volatile long loopStartMS = Long.MIN_VALUE;
volatile boolean running = true;
@Override
public void run() {
while (running) {
loopStartMS = System.currentTimeMillis();
doWork();
loopStartMS = Long.MIN_VALUE;
}
}
private void doWork() {
int loops = new Random().nextInt(100);
for (int i = 0; i < loops; i++)
pause(1); // line 24
}
static void pause(int ms) {
try {
Thread.sleep(ms); // line 29
} catch (InterruptedException e) {
throw new AssertionError(e); // shouldn't happen
}
}
public static void main(String[] args) {
final JitteryMain jittery = new JitteryMain();
Thread thread = new Thread(jittery, "jitter");
thread.setDaemon(true);
thread.start();
// monitor loop
long endMS = System.currentTimeMillis() + 1_000;
while (endMS > System.currentTimeMillis()) {
long busyMS = System.currentTimeMillis() - jittery.loopStartMS;
if (busyMS > 100) {
Logger.getAnonymousLogger()
.log(Level.INFO, "Thread spent longer than expected here, was " + busyMS + " ms.",
StackTrace.forThread(thread));
}
pause(50);
}
jittery.running = false;
}
}
```
Выводит следующее и опять же, как вы видите, можно легко перемещается по стеку в вашей IDE.
Вам может быть интересно, почему это происходит в данном случае. Наиболее вероятная причина заключается в том, что *Thread.sleep(time)* спит в течение минимального, а не максимального времени, а в Windows спящий режим 1 мс на самом деле довольно стабильно занимает около 1,9 мс.
Обнаружение одновременного доступа к однопоточному ресурсу разными потоками
---------------------------------------------------------------------------
```
package net.openhft.chronicle.core;
public class ConcurrentUsageMain {
static class SingleThreadedResource {
private StackTrace usedHere;
private Thread usedByThread;
public void use() {
checkMultithreadedAccess();
// BLAH
}
private void checkMultithreadedAccess() {
if (usedHere == null || usedByThread == null) {
usedHere = new StackTrace("First used here");
usedByThread = Thread.currentThread();
} else if (Thread.currentThread() != usedByThread) {
throw new IllegalStateException("Used two threads " + Thread.currentThread() + " and " + usedByThread, usedHere);
}
}
}
public static void main(String[] args) throws InterruptedException {
SingleThreadedResource str = new SingleThreadedResource();
final Thread thread = new Thread(() -> str.use(), "Resource user"); // line 25
thread.start();
thread.join();
str.use(); // line 29
}
}
```
Выводит следующее:
Вы можете заметить, что ресурс использовался двумя потоками с разными именами, однако вы также можете видеть, где в стеке они использовались, чтобы определить возможную причину.
Отключение этой трассировки
---------------------------
Создание StackTrace оказывает значительное влияние на поток и, возможно, на JVM. Однако его легко отключить с помощью управляющего флага, такого как системное свойство, и заменить его *нулевым* значением.
```
createdHere = Jvm.isResourceTracing()
? new StackTrace(getClass().getName() + " created here")
: null;
```
Это использование *значения null* не требует специальной обработки, поскольку logger будет игнорировать Throwable, который имеет значение *null*, и вы можете указать *null как* причину для исключения, и это то же самое, что и не указывать ее.
Заключение
----------
Хотя класс, который напрямую расширяет Throwable, выглядит странно, он разрешен.
Более того он удивительно полезен для предоставления дополнительной информации о жизненном цикле ресурса или добавления простого мониторинга, который вы можете запустить в рабочей среде.
Ссылки
------
[Chronicle Open Source](https://chronicle.software/open-hft/)
[OpenHFT Chronicle Core](https://github.com/OpenHFT/Chronicle-Core) | https://habr.com/ru/post/655259/ | null | ru | null |
# Автоматизируем и ускоряем процесс настройки облачных серверов с Ansible. Часть 5: local_action, условия, циклы и роли
[В первой части](https://infoboxcloud.ru/community/blog/iaas/226.html) мы начали изучение Ansible, популярного инструмента для автоматизации настройки и развертывания ИТ-инфраструктуры. Ansible был успешно установлен в [InfoboxCloud](http://infoboxcloud.ru), описаны принципы работы, базовая настройка. В завершении статьи мы показали как быстро установить nginx на несколько серверов.
[Во второй части](https://infoboxcloud.ru/community/blog/iaas/236.html) мы разобрались в выводе playbook, научились отлаживать и повторно использовать скрипты Ansible.
[В третьей части](https://infoboxcloud.ru/community/blog/iaas/242.html) мы узнали как написать единый Ansible playbook для разных ОС (например с rpm и deb), как обслуживать сотни хостов и не писать их все в inventory и как сгруппировать сервера по регионам InfoboxCloud. Было изучено использование переменных Ansible и файла inventory.
[В четвертой части](https://infoboxcloud.ru/community/blog/iaas/244.html) мы научились использовать модули Ansible для настройки сервера: разобрались, как запускать самые обычные скрипты на удаленных серверах в [InfoboxCloud](http://infoboxcloud.ru), использовать шаблонизацию для файлов конфигурации, подставляя необходимые переменные, и как использовать системы управления версиями для получения кода на сервер.
В этой части мы рассмотрим, как запускать задачу локально в рамках playbook для удаленных серверов, как использовать условия для выполнения конкретных задач только в определенной ситуации, как использовать циклы для значительного сокращения количества задач в playbook. В завершении мы разберем, как организовывать playbook в роли.
#### **Запускаем задачи локально с помощью local\_action**
Иногда задачи надо запускать на локальной машине в рамках исполнения playbook для удаленных серверов. Например, можно на Ansible–сервере прописать ключи доступа по API к облаку и отдавать команды [утилите командной строки](https://github.com/tsukaeru/pacicli) для создания новых серверов облака. Часто может требоваться отправлять запросы в REST API через модуль **uri** Ansible. Возможность что-то делать прямо на Ansible–сервере для отдельной задачи в playbook, где в качестве hosts прописаны удаленные сервера, есть.
Допустим, вы хотите запустить shell–модуль на сервере, откуда вы запускаете Ansible. Для этого пригодится опция **local\_action**, которая запустит модуль локально.
```
---
- hosts: experiments
remote_user: root
tasks:
- name: check running processes on remote system
shell: ps
register: remote_processes
- name: remote running processes
debug: msg="{{ remote_processes.stdout }}"
- name: check running processes on local system
local_action: shell ps
register: local_processes
- name: local running processes
debug: msg="{{ local_processes.stdout }}"
```
Процессы на удаленных машинах.
Процессы на локальной машине.
Mы видим, что исполнение команды перенаправляется для локальной машины.
Таким образом, вы можете запустить любой модуль Ansible с local\_action.
#### **Работаем с условиями**
Ansible исполняет все задачи последовательно. Тем не менее, для сложного playbook с десятками задач, вам может потребоваться в зависимости от ситуации запускать только часть задач. Ранее мы уже рассматривали ситуацию, когда [с помощью переменных](https://infoboxcloud.ru/community/blog/iaas/242.html) мы корректно устанавливали Apache на rpm и deb дистрибутивы. Подобным образом можно указывать условия для выполнения задач с помощью **when**:
```
---
- hosts: experiments
remote_user: root
tasks:
- name: Install httpd package
yum: name=httpd state=latest
sudo: yes
when: ansible_os_family == "RedHat"
- name: Install apache2 package
apt: name=apache2 state=latest
sudo: yes
when: ansible_os_family == "Debian"
```
Если ОС семейства RedHat – будет установлен пакет httpd через yum, а если семейства Debian – apache2 через apt. ansible\_os\_family – переменная Ansible, получаемая на стадии gather\_facts.
В playbook выше мы использовали sudo: yes, подразумевая, что у пользователя есть права sudo. Давайте проверим, так ли это:
```
---
- hosts: experiments
remote_user: root
tasks:
- name: Testing user sudo privilege
command: /usr/bin/sudo -v
register: sudo_response
ignore_errors: yes
- name: Stop if Users doesn`t have sudo privilege
fail: msg="User doesn`t have sudo privilege"
when: sudo_response.rc == 1
```
В примере выше мы запустили команду на сервере **/usr/bin/sudo -v** и сохранили ее вывод в переменную через **register**. В переменной был захвачен вывод stdout и stderr (rc, return code). Во второй задаче мы проверили содержание return code переменной и если ошибка произошла — должны завершить исполнение playbook с выводом сообщения.
Для сравнения в условиях в Ansible можно использовать == (равно), != (не равно), > (больше), < (меньше), >= (больше равно), <= (меньше равно).
Если вам нужно проверить, есть ли в переменной символ или строка, используйте операторы in и not.
```
- name: Querying rpm list for httpd package
shell: rpm -qa | grep httpd
register: httpd_rpm
- name: Check if httpd rpm is installed on the remote host
debug: msg="httpd is installed on the remote host"
when: "'httpd-2.2.27–1.2.x86_64' in httpd_rpm.stdout"
– name: Check if httpd rpm is not installed on the remote host
debug: msg="httpd is not installed on the remote host"
when: not 'httpd-2.2.27.1.2.x86_64' in httpd_rpm.stdout
```
Можно задавать несколько условий, используя операторы and (и) и or (или).
```
– name: Check if httpd rpm is installed on the remote host
debug: msg="httpd is installed on the remote host"
when: "'httpd-2.2.27–1.2.x86_64' in httpd_rpm.stdout and 'httpd-tools-2.2.27–1.2.x86–64' in httpd_rpm.stdout"
```
Также можно проверить логическое значение переменной. Давайте сделаем бекап, если в переменной backup установлено true:
```
– name: Rsync
shell: /usr/bin/rsync -ra /home /backup/{{ inventory_hostname}}
sudo: yes
when: backup
```
Ansible позволяет в условии использовать информацию о том, была ли уже определена переменная. Для этого используйте **when: var is not define** (где var — имя переменной, is not define – еще не была определена, is defined – уже была определена).
#### **Работаем с циклами**
Бывает, что необходимо установить сразу несколько пакетов на сервер. Но написание многих задач для этого может превратиться в настоящий ночной кошмар. Проблему решит использование циклов.
##### **Стандартные циклы**
Используя стандартные циклы вы можете передать список пакетов для установки и Ansible запустит задачу для всех указанных пакетов.
```
---
- hosts: experiments
remote_user: root
tasks:
– name: Install nginx package
yum: name={{ item }} state=latest
with_items:
– nginx
– htop
sudo: yes
```
В примере выше мы использовали конструкцию «with\_items:» для задания переменных и использовали переменную по умолчанию item. На каждой итерации item принимает следующее значение, указанное в with\_items.
Задача запускается один раз, но apt вызывается для всех указанных пакетов. Можно так же использовать with\_items как словарь вместо строк:
```
with_items:
– {name: 'httpd', state: 'latest'}
– {name: 'htop', state: 'absent'}
```
##### **Вложенные циклы**
Вложенные циклы полезны, когда вы хотите выполнить несколько операций над одним и тем же ресурсом. Например, если вы хотите предоставить доступ ко множеству баз данных для пользователей MySQL.
```
–––
– hosts: experiments
remote_user: root
tasks:
– name: give users access to multiple databases
mysql_user: name={{ item[0] }} priv={{ item[1]}}.*:ALL append_privs=yes password=pass login_user=root login_password=root
with_nested:
– ['alexey', 'alexander']
– ['clientdb', 'providerdb']
```
В приведенном примере мы используем модуль mysql\_user для установки прав на базы данных и используем вложенные циклы с двумя списками: список пользователей и список баз данных. Ansible запустит модуль mysql\_user для пользователя alexey, даст права на все указанные во втором списке базы данных, затем запустит для пользователя alexander и так же даст права.
#### **Циклы по подэлементам**
В предыдущем примере мы назначили все указанные базы данных всем указанным пользователям. Но что делать, если для каждого пользователя нужно назначить свой специфический набор баз данных? Для этого нам пригодятся циклы по подэлементам.
```
---
- hosts: experiments
remote_user: root
vars:
users:
– name: alexey
database:
– clientdb
– providerdb
– name: alexander
database:
– providerdb
tasks:
– name: give users access to multiple databases
mysql_user: name={{ item.0.name }} priv={{ item.1 }}.*:ALL append_privs=yes password=pass login_user=root login_password=root
with_subelements:
– users
- database
```
Мы создали словари, которые состоят из имен пользователей и имен баз данных. Вместо добавления данных пользователей в playbook можно вынести их в отдельный файл переменных и включить в playbook. Ansible пройдется по словарю используя переменную item. Ansible назначает численные значения ключам, представленным конструкцией with\_subelements, начиная с 0. В словаре 0 имя — пара «ключ-значения», поэтому для обращения по имени пользователя мы используем item.0.name. Dictionary — простой список, поэтому для обращения используем item.1.
#### **Работаем с ролями**
При проектировании архитектуры обычно оперируют ролями серверов: веб-сервер, сервер баз данных, балансировщик нагрузки и так далее. Каждая роль включает в себя определенный набор софта для установки и настройки. С ростом вашей системы постепенно будут выделяться компоненты, которые можно повторно использовать. Роли в Ansible предоставляют удобный способ организации ваших playbook. На основе предопределенной файловой структуры будут загружаться компоненты роли. Фактически роли — просто магия вокруг include (импортов), облегчающая подготовку playbook.
Типичная структура playbook с ролями:
```
---
- hosts: webservers
roles:
- common
- web
– db
```
Файловая структура ролей будет выглядеть так:
```
site.yml
webservers.yml
roles/
common/
files/
templates/
tasks/
handlers/
vars/
defaults/
meta/
web/
files/
templates/
tasks/
handlers/
vars/
defaults/
meta/
db/
files/
templates/
tasks/
handlers/
vars/
defaults/
meta/
```
Если какой-то директории в роли нет — она будет проигнорирована и playbook будет исполняться. Совсем не обязательно у вас должны быть все элементы и директории playbook.
Правила, используемые для каждой роли:
* Если **roles/x/tasks/main.yml** существует, задачи будут добавлены в процесс исполнения playbook.
* Если **roles/x/handlers/main.yml** существует, обработчики событий будут добавлены в процесс исполнения playbook.
* Если **roles/x/vars/main.yml** существует, переменные будут добавлены в процесс исполнения playbook.
* Если **roles/x/meta/mail.yml** существует, любые роли-зависимости будут добавлены в список ролей. (В meta можно указывать список ролей, которые должны быть применены до конкретной роли, чтобы она применилась корректно).
* Любая задача копирования может ссылаться на файл в **roles/x/files** без указания абсолютного или относительного пути.
* Любая скриптовая задача может ссылаться на скрипты в **roles/x/files** без указания абсолютного или относительного пути.
* Любая задача шаблонизации может ссылаться на **roles/x/templates** без указания абсолютного или относительного пути.
* Любые импортируемые задачи могут ссылаться на файлы задач в директории **roles/x/tasks** без указания абсолютного или относительного пути.
В конфигурационном файле Аnsible можно задать **roles\_path** (директорию с ролями). Это может пригодиться, если у вас playbook лежат в одном репозитории, а сами роли в другом. Можно задавать сразу несколько путей к ролям через двоеточие:
```
roles_path = /opt/mysite/roles:/opt/othersite/roles
```
В роли можно передавать переменные или использовать условия:
```
---
- hosts: experiments
roles:
– common
– {role: web, dir: '/var/www', port: 80}
– {role: repository, when: "ansible_os_family =='RedHat'"}
```
Ранее в статьях мы не рассматривали тэги. С их помощью можно запускать помеченную часть playbook.
С задачами использование тэгов выглядит так:
```
tasks:
- apt: name={{ item }} state=installed
with_items:
- httpd
- htop
tags:
- packages
- template: src=templates/src.j2 dest=/var/www/.htaccess
tags:
- configuration
```
Можно запустить часть playbook так: **ansible-playbook example.yml --tags «configuration,packages»** или пропустить исполнение части так: ansible-playbook example.yml --skip-tags «notification».
Так вот тэги также можно использовать и при указании ролей:
```
---
- hosts: experiments
roles:
- { role: web, tags: ["apache", "simple"] }
```
Можно указать, какие задачи должны выполниться до роли и после:
```
---
- hosts: experiments
pre_tasks:
- shell: echo 'hello, habr'
roles:
- { role: web }
tasks:
- shell: echo 'still busy'
post_tasks:
- shell: echo 'goodbye, habr'
```
##### **Зависимости ролей**
Зависимости ролей позволяют автоматически исполнить зависимые роли при запуске конкретных ролей, у которых зависимости есть. Зависимости хранятся в roles/x/meta/main.yml. Вместе с зависимыми ролями могут быть переданы параметры. Путь к ролям может быть указан как в сокращенном виде, так и в полном. Также может быть использован репозиторий системы управления версиями.
```
---
dependencies:
- { role: common, some_parameter: 3 }
- { role: '/path/to/common/roles/foo', x: 1 }
- { role: 'git+http://git.example.com/repos/role-foo,v1.1,foo' }
```
Если в зависимостях указана одна и та же роль несколько раз — она запустится только однажды. Если нужно несколько раз, можно в файле зависимостей попросить об этом явно.
#### **Ansible Galaxy**
[Ansible Galaxy](https://galaxy.ansible.com) — репозиторий ролей Ansible. С этого ресурса можно использовать уже готовые роли Ansible или добавлять свои.
#### **Заключение**
В написании статьи очень помогла книга "[Learning Ansible](http://www.amazon.com/Learning-Ansible-Madhurranjan-Mohaan/dp/1783550635/ref=sr_1_2?ie=UTF8&qid=1422482924&sr=8-2&keywords=ansible)" и конечно [официальная документация](http://docs.ansible.com).
Все эксперименты с Ansible удобно проводить в [InfoboxCloud](http://infoboxcloud.ru), так как имеется возможность для каждого виртуального сервера установить именно то количество ресурсов, которое необходимо для задачи (CPU/Ram/диск независимо друг от друга) или использовать автомасштабирование, а не выбирать VM из готовых шаблонов. Когда эксперименты не проводятся — можно просто выключить VM и оплачивать только стоимость диска.
Если вы обнаружили ошибку в статье, автор ее с удовольствием исправит. Пожалуйста напишите в ЛС или [на почту](mailto:trukhinyuri@infoboxcloud.com) о ней. Туда же можно задавать вопросы по Ansible для освещения в последующих статьях. Если вы не можете писать комментарии на Хабре, можно оставить их в [Сообществе InfoboxCloud](https://infoboxcloud.ru/community/blog/iaas/246.html).
Успешной работы! | https://habr.com/ru/post/252461/ | null | ru | null |
# Android — фильтруем пины на карте, в зависимости от расстояния друг от друга
Довелось как то недавно делать проект с использованием google maps. В один из моментов, увидел я вот такую картину:
Это происходило, как вы догадались, когда рядом находилось слишком много мест, которые требовалось отображать. Ну ничего – проблема то вроде стандартная – много у кого должно было такое встречаться, наверняка разработчики предусмотрели группировку и фильтрацию… Ага, ни тут то было! Просмотрев документацию(сразу признаюсь что только бегло – возможно и упустил то что мне нужно) и спросив у гугла – к своему удивлению быстро ничего нужного найти не удалось. Ну ничего – не боги горшки обжигают – значит напишем сами.
Для начала создадим проект и подключим к нему google maps api. Тут я думаю объяснять ничего не надо – про это много уже было написано, вот кстати ссылки и на хабре – [раз](http://habrahabr.ru/blogs/android_development/131252/), [два](http://habrahabr.ru/blogs/android_development/129234/), [три](http://habrahabr.ru/blogs/android_development/123403/).
Cначала определимся что да как должно работать. Поехали…
Очевидно что нам надо придумать некий алгоритм, по которому будут выводиться на экран не все пины, а только находящиеся друг от друга на определенном расстоянии. А так же надо научиться объединять их в группы. Пересчет всего этого хозяйства надо чтобы происходил:
1) При первоначальной загрузке пинов на карту.
2) При изменении zoom
С первым пунктом в принципе все ясно – давайте определимся со вторым. Объявим интерфейс:
```
public interface IOnZoomListener {
void onZoomChanged();
}
```
И модифицируем наш MapView вот таким образом:
```
public class MyMapView extends MapView {
int oldZoomLevel = -1;
IOnZoomListener onZoomListener;
public MyMapView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
}
public MyMapView(Context context, String apiKey) {
super(context, apiKey);
}
public MyMapView(Context context, AttributeSet attrs) {
super(context, attrs);
}
public void setOnZoomListener(IOnZoomListener onZoomListener) {
this.onZoomListener = onZoomListener;
}
@Override
public void dispatchDraw(Canvas canvas) {
super.dispatchDraw(canvas);
int newZoom = this.getZoomLevel();
if (newZoom != oldZoomLevel) {
if (oldZoomLevel != -1 && onZoomListener != null) {
onZoomListener.onZoomChanged();
}
oldZoomLevel = getZoomLevel();
}
}
}
```
Здесь мы просто добавили возможность регистрации нашего интерфейса и проверку при отрисовке на изменение ZoomLevel(если ZoomLevel поменялся – дергаем метод нашего интерфейса).
Теперь определимся с тем, как мы будем отображать пины на карте и как объединять их в группы. Для этого создадим class MyOverlayItem унаследованный от OverlayItem вот с такими дополнениями:
```
public class MyOverlayItem extends OverlayItem {
private String name;
private ArrayList list = new ArrayList();
public MyOverlayItem(GeoPoint point, String name) {
super(point, "", "");
this.name = name;
}
public String getName() {
if (list.size() > 0) {
return "There are " + (list.size() + 1) + " places.";
} else {
return name;
}
}
public void addList(MyOverlayItem item) {
list.add(item);
}
public ArrayList getList() {
return list;
}
}
```
В ArrayList list будет храниться список сгруппированных пинов, а метод getName будет возвращать нам либо имя объекта, либо их количество в группе.
Теперь опишем то, ради чего, собственно, это все и затевалось – наш модифицированный ItemizedOverlay.
Суть алгоритма фильтрации довольно таки проста: мы просто бежим в цикле по всем существующим элементам и проверяем каждый элемент на предмет близкого расстояния с уже существующей группой элементов. Если мы нашли такую группу – элемент добавляется в нее, если нет – создается новая группа с данным элементом:
```
boolean isImposition;
for (MyOverlayItem itemFromAll : myOverlaysAll) {
isImposition = false;
for (MyOverlayItem item : myOverlays) {
if (itemFromAll == item) {
isImposition = true;
break;
}
if (isImposition(itemFromAll, item)) {
item.addList(itemFromAll);
isImposition = true;
break;
}
}
if (!isImposition) {
myOverlays.add(itemFromAll);
}
}
```
Сначала для проверки расстояния, я хотел использовать просто координаты пинов(погрешностью, возникающей в зависимости от широты, можно пренебречь, так как расстояния не велики), но тогда пришлось бы еще и контролировать ZoomLevel.
Для моих задач вполне подошел метод mapView.getLatitudeSpan который возвращает расстояние видимой ширины экрана в нужной нам системе координат. Осталось только поделить это расстояние на некий коэффициент(сколько максимально пинов должно «влезать» в экран по ширине) – это и будет минимальное расстояние между пинами:
```
private boolean isImposition(MyOverlayItem item1, MyOverlayItem item2) {
int latspan = mapView.getLatitudeSpan();
int delta = latspan / KOEFF;
int dx = item1.getPoint().getLatitudeE6() - item2.getPoint().getLatitudeE6();
int dy = item1.getPoint().getLongitudeE6() - item2.getPoint().getLongitudeE6();
double dist = Math.sqrt(dx * dx + dy * dy);
if (dist < delta) {
return true;
} else {
return false;
}
}
```
Вот на всякий случай полный исходник класса:
```
public class PlaceOverlay extends ItemizedOverlay {
private static final int KOEFF = 20;
private ArrayList myOverlaysAll = new ArrayList();
private ArrayList myOverlays = new ArrayList();
private MapView mapView;
public PlaceOverlay(Drawable defaultMarker, MapView mapView) {
super(boundCenterBottom(defaultMarker));
this.mapView = mapView;
populate();
}
public void addOverlay(MyOverlayItem overlay) {
myOverlaysAll.add(overlay);
myOverlays.add(overlay);
}
public void doPopulate() {
populate();
setLastFocusedIndex(-1);
}
@Override
protected MyOverlayItem createItem(int i) {
return myOverlays.get(i);
}
@Override
public int size() {
return myOverlays.size();
}
private boolean isImposition(MyOverlayItem item1, MyOverlayItem item2) {
int latspan = mapView.getLatitudeSpan();
int delta = latspan / KOEFF;
int dx = item1.getPoint().getLatitudeE6() - item2.getPoint().getLatitudeE6();
int dy = item1.getPoint().getLongitudeE6() - item2.getPoint().getLongitudeE6();
double dist = Math.sqrt(dx \* dx + dy \* dy);
if (dist < delta) {
return true;
} else {
return false;
}
}
public void clear() {
myOverlaysAll.clear();
myOverlays.clear();
}
public void calculateItems() {
myOverlaysClear();
boolean isImposition;
for (MyOverlayItem itemFromAll : myOverlaysAll) {
isImposition = false;
for (MyOverlayItem item : myOverlays) {
if (itemFromAll == item) {
isImposition = true;
break;
}
if (isImposition(itemFromAll, item)) {
item.addList(itemFromAll);
isImposition = true;
break;
}
}
if (!isImposition) {
myOverlays.add(itemFromAll);
}
}
doPopulate();
}
private void myOverlaysClear() {
for (MyOverlayItem item : myOverlaysAll) {
item.getList().clear();
}
myOverlays.clear();
}
@Override
protected boolean onTap(int index) {
Toast.makeText(mapView.getContext(), myOverlays.get(index).getName(), Toast.LENGTH\_SHORT).show();
return true;
}
}
```
Ах да – в методе onTap мы выводим Toast с именем группы – для наглядной демонстрации работы алгоритма.
Хочу добавить, что данный алгоритм не является истиной в последней инстанции – его можно и нужно улучшать – например рисовать пин не на месте первого элемента группы, а рассчитывать его местоположение в зависимости от ее наполнения. Но это вы уже реализуете сами в собственных проектах.
Теперь давайте разберемся как все это собрать воедино.
Создадим ManyPinsProjectActivity которое унаследуем от MapActivity и реализуем следующие интерфейсы: LocationListener, IOnZoomListener. Впрочем не буду расписывать все подробно – исходники все расскажут за меня:
```
public class ManyPinsProjectActivity extends MapActivity implements LocationListener, IOnZoomListener {
private static final int DEFAULT_ZOOM = 15;
private MyMapView mapView = null;
private Drawable myCurrentMarker = null;
private Drawable placeMarker = null;
private List mapOverlays;
private PlaceOverlay placeOverlay;
private MyCurrentLocationOverlay myCurrentLocationOverlay;
double currentLatitude, currentLongitude;
private MapController mapController;
private LocationManager locationManager;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
locationManager = (LocationManager) this.getSystemService(Context.LOCATION\_SERVICE);
mapView = (MyMapView) findViewById(R.id.mapview);
myCurrentMarker = this.getResources().getDrawable(R.drawable.my\_pin\_red);
placeMarker = this.getResources().getDrawable(R.drawable.my\_pin);
myCurrentLocationOverlay = new MyCurrentLocationOverlay(myCurrentMarker, mapView);
placeOverlay = new PlaceOverlay(placeMarker, mapView);
mapOverlays = mapView.getOverlays();
mapController = mapView.getController();
mapView.setBuiltInZoomControls(true);
mapView.setOnZoomListener(this);
}
private void animateToPlaceOnMap(final GeoPoint geopoint) {
mapView.post(new Runnable() {
@Override
public void run() {
mapView.invalidate();
mapController.animateTo(geopoint);
mapController.setZoom(DEFAULT\_ZOOM);
}
});
}
private void setCurrentGeopoint(double myLatitude, double myLongitude) {
currentLatitude = myLatitude;
currentLongitude = myLongitude;
final GeoPoint myCurrentGeoPoint = new GeoPoint((int) (myLatitude \* 1E6), (int) (myLongitude \* 1E6));
MyOverlayItem myCurrentItem = new MyOverlayItem(myCurrentGeoPoint, "Current Location");
myCurrentLocationOverlay.addOverlay(myCurrentItem);
mapOverlays.add(myCurrentLocationOverlay);
animateToPlaceOnMap(myCurrentGeoPoint);
}
@Override
protected void onPause() {
super.onPause();
locationManager.removeUpdates(this);
}
@Override
protected void onResume() {
super.onResume();
locationManager.requestLocationUpdates(LocationManager.NETWORK\_PROVIDER, 5000, 100, this);
}
private ArrayList generatePlaces(){
Random random = new Random();
int x, y;
ArrayList places = new ArrayList();
PlaceInfo p;
for(int i = 0; i < 100; i++){
x = random.nextInt(2000);
y = random.nextInt(2000);
p = new PlaceInfo();
p.setLatitude(currentLatitude + x/100000f);
p.setLongitude(currentLongitude - y/100000f);
p.setName("Place № " + i);
places.add(p);
}
return places;
}
private void displayPlacesOnMap() {
ArrayList places = generatePlaces();
mapOverlays.remove(placeOverlay);
GeoPoint point = null;
MyOverlayItem overlayitem = null;
placeOverlay.clear();
for (PlaceInfo place : places) {
point = new GeoPoint((int) (place.getLatitude() \* 1E6), (int) (place.getLongitude() \* 1E6));
overlayitem = new MyOverlayItem(point, place.getName());
placeOverlay.addOverlay(overlayitem);
}
placeOverlay.calculateItems();
placeOverlay.doPopulate();
if (placeOverlay.size() > 0) {
mapOverlays.add(placeOverlay);
mapView.postInvalidate();
}
}
@Override
public void onLocationChanged(Location location) {
locationManager.removeUpdates(this);
double myLatitude = location.getLatitude();
double myLongitude = location.getLongitude();
setCurrentGeopoint(myLatitude, myLongitude);
displayPlacesOnMap();
}
@Override
public void onStatusChanged(String provider, int status, Bundle extras) {
}
@Override
public void onProviderEnabled(String provider) {
}
@Override
public void onProviderDisabled(String provider) {
}
@Override
protected boolean isRouteDisplayed() {
return false;
}
@Override
public void onZoomChanged() {
if (placeOverlay != null) {
placeOverlay.calculateItems();
}
}
}
```
Тут стоит добавить что MyCurrentLocationOverlay – это обычный ItemizedOverlay с одним элементом, а PlaceInfo – обычный класс обертка содержащий в себе:
```
private String name;
private double latitude;
private double longitude;
```
После всех этих манипуляций – вот как стала выглядеть наша карта с пинами:
Надеюсь статья окажется вам полезной.
Весь проект можно найти по [ссылке](https://github.com/igorab/ManyPinsProject). | https://habr.com/ru/post/139929/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.